Embed Modules

Embed Module 

 This module is a super duper cool module in the sense that you are able to pack static files into your binary, rather than having your program relying on the actual file being present in your filesystem when it is ran. 

 Normally when you do deployment with a Go server, you would have the server binary, the static frontend files that is open and serve by the Go server. You can pack everything into a Docker image so the server that's running your web application can just spin up the container which will have everything. However, in Golang 1.16 you can directly embed your static frontend files into the binary so you do not need a docker image to pack your static files in. You can just embed it directly into your binary. 

 Embed directives 

 To get started with using the Embed module you would actually use the embed directives which instructs compiler at compile time what to do. 

 For example: 

 //go:embed $PATH

var content $WANTED_DATA_TYPE 

 

 $PATH  is the file or directory that you want to include. If you use dataa type embed.FS then you can put multiple files or multiple directories 

 $WANTED_DATA_TYPE needs to be replace with one of the followings

 

 string = Accepts a single file and when the binary is built, it wil lread the content of that entire file into the variable as a string. If you use this you can only embed in ONE file. No multiple files or a directory 

 []byte = Same as String, but it will be read in as  []byte 

 embed.FS = Using this data type you are allowed to embed multiple directories and even files. This struct implements the io/FS interface, which means that  net/http package can use it as part of the handler 

 

 

 

 embed.FS after you embed the files into the binary, you can open files that are included as part of the binary. Even if the files / directory doesn't exist after the program is ran. Magic. Power of embedded files. 

 Note about  embed.FS 

 Do keep in mind that the directory that you embed, the variable that it is assigned under refer to the root directory that contains the directory or file. For example: 

 //go:embed static/

var embeddedFS embed.FS 

 The variable  embeddedFS refers to a "root directory" that contains the "static" directory (I put it in quotes because it is in the binary not in the actual OS filesystem 

 Thus if you want to say open a file you need to do: 

 embeddedFS.Open("static/index.html") 

 And not this: 

 embeddedFS.Open("index.html") 

 In terms of  net/http package, that means the files will be serve the subdirectory that you embed as. For example, if you embed  static/index.html , and you add a handler  "/" that references the particular  static/index.html file, you will have to visit  localhost:80/static/index.html or  localhost:80/static in order to see the file rather than just  localhost:80 . 

 To solve that problem you would need use fs.Sub which: 

 Sub returns an FS corresponding to the subtree rooted at fsys's dir. 

 Basically returns you a filesystem that is rooted at the provided filesystem, making an "alias" per se.