Distribuire un'applicazione Spring Boot nel servizio Azure Kubernetes

Nota

Per le applicazioni Spring Boot, è consigliabile usare Azure Spring Apps. Tuttavia, è comunque possibile scegliere di usare servizio Azure Kubernetes come destinazione. Per altre informazioni, vedere Scegliere i servizi di Azure corretti per le applicazioni Java.

Questa esercitazione illustra come combinare Kubernetes e Docker per sviluppare e distribuire un'applicazione Spring Boot in Microsoft Azure. In particolare, si userà Spring Boot per lo sviluppo dell'applicazione, Kubernetes per la distribuzione del contenitore e il servizio Azure Kubernetes per l'hosting dell'applicazione.

Kubernetes e Docker sono soluzioni open source che consentono agli sviluppatori di automatizzare la distribuzione, il ridimensionamento e la gestione delle applicazioni eseguite in contenitori.

Prerequisiti

• Sottoscrizione di Azure; se non si ha una sottoscrizione di Azure, è possibile attivare i vantaggi per i sottoscrittori di MSDN oppure iscriversi per ottenere un account Azure gratuito.
• Interfaccia della riga di comando di Azure.
• Java Development Kit (JDK) supportato. Per altre informazioni sui JDK disponibili per l'uso durante lo sviluppo in Azure, vedere Supporto java in Azure e Azure Stack.
• Lo strumento di compilazione Maven di Apache (versione 3).
• Un client Git.
• Un client Docker.
• L'helper per le credenziali Docker di Registro Azure Container.

Nota

A causa dei requisiti di virtualizzazione di questa esercitazione, non è possibile seguire la procedura illustrata in questo articolo in una macchina virtuale. È necessario usare un computer fisico in cui sono abilitate le funzionalità di virtualizzazione.

Creare l'app Web introduttiva di Spring Boot in Docker

La procedura seguente illustra come creare un'applicazione Web di Spring Boot e come testarla in locale.

1. Aprire un prompt dei comandi e creare una directory locale in cui contenere l'applicazione, quindi passare a tale directory. Ad esempio:

   mkdir C:\SpringBoot
   cd C:\SpringBoot
   

   -- o --

   mkdir /users/$USER/SpringBoot
   cd /users/$USER/SpringBoot
   

2. Clonare il progetto di esempio Spring Boot on Docker Getting Started (Introduzione a Spring Boot in Docker) nella directory.

   git clone https://github.com/spring-guides/gs-spring-boot-docker.git
   

3. Passare alla directory del progetto completato.

   cd gs-spring-boot-docker
   cd complete
   

4. Usare Maven per compilare ed eseguire l'app di esempio.

   mvn package spring-boot:run
   

5. Testare l'app Web passando a http://localhost:8080 oppure con il comando curl seguente:

   curl http://localhost:8080
   

6. Dovrebbe essere visualizzato il messaggio seguente: Hello Docker World

   

Creare un'istanza di Registro Azure Container usando l'interfaccia della riga di comando di Azure

1. Apri un prompt dei comandi.

2. Accedere all'account di Azure:

   az login
   

3. Scegliere la sottoscrizione di Azure:

   az account set -s <YourSubscriptionID>
   

4. Creare un gruppo di risorse per le risorse di Azure usate in questa esercitazione.

   az group create --name=wingtiptoys-kubernetes --location=eastus
   

5. Creare un Registro Azure Container privato nel gruppo di risorse. L'esercitazione effettua il push dell'app di esempio come immagine Docker in questo registro nei passaggi successivi. Sostituire wingtiptoysregistry con un nome univoco da assegnare al registro.

   az acr create --resource-group wingtiptoys-kubernetes --location eastus \
    --name wingtiptoysregistry --sku Basic
   

Eseguire il push dell'app nel registro contenitori tramite Jib

1. Accedere a Registro Azure Container dall'interfaccia della riga di comando di Azure.

   # set the default name for Azure Container Registry, otherwise you need to specify the name in "az acr login"
   az config set defaults.acr=wingtiptoysregistry
   az acr login
   

2. Aprire il file pom.xml con un editor di testo, ad esempio Visual Studio Code.

   code pom.xml
   

