{"componentChunkName":"component---src-pages-markdown-remark-fields-slug-js","path":"/engineering/build-push-docker-images-golang/","result":{"data":{"markdownRemark":{"id":"4836456a-d38a-563c-babe-3f0a5b173c32","excerpt":"Let's walk through how to build and push Docker images programmatically using Go. To do this, we need to talk to the Docker daemon via the Docker Engine API…","html":"

Let's walk through how to build and push Docker images programmatically using Go. To do this, we need to talk to the Docker daemon via the Docker Engine API. This is similar to how the Docker CLI works, but instead of entering commands through a CLI, we'll be writing code with Docker's Go SDK.

\n

At the time of writing, the official Docker Go SDK docs provide great examples of running basic Docker commands with Go. However, it's missing examples on building and pushing Docker images, so we'll go over those in this blog.

\n

Before we begin, this blog assumes you have a working knowledge of Docker and Go. We'll go over the following:

\n\n

Environment Setup

\n

First, we need to set up the environment. Create a project and include the app we want to containerize:

\n
mkdir docker-go-tutorial && cd docker-go-tutorial && mkdir node-hello
\n

We'll add a simple Node.js app:

\n
// node-hello/app.js\nconsole.log("Hello From LoginRadius");
\n

with the Dockerfile:

\n
// node-hello/Dockerfile\nFROM node:12\nWORKDIR /src\nCOPY . .\nCMD [ "node", "app.js" ]
\n

Next, install the Go SDK. These are the Docker related imports we will be using:

\n
"github.com/docker/docker/api/types"\n"github.com/docker/docker/client"\n"github.com/docker/docker/pkg/archive"
\n

Build Docker Image

\n

One way to build a Docker image from our local files is to compress those files into a tar archive first.

\n

We use the archive package provided by Docker:

\n
"github.com/docker/docker/pkg/archive"
\n
tar, err := archive.TarWithOptions("node-hello/", &archive.TarOptions{})\nif err != nil {\n    return err\n}
\n

Now, we can call the ImageBuild function using the Go SDK:

\n\n

To print the response, we use a scanner to go through line by line:

\n
scanner := bufio.NewScanner(res.Body)\nfor scanner.Scan() {\n    lastLine = scanner.Text()\n    fmt.Println(scanner.Text())\n}
\n

This prints the following:

\n
{"stream":"Step 1/4 : FROM node:12"}\n{"stream":"\\n"}\n{"stream":" ---\\u003e e4f1e16b3633\\n"}\n{"stream":"Step 2/4 : WORKDIR /src"}\n{"stream":"\\n"}\n{"stream":" ---\\u003e Using cache\\n"}\n{"stream":" ---\\u003e b298b8519669\\n"}\n{"stream":"Step 3/4 : COPY . ."}\n{"stream":"\\n"}\n{"stream":" ---\\u003e Using cache\\n"}\n{"stream":" ---\\u003e 1ff6a87e79d9\\n"}\n{"stream":"Step 4/4 : CMD [ \\"node\\", \\"app.js\\" ]"}\n{"stream":"\\n"}\n{"stream":" ---\\u003e Using cache\\n"}\n{"stream":" ---\\u003e 6ca44f72b68d\\n"}\n{"aux":{"ID":"sha256:238a923459uf28h80103eb089804a2ff2c1f68f8c"}}\n{"stream":"Successfully built 6ca44f72b68d\\n"}\n{"stream":"Successfully tagged lrblake/node-hello:latest\\n"}
\n

The last step would be checking the response for errors, so if something went wrong during the build, we could handle it.

\n
errLine := &ErrorLine{}\njson.Unmarshal([]byte(lastLine), errLine)\nif errLine.Error != "" {\n    return errors.New(errLine.Error)\n}
\n

For example, the following error can occur during build:

\n
{"errorDetail":{"message":"COPY failed: stat /var/lib/docker/tmp/docker-builder887191115/z: no such file or directory"},"error":"COPY failed: stat /var/lib/docker/tmp/docker-builder887191115/z: no such file or directory"}
\n

All together, the file looks like this:

\n
package main\n\nimport (\n\t"bufio"\n\t"context"\n\t"encoding/json"\n\t"errors"\n\t"fmt"\n\t"io"\n\t"time"\n\n\t"github.com/docker/docker/api/types"\n\t"github.com/docker/docker/client"\n\t"github.com/docker/docker/pkg/archive"\n)\n\nvar dockerRegistryUserID = ""\n\ntype ErrorLine struct {\n\tError       string      `json:"error"`\n\tErrorDetail ErrorDetail `json:"errorDetail"`\n}\n\ntype ErrorDetail struct {\n\tMessage string `json:"message"`\n}\n\nfunc main() {\n\tcli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())\n\tif err != nil {\n\t\tfmt.Println(err.Error())\n\t\treturn\n\t}\n\n\terr = imageBuild(cli)\n\tif err != nil {\n\t\tfmt.Println(err.Error())\n\t\treturn\n\t}\n}\n\nfunc imageBuild(dockerClient *client.Client) error {\n\tctx, cancel := context.WithTimeout(context.Background(), time.Second*120)\n\tdefer cancel()\n\n\ttar, err := archive.TarWithOptions("node-hello/", &archive.TarOptions{})\n\tif err != nil {\n\t\treturn err\n\t}\n\n\topts := types.ImageBuildOptions{\n\t\tDockerfile: "Dockerfile",\n\t\tTags:       []string{dockerRegistryUserID + "/node-hello"},\n\t\tRemove:     true,\n\t}\n\tres, err := dockerClient.ImageBuild(ctx, tar, opts)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tdefer res.Body.Close()\n\n\terr = print(res.Body)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}\n\nfunc print(rd io.Reader) error {\n\tvar lastLine string\n\n\tscanner := bufio.NewScanner(rd)\n\tfor scanner.Scan() {\n\t\tlastLine = scanner.Text()\n\t\tfmt.Println(scanner.Text())\n\t}\n\n\terrLine := &ErrorLine{}\n\tjson.Unmarshal([]byte(lastLine), errLine)\n\tif errLine.Error != "" {\n\t\treturn errors.New(errLine.Error)\n\t}\n\n\tif err := scanner.Err(); err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}
\n

The equivalent Docker CLI command would be:

\n
docker build -t <dockerRegistryUserID>/node-hello .
\n

Push Docker Image

\n

We'll push the Docker image we created to Docker Hub. But, we need to authenticate with Docker Hub by providing credentials encoded in base64.

\n\n

Now, call the ImagePush function in the Go SDK, along with your encoded credentials:

\n
opts := types.ImagePushOptions{RegistryAuth: authConfigEncoded}\nrd, err := dockerClient.ImagePush(ctx, dockerRegistryUserID + "/node-hello", opts)
\n

Together, this looks like:

\n
func imagePush(dockerClient *client.Client) error {\n\tctx, cancel := context.WithTimeout(context.Background(), time.Second*120)\n\tdefer cancel()\n\n\tauthConfigBytes, _ := json.Marshal(authConfig)\n\tauthConfigEncoded := base64.URLEncoding.EncodeToString(authConfigBytes)\n\n\ttag := dockerRegistryUserID + "/node-hello"\n\topts := types.ImagePushOptions{RegistryAuth: authConfigEncoded}\n\trd, err := dockerClient.ImagePush(ctx, tag, opts)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tdefer rd.Close()\n\n\terr = print(rd)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}
\n

The equivalent Docker CLI command (after docker login) would be:

\n
docker push <dockerRegistryUserID>/node-hello
\n","headings":[{"value":"Environment Setup","depth":2},{"value":"Build Docker Image","depth":2},{"value":"Push Docker Image","depth":2}],"fields":{"slug":"/engineering/build-push-docker-images-golang/"},"frontmatter":{"metatitle":null,"metadescription":null,"description":"Guide on how to build and push Docker images programmatically using Go.","title":"Build and Push Docker Images with Go","canonical":null,"date":"December 08, 2020","updated_date":null,"tags":["Docker","Go"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.680672268907563,"src":"/static/f7f513d2d6c5460c9f71278fcb98f766/03979/cover.png","srcSet":"/static/f7f513d2d6c5460c9f71278fcb98f766/f5f11/cover.png 200w,\n/static/f7f513d2d6c5460c9f71278fcb98f766/6d133/cover.png 400w,\n/static/f7f513d2d6c5460c9f71278fcb98f766/03979/cover.png 800w,\n/static/f7f513d2d6c5460c9f71278fcb98f766/30425/cover.png 1000w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Andy Yeung","github":null,"bio":"Software Developer at LoginRadius with an interest in big data and basketball..","avatar":null}}}},"pageContext":{"id":"4836456a-d38a-563c-babe-3f0a5b173c32","fields__slug":"/engineering/build-push-docker-images-golang/","__params":{"fields__slug":"engineering"}}},"staticQueryHashes":["1171199041","1384082988","1711371485","1753898100","2100481360","229320306","23180105","528864852"]}