Deployment di un'applicazione web containerizzata

Autopilot Standard

---

Questo tutorial mostra come pacchettizzare un'applicazione web in un'immagine di container Docker ed eseguire quell'immagine di container su un cluster Google Kubernetes Engine (GKE). Poi, esegui il deployment dell'applicazione web come set di repliche con bilanciamento del carico che può essere scalato in base alle esigenze degli utenti.

Questa pagina è rivolta a operatori e sviluppatori che provisionano e configurano risorse cloud ed eseguono il deployment di app e servizi. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli e attività comuni degli utenti di GKE Enterprise. Google Cloud

Obiettivi

• Pacchettizzare un'applicazione web di esempio in un'immagine Docker.
• Caricare l'immagine Docker su Artifact Registry.
• Creare un cluster GKE.
• Eseguire il deployment dell'app di esempio nel cluster.
• Gestire la scalabilità automatica per il deployment.
• Esporre l'app di esempio su Internet.
• Eseguire il deployment di una nuova versione dell'app di esempio.

Costi

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

• GKE
• Artifact Registry

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

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. In the Google Cloud console, on the project selector page, select or create 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.

   Go to project selector

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

4. Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create 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.

   Go to project selector

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

7. Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

   Enable the APIs

Attiva Cloud Shell

Cloud Shell include gli strumenti a riga di comando gcloud, docker e kubectl utilizzati in questo tutorial.

1. Vai alla console Google Cloud.

2. Fai clic sul pulsante Attiva Cloud Shell nella parte superiore della finestra della console Google Cloud.

   All'interno di un nuovo frame nella parte inferiore della console Google Cloud si apre una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando.

   

Crea un repository

In questo tutorial archivi un'immagine in Artifact Registry ed esegui il deployment dal registry. Per questa guida rapida, creerai un repository denominato hello-repo.

1. Imposta la variabile di ambiente PROJECT_ID sul tuo Google Cloud ID progetto (PROJECT_ID). Utilizzerai questa variabile di ambiente quando crei l'immagine container e la invii al tuo repository.

   export PROJECT_ID=PROJECT_ID
   

2. Verifica che la variabile di ambiente PROJECT_ID contenga il valore corretto:

   echo $PROJECT_ID
   

3. Imposta l'ID progetto per Google Cloud CLI:

   gcloud config set project $PROJECT_ID
   

   Output:

   Updated property [core/project].
   

   Nota: l'interfaccia a riga di comando gcloud potrebbe essere già impostata su $PROJECT_ID; vedrai comunque l'output Updated property.

4. Crea il repository hello-repo con il seguente comando:

   gcloud artifacts repositories create hello-repo \
      --repository-format=docker \
      --location=REGION \
      --description="Docker repository"
   

   Sostituisci REGION con una regione per il repository, ad esempio us-west1. Per visualizzare un elenco delle località disponibili, esegui il comando:

    gcloud artifacts locations list
   

Creazione dell'immagine container

In questo tutorial, esegui il deployment di un'applicazione web di esempio chiamata hello-app, un server web scritto in Go che risponde a tutte le richieste con il messaggio Hello, World! sulla porta 8080.

GKE accetta immagini Docker come formato di deployment delle applicazioni. Prima di eseguire il deployment di hello-app in GKE, devi pacchettizzare il codice sorgente di hello-app come immagine Docker.

Per creare un'immagine Docker, è necessario il codice sorgente e un Dockerfile. Un Dockerfile contiene le istruzioni di creazione dell'immagine.

1. Scarica il codice sorgente hello-app e il Dockerfile eseguendo i seguenti comandi:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/quickstarts/hello-app
   

2. Crea e tagga l'immagine Docker per hello-app:

   docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
   

   Questo comando indica a Docker di creare l'immagine usando il Dockerfile nell'attuale directory, salvarla nel tuo ambiente locale e taggarla con un nome, ad esempio us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. Nella prossima sezione viene eseguito il push dell'immagine in Artifact Registry.

   • La variabile PROJECT_ID associa l'immagine container al repository hello-reponel tuo progetto. Google Cloud
   • Il prefisso us-west1-docker.pkg.dev si riferisce ad Artifact Registry, l'host regionale del tuo repository.
   Nota: se richiesto, autorizza Cloud Shell a effettuare chiamate Google Cloud API.

3. Esegui il comando docker images per verificare che la build sia andata a buon fine:

   docker images
   

   Output:

   REPOSITORY                                                 TAG     IMAGE ID       CREATED          SIZE
   us-west1-docker.pkg.dev/my-project/hello-repo/hello-app    v1      25cfadb1bf28   10 seconds ago   54 MB
   

   Nota: potresti anche vedere immagini aggiuntive che rappresentano livelli di immagine intermedi.

