Självstudie – Förbereda ett program för Azure Kubernetes Service (AKS)

Artikel
03/20/2024

I den här självstudien, som är del ett av sju, förbereder du ett program med flera containrar som ska användas i Kubernetes. Du använder befintliga utvecklingsverktyg som Docker Compose för att bygga och testa programmet lokalt. Du lär dig att:

Klona en exempelprogramkälla från GitHub.
Skapa en containeravbildning från exempelprogrammets källa.
Testa programmet med flera containrar i en lokal Docker-miljö.

När det är klart körs följande program i din lokala utvecklingsmiljö:

I senare självstudier laddar du upp containeravbildningen till ett Azure Container Registry (ACR) och distribuerar den sedan till ett AKS-kluster.

Innan du börjar

Den här självstudiekursen förutsätter grundläggande kunskaper om grundläggande Docker-begrepp som containrar, containeravbildningar och docker-kommandon. Läs mer om grunderna för containrar i Kom igång med Docker.

För att slutföra den här självstudien behöver du en lokal Docker-utvecklingsmiljö som kör Linux-containrar. Docker tillhandahåller paket som konfigurerar Docker i ett Mac-, Windows- eller Linux-system.

Kommentar

Azure Cloud Shell innehåller inte de Docker-komponenter som krävs för att slutföra varje steg i de här självstudierna. Därför rekommenderar vi att du använder en fullständig Docker-utvecklingsmiljö.

Hämta programkod

Exempelprogrammet som används i den här självstudien är en grundläggande store-klientapp, inklusive följande Kubernetes-distributioner och -tjänster:

Butiksfront: Webbprogram där kunder kan visa produkter och göra beställningar.
Produkttjänst: Visar produktinformation.
Ordertjänst: Gör beställningar.
Rabbit MQ: Meddelandekö för en orderkö.

Git
Azure Developer CLI

Använd git för att klona exempelprogrammet till utvecklingsmiljön.
```
git clone https://github.com/Azure-Samples/aks-store-demo.git
```
Ändra till den klonade katalogen.
```
cd aks-store-demo
```

Om du använder azd lokalt skapar du en tom katalog med namnet aks-store-demo som värd för azd-mallfilerna.
```
mkdir aks-store-demo
```
Ändra till den nya katalogen för att läsa in alla filer från azd-mallen.
```
cd aks-store-demo
```
Klona exempelprogrammet till aks-store-demo katalogen med kommandot [azd init][azd-init] med --template flaggan inställd på aks-store-demo.
```
azd init --template aks-store-demo
```

Granska Docker Compose-fil

Exempelprogrammet som du skapar i den här självstudien använder YAML-filen docker-compose-quickstart från lagringsplatsen som du klonade.

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

Skapa containeravbildningar och kör program

Docker
Azure Developer CLI

Du kan använda Docker Compose för att automatisera skapandet av containeravbildningar och distributionen av program med flera containrar.

Docker

Skapa containeravbildningen, ladda ned RabbitMQ-avbildningen och starta programmet med kommandot docker compose :
```
docker compose -f docker-compose-quickstart.yml up -d
```

Visa de skapade avbildningarna docker images med kommandot .

docker images

Följande komprimerade exempelutdata visar de skapade bilderna:

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

Visa containrar som körs med kommandot docker ps .

docker ps

Följande komprimerade exempelutdata visar fyra containrar som körs:

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

Testa programmet lokalt

Om du vill se ditt program som körs navigerar du till http://localhost:8080 i en lokal webbläsare. Exempelprogrammet läses in, som du ser i följande exempel:

På den här sidan kan du visa produkter, lägga till dem i kundvagnen och sedan göra en beställning.

Rensa resurser

Eftersom du har verifierat programmets funktioner kan du stoppa och ta bort de containrar som körs. Ta inte bort containeravbildningarna – du använder dem i nästa självstudie.

Stoppa och ta bort containerinstanserna och resurserna med kommandot docker-compose down .
```
docker compose down
```

När du använder azdfinns det inga manuella beroenden för containeravbildningar. azd hanterar etablering, distribution och rensning av dina program och kluster med azd up kommandona och azd down som liknar Docker.

Du kan anpassa förberedelsestegen så att de använder antingen Terraform eller Bicep innan du distribuerar klustret i infra avsnittet i .azure.yaml Som standard använder det här projektet Terraform:

infra:
  provider: terraform
  path: infra/terraform

Om du vill ändra providern till Bicep uppdaterar du filen på azure.yaml följande sätt:

infra:
  provider: bicep
  path: infra/bicep

I den här självstudien skapade du ett exempelprogram, skapade containeravbildningar för programmet och testade sedan programmet. Du har lärt dig att:

Klona en exempelprogramkälla från GitHub.
Skapa en containeravbildning från exempelprogrammets källa.
Testa programmet med flera containrar i en lokal Docker-miljö.

I nästa självstudie får du lära dig hur du lagrar containeravbildningar i en ACR.

Push-överföra avbildningar till Azure Container Registry