Správa Docker kontejnerů v Go

Dokumentace!

Když se rozhodnete napsat svůj vlastní skript pro stahování kontejnerů z Docker Hub nebo registry pro automatické aktualizace/spouštění kontejnerů na serveru, může se vám hodit Docker CLI, které pomůže spravovat Docker démon ve vašem systému.

Pro práci budete potřebovat Go verze 1.9.4 nebo novější.

Pokud jste ještě nepřešli na moduly, nainstalujte CLI následujícím příkazem:

go get github.com/docker/docker/client

Spuštění kontejneru

Následující příklad ukazuje, jak spustit kontejner pomocí Docker API. V příkazovém řádku byste použili příkaz docker run, ale tuto úlohu snadno zvládneme v našem servisu.
Tento příklad je ekvivalentní spuštění příkazu docker run alpine echo hello world

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

    // Provádíme 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("Není možné získat port")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Vytváříme kontejner se zadanou konfigurací
    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)
    }

    // Spouštíme kontejner
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    // Získáváme logy kontejneru
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Získání seznamu spuštěných kontejnerů

Tento příklad je ekvivalentní spuštění příkazu 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)
    }

    // Získání seznamu spuštěných kontejnerů (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Výpis všech identifikátorů kontejnerů
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Zastavení všech spuštěných kontejnerů

Poté, co jste se naučili vytvářet a spouštět kontejnery, nastal čas naučit se je spravovat. Následující příklad zastaví všechny spuštěné kontejnery.

Nespouštějte tento kód v produkčním prostředí. serveru!

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

    // Získání seznamu spuštěných kontejnerů (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Zastavuji kontejner ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Úspěch")
    }
}

Výstup logů jednotlivého kontejneru

Můžete pracovat s jednotlivými kontejnery. V následujícím příkladu se zobrazují logy kontejneru s uvedeným identifikátorem. Před spuštěním je třeba změnit identifikátor kontejneru, jehož logy chcete získat.

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}
    // Změňte id kontejneru zde
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Získání seznamu obrazů

Tento příklad je ekvivalentní spuštění příkazu 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)
    }

    // Získání seznamu obrazů
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Tento příklad je ekvivalentní spuštění příkazu 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)
}

Stahování obrazu s autentizací uživatele

Tento příklad je ekvivalentní spuštění příkazu docker pull, s autentizací.

Ověřovací údaje se odesílají v otevřené podobě. Oficiální docker registry používají HTTPS,
privátní registry by měly být také nastaveny na přenos dat s použitím 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)
    }

    // Vytvoření konfigurace s autentizačními údaji
    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)
}

Zdroj: habr.com