Üben Sie die Verwendung von Golang, um mit der Docker-API zu spielen

Inhaltsverzeichnis

Installieren des SDK
Lokalen Docker verwalten

Ausführen des Containers
Container im Hintergrund ausführen
Containerliste anzeigen
Stoppen Sie alle laufenden Container
Abrufen der Protokolle eines angegebenen Containers
Spiegelliste anzeigen
Ziehen Sie das Bild
Privates Bild abrufen
Speichern Sie den Container als Bild

Verwalten von Remote-Dockern

Remote-Verbindung
Ändern des Clients

Zusammenfassen

Docker bietet eine API (Docker Engine API genannt) für die Interaktion mit dem Docker-Daemon. Wir können das offizielle Go-Sprach-SDK verwenden, um Docker-Anwendungen und -Lösungen zu erstellen und zu erweitern.

Installieren des SDK

Sie können das SDK installieren, indem Sie den folgenden Befehl ausführen:

Gehen Sie zu github.com/docker/docker/client

Lokalen Docker verwalten

In diesem Abschnitt wird die Verwendung von Golang + Docker API zur Verwaltung des lokalen Dockers vorgestellt.

Ausführen des Containers

Das erste Beispiel zeigt, wie ein Container ausgeführt wird, das dem Befehl docker run docker.io/library/alpine echo "hello world" entspricht:

Paket Haupt

importieren (
 "Kontext"
 "io"
 "os"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/api/types/container“
 „github.com/docker/docker/client“
 „github.com/docker/docker/pkg/stdcopy“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
 Panik (äh)
 }

 Leser, Fehler := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{})
 wenn err != nil {
 Panik (äh)
 }
 io.Copy(os.Stdout, Leser)

 bzw. Fehler := cli.ContainerCreate(ctx, &container.Config{
 Bild: "alpin",
 Cmd: []string{"echo", "hallo welt"},
 }, null, null, "")
 wenn err != nil {
 Panik (äh)
 }

 wenn err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
 Panik (äh)
 }

 statusCh, errCh := cli.ContainerWait(ctx, resp.ID, Container.WaitConditionNotRunning)
 wählen {
 Fall err := <-errCh:
 wenn err != nil {
  Panik (äh)
 }
 Fall <-statusCh:
 }

 raus, Fehler := cli.ContainerLogs(ctx, resp.ID, Typen.ContainerLogsOptions{ShowStdout: true})
 wenn err != nil {
 Panik (äh)
 }

 stdcopy.StdCopy(os.Stdout, os.Stderr, out)
}

Container im Hintergrund ausführen

Sie können den Container auch im Hintergrund ausführen, was dem Befehl docker run -d bfirsh/reticulate-splines entspricht:

Paket Haupt

importieren (
 "Kontext"
 "fmt"
 "io"
 "os"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/api/types/container“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
 Panik (äh)
 }

 Bildname := "bfirsh/reticulate-splines"

 raus, Fehler := cli.ImagePull(ctx, imageName, types.ImagePullOptions{})
 wenn err != nil {
 Panik (äh)
 }
 io.Kopieren(os.Stdout, out)

 bzw. Fehler := cli.ContainerCreate(ctx, &container.Config{
 Bild: Bildname,
 }, null, null, "")
 wenn err != nil {
 Panik (äh)
 }

 wenn err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
 Panik (äh)
 }

 fmt.Println(bzw.ID)
}

Containerliste anzeigen

Listet laufende Container auf, genau wie mit Docker PS:

Paket Haupt

importieren (
 "Kontext"
 "fmt"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 Container, Fehler := cli.ContainerList(ctx, Typen.ContainerListOptions{})
 wenn err != nil {
  Panik (äh)
 }

 für _, Container := Bereich Container {
  fmt.Println(container.ID)
 }
}

Wenn es sich um Docker ps -a handelt, können wir dies erreichen, indem wir die Eigenschaft „All“ in types.ContainerListOptions ändern:

