Mehrstufige Webanwendung mit Redis und PHP erstellen


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:

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:

GKE-Clusterarchitektur

Kosten

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

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
  4. Create or select a Google Cloud 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. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  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
  9. Create or select a Google Cloud 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. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  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:

  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:

Webanwendung, die in GKE ausgeführt wird

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

    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