1. Enable Go's embed by importing "embed", "io/fs", and using Go 1.16 . 2. Use //go:embed static/ and //go:embed templates/ to embed directories into variables of type embed.FS. 3. Serve static files by converting embed.FS to http.FileSystem via fs.Sub() and http.FS(), then use http.StripPrefix("/static/", ...) with echo.WrapHandler() to serve them under /static/. 4. For templates, create a custom Template struct implementing Render, parse embedded files using template.New("").ParseFS(templateFiles, "templates/.html"), assign to echo.Renderer, and use c.Render() to render pages like "index.html" with data. 5. A full working example combines embedded static assets and templates, serving them through Echo routes, and building a single binary with go build ensures no external file dependencies, resulting in a self-contained deployment.

Using Go's //go:embed directive with the Echo web framework is a clean way to serve static files (like HTML, CSS, JS, images) or templates directly from your binary—no need to rely on external file paths in production.

Here’s how to do it step by step.

? 1. Enable embed and import the embed package

First, make sure you're using Go 1.16 and import the embed package:

import (
    "embed"
    "io/fs"
    "net/http"

    "github.com/labstack/echo/v4"
)

? 2. Use //go:embed to include static files or templates

Suppose you have a directory structure like:

your-project/
├── main.go
├── static/
│   ├── style.css
│   └── script.js
└── templates/
    └── index.html

In main.go, embed these folders:

//go:embed static/*
var staticFiles embed.FS

//go:embed templates/*
var templateFiles embed.FS

? Note: embed.FS only supports string, []byte, or embed.FS. Use embed.FS for directories.

? 3. Serve static files with Echo

Convert the embedded embed.FS into an http.FileSystem using fs.Sub() and http.FS():

func main() {
    e := echo.New()

    // Serve static files
    subFS, err := fs.Sub(staticFiles, "static")
    if err != nil {
        e.Logger.Fatal("Error embedding static files:", err)
    }
    staticFilesHandler := http.FS(subFS)
    e.GET("/static/*", echo.WrapHandler(http.StripPrefix("/static/", http.FileServer(staticFilesHandler))))
}

This serves /static/style.css → maps to static/style.css in the embedded FS.

? Tip: http.StripPrefix removes /static/ prefix so the file server looks for style.css instead of /static/style.css inside the FS.

? 4. Serve HTML templates (e.g., with html/template)

If you're rendering HTML templates:

//go:embed templates/*.html
var templateFiles embed.FS

// Custom template renderer
type Template struct {
    templates *template.Template
}

func (t *Template) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
    return t.templates.ExecuteTemplate(w, name, data)
}

Load templates from embedded FS:

func main() {
    e := echo.New()

    // Parse templates from embedded FS
    t := &Template{
        templates: template.Must(template.New("").ParseFS(templateFiles, "templates/*.html")),
    }
    e.Renderer = t

    // Example route
    e.GET("/", func(c echo.Context) error {
        return c.Render(http.StatusOK, "index.html", map[string]interface{}{
            "Message": "Hello from embedded templates!",
        })
    })

    // ... static file setup (from above)

    e.Logger.Fatal(e.Start(":8080"))
}

? 5. Full working example (simplified)

package main

import (
    "embed"
    "html/template"
    "io"
    "net/http"

    "github.com/labstack/echo/v4"
)

//go:embed static/*
var staticFiles embed.FS

//go:embed templates/*
var templateFiles embed.FS

type Template struct {
    templates *template.Template
}

func (t *Template) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
    return t.templates.ExecuteTemplate(w, name, data)
}

func main() {
    e := echo.New()

    // Setup templates
    t := &Template{
        templates: template.Must(template.New("").ParseFS(templateFiles, "templates/*.html")),
    }
    e.Renderer = t

    // Serve static files
    subFS, _ := fs.Sub(staticFiles, "static")
    e.GET("/static/*", echo.WrapHandler(http.StripPrefix("/static/", http.FileServer(http.FS(subFS)))))

    // Render a page
    e.GET("/", func(c echo.Context) error {
        return c.Render(http.StatusOK, "index.html", nil)
    })

    e.Logger.Fatal(e.Start(":8080"))
}

?? Common pitfalls

• Forgetting fs.Sub() when embedding a subdirectory.
• Not stripping the URL prefix with http.StripPrefix.
• Using incorrect glob patterns in ParseFS or embed.
• Trying to embed files outside the module or in ignored dirs (like .git, node_modules).

? Bonus: Embed everything into a single binary

Build with:

go build -o server .

Now you can deploy just the binary—it includes all static assets and templates.

That’s it. You now have a fully embedded Echo app with static files and templates—no external dependencies on the file system. Basically just Go, embed, and Echo doing their jobs.

The above is the detailed content of How to use go embed with the Echo framework?. For more information, please follow other related articles on the PHP Chinese website!