Docker konteineru pārvaldība Go valodā

Dokumentācija!

Kad izlemsiet uzrakstīt savu velosipēdu, lai no Docker Hub vai reģistra automātiski atjauninātu/uzsāktu konteinerus serverī, var noderēt Docker CLI, kas palīdzēs pārvaldīt Docker demonus jūsu sistēmā.

Darba vajag Go versijas vismaz 1.9.4.

Ja vēl neesat pārgājuši uz moduļiem, instalējiet CLI ar sekojošo komandu:

go get github.com/docker/docker/client

Konteinera palaišana

Nākamais piemērs parāda, kā uzsākt konteineru, izmantojot Docker API. Komandrindā jūs izmantotu komandu $ docker-compose up, bet mēs viegli tiksim galā ar šo uzdevumu mūsu pakalpojumā.
Šis piemērs ir ekvivalents komandas izpildei docker run alpine echo hello world

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

    // Veicam 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("Nevar iegūt portu")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Izveidojam konteineru ar noteikto konfigurāciju
    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)
    }

    // Uzsākam konteineru
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    // Iegūstam konteineru žurnālus
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Aktīvo konteineru saraksta iegūšana

Šis piemērs ir ekvivalents komandas izpildei 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)
    }

    // Aktīvo konteineru saraksta iegūšana (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Izvada visu konteineru identifikatorus
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Visu aktīvo konteineru apstādināšana

Pēc tam, kad esat iemācījušies izveidot un uzsākt konteinerus, ir laiks iemācīties tos pārvaldīt. Nākamais piemērs apstādinās visus aktīvos konteinerus.

Nepalaidiet šo kodu darbībā produkcijā 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)
    }

    // Iegūstot palaisto konteineru sarakstu (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Apstājam konteineru ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Veiksmīgi")
    }
}

Noteikta konteineru žurnālu izvadīšana

Jūs varat strādāt ar noteiktiem konteineriem. Nākamajā piemērā tiek izvadīti konteineru žurnāli ar norādīto identifikatoru. Pirms palaišanas jums jāmaina konteineru identifikators, kuru žurnālus vēlaties saņemt.

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}
    // Šeit mainiet konteineru id
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Iegūstot attēlu sarakstu

Šis piemērs ir ekvivalents komandas izpildei 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)
    }

    // Iegūstot attēlu sarakstu
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Šis piemērs ir ekvivalents komandas izpildei 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)
}

Attēla lejupielāde ar lietotāja autentifikāciju

Šis piemērs ir ekvivalents komandas izpildei docker pull, ar autentifikāciju.

Autentifikācijas dati tiek nosūtīti atklātā veidā. Oficiālie docker reģistri izmanto HTTPS,
privātajiem reģistriem arī jābūt konfigurētiem, lai nodrošinātu datu pārsūtīšanu, izmantojot 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)
    }

    // Konfigurācijas izveide autentifikācijas datiem
    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)
}

Avots: habr.com