// Typ ContainerListOptions-Struktur {
// Ruhiger Bool
// Größe bool
// Alles bool
//Neueste bool
// Da Zeichenfolge
// Vor der Zeichenfolge
// Grenze int
// Filtert Filter.Args
// }

Optionen := Typen.ContainerListOptions{
 Alle: wahr,
}
Container, Fehler := cli.ContainerList(ctx, Optionen)
wenn err != nil {
 Panik (äh)
}

Stoppen Sie alle laufenden Container

Im obigen Beispiel können wir eine Liste von Containern abrufen und in diesem Fall alle laufenden Container stoppen.

Hinweis: Führen Sie den folgenden Code nicht auf einem Produktionsserver aus.

Paket Haupt

importieren (
 "Kontext"
 "fmt"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 Container, Fehler := cli.ContainerList(ctx, Typen.ContainerListOptions{})
 wenn err != nil {
  Panik (äh)
 }

 für _, Container := Bereich Container {
  fmt.Print("Container wird angehalten", container.ID[:10], "... ")
  wenn err := cli.ContainerStop(ctx, container.ID, nil); err != nil {
   Panik (äh)
  }
  fmt.Println("Erfolg")
 }
}

Abrufen der Protokolle eines angegebenen Containers

Durch Angabe der Container-ID können wir die Logs des Containers mit der entsprechenden ID abrufen:

Paket Haupt

importieren (
 "Kontext"
 "io"
 "os"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 Optionen := Typen.ContainerLogsOptions{ShowStdout: true}

 raus, err := cli.ContainerLogs(ctx, "f1064a8a4c82", Optionen)
 wenn err != nil {
  Panik (äh)
 }

 io.Kopieren(os.Stdout, out)
}

Spiegelliste anzeigen

Alle lokalen Images abrufen, entspricht Docker-Image-LS oder Docker-Images:

Paket Haupt

importieren (
 "Kontext"
 "fmt"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 Bilder, Fehler := cli.ImageList(ctx, types.ImageListOptions{})
 wenn err != nil {
  Panik (äh)
 }

 für _, Bild := Bereich Bilder {
  fmt.Println(bild.ID)
 }
}

Ziehen Sie das Bild

Ziehen Sie das angegebene Image, was dem „Docker Pull Alpine“ entspricht:

Paket Haupt

importieren (
 "Kontext"
 "io"
 "os"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 raus, Fehler := cli.ImagePull(ctx, "alpine", types.ImagePullOptions{})
 wenn err != nil {
  Panik (äh)
 }

 aufschieben.Schließen()

 io.Kopieren(os.Stdout, out)
}

Privates Bild abrufen

Zusätzlich zu öffentlichen Images verwenden wir normalerweise einige private Images. Dabei kann es sich um private Images auf DockerHub oder um selbst gehostete Image-Repositorys wie Harbor handeln. Zu diesem Zeitpunkt müssen wir die entsprechenden Anmeldeinformationen angeben, um das Image abzurufen.

Es ist zu beachten, dass bei Verwendung des Go SDK der Docker-API die Anmeldeinformationen im Klartext übertragen werden. Wenn Sie also Ihr eigenes Image-Repository erstellen, verwenden Sie unbedingt HTTPS!

Paket Haupt

importieren (
 "Kontext"
 "Kodierung/Base64"
 "Kodierung/JSON"
 "io"
 "os"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 authConfig := Typen.AuthConfig{
  Benutzername: "Benutzername",
  Passwort: "Passwort",
 }
 encodedJSON, Fehler := json.Marshal(authConfig)
 wenn err != nil {
  Panik (äh)
 }
 authStr := base64.URLEncoding.EncodeToString(kodiertesJSON)

 raus, Fehler := cli.ImagePull(ctx, "alpine", types.ImagePullOptions{RegistryAuth: authStr})
 wenn err != nil {
  Panik (äh)
 }

 aufschieben.Schließen()
 io.Kopieren(os.Stdout, out)
}

