Wenn Sie planen, Ihren eigenen Ansatz zum Abrufen von Hooks aus dem Docker Hub oder einem Registry für die automatische Aktualisierung/starten von Containern auf dem Server zu entwickeln, könnte Ihnen der Docker CLI nützlich sein, der Ihnen bei der Verwaltung des Docker-Daemons in Ihrem System hilft.
Für die Arbeit benötigen Sie Go in Version 1.9.4 oder höher.
Falls Sie noch nicht auf Module umgestiegen sind, installieren Sie den CLI mit dem folgenden Befehl:
go get github.com/docker/docker/clientStarten des Containers
Das folgende Beispiel zeigt, wie man einen Container mithilfe der Docker-API startet. In der Kommandozeile würden Sie den Befehl verwenden docker run, aber wir können diese Aufgabe problemlos in unserem Service bewältigen.
Dieses Beispiel entspricht dem Ausführen des Befehls docker run alpine echo hello world
package main {
ctx := context.Background()
cli, err := client.NewEnvClient()
if err != nil {
panic(err)
}
// Docker Pull ausführen
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("Kann den Port nicht abrufen")
}
portBinding := nat.PortMap{containerPort: []nat.PortBinding{hostBinding}}
// Container mit gegebener Konfiguration erstellen
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)
}
// Container starten
if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
// Container-Protokolle abrufen
out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Abrufen der Liste aktiver Container
Dieses Beispiel entspricht dem Ausführen des Befehls 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)
}
// Abrufen der Liste der laufenden Container (docker ps)
containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
if err != nil {
panic(err)
}
// Ausgabe aller Container-IDs
for _, container := range containers {
fmt.Println(container.ID)
}
}
Alle laufenden Container anhalten
Nachdem Sie gelernt haben, Container zu erstellen und zu starten, ist es Zeit, zu lernen, wie man sie verwaltet. Das folgende Beispiel stoppt alle laufenden Container.
Führen Sie diesen Code nicht in der Produktion aus 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)
}
// Abrufen der Liste der laufenden Container (docker ps)
containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
if err != nil {
panic(err)
}
for _, c := range containers {
fmt.Print("Container wird gestoppt: ", c.ID[:10], "... ")
if err := cli.ContainerStop(ctx, c.ID, nil); err != nil {
panic(err)
}
fmt.Println("Erfolg")
}
}Ausgabe der Logs eines einzelnen Containers
Sie können mit einzelnen Containern arbeiten. Im folgenden Beispiel werden die Logs des Containers mit der angegebenen ID angezeigt. Vor dem Start müssen Sie die ID des Containers ändern, dessen Logs Sie abrufen möchten.
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}
// Ändern Sie hier die ID des Containers
out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
if err != nil {
panic(err)
}
io.Copy(os.Stdout, out)
}Abrufen der Liste der Images
Dieses Beispiel entspricht dem Ausführen des Befehls 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)
}
// Abrufen der Liste der Images
images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
if err != nil {
panic(err)
}
for _, image := range images {
fmt.Println(image.ID)
}
}
Herunterladen
Dieses Beispiel entspricht dem Ausführen des Befehls 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)
}
Herunterladen des Images mit Benutzeranmeldung
Dieses Beispiel entspricht dem Ausführen des Befehls docker pull, mit Benutzeranmeldung.
Die Anmeldedaten werden unverschlüsselt übertragen. Offizielle Docker-Registrys verwenden HTTPS,
private Registrys sollten ebenfalls so konfiguriert werden, dass sie Daten über HTTPS übertragen.
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)
}
// Konfiguration mit Anmeldedaten erstellen
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)
}Quelle: habr.com
