Deployment di un'applicazione web containerizzata

Questo tutorial mostra come pacchettizzare un'applicazione web in un container Docker ed eseguirla su un cluster Google Kubernetes Engine (GKE). Quindi, esegui il deployment dell'applicazione web come set di repliche con bilanciamento del carico che può in base alle esigenze dei tuoi utenti.

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 vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

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

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

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Abilita le API Compute Engine, Artifact Registry, and Google Kubernetes Engine .

    Abilita le API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  7. Abilita le API Compute Engine, Artifact Registry, and Google Kubernetes Engine .

    Abilita le API

    8.

Attiva Cloud Shell

Cloud Shell è preinstallato con gcloud, docker e kubectl a riga di comando usati in questo tutorial.

  1. Vai alla console Google Cloud.

  2. Fai clic su Attiva Cloud Shell Pulsante Attiva shell nella parte superiore della finestra della console Google Cloud.

    Una sessione di Cloud Shell si apre all'interno di un nuovo frame in basso della console Google Cloud e visualizza un prompt della riga di comando.

    sessione Cloud Shell

Crea un repository

In questo tutorial, archivierai un'immagine in Artifact Registry e ne eseguirai il deployment del registro. Per questa guida rapida, creerai un repository denominato hello-repo.

  1. Imposta la variabile di ambiente PROJECT_ID sul tuo ID progetto Google Cloud (PROJECT_ID). Utilizzerai questa variabile di ambiente quando crei l'immagine container e ne esegui il push nel repository.

    export PROJECT_ID=PROJECT_ID

  2. Verifica che il valore della variabile di ambiente PROJECT_ID sia corretto:

    echo $PROJECT_ID

  3. Imposta il tuo ID progetto per Google Cloud CLI:

    gcloud config set project $PROJECT_ID

    Output:

    Updated property [core/project].

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

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

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

     gcloud artifacts locations list

Creazione dell'immagine container in corso...

In questo tutorial, eseguirai il deployment di una piattaforma Web di esempio denominata hello-app, un server web scritto in Go che risponda 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 hello-app come immagine Docker.

Per creare un'immagine Docker, hai bisogno del codice sorgente e di un Dockerfile. Un Dockerfile contiene istruzioni su come viene creata l'immagine.

  1. Scarica il codice sorgente hello-app e il Dockerfile eseguendo questi 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 utilizzando Dockerfile in la directory corrente, salvarla nel tuo ambiente locale e contrassegnarla con un nome, ad esempio us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. Nella sezione successiva viene eseguito il push dell'immagine ad Artifact Registry.

    • La variabile PROJECT_ID associa l'immagine container a hello-repo nel tuo progetto Google Cloud.
    • Il prefisso us-west1-docker.pkg.dev si riferisce ad Artifact Registry, regionale per il tuo repository.

  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

  4. Aggiungi associazioni di criteri IAM al tuo account di servizio:

    gcloud artifacts repositories add-iam-policy-binding hello-repo \
    --location=REGION \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role="roles/artifactregistry.reader"

    Sostituisci PROJECT_NUMBER con numero progetto del tuo progetto.

(Facoltativo) Esecuzione in locale del container

  1. Testa l'immagine container 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 Pulsante Anteprima web. e seleziona il numero di porta 8080. GKE apre l'URL di anteprima sul suo servizio di proxy in una nuova finestra del browser.

esegui il push dell'immagine Docker in Artifact Registry

Devi caricare l'immagine container in un registro in modo che l'ambiente GKE un cluster può scaricare ed eseguire l'immagine container. In questo tutorial imparerai archiviare il container 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

  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 cluster per eseguire hello-app. Un cluster GKE è costituito da un pool di istanze VM di Compute Engine che esegue Kubernetes, il servizio di orchestrazione dei cluster open source alla base di GKE.

