Cloud Service Mesh ist ein leistungsstarkes Tool für die Verwaltung und das Monitoring verteilter Anwendungen. Damit Sie Cloud Service Mesh optimal nutzen können, ist es hilfreich, die zugrunde liegenden Abstraktionen zu verstehen, einschließlich Container und Kubernetes. In dieser Anleitung wird beschrieben, wie Sie eine Anwendung für Cloud Service Mesh vom Quellcode bis zu einem Container vorbereiten, der in GKE bis zur Installation von Cloud Service Mesh ausgeführt wird.
Wenn Sie mit den Konzepten von Kubernetes und Service Mesh bereits vertraut sind, können Sie diese Anleitung überspringen und direkt die Installationsanleitung für Cloud Service Mesh lesen.
Lernziele
- Einfache „Hello World“-Anwendung für mehrere Services kennenlernen
- Anwendung aus der Quelle ausführen
- Anwendung containerisieren
- Kubernetes-Cluster erstellen
- Container im Cluster bereitstellen
Hinweis
Führen Sie die folgenden Schritte aus, um die Cloud Service Mesh API zu aktivieren:- Rufen Sie in der Google Cloud Console die Seite Kubernetes Engine auf.
- Erstellen Sie ein Projekt oder wählen Sie eines aus.
- Warten Sie, bis die API und die zugehörigen Dienste aktiviert worden sind. Dieser Vorgang kann einige Minuten dauern.
-
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
In dieser Anleitung wird Cloud Shell verwendet, das eine Virtuelle g1-small Compute Engine-Maschine (VM), auf der ein Debian-basiertes Linux-Betriebssystem ausgeführt wird.
Cloud Shell vorbereiten
Cloud Shell bietet folgende Vorteile:
- Die Entwicklungsumgebungen Python 2 und Python 3 (einschließlich
virtualenv
) sind fertig eingerichtet. - Die in dieser Anleitung verwendeten
gcloud
-,docker
-,git
- undkubectl
-Befehlszeilentools sind bereits installiert. Es stehen verschiedene Texteditoren zur Auswahl:
Code-Editor, auf den Sie zugreifen, indem Sie oben im Cloud Shell-Fenster auf klicken.
Emacs, Vim oder Nano, auf die Sie in Cloud Shell über die Befehlszeile zugreifen.
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Beispielcode herunterladen
Laden Sie den Quellcode
helloserver
herunter:git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-samples
Öffnen Sie das Verzeichnis mit dem Beispielcode:
cd anthos-service-mesh-samples/docs/helloserver
Anwendung mit mehreren Diensten entdecken
Die Beispielanwendung ist in Python geschrieben und besteht aus zwei Komponenten, die mit REST kommunizieren:
server
: Ein einfacher Server mit einemGET
-Endpunkt (/
), der „Hello World“ an die Konsole ausgibt.loadgen
: Ein Skript, das Traffic anserver
mit einer konfigurierbaren Anzahl von Anfragen pro Sekunde (RPS) sendet.
Anwendung aus der Quelle ausführen
Führen Sie die Beispielanwendung in Cloud Shell aus, um sich mit der Beispielanwendung vertraut zu machen.
Führen Sie im Verzeichnis
sample-apps/helloserver
den Befehlserver
aus:python3 server/server.py
Beim Start zeigt
server
Folgendes an:INFO:root:Starting server...
Öffnen Sie ein anderes Terminalfenster, damit Sie Anfragen an
server
senden können. Klicken Sie auf , um eine weitere Sitzung zu öffnen.Senden Sie eine Anfrage an
server
:curl http://localhost:8080
Der
server
antwortet:Hello World!
Wechseln Sie von dem Verzeichnis, in das Sie den Beispielcode heruntergeladen haben, in das Verzeichnis, das
loadgen
enthält:cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/loadgen
Erstellen Sie die folgenden Umgebungsvariablen:
export SERVER_ADDR=http://localhost:8080 export REQUESTS_PER_SECOND=5
Starten Sie
virtualenv
:virtualenv --python python3 env
Aktivieren Sie die virtuelle Umgebung:
source env/bin/activate
Installieren Sie die Anforderungen für
loadgen
:pip3 install -r requirements.txt
Führen Sie
loadgen
aus:python3 loadgen.py
Beim Start gibt
loadgen
eine Meldung wie diese aus:Starting loadgen: 2019-05-20 10:44:12.448415 5 request(s) complete to http://localhost:8080
Im anderen Terminalfenster schreibt
server
Nachrichten wie diese in die Konsole:127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 - INFO:root:GET request, Path: / Headers: Host: localhost:8080 User-Agent: python-requests/2.22.0 Accept-Encoding: gzip, deflate Accept: */*
Aus Netzwerksicht wird die gesamte Anwendung nun auf dem über denselben Host verfügen. Daher können Sie
localhost
verwenden, um Anfragen an denserver
.Zum Beenden von
loadgen
undserver
geben Sie in jedem TerminalfensterCtrl-c
ein.Deaktivieren Sie im Terminalfenster
loadgen
die virtuelle Umgebung:deactivate
Anwendung containerisieren
Um die Anwendung in GKE auszuführen, müssen Sie die Beispielanwendung (server
und loadgen
) in Container packen. Mit einem Container können Sie eine Anwendung so verpacken, dass sie von der zugrunde liegenden Umgebung isoliert ist.
Zum Containerisieren der Anwendung benötigen Sie ein Dockerfile
. Ein Dockerfile
ist eine Textdatei, in der die Befehle definiert sind, die zum Erstellen des Quellcodes der Anwendung und der Abhängigkeiten in einem Docker-Image erforderlich sind. Nachdem Sie das Image erstellt haben, laden Sie es in ein Container-Registry wie Docker Hub oder Container Registry hoch.
Im Beispiel wird ein Dockerfile
für server
und loadgen
mit allen Befehlen verwendet, die zum Erstellen der Images erforderlich sind. Im Folgenden finden Sie das Dockerfile
für den server
:
- Der Befehl
FROM python:3-slim as base
weist Docker an, das neueste Python 3-Image als Basis-Image zu verwenden. - Mit dem Befehl
COPY . .
werden die Quelldateien im aktuellen Arbeitsverzeichnis (in diesem Fall nurserver.py
) in das Dateisystem des Containers kopiert. ENTRYPOINT
definiert den Befehl, der zum Ausführen des Containers verwendet wird. In diesem Fall entspricht der Befehl fast dem Befehl, mit dem Sieserver.py
aus dem Quellcode ausgeführt haben.- Der Befehl
EXPOSE
gibt an, dassserver
den Port8080
überwacht. Mit diesem Befehl werden keine Ports freigegeben. Sie dienen jedoch als Dokumentation, die Sie beim Ausführen des Containers zum Öffnen von Port8080
benötigen.
Containerisierung der Anwendung vorbereiten
Legen Sie die folgenden Umgebungsvariablen fest: Ersetzen
PROJECT_ID
durch die ID Ihres Google Cloud-Projektexport PROJECT_ID="PROJECT_ID"
export GCR_REPO="asm-ready"
Sie verwenden den Wert von
PROJECT_ID
undGCR_REPO
, um das Docker-Image beim Erstellen zu kennzeichnen und es in Ihre private Container Registry zu übertragen.Legen Sie das Standard-Google Cloud-Projekt für die Google Cloud CLI fest:
gcloud config set project $PROJECT_ID
Legen Sie die Standardzone für die Google Cloud CLI fest:
gcloud config set compute/zone us-central1-b
Achten Sie darauf, dass der Container Registry-Dienst in Ihrem Google Cloud-Projekt
gcloud services enable containerregistry.googleapis.com
server
containerisieren
Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel
server
befindet:cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/
Erstellen Sie das Image mit dem
Dockerfile
und den Umgebungsvariablen, die Sie zuvor definiert haben:docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
Das Flag
-t
steht für das Docker-Tag. Dies ist der Name des Images, das Sie bei der Bereitstellung des Containers verwenden.Laden Sie das Image in Container Registry hoch.
docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1
loadgen
containerisieren
Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel
loadgen
befindet:cd ../loadgen
Erstellen Sie das Image:
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .
Laden Sie das Image in Container Registry hoch.
docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1
Images auflisten
Rufen Sie eine Liste der Images im Repository ab, um zu bestätigen, dass die Images übertragen wurden:
gcloud container images list --repository gcr.io/$PROJECT_ID/asm-ready
Der Befehl antwortet mit den soeben übertragenen Image-Namen:
NAME gcr.io/PROJECT_ID/asm-ready/helloserver gcr.io/PROJECT_ID/asm-ready/loadgen
GKE-Cluster erstellen
Sie können diese Container mit dem Befehl docker run
auf der Cloud Shell-VM ausführen. In der Produktion müssen Sie Container
jedoch orchestrieren,
einheitlicher gestalten. Sie benötigen beispielsweise ein System,
das dafür sorgt,
Da Container immer ausgeführt werden,
müssen sie hochskaliert werden,
zusätzliche Instanzen eines Containers, um Traffic-Anstiege zu bewältigen.
Sie können GKE verwenden, um Containeranwendungen auszuführen. GKE ist eine Plattform zur Containerorchestrierung, die VMs mit einem Cluster verbindet. Jede VM wird als Knoten bezeichnet. GKE-Cluster basieren auf dem Open-Source-Clusterverwaltungssystem Kubernetes. Kubernetes umfasst Mechanismen, die eine Interaktion mit Ihrem Cluster ermöglichen.
So erstellen Sie einen GKE-Cluster:
Erstellen Sie den Cluster:
gcloud container clusters create asm-ready \ --cluster-version latest \ --machine-type=n1-standard-4 \ --num-nodes 4
Der Befehl
gcloud
erstellt einen Cluster im Google Cloud-Projekt und -Zone, die Sie zuvor festgelegt haben. Zur Ausführung von Cloud Service Mesh empfehlen wir mindestens vier Knoten und den Maschinentyp n1-standard-4.Der Befehl zum Erstellen des Clusters dauert einige Minuten. Wenn der Cluster bereit ist, gibt der Befehl eine Meldung wie diese aus:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS asm-ready us-central1-b 1.13.5-gke.10 203.0.113.1 n1-standard-2 1.13.5-gke.10 4 RUNNING
Geben Sie Anmeldedaten für das
kubectl
-Befehlszeilentool an, damit Sie es zum Verwalten des Clusters verwenden können:gcloud container clusters get-credentials asm-ready
Sie können jetzt
kubectl
für die Kommunikation mit Kubernetes verwenden. Führen Sie beispielsweise den folgenden Befehl aus, um den Status der Knoten abzurufen:kubectl get nodes
Der Befehl antwortet mit einer Liste der Knoten, die etwa so aussieht:
NAME STATUS ROLES AGE VERSION gke-asm-ready-default-pool-dbeb23dc-1vg0 Ready <none> 99s v1.13.6-gke.13 gke-asm-ready-default-pool-dbeb23dc-36z5 Ready <none> 100s v1.13.6-gke.13 gke-asm-ready-default-pool-dbeb23dc-fj7s Ready <none> 99s v1.13.6-gke.13 gke-asm-ready-default-pool-dbeb23dc-wbjw Ready <none> 99s v1.13.6-gke.13
Grundlegende Kubernetes-Konzepte verstehen
Das folgende Diagramm zeigt die in GKE ausgeführte Anwendung:
Bevor Sie die Container in GKE bereitstellen, sollten Sie sich mit einigen wichtigen Kubernetes-Konzepten vertraut machen. Am Ende dieser Anleitung finden Sie Links zu den einzelnen Konzepten.
Knoten und Cluster: In GKE ist ein Knoten eine VM. Auf anderen Kubernetes-Plattformen kann ein Knoten entweder eine physische oder eine virtuelle Maschine sein. Ein Cluster ist ein Satz von Knoten, die als ein einzelner Computer behandelt werden können, auf dem Sie eine Containeranwendung bereitstellen.
Pods: In Kubernetes werden Container in einem Pod ausgeführt. Ein Pod ist die atomare Einheit in Kubernetes. Ein Pod enthält einen oder mehrere Container. Die Container
server
undloadgen
stellen Sie jeweils in einem eigenen Pod bereit. Wenn ein Pod mehrere Container ausführt (z. B. einen Anwendungsserver und einen Proxyserver), werden die Container als eine Einheit verwaltet und teilen die Ressourcen des Pods.Deployments: Ein Deployment ist ein Kubernetes-Objekt, das eine Gruppe identischer Pods darstellt. Ein Deployment führt mehrere Replikate der Pods aus, die auf die Knoten eines Clusters verteilt sind. Ein Deployment ersetzt automatisch alle Pods, die fehlschlagen oder nicht mehr reagieren.
Kubernetes-Service: Wenn Sie den Anwendungscode in GKE ausführen, wird das Netzwerk zwischen
loadgen
undserver
geändert. Wenn Sie die Services in einer Cloud Shell-VM ausgeführt haben, können Sie Anfragen an dieserver
mit der Adresselocalhost:8080
senden. Nach der Bereitstellung in GKE die Pods so geplant, dass sie auf den verfügbaren Knoten ausgeführt werden. Standardmäßig können Sie Folgendes nicht steuern, auf welchem Knoten der Pod ausgeführt wird. Pods enthalten nicht und stabile IP-Adressen.Zum Abrufen einer IP-Adresse für den
server
müssen Sie eine Netzwerkabstraktion auf den Pods definieren, die als Kubernetes-Service bezeichnet wird. Ein Kubernetes-Service stellt einen stabilen Netzwerkendpunkt für eine Reihe von Pods bereit. Es gibt mehrere Service-Typen. Derserver
verwendet einenLoadBalancer
, der eine externe IP-Adresse bereitstellt, sodass Sieserver
außerhalb des Clusters erreichen können.Kubernetes umfasst auch ein integriertes DNS-System, das Services DNS-Namen (z. B.
helloserver.default.cluster.local
) zuweist. Dadurch können Pods im Cluster andere Pods im Cluster mit einer stabilen Adresse erreichen. Sie können diesen DNS-Namen nicht außerhalb des Clusters verwenden, z. B. in Cloud Shell.
Kubernetes-Manifeste
Als Sie die Anwendung aus dem Quellcode ausgeführt haben, haben Sie einen imperativen Befehl verwendet: python3 server.py
Imperativ bedeutet in Verbform: „Tun Sie dies.“
Im Gegensatz dazu verwendet Kubernetes ein deklaratives Modell. Das bedeutet, dass Sie Kubernetes nicht genau mitteilen müssen, was zu tun ist, sondern Kubernetes einen gewünschten Status zuweisen. Beispielsweise werden Pods bei Kubernetes nach Bedarf gestartet und beendet, sodass der tatsächliche Systemstatus dem gewünschten Zustand entspricht.
Sie geben den gewünschten Status in einer Reihe von Manifesten oder YAML-Dateien an. Eine YAML-Datei enthält die Spezifikation für ein oder mehrere Kubernetes-Objekte.
Das Beispiel enthält eine YAML-Datei für server
und loadgen
. Jede YAML-Datei gibt den gewünschten Status für das Kubernetes-Deployment-Objekt und den Kubernetes-Service an.
Server
kind
gibt den Typ des Objekts an.metadata.name
gibt den Namen des Deployments an.- Das erste
spec
-Feld enthält eine Beschreibung des gewünschten Status. spec.replicas
gibt die Anzahl der gewünschten Pods an.- Im Abschnitt
spec.template
wird eine Pod-Vorlage definiert. In der Spezifikation für die Pods ist das Feldimage
enthalten. Dies ist der Name des Images, das aus Container Registry abgerufen werden soll.
Der Service ist folgendermaßen definiert:
LoadBalancer
: Clients senden Anfragen an die IP-Adresse eines Netzwerk-Load-Balancers, der eine stabile IP-Adresse hat und außerhalb des Clusters erreichbar ist.targetPort
: Beachten Sie, dass der BefehlEXPOSE 8080
imDockerfile
keine Ports tatsächlich verfügbar macht. Sie stellen Port8080
bereit, damit Sie denserver
-Container außerhalb des Clusters erreichen können. In diesem Fall wirdhellosvc.default.cluster.local:80
(Kurzname:hellosvc
) dem Port8080
derhelloserver
-Pod-IP zugeordnet.port
: Dies ist die Portnummer, die andere Services im Cluster beim Senden von Anfragen verwenden.
Load-Generator
Das Deployment-Objekt in loadgen.yaml
entspricht in etwa server.yaml
. Ein großer Unterschied besteht darin, dass das Deployment-Objekt einen Abschnitt mit dem Namen env
enthält. In diesem Abschnitt werden die Umgebungsvariablen loadgen
definiert, die Sie zuvor festgelegt haben, als Sie die Anwendung aus der Quelle ausgeführt haben.
Da loadgen
keine eingehenden Anfragen akzeptiert, ist das Feld type
auf ClusterIP
gesetzt. Dieser Typ bietet eine stabile IP-Adresse, die von Services im Cluster verwendet werden kann. Die IP-Adresse wird jedoch externen Clients nicht angezeigt.
Container in GKE bereitstellen
Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel
server
befindet:cd YOUR_WORKING_DIRECTORY/anthos-service-mesh-samples/docs/helloserver/server/
Öffnen Sie
server.yaml
in einem Texteditor.Ersetzen Sie den Namen im Feld
image
durch den Namen des Docker-Images.image: gcr.io/PROJECT_ID/asm-ready/helloserver:v0.0.1
Ersetzen Sie
PROJECT_ID
durch Ihre Google Cloud-Projekt-ID.Speichern und schließen Sie
server.yaml
.Stellen Sie die YAML-Datei in Kubernetes bereit:
kubectl apply -f server.yaml
Bei Erfolg gibt der Befehl Folgendes zurück:
deployment.apps/helloserver created service/hellosvc created
Wechseln Sie zu dem Verzeichnis, in dem sich
loadgen
befindet.cd ../loadgen
Öffnen Sie
loadgen.yaml
in einem Texteditor.Ersetzen Sie den Namen im Feld
image
durch den Namen des Docker-Images.image: gcr.io/PROJECT_ID/asm-ready/loadgen:v0.0.1
Ersetzen Sie
PROJECT_ID
durch Ihre Google Cloud-Projekt-ID.Speichern Sie die Datei
loadgen.yaml
und schließen Sie den Texteditor.Stellen Sie die YAML-Datei in Kubernetes bereit:
kubectl apply -f loadgen.yaml
Bei Erfolg gibt der Befehl Folgendes zurück:
deployment.apps/loadgenerator created service/loadgensvc created
Prüfen Sie den Status der Pods:
kubectl get pods
Der Befehl antwortet mit einem Status wie diesem:
NAME READY STATUS RESTARTS AGE helloserver-69b9576d96-mwtcj 1/1 Running 0 58s loadgenerator-774dbc46fb-gpbrz 1/1 Running 0 57s
Rufen Sie die Anwendungslogs aus dem Pod
loadgen
ab. Ersetzen SiePOD_ID
durch die ID aus der vorherigen Ausgabe.kubectl logs loadgenerator-POD_ID
Rufen Sie die externen IP-Adressen von
hellosvc
ab:kubectl get service
Die Befehlsausgabe sieht in etwa so aus:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hellosvc LoadBalancer 10.81.15.158 192.0.2.1 80:31127/TCP 33m kubernetes ClusterIP 10.81.0.1 <none> 443/TCP 93m loadgensvc ClusterIP 10.81.15.155 <none> 80/TCP 4m52s
Senden Sie eine Anfrage an
hellosvc
. Ersetzen SieEXTERNAL_IP
durch die externe IP-Adresse Ihrerhellosvc
:curl http://EXTERNAL_IP
Bereit für Cloud Service Mesh
Die Anwendung ist jetzt in GKE bereitgestellt. loadgen
verwendet Kubernetes-DNS (hellosvc:80
), um Anfragen an den server
zu senden. Ebenfalls können Sie Anfragen an server
mit einer externen IP-Adresse senden. Kubernetes bietet zwar viele Features, doch fehlen einige Informationen zu den Services:
- Wie interagieren die Services? Wie ist die Beziehung zwischen den Services? Wie funktioniert der Traffic zwischen den Services? Sie wissen, dass
loadgen
Anfragen anserver
sendet, aber stellen Sie sich vor, dass Sie mit der Anwendung nicht vertraut sind. All diese Fragen lassen sich nicht mit einem Blick auf die Liste der ausgeführten Pods in GKE beantworten. - Messwerte: Wie lange dauert es, bis der
server
auf eingehende Anfragen antwortet? Wie viele Anfragen pro Sekunde (RPS) gehen anserver
ein? Gibt es Fehlerantworten? - Sicherheitsinformationen: Ist der Traffic zwischen
loadgen
und demserver
Nur-HTTP
oder mTLS?
Cloud Service Mesh kann Ihnen Antworten auf diese Fragen geben. Cloud Service Mesh ist eine von Google Cloud verwaltete Version des Open-Source-Projekts Istio. Beim Cloud Service Mesh wird ein
Envoy-Sidecar-Proxy in jedem Pod Der Envoy-Proxy fängt den gesamten ein- und ausgehenden Traffic an die Anwendungscontainer ab. Das bedeutet, dass server
und loadgen
jeweils einen Envoy-Sidecar-Proxy erhalten und der gesamte Traffic von loadgen
zu server
über die Envoy-Proxys läuft. Die Verbindungen zwischen diesen Envoy-Proxys bilden das Service Mesh. Diese Service Mesh-Architektur bietet eine Steuerungsebene über Kubernetes.
Da die Envoy-Proxys in ihren eigenen Containern ausgeführt werden, können Sie Cloud Service Mesh auf ohne wesentliche Änderungen an Ihrem GKE-Cluster, Anwendungscode. Es gibt jedoch einige wichtige Methoden, mit denen Sie die Anwendung, die mit Cloud Service Mesh instrumentiert werden soll:
- Services für alle Container: Die Deployments
server
undloadgen
sind mit einem Kubernetes-Service verknüpft. Selbstloadgen
, das keine eingehenden Anfragen empfängt, hat einen Service. - Ports in Diensten müssen benannt werden. Mit GKE können Sie
unbenannte Dienstports definieren, müssen Sie für Cloud Service Mesh einen
Name für einen Anschluss
das mit dem Protokoll des Ports übereinstimmt. In der YAML-Datei heißt der Port für
server
http
, daserver
das KommunikationsprotokollHTTP
verwendet. Hätteservice
gRPC
verwendet, würden Sie den Portgrpc
nennen. - Bereitstellungen sind mit Labels versehen: Dies ermöglicht Ihnen die Verwendung der Traffic-Management-Funktionen von Cloud Service Mesh, z. B. zum Aufteilen des Traffics zwischen Versionen desselben Service.
Cloud Service Mesh installieren.
Rufen Sie die Installationsanleitung für Cloud Service Mesh auf und folgen Sie der Anleitung zur Installation von Cloud Service Mesh in Ihrem Cluster.
Bereinigen
Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.
Löschen Sie zum Bereinigen den GKE-Cluster. Durch das Löschen des Clusters werden alle Ressourcen des Containerclusters gelöscht, darunter Compute-Instanzen, Laufwerke und Netzwerkressourcen.
gcloud container clusters delete asm-ready
Weitere Informationen
Weitere Informationen zu den in dieser Anleitung verwendeten Technologien:
Weitere Informationen zu den Tools:
Weitere Informationen zu Kubernetes-Konzepten: