Förbereda Linux för avbildning i Azure

Gäller för: ✔️ Flexibla skalningsuppsättningar för virtuella Linux-datorer ✔️

Serviceavtal för Azure-plattform (SLA) gäller endast för virtuella datorer som kör Linux-operativsystemet när du använder en av de godkända distributionerna. För godkända distributioner tillhandahåller Azure Marketplace förkonfigurerade Linux-avbildningar. Mer information finns i:

• Godkända Linux-distributioner på Azure
• Support för Linux och teknik med öppen källkod i Azure

Alla andra distributioner som körs på Azure, inklusive community-stödda och icke-godkända distributioner, har vissa förutsättningar.

Den här artikeln fokuserar på allmän vägledning för att köra Din Linux-distribution på Azure. Den här artikeln kan inte vara omfattande eftersom varje distribution skiljer sig åt. Även om du uppfyller alla kriterier som beskrivs i den här artikeln kan du behöva justera Linux-systemet avsevärt för att det ska köras korrekt.

Allmänna linux-installationsanteckningar

• Azure stöder inte formatet Hyper-V virtuell hårddisk (VHDX). Azure stöder endast fast VHD. Du kan konvertera disken till VHD-format med hjälp av Hyper-V Manager eller cmdleten Convert-VHD. Om du använder VirtualBox väljer du Fast storlek i stället för standardvärdet (dynamiskt allokerad) när du skapar disken.

• Azure stöder virtuella datorer med Gen1 (BIOS-start) och Gen2 (UEFI-start).

• Kernelmodulen för virtuell filallokeringstabell (VFAT) måste vara aktiverad i kerneln.

• Den maximala tillåtna storleken för den virtuella hårddisken är 1 023 GB.

• När du installerar Linux-systemet rekommenderar vi att du använder standardpartitioner i stället för LVM (Logical Volume Manager). LVM är standard för många installationer.

  Om du använder standardpartitioner undviks LVM-namnkonflikter med klonade virtuella datorer, särskilt om en OS-disk någonsin är ansluten till en annan identisk virtuell dator för felsökning. Du kan använda LVM eller RAID på datadiskar.

• Kernelstöd för montering av användardefinierade funktionsfilsystem (UDF) är nödvändigt. Vid första starten på Azure skickas etableringskonfigurationen till den virtuella Linux-datorn via UDF-formaterade medier som är anslutna till gästen. Azure Linux-agenten måste montera UDF-filsystemet för att läsa dess konfiguration och etablera den virtuella datorn.

• Tidigare versioner av Linux-kernel än 2.6.37 stöder inte numa (Non-Uniform Memory Access) på Hyper-V med större VM-storlekar. Det här problemet påverkar främst äldre distributioner som använder den överordnade Red Hat 2.6.32-kerneln. Den har åtgärdats i Red Hat Enterprise Linux (RHEL) 6.6 (kernel-2.6.32-504).

  System som kör anpassade kernels som är äldre än 2.6.37 eller RHEL-baserade kernels som är äldre än 2.6.32-504 måste ange startparametern numa=off på kernelkommandoraden i grub.conf. Mer information finns i Red Hat KB 436883.

• Konfigurera inte en växlingspartition på OS-disken. Du kan konfigurera Linux-agenten för att skapa en växlingsfil på den tillfälliga resursdisken enligt beskrivningen senare i den här artikeln.

• Alla virtuella hårddiskar på Azure måste ha en virtuell storlek som är justerad till 1 MB (1 024 x 1 024 byte). När du konverterar från en rå disk till VHD ska du kontrollera att storleken på den råa disken är en multipel av 1 MB innan konverteringen, som beskrivs senare i den här artikeln.

• Använd den senaste distributionsversionen samt de senaste paketen och den senaste programvaran.

• Ta bort användare och systemkonton, offentliga nycklar, känsliga data, onödig programvara och program.

Installera kernelmoduler utan Hyper-V

Azure körs på Hyper-V hypervisor,så Linux kräver att vissa kernelmoduler körs i Azure. Om du har en virtuell dator som har skapats utanför Hyper-V kanske Linux-installationsprogrammet inte innehåller drivrutinerna för Hyper-V i den första RAM-disken (initrd eller initramfs), såvida inte den virtuella datorn identifierar att den körs i en Hyper-V miljö.

