Gestión de contenedores Docker en Go

Documentación!

Cuando decidas escribir tu propio contenedor para manejar hooks desde Docker Hub o desde el registro para la actualización / inicio automático de contenedores en el servidor, puede que te sirva Docker Cli, que ayuda a gestionar el demonio de Docker en tu sistema.

Para trabajar necesitarás Go versión 1.9.4 o superior.

Si todavía no has migrado a módulos, instala Cli con el siguiente comando:

go get github.com/docker/docker/client

Iniciar el contenedor

El siguiente ejemplo muestra cómo iniciar un contenedor utilizando la API de Docker. En la línea de comandos, usarías el comando docker run, pero nosotros podemos manejar esta tarea fácilmente en nuestro servicio.
Este ejemplo es equivalente a ejecutar el comando docker run alpine echo hello world

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

    \/\/ Realizamos 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("No se puede obtener el puerto")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    \/\/ Creamos un contenedor con la configuración dada
    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)
    }

    \/\/ Iniciamos el contenedor
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    \/\/ Obtenemos los registros del contenedor
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obtener lista de contenedores en ejecución

Este ejemplo es equivalente a ejecutar el 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)
    }

    \/\/ Obtener lista de contenedores en ejecución (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    \/\/ Mostrar todos los identificadores de los contenedores
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Detener todos los contenedores en ejecución

Después de que hayas aprendido a crear e iniciar contenedores, es hora de aprender a gestionarlos. El siguiente ejemplo detendrá todos los contenedores en ejecución.

No ejecutes este código en producción 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)
    }

    // Obtener la lista de contenedores en ejecución (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Deteniendo contenedor ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Éxito")
    }
}

Salida de logs de un contenedor específico

Puede trabajar con contenedores individuales. En el siguiente ejemplo se muestran los logs del contenedor con el identificador especificado. Antes de ejecutar, necesita cambiar el identificador del contenedor cuyos logs desea obtener.

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}
    // Cambie el id del contenedor aquí
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obtener lista de imágenes

Este ejemplo es equivalente a ejecutar el 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)
    }

    // Obtener la lista de imágenes
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Este ejemplo es equivalente a ejecutar el 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)
}

Descarga de imagen con autenticación de usuario

Este ejemplo es equivalente a ejecutar el comando docker pull, con autenticación.

Los datos de autenticación se envían en texto claro. Los registros oficiales de Docker utilizan HTTPS,
los registros privados también deben configurarse para transferir datos 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)
    }

    // Creando la configuración con datos de autenticación
    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)
}

Fuente: habr.com