Gestion des conteneurs Docker dans Go

Documentation!

Lorsque vous décidez d'écrire votre propre vélo à accrocher à partir du hub Docker ou du registre pour mettre à jour / lancer automatiquement les conteneurs sur le serveur, vous devrez peut-être Docker Cli, qui vous aidera à gérer le démon Docker sur votre système.

Pour fonctionner, vous aurez besoin de la version Go non inférieure à 1.9.4

Si vous n'êtes toujours pas passé aux modules, installez Cli avec la commande suivante:

go get github.com/docker/docker/client 

Lancement de conteneurs

L'exemple suivant montre comment démarrer un conteneur à l'aide de l'API Docker. Dans la ligne de commande, vous utiliseriez la docker run , mais nous pouvons facilement faire face à cette tâche dans notre service.
Cet exemple équivaut à exécuter la commande docker run alpine echo hello world

 package main { ctx := context.Background() cli, err := client.NewEnvClient() if err != nil { panic(err) } //  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("Unable to get the port") } portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}} //      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) } //   if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil { panic(err) } //    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true}) if err != nil { panic(err) } io.Copy(os.Stdout, out) } 

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

Cet exemple équivaut à exécuter la 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) } //    (docker ps) containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{}) if err != nil { panic(err) } //     for _, container := range containers { fmt.Println(container.ID) } } 

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

Une fois que vous avez appris à créer et à exécuter des conteneurs, il est temps d'apprendre à les gérer. L'exemple suivant arrête tous les conteneurs en cours d'exécution.

N'exécutez pas ce code sur un serveur de production!

 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) } //    (docker ps) containers, err := cli.ContainerList(ctx, types.ContainerListOptions{}) if err != nil { panic(err) } for _, c := range containers { fmt.Print("Stopping container ", c.ID[:10], "... ") if err := cli.ContainerStop(ctx, c.ID, nil); err != nil { panic(err) } fmt.Println("Success") } } 

Enregistrement d'un seul conteneur

Vous pouvez travailler avec des conteneurs individuels. L'exemple suivant affiche les journaux du conteneur avec l'identificateur spécifié. Avant de commencer, vous devez modifier l'identifiant du conteneur dont vous souhaitez recevoir les journaux.

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

Obtenir la liste des images

Cet exemple équivaut à exécuter l' 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) } //    images, err := cli.ImageList(context.Background(), types.ImageListOptions{}) if err != nil { panic(err) } for _, image := range images { fmt.Println(image.ID) } } 

Tirer

Cet exemple équivaut à exécuter la 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écharger l'image avec l'authentification utilisateur

Cet exemple équivaut à exécuter la docker pull avec authentification.

Les données d'authentification sont envoyées en texte clair. Le registre Docker officiel utilise HTTPS,
Les registres privés doivent également être configurés pour transmettre des données à l'aide de 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) } //       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) }