Docker konteinerite haldamine Go-s

Dokumentatsioon!

Kui otsustate kirjutada oma Docker Hub'i või registry's, mis automaatiliselt värskendab ja käivitab konteinerid serveris, võib teil olla kasulik Docker CLI, mis aitab hallata Docker daemonit teie süsteemis.

Tööks on vajalik Go versioon mitte madalam kui 1.9.4.

Kui te pole veel mooduleid kasutanud, installige CLI järgmise käsuga:

go get github.com/docker/docker/client

Konteineri käivitamine

Järgmine näide näitab, kuidas konteinerit käivitada Docker API kaudu. Käskude rea puhul kasutaksite käsku docker run, kuid meie teenuses saame selle ülesande kergesti täidetud.
See näide on ekvivalentne käsu käivitamisega docker run alpine echo hello world

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

    // Teeme 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}}

    // Loome konteineri määratud konfiguratsiooniga
    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)
    }

    // Käivitame konteineri
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

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

Käivitavate konteinerite loendi saamine

See näide on ekvivalentne käsu käivitamisega 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)
    }

    // Käivitavate konteinerite loendi saamine (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Väljund kõigi konteinerite ID-de kohta
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Käivitavate konteinerite peatamine

Pärast seda, kui olete õppinud konteinerite loomist ja käivitamist, on aeg õppida neid juhtima. Järgmine näide peatab kõik käivitatud konteinerid.

Ärge käivitage seda koodi tootmises. serveris!

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

    
    // Käivitatud konteinerite loendi saamine (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Konteineri peatamine: ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Edasi läks").
    }
}

Korra eraldi konteineri logide väljund

Saate töötada üksikute konteineritega. Järgnevas näites kuvatakse logid konteinerilt, mille identifikaator on määratud. Enne käivitamist peate muutma konteineri identifikaatori, mille logisid soovite saada.

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

Piltide loendi saamine

See näide on ekvivalentne käsu käivitamisega 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)
    }

    
    // Piltide loendi saamine
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

See näide on ekvivalentne käsu käivitamisega 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)
}

Pildi allalaadimine kasutaja autentimisega

See näide on ekvivalentne käsu käivitamisega docker pull, autentimisega.

Autentimisandmed saadetakse selgelt. Ametlikud docker registrid kasutavad HTTPS-i,
ka era registrid peaksid olema seadistatud andmete edastamiseks HTTPS-iga.

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

    // Looge andmete konfigureerimine
    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)
}

Allikas: habr.com