Container mit Dockerfiles entwickeln

1. Übersicht

Docker ist eine offene Plattform zum Entwickeln, Versenden und Ausführen von Anwendungen. Damit können Sie Anwendungen von Ihrer Infrastruktur trennen und diese wie eine verwaltete Anwendung handhaben. Außerdem lässt sich Code schneller versenden, testen und bereitstellen sowie der Zyklus zwischen dem Schreiben und Ausführen von Code verkürzen.

Zu diesem Zweck kombiniert Docker Funktionen zur Kernel-Containerisierung mit Workflows und Tools, die Ihnen beim Verwalten und Bereitstellen von Anwendungen helfen.

Docker-Container können direkt in Kubernetes verwendet und somit auch ganz einfach in der Kubernetes Engine ausgeführt werden. Sobald Sie die Grundlagen von Docker kennen, können Sie Kubernetes- und containerisierte Anwendungen entwickeln.

Lerninhalte

In diesem Lab lernen Sie Folgendes:

• Dockerfile für eine Beispielanwendung erstellen
• Image erstellen
• Image lokal als Container ausführen
• Containerverhalten ändern
• Image in Artifact Registry hochladen

Vorbereitung

Dies ist ein Einführungs-Lab. Es werden keine oder nur geringe Vorkenntnisse zu Docker und Containern vorausgesetzt. Vorkenntnisse zur Cloud Shell und zur Befehlszeile sind empfehlenswert, aber nicht erforderlich.

Umgebung zum selbstbestimmten Lernen einrichten

1. Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

• Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird und den Sie jederzeit aktualisieren können.
• Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf die Projekt-ID verweisen (die in der Regel als PROJECT_ID angegeben wird). Wenn Ihnen die ID nicht gefällt, können Sie eine andere zufällige ID generieren oder eine eigene ID ausprobieren und sehen, ob sie verfügbar ist. Danach wird sie „eingefroren“.
• Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Achtung:Eine Projekt-ID muss global eindeutig sein und kann nach der Auswahl nicht mehr von anderen verwendet werden. Sie sind der einzige Nutzer dieser ID. Wenn ein Projekt gelöscht wird, kann die ID nie wieder verwendet werden.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie den Standardspeicherort auf Keine Organisation belassen. Wenn Sie ein Google Workspace-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit nach Abschluss dieses Codelabs keine Gebühren anfallen, folgen Sie der Anleitung zum Bereinigen am Ende des Codelabs. Neue Nutzer von Google Cloud kommen für das kostenlose Testprogramm mit einem Guthaben von 300 $ infrage.

2. Beispiel-App

Für dieses Lab wurde eine Beispielanwendung bereitgestellt. In diesem Abschnitt rufen Sie den Quellcode ab und erstellen die Anwendung in ihrer nativen Form, bevor Sie mit der Containerisierung fortfahren.

Quellcode

Der Quellcode für dieses Lab ist im Repository GoogleCloudPlatform/container-developer-workshop zusammen mit der Dokumentation der Beispielanwendung verfügbar.

Git konfigurieren

git config --global user.name ${USER}
git config --global user.email ${USER}@qwiklabs.net

Cloud Source Repository der Beispielanwendung klonen

gcloud source repos clone sample-app ${HOME}/sample-app &&
cd ${HOME}/sample-app &&
git checkout main

Ausgabe

Cloning into '/home/student_03_49720296e995/sample-app'...
remote: Finding sources: 100% (16/16)
remote: Total 16 (delta 0), reused 16 (delta 0)
Receiving objects: 100% (16/16), 47.23 KiB | 681.00 KiB/s, done.
warning: remote HEAD refers to nonexistent ref, unable to checkout.

Project [qwiklabs-gcp-02-4327c4e03d82] repository [sample-app] was cloned to [/home/student_03_49720296e995/sample-app].
Branch 'main' set up to track remote branch 'main' from 'origin'.
Switched to a new branch 'main'

Beispielanwendung erstellen

cd ${HOME}/sample-app
./mvnw compile

Ausgabe

[INFO] Scanning for projects...
...
[INFO] Compiling 1 source file to /home/student_03_49720296e995/sample-app/target/classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  10.080 s
[INFO] Finished at: 2022-02-23T17:14:30Z
[INFO] ------------------------------------------------------------------------

