Diese Seite wurde von der Cloud Translation API übersetzt.

Einführung in Container

Wenn Sie mit containerisierten Arbeitslasten noch nicht vertraut sind, ist diese Anleitung genau das Richtige für Sie. Sie lernen Container und die Containerorchestrierung kennen, indem Sie eine einfache Anwendung vom Quellcode bis hin zu einem Container einrichten, der in GKE ausgeführt wird.

Für diese Anleitung sind keine Vorkenntnisse zu Containern oder Kubernetes erforderlich. Wenn Sie jedoch vor Beginn dieses Tutorials eine Übersicht über die wichtigsten Kubernetes-Begriffe lesen möchten, sehen Sie sich Kubernetes lernen an. Wenn Sie Kubernetes lieber in Comicform kennenlernen möchten, sehen Sie sich unseren Kubernetes-Comic an. Detailliertere Ressourcen finden Sie am Ende des Tutorials im Abschnitt Weitere Informationen.

Wenn Sie bereits mit Containern und Kubernetes vertraut sind, können Sie dieses Tutorial überspringen und direkt mit GKE beginnen.

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. Sie besteht aus den folgenden Komponenten, die mit REST kommunizieren:

server: Ein einfacher Server mit einem GET-Endpunkt (/), der „Hello World“ an das Terminalfenster ausgibt.
loadgen: Ein Skript, das Traffic an server mit einer konfigurierbaren Anzahl von Anfragen pro Sekunde (RPS) sendet.

Beispielanwendung

Anwendung aus der Quelle ausführen

Um sich mit der Beispielanwendung vertraut zu machen, führen Sie sie in Cloud Shell aus:

Führen Sie im Verzeichnis sample-apps/helloserver den Befehl server 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 dazu in Cloud Shell auf Neuen Tab öffnen, um eine weitere Sitzung zu öffnen.
Senden Sie im neuen Terminalfenster eine Anfrage an server:
```
curl http://localhost:8080
```
Die Ausgabe von server sieht so aus:
```
Hello World!
```
Wechseln Sie auf demselben Tab in das Verzeichnis, das das loadgen-Skript enthält:
```
cd 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 die Anwendung loadgen aus, um Traffic für die server zu generieren:
```
python3 loadgen.py
```
Beim Start sieht die Ausgabe von loadgen in etwa so aus:
```
Starting loadgen: 2024-10-11 09:49:51.798028
5 request(s) complete to http://localhost:8080
```
Öffnen Sie jetzt das Terminalfenster, in dem server ausgeführt wird. Es sollten Meldungen ähnlich den folgenden angezeigt werden:
```
127.0.0.1 - - [11/Oct/2024 09:51:28] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.32.3
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
```
Aus Netzwerksicht wird die gesamte Anwendung jetzt auf demselben Host ausgeführt. So können Sie localhost verwenden, um Anfragen an server zu senden.
Zum Beenden von loadgen und server drücken Sie in jedem Terminalfenster Ctrl-c.
Deaktivieren Sie im Terminalfenster loadgen die virtuelle Umgebung:
```
deactivate
```

Anwendung containerisieren

Um die Anwendung in GKE auszuführen, müssen Sie beide Komponenten der Beispielanwendung in Container packen. Ein Container ist ein Paket, das alle Elemente enthält, die für die Ausführung Ihrer Anwendung in einer beliebigen Umgebung erforderlich sind. In dieser Anleitung wird Docker verwendet, um die Anwendung in einem Container zu verpacken.

Zum Containerisieren der Anwendung mit Docker 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 Container-Image erforderlich sind. Nachdem Sie das Image erstellt haben, laden Sie es in eine Container Registry wie Artifact Registry hoch.

Der Quellcode für dieses Tutorial enthält ein Dockerfile für server und loadgen mit allen Befehlen, die zum Erstellen der Images erforderlich sind. Im Folgenden finden Sie das Dockerfile für den server:

FROM python:3.14-slim as base
FROM base as builder
RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        g++ \
    && rm -rf /var/lib/apt/lists/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        wget

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.* /usr/local/lib/

# Add the application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

In dieser Datei sehen Sie Folgendes:

Die Anweisung FROM python:3-slim as base weist Docker an, das neueste Python 3-Image als Basis-Image zu verwenden.
Mit der Anweisung COPY . . werden die Quelldateien aus dem aktuellen Arbeitsverzeichnis (in diesem Fall server.py) in das Dateisystem des Containers kopiert.
ENTRYPOINT definiert die Anweisung, die zum Ausführen des Containers verwendet wird. In diesem Beispiel ähnelt die Anleitung der Anleitung, mit der Sie server.py aus dem Quellcode ausgeführt haben.
Die Anweisung EXPOSE gibt an, dass server den Port 8080 überwacht. Mit dieser Anleitung werden keine Ports freigegeben. Sie dient jedoch als Dokumentation, die Sie beim Ausführen des Containers zum Öffnen von Port 8080 benötigen.

Containerisierung der Anwendung vorbereiten

Bevor Sie die Anwendung in einen Container packen, müssen Sie einige Vorbereitungen für die Tools und Dienste treffen, die Sie verwenden möchten:

Legen Sie das Standardprojekt für die Google Cloud CLI fest. Google Cloud
```
gcloud config set project PROJECT_ID
```
Legen Sie die Standardregion für die Google Cloud CLI fest.
```
gcloud config set compute/region us-central1
```

Repository erstellen

So erstellen Sie ein neues Repository für Docker-Container-Images in Artifact Registry:

Achten Sie darauf, dass der Artifact Registry-Dienst in IhremGoogle Cloud -Projekt aktiviert ist.
```
gcloud services enable artifactregistry.googleapis.com
```

Erstellen Sie das Artifact Registry-Repository:

gcloud artifacts repositories create container-intro --repository-format=docker \
    --location=us-central1 \
    --description="My new Docker repository"

Richten Sie die Authentifizierung von Docker bei Artifact Registry mit der Google Cloud CLI ein:
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```

