Creare un'applicazione web multilivello con Redis e PHP


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 Kubernetes:

  • Configurazione dichiarativa utilizzando i 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 ed eseguire l'applicazione su GKE:

  1. Configura il leader Redis
  2. Configura due follower Redis
  3. Configurare il frontend web
  4. Visita il sito web
  5. Aumentare le dimensioni del frontend web

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

Architettura del cluster GKE

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi 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. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

  4. Per inizializzare gcloud CLI, esegui questo comando:

    gcloud init
  5. 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.

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the GKE API:

    gcloud services enable container.googleapis.com
  8. Install the Google Cloud CLI.

  9. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

  10. Per inizializzare gcloud CLI, esegui questo comando:

    gcloud init
  11. 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.

  12. Verify that billing is enabled for your Google Cloud project.

  13. Enable the GKE API:

    gcloud services enable container.googleapis.com
  14. 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:

    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 dati in un'istanza leader Redis e legge i dati da più istanze follower Redis.

    1. Il seguente manifest descrive un deployment Kubernetes che esegue un pod leader Redis con una sola 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 leader Redis 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 lo stato di STATUS passi da Pending a Running.

    Creare il servizio leader Redis

    L'applicazione web deve comunicare con il leader Redis per scrivere i suoi dati. Puoi creare un servizio per indirizzare il traffico al pod leader di 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 quali pod eseguire il proxy in base alle etichette dei pod.

    1. Il seguente manifest 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 manifest include un insieme di selettori di etichette. Queste etichette corrispondono al set di etichette per le quali è stato eseguito il deployment nel passaggio precedente. Pertanto, questo servizio indirizza il traffico di rete al pod leader Redis creato in un passaggio precedente.

      La sezione ports del manifest dichiara un singolo mapping delle porte. Il servizio instrada il traffico su port: 6379 a targetPort: 6379 dei container che corrispondono alle etichette selector specificate. L'containerPort utilizzato nel deployment deve corrispondere all'targetPort per indirizzare 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 altamente disponibile e soddisfare le richieste di traffico aggiungendo alcuni follower o repliche 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 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 diversi minuti prima che lo stato di STATUS passi da Pending a Running.

    Creare il servizio follower Redis

    L'applicazione web deve comunicare con i follower 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 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 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 l'archiviazione Redis per la tua applicazione, avvia i server web. Come i follower Redis, il frontend viene sottoposto a deployment utilizzando un deployment Kubernetes.

    L'applicazione web utilizza un frontend PHP, che è configurato per comunicare con i servizi follower o leader Redis, 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 seguente manifest 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, quest'ultima 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 service discovery DNS.

      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 punta il servizio. Questo indirizzo IP è accessibile solo all'interno del cluster.

    Per rendere accessibile esternamente il servizio di frontend web, 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, il valore predefinito è quello 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
    

    Quando viene creato il servizio frontend, GKE crea un 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 alcuni minuti. Se visualizzi 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:

    Applicazione web in esecuzione su GKE

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

    Aumentare le dimensioni del frontend web

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

    1. Fai lo scale up del 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 il numero di pod frontend utilizzando lo stesso comando, sostituendo 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

      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