Esegui il deployment di un'app Java Spring Boot in Kubernetes su Google Kubernetes Engine

Kubernetes è un progetto open source eseguibile in molti ambienti diversi, dai laptop ai cluster multinodo ad alta disponibilità, dai cloud pubblici ai deployment on-premise e dalle istanze di macchine virtuali (VM) al bare metal.

In questo codelab, eseguirai il deployment di una semplice app web Java Spring Boot in Kubernetes su GKE, con l'obiettivo di eseguire l'app web come app replicata su Kubernetes. Prenderai il codice che sviluppi sulla tua macchina, lo trasformerai in un'immagine container Docker ed eseguirai l'immagine su GKE.

Utilizzerai GKE, un servizio Kubernetes completamente gestito su Google Cloud, per concentrarti maggiormente sull'utilizzo di Kubernetes anziché sulla configurazione dell'infrastruttura sottostante.

Se ti interessa eseguire Kubernetes sulla tua macchina locale, ad esempio un laptop di sviluppo, dai un'occhiata a Minikube, che offre una semplice configurazione di un cluster Kubernetes a un solo nodo per scopi di sviluppo e test. Se vuoi, puoi utilizzare Minikube per seguire il codelab.

Il codelab utilizzerà il codice campione della guida su Creazione di un'app con Spring Boot.

Prerequisiti

• Familiarità con il linguaggio di programmazione Java e gli strumenti
• Conoscenza degli editor di testo standard di Linux, ad esempio Vim, Emacs e nano

Attività previste

• Pacchettizza una semplice app Java come container Docker.
• Crea il cluster Kubernetes su GKE.
• Esegui il deployment della tua app Java in Kubernetes su GKE.
• Aumenta le dimensioni del tuo servizio ed esegui il deployment di un upgrade.
• Accedi a Dashboard, un'interfaccia utente Kubernetes basata sul web.

Che cosa ti serve

• Un progetto Google Cloud
• Un browser, ad esempio Google Chrome

Configurazione dell'ambiente autonoma

1. Accedi alla console Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai già un account Gmail o G Suite, devi crearne uno.

Nota:puoi accedere facilmente a Cloud Console memorizzando il relativo URL, ovvero console.cloud.google.com.

Ricorda l'ID progetto, un nome univoco per tutti i progetti Google Cloud (il nome riportato sopra è già stato utilizzato e non funzionerà per te, mi dispiace). In questo codelab verrà chiamato PROJECT_ID.

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account G Suite, scegli una posizione adatta alla tua organizzazione.

2. Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse Google Cloud.

L'esecuzione di questo codelab non dovrebbe costarti più di qualche dollaro, ma potrebbe essere più cara se decidi di utilizzare più risorse o se le lasci in esecuzione.

I nuovi utenti di Google Cloud possono beneficiare di una prova senza costi di 300$.

Attiva Cloud Shell

1. Nella console Google Cloud, fai clic su Attiva Cloud Shell .

Se non hai mai avviato Cloud Shell, vedrai una schermata intermedia (sotto la piega) che ne descrive le funzionalità. In questo caso, fai clic su Continua (e non la vedrai mai più). Ecco come si presenta la schermata una tantum:

Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.

Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, il lavoro in questo codelab può essere svolto semplicemente con un browser o con Chromebook.

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo ID progetto.

2. Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:

gcloud auth list

Output comando

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Nota : lo strumento a riga di comando gcloud è il potente strumento a riga di comando unificato di Google Cloud. È già installato in Cloud Shell. Noterai il supporto del completamento automatico. Per saperne di più, consulta la panoramica dello strumento a riga di comando gcloud.

gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

In caso contrario, puoi impostarlo con questo comando:

gcloud config set project <PROJECT_ID>

Output comando

Updated property [core/project].

Dopo l'avvio di Cloud Shell, puoi utilizzare la riga di comando per clonare il codice sorgente di esempio nella home directory.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

1. Puoi avviare l'app Spring Boot normalmente con il plug-in Spring Boot.

$ ./mvnw -DskipTests spring-boot:run

2. Dopo l'avvio dell'app, fai clic su Anteprima web nella barra degli strumenti di Cloud Shell e seleziona Anteprima sulla porta 8080.