När du använder ett annat virtualiseringssystem (till exempel VirtualBox eller KVM) för att förbereda Linux-avbildningen kan du behöva återskapa initrd så att åtminstone hv_vmbus kernelmodulerna och hv_storvsc är tillgängliga på den första RAM-disken. Det här kända problemet gäller system som baseras på den överordnade Red Hat-fördelningen och eventuellt andra.

Mekanismen för att återskapa initrd- eller initramfs-avbildningen kan variera beroende på fördelningen. Konsultera dokumentationen eller supporten för ditt distributionssystem för att följa den korrekta proceduren. Här är ett exempel på hur du återskapar initrd med hjälp mkinitrd av verktyget:

1. Säkerhetskopiera den befintliga initrd-avbildningen:

   cd /boot
   sudo cp initrd-`uname -r`.img  initrd-`uname -r`.img.bak
   

2. Återskapa initrd med hjälp av kärnmodulerna hv_vmbus och hv_storvsc:

   sudo mkinitrd --preload=hv_storvsc --preload=hv_vmbus -v -f initrd-`uname -r`.img `uname -r`
   

Ändra storlek på virtuella hårddiskar

VHD-avbildningar på Azure måste ha en virtuell storlek som är justerad till 1 MB. Vanligtvis är VHD:er som skapats via Hyper-V korrekt justerade. Om den virtuella hårddisken inte är korrekt justerad kan du få ett felmeddelande som liknar följande exempel när du försöker skapa en avbildning från den virtuella hårddisken:

The VHD http://<mystorageaccount>.blob.core.windows.net/vhds/MyLinuxVM.vhd has an unsupported virtual size of 21475270656 bytes. The size must be a whole number (in MBs).

I det här fallet ändrar du storlek på den virtuella datorn med hjälp av antingen Hyper-V Manager-konsolen eller Resize-VHD PowerShell-cmdlet. Om du inte kör i en Windows miljö rekommenderar vi att du använder qemu-img för att konvertera (om det behövs) och ändra storlek på den virtuella hårddisken.

1. Att ändra storlek på VHD:n direkt med hjälp av verktyg som qemu-img eller vbox-manage kan leda till att VHD:n inte går att starta. Vi rekommenderar att du först konverterar den virtuella hårddisken till en rå diskbild med hjälp av följande kod.

   Om vm-avbildningen skapades som en rå diskavbildning kan du hoppa över det här steget. Att skapa den virtuella datoravbildningen som en rå diskavbildning är standard i vissa hypervisor-program, till exempel KVM.

   sudo qemu-img convert -f vpc -O raw MyLinuxVM.vhd MyLinuxVM.raw
   

