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

Artikel
10/15/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.

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

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-product-service    latest                       72f5cd7e6b84
aks-store-demo-order-service      latest                       54ad5de546f9
aks-store-demo-store-front        latest                       1125f85632ae
...

Visa containrar som körs med kommandot docker ps .

docker ps

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

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

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

Dela via