Si apre una scheda nel browser e si connette al server appena avviato.

Poi, devi preparare l'app per l'esecuzione su Kubernetes. Il primo passaggio consiste nel definire il contenitore e i relativi contenuti.

1. Crea il file JAR implementabile per l'app.

$ ./mvnw -DskipTests package

2. Attiva Container Registry per archiviare l'immagine container che creerai.

$ gcloud services enable containerregistry.googleapis.com

3. Utilizza Jib per creare l'immagine container ed eseguirne il push su Container Registry.

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. Se tutto va bene, dovresti essere in grado di visualizzare l'immagine container elencata nella console andando a Container Registry > Immagini. Ora hai a disposizione un'immagine Docker a livello di progetto a cui Kubernetes può accedere e che può orchestrare, come vedrai tra qualche minuto.

Nota:anche se hai utilizzato un dominio generico per il registro (gcr.io), puoi anche specificare la zona e il bucket da utilizzare. Per saperne di più, consulta la documentazione di Container Registry.

5. Al termine (il download e l'estrazione di tutti i file richiedono un po' di tempo), puoi testare localmente l'immagine con il seguente comando, che eseguirà un container Docker come daemon sulla porta 8080 dall'immagine container appena creata:

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

6. Anche in questo caso, sfrutta la funzionalità di anteprima web di Cloud Shell.

7. Dovresti vedere la pagina predefinita in una nuova scheda. Dopo aver verificato che l'app sia in esecuzione localmente in un container Docker, puoi arrestare il container in esecuzione premendo Control+C.

Ora puoi creare il cluster GKE. Un cluster è costituito da un server API Kubernetes gestito da Google e da un insieme di nodi worker. I nodi worker sono VM di Compute Engine.

1. Innanzitutto, assicurati che le funzionalità API correlate siano abilitate.

$ gcloud services enable compute.googleapis.com container.googleapis.com
Operation "operations/..." finished successfully