4. Aggiungi associazioni di criteri IAM all'account di servizio:

   gcloud artifacts repositories add-iam-policy-binding hello-repo \
       --location=REGION \
       --member=serviceAccount:[e-mail] \
       --role="roles/artifactregistry.reader"
   

   Sostituisci PROJECT_NUMBER con il numero del progetto del tuo progetto.

(Facoltativo) Eseguire il container in locale

1. Testa l'immagine del contenitore utilizzando il tuo motore Docker locale:

   docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
   

2. Fai clic sul pulsante Anteprima web e seleziona il numero di porta 8080. GKE apre l'URL di anteprima nel suo servizio proxy, in una nuova finestra del browser.

Eseguire il push dell'immagine Docker in Artifact Registry

Devi caricare l'immagine del container in un registry in modo che il tuo cluster GKE possa scaricarla ed eseguirla. In questo tutorial, archiviare il contenitore in Artifact Registry.

1. Configura lo strumento a riga di comando Docker per eseguire l'autenticazione su Artifact Registry:

   gcloud auth configure-docker REGION-docker.pkg.dev
   

   Nota: puoi ignorare gli avvisi relativi alla presenza di un elenco lungo di helper per le credenziali.

2. Esegui il push dell'immagine Docker che hai appena creato nel repository:

   docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
   

Crea un cluster GKE

Ora che l'immagine Docker è archiviata in Artifact Registry, crea un cluster GKE per eseguire hello-app. Un cluster GKE è costituito da un pool di istanze VM Compute Engine su cui è in esecuzione Kubernetes, il sistema di orchestrazione dei cluster open source che alimenta GKE.

Cloud Shell

1. Imposta la regione di Compute Engine:

    gcloud config set compute/region REGION
   

   Per i cluster zonali standard, imposta una zona Compute Engine più vicina al repository Artifact Registry.

2. Crea un cluster denominato hello-cluster:

    gcloud container clusters create-auto hello-cluster
   

   La creazione e il controllo dell'integrità del cluster GKE richiedono alcuni minuti. Per eseguire questo tutorial su un cluster GKE standard, utilizza invece il comando gcloud container clusters create.

Console

1. Vai alla pagina Google Kubernetes Engine nella console Google Cloud.

   Vai a Google Kubernetes Engine

2. Fai clic su Crea.

3. Per GKE Autopilot, fai clic su Configura.

4. Nel campo Nome, inserisci il nome hello-cluster.

5. Seleziona una regione Compute Engine dall'elenco a discesa Regione, ad esempio us-west1.

6. Fai clic su Crea.

7. Attendi che il cluster venga creato. Quando il cluster è pronto, accanto al suo nome viene visualizzato un segno di spunta.

Eseguire il deployment dell'app di esempio in GKE

Ora puoi eseguire il deployment dell'immagine Docker che hai creato nel tuo cluster GKE.

Kubernetes rappresenta le applicazioni come pod, che sono unità scalabili che includono uno o più container. Il Pod è l'unità più piccola di cui è possibile eseguire il deployment in Kubernetes. In genere, esegui il deployment dei pod come un insieme di repliche che possono essere scalate e distribuite insieme nel tuo cluster. Un modo per eseguire il deployment di un set di repliche è utilizzare un deployment Kubernetes.

In questa sezione, creerai un deployment di Kubernetes per eseguire hello-app sul tuo cluster. Questo deployment ha delle repliche (pod). Un pod di deployment include solamente un container: l'immagine Docker di hello-app. Inoltre, crei una risorsa HorizontalPodAutoscaler che scala il numero di pod da 3 a un numero compreso tra 1 e 5, in base al carico della CPU.

Cloud Shell

1. Assicurati di essere connesso al tuo cluster GKE.

   gcloud container clusters get-credentials hello-cluster --region REGION
   

2. Crea un deployment Kubernetes per la tua immagine Docker hello-app.

   kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
   

3. Imposta il numero di riferimento per le repliche di deployment su 3.

   kubectl scale deployment hello-app --replicas=3
   

4. Crea una risorsa HorizontalPodAutoscaler per il tuo deployment.

   kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
   

5. Per visualizzare i pod creati, esegui il seguente comando:

   kubectl get pods
   

   Output:

   NAME                         READY   STATUS    RESTARTS   AGE
   hello-app-784d7569bc-hgmpx   1/1     Running   0          90s
   hello-app-784d7569bc-jfkz5   1/1     Running   0          90s
   hello-app-784d7569bc-mnrrl   1/1     Running   0          95s
   

   Nota: l'avvio dei pod potrebbe richiedere fino a due minuti. Fino al loro inizio, nella colonna Status viene visualizzato Pending.

