Esercitazione: Preparare un'applicazione per il servizio Azure Kubernetes

Articolo
03/18/2024

In questa esercitazione, parte uno di sette, 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 l'origine di un'applicazione di esempio da GitHub.
Creare un'immagine del contenitore dall'origine 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:

Nelle esercitazioni successive si carica l'immagine del contenitore in un Registro Azure Container e quindi la si distribuisce 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 offre pacchetti che consentono di configurare Docker in un sistema Mac, Windows o Linux.

Nota

Azure Cloud Shell non include i componenti di 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 di esempio usata in questa esercitazione è un'app front-store di base che include le distribuzioni e i servizi Kubernetes seguenti:

Front-store: applicazione Web per i clienti per visualizzare i prodotti ed effettuare ordini.
Servizio prodotto: mostra le informazioni sul prodotto.
Servizio ordini: effettua ordini.
Rabbit MQ: coda di messaggi per una coda di ordini.

Git
Azure Developer CLI

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 comando [azd init][azd-init] con il --template flag impostato su aks-store-demo.
```
azd init --template aks-store-demo
```

Esaminare il file Docker Compose

L'applicazione di esempio creata in questa esercitazione usa il file YAML docker-compose-quickstart dal repository clonato.

version: "3.7"
services:
  rabbitmq:
    image: rabbitmq:3.11.17-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
  orderservice:
    build: src/order-service
    container_name: 'orderservice'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://orderservice: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
  productservice:
    build: src/product-service
    container_name: 'productservice'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://productservice:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  storefront:
    build: src/store-front
    container_name: 'storefront'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://storefront:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://productservice:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://orderservice:3000/
    networks:
      - backend_services
    depends_on:
      - productservice
      - orderservice
networks:
  backend_services:
    driver: bridge

Creare immagini del contenitore ed eseguire l'applicazione

Docker
Azure Developer CLI

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

Docker

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

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-productservice    latest                       2b66a7e91eca
aks-store-demo-orderservice      latest                       54ad5de546f9
aks-store-demo-storefront        latest                       d9e3ac46a225
rabbitmq                         3.11.17-management-alpine    79a570297657
...

Visualizzare i contenitori in esecuzione usando il comando docker ps.

docker ps

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

CONTAINER ID        IMAGE
21574cb38c1f        aks-store-demo-productservice
c30a5ed8d86a        aks-store-demo-orderservice
d10e5244f237        aks-store-demo-storefront
94e00b50b86a        rabbitmq:3.11.17-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 contenitori in esecuzione. Non eliminare le immagini del contenitore, verranno usate nell'esercitazione successiva.

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

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 azd up comandi e azd down , in modo analogo a Docker.

È possibile personalizzare i passaggi di preparazione per usare Terraform o Bicep prima di distribuire il cluster all'interno della infra sezione di 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 azure.yaml file nel modo seguente:

infra:
  provider: bicep
  path: infra/bicep

Passaggi successivi

Interfaccia della riga di comando di Azure
Azure Developer CLI

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

Clonare l'origine di un'applicazione di esempio da GitHub.
Creare un'immagine del contenitore dall'origine dell'applicazione di esempio.
Testare l'applicazione multicontenitore in un ambiente Docker locale.

Nell'esercitazione successiva si apprenderà come archiviare le immagini del contenitore in un Registro Azure Container.

Eseguire il push delle immagini in Registro Azure Container

In questa esercitazione è stata clonata un'applicazione di esempio usando azd. Contenuto del modulo:

Clonare un modello di esempio azd da GitHub.
Visualizzare la posizione in cui vengono usate le immagini del contenitore dall'origine dell'applicazione di esempio.

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

Creare un cluster del servizio Azure Kubernetes