Gerenciamento de contêineres Docker em Go

Documentação!

Quando você decidir escrever seu próprio contêiner para capturar hooks do docker hub ou de um registry para atualização/início automático de contêineres no servidor, o Docker CLI pode ser útil para gerenciar o daemon Docker em seu sistema.

Você precisará do Go na versão 1.9.4 ou superior.

Se você ainda não migrou para módulos, instale o CLI com o seguinte comando:

go get github.com/docker/docker/client

Iniciar contêiner

O exemplo a seguir demonstra como iniciar um contêiner usando a API do Docker. No terminal, você usaria o comando docker run, mas podemos facilmente lidar com essa tarefa em nosso serviço.
Este exemplo é equivalente a executar o comando docker run alpine echo hello world

package main {
    ctx := context.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    \/\/ Fazendo o 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("Não foi possível obter a porta")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    \/\/ Criando contêiner com a configuração especificada
    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)
    }

    \/\/ Iniciando contêiner
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    \/\/ Obtendo logs do contêiner
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obtendo a lista de contêineres em execução

Este exemplo é equivalente a executar o comando 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)
    }

    \/\/ Obtendo a lista de contêineres em execução (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    \/\/ Exibindo todos os identificadores de contêineres
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Parar todos os contêineres em execução

Depois de aprender a criar e iniciar contêineres, é hora de aprender a gerenciá-los. O exemplo a seguir vai parar todos os contêineres em execução.

Não execute este código em produção servidor!

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)
    }

    // Obtendo a lista de contêineres em execução (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Parando o contêiner ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Sucesso")
    }
}

Saída de logs de um contêiner específico

Você pode trabalhar com contêineres específicos. No exemplo a seguir, são exibidos os logs de um contêiner com um identificador específico. Antes de executar, você precisa alterar o identificador do contêiner cujos logs deseja obter.

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}
    // Altere o id do contêiner aqui
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obtenção da lista de imagens

Este exemplo é equivalente a executar o comando 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)
    }

    // Obtendo a lista de imagens
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

    for _, image := range images {
        fmt.Println(image.ID)
    }
}

Pull

Este exemplo é equivalente a executar o comando 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)
}

Baixando a imagem com autenticação do usuário

Este exemplo é equivalente a executar o comando docker pull, com autenticação.

Os dados de autenticação são enviados em texto aberto. Os registros oficiais do Docker utilizam HTTPS,
os registros privados também devem ser configurados para transmitir dados utilizando 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)
    }

    // Criação de configuração com dados de autenticação
    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)
}

Fonte: habr.com