Cloud & IT Cert Prep · Lektion

Distribuera arbetsbelastningar i AKS

Skapa ett AKS-kluster, distribuera en applikation med flera containrar med kubectl och Helm-diagram och exponera den externt med en Azure Load Balancer-tjänst.

Lektion 4 av 413 steg

Distribuera arbetsbelastningar i AKS är en gratis lektion i Cloud & IT Cert Prep på CoddyKit. Detta är lektion 4 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 Cloud & IT Cert Prep, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Cloud & IT Cert Prep innehåller totalt 4 lektioner.

Vad är Azure Kubernetes Service?

Azure Kubernetes Service (AKS) är en hanterad Kubernetes-tjänst där Microsoft driver och underhåller kontrollplanet (API-servern, etcd, schemaläggaren och så vidare) utan kostnad. Ni betalar endast för arbetarnoderna (VM:er). AKS hanterar uppgraderingar av Kubernetes-versionen, patchning av nodernas operativsystem, skalning av kontrollplanet samt integrering med Azure-nätverk, lagring och identitet. Det minskar avsevärt den operativa arbetsbördan med att köra Kubernetes i produktion.

Skapa ett AKS-kluster

Skapa ett AKS-kluster med az aks create och ange antal noder, VM-storlek och nätverksalternativ. AKS skapar automatiskt en nodresursgrupp som innehåller VM:er, hanterade diskar, nätverksgränssnitt och lastbalanserare. Det rekommenderade nätverksläget är Azure CNI — varje podd får en riktig VNet-IP-adress, vilket möjliggör direktanslutning till andra Azure-tjänster utan NAT.

# Create an AKS cluster with 3 nodes
az aks create \
  --name myAKSCluster \
  --resource-group MyRG \
  --location eastus \
  --node-count 3 \
  --node-vm-size Standard_D2s_v3 \
  --enable-managed-identity \
  --attach-acr mycontainerregistry \
  --network-plugin azure \
  --generate-ssh-keys

# Get kubectl credentials
az aks get-credentials --name myAKSCluster --resource-group MyRG

Nodpooler

AKS-kluster kan ha flera nodpooler — grupper av VM:er med samma konfiguration. Systemnodpoolen kör viktiga Kubernetes-systemkomponenter (kube-system-poddar). Användarnodpooler kör era programarbetsbelastningar. Separata pooler gör att ni kan blanda VM-SKU:er — en pool för allmän användning för webbappar och en GPU-pool för ML-arbetsbelastningar — och skala varje pool oberoende.

# Add a GPU node pool for ML workloads
az aks nodepool add \
  --cluster-name myAKSCluster \
  --resource-group MyRG \
  --name gpupool \
  --node-count 2 \
  --node-vm-size Standard_NC6s_v3 \
  --node-taints sku=gpu:NoSchedule

# List node pools
az aks nodepool list \
  --cluster-name myAKSCluster \
  --resource-group MyRG \
  -o table

Distribuera ett program med flera containrar

Distribuera ett program i flera nivåer till AKS genom att skriva separata Kubernetes-manifestfiler för varje nivå och tillämpa dem med kubectl apply. En typisk distribution innehåller en Deployment för webbnivån, en Deployment för API-nivån, Services som kopplar ihop dem, en ConfigMap för miljökonfiguration och en Ingress-resurs som exponerar appen externt via ett enda värdnamn.

# Apply all manifests in a directory
kubectl apply -f k8s/

# Or apply individual files
kubectl apply -f frontend-deployment.yaml
kubectl apply -f frontend-service.yaml
kubectl apply -f api-deployment.yaml
kubectl apply -f api-service.yaml
kubectl apply -f ingress.yaml

# Watch rollout status
kubectl rollout status deployment/frontend
kubectl rollout status deployment/api

Ingress och Application Gateway