`server` containerisieren

Jetzt ist es an der Zeit, Ihre Anwendung zu containerisieren. Containerisieren Sie zuerst die server-Datei „hello world“ und übertragen Sie das Image per Push an Artifact Registry:

Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel server befindet:
```
cd ~/anthos-service-mesh-samples/docs/helloserver/server/
```
Erstellen Sie das Image mit dem Dockerfile:
```
docker build -t us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1 .
```
- Ersetzen Sie PROJECT_ID durch die ID Ihres Google Cloud Projekts.
Das Flag -t steht für das Docker-Tag. Dies ist der Name des Images, das Sie bei der Bereitstellung des Containers verwenden.

Übertragen Sie das Image per Push an Artifact Registry.

docker push us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1

`loadgen` containerisieren

Containerisieren Sie als Nächstes den Load Generator-Dienst auf dieselbe Weise:

Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel loadgen befindet:
```
cd ../loadgen
```

Erstellen Sie das Image:

docker build -t us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen:v0.0.1 .

Übertragen Sie das Image per Push an Artifact Registry.

docker push us-central1-docker.pkg.dev/PROJECT_ID/container-intro/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 us-central1-docker.pkg.dev/PROJECT_ID/container-intro

In der Ausgabe sollten die Namen der von Ihnen übertragenen Bilder aufgeführt sein, ähnlich wie im Folgenden:

NAME
us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver
us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen

GKE-Cluster erstellen

Jetzt können Sie die Container mit dem Befehl docker run auf der Cloud Shell-VM ausführen. Wenn Sie jedoch zuverlässige Produktionsarbeitslasten ausführen möchten, müssen Sie Container einheitlicher verwalten. Beispielsweise müssen Sie dafür sorgen, dass die Container neu gestartet werden, wenn sie fehlschlagen. Außerdem müssen Sie zusätzliche Instanzen eines Containers horizontal und vertikal installieren können, um Traffic-Spitzen zu bewältigen.

GKE kann Ihnen dabei helfen, diese Anforderungen zu erfüllen. 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 bietet Mechanismen für die Interaktion mit dem Cluster.

Damit Sie die Container in GKE ausführen können, müssen Sie zuerst einen Cluster erstellen und dann eine Verbindung zu ihm herstellen:

Erstellen Sie den Cluster:
```
gcloud container clusters create-auto container-intro
```
Mit dem Befehl gcloud wird im Standardprojekt Google Cloud und in der Standardregion, die Sie zuvor festgelegt haben, ein Cluster erstellt.

Der Befehl zum Erstellen des Clusters dauert einige Minuten. Wenn der Cluster bereit ist, sieht die Ausgabe in etwa so aus:
```
 NAME: container-intro
 LOCATION: us-central1
 MASTER_VERSION: 1.30.4-gke.1348000
 MASTER_IP: 34.44.14.166
 MACHINE_TYPE: e2-small
 NODE_VERSION: 1.30.4-gke.1348000
 NUM_NODES: 3
 STATUS: 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 container-intro
```

Kubernetes-Manifeste untersuchen

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 Datei an, die als Manifest bezeichnet wird. Manifeste werden in Sprachen wie YAML oder JSON geschrieben und enthalten die Spezifikation für ein oder mehrere Kubernetes-Objekte.

Das Beispiel enthält jeweils ein Manifest für server und loadgen. Jedes Manifest gibt den gewünschten Status für das Kubernetes-Deployment-Objekt (das die Ausführung Ihres Containers verwaltet, der als Kubernetes-Pod für die Verwaltung verpackt ist) und den Kubernetes-Service (der eine IP-Adresse für den Pod bereitstellt) an. Ein Pod ist die kleinste bereitstellbare Recheneinheit, die Sie in Kubernetes erstellen und verwalten können. Er enthält einen oder mehrere Container.

Das folgende Diagramm zeigt die in GKE ausgeführte Anwendung:

Containerisierte Anwendung, die in GKE ausgeführt wird

Weitere Informationen zu Pods, Deployments und Services finden Sie unter Kubernetes lernen oder in den Ressourcen am Ende dieser Seite.

Server

