Docker konteinerite haldamine Go-s

Dokumentatsioon!

Kui otsustate kirjutada oma nöörimisveebi Docker Hubist või registrist automaatseks konteinerite uuendamiseks/avalehtimiseks serveris, võib teile kasuks tulla Docker CLI, mis aitab hallata Docker daemonit teie süsteemis.

Tööks on vajalik Go versioon, mis ei ole madalam kui 1.9.4.

Kui te pole veel moodulitele üle läinud, installige CLI järgmise käsu abil:

go get github.com/docker/docker/client

Konteineri käivitamine

Järgmine näide näitab, kuidas käivitada konteinerit Docker API abil. Kommandojoones kasutaksite käsku docker run, kuid me saame selle ülesande kergesti lahendada meie teenuses.
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("Porti saamine ebaõnnestus")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Loome konteineri etteantud 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 nimekirja 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äivitatud konteinerite nimekirja saamine (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Kõikide konteinerite ID-de väljatrükkimine
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Kõigi käivitatud konteinerite peatamine

Nüüd, kui olete õppinud konteinerite loomist ja käivitamist, on aeg õppida nende haldamist. Järgmine näide peatab kõik käivitatud konteinerid.

Ärge käitage seda koodi tootmises serveril!

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 nimekirja saamine (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

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

Konkreetse konteineri logide väljatrükkimine

Saate töötada eraldi konteineritega. Järgmises näites kuvatakse määratud ID-ga konteineri logid. Enne käivitamist peate muutma ID-d konteineril, kelle 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 nimekirja 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 nimekirja saamine
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Tõmba

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 sõltumatul kujul. Ametlikud docker registryd kasutavad HTTPS-i,
era registryd peavad samuti olema seadistatud andmete edastamiseks HTTPS-i kaudu.

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

    // Autentimisandmete konfi loomine
    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