Crea un'applicazione web multi-livello con Redis e PHP

Autopilot Standard

---

Questo tutorial illustra come creare un'applicazione web multi-livello utilizzando Google Kubernetes Engine (GKE).

In questo tutorial imparerai a:

• Configura un'applicazione web con un indirizzo IP esterno e un bilanciatore del carico.
• Crea un cluster Redis con un singolo master (leader) e più repliche (follower).

L'esempio descrive i seguenti concetti di base di Kubernetes:

• Configurazione dichiarativa con file manifest YAML
• Deployment, che sono risorse Kubernetes che determinano la configurazione per un insieme di pod replicati
• Servizi per creare bilanciatori del carico interni ed esterni per un insieme di pod

Obiettivi

Per eseguire il deployment e l'esecuzione dell'applicazione su GKE:

1. Configura il leader Redis
2. configura due follower Redis
3. Configura il frontend web
4. Visita il sito web
5. Fai lo scale up del frontend web

Il seguente diagramma mostra una panoramica dell'architettura del cluster creata completando questi obiettivi:

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

• GKE

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Cloud Shell include il software necessario per questo tutorial, tra cui kubectl e gcloud CLI. Se non utilizzi Cloud Shell, devi installare gcloud CLI.

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

Prepara l'ambiente

Per configurare l'ambiente:

1. Imposta le variabili di ambiente:

   export PROJECT_ID=PROJECT_ID
   export COMPUTE_LOCATION=COMPUTE_LOCATION
   

   Sostituisci quanto segue:

   • PROJECT_ID: il tuo account Google Cloud ID progetto
   • COMPUTE_LOCATION: una località Compute Engine, ad esempio us-central1.

2. Clona il repository GitHub:

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

3. Passa alla directory di lavoro:

   cd kubernetes-engine-samples/quickstarts/guestbook/
   

Crea un cluster GKE

Crea un cluster GKE Autopilot o standard:

Autopilot

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

Standard

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

Connettiti al cluster

Configura kubectl per comunicare con il cluster:

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

Configura il leader Redis

L'applicazione utilizza Redis per archiviare i dati. L'applicazione scrive i propri dati a un'istanza leader Redis e legge i dati di più follower Redis di Compute Engine.

1. Il seguente manifest descrive un deployment Kubernetes che esegue un singolo pod leader Redis con replica:

   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

   Applica il manifest al cluster:

   kubectl apply -f redis-leader-deployment.yaml
   

2. Verifica che il pod Redis Leader sia in esecuzione:

   kubectl get pods
   

   L'output è simile al seguente:

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

   Potrebbero essere necessari diversi minuti prima che il valore di STATUS passi da Pending a Running.

Creare il servizio leader Redis

L'applicazione web deve comunicare con il leader Redis per scrivere il proprio e i dati di Google Cloud. Puoi creare un servizio per eseguire il proxy del traffico al pod leader Redis.

Un servizio è un'astrazione Kubernetes che definisce un insieme logico di pod e un criterio per consentire l'accesso ai pod. Quando crei un servizio, descrivi i pod da usare come proxy in base alle relative etichette.

1. Il manifest seguente descrive un servizio per il leader Redis:

   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

   Questo file manifest include un insieme di selettori di etichette. Queste etichette corrispondono al set di etichette il cui deployment è stato eseguito nel passaggio precedente. Di conseguenza, questo servizio indirizza il traffico di rete al pod leader Redis creato in un passaggio precedente.

   La sezione ports del manifest dichiara una singola mappatura delle porte. La Il servizio instrada il traffico su port: 6379 verso targetPort: 6379 del che corrispondono alle etichette selector specificate. Il valore containerPort utilizzato nel deployment deve corrispondere a targetPort per instradare il traffico al deployment.

   Applica il manifest al cluster:

   kubectl apply -f redis-leader-service.yaml
   

2. Verifica che GKE abbia creato il servizio:

   kubectl get service
   

   L'output è simile al seguente:

   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
   

Configurare i follower Redis

Sebbene il leader Redis sia un singolo pod, puoi renderlo ad alta disponibilità per soddisfare le esigenze di traffico aggiungendo alcune repliche o follower Redis.

1. Il seguente manifest descrive un deployment per i pod follower Redis:

   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. Applica il manifest al cluster:

   kubectl apply -f redis-follower-deployment.yaml
   

3. Verifica che le due repliche dei follower Redis siano in esecuzione:

   kubectl get pods
   

   L'output è simile al seguente:

   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
   

   Potrebbero essere necessari alcuni minuti prima che lo stato di STATUS passi da Pending a Running.

Crea il servizio Redis follower

L'applicazione web deve comunicare con i follower di Redis per leggere i dati. Per rendere rilevabili i follower Redis, devi configurare un servizio.

