Wie man den docker init-Befehl verwendet, um eine Go-Anwendung zu containerisieren

Einführung

In diesem Lab lernen Sie, wie Sie eine Go-Anwendung mithilfe des Befehls docker init in Container verpacken können. Das Lab beginnt mit der Überprüfung der korrekten Installation von Docker Desktop auf der LabEx VM. Dazu gehört die Prüfung der Docker-Version und das Ausführen des hello-world-Containers, um sicherzustellen, dass Docker wie erwartet funktioniert.

In den folgenden Schritten initialisieren Sie ein Go-Projekt mit docker init, passen die generierten Dockerfile und Compose-Datei speziell für eine Go-Anwendung an und erstellen schließlich die Go-Anwendung mit Docker Compose und führen sie aus. Diese praktische Erfahrung vermittelt Ihnen die Fähigkeiten, um Go-Anwendungen effektiv mit modernen Docker-Tools in Container zu verpacken.

Skills Graph

Installieren von Docker Desktop und Überprüfen von Docker Init

In diesem Schritt überprüfen wir, ob Docker korrekt auf der LabEx VM installiert ist. Die LabEx VM kommt mit Docker Engine vorkonfiguriert, daher überprüfen wir die Docker-Version und führen einen einfachen "hello-world"-Container aus, um sicherzustellen, dass alles wie erwartet funktioniert.

Zunächst überprüfen wir die Docker-Version. Öffnen Sie ein Terminal in der LabEx VM. Sie können das Terminal-Symbol auf dem Desktop oder im Anwendungsmenü finden.

Führen Sie den folgenden Befehl im Terminal aus:

docker --version

Dieser Befehl zeigt die auf dem System installierte Docker-Version an. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Docker version 20.10.21, build xxxxxxx

Wenn Sie die Docker-Version sehen, bedeutet dies, dass Docker korrekt installiert ist. Wenn Sie einen Fehler erhalten, wenden Sie sich bitte an den Support.

Als nächstes führen wir den "hello-world"-Container aus. Dies ist ein einfacher Container, der eine Nachricht auf der Konsole ausgibt und dann beendet wird.

Führen Sie den folgenden Befehl im Terminal aus:

docker run hello-world

Bevor Sie den Befehl ausführen, müssen Sie das hello-world-Image von Docker Hub herunterladen. Docker Hub ist ein öffentliches Registry für Docker-Images.

Führen Sie den folgenden Befehl aus, um das Image herunterzuladen:

docker pull hello-world

Dieser Befehl lädt das hello-world-Image von Docker Hub auf Ihren lokalen Rechner herunter. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Using default tag: latest
latest: Pulling from library/hello-world
...
Digest: sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest

Führen Sie nun erneut den Befehl docker run hello-world aus:

docker run hello-world

Dieser Befehl führt den hello-world-Container aus. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Diese Nachricht zeigt an, dass Docker korrekt funktioniert und Sie Ihren ersten Container erfolgreich ausgeführt haben!

Initialisieren eines Go-Projekts mit Docker Init

In diesem Schritt werden wir ein neues Go-Projekt initialisieren und docker init verwenden, um die erforderlichen Dockerfile- und docker-compose.yml-Dateien zu generieren. Dies wird den Ausgangspunkt für die Containerisierung unserer Go-Anwendung bilden.

Zunächst erstellen wir ein neues Verzeichnis für unser Go-Projekt. Öffnen Sie ein Terminal in der LabEx VM und führen Sie die folgenden Befehle aus:

mkdir my-go-app
cd my-go-app

Diese Befehle erstellen ein neues Verzeichnis namens my-go-app im Verzeichnis ~/project und ändern dann das aktuelle Verzeichnis in my-go-app.

Als nächstes müssen wir ein Go-Modul initialisieren. Dadurch wird eine go.mod-Datei erstellt, die die Abhängigkeiten unseres Projekts verfolgt.

Führen Sie den folgenden Befehl im Terminal aus:

go mod init my-go-app

Dieser Befehl initialisiert ein neues Go-Modul namens my-go-app. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

go: creating new go.mod: module my-go-app
go: to add module requirements and sums:
        go mod tidy

Jetzt erstellen wir eine einfache Go-Anwendung. Erstellen Sie eine neue Datei namens main.go im Verzeichnis my-go-app mit dem nano-Editor:

nano main.go

Fügen Sie den folgenden Code zur Datei main.go hinzu:

package main

import "fmt"

func main() {
	fmt.Println("Hello, Docker!")
}

Dies ist ein einfaches Go-Programm, das "Hello, Docker!" auf der Konsole ausgibt.

