Migrera till Azure Kubernetes Service (AKS)

För att hjälpa dig att planera och utföra en lyckad migrering till Azure Kubernetes Service (AKS) innehåller den här guiden information om den aktuella rekommenderade AKS-konfigurationen. Även om den här artikeln inte omfattar alla scenarion innehåller den länkar till mer detaljerad information för att planera en lyckad migrering.

I den här artikeln sammanfattar vi migreringsinformation för:

• Containerisera program via Azure Migrate
• AKS med Azure Load Balancer (Standard) och VM-skalningsuppsättningar
• Befintliga anslutna Azure-tjänster
• Kontrollera giltiga kvoter
• Hög tillgänglighet och affärskontinuitet
• Överväganden för tillståndslösa program
• Överväganden för tillståndskänsliga program
• Distribution av klusterkonfigurationen

Kommentar

Beroende på ditt scenario kan följande verktyg med öppen källkod hjälpa dig med migreringen:

• Velero (kräver Kubernetes 1.7+)
• Azure Kube CLI-tillägg

Innan du börjar

• Kontrollera att kubernetes-målversionen finns i fönstret som stöds för AKS. Äldre versioner kanske inte ligger inom det intervall som stöds och kräver en versionsuppgradering för AKS-stöd. Mer information finns i AKS-versioner som stöds av Kubernetes.
• Om du migrerar till en nyare version av Kubernetes läser du supportprincipen för Kubernetes-versionen och versionens skevhet.

En viktig metod som du bör ta med som en del av migreringsprocessen är att komma ihåg att följa vanliga distributions- och testmönster. Att testa programmet före distributionen är ett viktigt steg för att säkerställa dess kvalitet, funktionalitet och kompatibilitet med målmiljön. Det kan hjälpa dig att identifiera och åtgärda eventuella fel, buggar eller problem som kan påverka programmets eller den underliggande infrastrukturens prestanda, säkerhet eller användbarhet.

Använda Azure Migrate för att migrera dina program till AKS

Azure Migrate erbjuder en enhetlig plattform för att utvärdera och migrera till lokala Azure-servrar, infrastruktur, program och data. För AKS kan du använda Azure Migrate för följande uppgifter:

• Containerisera ASP.NET program och migrera till AKS.
• Containerisera Java-webbprogram och migrera till AKS.

AKS med Standard Load Balancer och Vm-skalningsuppsättningar

AKS är en hanterad tjänst som erbjuder unika funktioner med lägre hanteringskostnader. Eftersom AKS är en hanterad tjänst måste du välja från en uppsättning AKS-regioner som stöds. Du kan behöva ändra dina befintliga program för att hålla dem felfria på det AKS-hanterade kontrollplanet under övergången från ditt befintliga kluster till AKS.

Vi rekommenderar att du använder AKS-kluster som backas upp av Vm-skalningsuppsättningar och Lastbalanserare (Standard) för att se till att du får följande funktioner:

• Flera nodpooler,
• Tillgänglighetszoner,
• Auktoriserade IP-intervall,
• Autoskalning av kluster,
• Azure Policy för AKS och
• Andra nya funktioner när de släpps.

AKS-kluster som backas upp av vm-tillgänglighetsuppsättningar (VM) saknar stöd för många av dessa funktioner.

Skapa ett AKS-kluster med Load Balancer (Standard) och Vm-skalningsuppsättningar

Azure CLI

I följande exempel skapas ett AKS-kluster med en nodpool som backas upp av en VM-skalningsuppsättning. Den aktiverar autoskalning av kluster i nodpoolen för klustret och anger minst en och högst tre noder.

1. Skapa en resursgrupp med kommandot az group create .

   az group create --name myResourceGroup --location eastus
   

2. Skapa ett AKS-kluster med kommandot az aks create .

   az aks create \
       --resource-group myResourceGroup \
       --name myAKSCluster \
       --node-count 1 \
       --vm-set-type VirtualMachineScaleSets \
       --load-balancer-sku standard \
       --enable-cluster-autoscaler \
       --min-count 1 \
       --max-count 3 \
       --generate-ssh-keys
   

Terraform

Följande kod skapar en resursgrupp och ett Kubernetes-kluster i Azure, med automatisk skalning aktiverat och specifika nätverksinställningar med Terraform.

Kommentar

Exempelkoden för den här artikeln finns på Azure Terraform GitHub-lagringsplatsen. Du kan visa loggfilen som innehåller testresultaten från aktuella och tidigare versioner av Terraform.

Se fler artiklar och exempelkod som visar hur du använder Terraform för att hantera Azure-resurser

1. Skapa en katalog där du kan testa och köra Terraform-exempelkoden och göra den till den aktuella katalogen.