Beispielanwendung ausführen

cd ${HOME}/sample-app
./mvnw exec:java

Ausgabe

[INFO] Scanning for projects...
...
Listening at http://localhost:8080

Ausgeführte Anwendung als Vorschau ansehen

• Auf die Schaltfläche „Cloud Shell-Webvorschau“ klicken
• Klicken Sie auf „Vorschau auf Port 8080“.

Nächster Schritt

• Drücken Sie in Cloud Shell STRG + C, um die laufende Anwendung zu beenden.

3. Dockerfile

Anwendung mit einem Dockerfile containerisieren

Eine Möglichkeit, eine Anwendung in einem Container zu verpacken, ist die Verwendung eines Dockerfile. Das Dockerfile ähnelt einem Skript, das den Daemon anweist, wie das Container-Image zusammengestellt werden soll. Weitere Informationen finden Sie in der Dockerfile-Referenzdokumentation.

Erstellen Sie ein leeres Dockerfile im Repository der Beispielanwendung.

touch ${HOME}/sample-app/Dockerfile

Öffnen Sie das Dockerfile in einem Editor Ihrer Wahl.

vi ${HOME}/sample-app/Dockerfile

Startbild auswählen

Wenn Sie einen Container mit der Dockerfile-Methode erstellen, sind direkte Kenntnisse der Anwendung erforderlich, um den Container zusammenzustellen. Der erste Schritt zum Erstellen eines Dockerfile ist die Auswahl eines Images, das als Grundlage für Ihr Image verwendet wird.Dieses Image sollte ein übergeordnetes oder Basis-Image sein, das von einer vertrauenswürdigen Quelle, in der Regel Ihrem Unternehmen, verwaltet und veröffentlicht wird.

Mit der Anweisung FROM wird eine neue Build-Phase initialisiert und das Basis-Image für nachfolgende sequenzielle Befehle festgelegt. Die Anweisung FROM ist daher in der Regel die erste Anweisung in einem Dockerfile und kann nur von einer optionalen ARG-Anweisung gefolgt werden, um Variablen zu unterstützen.

Syntax: FROM <image>[:<tag> | @<digest>] [AS <name>]

Das Format für ein Bild ist <image>:<tag> oder <image>@<digest>. Wenn kein Tag oder Digest angegeben ist, wird standardmäßig das :latest-Tag verwendet. Das Format von <image> hängt von der Registry ab, in der das Image gespeichert ist. Für Artifact Registry ist das <image>-Format <region>-docker.pkg.dev/<project ID>/<repository name>/<image name>:<image tag>.

In diesem Lab verwenden wir das öffentliche openjdk:11.0-jdk-Image. Fügen Sie Ihrem Dockerfile die folgende Zeile hinzu:

FROM openjdk:11.0-jdk

Arbeitsverzeichnis festlegen

Mit der Anweisung WORKDIR wird das Arbeitsverzeichnis für alle nachfolgenden sequenziellen Anweisungen im Dockerfile festgelegt. Weitere Informationen finden Sie im Abschnitt WORKDIR der Dockerfile-Referenzdokumentation.

Syntax: WORKDIR <path>

In diesem Lab verwenden wir das Verzeichnis /app als WORKDIR. Fügen Sie die folgende Zeile am Ende Ihres Dockerfile hinzu:

WORKDIR /app

Anwendungsdateien kopieren

Mit der COPY-Anweisung werden Verzeichnisse oder Dateien vom Speicherort <source> in den Pfad <destination> des Image-Dateisystems kopiert. Es können mehrere <source>-Ressourcen angegeben werden, die alle relativ zum Build-Kontext sind. Der Build-Kontext wird im Abschnitt „Build“ näher erläutert. Weitere Informationen finden Sie im Abschnitt COPY der Dockerfile-Referenzdokumentation.

Syntax: COPY <source>... <destination>

In diesem Lab kopieren wir alle Dateien im Repository in das Image-Dateisystem. Fügen Sie dazu die folgende Zeile am Ende Ihres Dockerfile ein:

COPY . /app

Anwendung kompilieren

