Esercitazione: Preparare un'applicazione per Servizio Azure Kubernetes (AKS)

In questa esercitazione si prepara un'applicazione multi-contenitore da usare in Kubernetes. È possibile usare questa esercitazione se si inizia con una nuova app di esempio o si adattano i concetti di Docker Compose per un'app di cui si intende eseguire la migrazione a Servizio Azure Kubernetes (AKS). Si usano strumenti di sviluppo esistenti come Docker Compose per compilare e testare localmente l'applicazione. Scopri come:

Al termine, l'applicazione seguente viene eseguita nell'ambiente di sviluppo locale:

Nei tutorial successivi, verrà caricata l'immagine del contenitore in un Registro Container di Azure (ACR) e poi distribuita in un cluster del servizio Azure Kubernetes.

Operazioni preliminari

Questa esercitazione presuppone una conoscenza di base dei concetti principali di Docker, ad esempio contenitori, immagini del contenitore e comandi docker. Per una panoramica sulle nozioni di base dei contenitori, vedere Get started with Docker (Introduzione a Docker).

Per completare questa esercitazione, è necessario un ambiente di sviluppo Docker locale in cui sono in esecuzione i contenitori Linux. Docker fornisce pacchetti che configurano Docker in un Mac, Windows o Linux.

Ottenere il codice dell'applicazione

L'applicazione sample usata in questa esercitazione è un'app front-store di base, incluse le distribuzioni e i servizi kubernetes seguenti:

• Vetrina di vendita: applicazione Web che consente ai clienti di visualizzare i prodotti ed effettuare ordini.
• Servizio prodotto: mostra le informazioni sul prodotto.
• Servizio ordini: effettua ordini.
• RabbitMQ: coda di messaggi per una coda di ordini.

Esaminare il file Docker Compose

L'applicazione di esempio che crei in questo tutorial utilizza il file YAML docker-compose-quickstart dal repository clonato.

La tabella seguente riepiloga le principali impostazioni predefinite del file Compose di esempio, così da poter vedere rapidamente quali servizi, porte e dipendenze vengono utilizzati nell'esercitazione:

services:
  rabbitmq:
    image: rabbitmq:4.3.2-management-alpine
    container_name: 'rabbitmq'
    restart: always
    environment:
      - "RABBITMQ_DEFAULT_USER=username"
      - "RABBITMQ_DEFAULT_PASS=password"
    ports:
      - 15672:15672
      - 5672:5672
    healthcheck:
      test: ["CMD", "rabbitmqctl", "status"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  order-service:
    build: src/order-service
    container_name: 'order-service'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://order-service:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - ORDER_QUEUE_HOSTNAME=rabbitmq
      - ORDER_QUEUE_PORT=5672
      - ORDER_QUEUE_USERNAME=username
      - ORDER_QUEUE_PASSWORD=password
      - ORDER_QUEUE_NAME=orders
    networks:
      - backend_services
    depends_on:
      rabbitmq:
        condition: service_healthy
  product-service:
    build: src/product-service
    container_name: 'product-service'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://product-service:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - AI_SERVICE_URL=http://ai-service:5001/
    networks:
      - backend_services
  store-front:
    build: src/store-front
    container_name: 'store-front'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://store-front:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://product-service:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://order-service:3000/
    networks:
      - backend_services
    depends_on:
      - product-service
      - order-service
networks:
  backend_services:
    driver: bridge

Creare immagini del contenitore ed eseguire l'applicazione

Docker Compose può essere usato per automatizzare la compilazione di immagini del contenitore e la distribuzione di applicazioni multicontenitore.

Assicurarsi che Docker sia in esecuzione in modalità contenitore Linux prima di eseguire i comandi seguenti.

1. Dalla radice del repository clonato aks-store-demo creare l'immagine del contenitore, scaricare l'immagine RabbitMQ e avviare l'applicazione usando il docker compose comando :

   docker compose -f docker-compose-quickstart.yml up -d
   

2. Visualizzare le immagini create usando il comando docker images .

   docker images
   

   L'output di esempio condensato seguente mostra le immagini create:

   REPOSITORY                        TAG                          IMAGE ID
   aks-store-demo-product-service    latest                       72f5cd7e6b84
   aks-store-demo-order-service      latest                       54ad5de546f9
   aks-store-demo-store-front        latest                       1125f85632ae
   ...
   

3. Visualizzare i contenitori in esecuzione usando il comando docker ps.

   docker ps
   

   L'output di esempio condensato seguente mostra quattro contenitori in esecuzione:

   CONTAINER ID        IMAGE
   f27fe74cfd0a        aks-store-demo-product-service
   df1eaa137885        aks-store-demo-order-service
   b3ce9e496e96        aks-store-demo-store-front
   31df28627ffa        rabbitmq:4.3.2-management-alpine
   

Testare l'applicazione in locale

Per visualizzare l'applicazione in esecuzione, passare a http://localhost:8080 in un Web browser locale. L'applicazione di esempio viene caricata, come illustrato nell'esempio seguente:

In questa pagina è possibile visualizzare i prodotti, aggiungerli al carrello e quindi effettuare un ordine.

Eseguire la migrazione dei propri file Compose

Se un'applicazione è già definita in un file Docker Compose, è possibile usare questa esercitazione come riferimento per la convalida locale, quindi convertire la configurazione compose esistente in manifesti Kubernetes. Usare strumenti come Kompose, Move2Kube, Docker Compose Bridge o Podman per convertire le definizioni docker Compose in risorse Kubernetes. Per l'intero processo di conversione end-to-end, consulta la documentazione di Kubernetes per la migrazione da Docker Compose a Kubernetes e la panoramica della migrazione di AKS, se esegui anche la migrazione da un altro orchestratore o da un altro processo di modernizzazione.

Scegliere uno strumento di conversione

Usare questa tabella quando è necessario un confronto rapido delle opzioni più comuni di Compose-to-Kubernetes.

Quale strumento devo scegliere?

• Se vuoi un rapido modello di verifica o manifesti di avvio, usa Kompose.
• Se si usa Docker Desktop e si vuole un percorso nativo docker, usare Docker Compose Bridge.
• Se si dispone di un maggiore impegno di migrazione o modernizzazione multiservizio, usare Move2Kube.
• Se si desidera esportare da container o pod in esecuzione, utilizzare Podman.
• Se sono già presenti manifesti e sono necessari pacchetti o sovrapposizioni, usare Helm o Kustomize.
• Se è necessario un ciclo di sviluppo Kubernetes locale dopo la conversione, usare Skaffold o Tilt.
• Se vuoi bozze di file manifest o spiegazioni sulla migrazione, usa l'assistenza dell'IA e convalidane il risultato rispetto alla documentazione ufficiale di Kubernetes e AKS.

Altri strumenti da considerare:

• 8gwifi.org Convertitore YAML di Kubernetes: utile per esperimenti online rapidi con piccoli file Compose.
• Okteto: utile quando si vuole un ciclo di sviluppo Kubernetes remoto o cloud per i team delle applicazioni.
• Devtron: utile quando si desidera un workflow di piattaforma per il rilascio su Kubernetes dopo la conversione.
• Portainer: utile quando si vuole un contenitore basato sull'interfaccia utente e un'esperienza di gestione kubernetes.

Converti i tuoi file Compose

Usare i comandi copiabili seguenti come punto di partenza:

kompose convert
move2kube plan -s ./path && move2kube transform
docker compose bridge convert -o ./k8s/
podman kube generate mypod > k8s.yaml
skaffold init

Esempio di conversione di Kompose

Lo strumento Kompose open source converte le impostazioni comuni di Docker Compose in oggetti Kubernetes, ad esempio distribuzioni e servizi.

1. In Windows installare Kompose con il comando seguente:

   curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-windows-amd64.exe -o kompose.exe
   

   Per altre opzioni di installazione, vedere le istruzioni di installazione di Kompose.

2. Eseguire Kompose dalla directory che contiene il docker-compose.yml file.

   kompose convert
   

3. Esamina i file YAML di Kubernetes generati prima di distribuirli in AKS.

Conversione assistita dall'intelligenza artificiale

È possibile usare un assistente di intelligenza artificiale per creare manifesti Kubernetes, confrontare le impostazioni compose con gli equivalenti kubernetes o spiegare perché una conversione richiede modifiche manuali.

Prompt di esempio generico:

Convert this docker-compose.yml into production-ready Kubernetes manifests. Use Apps/v1, move secrets to Kubernetes Secret objects, map local volumes to PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Prompt di esempio per AKS:

Convert this docker-compose.yml into AKS-ready Kubernetes manifests. Target an AKS cluster, push images to Azure Container Registry, use Apps/v1 objects, move secrets to Kubernetes Secret objects, map local volumes to Azure Files or Azure Disks-backed PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Esaminare sempre l'output di intelligenza artificiale prima di applicarlo. Convalidare i valori apiVersion, le richieste e i limiti delle risorse, le classi di archiviazione, l'esposizione del servizio e le sonde di integrità.

Gestire i problemi di traduzione comuni

Come vengono gestiti i volumi?

Compose volumes richiede spesso volumi permanenti Kubernetes e una classe di archiviazione. In AKS, sostituire i mount locali con servizi quali Azure Disks o File di Azure.

Cosa sostituisce depends_on?

Compose depends_on non applica l'idoneità del runtime in Kubernetes. Sostituirlo con probe di idoneità, probe di avvio o logica del contenitore init quando necessario.

Come si gestiscono i segreti e i valori dell'ambiente?

I valori di ambiente di Compose diventano spesso risorse Kubernetes ConfigMap o Secret integrazioni con Azure Key Vault.

Che cosa succede alle porte e al traffico in ingresso?

Gli oggetti Compose ports vengono mappati agli oggetti Kubernetes Service e talvolta alle risorse Ingress o Gateway API, a seconda di come si pubblica l'applicazione.

Come si traducono i controlli di integrità?

Le impostazioni di Compose healthcheck di solito diventano probe Kubernetes di integrità e prontezza.

Cosa succede alle reti Compose?

Le reti di Compose di solito vengono tradotte nel rilevamento dei servizi di Kubernetes tramite i servizi e il DNS del cluster, invece che tramite reti bridge personalizzate.

Come si esegue il test in locale con Kubernetes?

Dopo la conversione, distribuire i manifesti generati in un ambiente Kubernetes locale, ad esempio kind o minikube, quindi usare Skaffold o Tilt se si vuole un ciclo edit-build-deploy più veloce.

Applica modifiche specifiche di AKS dopo la conversione

Kompose offre un punto di partenza, ma in genere è necessario apportare modifiche manuali per AKS:

• Aggiornare i riferimenti alle immagini in modo che puntino al Registro Azure Container (ACR).
• Sostituisci l'archiviazione locale e i bind mount con archiviazione persistente, ad esempio Azure Disks o File di Azure, a seconda delle esigenze del carico di lavoro.
• Sostituire i segreti di Compose o i valori specifici dell'ambiente con Secret di Kubernetes, ConfigMap o le integrazioni di Azure Key Vault.
• Rivedi le impostazioni di rete e di esposizione, ad esempio LoadBalancer, ingress o la configurazione del gateway, in base a come vuoi pubblicare l'app in AKS.
• Controllare se i componenti con stato devono rimanere come distribuzioni o passare a modelli come StatefulSets quando è necessario un comportamento stabile di identità o archiviazione.
• Convalidare le richieste di risorse, i probe e i presupposti di ordinamento di avvio perché i comportamenti di Compose, depends_on ad esempio, non si traducono direttamente nel comportamento di runtime di Kubernetes.

Flusso di lavoro post-conversione

1. Convertire il file Compose con uno strumento come Kompose, Move2Kube, Docker Compose Bridge, Podman o una bozza esaminata dall'intelligenza artificiale.
2. Esaminare e rafforzare i manifesti correggendo archiviazione, segreti, esposizione del servizio, probe e riferimenti alle immagini.
3. Creare pacchetti dei manifest con Helm oppure applicare modifiche specifiche dell'ambiente con Kustomize.
4. Esegui il push delle immagini in un registro come ACR, quindi distribuisci con GitOps, CI/CD o flussi di lavoro diretti kubectl.

Sequenza di esempio: kompose convert -> esaminare i manifest -> eseguire il push delle immagini in ACR -> aggiornare i riferimenti delle immagini ->kubectl apply o helm install.

Pulire le risorse

Se è stato seguito il flusso di lavoro Docker Compose, è possibile arrestare e rimuovere i contenitori in esecuzione. Non eliminare le immagini del contenitore perché vengono usate nell'esercitazione successiva. Se hai seguito il flusso di lavoro di Azure Developer CLI, usa azd down invece di docker compose down.

Arrestare e rimuovere le istanze e le risorse del contenitore usando il comando docker compose down.

docker compose down

Comandi dell'interfaccia della riga di comando per sviluppatori Azure

Quando si usa azd, non esistono dipendenze manuali dell'immagine del contenitore. azd gestisce il provisioning, la distribuzione e la pulizia delle applicazioni e dei cluster con i comandi azd up e azd down, in modo analogo a Docker.

È possibile personalizzare i passaggi di preparazione per usare Terraform o Bicep prima di distribuire il cluster nella sezione infra del azure.yaml. Per impostazione predefinita, questo progetto usa Terraform:

infra:
  provider: terraform
  path: infra/terraform

Se si vuole modificare il provider in Bicep, aggiornare il file azure.yaml come indicato di seguito:

infra:
  provider: bicep
  path: infra/bicep

Passaggi successivi

Interfaccia CLI di Azure

In questa esercitazione è stata creata un'applicazione di esempio, sono state create immagini del contenitore per l'applicazione e quindi è stata testata l'applicazione. Si è appreso come:

Nel prossimo tutorial, imparerai come archiviare le immagini di contenitori in un ACR.

CLI per sviluppatori di Azure

In questa esercitazione è stata clonata un'applicazione di esempio usando azd. Si è appreso come:

Nell'esercitazione successiva si apprenderà come creare un cluster usando il modello azd clonato.