En Ingress-resurs definierar HTTP-dirigeringsregler som mappar värdnamn och URL-sökvägar till backend-tjänster. Till skillnad från en LoadBalancer-tjänst (en extern IP-adress per tjänst) hanterar en enda Ingress-kontroller all extern HTTP-trafik och dirigerar den baserat på regler. I AKS använder ni NGINX Ingress Controller eller Application Gateway Ingress Controller (AGIC) för att terminera TLS och dirigera trafik till flera tjänster.

# Ingress routing traffic to two services by path
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  tls:
  - hosts: [myapp.contoso.com]
    secretName: myapp-tls
  rules:
  - host: myapp.contoso.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service: {name: api-svc, port: {number: 80}}
      - path: /
        pathType: Prefix
        backend:
          service: {name: frontend-svc, port: {number: 80}}

Helm-diagram för paketering av program

Helm är pakethanteraren för Kubernetes. Ett diagram samlar alla Kubernetes-manifest för ett program (Deployments, Services, Ingress, ConfigMaps) i ett enda versionshanterat och parametriserbart paket. helm install distribuerar ett diagram med miljöspecifika värden. Helm-repositoriet på Artifact Hub innehåller tusentals färdigbyggda diagram för vanlig infrastruktur (NGINX, cert-manager, Prometheus, Redis).

# Add the NGINX Ingress Controller chart repo
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Install NGINX Ingress Controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
  --namespace ingress-nginx \
  --create-namespace \
  --set controller.replicaCount=2

# Install your own app chart with custom values
helm install myapp ./charts/myapp -f values-prod.yaml

Rullande uppdateringar och återställningar

Uppdatera en Deployment genom att ändra containerns image-tagg — Kubernetes utför en rullande uppdatering, skapar nya poddar med den uppdaterade imagen och avslutar gradvis de gamla, så att programmet förblir tillgängligt under hela processen. Om den nya versionen inte fungerar kan ni omedelbart återgå till den föregående revisionen med kubectl rollout undo. Kubernetes sparar en konfigurerbar revisionshistorik för varje Deployment.

# Update the image to a new version
kubectl set image deployment/myapp \
  myapp=mycontainerregistry.azurecr.io/myapp:v2.0

# Watch the rollout progress
kubectl rollout status deployment/myapp

# View rollout history
kubectl rollout history deployment/myapp

# Rollback to the previous version
kubectl rollout undo deployment/myapp

# Rollback to a specific revision
kubectl rollout undo deployment/myapp --to-revision=2

Klusterautoskalning

Cluster Autoscaler lägger automatiskt till eller tar bort arbetarnoder från en AKS-nodpool baserat på väntande pods schemaläggning och nodernas användning. När pods inte kan schemaläggas eftersom alla noder är fulla etablerar Cluster Autoscaler nya noder. När noder är underutnyttjade och pods kan konsolideras tömmer och tar Cluster Autoscaler bort noder. Detta kompletterar Horizontal Pod Autoscaler — HPA skalar pods och Cluster Autoscaler skalar noder.

# Enable Cluster Autoscaler on the default node pool
az aks update \
  --name myAKSCluster \
  --resource-group MyRG \
  --enable-cluster-autoscaler \
  --min-count 2 \
  --max-count 10

# Update autoscaler bounds on a specific node pool
az aks nodepool update \
  --cluster-name myAKSCluster \
  --resource-group MyRG \
  --name nodepool1 \
  --enable-cluster-autoscaler \
  --min-count 3 \
  --max-count 20

AKS-övervakning med Azure Monitor

Aktivera Azure Monitor Container Insights för att samla in loggar och mätvärden från ert AKS-kluster utan att distribuera övervakningsverktyg från tredje part. Container Insights tillhandahåller färdiga instrumentpaneler för klusterhälsa, CPU- och minnesanvändning för noder och pods, containerloggar samt direktströmning av pods. Det integreras med Prometheus för insamling av anpassade mätvärden och gör det möjligt att fråga alla data med KQL i Log Analytics.

