Einführung in Container

Beispielcode herunterladen

1. Laden Sie den Quellcode helloserver herunter:

   git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-samples
   

2. Ö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“ in das Terminalfenster ausgibt.
• loadgen: Ein Skript, das Traffic an server mit einer konfigurierbaren Anzahl von Anfragen pro Sekunde (RPS) sendet.

Anwendung aus der Quelle ausführen

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

1. 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...
   

2. Öffnen Sie ein anderes Terminalfenster, damit Sie Anfragen an server senden können. Klicken Sie dazu in Cloud Shell auf add Neuen Tab öffnen, um eine weitere Sitzung zu öffnen.

3. Senden Sie im neuen Terminalfenster eine Anfrage an server:

   curl http://localhost:8080
   

   Die Ausgabe von server sieht so aus:

   Hello World!
   

4. Wechseln Sie auf demselben Tab in das Verzeichnis, das das loadgen-Skript enthält:

   cd anthos-service-mesh-samples/docs/helloserver/loadgen

5. Erstellen Sie die folgenden Umgebungsvariablen:

   export SERVER_ADDR=http://localhost:8080
   export REQUESTS_PER_SECOND=5
   

6. Starten Sie virtualenv:

   virtualenv --python python3 env
   

7. Aktivieren Sie die virtuelle Umgebung:

   source env/bin/activate
   

8. Installieren Sie die Anforderungen für loadgen:

   pip3 install -r requirements.txt
   

9. 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 etwa so aus:

   Starting loadgen: 2024-10-11 09:49:51.798028
   5 request(s) complete to http://localhost:8080
   

10. Öffnen Sie nun 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.

11. Zum Beenden von loadgen und server drücken Sie in jedem Terminalfenster Ctrl-c.

12. 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.13-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 Einrichtungsschritte für die Tools und Dienste ausführen, die Sie verwenden möchten:

1. Legen Sie das Standardprojekt für die Google Cloud CLI fest. Trusted Cloud

   gcloud config set project PROJECT_ID

2. 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:

1. Achten Sie darauf, dass der Artifact Registry-Dienst in IhremTrusted Cloud -Projekt aktiviert ist.

   gcloud services enable artifactregistry.googleapis.com
   
   

2. Erstellen Sie das Artifact Registry-Repository:

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

3. 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:

1. Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel server befindet:

   cd ~/anthos-service-mesh-samples/docs/helloserver/server/

2. 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 Projekts. Trusted Cloud by S3NS

   Das Flag -t steht für das Docker-Tag. Dies ist der Name des Images, das Sie bei der Bereitstellung des Containers verwenden.

3. Ü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:

1. Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel loadgen befindet:

   cd ../loadgen
   

2. Erstellen Sie das Image:

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

3. Ü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:

1. Erstellen Sie den Cluster:

   gcloud container clusters create-auto container-intro
   

   Mit dem Befehl gcloud wird im Standardprojekt Trusted 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
   

2. 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:

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.

Load-Generator

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

1. Wechseln Sie zu dem Verzeichnis, in dem sich das Beispiel server befindet:

   cd ~/anthos-service-mesh-samples/docs/helloserver/server/

2. Öffnen Sie server.yaml im Cloud Shell-Editor (oder in Ihrem bevorzugten Texteditor).

3. 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 PROJECT_ID durch Ihre Trusted Cloud Projekt-ID.

   • 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.

4. 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

1. Wechseln Sie zu dem Verzeichnis, in dem sich loadgen befindet.

   cd ../loadgen
   

2. Öffnen Sie loadgen.yaml wie zuvor in einem Texteditor.

3. 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 PROJECT_ID durch Ihre Trusted Cloud Projekt-ID.

   • 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.

4. 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:

1. 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
   

2. 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
   

3. Rufen Sie die externen IP-Adressen von hellosvc ab:

   kubectl get service hellosvc
   

   Die Ausgabe sieht 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
   

4. Senden Sie eine Anfrage an hellosvc. Ersetzen Sie EXTERNAL_IP durch die externe IP-Adresse Ihrer hellosvc.

   curl http://EXTERNAL_IP
   

   Jetzt sollten Sie die Meldung „Hello World!“ vom Server sehen.