Manage Docker Containers in Go

Documentation!

When you decide to write your bike by catching hooks from the docker hub or from the registry to automatically update / launch containers on the server, you may need the Docker Cli, which will help manage the Docker daemon on your system.

To work, you need Go version not lower than 1.9.4

If you still haven't switched to modules, install Cli with the following command:

go get github.com/docker/docker/client 

Launch container

The following example shows how to start a container using the Docker API. In the command line, you would use the docker run , but we will easily cope with this task in our service.
This example is equivalent to running the docker run alpine echo hello world

 package main { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { panic(err) } //  docker pull reader, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{}) if err != nil { panic(err) } io.Copy(os.Stdout, reader) hostBinding := nat.PortBinding{ HostIP: "0.0.0.0", HostPort: "8000", } containerPort, err := nat.NewPort("tcp", "80") if err != nil { panic("Unable to get the port") } portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}} //      resp, err := cli.ContainerCreate(ctx, &container.Config{ Image: "alpine", Cmd: []string{"echo", "hello world"}, Tty: true, }, &container.HostConfig{ PortBindings: portBinding, }, nil, "") if err != nil { panic(err) } //   if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil { panic(err) } //    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true}) if err != nil { panic(err) } io.Copy(os.Stdout, out) } 

Getting a list of running containers

This example is equivalent to running the docker ps

 package main import ( "context" "fmt" "github.com/docker/docker/api/types" "github.com/docker/docker/client" ) func main() { cli, err := client.NewEnvClient() if err != nil { panic(err) } //    (docker ps) containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{}) if err != nil { panic(err) } //     for _, container := range containers { fmt.Println(container.ID) } } 

Stop all running containers

After you learned how to create and launch containers, it's time to learn how to manage them. The following example will stop all running containers.

Do not run this code on the production server!

 package main import ( "context" "fmt" "github.com/docker/docker/api/types" "github.com/docker/docker/client" ) func main() { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { panic(err) } //    (docker ps) containers, err := cli.ContainerList(ctx, types.ContainerListOptions{}) if err != nil { panic(err) } for _, c := range containers { fmt.Print("Stopping container ", c.ID[:10], "... ") if err := cli.ContainerStop(ctx, c.ID, nil); err != nil { panic(err) } fmt.Println("Success") } } 

Log output of a single container

You can work with individual containers. The following example displays the logs of the container with the specified identifier. Before launching you need to change the identifier of the container whose logs you want to receive.

 package main import ( "context" "io" "os" "github.com/docker/docker/api/types" "github.com/docker/docker/client" ) func main() { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { panic(err) } options := types.ContainerLogsOptions{ShowStdout: true} //  id   out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options) if err != nil { panic(err) } io.Copy(os.Stdout, out) } 

Getting a list of images

This example is equivalent to running the docker image ls

 package main import ( "context" "fmt" "github.com/docker/docker/api/types" "github.com/docker/docker/client" ) func main() { cli, err := client.NewEnvClient() if err != nil { panic(err) } //    images, err := cli.ImageList(context.Background(), types.ImageListOptions{}) if err != nil { panic(err) } for _, image := range images { fmt.Println(image.ID) } } 

Pull

This example is equivalent to running the docker pull

 package main import ( "context" "io" "os" "github.com/docker/docker/api/types" "github.com/docker/docker/client" ) func main() { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { panic(err) } // docker pull alpine out, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{}) if err != nil { panic(err) } defer out.Close() io.Copy(os.Stdout, out) } 

Downloading an image with user authentication

This example is equivalent to running the docker pull , with authentication.

Authentication data is sent in clear text. The official docker registry uses HTTPS,
Private registry should also be configured to transfer data using HTTPS.

 package main import ( "context" "encoding/base64" "encoding/json" "io" "os" "github.com/docker/docker/api/types" "github.com/docker/docker/client" ) func main() { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { panic(err) } //       authConfig := types.AuthConfig{ Username: "username", Password: "password", } encodedJSON, err := json.Marshal(authConfig) if err != nil { panic(err) } authStr := base64.URLEncoding.EncodeToString(encodedJSON) out, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{RegistryAuth: authStr}) if err != nil { panic(err) } defer out.Close() io.Copy(os.Stdout, out) }