Handledning – Förbered ett program för Azure Kubernetes Service (AKS)

I den här handledningen förbereder du en flercontainersapplikation att använda i Kubernetes. Du kan använda den här självstudien oavsett om du börjar med en ny exempelapp eller anpassar Docker Compose-begrepp för en app som du planerar att migrera till Azure Kubernetes Service (AKS). Du använder befintliga utvecklingsverktyg som Docker Compose för att bygga och testa programmet lokalt. Du lär dig att:

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

I senare självstudier laddar du upp containeravbildningen till en 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 på ett Mac, Windows eller Linux system.

Hämta programkod

Exempelapplikationen sample som används i denna handledning är en grundläggande butiksfrontapplikation som inkluderar följande Kubernetes-utplaceringar 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.
• RabbitMQ: Meddelandekö för en orderkö.

Granska Docker Compose-fil

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

I följande tabell sammanfattas viktiga standardvärden från exempelfilen Compose så att du snabbt kan se vilka tjänster, portar och beroenden som används i självstudien:

services:
  rabbitmq:
    image: rabbitmq:4.3.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
    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
    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

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

Kontrollera att Docker körs i Linux-containerläge innan du kör följande kommandon.

1. Från roten för den klonade lagringsplatsen aks-store-demo skapar du containeravbildningen, laddar ned RabbitMQ-avbildningen och startar programmet med docker compose kommandot :

   docker compose -f docker-compose-quickstart.yml up -d
   

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

3. 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:4.3.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.

Migrera dina egna Compose-filer

Om du redan har ett program som definierats i en Docker Compose-fil kan du använda den här självstudien som referens för lokal validering och sedan konvertera din befintliga Compose-konfiguration till Kubernetes-manifest. Använd verktyg som Kompose, Move2Kube, Docker Compose Bridge eller Podman för att konvertera Docker Compose-definitioner till Kubernetes-resurser. Mer information om den fullständiga konverteringsprocessen från början till slut finns i Kubernetes-dokumentationen om migrering av Docker Compose till Kubernetes och i AKS-översikten över migrering om du också migrerar från ett annat orkestreringsverktyg eller moderniseringsarbetsflöde.

Välj ett konverteringsverktyg

Använd den här tabellen när du behöver en snabb jämförelse av de vanligaste alternativen för Compose-to-Kubernetes.

Vilket verktyg ska jag välja?

• Om du vill ha ett snabbt konceptbevis eller startmanifest använder du Kompose.
• Om du använder Docker Desktop och vill ha en Docker-inbyggd sökväg använder du Docker Compose Bridge.
• Om du har en större migrering eller modernisering av flera tjänster använder du Move2Kube.
• Om du vill exportera från containrar eller poddar som körs använder du Podman.
• Om du redan har manifest och behöver paketering eller överlägg använder du Helm eller Kustomize.
• Om du behöver en lokal Kubernetes dev-loop efter konverteringen använder du Skaffold eller Tilt.
• Om du vill ha utkast till manifest eller migreringsförklaringar använder du AI-hjälp och validerar resultatet mot officiella Kubernetes- och AKS-riktlinjer.

Andra verktyg att tänka på:

• 8gwifi.org Kubernetes YAML-konverterare: Användbart för snabba onlineexperiment med små Compose-filer.
• Okteto: Användbart när du vill ha en molnbaserad eller fjärransluten Kubernetes-utvecklingsloop för programteam.
• Devtron: Användbart när du vill ha ett plattformsarbetsflöde kring Kubernetes-leverans efter konvertering.
• Portainer: Användbart när du vill ha en användargränssnittsdriven container och Kubernetes-hantering.

Konvertera dina Compose-filer

Använd följande kopierbara kommandon som utgångspunkt:

kompose convert
move2kube plan -s ./path && move2kube transform
docker compose bridge convert -o ./k8s/
podman kube generate mypod > k8s.yaml
skaffold init

Konverteringsexempel för Kompose

Kompose-verktyget med öppen källkod konverterar vanliga Docker Compose-inställningar till Kubernetes-objekt som Distributioner och tjänster.

1. Installera Kompose med följande kommando på Windows:

   curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-windows-amd64.exe -o kompose.exe
   

   Andra installationsalternativ finns i installationsanvisningarna för Kompose.

2. Kör Kompose från katalogen som innehåller filen docker-compose.yml .

   kompose convert
   

3. Granska de genererade Kubernetes YAML-filerna innan du distribuerar dem till AKS.

AI-assisterad konvertering

Du kan använda en AI-assistent för att skapa Kubernetes-manifest, jämföra Compose-inställningar med Kubernetes-motsvarigheter eller förklara varför en konvertering behöver manuella ändringar.

Allmän exempelprompt:

Convert this docker-compose.yml into production-ready Kubernetes manifests. Use Apps/v1, move secrets to Kubernetes Secret objects, map local volumes to PersistentVolumeClaims, and add readiness and liveness probes for the web service.

