Azure Fundamentals · Lektion

Azure Container Instances

Starta en containeriserad applikation på några sekunder med ACI utan att hantera servrar, konfigurera miljövariabler och volymmonteringar och förstå hur ACI debiteras.

Lektion 2 av 413 steg

Azure Container Instances är en gratis lektion i Azure Fundamentals på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Azure Fundamentals, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Azure Fundamentals innehåller totalt 4 lektioner.

Vad är Azure Container Instances?

Azure Container Instances (ACI) är det snabbaste sättet att köra en containeriserad arbetsbelastning i Azure utan att hantera servrar eller orkestrerare. Ni anger en containeravbildning, och Azure kör den på några sekunder i en delad infrastruktur med flera klienter. ACI passar utmärkt för kortvariga uppgifter, batchjobb, byggagenter och händelsestyrda arbetsbelastningar där det skulle innebära onödig överbelastning att starta ett helt Kubernetes-kluster.

Skapa en containerinstans

Starta en ACI-container med ett enda az container create-kommando. Ange avbildningen, resursgruppen, processorn och minnet. ACI hämtar avbildningen, tilldelar resurser och startar containern – vanligtvis inom 5–10 sekunder. Varje containerinstans får ett unikt fullständigt kvalificerat domännamn (FQDN) om ni tilldelar en DNS-namnetikett, vilket gör den omedelbart åtkomlig från internet.

# Run an Nginx container accessible from the internet
az container create \
  --name my-nginx \
  --resource-group MyRG \
  --image nginx:latest \
  --cpu 1 \
  --memory 1 \
  --dns-name-label my-nginx-demo \
  --ports 80

# Access at: http://my-nginx-demo.<region>.azurecontainer.io

Miljövariabler och säkra värden

Skicka konfiguration till ACI-containrar med hjälp av miljövariabler som anges när containern skapas. För känsliga värden, till exempel API-nycklar eller lösenord, använder ni säkra miljövariabler – dessa visas inte i Azure-portalen eller CLI-utdata efter distributionen, vilket förhindrar att de oavsiktligt exponeras i loggar eller granskningsspår. Säkra värden är fortfarande åtkomliga inifrån containern under körning som vanliga miljövariabler.

# Pass regular and secure environment variables
az container create \
  --name my-app \
  --resource-group MyRG \
  --image mycontainerregistry.azurecr.io/myapp:v1.0 \
  --environment-variables APP_ENV=production \
  --secure-environment-variables \
    DATABASE_PASSWORD='super-secret-password' \
    API_KEY='my-api-key'

# View logs from the running container
az container logs --name my-app --resource-group MyRG

ACI-fakturering och resursallokering

ACI debiteras per sekund baserat på de CPU-kärnor och den mängd minne i GB som ni tilldelar, utan någon minsta debiteringsperiod. Ni betalar endast medan containern körs – så snart den stoppas upphör debiteringen. Därför är ACI mycket kostnadseffektivt för kortvariga arbetsbelastningar. Ni kan tilldela mellan 0,1 och 4 CPU-kärnor samt mellan 0,1 och 16 GB minne per containergupp, i kombinationer som stöds.

# Small: 0.5 CPU, 0.5 GB memory
az container create --name small-task --resource-group MyRG \
  --image my-batch-image:latest --cpu 0.5 --memory 0.5 \
  --restart-policy Never  # Don't restart after completion

# Large: 4 CPU, 16 GB memory for intensive tasks
az container create --name ml-inference --resource-group MyRG \
  --image ml-model:latest --cpu 4 --memory 16

Omstartprinciper

ACI stöder tre omstartprinciper som styr hur containern hanteras efter att den avslutas. Always (standard) startar om containern varje gång den avslutas – lämpligt för långvariga tjänster. Never kör containern en gång och lämnar den i avslutat tillstånd – idealiskt för batchjobb. OnFailure startar endast om containern när den avslutas med en slutkod som inte är noll – användbart för mönster med nytt försök vid fel.

# Batch job: run once, never restart
az container create \
  --name data-processor \
  --resource-group MyRG \
  --image my-batch-image:latest \
  --restart-policy Never \
  --environment-variables BATCH_DATE=2025-01-01

# Check the container's final state
az container show \
  --name data-processor \
  --resource-group MyRG \
  --query '{state:instanceView.state, exitCode:instanceView.currentState.exitCode}'

Containerg grupper: distributioner med flera containrar

En containergupp är en samling containrar som delar livscykel, nätverk och lagring – ungefär som en Kubernetes-pod. Containrar i samma grupp delar en lokal IP-adress och ett portnamnområde, vilket gör att de kan kommunicera via localhost. Ett vanligt mönster är en huvudcontainer för applikationen och en sidecar-container (till exempel en loggningsagent eller proxy) i samma grupp, definierade med en YAML- eller ARM-mall.

# multi-container.yaml
apiVersion: '2021-09-01'
location: eastus
name: my-container-group
properties:
  containers:
  - name: app
    properties:
      image: myapp:v1.0
      ports: [{port: 80}]
      resources: {requests: {cpu: 1, memoryInGb: 1}}
  - name: log-forwarder
    properties:
      image: fluent-bit:latest
      resources: {requests: {cpu: 0.5, memoryInGb: 0.5}}
  osType: Linux
  restartPolicy: Always
type: Microsoft.ContainerInstance/containerGroups

