Preparare un disco rigido virtuale Debian per Azure

Si applica a: ✔️ macchine virtuali di Linux ✔️ set di scalabilità flessibili

Prerequisiti

In questa sezione si presuppone che un sistema operativo Linux Debian sia già stato installato da un file .iso scaricato dal sito Web di Debian in un disco rigido virtuale (VHD). Sono disponibili vari strumenti per la creazione di file VHD. Hyper-V è un solo esempio. Per istruzioni sull’uso di Hyper-V, vedere Installare il ruolo Hyper-V e configurare una macchina virtuale (VM).

Note sull'installazione

• Per altri suggerimenti sulla preparazione di Linux per Azure, vedere Note generali sull'installazione di Linux.
• Il formato VHDX più recente non è supportato in Azure. È possibile convertire il disco in formato VHD tramite la console di gestione di Hyper-V o il cmdlet convert-vhd.
• Quando si installa il sistema Linux è consigliabile usare partizioni standard anziché LVM (Logical Volume Manager), che è spesso l'impostazione predefinita per numerose installazioni. L'uso delle partizioni consente di evitare conflitti di nome LVM con le macchine virtuali clonate, in particolare se fosse necessario collegare un disco del sistema operativo a un'altra macchina virtuale per la risoluzione dei problemi. È possibile usare LVM o RAID anche su dischi di dati.
• Non configurare una partizione swap nel disco del sistema operativo. L'agente Linux di Azure può essere configurato in modo da creare un file swap sul disco temporaneo delle risorse. Altre informazioni sono disponibili nei passaggi seguenti.
• Tutti i VHD in Azure devono avere una dimensione virtuale allineata a 1 MB. Quando si converte un disco raw in un VHD, è necessario assicurarsi che le dimensioni del disco raw siano un multiplo di 1 MB prima della conversione. Per altre informazioni, vedere Note sull'installazione di Linux.

Preparare un'immagine Debian per Azure

È possibile creare l'immagine cloud Debian per Azure di base usando il generatore di immagini cloud FAI (Fully Automatic Installation). Per preparare un'immagine senza FAI, vedere l'articolo relativo alla procedura generica.

I seguenti comandi `git clone` e di installazione di `apt` sono stati estratti dal repository delle immagini cloud di Debian. Per iniziare, clonare il repository e installare le dipendenze:

$ git clone https://salsa.debian.org/cloud-team/debian-cloud-images.git
$ sudo apt install --no-install-recommends ca-certificates debsums dosfstools \
    fai-server fai-setup-storage make python3 python3-libcloud python3-marshmallow \
    python3-pytest python3-yaml qemu-utils udev
$ cd ./debian-cloud-images

Facoltativo: personalizzare la compilazione aggiungendo script (ad esempio script della shell) a ./config_space/scripts/AZURE.

Esempio di script per personalizzare l'immagine

$ mkdir -p ./config_space/scripts/AZURE
$ cat > ./config_space/scripts/AZURE/10-custom <<EOF
#!/bin/bash

\$ROOTCMD bash -c "echo test > /usr/local/share/testing"
EOF
$ sudo chmod 755 ./config_space/scripts/AZURE/10-custom

Aggiungere a qualsiasi comando con cui si vuole personalizzare l'immagine il prefisso $ROOTCMD. Il suo alias è chroot $target.

Convalidare la configurazione del disco Debian

Per le immagini SCSI e NVMe, aggiungere uno script di personalizzazione FAI che convalida /etc/fstab e rifiuta i nomi dei dischi non permanenti:

$ cat > ./config_space/scripts/AZURE/15-storage-validation <<'EOF'
#!/bin/bash
set -eu

$ROOTCMD findmnt --verify --verbose

if $ROOTCMD grep -Eq '^[[:space:]]*[^#].*[[:space:]]/dev/(sd|nvme)' /etc/fstab; then
    echo 'Replace /dev/sd* and /dev/nvme* entries in /etc/fstab with UUIDs or another persistent identifier.' >&2
    exit 1
fi
EOF
$ sudo chmod 755 ./config_space/scripts/AZURE/15-storage-validation

Preparare l'immagine Debian per NVMe remoto

Completare questa sezione solo se si sta creando un'immagine per un controller disco NVMe remoto. In caso contrario, continuare a Compilare l'immagine Debian Azure senza aggiungere questo script.

Aggiungere un altro script di personalizzazione FAI prima di compilare l'immagine NVMe. Lo script rende disponibili i driver NVMe durante la fase iniziale dell'avvio e imposta il timeout di I/O NVMe di Azure.

$ cat > ./config_space/scripts/AZURE/20-nvme <<'EOF'
#!/bin/bash
set -eu

$ROOTCMD bash -c "printf '%s\n' nvme nvme_core >> /etc/initramfs-tools/modules"
$ROOTCMD update-initramfs -u -k all
$ROOTCMD sed -i '/^GRUB_CMDLINE_LINUX_DEFAULT=/ s/"$/ nvme_core.io_timeout=240"/' /etc/default/grub
$ROOTCMD update-grub

