Hantera Docker-behållare i Go

Dokumentation!

När du bestämmer dig för att skriva din egen cykel för att hämta hooks från Docker Hub eller från registry för automatisk uppdatering/start av containrar på servern kan Docker CLI vara till hjälp, vilket gör att du kan hantera Docker-demonen i ditt system.

För att arbeta behövs Go-version inte lägre än 1.9.4

Om du fortfarande inte har övergått till moduler, installera CLI med följande kommando:

go get github.com/docker/docker/client

Starta containern

Följande exempel visar hur man startar en container med hjälp av Docker API. I kommandoraden skulle du använda kommandot docker run, men vi klarar lätt av denna uppgift i vår tjänst.
Detta exempel är ekvivalent med att köra kommandot docker run alpine echo hello world

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

    // Gö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("Kunde inte få porten")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Skapa en container med angiven konfiguration
    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)
    }

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

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

Hämtning av listan över aktiva containrar

Detta exempel är ekvivalent med att köra kommandot 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)
    }

    // Hämta listan över aktiva containrar (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Skriv ut alla container-ID:n
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Stoppa alla aktiva containrar

Efter att du har lärt dig att skapa och starta containrar är det dags att lära sig att hantera dem. Nästa exempel stoppar alla aktiva containrar.

Kör inte denna kod i produktion servern!

paket huvud

import (
    "context"
    "fmt"

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

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

    // Hämtning av lista över körande containrar (docker ps)
    containrar, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    för _, c := range containrar {
        fmt.Print("Stoppar container ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Lyckades")
    }
}

Utskrift av loggar för enskild container

Du kan arbeta med enskilda containrar. I följande exempel skrivs loggarna för containern med det angivna ID:t ut. Innan du kör det måste du ändra containerns ID vars loggar du vill hämta.

paket huvud

import (
    "context"
    "io"
    "os"

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

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

    options := types.ContainerLogsOptions{ShowStdout: true}
    // Ändra ID för containern här
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Hämtning av lista över bilder

Detta exempel är ekvivalent med att köra kommandot docker image ls

paket huvud

import (
    "context"
    "fmt"

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

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

    // Hämtning av lista över bilder
    bilder, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

    för _, bild := range bilder {
        fmt.Println(bild.ID)
    }
}

Pull

Detta exempel är ekvivalent med att köra kommandot docker pull

paket huvud

import (
    "context"
    "io"
    "os"

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

funktion huvud() {
    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)
}

Nedladdning av bild med användarauthentisering

Detta exempel är ekvivalent med att köra kommandot docker pull, med autentisering.

Autentiseringsuppgifterna skickas i klartext. Officiella docker-registry använder HTTPS,
privata registry bör också konfigureras för att överföra data med hjälp av 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)
    }

    // Skapa en konfiguration för autentiseringsdata
    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)
}

Källa: habr.com