- Published on
A Complete Guide to Embedding Static Files in Go using go:embed?
Table of content
A Complete Guide to Embedding Static Files in Go using go:embed
Introduction
Embedding static files in Go binaries is a powerful feature that can simplify the deployment and distribution of your applications. It can also improve performance by making static files directly accessible from the binary, without having to read them from disk.
The go:embed
directive was introduced in Go 1.16 and makes it easy to embed static files in Go binaries. This directive can be used to embed files of any type, including HTML, CSS, JavaScript, images, and fonts.
go:embed
Directive
Using the To use the go:embed
directive, simply place it above the declaration of a variable of type string
, []byte
, or embed.FS
. The directive should be followed by a list of file paths or glob patterns that should be embedded in the binary.
For example, the following code embeds all of the files in the assets
directory:
package main
import (
"embed"
)
//go:embed assets/*
var assets embed.FS
func main() {
// Use the assets variable as needed...
}
Once you have embedded your static files in the binary, you can access them using the variable that you declared. For example, to read the contents of the index.html
file, you would use the following code:
indexData, err := assets.ReadFile("index.html")
if err != nil {
// Handle error...
}
You can also use the embed.FS
type to serve static files over HTTP. For example, the following code creates a simple HTTP server that serves the contents of the assets
directory:
package main
import (
"embed"
"fmt"
"log"
"net/http"
)
//go:embed assets/*
var assets embed.FS
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
if path == "/" {
path = "/index.html"
}
data, err := assets.ReadFile(path)
if err != nil {
w.WriteHeader(http.StatusNotFound)
fmt.Fprintf(w, "File not found: %s", path)
return
}
w.WriteHeader(http.StatusOK)
w.Write(data)
})
log.Fatal(http.ListenAndServe(":8080", nil))
}
Benefits of Embedding Static Files
There are several benefits to embedding static files in Go binaries:
- Simplified deployment and distribution: When static files are embedded in the binary, you don't need to worry about deploying and distributing them separately. This can simplify your deployment and distribution process, especially if you have a large number of static files.
- Improved performance: By embedding static files in the binary, you can make them directly accessible from the binary, without having to read them from disk. This can improve the performance of your application, especially if you frequently access the static files.
- Reduced binary size: In some cases, embedding static files in the binary can reduce the overall size of the binary. This is because the Go compiler can optimize the way that static files are embedded in the binary.
Best Practices
Here are some best practices for embedding static files in Go binaries:
- Only embed static files that are essential: Don't embed static files that you don't need. This can increase the size of your binary and make it more difficult to deploy and distribute.
- Use the
embed.FS
type: Theembed.FS
type is the best way to embed static files in Go binaries. It provides a number of features that make it easy to manage and access embedded files. - Use a build tool: There are a number of build tools that can help you to embed static files in Go binaries. These tools can simplify the process of embedding static files and make it easier to manage embedded files in large projects.
Conclusion
Embedding static files in Go binaries is a powerful feature that can simplify the deployment and distribution of your applications, improve performance, and reduce binary size. By following the best practices in this tutorial, you can use the go:embed
directive to embed static files in your Go binaries and reap the benefits.
Reference
- Go:embed package