Mehrstufige Webanwendung mit Redis und PHP erstellen

Autopilot Standard

---

In dieser Anleitung wird gezeigt, wie Sie mithilfe von Google Kubernetes Engine (GKE) eine mehrstufige Webanwendung erstellen.

In dieser Anleitung tun Sie Folgendes:

• Richten Sie eine Webanwendung mit einer externen IP-Adresse und einem Load Balancer ein.
• Erstellen Sie einen Redis mit einem einzelnen Master (Leader) und mehreren Replikaten (Follower).

Im Beispiel werden die folgenden Kubernetes-Konzepte beschrieben:

• Deklarative Konfiguration mithilfe von YAML-Manifestdateien
• Deployments, also Kubernetes-Ressourcen, die die Konfiguration eines Sets von replizierten Pods festlegen
• Services zum Erstellen interner und externer Load-Balancer für ein Set von Pods

Ziele

So stellen Sie die Anwendung auf GKE bereit und führen sie aus:

1. Redis-Leader einrichten
2. Redis-Follower einrichten
3. Web-Frontend einrichten
4. Zur Website
5. Web-Frontend skalieren

Das folgende Diagramm bietet einen Überblick über die Clusterarchitektur, die Sie durch Erfüllen dieser Ziele erstellen:

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

• GKE

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl und gcloud CLI. Wenn Sie Cloud Shell nicht verwenden, müssen Sie die gcloud CLI installieren.

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Make sure that billing is enabled for your Google Cloud project.

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

10. Make sure that billing is enabled for your Google Cloud project.

11. Enable the GKE API:

    gcloud services enable container.googleapis.com

Umgebung vorbereiten

So richten Sie Ihre Umgebung ein:

1. Legen Sie Umgebungsvariablen fest:

   export PROJECT_ID=PROJECT_ID
   export COMPUTE_LOCATION=COMPUTE_LOCATION
   

   Ersetzen Sie Folgendes:

   • PROJECT_ID: Ihre Google Cloud-Projekt-ID
   • COMPUTE_LOCATION: ein Compute Engine-Standort, z. B. us-central1.

2. Klonen Sie das GitHub-Repository:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

3. Wechseln Sie in das Arbeitsverzeichnis:

   cd kubernetes-engine-samples/quickstarts/guestbook/
   

GKE-Cluster erstellen

Autopilot- oder Standard-GKE-Cluster erstellen:

Autopilot

gcloud container clusters create-auto guestbook \
    --location=${COMPUTE_LOCATION} \

Standard

gcloud container clusters create guestbook \
    --location=${COMPUTE_LOCATION} \
    --num-nodes=4

Mit dem Cluster verbinden

Konfigurieren Sie kubectl für die Kommunikation mit dem Cluster:

gcloud container clusters get-credentials guestbook \
    --location=${COMPUTE_LOCATION}

Redis-Leader einrichten

Die Anwendung nutzt Redis zur Datenspeicherung. Die Anwendung schreibt Daten auf eine Redis-Leader-Instanz und verwendet mehrere Redis-Follower-Instanzen zum Lesen von Daten.

1. Das folgende Manifest beschreibt ein Kubernetes-Deployment, das ein Einzel-Replikat-Redis-Leader-Pod ausführt:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: leader
           tier: backend
       spec:
         containers:
         - name: leader
           image: "docker.io/redis:6.0.5"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

   Wenden Sie das Manifest auf Ihren Cluster an:

   kubectl apply -f redis-leader-deployment.yaml
   

2. Prüfen Sie, ob der Redis-Leader-Pod ausgeführt wird:

   kubectl get pods
   

   Die Ausgabe sieht in etwa so aus:

   NAME                           READY     STATUS    RESTARTS   AGE
   redis-leader-343230949-qfvrq   1/1       Running   0          43s
   

   Es kann einige Minuten dauern, bis STATUS von Pending in Running geändert wird.

Redis-Leader-Service erstellen

Die Webanwendung muss mit dem Redis-Leader kommunizieren, um die Daten zu schreiben. Sie können einen Service erstellen, um den Traffic an den Redis-Leader-Pod weiterzuleiten.

Ein Dienst ist eine Kubernetes-Abstraktion, die ein logisches Set von Pods und eine Richtlinie für den Zugriff auf die Pods definiert. Wenn Sie einen Dienst erstellen, geben Sie auf der Grundlage von Pod-Labels an, welche Pods weitergeleitet werden sollen.

1. Das folgende Manifest beschreibt einen Dienst für den Redis-Leader:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     ports:
     - port: 6379
       targetPort: 6379
     selector:
       app: redis
       role: leader
       tier: backend

   Dieses Manifest enthält eine Reihe von Labelauswahlen. Diese Label entsprechen jenen, die im letzten Schritt bereitgestellt wurden. Deshalb leitet dieser Dienst den Netzwerktraffic an den Redis-Leader-Pod weiter, der in einem vorherigen Schritt erstellt wurde.

   Im Abschnitt ports des Manifests wird eine einzelne Portzuordnung deklariert. Der Dienst leitet den Traffic über port: 6379 zum targetPort: 6379 der Container weiter, die den spezifizierten selector-Labels entsprechen. Der im Deployment verwendete containerPort muss dem targetPort entsprechen, damit der Traffic an das Deployment weitergeleitet werden kann.

   Wenden Sie das Manifest auf Ihren Cluster an:

   kubectl apply -f redis-leader-service.yaml
   

2. Prüfen Sie, ob GKE den Dienst erstellt hat:

   kubectl get service
   

   Die Ausgabe sieht in etwa so aus:

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    42s
   redis-leader   10.51.242.233   <none>        6379/TCP   12s
   

Redis-Follower einrichten

Auch wenn es sich beim Redis-Leader um einen einzelnen Pod handelt, können Sie ihn durch das Hinzufügen einiger Redis-Follower oder -Replikate hochverfügbar machen und damit so anpassen, dass er den Traffic bewältigt.

1. Das folgende Manifest beschreibt ein Deployment für die Redis-Follower-Pods:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: follower
           tier: backend
       spec:
         containers:
         - name: follower
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-redis-follower:v2
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

2. Wenden Sie das Manifest auf Ihren Cluster an:

   kubectl apply -f redis-follower-deployment.yaml
   

3. Prüfen Sie, ob die beiden Redis-Follower-Replikate ausgeführt werden:

   kubectl get pods
   

   Die Ausgabe sieht in etwa so aus:

   NAME                              READY   STATUS    RESTARTS   AGE
   redis-follower-76588f55b7-bnsq6   1/1     Running   0          27s
   redis-follower-76588f55b7-qvtws   1/1     Running   0          27s
   redis-leader-dd446dc55-kl7nl      1/1     Running   0          119s
   

   Es kann einige Minuten dauern, bis STATUS von Pending in Running geändert wird.

Redis-Follower-Service erstellen

Die Webanwendung muss mit den Redis-Followern kommunizieren, um Daten zu lesen. Damit die Redis-Follower gefunden werden können, müssen Sie einen weiteren Service einrichten.

1. Das folgende Manifest beschreibt einen Dienst für den Redis-Follower:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     ports:
       # the port that this service should serve on
     - port: 6379
     selector:
       app: redis
       role: follower
       tier: backend

   In diesem Manifest wird angegeben, dass der Dienst auf Port 6379 ausgeführt wird. Das Feld selector des Service muss den Redis-Follower-Pods entsprechen, die im vorherigen Schritt erstellt wurden.

   Wenden Sie das Manifest auf Ihren Cluster an:

   kubectl apply -f redis-follower-service.yaml
   

2. Prüfen Sie, ob GKE den Dienst erstellt hat:

   kubectl get service
   

   Die Ausgabe sieht in etwa so aus:

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    1m
   redis-leader   10.51.242.233   <none>        6379/TCP   49s
   redis-follower 10.51.247.238   <none>        6379/TCP   3s
   

Web-Frontend der Anwendung einrichten

Da Sie nun den Redis-Speicher für Ihre Anwendung haben, können Sie die Webserver starten. Wie bei den Redis-Follower wird das Frontend mithilfe eines Kubernetes-Deployments bereitgestellt.

Die Webanwendung verwendet ein PHP-Frontend, das so konfiguriert ist, dass es entweder mit den Redis-Follower- oder den Redis-Leader-Diensten kommuniziert, je nachdem, ob es sich um eine Lese- oder Schreibanfrage handelt. Das Frontend stellt eine JSON-Schnittstelle bereit und bietet eine jQuery-Ajax-basierte UX.

1. Das folgende Manifest beschreibt ein Deployment für den Webserver:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontend
   spec:
     replicas: 3
     selector:
       matchLabels:
           app: guestbook
           tier: frontend
     template:
       metadata:
         labels:
           app: guestbook
           tier: frontend
       spec:
         containers:
         - name: php-redis
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-frontend:v5
           env:
           - name: GET_HOSTS_FROM
             value: "dns"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 80

   In der Manifestdatei wird die Umgebungsvariable GET_HOSTS_FROM=dns angegeben. Wenn Sie die Konfiguration für die Web-Frontend-Anwendung bereitstellen, verwendet die Frontend-Anwendung die Hostnamen redis-follower und redis-leader, um einen DNS-Lookup durchzuführen. Der DNS-Lookup ermittelt die IP-Adressen der Services, die Sie in den vorherigen Schritten erstellt haben. Dieses Konzept heißt DNS-Diensterkennung.

   Wenden Sie das Manifest auf Ihren Cluster an:

   kubectl apply -f frontend-deployment.yaml
   

2. Prüfen Sie, ob die Replikate ausgeführt werden:

   kubectl get pods -l app=guestbook -l tier=frontend
   

   Die Ausgabe sieht in etwa so aus:

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-7b78458576-8kp8s   1/1     Running   0          37s
   frontend-7b78458576-gg86q   1/1     Running   0          37s
   frontend-7b78458576-hz87g   1/1     Running   0          37s
   