3. Aggiornare la raccolta <properties> nel file pom.xml con il nome registro dell'istanza di Registro Azure Container e la versione più recente di jib-maven-plugin.

   <properties>
      <!-- Note: If your ACR name contains upper case characters, be sure to convert them to lower case characters. -->
      <docker.image.prefix>wingtiptoysregistry.azurecr.io</docker.image.prefix>
      <jib-maven-plugin.version>2.5.2</jib-maven-plugin.version>
      <java.version>1.8</java.version>
   </properties>
   

4. Aggiornare la raccolta <plugins> nel file pom.xml in modo che l'elemento <plugin> contenga una voce per jib-maven-plugin, come illustrato nell'esempio seguente. Si noti che si sta usando un'immagine di base di Microsoft Container Registry, mcr.microsoft.com/openjdk/jdk:11-ubuntu, che contiene una versione di JDK supportata ufficialmente per Azure. Per altre immagini di base MCR con JDK ufficialmente supportati, vedere Installare la build Microsoft di OpenJDK.

   <plugin>
     <artifactId>jib-maven-plugin</artifactId>
     <groupId>com.google.cloud.tools</groupId>
     <version>${jib-maven-plugin.version}</version>
     <configuration>
        <from>
            <image>mcr.microsoft.com/openjdk/jdk:11-ubuntu</image>
        </from>
        <to>
            <image>${docker.image.prefix}/gs-spring-boot-docker</image>
        </to>
     </configuration>
   </plugin>
   

5. Passare alla directory del progetto completato per l'applicazione Spring Boot ed eseguire questo comando per creare l'immagine ed eseguire il push dell'immagine nel registro:

   az acr login && mvn compile jib:build
   

Nota

A causa del problema di sicurezza dell'interfaccia della riga di comando di Azure e Registro Azure Container, le credenziali create da az acr login sono valide per 1 ora. Se viene visualizzato un errore 401 Non autorizzato , è possibile eseguire di nuovo il comando per ripetere l'autenticazione az acr login --name <your registry name> . Se viene visualizzato un errore di timeout di lettura, è possibile provare ad aumentare i timeout con mvn -Djib.httpTimeout=7200000 jib:dockerBuildo -Djib.httpTimeout=0 per un timeout infinito.

Creare un cluster Kubernetes nel servizio Azure Container usando l'interfaccia della riga di comando di Azure

1. Creare un cluster Kubernetes nel servizio Azure Kubernetes. Il comando seguente crea un cluster kubernetes nel gruppo di risorse wingtiptoys-kubernetes, con wingtiptoys-akscluster come nome del cluster, con wingtiptoysregistry come Registro Azure Container collegato e con wingtiptoys-kubernetes come prefisso DNS:

   az aks create --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster \
    --attach-acr wingtiptoysregistry \
    --dns-name-prefix=wingtiptoys-kubernetes --generate-ssh-keys
   

   Il completamento di questo comando può richiedere alcuni minuti.

2. Installare kubectl usando l'interfaccia della riga di comando di Azure. È possibile che gli utenti Linux debbano aggiungere al comando il prefisso sudo, perché distribuisce l'interfaccia della riga di comando di Kubernetes in /usr/local/bin.

   az aks install-cli
   

3. Scaricare le informazioni sulla configurazione del cluster, in modo da consentire la gestione del cluster dall'interfaccia Web di Kubernetes e kubectl.

   az aks get-credentials --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster
   

Distribuire l'immagine nel cluster Kubernetes

Questa esercitazione consente di distribuire l'app usando kubectl e quindi di esplorare la distribuzione tramite l'interfaccia Web di Kubernetes.

Eseguire la distribuzione con kubectl

1. Apri un prompt dei comandi.

2. Eseguire il contenitore nel cluster Kubernetes usando il comando kubectl run. Specificare un nome di servizio per l'app in Kubernetes e il nome completo dell'immagine. Ad esempio:

   kubectl run gs-spring-boot-docker --image=wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

   In questo comando:

   • Il nome del contenitore gs-spring-boot-docker viene specificato immediatamente dopo il comando run.

   • Il parametro --image specifica il nome combinato del server di accesso e dell'immagine come wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest.

