Verwaltung von Docker-Containern in Go

Dokumentation!

Wenn Sie sich entscheiden, Ihr eigenes Werkzeug zur Abgleichung von Hooks aus dem Docker Hub oder aus dem Registry für die automatische Aktualisierung/Starten von Containern auf dem Server zu schreiben, könnte Ihnen Docker CLI nützlich sein, das Ihnen hilft, den Docker-Daemon in Ihrem System zu verwalten.

Für die Arbeit wird eine Go-Version von mindestens 1.9.4 benötigt.

Wenn Sie noch nicht auf Module umgestiegen sind, installieren Sie CLI mit dem folgenden Befehl:

go get github.com/docker/docker/client

Starten eines Containers

Das folgende Beispiel zeigt, wie man einen Container mit der Docker-API startet. In der Kommandozeile würden Sie den Befehl verwenden docker run, aber wir können diese Aufgabe problemlos in unserem Service erledigen.
Dieses Beispiel entspricht dem Starten des Befehls docker run alpine echo hello world

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

    // Docker Pull durchführen
    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("Konnte den Port nicht erhalten")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Container mit der angegebenen Konfiguration erstellen
    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)
    }

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

Abrufen der Liste der gestarteten Container

Dieses Beispiel entspricht dem Starten des Befehls 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)
    }

    // Abrufen der Liste der gestarteten Container (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Alle Container-IDs ausgeben
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Stoppen aller gestarteten Container

Nachdem Sie gelernt haben, Container zu erstellen und zu starten, ist es an der Zeit, zu lernen, wie man sie verwaltet. Das folgende Beispiel stoppt alle gestarteten Container.

Führen Sie diesen Code nicht in der Produktion aus 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)
    }

    // Abrufen der Liste der laufenden Container (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

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

Protokollausgabe eines einzelnen Containers

Sie können mit einzelnen Containern arbeiten. Im nächsten Beispiel werden die Protokolle des Containers mit der angegebenen ID ausgegeben. Vor dem Start müssen Sie die ID des Containers ändern, dessen Protokolle Sie erhalten möchten.

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

Abrufen der Liste von Images

Dieses Beispiel entspricht dem Starten des Befehls 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)
    }

    // Abrufen der Liste der Images
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Dieses Beispiel entspricht dem Starten des Befehls 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)
}

Herunterladen des Images mit Benutzerauthentifizierung

Dieses Beispiel entspricht dem Starten des Befehls docker pull, mit Authentifizierung.

Die Authentifizierungsdaten werden unverschlüsselt übertragen. Offizielle Docker-Registries verwenden HTTPS,
private Registries sollten ebenfalls so konfiguriert sein, dass die Übertragung von Daten über HTTPS erfolgt.

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

    // Erstellung der Konfiguration mit Authentifizierungsdaten
    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)
}

Quelle: habr.com