2. Crea un cluster con due nodi n1-standard-1 (il completamento dell'operazione richiederà alcuni minuti).

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Alla fine, dovresti vedere il cluster creato.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

Nota : in alternativa, puoi creare il cluster in Cloud Console. Per arrivarci, fai clic su menu di navigazione > Kubernetes Engine > Cluster > Crea cluster. Puoi creare un cluster in un'altra zona, ma ti consigliamo di rimanere nella stessa regione del bucket di archiviazione utilizzato da Container Registry.

Ora dovresti avere un cluster Kubernetes completamente funzionante basato su GKE.

È ora di eseguire il deployment dell'app containerizzata nel cluster Kubernetes. D'ora in poi, utilizzerai la riga di comando kubectl (già configurata nel tuo ambiente Cloud Shell). Il resto del codelab richiede che la versione del client e del server Kubernetes sia 1.2 o successive. kubectl version mostrerà la versione attuale del comando.

1. Un deployment Kubernetes può creare, gestire e scalare più istanze della tua app utilizzando l'immagine container che hai creato. Esegui il deployment di un'istanza della tua app in Kubernetes utilizzando il comando kubectl run.

$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

2. Per visualizzare il deployment che hai creato, esegui questo comando:

$ kubectl get deployments
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s

3. Per visualizzare le istanze dell'app create dal deployment, esegui questo comando:

$ kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-java-714049816-ztzrb   1/1       Running   0          57s

A questo punto, il container dovrebbe essere in esecuzione sotto il controllo di Kubernetes, ma devi ancora renderlo accessibile al mondo esterno.

Per impostazione predefinita, il pod è accessibile solo tramite il suo IP interno all'interno del cluster. Per rendere accessibile il container hello-java dall'esterno della rete virtuale Kubernetes, devi esporre il pod come servizio Kubernetes.

1. In Cloud Shell, puoi esporre il pod a internet pubblico con il comando kubectl expose combinato con il flag --type=LoadBalancer. Il flag è obbligatorio per la creazione di un IP accessibile esternamente.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

Il flag utilizzato nel comando specifica che utilizzerai il bilanciatore del carico fornito dall'infrastruttura sottostante. Tieni presente che esponi direttamente il deployment, non il pod. In questo modo, il servizio risultante bilancia il carico del traffico su tutti i pod gestiti dal deployment (in questo caso, un solo pod, ma in seguito aggiungerai altre repliche).

Il master Kubernetes crea il bilanciatore del carico e le regole di forwarding, i pool di destinazione e le regole firewall di Compute Engine correlate per rendere il servizio completamente accessibile dall'esterno di Google Cloud.

2. Per trovare l'indirizzo IP accessibile pubblicamente del servizio, richiedi semplicemente kubectl per elencare tutti i servizi del cluster.

$ kubectl get services
NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
Hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Nota: potrebbero essere necessari diversi minuti prima che EXTERNAL-IP diventi disponibile e visibile. Se EXTERNAL-IP non è presente, attendi qualche minuto e riprova.

3. Tieni presente che per il tuo servizio sono elencati due indirizzi IP, entrambi sulla porta 8080. Uno è l'indirizzo IP interno, visibile solo all'interno del tuo Virtual Private Cloud. L'altro è l'indirizzo IP con bilanciamento del carico esterno. Nell'esempio, l'indirizzo IP esterno è aaa.bbb.ccc.ddd. Ora dovresti essere in grado di raggiungere il servizio puntando il browser su http://<EXTERNAL_IP>:8080.

Una delle potenti funzionalità offerte da Kubernetes è la facilità di scalabilità della tua app. Supponiamo che tu abbia improvvisamente bisogno di più capacità per la tua app. Puoi semplicemente chiedere al controller di replica di gestire un nuovo numero di repliche per le istanze dell'app.

$ kubectl scale deployment hello-java --replicas=3
deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

Nota l'approccio dichiarativo. Anziché avviare o arrestare nuove istanze, dichiari quante istanze devono essere in esecuzione in ogni momento. I cicli di riconciliazione di Kubernetes si assicurano semplicemente che la realtà corrisponda a ciò che hai richiesto e intervengono, se necessario.

A un certo punto, l'app di cui hai eseguito il deployment in produzione richiederà correzioni di bug o funzionalità aggiuntive. Kubernetes può aiutarti a eseguire il deployment di una nuova versione in produzione senza influire sugli utenti.

1. Apri l'editor di codice facendo clic su Avvia editor nel menu di Cloud Shell.
2. Vai a src/main/java/hello/HelloController.java e aggiorna il valore della risposta.

package hello;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {    
    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. Utilizza Jib per creare ed eseguire il push di una nuova versione dell'immagine container.

$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Nota : la creazione e il push dell'immagine aggiornata dovrebbero essere molto più rapidi, in quanto sfruttano appieno la memorizzazione nella cache.

Kubernetes è pronto per aggiornare senza problemi il controller di replica alla nuova versione dell'app.

4. Per modificare l'etichetta dell'immagine per il container in esecuzione, devi modificare il deployment hello-java esistente e cambiare l'immagine da gcr.io/PROJECT_ID/hello-java:v1 a gcr.io/PROJECT_ID/hello-java:v2.

5. Puoi utilizzare il comando kubectl set image per chiedere a Kubernetes di eseguire il deployment della nuova versione dell'app nell'intero cluster un'istanza alla volta con aggiornamenti in sequenza.

$ kubectl set image deployment/hello-java \
  hello-java=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

Nota : durante questo processo, gli utenti dei servizi potrebbero riscontrare interruzioni, ma ciò è dovuto al fatto che non è stato configurato alcun controllo di integrità. Si tratta di una configurazione leggermente più avanzata che non rientra nell'ambito del codelab.

6. Controlla di nuovo http://EXTERNAL_IP:8080 per verificare che restituisca la nuova risposta.

Spiacenti. Hai commesso un errore con una nuova versione dell'app? Forse la nuova versione conteneva un errore e devi eseguire rapidamente il rollback. Con Kubernetes, puoi ripristinare facilmente lo stato precedente. Esegui il rollback dell'app eseguendo questo comando:

$ kubectl rollout undo deployment/hello-java

Hai imparato a creare ed eseguire il deployment di una nuova app web basata su Java in Kubernetes su GKE.

Scopri di più

• Java su Google Cloud
• Esempi di codice Java
• Kubernetes su GKE: dalle nozioni di base a quelle avanzate