1. Il seguente manifest descrive un servizio per i follower di Redis:

   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

   Questo manifest specifica che il servizio viene eseguito sulla porta 6379. Il campo selector del servizio corrisponde ai pod dei follower Redis creati nel passaggio precedente.

   Applica il manifest al cluster:

   kubectl apply -f redis-follower-service.yaml
   

2. Verifica che GKE abbia creato il servizio:

   kubectl get service
   

   L'output è simile al seguente:

   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
   

Configurare il frontend web dell'applicazione

Ora che hai lo spazio di archiviazione Redis per la tua applicazione, avvia i server web. Come per i follower Redis, il frontend viene disegnato utilizzando un deployment Kubernetes.

L'applicazione web utilizza un frontend PHP, che è configurato per comunicare con i follower Redis o i servizi leader, a seconda che la richiesta sia di lettura o di scrittura. Il frontend espone un'interfaccia JSON e pubblica un'interfaccia utente basata su jQuery Ajax.

1. Il file manifest seguente descrive un deployment per il server web:

   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

   Il file manifest specifica la variabile di ambiente GET_HOSTS_FROM=dns. Quando fornisci la configurazione all'applicazione frontend web, l'applicazione frontend utilizza i nomi host redis-follower e redis-leader per eseguire una ricerca DNS. La ricerca DNS trova gli indirizzi IP dei servizi che hai creato nei passaggi precedenti. Questo concetto è chiamato DNS. Service Discovery.

   Applica il manifest al cluster:

   kubectl apply -f frontend-deployment.yaml
   

2. Verifica che le repliche siano in esecuzione:

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

   L'output è simile al seguente:

   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
   

Esporre il frontend su un indirizzo IP esterno

Con la configurazione attuale, i servizi redis-follower e redis-leader che hai creato nei passaggi precedenti sono accessibili solo all'interno del cluster GKE perché il tipo predefinito per un servizio è ClusterIP.

Un servizio ClusterIP fornisce un singolo indirizzo IP per l'insieme di pod a cui fa riferimento. Questo indirizzo IP è accessibile solo all'interno del cluster.

Per rendere il servizio di frontend web accessibile dall'esterno, puoi specificare type: LoadBalancer o type: NodePort nella configurazione del servizio, a seconda dei tuoi requisiti.

Il seguente manifest descrive un servizio di tipo 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

La dichiarazione della porta nella sezione ports specifica port: 80 e targetPort non è specificato. Se ometti la proprietà targetPort, viene utilizzato per impostazione predefinita il valore del campo port. In questo caso, questo servizio instrada il traffico esterno sulla porta 80 alla porta 80 dei container nel deployment frontend.

Applica il manifest al cluster:

kubectl apply -f frontend-service.yaml

Alla creazione del servizio frontend, GKE crea un'istanza bilanciatore del carico e un indirizzo IP esterno. Queste risorse sono soggette a fatturazione.

Visitare il sito web dell'applicazione

Per accedere al sito web dell'applicazione, recupera l'indirizzo IP esterno del servizio frontend:

kubectl get service frontend

L'output è simile al seguente:

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

La colonna EXTERNAL-IP potrebbe mostrare <pending> durante la creazione del bilanciatore del carico. L'operazione potrebbe richiedere diversi minuti. Se vedi errori come Does not have minimum availability, attendi qualche minuto. Questo errore temporaneo si verifica perché GKE ricrea i nodi per apportare le modifiche.

Copia l'indirizzo IP e apri la pagina nel browser:

Prova ad aggiungere alcune voci digitando un messaggio e facendo clic Invia. Il messaggio digitato viene visualizzato nella parte anteriore. Questo messaggio indica che i dati sono stati aggiunti correttamente a Redis tramite i servizi che hai creato.

Eseguire l'upgrade del frontend web

Supponiamo che la tua applicazione sia in esecuzione da un po' di tempo e che si verifichi improvvisamente un'esplosione di pubblicità. Decidi che sarebbe una buona idea aggiungere altri server web al tuo frontend. Puoi farlo aumentando il numero di pod.

1. Aumenta il numero di pod frontend:

   kubectl scale deployment frontend --replicas=5
   

   L'output è simile al seguente:

   deployment.extensions/frontend scaled
   

2. Verifica il numero di repliche in esecuzione:

   kubectl get pods
   

   L'output è simile al seguente:

   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
   

   Puoi fare lo scale down del numero di pod frontend utilizzando lo stesso comando, sostituzione di 5 con 1.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimina le singole risorse

Se hai utilizzato un progetto esistente e non vuoi eliminarlo, elimina le singole risorse.

1. Elimina il servizio frontend:

   kubectl delete service frontend
   

2. Elimina il cluster GKE:

   gcloud container clusters delete guestbook
   

Passaggi successivi

• Scopri come configurare la scalabilità automatica del pod orizzontale.
• Scopri come eseguire il deployment di WordPress su GKE con Persistent Disk e Cloud SQL.
• Scopri come Configura i nomi di dominio con indirizzi IP statici.
• Esplora altri tutorial su Kubernetes Engine.