2. Skapa en fil med namnet main.tfoch infoga följande kod:

   resource "random_pet" "rg_name" {
     prefix = var.resource_group_name_prefix
   }
   
   resource "azurerm_resource_group" "rg" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   resource "random_string" "aks_cluster_name" {
     length  = 12
     special = false
   }
   
   resource "azurerm_kubernetes_cluster" "aks_cluster" {
     name                = random_string.aks_cluster_name.result
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
     dns_prefix          = "myakscluster"
   
     default_node_pool {
       type                = "VirtualMachineScaleSets"
       name                = "default"
       node_count          = 1
       max_count           = 3
       min_count           = 1
       vm_size             = "Standard_DS2_v2"
       enable_auto_scaling = true
       upgrade_settings {
         drain_timeout_in_minutes      = 90
         max_surge                     = "10%"
         node_soak_duration_in_minutes = 0
       }
     }
   
     network_profile {
       network_plugin    = "azure"
       load_balancer_sku = "standard"
     }
   
     identity {
       type = "SystemAssigned"
     }
   
     tags = {
       Environment = "Production"
     }
   }
   

3. Skapa en fil med namnet outputs.tfoch infoga följande kod:

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "aks_cluster_name" {
     value = azurerm_kubernetes_cluster.aks_cluster.name
   }
   