Console

1. Vai alla pagina Carichi di lavoro nella console Google Cloud.

   Visita Carichi di lavoro

2. Fai clic su Esegui il deployment.

3. Nella sezione Specifica contenitore, seleziona Immagine container esistente.

4. Nel campo Percorso immagine, fai clic su Seleziona.

5. Nel riquadro Seleziona immagine container, seleziona l'immagine hello-app di cui hai eseguito il push in Artifact Registry e fai clic su Seleziona.

6. Nella sezione Contenitore, fai clic su Fine, poi su Continua.

7. Nella sezione Configurazione, in Etichette, inserisci app per Chiave e hello-app per Valore.

8. In YAML configurazione, fai clic su Visualizza YAML. Viene aperto un file di configurazione YAML che rappresenta le due risorse dell'API Kubernetes di cui verrà eseguito il deployment nel cluster: un deployment e un HorizontalPodAutoscaler per quel deployment.

9. Fai clic su Chiudi, quindi su Esegui il deployment.

10. Quando i pod di deployment sono pronti, viene aperta la pagina Dettagli deployment.

11. In Pod gestiti, puoi notare i tre pod in esecuzione per il deployment hello-app.

Esposizione dell'app di esempio a internet

Sebbene i pod abbiano indirizzi IP assegnati singolarmente, questi IP possono essere raggiunti solo dall'interno del cluster. Inoltre, i pod GKE sono progettati per essere temporanei e avviarsi o arrestarsi in base alle esigenze di scalabilità. Quando un pod si arresta in modo anomalo a causa di un errore, GKE lo ridistribuisce automaticamente assegnando ogni volta un nuovo indirizzo IP.

Ciò significa che per qualsiasi deployment, l'insieme di indirizzi IP corrispondente all'insieme attivo di pod è dinamico. Abbiamo bisogno di un modo per 1) raggruppare i pod in un unico nome host statico e 2) esporre un gruppo di pod all'esterno del cluster a internet.

I servizi Kubernetes risolvono entrambi i problemi. Pod del gruppo di servizi in un unico indirizzo IP statico, raggiungibile da qualsiasi pod all'interno del cluster. GKE assegna anche un nome host DNS a quell'IP statico. Ad esempio: hello-app.default.svc.cluster.local.

Il tipo di servizio predefinito in GKE è chiamato ClusterIP, in cui il servizio ottiene un indirizzo IP raggiungibile solo dall'interno del cluster. Per esporre un servizio Kubernetes all'esterno del cluster, crea un servizio di tipo LoadBalancer. Questo tipo di servizio genera un IP del bilanciatore di carico esterno per un insieme di pod, raggiungibili tramite internet.

In questa sezione, esponi il deployment di hello-app su internet usando un servizio di tipo LoadBalancer.

Nota: i bilanciatori del carico delle applicazioni esterni (soggetto a fatturazione) sono separati dai costi di GKE.

Cloud Shell

1. Usa il comando kubectl expose per generare un servizio Kubernetes per il deployment di hello-app:

   kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
   

   Qui il flag --port specifica il numero di porta configurato sul bilanciatore del carico, mentre il flag --target-port specifica il numero di porta su cui il container hello-app è in ascolto.

2. Esegui questo comando per recuperare i dettagli del servizio per hello-app-service:

   kubectl get service
   

   Output:

   NAME                 CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
   hello-app-service    10.3.251.122    203.0.113.0     80:30877/TCP     10s
   

3. Copia l'indirizzo EXTERNAL_IP negli appunti (ad esempio: 203.0.113.0).

   Nota: il provisioning del bilanciatore del carico potrebbe richiedere alcuni minuti. Fino al provisioning del bilanciatore del carico, potresti visualizzare un <pending> indirizzo IP.

Console

1. Vai alla pagina Carichi di lavoro nella console Google Cloud.

   Vai a Carichi di lavoro

2. Fai clic su hello-app.

3. Nella pagina dei dettagli del deployment, fai clic su Azioni > Esponi.

4. Nella finestra di dialogo Esponi, imposta Porta di destinazione su 8080. Questa è la porta su cui il container hello-app è in ascolto.

5. Nell'elenco a discesa Tipo di servizio, seleziona Bilanciatore del carico.

6. Fai clic su Esponi per creare un servizio Kubernetes per hello-app.

7. Quando il bilanciatore del carico è pronto, viene aperta la pagina Dettagli del servizio.

8. Scorri verso il basso fino al campo Endpoint esterni e copia l'indirizzo IP.