Frontend über eine externe IP-Adresse bereitstellen

In der aktuellen Konfiguration sind die Services redis-follower und redis-leader, die Sie in den vorherigen Schritten erstellt haben, nur im GKE-Cluster zugänglich, da der Standardtyp für einen Dienst ClusterIP ist.

Ein ClusterIP-Service stellt eine einzige IP-Adresse für das Set von Pods bereit, auf das der Service verweist. Diese IP-Adresse ist nur innerhalb des Clusters zugänglich.

Um den Web-Frontend-Dienst extern zugänglich zu machen, können Sie je nach Ihren Anforderungen in der Dienstkonfiguration type: LoadBalancer oder type: NodePort angeben.

Das folgende Manifest beschreibt einen Service vom Typ LoadBalancer.

apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  type: LoadBalancer
  ports:
    # the port that this service should serve on
  - port: 80
  selector:
    app: guestbook
    tier: frontend

In der Portdeklaration im Abschnitt ports ist port: 80 spezifiziert und targetPort ist nicht spezifiziert. Wenn Sie die Eigenschaft targetPort weglassen, wird standardmäßig der Wert im Feld port verwendet. In diesem Fall leitet der Service den externen Traffic über Port 80 an Port 80 der Container im frontend-Deployment weiter.

Wenden Sie das Manifest auf Ihren Cluster an:

kubectl apply -f frontend-service.yaml

Beim Erstellen des Service frontend generiert GKE einen Load-Balancer und eine externe IP-Adresse. Diese Ressourcen werden abgerechnet.

Website der Anwendung aufrufen

Rufen Sie die externe IP-Adresse des frontend-Dienstes ab, um auf die Anwendungswebsite zuzugreifen:

kubectl get service frontend

Die Ausgabe sieht in etwa so aus:

NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
frontend   10.51.242.136   109.197.92.229     80:32372/TCP   1m

In der Spalte EXTERNAL-IP kann <pending> angezeigt werden, während der Load Balancer erstellt wird. Dieser Vorgang kann einige Minuten dauern. Wenn Fehler wie Does not have minimum availability angezeigt werden, warten Sie einige Minuten. Dieser temporäre Fehler tritt auf, weil GKE die Knoten neu erstellt, um die Änderungen vorzunehmen.

Kopieren Sie die IP-Adresse und öffnen Sie die Seite in Ihrem Browser:

Schreiben Sie Einträge durch Eingabe einer Nachricht und klicken Sie auf Senden. Die eingegebene Nachricht wird im Frontend angezeigt. Dies weist darauf hin, dass Daten über die von Ihnen erstellten Services erfolgreich zu Redis hinzugefügt wurden.

Web-Frontend skalieren

Stellen Sie sich vor, Ihre Anwendung läuft schon eine Weile und erfährt einen plötzlichen Popularitätsschub. Sie entschließen sich dazu, weitere Webserver Ihrem Frontend hinzuzufügen. Dazu können Sie die Anzahl der Pods erhöhen.

1. Skalieren Sie die Anzahl der frontend-Pods:

   kubectl scale deployment frontend --replicas=5
   

   Die Ausgabe sieht in etwa so aus:

   deployment.extensions/frontend scaled
   

2. Prüfen Sie die Anzahl der ausgeführten Replikate:

   kubectl get pods
   

   Die Ausgabe sieht in etwa so aus:

   NAME                             READY     STATUS    RESTARTS   AGE
   frontend-88237173-3s3sc          1/1       Running   0          1s
   frontend-88237173-twgvn          1/1       Running   0          1s
   frontend-88237173-5p257          1/1       Running   0          23m
   frontend-88237173-84036          1/1       Running   0          23m
   frontend-88237173-j3rvr          1/1       Running   0          23m
   redis-leader-343230949-qfvrq     1/1       Running   0          54m
   redis-follower-132015689-dp23k   1/1       Running   0          37m
   redis-follower-132015689-xq9v0   1/1       Running   0          37m
   

   Sie können mit diesem Befehl die Anzahl der frontend-Pods auch herunterskalieren. Ersetzen Sie dazu 5 durch 1.

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.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Einzelne Ressourcen löschen

Wenn Sie ein vorhandenes Projekt verwendet haben und es nicht löschen möchten, können Sie die einzelnen Ressourcen löschen.

1. So löschen Sie den Dienst frontend:

   kubectl delete service frontend
   

2. Löschen Sie den GKE-Cluster:

   gcloud container clusters delete guestbook
   

Nächste Schritte

• Informationen zur Konfiguration des horizontalen Pod-Autoscaling
• WordPress auf GKE mit Persistent Disk und Cloud SQL bereitstellen
• Domainnamen mit statischen IP-Adressen konfigurieren
• Weitere Kubernetes-Anleitungen