Sehen Sie sich zuerst das Manifest für die server-App „Hello World“ an:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloserver
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      containers:
      - image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always
        name: main
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

Dieses Manifest enthält die folgenden Felder:

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 Feld image enthalten. Dies ist der Name des Images, das aus Artifact Registry abgerufen werden soll. Im nächsten Schritt aktualisieren Sie dies auf das neue Bild, das Sie gerade erstellt haben.

Der hellosvc-Dienst ist so definiert:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: helloserver
  type: LoadBalancer

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 Befehl EXPOSE 8080 im Dockerfile keine Ports tatsächlich verfügbar macht. Sie stellen Port 8080 bereit, damit Sie den server-Container außerhalb des Clusters erreichen können. In diesem Fall wird hellosvc.default.cluster.local:80 (Kurzname: hellosvc) dem Port 8080 der helloserver-Pod-IP zugeordnet.
port: Dies ist die Portnummer, die andere Dienste im Cluster beim Senden von Anfragen verwenden.

Lastgenerator

Das Deployment-Objekt in loadgen.yaml entspricht in etwa server.yaml. Ein großer Unterschied besteht darin, dass die Pod-Spezifikation für das loadgen-Deployment ein Feld mit dem Namen env enthält. In diesem Abschnitt werden die Umgebungsvariablen definiert, die von loadgen benötigt werden. Sie haben sie zuvor festgelegt, als Sie die Anwendung aus der Quelle ausgeführt haben.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  replicas: 1
  selector:
    matchLabels:
      app: loadgenerator
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      containers:
      - env:
        - name: SERVER_ADDR
          value: http://hellosvc:80/
        - name: REQUESTS_PER_SECOND
          value: '10'
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        name: main
        resources:
          limits:
            cpu: 500m
            memory: 512Mi
          requests:
            cpu: 300m
            memory: 256Mi
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

Da loadgen keine eingehenden Anfragen akzeptiert, ist das Feld type auf ClusterIP gesetzt. Dieser Diensttyp bietet eine stabile IP-Adresse, die von Entitäten im Cluster verwendet werden kann. Die IP-Adresse wird jedoch externen Clients nicht angezeigt.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: loadgenerator
  type: ClusterIP

Container in GKE bereitstellen

Um die Container bereitzustellen, wenden Sie die Manifeste an, in denen der gewünschte Status angegeben ist. Verwenden Sie dazu kubectl.

`server` bereitstellen

Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel server befindet:
```
cd ~/anthos-service-mesh-samples/docs/helloserver/server/
```
Öffnen Sie server.yaml im Cloud Shell-Editor (oder in Ihrem bevorzugten Texteditor).
Ersetzen Sie den Namen im Feld image durch den Namen des Docker-Images.
```
image: us-central1-docker.pkg.dev/PROJECT_ID/container-intro/helloserver:v0.0.1
```
Ersetzen Sie dabei PROJECT_ID durch die ID Ihres Projekts in Google Cloud .
- Wenn Sie den Cloud Shell-Editor verwenden, wird die Datei automatisch gespeichert. Klicken Sie auf Terminal öffnen, um zum Terminalfenster zurückzukehren.
- Wenn Sie einen Texteditor in Cloud Shell verwenden, speichern Sie server.yaml und schließen Sie die Datei.

Stellen Sie das Manifest in Kubernetes bereit:

kubectl apply -f server.yaml

Die Ausgabe sieht etwa so aus:

deployment.apps/helloserver created
service/hellosvc created

`loadgen` bereitstellen

Wechseln Sie zu dem Verzeichnis, in dem sich loadgen befindet.
```
cd ../loadgen
```
Öffnen Sie loadgen.yaml wie zuvor in einem Texteditor.
Ersetzen Sie den Namen im Feld image wieder durch den Namen Ihres Docker-Images.
```
image: us-central1-docker.pkg.dev/PROJECT_ID/container-intro/loadgen:v0.0.1
```
Ersetzen Sie dabei PROJECT_ID durch die ID Ihres Projekts in Google Cloud .
- Wenn Sie den Cloud Shell-Editor verwenden, wird die Datei automatisch gespeichert. Klicken Sie auf Terminal öffnen, um zum Terminalfenster zurückzukehren.
- Wenn Sie einen Texteditor in Cloud Shell verwenden, speichern Sie loadgen.yaml und schließen Sie die Datei.

Stellen Sie das Manifest in Ihrem Cluster bereit:

kubectl apply -f loadgen.yaml

Bei Erfolg gibt der Befehl Folgendes zurück:

deployment.apps/loadgenerator created
service/loadgensvc created

Bereitstellung prüfen

Nachdem Sie Ihre Manifeste im Cluster bereitgestellt haben, prüfen Sie, ob Ihre Container erfolgreich bereitgestellt wurden:

Prüfen Sie den Status der Pods in Ihrem Cluster:

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 Sie POD_ID durch die Pod-ID des Load-Generators aus der vorherigen Ausgabe.
```
kubectl logs POD_ID
```

Rufen Sie die externen IP-Adressen von hellosvc ab:

kubectl get service hellosvc