Gestion des conteneurs Docker en Go

Documentation !

Lorsque vous décidez d'écrire votre propre vélo pour attraper des hooks depuis docker hub ou depuis un registre pour mettre à jour/démarrer automatiquement des conteneurs sur le serveur, vous pourriez avoir besoin de Docker Cli, qui vous aidera à gérer le démon Docker sur votre système.

Pour cela, vous aurez besoin de Go version 1.9.4 ou supérieure.

Si vous n'avez pas encore migré vers les modules, installez Cli avec la commande suivante :

go get github.com/docker/docker/client

Lancer un conteneur

L'exemple suivant montre comment lancer un conteneur en utilisant l'API Docker. Dans la ligne de commande, vous utiliseriez la commande docker run, mais nous pouvons facilement accomplir cette tâche dans notre service.
Cet exemple est équivalent à l'exécution de la commande docker run alpine echo hello world

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

    // Réaliser un 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("Impossible d'obtenir le port")
    }
    portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}

    // Création du conteneur avec la configuration donnée
    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)
    }

    // Démarrage du conteneur
    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    // Obtention des logs du conteneur
    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Obtenir la liste des conteneurs en cours d'exécution

Cet exemple est équivalent à l'exécution de la commande 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)
    }

    // Obtention de la liste des conteneurs en cours d'exécution (docker ps)
    containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    // Affichage de tous les identifiants des conteneurs
    for _, container := range containers {
        fmt.Println(container.ID)
    }
}

Arrêter tous les conteneurs en cours d'exécution

Après avoir appris à créer et lancer des conteneurs, il est temps d'apprendre à les gérer. L'exemple suivant arrêtera tous les conteneurs en cours d'exécution.

Ne pas exécuter ce code en production le serveur!

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

    // Récupération de la liste des conteneurs en cours d'exécution (docker ps)
    containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
    if err != nil {
        panic(err)
    }

    for _, c := range containers {
        fmt.Print("Arrêt du conteneur ", c.ID[:10], "... ")
        if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
            panic(err)
        }
        fmt.Println("Succès")
    }
}

Affichage des logs d'un conteneur spécifique

Vous pouvez travailler avec des conteneurs spécifiques. Dans l'exemple suivant, les logs d'un conteneur avec l'identifiant spécifié sont affichés. Vous devez modifier l'identifiant du conteneur dont vous souhaitez obtenir les logs avant de lancer.

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}
    // Modifiez l'id du conteneur ici
    out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, out)
}

Récupération de la liste des images

Cet exemple est équivalent à l'exécution de la commande 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)
    }

    // Récupération de la liste des images
    images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
    if err != nil {
        panic(err)
    }

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

Tirer

Cet exemple est équivalent à l'exécution de la commande 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)
}

Téléchargement d'une image avec authentification utilisateur

Cet exemple est équivalent à l'exécution de la commande docker pull, avec authentification.

Les données d'authentification sont envoyées en clair. Les registre docker officiels utilisent HTTPS,
les registres privés doivent également être configurés pour transmettre des données en utilisant 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)
    }

    // Création d'une configuration avec des données d'authentification
    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)
}

Source : habr.com