2. Beräkna den nödvändiga storleken på diskbilden så att den virtuella storleken justeras till 1 MB. Följande Bash-skalsskript använder qemu-img info för att fastställa diskbildens virtuella storlek och beräknar sedan storleken upp till närmaste 1 MB:

   rawdisk="MyLinuxVM.raw"
   vhddisk="MyLinuxVM.vhd"
   
   MB=$((1024*1024))
   size=$(qemu-img info -f raw --output json "$rawdisk" | \
   gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
   
   rounded_size=$(((($size+$MB-1)/$MB)*$MB))
   
   echo "Rounded Size = $rounded_size"
   

3. Ändra storlek på raw-disken med hjälp $rounded_sizeav :

   sudo qemu-img resize MyLinuxVM.raw $rounded_size
   

4. Konvertera tillbaka den råa disken till en VHD med fast storlek:

   sudo qemu-img convert -f raw -o subformat=fixed,force_size -O vpc MyLinuxVM.raw MyLinuxVM.vhd
   

   Eller ta bort force_size alternativet med QEMU-versioner före 2.6:

   sudo qemu-img convert -f raw -o subformat=fixed -O vpc MyLinuxVM.raw MyLinuxVM.vhd
   

Krav för Linux-kernel

Linux Integration Services-drivrutinerna (LIS) för Hyper-V och Azure bidrar direkt till den överordnade Linux-kerneln. Många distributioner som innehåller en ny Linux-kernelversion (till exempel 3.x) har dessa drivrutiner redan tillgängliga, eller på annat sätt tillhandahåller bakåtporterade versioner av dessa drivrutiner med sina kärnor.

LIS-drivrutiner uppdateras ständigt i den överordnade kerneln med nya korrigeringar och funktioner. När det är möjligt rekommenderar vi att du kör en godkänd distribution som innehåller dessa korrigeringar och uppdateringar.

Om du kör en variant av RHEL versionerna 6.0 till 6.3 måste du installera de senaste LIS-drivrutinerna för Hyper-V. Från och med RHEL 6.4+ (och derivat) ingår LIS-drivrutinerna redan i kerneln, så du behöver inte ytterligare installationspaket.

Om en anpassad kernel krävs rekommenderar vi en ny kernelversion (till exempel 3.8+). För distributioner eller leverantörer som underhåller sin egen kernel måste du regelbundet backportera LIS-drivrutinerna från den överordnade kerneln till din anpassade kernel.

Även om du redan kör en relativt ny kernelversion rekommenderar vi starkt att du håller reda på eventuella överordnade korrigeringar i LIS-drivrutinerna och backporterar dem efter behov. Platserna för LIS-drivrutinskällfilerna anges i MAINTAINERS-filen i Linux-kernelns källträd:

    F:    arch/x86/include/asm/mshyperv.h
    F:    arch/x86/include/uapi/asm/hyperv.h
    F:    arch/x86/kernel/cpu/mshyperv.c
    F:    drivers/hid/hid-hyperv.c
    F:    drivers/hv/
    F:    drivers/input/serio/hyperv-keyboard.c
    F:    drivers/net/hyperv/
    F:    drivers/scsi/storvsc_drv.c
    F:    drivers/video/fbdev/hyperv_fb.c
    F:    include/linux/hyperv.h
    F:    tools/hv/

Den virtuella datorns aktiva kernel måste innehålla följande korrigeringar. Den här listan kan inte slutföras för alla distributioner.

• ata_piix: överlåt diskarna till Hyper-V-drivrutinerna som standard
• storvsc: Ta hänsyn till paket i transit i RESET-sökvägen
• storvsc: undvik användning av WRITE_SAME
• storvsc: Inaktivera WRITE SAME för RAID- och virtuella värdkortsdrivrutiner
• storvsc: NULL-pekarens referenskorrigering
• storvsc: ringbuffertfel kan leda till I/O-frysning
• scsi_sysfs: skydda mot dubbel körning av __scsi_remove_device

Azure Linuxagent

Azure Linux Agent (waagent) etablerar en virtuell Linux-dator i Azure. Du kan hämta den senaste versionen, rapportera problem eller skicka pull-begäranden på Linux Agent GitHub lagringsplats.

Här följer några saker att tänka på när du använder Azure Linux-agenten:

• Linux-agenten släpps under Apache 2.0-licensen. Många distributioner tillhandahåller redan .rpm- eller .deb-paket för agenten. Du kan enkelt installera och uppdatera dessa paket.
• Azure Linux-agenten kräver Python v2.6+.
• Agenten kräver också modulen python-pyasn1 . De flesta distributioner tillhandahåller den här modulen som ett separat paket som ska installeras.
• I vissa fall kanske Azure Linux-agenten inte är kompatibel med NetworkManager. Många av de paket (.rpm eller .deb) som tillhandahålls av distributioner konfigurerar NetworkManager som en konflikt med waagent paketet. I dessa fall avinstallerar agenten NetworkManager när du installerar Linux-agentpaketet.
• Azure Linux-agenten måste ha minst den lägsta version som stöds.

Allmänna Linux-systemkrav

1. Ändra kernel-startlinjen i GRUB eller GRUB2 så att den innehåller följande parametrar, så att alla konsolmeddelanden skickas till den första serieporten. Dessa meddelanden kan hjälpa Azure support med felsökning av eventuella problem.

   GRUB_CMDLINE_LINUX="rootdelay=300 console=ttyS0 earlyprintk=ttyS0 net.ifnames=0"
   

   Vi rekommenderar också att du tar bort följande parametrar om de finns:

   rhgb quiet crashkernel=auto
   

   Grafisk och tyst start är inte användbara i en molnmiljö, där du vill att alla loggar ska skickas till serieporten. Du kan lämna alternativet crashkernel konfigurerat om det behövs, men den här parametern minskar mängden tillgängligt minne på den virtuella datorn med minst 128 MB. Det kan vara problematiskt att minska det tillgängliga minnet för mindre VM-storlekar.

2. När du har redigerat /etc/default/grub återskapar du GRUB-konfigurationen. Kör endast det kommando som är lämpligt för distributionen.

   För distributioner baserade på Debian eller Ubuntu kör du:

   sudo update-grub
   

   För distributioner som tillhandahåller grub2-mkconfig, till exempel RHEL, Oracle Linux och SUSE, kör du:

   sudo grub2-mkconfig -o /boot/grub2/grub.cfg
   

   På distributioner som tillhandahåller grub-mkconfig i stället, kör du:

   sudo grub-mkconfig -o /boot/grub/grub.cfg
   

   GRUB-konfigurationssökvägen kan skilja sig åt för UEFI-installationer. Om distributionen använder en annan sökväg använder du sökvägen som dokumenterats för distributionen.

3. Lägg till Hyper-V moduler till den första RAM-disken. Kör endast den procedur som matchar de verktyg som används av din distribution.

   1. För en dracut-baserad distribution, kör:

   cd /boot
   sudo cp initramfs-<kernel-version>.img <kernel-version>.img.bak
   sudo dracut -f -v initramfs-<kernel-version>.img <kernel-version> --add-drivers "hv_vmbus hv_netvsc hv_storvsc"
   

   1. För en distribution som använder mkinitramfskör du den här proceduren i stället för dracut-proceduren:

   cd /boot
   sudo cp initrd.img-<kernel-version> initrd.img-<kernel-version>.bak
   sudo mkinitramfs -o initrd.img-<kernel-version> <kernel-version> --with=hv_vmbus,hv_netvsc,hv_storvsc
   

4. Endast om du skapar en avbild för en fjärransluten NVMe-diskstyrenhet, konfigurera och verifiera stöd för att starta från NVMe. Annars hoppar du över det här steget. De exakta kommandona kan variera beroende på distribution.

   1. Bygg om initramfs med NVMe-drivrutinerna med den metod som gäller för din distribution.

      För en dracut-baserad distribution gör du NVMe-drivrutinerna beständiga i framtida initramfs-avbildningar och återskapar de aktuella initramferna:

      sudo mkdir -p /etc/dracut.conf.d
      printf '%s\n' 'add_drivers+=" nvme nvme_core "' | sudo tee /etc/dracut.conf.d/azure-nvme.conf
      sudo dracut --force
      

      För en initramfs-tools-baserad distribution gör du NVMe-drivrutinerna beständiga och återskapar initramfs:

      printf '%s\n' nvme nvme_core | sudo tee -a /etc/initramfs-tools/modules
      sudo update-initramfs -u -k all
      

   2. Lägg till nvme_core.io_timeout=240 på den befintliga kernel-kommandoraden i /etc/default/gruboch återskapa grub-konfigurationen med hjälp av kommandot som är lämpligt för distributionen.

   3. Kontrollera att båda NVMe-drivrutinsmodulerna är tillgängliga i systemet. Kör båda kommandona:

      modinfo nvme
      modinfo nvme_core
      

      Varje kommando måste returnera information om sin modul. Om någon av modulerna inte hittas installerar eller aktiverar du den genom att följa distributionens dokumentation innan du fortsätter.

   4. Kontrollera att båda NVMe-drivrutinerna ingår i initramfs. Kör endast kommandot för distributionen.

      För en dracut-baserad distribution, kör:

      sudo lsinitrd /boot/initramfs-$(uname -r).img | grep -E 'nvme(_core)?\.ko'
      

      För en distribution som bygger på initramfs-tools, kör:

      sudo lsinitramfs /boot/initrd.img-$(uname -r) | grep -E 'nvme(_core)?\.ko'
      

      Utdata måste visa både drivrutinerna nvme och nvme_core . Om den inte gör det kan du läsa distributionens dokumentation och återskapa den första RAM-disken innan du fortsätter.

5. Kontrollera att SSH-servern är installerad och konfigurerad att starta vid start. Den här konfigurationen är vanligtvis standard.

6. Installera Azure Linux-agenten.

   Azure Linux-agent krävs för att etablera en Linux-avbildning på Azure. Många distributioner tillhandahåller agenten som ett .rpm- eller .deb-paket. Paketet anropas WALinuxAgent vanligtvis eller walinuxagent. Du kan också installera agenten manuellt genom att följa stegen i Azure Linux-agentguiden.

   Note

   Kontrollera att modulerna udf och vfat är aktiverade. Om du tar bort eller inaktiverar dem orsakar det ett provisionerings- eller startfel. Cloud-init version 21.2 eller senare tar bort UDF-kravet.

   Installera Azure Linux-agenten, cloud-init och andra nödvändiga verktyg. Kör endast kommandot för den pakethanterare som är tillgänglig i systemet.

   För dnfkör du:

    sudo dnf install -y WALinuxAgent cloud-init cloud-utils-growpart gdisk hyperv-daemons
   

   Om systemet tillhandahåller yum i stället dnfför ersätter du dnf med yum i föregående kommando.

   För apt, kör:

   sudo apt install walinuxagent cloud-init cloud-utils-growpart gdisk hyperv-daemons
   

   För zypper, kör:

   sudo zypper install python-azure-agent cloud-init cloud-utils-growpart gdisk hyperv-daemons
   

   Aktivera sedan agenten och cloud-init för alla distributioner:

   sudo systemctl enable waagent.service
   sudo systemctl enable cloud-init.service
   

7. Skapa inte växlingsutrymme på OS-disken.

   Du kan använda Azure Linux-agent eller cloud-init för att konfigurera växlingsutrymme via den lokala resursdisken. Azure kopplar den här resursdisken till den virtuella datorn efter etableringen. Den lokala resursdisken är tillfällig och kan tömmas när den virtuella datorn avetableras.

   Important

   De här anvisningarna gäller om fjärrdiskstyrenheten är SCSI eller NVMe. De kräver en VM-storlek som innehåller en lokal tillfällig resursdisk. Fjärrdiskkontrollanttypen avgör inte om en resursdisk är tillgänglig.

   1. Välj och konfigurera en metod för att hantera växlingsutrymme.

      Om du vill använda Azure Linux-agenten ändrar du följande parametrar i /etc/waagent.conf:

      ResourceDisk.Format=y
      ResourceDisk.Filesystem=ext4
      ResourceDisk.MountPoint=/mnt/resource
      ResourceDisk.EnableSwap=y
      ResourceDisk.SwapSizeMB=2048    ## NOTE: Set this to your desired size.
      

      Om du vill använda cloud-init i stället konfigurerar du cloud-init för att hantera etablering och förhindra att Azure Linux-agenten formaterar resursdisken eller skapar växlingsutrymme:

      sudo sed -i 's/Provisioning.Agent=auto/Provisioning.Agent=cloud-init/g' /etc/waagent.conf
      sudo sed -i 's/ResourceDisk.Format=y/ResourceDisk.Format=n/g' /etc/waagent.conf
      sudo sed -i 's/ResourceDisk.EnableSwap=y/ResourceDisk.EnableSwap=n/g' /etc/waagent.conf
      

   2. Om du väljer cloud-init väljer du hur du ska ange växlingskonfigurationen.

      Du kan skicka med en cloud-init-konfiguration via customdata varje gång du skapar en virtuell dator. Använd den här metoden.

      Alternativt kan du lägga till ett cloud-init-direktiv i avbilden så att växlingsutrymme konfigureras varje gång en VM skapas. Om du vill använda den här metoden skapar du en .cfg-fil:

      echo 'DefaultEnvironment="CLOUD_CFG=/etc/cloud/cloud.cfg.d/00-azure-swap.cfg"' | sudo tee -a /etc/systemd/system.conf
      cat << EOF | sudo tee /etc/cloud/cloud.cfg.d/00-azure-swap.cfg
      #cloud-config
      # Generated by Azure cloud image build
      disk_setup:
        ephemeral0:
          table_type: mbr
          layout: [66, [33, 82]]
          overwrite: True
      fs_setup:
        - device: ephemeral0.1
          filesystem: ext4
        - device: ephemeral0.2
          filesystem: swap
      mounts:
        - ["ephemeral0.1", "/mnt/resource"]
        - ["ephemeral0.2", "none", "swap", "sw,nofail,x-systemd.requires=cloud-init.service,x-systemd.device-timeout=2", "0", "0"]
      EOF
      

8. Konfigurera cloud-init för att hantera etableringen:

   1. Konfigurera waagent för cloud-init:

      sudo sed -i 's/Provisioning.Agent=auto/Provisioning.Agent=cloud-init/g' /etc/waagent.conf
      sudo sed -i 's/ResourceDisk.Format=y/ResourceDisk.Format=n/g' /etc/waagent.conf
      sudo sed -i 's/ResourceDisk.EnableSwap=y/ResourceDisk.EnableSwap=n/g' /etc/waagent.conf
      

      Om du migrerar en specifik virtuell dator och inte vill skapa en generaliserad avbildning, anger du Provisioning.Agent=disabled i konfigurationsfilen /etc/waagent.conf.

   2. Konfigurera monteringspunkter:

      echo "Adding mounts and disk_setup to init stage"
      sudo sed -i '/ - mounts/d' /etc/cloud/cloud.cfg
      sudo sed -i '/ - disk_setup/d' /etc/cloud/cloud.cfg
      sudo sed -i '/cloud_init_modules/a\\ - mounts' /etc/cloud/cloud.cfg
      sudo sed -i '/cloud_init_modules/a\\ - disk_setup' /etc/cloud/cloud.cfg
      
      

   3. Konfigurera Azure-datakällan:

      echo "Allow only Azure datasource, disable fetching network setting via IMDS"
      cat << EOF | sudo tee /etc/cloud/cloud.cfg.d/91-azure_datasource.cfg
      datasource_list: [ Azure ]
      datasource:
         Azure:
           apply_network_config: False
      EOF
      

   4. Ta bort den befintliga växlingsfilen om du har konfigurerat en:

      if [[ -f /mnt/resource/swapfile ]]; then
      echo "Removing swapfile" #RHEL uses a swap file by default
      swapoff /mnt/resource/swapfile
      rm /mnt/resource/swapfile -f
      fi
      

   5. Konfigurera cloud-init-loggning:

      echo "Add console log file"
      cat << EOF | sudo tee -a /etc/cloud/cloud.cfg.d/05_logging.cfg
      
      # This tells cloud-init to redirect its stdout and stderr to
      # 'tee -a /var/log/cloud-init-output.log' so the user can see output
      # there without needing to look on the console.
      output: {all: '| tee -a /var/log/cloud-init-output.log'}
      EOF
      

9. Verifiera konfigurationen för diskmontering innan du avetablerar den virtuella datorn. Den här valideringen gäller för både SCSI- och fjärr-NVMe-avbildningar.

   1. Granska /etc/fstab. Använd inte enhetsnamn som /dev/sd* eller /dev/nvme*, eftersom enhetsnamn kan ändras mellan omstarter eller när diskkontrollanten ändras. Använd UUID:er för filsystem eller andra beständiga identifierare i stället.

      Visa en lista över blockenheter och deras beständiga identifierare så att du kan jämföra dem med posterna i /etc/fstab:

      sudo blkid
      

   2. Kontrollera /etc/fstab med avseende på syntaxfel, ogiltiga monteringsalternativ och referenser som inte kan lösas:

      sudo findmnt --verify --verbose
      

   3. Endast om du skapar en avbildning för en fjärr-NVMe-diskkontrollant kontrollerar du den konfigurerade I/O-tidsgränsen. Om den virtuella källdatorn för närvarande använder NVMe kör du:

      cat /sys/module/nvme_core/parameters/io_timeout
      

      Värdet måste vara 240. En virtuell SCSI-källdator kanske inte exponerar den här körningsparametern. I så fall kontrollerar du att det nvme_core.io_timeout=240 finns i GRUB-konfigurationen och att den ombyggda konfigurationen innehåller den.

10. Kör följande kommandon för att avetablera den virtuella datorn.

    Caution

    Om du migrerar en specifik virtuell dator och inte vill skapa en generaliserad avbildning hoppar du över avetableringssteget. Om du kör kommandot waagent -force -deprovision+user blir källdatorn oanvändbar. Det här steget är endast avsett att skapa en generaliserad avbildning.

    sudo rm -f /var/log/waagent.log
    sudo cloud-init clean
    sudo waagent -force -deprovision+user
    sudo rm -f ~/.bash_history
    sudo export HISTSIZE=0
    

    I VirtualBox kan ett felmeddelande visas när du har kört waagent -force -deprovision som säger [Errno 5] Input/output error. Det här felmeddelandet är inte kritiskt och du kan ignorera det.

11. Stäng av den virtuella datorn och ladda upp den virtuella hårddisken till Azure.

Nästa steg

Skapa en virtuell Linux-dator från en anpassad disk med hjälp av Azure CLI

För en befintlig Azure virtuell dator som du behöver flytta från SCSI till NVMe använder du Konvertera Linux och Windows virtuella datorer från SCSI till NVMe. Information om arkitektur och support finns i ÖVERSIKT över NVMe.