Speichern Sie den Container als Bild

Wir können einen vorhandenen Container als Image speichern, indem wir Folgendes committen:

Paket Haupt

importieren (
 "Kontext"
 "fmt"

 „github.com/docker/docker/api/types“
 „github.com/docker/docker/api/types/container“
 „github.com/docker/docker/client“
)

Funktion main() {
 ctx := Kontext.Hintergrund()
 cli, err := Client.NewClientWithOpts(Client.FromEnv, Client.WithAPIVersionNegotiation())
 wenn err != nil {
  Panik (äh)
 }

 createResp, err := cli.ContainerCreate(ctx, &container.Config{
  Bild: "alpin",
  Befehl: []string{"touch", "/hallowelt"},
 }, null, null, "")
 wenn err != nil {
  Panik (äh)
 }

 wenn err := cli.ContainerStart(ctx, createResp.ID, types.ContainerStartOptions{}); err != nil {
  Panik (äh)
 }

 statusCh, errCh := cli.ContainerWait(ctx, createResp.ID, container.WaitConditionNotRunning)
 wählen {
 Fall err := <-errCh:
  wenn err != nil {
   Panik (äh)
  }
 Fall <-statusCh:
 }

 commitResp, err := cli.ContainerCommit(ctx, createResp.ID, types.ContainerCommitOptions{Referenz: "hallowelt"})
 wenn err != nil {
  Panik (äh)
 }

 fmt.Println(commitResp.ID)
}

Verwalten von Remote-Dockern

Natürlich können wir zusätzlich zur Verwaltung des lokalen Dockers auch den Remote-Docker verwalten, indem wir Golang + Docker API verwenden.

Remote-Verbindung

Standardmäßig läuft Docker über einen nicht vernetzten Unix-Socket und kann nur lokal kommunizieren (/var/run/docker.sock). Eine Remote-Verbindung zu Docker ist nicht möglich.
Wir müssen die Konfigurationsdatei /etc/docker/daemon.json bearbeiten und den folgenden Inhalt ändern (192.168.59.3 in Ihre eigene IP-Adresse ändern) und dann Docker neu starten:

# vi /etc/docker/daemon.json
{
 "Gastgeber": [
 "tcp://192.168.59.3:2375",
 "unix:///var/run/docker.sock"
 ]
}

systemctl Neustart Docker

Ändern des Clients

Beim Erstellen eines Clients müssen Sie die Adresse des Remote-Dockers angeben, damit Sie den Remote-Docker genauso verwalten können wie den lokalen Docker:

cli, err = Client.NeuerClientMitOpts(Client.FromEnv, Client.MitAPIVersionNegotiation(),
 client.MitHost("tcp://192.168.59.3:2375"))

Zusammenfassen

Es gibt bereits viele Produkte, die Docker verwalten können und auf diese Weise implementiert sind, beispielsweise Portainer.

Dies ist das Ende dieses Artikels über die Verwendung von Golang zum Spielen mit Docker API. Weitere Informationen zum Ausführen von Docker API mit Golang finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder durchsuchen Sie die folgenden verwandten Artikel weiter. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:

Detaillierte Erklärung zum Einrichten von Go und Bereitstellen von Anwendungen in Docker
Die clevere Kombination aus Docker und Golang
Detaillierte Schritte zum Bereitstellen eines Golang-Projekts im Docker
Beispiel für die Bereitstellung einer Django-Anwendung mit Docker
Beim Kompilieren des Go-Programms im Docker-Container wird angezeigt, dass die Datei nicht gefunden werden kann
Beispiel für die Bereitstellung eines Django-Projekts mit Docker
Lösung für Docker Django, der nicht auf den Redis-Container zugreifen kann
Golang-Lernnotizen: Installieren Sie die Version Go1.15 (Win-/Linux-/MacOS-/Docker-Installation)

<<: HTML-Elemente (Tags) und ihre Verwendung

>>: Rankings zur Benutzerfreundlichkeit chinesischer Websites