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 agli operatori e agli sviluppatori che eseguire il provisioning e configurare le risorse cloud ed eseguire il deployment di app e servizi. Per scoprire di più sui ruoli comuni e sugli esempi di attività a cui facciamo riferimento nei contenuti di Google Cloud, consulta Ruoli e attività comuni degli utenti di GKE Enterprise.
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:
Per generare una stima dei costi basata sull'utilizzo previsto,
utilizza il Calcolatore prezzi.
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
- 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.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.
Attiva Cloud Shell
Cloud Shell è preinstallato nelle versioni gcloud
, docker
e
kubectl
a riga di comando usati in questo tutorial.
- Vai alla console Google Cloud.
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, archivierai un'immagine in Artifact Registry e ne eseguirai il deployment
del registro. Per questa guida rapida, creerai un repository denominato
hello-repo
.
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
Verifica che il valore della variabile di ambiente
PROJECT_ID
sia corretto:echo $PROJECT_ID
Imposta il tuo ID progetto per Google Cloud CLI:
gcloud config set project $PROJECT_ID
Output:
Updated property [core/project].
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 comeus-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 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.
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
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 esempious-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 ahello-repo
nel tuo progetto Google Cloud. - Il prefisso
us-west1-docker.pkg.dev
si riferisce ad Artifact Registry, l'host regionale del tuo repository.
- La variabile
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
Aggiungi associazioni di criteri IAM all'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) Eseguire il container in locale
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
Fai clic sul 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, archiviare il contenitore in Artifact Registry.
Configura lo strumento a riga di comando Docker per eseguire l'autenticazione su Artifact Registry:
gcloud auth configure-docker REGION-docker.pkg.dev
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 su cui è in esecuzione Kubernetes, il sistema di orchestrazione dei cluster open source che alimenta GKE.
Cloud Shell
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.
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
Vai alla pagina Google Kubernetes Engine nella console Google Cloud.
Fai clic su add_box Crea.
Per GKE Autopilot, fai clic su Configura.
Nel campo Nome, inserisci il nome
hello-cluster
.Seleziona una regione Compute Engine dall'elenco a discesa Regione, ad esempio
us-west1
.Fai clic su Crea.
Attendi che il cluster venga creato. Quando il cluster è pronto, accanto al suo nome viene visualizzato un segno di spunta.
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
Assicurati di essere connesso al tuo cluster GKE.
gcloud container clusters get-credentials hello-cluster --region REGION
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
Imposta il numero di riferimento di repliche di deployment su 3.
kubectl scale deployment hello-app --replicas=3
Crea una risorsa
HorizontalPodAutoscaler
per il tuo deployment.kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=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
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Fai clic su add_box Esegui il deployment.
Nella sezione Specifica contenitore, seleziona Immagine container esistente.
Nel campo Percorso immagine, fai clic su Seleziona.
Nel riquadro Seleziona immagine container, seleziona l'immagine
hello-app
di cui hai eseguito il push in Artifact Registry e fai clic su Seleziona.Nella sezione Contenitore, fai clic su Fine e poi su Continua.
Nella sezione Configurazione, in Etichette, inserisci
app
per Chiave ehello-app
per Valore.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.Fai clic su Chiudi, quindi su Esegui il deployment.
Quando i pod di deployment sono pronti, viene aperta la pagina Dettagli deployment.
In Pod gestiti, puoi notare i tre pod in esecuzione per il deployment
hello-app
.
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 nuovamente 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. 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 dei gruppi 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 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
Usa il comando
kubectl expose
per generare un servizio Kubernetes per il deployment dihello-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 containerhello-app
è in ascolto.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
Copia l'indirizzo
EXTERNAL_IP
negli appunti (ad esempio:203.0.113.0
).
Console
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Fai clic su hello-app.
Nella pagina dei dettagli del deployment, fai clic su list Azioni > Esponi.
Nella finestra di dialogo Esponi, imposta Porta di destinazione su
8080
. Questa è la porta su cui il containerhello-app
rimane in ascolto.Nell'elenco a discesa Tipo di servizio, seleziona Bilanciatore del carico.
Fai clic su Esponi per creare un servizio Kubernetes per
hello-app
.Quando il bilanciatore del carico è pronto, viene aperta la pagina Dettagli del servizio.
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 gestiscono
una 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 del bilanciatore del carico instrada il traffico solo ai pod disponibili.
Torna a Cloud Shell, dove hai clonato il codice sorgente e il Dockerfile dell'app hello. Aggiorna la funzione
hello()
nel filemain.go
per segnalare la nuova versione2.0.0
.Crea e tagga una nuova immagine Docker
hello-app
.docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .
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
Applica un aggiornamento in sequenza al deployment
hello-app
esistente con un aggiornamento dell'immagine utilizzando il comandokubectl set image
:kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
Guarda i pod in esecuzione che utilizzano l'immagine
v1
arrestarsi e i nuovi pod che utilizzano l'immaginev2
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
In una scheda separata, vai di nuovo all'IP esterno di
hello-app-service
. Ora dovresti vedereVersion
impostato su2.0.0.
Console
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Fai clic su hello-app.
Nella pagina Dettagli deployment, fai clic su list Azioni > Aggiornamento incrementale.
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
.Fai clic su Aggiorna.
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 è la sequenza aggiornamento appena iniziato.
Dopo qualche istante, aggiorna la pagina. In Pod gestiti, tutte le repliche di
hello-app
ora corrispondono alla revisione 2.In una scheda separata, vai di nuovo all'indirizzo IP del servizio che hai copiato.
Version
deve essere2.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.
Elimina il servizio: questa operazione annulla l'assegnazione del bilanciatore del carico Cloud creato per il tuo servizio:
kubectl delete service hello-app-service
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
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 per GKE e usa il Calcolatore prezzi per stimare i costi.
Leggi il tutorial sui 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. Dai un'occhiata al nostro Centro architetture cloud.
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