Condividi tramite


Esercitazione: Preparare un'applicazione per il servizio Azure Kubernetes

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:

Screenshot che mostra l'app Azure Store Front in esecuzione in locale aperta in un Web browser 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:

Screenshot dell'architettura di esempio di Azure Store.

  • 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.
  1. Usare git per clonare l'applicazione di esempio nell'ambiente di sviluppo.

    git clone https://github.com/Azure-Samples/aks-store-demo.git
    
  2. Passare alla directory clonata.

    cd 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 Compose può essere usato per automatizzare la compilazione di immagini del contenitore e la distribuzione di applicazioni multicontenitore.

Docker

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

Screenshot che mostra l'app Azure Store Front aperta in un browser locale.

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
    

Passaggi successivi

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.