Cloud Shell

  1. Imposta la regione di Compute Engine:

     gcloud config set compute/region REGION

    Per i cluster di zona Standard, imposta una zona Compute Engine più vicino al repository Artifact Registry.

  2. Crea un cluster denominato hello-cluster:

     gcloud container clusters create-auto hello-cluster

    L'avvio del cluster GKE dei dati e dei controlli di integrità. Per eseguire questo tutorial su un GKE per il cluster standard, utilizza 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 di 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 nome del cluster.

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 scalabili unità contenenti uno o più container. Il Pod è l'unità più piccola di cui è possibile eseguire il deployment in Kubernetes. Di solito, il deployment dei pod è 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. Creerai anche 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 di 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 questo 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

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 che ad Artifact Registry e fai clic su Seleziona.

  6. Nella sezione Contenitore, fai clic su Fine e 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. Si apre un file YAML di configurazione di deployment che rappresenta le due risorse dell'API Kubernetes che stanno per il deployment nel tuo cluster: un deployment HorizontalPodAutoscaler per quel deployment.

  9. Fai clic su Chiudi e poi su Esegui il deployment.

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

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

Esposizione dell'app di esempio su 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, essere avviati o arrestati in base alle esigenze di scalabilità. E quando un pod si arresta in modo anomalo a causa di un errore, GKE esegue di nuovo automaticamente il deployment di quel pod, assegnando un nuovo IP del pod indirizzo IP.

Ciò significa che per qualsiasi deployment, l'insieme di indirizzi IP di pod corrispondenti a un insieme attivo di pod sia dinamico. Ci serve un modo per 1) raggruppare insieme i pod in un nome host statico e 2) espongono un gruppo di pod all'esterno del cluster a internet.

I servizi Kubernetes risolvono entrambi questi problemi. Pod dei gruppi di servizi in un unico indirizzo IP statico, raggiungibile da qualsiasi pod all'interno del cluster. Inoltre, GKE assegna 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 digita LoadBalancer. Questo tipo di servizio genera un IP del bilanciatore del carico esterno per un insieme di pod, raggiungibile tramite internet.

In questa sezione, esponi il deployment hello-app su internet utilizzando una Servizio di tipo LoadBalancer.

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

    In questo caso, il flag --port specifica il numero di porta configurato sul bilanciatore del carico e Il flag --target-port specifica il numero di porta utilizzato da hello-app container è 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).

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 > Esponi.

  4. Nella finestra di dialogo Esponi, imposta Porta di destinazione su 8080. Questa è la porta su cui il container hello-app rimane 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, si apre la pagina Dettagli 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 passare all'indirizzo IP del servizio che hai copiato negli appunti. Viene visualizzato un messaggio Hello, World! e un Hostname . Hostname corrisponde a uno dei tre pod hello-app che gestiscono una richiesta HTTP al browser.

Deployment di una nuova versione dell'app di esempio

In questa sezione, eseguirai l'upgrade di hello-app a una nuova versione creando e implementando una nuova immagine Docker nel tuo cluster GKE.

Kubernetes aggiornamento in sequenza 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 del bilanciatore del carico instrada il traffico solo ai 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 è tutto pronto per aggiornare il tuo deployment Kubernetes hello-app in modo da utilizzare una nuova immagine Docker.

Cloud Shell

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

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

  2. Osserva l'arresto dei pod in esecuzione che eseguono l'immagine v1 e dei nuovi pod che eseguono Inizio immagine v2.

    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 di 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 in sequenza.

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

  5. Fai clic su Aggiorna.

  6. Nella pagina Dettagli deployment, esamina le Revisioni attive . Ora dovresti vedere due revisioni, la 1 e la 2. La revisione 1 corrisponde al deployment iniziale che hai creato in precedenza. La revisione 2 è la sequenza aggiornamento appena iniziato.

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

  8. In una scheda separata, vai di nuovo all'indirizzo IP del servizio che hai copiato. Il valore 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 trasferisce il bilanciatore del carico Cloud creato per il Servizio:

    kubectl delete service hello-app-service

  2. Elimina il cluster: vengono eliminate le risorse che lo compongono, ad esempio istanze di calcolo, dischi e risorse di rete:

    gcloud container clusters delete hello-cluster --region REGION

  3. Elimina le immagini container: vengono eliminate le immagini Docker di cui hai eseguito il push su 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

Provalo

Se non hai mai utilizzato Google Cloud, crea un account per valutare in che modo GKE si comporta nel mondo reale diversi scenari. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova GKE gratuitamente