# Enable Azure Monitor Container Insights on AKS
az aks enable-addons \
  --addons monitoring \
  --name myAKSCluster \
  --resource-group MyRG \
  --workspace-resource-id /subscriptions/.../workspaces/MyLogAnalytics

# Stream live logs from a running pod
kubectl logs -f deployment/myapp -c myapp

# Query pod resource usage
kubectl top pods --namespace default

AKS-RBAC och Azure Active Directory

Integrera AKS med Microsoft Entra ID för att använda Azure AD-användare och grupper för Kubernetes-RBAC. I stället för att hantera separata Kubernetes-användarkonton tilldelar ni ClusterRole- eller Role-bindningar till Entra ID-objekt-ID:n. När en utvecklare kör kubectl validerar AKS utvecklarens Entra ID-token. Detta ger centraliserad identitetshantering och integreras med principer för villkorsstyrd åtkomst och MFA.

# Enable Entra ID RBAC on an AKS cluster
az aks update \
  --name myAKSCluster \
  --resource-group MyRG \
  --enable-azure-rbac

# Assign a built-in AKS role to an Entra group
az role assignment create \
  --role 'Azure Kubernetes Service RBAC Reader' \
  --assignee '<Entra-Group-Object-ID>' \
  --scope /subscriptions/.../resourceGroups/MyRG/providers/Microsoft.ContainerService/managedClusters/myAKSCluster

Nätverksprinciper för säkerhet på poddnivå

Nätverksprinciper är Kubernetes-resurser som styr vilka pods som får kommunicera med varandra. Som standard kan alla pods i ett kluster nå alla andra pods — nätverksprinciper tillhandahåller en brandvägg på poddnivå. I AKS aktiverar ni Azure network policy eller Calico för att tillämpa principer. Ett vanligt mönster är en default-deny-princip som blockerar all trafik mellan pods, följt av uttryckliga tillåtelseprinciper för de specifika trafikvägar som appen behöver.

# Default deny all ingress to pods in namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: production
spec:
  podSelector: {}  # Matches all pods
  policyTypes:
  - Ingress

# Allow API pods to receive from frontend pods only
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-allow-frontend
spec:
  podSelector: {matchLabels: {app: api}}
  ingress:
  - from:
    - podSelector: {matchLabels: {app: frontend}}

Snabbtest

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 AKS är en hanterad Kubernetes-tjänst där Microsoft driver kontrollplanet, att Helm-diagram paketerar Kubernetes-program med flera resurser för repeterbar distribution och att Cluster Autoscaler dynamiskt lägger till och tar bort noder baserat på poddarnas schemaläggningsbehov. Nästa steg är att utforska utlösare och bindningar i Azure Functions.

Gratis att börja

Lär dig Cloud & IT Cert Prep 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: 150
Lektioner: 600

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Distribuera arbetsbelastningar i AKS” gratis?

Ja – hela texten till ”Distribuera arbetsbelastningar i AKS” 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 Cloud & IT Cert Prep, kan Ni uppgradera till CoddyKit PRO. Kursen i Cloud & IT Cert Prep innehåller totalt 4 lektioner.

Vad lär jag mig i ”Distribuera arbetsbelastningar i AKS”?

Skapa ett AKS-kluster, distribuera en applikation med flera containrar med kubectl och Helm-diagram och exponera den externt med en Azure Load Balancer-tjänst. Ni övar på Cloud & IT Cert Prep 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 Cloud & IT Cert Prep?

Du behöver inga förkunskaper. Utbildningen i Cloud & IT Cert Prep 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 4 av 4.

Hur lång tid tar lektionen ”Distribuera arbetsbelastningar i AKS”?

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 Cloud & IT Cert Prep-lektionen?

Ja. Varje Cloud & IT Cert Prep-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 Cloud & IT Cert Prep