Správa Docker kontajnerov v Go

Dokumentácia!

Keď sa rozhodnete napísať svoj vlastný bicykel na lov hookov z docker hubu alebo z registry pre automatické aktualizácie/spúšťanie kontajnerov na serveri, môžete potrebovať Docker CLI, ktorý vám pomôže spravovať demon Docker vo vašej sústave.

Na prácu budete potrebovať Go verziu aspoň 1.9.4.

Ak ste sa ešte neprepli na moduly, nainštalujte CLI nasledujúcim príkazom:

go get github.com/docker/docker/client

Spustenie kontajnera

Nasledujúci príklad ukazuje, ako spustiť kontajner pomocou Docker API. V príkazovom riadku by ste použili príkaz docker run, ale túto úlohu zvládneme bez námahy v našej službe.
Tento príklad je ekvivalentný spusteniu príkazu docker run alpine echo hello world

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

    // Robí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("Unable to get the port")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Vytvoríme kontajner s danou konfiguráciou
    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)
    }

    // Spúšťame kontajner
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

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

Získanie zoznamu spustených kontajnerov

Tento príklad je ekvivalentný spusteniu prí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ískanie zoznamu spustených kontajnerov (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Výpis všetkých identifikátorov kontajnerov
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Zastavenie všetkých spustených kontajnerov

Potom, čo ste sa naučili vytvárať a spúšťať kontajnery, je čas naučiť sa nimi spravovať. Nasledujúci príklad zastaví všetky spustené kontajnery.

Nespúšťajte tento kód v produkcii. serveri!

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ískanie zoznamu spustených kontajnerov (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Zastavujem kontajner ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Úspešne")
    }
}

Výstup logov jednotlivého kontajnera

Môžete pracovať s jednotlivými kontajnermi. V nasledujúcom príklade sa zobrazia logy kontajnera s uvedeným identifikátorom. Pred spustením musíte zmeniť identifikátor kontajnera, ktorého logy chcete získať.

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

Získanie zoznamu obrazov

Tento príklad je ekvivalentný spusteniu prí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ískanie zoznamu obrazov
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Tento príklad je ekvivalentný spusteniu prí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)
}

Sťahovanie obrazu s autentifikáciou používateľa

Tento príklad je ekvivalentný spusteniu príkazu docker pull, s autentifikáciou.

Údaje o autentifikácii sa odosielajú v otvorenom formáte. Oficiálne docker registry používajú HTTPS,
súkromné registry by mali byť tiež nastavené na prenos dát pomocou 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)
    }

    // Vytvorenie konfigurácie s údajmi na autentifikáciu
    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