Speichern Sie die Datei und verlassen Sie den nano-Editor, indem Sie Strg+X, dann Y und schließlich Enter drücken.

Jetzt verwenden wir docker init, um die Dockerfile- und docker-compose.yml-Dateien zu generieren. Die LabEx VM hat jedoch standardmäßig kein Docker Compose installiert. Wir müssen es zuerst installieren.

Laden Sie die neueste Version von Docker Compose mit curl herunter:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Machen Sie die Docker Compose-Binary ausführbar:

sudo chmod +x /usr/local/bin/docker-compose

Überprüfen Sie die Installation, indem Sie die Docker Compose-Version prüfen:

docker-compose --version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

docker-compose version 1.29.2, build xxxxxxx

Nachdem Docker Compose installiert ist, können wir mit docker init fortfahren.

Führen Sie den folgenden Befehl im Terminal aus:

docker init

docker init wird eine Reihe von Fragen stellen, um die Dockerfile- und docker-compose.yml-Dateien zu konfigurieren. Hier sind die empfohlenen Antworten für dieses Lab:

• What do you want to call this application? my-go-app
• What port is this app listening on? 3000 (Dies ist ein Platzhalter, wir werden in diesem einfachen Beispiel tatsächlich keinen Port verwenden)
• What is the main file to execute? main.go
• Would you like to include the Docker Compose configuration? Yes
• Please choose a Docker Compose version: 2.0

Nachdem Sie diese Fragen beantwortet haben, wird docker init eine Dockerfile und eine docker-compose.yml-Datei im Verzeichnis my-go-app generieren.

Sie können den Inhalt der generierten Dateien mit dem cat-Befehl anzeigen:

cat Dockerfile
cat docker-compose.yml

Diese Dateien bieten eine grundlegende Konfiguration für das Erstellen und Ausführen unserer Go-Anwendung in einem Docker-Container. Im nächsten Schritt werden wir diese Dateien anpassen, um unseren Bedürfnissen besser zu entsprechen.

Anpassen der generierten Dockerfile- und Compose-Datei für Go

In diesem Schritt werden wir die im vorherigen Schritt generierten Dockerfile- und docker-compose.yml-Dateien anpassen. Wir werden das Dockerfile für das Bauen unserer Go-Anwendung optimieren und die docker-compose.yml-Datei so konfigurieren, dass unsere Anwendung ausgeführt wird.

Zunächst betrachten wir das generierte Dockerfile. Öffnen Sie das Dockerfile im Verzeichnis my-go-app mit dem nano-Editor:

nano Dockerfile

Das generierte Dockerfile könnte in etwa so aussehen:

## syntax=docker/dockerfile:1

FROM golang:latest AS builder

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download && go mod verify

COPY . .

RUN go build -o my-go-app

FROM alpine:latest

WORKDIR /app

COPY --from=builder /app/my-go-app .

EXPOSE 3000

CMD ["./my-go-app"]

Dieses Dockerfile verwendet einen mehrstufigen Build-Prozess. Die erste Stufe (builder) verwendet das golang:latest-Image, um die Go-Anwendung zu bauen. Die zweite Stufe verwendet das alpine:latest-Image, um die Anwendung auszuführen.

Lassen Sie uns das Dockerfile ändern, um eine bestimmte Go-Version zu verwenden und den Build-Prozess zu optimieren. Ersetzen Sie den Inhalt des Dockerfile durch Folgendes:

## syntax=docker/dockerfile:1

FROM golang:1.17 AS builder

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download && go mod verify

COPY . .

RUN go build -o my-go-app

FROM alpine:latest

WORKDIR /app

COPY --from=builder /app/my-go-app .

CMD ["./my-go-app"]

Wir haben das Basis-Image für die Builder-Stufe auf golang:1.17 geändert. Dies stellt sicher, dass wir eine bestimmte Go-Version für das Bauen unserer Anwendung verwenden.

Speichern Sie die Datei und verlassen Sie den nano-Editor.

Jetzt betrachten wir die generierte docker-compose.yml-Datei. Öffnen Sie die docker-compose.yml-Datei im Verzeichnis my-go-app mit dem nano-Editor:

nano docker-compose.yml

Die generierte docker-compose.yml-Datei könnte in etwa so aussehen:

version: "3.9"
services:
  my-go-app:
    build: .
    ports:
      - "3000:3000"

Diese docker-compose.yml-Datei definiert einen einzelnen Service namens my-go-app. Sie gibt an, dass der Service aus dem aktuellen Verzeichnis (.) gebaut werden soll und dass Port 3000 freigegeben werden soll.

Da unsere Anwendung tatsächlich nicht auf einem Port lauscht, können wir den ports-Abschnitt entfernen. Ändern Sie die docker-compose.yml-Datei wie folgt:

version: "3.9"
services:
  my-go-app:
    build: .

Speichern Sie die Datei und verlassen Sie den nano-Editor.

In diesem Schritt haben wir die Dockerfile- und docker-compose.yml-Dateien an unsere Bedürfnisse angepasst. Im nächsten Schritt werden wir unsere Go-Anwendung mit Docker Compose bauen und ausführen.

Bauen und Ausführen der Go-Anwendung mit Docker Compose

In diesem Schritt werden wir unsere Go-Anwendung mit Docker Compose bauen und ausführen. Docker Compose vereinfacht den Prozess des Bauens und Ausführens von Anwendungen mit mehreren Containern. In unserem Fall haben wir nur einen Container, aber Docker Compose bietet dennoch eine bequeme Möglichkeit, den Bau- und Ausführprozess zu verwalten.

Zunächst navigieren Sie im Terminal in das Verzeichnis my-go-app:

cd ~/project/my-go-app

Um das Docker-Image für unsere Anwendung zu bauen, führen Sie den folgenden Befehl aus:

docker-compose build

Dieser Befehl baut das Docker-Image basierend auf dem Dockerfile im aktuellen Verzeichnis. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Building my-go-app
Sending build context to Docker daemon  3.072kB
Step 1/6 : FROM golang:1.17 AS builder
 ---> xxxxxxxxxxxxxxxx
Step 2/6 : WORKDIR /app
 ---> Using cache
 ---> xxxxxxxxxxxxxxxx
Step 3/6 : COPY go.mod go.sum ./
 ---> Using cache
 ---> xxxxxxxxxxxxxxxx
Step 4/6 : RUN go mod download && go mod verify
 ---> Using cache
 ---> xxxxxxxxxxxxxxxx
Step 5/6 : COPY . .
 ---> xxxxxxxxxxxxxxxx
Step 6/6 : RUN go build -o my-go-app
 ---> Running in xxxxxxxxxx
Removing intermediate container xxxxxxxxxx
 ---> xxxxxxxxxxxxxxxx
Successfully built xxxxxxxxxxxxxxxx
Successfully tagged my-go-app_my-go-app:latest

Diese Ausgabe zeigt an, dass das Docker-Image erfolgreich gebaut wurde.

Jetzt führen Sie die Anwendung aus, indem Sie den folgenden Befehl ausführen:

docker-compose up

Dieser Befehl startet den im docker-compose.yml-File definierten Container. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Starting my-go-app_my-go-app_1 ... done
Attaching to my-go-app_my-go-app_1
my-go-app_1  | Hello, Docker!
my-go-app_my-go-app_1 exited with code 0

Diese Ausgabe zeigt, dass unsere Go-Anwendung ausgeführt wurde und "Hello, Docker!" auf der Konsole ausgegeben hat. Der Container wurde dann mit Code 0 beendet, was auf einen erfolgreichen Ausführungsablauf hinweist.

Um den Container zu stoppen, drücken Sie Strg+C im Terminal.

Sie können den Container auch im detached-Modus ausführen, indem Sie der docker-compose up-Befehl den -d-Schalter hinzufügen:

docker-compose up -d

Dadurch wird der Container im Hintergrund gestartet. Um die Logs des Containers anzuzeigen, führen Sie den folgenden Befehl aus:

docker logs my-go-app_my-go-app_1

Um den im detached-Modus laufenden Container zu stoppen, führen Sie den folgenden Befehl aus:

docker-compose down

Dieser Befehl stoppt und entfernt den Container.

In diesem Schritt haben wir unsere Go-Anwendung erfolgreich mit Docker Compose gebaut und ausgeführt. Dies zeigt, wie Docker Compose den Prozess der Verwaltung von containerisierten Anwendungen vereinfachen kann.

Zusammenfassung

In diesem Lab haben wir zunächst die erfolgreiche Installation von Docker Desktop auf der LabEx-VM überprüft. Dies beinhaltete die Prüfung der Docker-Version mit dem Befehl docker --version und die Bestätigung der ordnungsgemäßen Installation. Anschließend haben wir das hello-world-Image von Docker Hub mit docker pull hello-world heruntergeladen und den Container mit docker run hello-world ausgeführt, um sicherzustellen, dass Docker wie erwartet funktioniert. Dabei wurde eine Bestätigungsnachricht auf der Konsole ausgegeben.

Dieser erste Schritt hat eine funktionierende Docker-Umgebung geschaffen und die Grundlage für die folgenden Schritte gelegt, in denen docker init verwendet wurde, um eine Go-Anwendung zu containerisieren.