# Deploy from YAML
# az container create --resource-group MyRG --file multi-container.yaml

Volymmonteringar: integrering med Azure Files

ACI-containrar är tillståndslösa som standard – data som skrivs till containerns filsystem går förlorade när containern startas om. Montera en Azure Files-resurs som en volym för att bevara data mellan omstarter av containern eller dela data mellan containrar i samma grupp. Ange lagringskontots namn, nyckel och filresursens namn när containerinstansen skapas.

# Mount an Azure Files share for persistent storage
az container create \
  --name stateful-app \
  --resource-group MyRG \
  --image myapp:v1.0 \
  --azure-file-volume-account-name mystorageaccount \
  --azure-file-volume-account-key '<storage-account-key>' \
  --azure-file-volume-share-name myfileshare \
  --azure-file-volume-mount-path /data

# Data written to /data persists in the Azure Files share

GPU-containerinstanser

ACI stöder GPU-containerinstanser (K80, V100) för arbetsbelastningar som maskininlärningsinferens, videobearbetning och vetenskapliga beräkningar. GPU-instanser är tillgängliga i utvalda regioner och kräver Linux-containrar. De debiteras per GPU och sekund, vilket gör dem ekonomiska för scenarier med tillfällig inferens där ni startar en GPU-container, kör modellen och omedelbart tar bort den – mycket billigare än en dedikerad GPU-VM som körs dygnet runt.

# Create a GPU-enabled container instance
az container create \
  --name gpu-inference \
  --resource-group MyRG \
  --image my-ml-model:latest \
  --gpu-count 1 \
  --gpu-sku V100 \
  --cpu 4 \
  --memory 16 \
  --os-type Linux

ACI med virtuellt nätverk

Distribuera ACI-containergupper till ett dedikerat undernät i ett VNet för att ge dem privata IP-adresser och låta dem nå andra VNet-anslutna resurser (databaser, virtuella datorer) utan att exponera dem på internet. VNet-integrerad ACI kräver ett dedikerat, delegerat undernät (delegerat till Microsoft.ContainerInstance/containerGroups) och stöder inte tilldelning av offentliga IP-adresser.

# Create an ACI container in a VNet
az container create \
  --name private-task \
  --resource-group MyRG \
  --image myapp:v1.0 \
  --vnet MyVNet \
  --subnet ContainerSubnet \
  --restart-policy Never

# The container gets a private IP from the subnet CIDR
# It can reach VNet resources (SQL, Redis, VMs) on private IPs

ACI som en Virtual Kubelet-nod

ACI integreras med AKS som en virtuell nod via open source-projektet Virtual Kubelet. När ett AKS-kluster utsätts för en tillfällig belastning som överstiger kapaciteten hos dess virtuella datornoder kan Kubernetes schemalägga poddar på en virtuell ACI-nod – vilket startar riktiga ACI-containerinstanser. Detta ger obegränsad tillfällig skalning utan att extra virtuella datornoder behöver förberedas i förväg, och ni betalar endast för ACI-beräkningen under perioden med hög belastning.

# Enable virtual nodes on an AKS cluster
az aks enable-addons \
  --name myAKSCluster \
  --resource-group MyRG \
  --addons virtual-node \
  --subnet-name VirtualNodeSubnet

# Schedule a burst pod on ACI via node selector
# spec:
#   nodeSelector:
#     kubernetes.io/role: agent
#     beta.kubernetes.io/os: linux
#     type: virtual-kubelet
#   tolerations:
#   - key: virtual-kubelet.io/provider
#     operator: Exists

När ska ni använda ACI, AKS eller App Service?

Välj ACI för kortvariga uppgifter, batchjobb, CI-byggagenter och enstaka containrar där Kubernetes över huvud taget inte behövs. Välj AKS för långvariga mikrotjänster med flera containrar som kräver tjänsteidentifiering, hälsokontroller, fortlöpande uppdateringar och klusternätverk. Välj App Service när ni vill ha fördelarna med PaaS (distributionsplatser, hanterade certifikat och inbyggd autentisering) utan att själva behöva hantera containernätverk.

Snabbkontroll

Testa era kunskaper om begreppen i Microsoft Azure Fundamentals (AZ-900) från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen har ni lärt er att Azure Container Instances kör containrar på några sekunder utan serverhantering och debiterar per CPU- och minnessekund, att containergupper gör det möjligt för flera containrar att dela nätverk och lagring som en Kubernetes-pod och att omstartprinciper (Always, Never, OnFailure) styr containerns livscykel efter avslut. Nästa avsnitt handlar om Kubernetes-koncept för Azure.

Gratis att börja

Lär dig Azure Fundamentals med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Azure Container Instances” gratis?

Ja – hela texten till ”Azure Container Instances” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Azure Fundamentals, kan Ni uppgradera till CoddyKit PRO. Kursen i Azure Fundamentals innehåller totalt 4 lektioner.

Vad lär jag mig i ”Azure Container Instances”?

Starta en containeriserad applikation på några sekunder med ACI utan att hantera servrar, konfigurera miljövariabler och volymmonteringar och förstå hur ACI debiteras. Ni övar på Azure Fundamentals med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Azure Fundamentals?

Du behöver inga förkunskaper. Utbildningen i Azure Fundamentals på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Azure Container Instances”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Azure Fundamentals-lektionen?

Ja. Varje Azure Fundamentals-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Azure Fundamentals