Mit der RUN-Anweisung werden Befehle in einer neuen Image-Ebene über dem aktuellen Image ausgeführt und die Ergebnisse werden übernommen. Das resultierende committete Image wird für nachfolgende Schritte im Dockerfile verwendet. Weitere Informationen finden Sie im Abschnitt „RUN“ der Dockerfile-Referenzdokumentation.

Syntax: RUN <command>

In diesem Lab verwenden wir Maven, um die Anwendung in eine JAR-Datei zu kompilieren. Fügen Sie dazu die folgende Zeile am Ende Ihres Dockerfile ein:

RUN ./mvnw compile assembly:single

Anwendung starten

Die Anweisung CMD stellt den Standardbefehl für einen laufenden Container bereit. In einem Dockerfile kann nur eine CMD-Anweisung vorhanden sein. Wenn mehr als eine CMD-Anweisung angegeben ist, wird nur die letzte CMD-Anweisung wirksam. Sowohl mit den Anweisungen CMD als auch ENTRYPOINT sind erweiterte Funktionen verfügbar, die in diesem Lab jedoch nicht behandelt werden. Weitere Informationen finden Sie im Abschnitt CMD der Dockerfile-Referenzdokumentation.

Syntax: CMD ["executable","param1","param2"]

Für dieses Lab führen wir die JAR-Datei aus, die wir kompiliert haben. Fügen Sie dazu die folgende Zeile am Ende Ihres Dockerfile ein:

CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]

Finales Dockerfile

Das endgültige Dockerfile sieht so aus:

FROM openjdk:11.0-jdk
WORKDIR /app
COPY . /app
RUN ./mvnw compile assembly:single
CMD ["java","-jar","/app/target/sample-app-1.0.0-jar-with-dependencies.jar"]

Dockerfile lokal committen

cd ${HOME}/sample-app
git add Dockerfile
git commit -m "Added Dockerfile"

4. Build

Jetzt erstellen wir das Image aus dem Dockerfile mit dem Befehl docker build. Dieser Befehl weist den Docker-Daemon an, das Image anhand der Anweisungen in unserem Dockerfile zu erstellen. Weitere Informationen finden Sie in der Referenzdokumentation zu „docker build“.

Image erstellen

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker build --tag sample-app:${IMAGE_TAG} .

Ausgabe

Sending build context to Docker daemon  221.2kB
Step 1/4 : FROM openjdk:11.0-jdk
11.0-jdk: Pulling from library/openjdk
0c6b8ff8c37e: Pull complete
412caad352a3: Pull complete
e6d3e61f7a50: Pull complete
461bb1d8c517: Pull complete
e442ee9d8dd9: Pull complete
542c9fe4a7ba: Pull complete
41de18d1833d: Pull complete
Digest: sha256:d72b1b9e94e07278649d91c635e34737ae8f181c191b771bde6816f9bb4bd08a
Status: Downloaded newer image for openjdk:11.0-jdk
---> 2924126f1829
Step 2/4 : WORKDIR /app
---> Running in ea037abb273d
Removing intermediate container ea037abb273d
---> bd9b6d078082
Step 3/4 : COPY . /app
---> b9aec2b5de51
Step 4/4 : RUN ./mvnw compile jar:jar
---> Running in 3f5ff737b7fd
[INFO] Scanning for projects...
...
[INFO] Building jar: /app/target/sample-app-1.0.0.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  22.952 s
[INFO] Finished at: 2022-02-23T18:09:08Z
[INFO] ------------------------------------------------------------------------
Removing intermediate container 331443caebd3
---> 152f65cc441e
Step 5/5 : CMD ["java", "-jar", "/app/target/sample-app-1.0.0.jar"]
---> Running in 3d595a72231c
Removing intermediate container 3d595a72231c
---> 0e40d7548cab
Successfully built 0e40d7548cab
Successfully tagged sample-app:aaa8895

5. Ausführen

Nachdem wir unser Container-Image erfolgreich erstellt haben, können wir unsere Anwendung mit dem Befehl „docker run“ ausführen und prüfen, ob sie sich wie erwartet verhält. Mit diesem Befehl wird unser Container im Vordergrund der Eingabeaufforderung für Tests oder das Debugging gestartet. Weitere Informationen finden Sie in der Referenzdokumentation zu „docker run“.

