Gestionarea containerelor Docker în Go

Documentație!

Când decideți să scrieți despre bicicleta dumneavoastră pentru a captura hook-uri din docker hub sau din registry pentru actualizarea/începerea automată a containerelor pe server, Docker CLI vă poate fi de ajutor pentru a gestiona demonul Docker din sistemul dumneavoastră.

Pentru a funcționa, va fi necesar Go versiunea 1.9.4 sau mai recentă.

Dacă nu ați trecut încă la module, instalați CLI cu următoarea comandă:

go get github.com/docker/docker/client

Pornirea containerului

Exemplul următor ilustrează cum să rulați un container folosind Docker API. În linia de comandă ați folosi comanda docker run, dar ne vom descurca cu ușurință cu această sarcină în serviciul nostru.
Acest exemplu este echivalent cu rularea comenzii docker run alpine echo hello world

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

    // Facem 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("Imposibil de obținut portul")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Creăm un container cu configurarea specificată
    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)
    }

    // Pornim containerul
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    // Obținem jurnalele containerului
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obținerea listei containerelor în funcțiune

Acest exemplu este echivalent cu rularea comenzii 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)
    }

    // Obținerea listei containerelor în funcțiune (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Afișarea tuturor identificatorilor containerelor
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Oprirea tuturor containerelor în funcțiune

După ce ați învățat să creați și să rulați containere, a venit timpul să învățați să le gestionați. Exemplul următor va opri toate containerele în funcțiune.

Nu rulați acest cod în producție server!

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

    // Obținerea listei de containere active (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

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

Ieșirea jurnalelor unui container specific

Puteți lucra cu containere individuale. În exemplul următor, sunt afișate jurnalele containerului cu ID-ul specificat. Înainte de a rula, trebuie să modificați ID-ul containerului ale cărui jurnale doriți să le obțineți.

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}
    // Schimbați ID-ul containerului aici
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obținerea listei de imagini

Acest exemplu este echivalent cu rularea comenzii 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)
    }

    // Obținerea listei de imagini
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Pull

Acest exemplu este echivalent cu rularea comenzii 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)
}

Descărcarea imaginii cu autentificarea utilizatorului

Acest exemplu este echivalent cu rularea comenzii docker pull, cu autentificarea.

Datele de autentificare sunt trimise în mod deschis. Registry-urile oficiale Docker folosesc HTTPS,
registry-urile private trebuie, de asemenea, să fie configurate pentru a transmite date prin 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)
    }

    // Crearea configurației cu datele de autentificare
    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)
}

Sursa: habr.com