4. Skapa en fil med namnet providers.tfoch infoga följande kod:

   terraform {
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>3.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

5. Skapa en fil med namnet variables.tfoch infoga följande kod:

   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   

6. Initiera Terraform.

   Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned den Azure-provider som krävs för att hantera dina Azure-resurser.

   terraform init -upgrade
   

   Viktiga punkter:

   • Parametern -upgrade uppgraderar nödvändiga provider-plugin-program till den senaste versionen som uppfyller konfigurationens versionsbegränsningar.

7. Skapa en Terraform-körningsplan.

   Kör terraform-planen för att skapa en körningsplan.

   terraform plan -out main.tfplan
   

   Viktiga punkter:

   • Kommandot terraform plan skapar en körningsplan, men kör den inte. I stället avgör den vilka åtgärder som krävs för att skapa den konfiguration som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om körningsplanen matchar dina förväntningar innan du gör några ändringar i faktiska resurser.
   • Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att planen du granskade är exakt vad som tillämpas.

8. Tillämpa en Terraform-körningsplan.

   Kör terraform gäller för att tillämpa körningsplanen på din molninfrastruktur.

   terraform apply main.tfplan
   

   Viktiga punkter:

   • terraform apply Exempelkommandot förutsätter att du tidigare körde terraform plan -out main.tfplan.
   • Om du har angett ett annat filnamn för parametern -out använder du samma filnamn i anropet till terraform apply.
   • Om du inte använde parametern -out anropar terraform apply du utan några parametrar.

Befintliga anslutna Azure-tjänster

När du migrerar kluster kan du ha kopplat externa Azure-tjänster. Även om följande tjänster inte kräver resursuppkoppling, kräver de uppdatering av anslutningar från tidigare till nya kluster för att underhålla funktioner:

• Azure Container Registry
• Azure Log Analytics
• Azure Application Insights
• Azure Traffic Manager
• Azure-lagringskonto
• Externa databaser

Kontrollera giltiga kvoter

Eftersom andra virtuella datorer distribueras till din prenumeration under migreringen bör du kontrollera att dina kvoter och gränser är tillräckliga för dessa resurser. Begär vid behov en ökning av vCPU-kvoten.

Du kan behöva begära en ökning av nätverkskvoterna för att säkerställa att du inte avtömmer IP-adresser. Mer information finns i nätverk och IP-intervall för AKS.

Mer information finns i Azure-prenumerations - och tjänstbegränsningar. Om du vill kontrollera dina aktuella kvoter går du till prenumerationsbladet i Azure Portal, väljer din prenumeration och väljer sedan Användning + kvoter.

Hög tillgänglighet och affärskontinuitet

Om ditt program inte kan hantera stilleståndstid måste du följa metodtipsen för scenarier med hög tillgänglighetsmigrering. Läs mer om metodtips för komplex planering av affärskontinuitet, haveriberedskap och maximera drifttid i Azure Kubernetes Service (AKS).

För komplexa program migrerar du vanligtvis över tid i stället för alla samtidigt, vilket innebär att de gamla och nya miljöerna kan behöva kommunicera via nätverket. Program som tidigare använde ClusterIP tjänster för att kommunicera kan behöva exponeras som typ LoadBalancer och skyddas på lämpligt sätt.

För att slutföra migreringen vill du peka klienter till de nya tjänster som körs på AKS. Vi rekommenderar att du omdirigerar trafik genom att uppdatera DNS så att den pekar på lastbalanseraren som sitter framför ditt AKS-kluster.

Azure Traffic Manager kan dirigera kunder till önskat Kubernetes-kluster och programinstans. Traffic Manager är en DNS-baserad trafiklastbalanserare som kan distribuera nätverkstrafik mellan regioner. För bästa prestanda och redundans dirigerar du all programtrafik via Traffic Manager innan den går till ditt AKS-kluster.

I en distribution med flera kluster bör kunderna ansluta till ett Traffic Manager DNS-namn som pekar på tjänsterna i varje AKS-kluster. Definiera dessa tjänster med hjälp av Traffic Manager-slutpunkter. Varje slutpunkt är tjänstens lastbalanserares IP-adress. Använd den här konfigurationen för att dirigera nätverkstrafik från Traffic Manager-slutpunkten i en region till slutpunkten i en annan region.

Azure Front Door är ett annat alternativ för att dirigera trafik för AKS-kluster. Med Azure Front Door kan du definiera, hantera och övervaka den globala routningen för din webbtrafik genom att optimera för bästa prestanda och omedelbar global redundans för hög tillgänglighet.

Överväganden för tillståndslösa program

Tillståndslös programmigrering omfattar följande steg:

1. Tillämpa dina resursdefinitioner (YAML eller Helm) på det nya klustret.
2. Se till att allt fungerar som förväntat.
3. Omdirigera trafik för att aktivera det nya klustret.

Överväganden för tillståndskänsliga program

Planera noggrant migreringen av tillståndskänsliga program för att undvika dataförlust eller oväntad stilleståndstid.

• Om du använder Azure Files kan du montera filresursen som en volym i det nya klustret. Se Montera statiska Azure Files som en volym.
• Om du använder Azure Managed Disks kan du bara montera disken om den inte är kopplat till en virtuell dator. Se Montera statisk Azure Disk som en volym.
• Om ingen av dessa metoder fungerar kan du använda alternativ för säkerhetskopiering och återställning. Se Velero på Azure.

Azure Files

Till skillnad från diskar kan Azure Files monteras på flera värdar samtidigt. I ditt AKS-kluster hindrar Azure och Kubernetes dig inte från att skapa en podd som AKS-klustret fortfarande använder. För att förhindra dataförlust och oväntat beteende kontrollerar du att klustren inte samtidigt skriver till samma filer.

Om programmet kan vara värd för flera repliker som pekar på samma filresurs följer du de tillståndslösa migreringsstegen och distribuerar YAML-definitionerna till det nya klustret.

Om inte, innebär en möjlig migreringsmetod följande steg:

1. Kontrollera att programmet fungerar korrekt.
2. Peka din livetrafik till ditt nya AKS-kluster.
3. Koppla från det gamla klustret.

Om du vill börja med en tom resurs och göra en kopia av källdata kan du använda az storage file copy kommandot för att migrera dina data.

Migrera beständiga volymer

Om du migrerar befintliga beständiga volymer till AKS följer du vanligtvis dessa steg:

1. Quiesce-skrivningar till programmet.
   • Det här steget är valfritt och kräver stilleståndstid.
2. Ta ögonblicksbilder av diskarna.
3. Skapa nya hanterade diskar från ögonblicksbilderna.
4. Skapa beständiga volymer i AKS.
5. Uppdatera poddspecifikationer för att använda befintliga volymer i stället för PersistentVolumeClaims (statisk etablering).
6. Distribuera ditt program till AKS.
7. Kontrollera att programmet fungerar korrekt.
8. Peka din livetrafik till ditt nya AKS-kluster.

Viktigt!

Om du väljer att inte quiesce-skrivningar måste du replikera data till den nya distributionen. Annars missar du de data som skrevs efter att du tog diskögonblicksbilderna.

Följande verktyg med öppen källkod kan hjälpa dig att skapa hanterade diskar och migrera volymer mellan Kubernetes-kluster:

• Azure CLI Disk Copy-tillägget kopierar och konverterar diskar mellan resursgrupper och Azure-regioner.
• Azure Kube CLI-tillägget räknar upp ACS Kubernetes-volymer och migrerar dem till ett AKS-kluster.

Distribution av klusterkonfigurationen

Vi rekommenderar att du använder din befintliga pipeline för kontinuerlig integrering och kontinuerlig leverans för att distribuera en känd konfiguration till AKS. Du kan använda Azure Pipelines för att skapa och distribuera dina program till AKS. Klona dina befintliga distributionsuppgifter och se kubeconfig till att pekar på det nya AKS-klustret.

Om det inte är möjligt exporterar du resursdefinitioner från ditt befintliga Kubernetes-kluster och tillämpar dem sedan på AKS. Du kan använda kubectl för att exportera objekt. Till exempel:

kubectl get deployment -o yaml > deployments.yaml

Se till att undersöka utdata och ta bort onödiga livedatafält.

Flytta befintliga resurser till en annan region

Du kanske vill flytta ditt AKS-kluster till en annan region som stöds av AKS. Vi rekommenderar att du skapar ett nytt kluster i den andra regionen och sedan distribuerar dina resurser och program till det nya klustret.

Om du har tjänster som körs i AKS-klustret måste du installera och konfigurera tjänsterna i klustret i den nya regionen.

I den här artikeln sammanfattade vi migreringsinformation för:

• Containerisera program via Azure Migrate
• AKS med lastbalanserare (standard) och vm-skalningsuppsättningar
• Befintliga anslutna Azure-tjänster
• Säkerställa giltiga kvoter
• Hög tillgänglighet och affärskontinuitet
• Överväganden för tillståndslösa program
• Överväganden för tillståndskänsliga program
• Distribuera klusterkonfigurationen