Managing Docker Containers in Go

Documentation!

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

To work, you will need Go version no 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

Container launch

The following example shows how to start a container using the Docker API. In the command line you would use the command docker run, but we can easily cope with this task in our service.
This example is equivalent to running the commanddocker 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 command 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

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

Do not run this code on a 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")
    }
}

Logging a single container

You can work with individual containers. The following example displays the logs of the container with the specified identifier. Before starting 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 the list of images

This example is equivalent to running the command 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 command 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)
}

Download Image with User Authentication

This example is equivalent to running a command docker pullwith authentication.

Authentication data is sent in clear text. Official docker registry uses HTTPS,
private registry should also be configured to transmit 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)
}