$ROOTCMD modinfo nvme
$ROOTCMD modinfo nvme_core
$ROOTCMD bash -c "lsinitramfs /boot/initrd.img-\$(ls /lib/modules | sort -V | tail -1) | grep -Eq 'nvme(_core)?\\.ko'"
EOF
$ sudo chmod 755 ./config_space/scripts/AZURE/20-nvme

Creare l'immagine Debian di Azure

$ make image_[release]_azure_amd64

Questo comando restituisce alcuni file nella directory corrente, in particolare il file di immagine image_[release]_azure_amd64.raw.

Convertire l'immagine RAW in formato VHD per Azure:

rawdisk="image_[release]_azure_amd64.raw"
vhddisk="image_[release]_azure_amd64.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))
rounded_size_adjusted=$(($rounded_size + 512))

echo "Rounded Size Adjusted = $rounded_size_adjusted"

sudo qemu-img resize "$rawdisk" $rounded_size
qemu-img convert -f raw -o subformat=fixed,force_size -O vpc "$rawdisk" "$vhddisk"

Questo processo crea un file VHD image_[release]_azure_amd64.vhd con dimensioni arrotondate in modo che possa essere copiato correttamente in un disco di Azure.

Dopo aver creato un'immagine del disco rigido virtuale Debian stabile e prima del caricamento, verificare che siano installati i pacchetti seguenti:

sudo apt update
sudo apt install hyperv-daemons
sudo apt install waagent # *(Optional but recommended for password resets and the use of extensions)*
sudo apt-get install cloud-init

Eseguire quindi un aggiornamento completo:

sudo apt full-upgrade

Ora è necessario creare le risorse di Azure per questa immagine. Questo esempio usa la variabile $rounded_size_adjusted, quindi deve trovarsi all'interno dello stesso processo della shell del passaggio precedente.

Impostare la generazione Hyper-V prima di creare il disco gestito. L'esempio usa V1 come impostazione predefinita per un'immagine SCSI standard. Modificarlo in V2 solo se si completa la sezione di preparazione NVMe remota o si prepara un'immagine di seconda generazione.

HYPER_V_GENERATION=V1

az group create -l $LOCATION -n $RG

az disk create \
    -n $DISK \
    -g $RG \
    -l $LOCATION \
    --for-upload --upload-size-bytes "$rounded_size_adjusted" \
    --sku standard_lrs --hyper-v-generation $HYPER_V_GENERATION

ACCESS=$(az disk grant-access \
    -n $DISK -g $RG \
    --access-level write \
    --duration-in-seconds 86400 \
    --query accessSas -o tsv)

azcopy copy "$vhddisk" "$ACCESS" --blob-type PageBlob

az disk revoke-access -n $DISK -g $RG
az image create \
    -g $RG \
    -n $IMAGE \
    --os-type linux \
    --hyper-v-generation $HYPER_V_GENERATION \
    --source $(az disk show \
        -g $RG \
        -n $DISK \
        --query id -o tsv)
az vm create \
    -g $RG \
    -n $VM \
    --ssh-key-value $SSH_KEY_VALUE \
    --public-ip-address-dns-name $VM \
    --image $(az image show \
        -g $RG \
        -n $IMAGE \
        --query id -o tsv)

Se a causa della larghezza di banda dal computer locale al disco di Azure occorre molto tempo per elaborare il caricamento con azcopy, è possibile usare una VM jumpbox di Azure per velocizzare il processo. Ecco come eseguire questo processo:

1. Crea un tarball del VHD sul computer locale: tar -czvf ./image_buster_azure_amd64.vhd.tar.gz ./image_[release]_azure_amd64.vhd.
2. Creare una macchina virtuale Linux di Azure (della propria distribuzione preferita). Assicurati di crearla con un disco abbastanza grande da contenere il VHD estratto.
3. Scaricare l'utilità azcopy nella VM Linux di Azure. È possibile recuperarla da Introduzione ad AzCopy.
4. Copiare il file tarball nella VM: scp ./image_buster_azure_amd64.vhd.tar.gz <vm>:~.
5. Nella VM estrarre il VHD: tar -xf ./image_buster_azure_amd64.vhd.tar.gz. Questo passaggio richiede un po' di tempo in base alle dimensioni del file.
6. Infine, nella macchina virtuale copiare il VHD nel disco di Azure con azcopy (il comando precedente).

Contenuto correlato

Ora puoi usare il tuo VHD Debian Linux per creare nuove VM in Azure. Se è la prima volta che si carica il file VHD in Azure, vedere Creare una macchina virtuale Linux da un disco personalizzato.

Per una macchina virtuale Azure esistente che è necessario passare da SCSI a NVMe, usare Convertire Linux e Windows macchine virtuali da SCSI a NVMe. Per informazioni sull'architettura e sul supporto, vedere Panoramica di NVMe.