Administrering av Docker-containere i Go

Dokumentasjon!

Når du bestemmer deg for å skrive din egen sykkel for å hente hooks fra docker hub eller registry for automatisk oppdatering/start av containere på serveren, kan Docker Cli være nyttig, som vil hjelpe deg med å administrere Docker-demonen i systemet ditt.

For å jobbe med dette, trenger du Go versjon 1.9.4 eller høyere

Hvis du fortsatt ikke har oppgradert til moduler, installer Cli med følgende kommando:

go get github.com/docker/docker/client

Starte en container

Det følgende eksempelet viser hvordan du kan starte en container ved hjelp av Docker API. I kommandolinjen ville du ha brukt kommandoen docker run, men vi klarer enkelt dette i tjenesten vår.
Dette eksempelet er ekvivalent med å kjøre kommandoen docker run alpine echo hello world

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

    // Gjør 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("Kan ikke få port")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Opprett en container med spesifisert konfigurasjon
    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)
    }

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

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

Hente listen over kjørende containere

Dette eksempelet er ekvivalent med å kjøre kommandoen 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)
    }

    // Hente listen over kjørende containere (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Utskrift av alle container-IDer
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Stoppe alle kjørende containere

Etter at du har lært å opprette og starte containere, er det på tide å lære å administrere dem. Det følgende eksempelet vil stoppe alle kjørende containere.

Ikke kjør denne koden i produksjon serveren!

pakke hoved

import (
    "kontekst"
    "fmt"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func hoved() {
    ctx := kontekst.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Hente listen over kjørende containere (docker ps)
    containere, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containere {
        fmt.Print("Stopper container ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Suksess")
    }
}

Utdata fra loggene til en enkelt container

Du kan jobbe med individuelle containere. I følgende eksempel vises loggene fra containeren med den angitte identifikatoren. Før du kjører, må du endre containerens identifikator som du vil hente logger for.

pakke hoved

import (
    "kontekst"
    "io"
    "os"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func hoved() {
    ctx := kontekst.Background()
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    alternativer := types.ContainerLogsOptions{ShowStdout: true}
    // Endre id til container her
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", alternativer)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Hente listen over bilder

Dette eksempelet er ekvivalent med å kjøre kommandoen docker image ls

pakke hoved

import (
    "kontekst"
    "fmt"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func hoved() {
    cli, err := client.NewEnvClient()
    if err != nil {
        panic(err)
    }

    // Hente listen over bilder
    bilder, err := cli.ImageList(kontekst.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

    for _, bilde := range bilder {
        fmt.Println(bilde.ID)
    }
}

Dra

Dette eksempelet er ekvivalent med å kjøre kommandoen docker pull

pakke hoved

import (
    "kontekst"
    "io"
    "os"

    "github.com/docker/docker/api/types"
    "github.com/docker/docker/client"
)

func hoved() {
    ctx := kontekst.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)
}

Nedlasting av bilde med brukerauthentisering

Dette eksempelet er ekvivalent med å kjøre kommandoen docker pull, med autentisering.

Autentiseringsdata blir sendt i klar tekst. Offisielle Docker-registere bruker HTTPS,
private registre bør også konfigureres for å overføre data ved hjelp av HTTPS.

pakke hoved

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

    	// Opprette en konfigurasjon med autentiseringsdetaljer
    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)
}

Kilde: habr.com