AKS-inriktad exempelprompt:

Convert this docker-compose.yml into AKS-ready Kubernetes manifests. Target an AKS cluster, push images to Azure Container Registry, use Apps/v1 objects, move secrets to Kubernetes Secret objects, map local volumes to Azure Files or Azure Disks-backed PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Granska alltid AI-utdata innan du tillämpar dem. Verifiera apiVersion värden, resursbegäranden och gränser, lagringsklasser, tjänstexponering och hälsoavsökningar.

Hantera vanliga översättningsproblem

Hur hanteras volymer?

Compose volumes behöver ofta Kubernetes beständiga volymer och en lagringsklass. I AKS ersätter du lokalt tillgängliga monteringar med tjänster som Azure Disks eller Azure Files.

Vad ersätter depends_on?

Compose depends_on framtvingar inte körberedskap i Kubernetes. Ersätt den med readiness-prober, startprober eller logik för init-containrar när det behövs.

Hur ska jag hantera hemligheter och miljövärden?

Miljövärden i Compose blir ofta Kubernetes-ConfigMap- eller Secret-resurser, eller integreringar med Azure Key Vault.

Vad händer med portar och ingress?

Compose ports motsvarar Kubernetes-objekt Service och ibland ingress- eller Gateway API-resurser, beroende på hur du publicerar applikationen.

Hur översätts hälsokontroller?

Compose-healthcheckinställningar omvandlas vanligtvis till Kubernetes liveness- och readiness-prober.

Vad händer med Compose-nätverk?

Compose-nätverk motsvaras vanligtvis i Kubernetes av tjänsteupptäckt via Services och kluster-DNS i stället för anpassade bryggnätverk.

Hur testar jag lokalt med Kubernetes?

Efter konverteringen distribuerar du de genererade manifesten till en lokal Kubernetes-miljö, till exempel kind eller minikube, och använder sedan Skaffold eller Tilt om du vill ha en snabbare edit-build-deploy-loop.

Tillämpa AKS-specifika justeringar efter konvertering

Kompose ger dig en startpunkt, men du behöver vanligtvis göra manuella ändringar för AKS:

• Uppdatera referenser till avbildningar så att de pekar på ditt Azure Container Registry (ACR).
• Ersätt lokal lagring och bind-monteringar med beständig lagring, till exempel Azure Disks eller Azure Files, beroende på behoven för din arbetsbelastning.
• Ersätt Compose-secrets eller miljöspecifika värden med Kubernetes Secrets, ConfigMaps eller Azure Key Vault-integreringar.
• Granska nätverks- och exponeringsinställningar, till exempel LoadBalanceringress- eller gatewaykonfiguration, baserat på hur du vill publicera appen i AKS.
• Kontrollera om tillståndskänsliga komponenter ska förbli distributioner eller övergå till mönster som StatefulSets när du behöver en stabil identitet eller ett stabilt lagringsbeteende.
• Kontrollera resursbegäranden, prober och eventuella antaganden om startordning, eftersom beteenden i Compose, till exempel depends_on, inte översätts direkt till Kubernetes körningsbeteende.

Arbetsflöde efter konvertering

1. Konvertera Compose-filen med hjälp av ett verktyg som Kompose, Move2Kube, Docker Compose Bridge, Podman eller ett AI-granskat förslag.
2. Granska och härda manifesten genom att åtgärda lagring, hemliga uppgifter, tjänstexponering, probar och avbildningsreferenser.
3. Paketera manifesten med Helm eller tillämpa miljöspecifika ändringar med Kustomize.
4. Skicka avbildningarna till ett register som ACR och distribuera sedan med GitOps, CI/CD eller direkta kubectl arbetsflöden.

Exempelsekvens: kompose convert –> granska manifest –> skicka bilder till ACR –> uppdatera bildreferenser –>kubectl apply eller helm install.

Rensa resurser

Om du följde arbetsflödet för Docker Compose kan du stoppa och ta bort de containrar som körs. Ta inte bort containeravbildningarna eftersom du kommer att använda dem i nästa handledning. Om du har följt Azure Developer CLI-arbetsflödet använder du azd down i stället för docker compose down.

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

docker compose down

Azure CLI-kommandon för utvecklare

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 du använder Terraform eller Bicep innan du distribuerar klustret i avsnittet infra i din 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 azure.yaml enligt följande:

infra:
  provider: bicep
  path: infra/bicep

Nästa steg

Azure CLI

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:

I nästa självstudie kommer du att lära dig hur du lagrar containerbilder i en ACR.

Azure Developer CLI (kommandoradsgränssnitt)

I den här handledningen klonade du ett exempelprogram med hjälp av azd. Du har lärt dig att:

I nästa självstudie får du lära dig hur du skapar ett kluster med hjälp av mallen azd som du klonade.