Container mit dem Image ausführen

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
  --rm \
  -p 8080:8080 \
  sample-app:${IMAGE_TAG}

Ausgabe

Listening at http://localhost:8080

Vorschau der Anwendung in einem Container ansehen

• Auf die Schaltfläche „Cloud Shell-Webvorschau“ klicken
• Klicken Sie auf „Vorschau auf Port 8080“.
• Drücken Sie in Cloud Shell STRG + C, um die Container zu beenden.

Containerverhalten ändern

Beim Ausführen von „docker run“ wird die Standardkonfiguration im Dockerfile verwendet. Sie können zusätzliche Anweisungen und Parameter hinzufügen, um dieses Verhalten zu ändern.

TRACE-Logging aktivieren

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
  --rm \
  -p 8080:8080 \
  sample-app:${IMAGE_TAG} \
  java -Dorg.slf4j.simpleLogger.defaultLogLevel=trace -jar /app/target/sample-app-1.0.0-jar-with-dependencies.jar

Vorschau der Anwendung in einem Container ansehen

• Auf die Schaltfläche „Cloud Shell-Webvorschau“ klicken
• Klicken Sie auf „Vorschau auf Port 8080“.
• Wechseln Sie zum Cloud Shell-Tab und sehen Sie sich die zusätzlichen Logs an.
• Drücken Sie in Cloud Shell STRG + C, um den Container zu beenden.

Port ändern

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
docker run \
--rm \
-e PORT=8081 \
-p 8081:8081 \
sample-app:${IMAGE_TAG}

Vorschau der Anwendung in einem Container ansehen

• Auf die Schaltfläche „Cloud Shell-Webvorschau“ klicken
• Klicken Sie auf „Port ändern“.
• Geben Sie 8081 ein.
• Klicken Sie auf „Ändern und Vorschau“.
• Drücken Sie in Cloud Shell STRG + C, um den Container zu beenden.

6. Push

Wenn wir sicher sind, dass das Container-Image ordnungsgemäß ausgeführt wird und wir diesen Container in anderen Umgebungen und/oder von anderen Nutzern ausführen lassen möchten, müssen wir das Image in ein gemeinsames Repository übertragen. Dies sollte im Rahmen einer automatisierten Build-Pipeline erfolgen. In unserer Testumgebung ist jedoch bereits ein Repository konfiguriert und wir können unser Image manuell übertragen.

Dockerfile-Commit in das Repository „sample-app“ übertragen

cd ${HOME}/sample-app
export IMAGE_TAG=$(git rev-parse --short HEAD)
git push

Image für Artifact Registry taggen

docker tag sample-app:${IMAGE_TAG} \
    us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}

Anmeldedaten für Artifact Registry konfigurieren

gcloud auth configure-docker us-central1-docker.pkg.dev

Wenn Sie dazu aufgefordert werden, Do you want to continue (Y/n)? geben Sie y ein und drücken Sie Enter.

Image in Artifact Registry hochladen

docker push us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/apps/sample-app:${IMAGE_TAG}

Ausgabe

 The push refers to repository [us-central1-docker.pkg.dev/qwiklabs-gcp-04-b47ced695a3c/apps/sample-app]
  453b97f86449: Pushed
  e86791aa0382: Pushed
  d404c7ee0850: Pushed
  fe4f44af763d: Pushed
  7c072cee6a29: Pushed
  1e5fdc3d671c: Pushed
  613ab28cf833: Pushed
  bed676ceab7a: Pushed
  6398d5cccd2c: Pushed
  0b0f2f2f5279: Pushed
  aaa8895: digest: sha256:459de00f86f159cc63f98687f7c9563fd65a2eb9bcc71c23dda3351baf13607a size: 2424

7. Glückwunsch!

Herzlichen Glückwunsch! Sie haben das Codelab abgeschlossen.

Behandelte Themen

• Dockerfile für eine Beispielanwendung erstellt
• Image erstellt
• Das Image wurde lokal als Container ausgeführt.
• Geändertes Containerverhalten
• Image in Artifact Registry hochgeladen