Ora che i pod hello-app sono esposti a internet tramite un servizio Kubernetes, puoi aprire una nuova scheda del browser e andare all'indirizzo IP del servizio che hai copiato nella clipboard. Viene visualizzato un messaggio Hello, World!, insieme a un campo Hostname. Hostname corrisponde a uno dei tre pod hello-app che inviano la richiesta HTTP al browser.

Eseguire il deployment di una nuova versione dell'app di esempio

In questa sezione esegui l'upgrade di hello-app a una nuova versione creando ed eseguendo il deployment di una nuova immagine Docker nel tuo cluster GKE.

L'aggiornamento in sequenza di Kubernetes consente di aggiornare i deployment senza tempi di inattività. Durante un aggiornamento in sequenza, il cluster GKE sostituisce in modo incrementale i pod hello-app esistenti con pod contenenti l'immagine Docker per la nuova versione. Durante l'aggiornamento, il servizio di bilanciamento del carico instrada il traffico solo nei pod disponibili.

1. Torna a Cloud Shell, dove hai clonato il codice sorgente e il Dockerfile dell'app hello. Aggiorna la funzione hello() nel file main.go per segnalare la nuova versione 2.0.0.

2. Crea e tagga una nuova immagine Docker hello-app.

   docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .
   

3. Esegui il push dell'immagine in Artifact Registry.

   docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
   

Ora puoi aggiornare il hello-appdeployment Kubernetes per utilizzare una nuova immagine Docker.

Nota: poiché hai creato un HorizontalPodAutoscaler in precedenza, il numero di hello-app pod in esecuzione in questa sezione potrebbe essere inferiore ai tre pod implementati inizialmente. Il numero di pod del tuo cluster GKE potrebbe essere stato ridotto in base a un utilizzo ridotto della CPU.

Cloud Shell

1. Applica un aggiornamento in sequenza al deployment hello-app esistente con un aggiornamento dell'immagine utilizzando il comando kubectl set image:

   kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
   

2. Guarda i pod in esecuzione che utilizzano l'immagine v1 arrestarsi e i nuovi pod che utilizzano l'immagine v2 avviarsi.

   watch kubectl get pods
   

   Output:

   NAME                        READY   STATUS    RESTARTS   AGE
   hello-app-89dc45f48-5bzqp   1/1     Running   0          2m42s
   hello-app-89dc45f48-scm66   1/1     Running   0          2m40s
   

3. In una scheda separata, vai di nuovo all'IP esterno hello-app-service. Ora dovresti vedere Version impostato su 2.0.0.

Console

1. Vai alla pagina Carichi di lavoro nella console Google Cloud.

   Vai a Carichi di lavoro

2. Fai clic su hello-app.

3. Nella pagina Dettagli deployment, fai clic su Azioni > Aggiornamento progressivo.

4. Nella finestra di dialogo Aggiornamento progressivo, imposta il campo Immagine di hello-app su REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2.

5. Fai clic su Aggiorna.

6. Nella pagina Dettagli del deployment, controlla la sezione Revisioni attive. Ora dovresti vedere due revisioni, 1 e 2. La revisione 1 corrisponde al deployment iniziale che hai creato in precedenza. La revisione 2 è l'aggiornamento graduale che hai appena avviato.

7. Dopo qualche istante, aggiorna la pagina. In Pod gestiti, tutte le repliche di hello-app ora corrispondono alla revisione 2.

8. In una scheda separata, vai di nuovo all'indirizzo IP del servizio che hai copiato. Version deve essere 2.0.0.

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.

1. Elimina il servizio:questa operazione annulla l'assegnazione del bilanciatore del carico Cloud creato per il tuo servizio:

   kubectl delete service hello-app-service
   

2. Elimina il cluster:vengono eliminate le risorse che compongono il cluster, come le istanze di calcolo, i dischi e le risorse di rete:

   gcloud container clusters delete hello-cluster --region REGION
   

3. Elimina le immagini container:questa operazione elimina le immagini Docker di cui hai eseguito il push in Artifact Registry.

   gcloud artifacts docker images delete \
       REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \
       --delete-tags --quiet
   gcloud artifacts docker images delete \
       REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \
       --delete-tags --quiet
   

Passaggi successivi

• Scopri di più sui prezzi di GKE e usa il Calcolatore prezzi per stimare i costi.

• Leggi il tutorial relativo ai bilanciatori del carico, che presenta configurazioni di bilanciamento del carico avanzate per le applicazioni web.

• Configura un IP statico e un nome di dominio per la tua applicazione.

• Esplora altri tutorial su Kubernetes Engine.

• Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di GKE in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova GKE gratuitamente