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

In questa esercitazione si prepara un'applicazione multi-contenitore da usare in Kubernetes. Si usano strumenti di sviluppo esistenti come Docker Compose per compilare e testare localmente l'applicazione. Scopri come:

Clonare il codice sorgente di un'applicazione di esempio da GitHub.
Creare un'immagine del container dal codice sorgente dell'applicazione di esempio.
Testare l'applicazione multicontenitore in un ambiente Docker locale.

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.

Nota

Azure Cloud Shell non include i componenti Docker necessari per completare ogni passaggio di queste esercitazioni. È pertanto consigliabile usare un ambiente di sviluppo completo di Docker.

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.

Git
CLI per sviluppatori di Azure

Creare una directory nel computer e passare a tale directory nella sessione del terminale, ad esempio Bash. In questo esempio viene usata una directory denominata demorepo , ma è possibile usare qualsiasi nome desiderato.
```
mkdir demorepo
cd demorepo
```
Usare git per clonare l'applicazione di esempio nell'ambiente di sviluppo.
```
git clone https://github.com/Azure-Samples/aks-store-demo.git
```
Passare alla directory clonata.
```
cd aks-store-demo
```

Se si usa azd localmente, creare una directory vuota denominata aks-store-demo per ospitare i file di modello azd.
```
mkdir aks-store-demo
```
Passare alla nuova directory per caricare tutti i file dal modello azd.
```
cd aks-store-demo
```
Clonare l'applicazione di esempio nella aks-store-demo directory usando il azd init comando con il --template flag impostato su aks-store-demo.
```
azd init --template aks-store-demo
```

Esaminare il file Docker Compose

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

services:
  rabbitmq:
    image: rabbitmq:3.13.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
    volumes:
      - ./rabbitmq_enabled_plugins:/etc/rabbitmq/enabled_plugins
    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
      - ORDER_QUEUE_RECONNECT_LIMIT=3
    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.

Creare l'immagine del contenitore, scaricare l'immagine RabbitMQ e avviare l'applicazione usando il comando docker compose:
```
docker compose -f docker-compose-quickstart.yml up -d
```

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

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:3.13.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.

Pulire le risorse

Poiché è stata convalidata la funzionalità dell'applicazione, è possibile arrestare e rimuovere i container in esecuzione. Non eliminare le immagini del contenitore perché vengono usate nell'esercitazione successiva.

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:

Clonare il codice sorgente di un'applicazione di esempio da GitHub.
Creare un'immagine del container dal codice sorgente dell'applicazione di esempio.
Testare l'applicazione multicontenitore in un ambiente Docker locale.

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

Push delle immagini al Registro Container di Azure

CLI per sviluppatori di Azure

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

Clonare un modello di esempio azd da GitHub.
Visualizza dove vengono utilizzate le immagini dei container nel codice sorgente dell'applicazione di esempio.

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

Creare un cluster AKS

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-05-14