Docker-containers beheren in Go

Documentatie!

Wanneer je besluit je eigen fiets voor het vastleggen van hooks uit Docker Hub of uit de registry voor automatische updates/starten van containers op de server te schrijven, kan de Docker CLI handig zijn, die je helpt de Docker-daemon in je systeem te beheren.

Voor het werk heb je minimaal Go versie 1.9.4 nodig.

Als je nog niet bent overgestapt op modules, installeer dan de CLI met het volgende commando:

go get github.com/docker/docker/client

Container starten

Het volgende voorbeeld laat zien hoe je een container kunt starten met de Docker API. In de opdrachtregel zou je het commando gebruiken docker run, maar we kunnen deze taak eenvoudig uitvoeren in onze service.
Dit voorbeeld is gelijk aan het uitvoeren van het commando docker run alpine echo hello world

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

    // Docker pull uitvoeren
    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("Kan de poort niet krijgen")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Container creëren met de opgegeven configuratie
    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)
    }

    // Container starten
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    // Logs van de container ophalen
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Lijst van draaiende containers ophalen

Dit voorbeeld is gelijk aan het uitvoeren van het commando 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)
    }

    // Lijst van draaiende containers ophalen (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Alle container-ID's afdrukken
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Alle draaiende containers stoppen

Nu je hebt geleerd hoe je containers kunt maken en starten, is het tijd om te leren ze te beheren. Het volgende voorbeeld stopt alle draaiende containers.

Voer deze code niet uit in productie de 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)
    }

    // Het ophalen van de lijst met draaiende containers (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

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

Logboekweergave van een individuele container

U kunt werken met afzonderlijke containers. In het volgende voorbeeld worden de logs van de container met de opgegeven identifier weergegeven. Voor het uitvoeren moet u de identifier van de container die u wilt loggen veranderen.

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}
    // Verander hier de container ID
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Het ophalen van de lijst met images

Dit voorbeeld is gelijk aan het uitvoeren van het commando 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)
    }

    // Het ophalen van de lijst met images
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Dit voorbeeld is gelijk aan het uitvoeren van het commando 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)
}

Een image downloaden met gebruikersauthenticatie

Dit voorbeeld is gelijk aan het uitvoeren van het commando docker pull, met authenticatie.

Authenticatiegegevens worden in platte tekst verzonden. Officiële Docker registries gebruiken HTTPS,
privé registries moeten ook worden geconfigureerd om gegevens met HTTPS te verzenden.

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

    // Configuratie aanmaken met authenticatiegegevens
    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)
}

Bron: habr.com