3. Esporre esternamente il cluster Kubernetes usando il comando kubectl expose. Specificare il nome del servizio, la porta TCP pubblica usata per accedere all'app e la porta di destinazione interna su cui è in ascolto l'app. Ad esempio:

   kubectl expose pod gs-spring-boot-docker --type=LoadBalancer --port=80 --target-port=8080
   

   In questo comando:

   • Il nome del contenitore gs-spring-boot-docker viene specificato immediatamente dopo il comando expose pod.

   • Il parametro --type specifica che il cluster usa il bilanciamento del carico.

   • Il parametro --port specifica la porta TCP pubblica, ovvero 80. Si accede all'app tramite questa porta.

   • Il parametro --target-port specifica la porta TCP interna, ovvero 8080. Il servizio di bilanciamento del carico inoltra le richieste all'app su questa porta.

4. Dopo la distribuzione dell'app nel cluster, eseguire query sull'indirizzo IP esterno e aprirlo nel Web browser:

   kubectl get services -o=jsonpath='{.items[*].status.loadBalancer.ingress[0].ip}'
   

   

Eseguire la distribuzione con la visualizzazione delle risorse Kubernetes

1. Selezionare Aggiungi da una delle visualizzazioni delle risorse (spazio dei nomi, carichi di lavoro, servizi e ingresso, Archiviazione o configurazione).

   

2. Incollare il codice YAML seguente:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gs-spring-boot-docker
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gs-spring-boot-docker
     template:
       metadata:
         labels:
           app: gs-spring-boot-docker
       spec:
         containers:
         - name: gs-spring-boot-docker
           image: wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

3. Selezionare Aggiungi nella parte inferiore dell'editor YAML per distribuire l'applicazione.

   

   Dopo aver distribuito , Deploymentcome sopra, selezionare Aggiungi nella parte inferiore dell'editor YAML per eseguire la distribuzione Service usando il codice YAML seguente:

   apiVersion: v1
   kind: Service
   metadata:
     name: gs-spring-boot-docker
   spec:
     type: LoadBalancer
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: gs-spring-boot-docker
   

4. Dopo aver aggiunto il file YAML, il visualizzatore risorse mostra l'applicazione Spring Boot. Il servizio esterno include un indirizzo IP esterno collegato in modo da poter visualizzare facilmente l'applicazione nel browser.

   

   

5. Selezionare IP esterno. Verrà quindi visualizzata l'applicazione Spring Boot in esecuzione in Azure.

   

Passaggi successivi

Per altre informazioni su Spring e Azure, passare al centro di documentazione di Spring in Azure.

Spring in Azure

Vedi anche

Per altre informazioni sull'uso di Spring Boot in Azure, vedere l'articolo seguente:

• Distribuire un'applicazione Spring Boot in Linux nel Servizio app di Azure

Per altre informazioni sull'uso di Azure con Java, vedere Azure per sviluppatori Java e la documentazione relativa all'uso di Azure DevOps e Java.

Per altre informazioni sulla distribuzione di un'applicazione Java in Kubernetes con Visual Studio Code, vedere le esercitazioni su Java in Visual Studio Code.

Per altre informazioni sul progetto di esempio di Spring Boot in Docker, vedere Spring Boot on Docker Getting Started (Introduzione a Spring Boot in Docker).

I collegamenti seguenti forniscono informazioni aggiuntive sulla creazione di applicazioni Spring Boot:

• Per altre informazioni sulla creazione di una semplice applicazione Spring Boot, vedere Spring Initializr all'indirizzo https://start.spring.io/.

I collegamenti seguenti forniscono informazioni aggiuntive sull'uso di Kubernetes con Azure:

• Introduzione ai cluster Kubernetes nel servizio Azure Kubernetes

Per altre informazioni sull'uso dell'interfaccia della riga di comando di Kubernetes, vedere la guida dell'utente di kubectl all'indirizzo https://kubernetes.io/docs/reference/kubectl/.

Il sito Web Kubernetes include alcuni articoli relativi all'uso delle immagini nei registri privati:

• Configuring Service Accounts for Pods (Configurazione degli account del servizio per i pod)
• Namespaces (Spazi dei nomi)
• Pulling an Image from a Private Registry (Effettuare il pull di un'immagine da un registro privato)

Per altri esempi sull'uso delle immagini personalizzate di Docker con Azure, vedere Uso di un'immagine Docker personalizzata per App Web di Azure in Linux.

Per altre informazioni sull'esecuzione iterativa e il debug di contenitori direttamente nel servizio Azure Kubernetes con Azure Dev Spaces, vedere Introduzione ad Azure Dev Spaces con Java