Preparar un VHD de Debian para Azure

Se aplica a: ✔️ máquinas virtuales Linux ✔️ conjuntos de escalado flexibles

Requisitos previos

En esta sección se supone que ya ha instalado un sistema operativo Debian Linux desde un archivo .iso descargado desde el sitio web de Debian a un disco duro virtual (VHD). Existen varias herramientas para crear archivos .vhd. Hyper-V es solo un ejemplo. Para obtener instrucciones sobre cómo usar Hyper-V, consulte Instalación del rol de Hyper-V y configuración de una máquina virtual (VM).

Notas de instalación

• Para obtener más sugerencias sobre cómo preparar Linux para Azure, consulte Notas generales de instalación de Linux.
• El formato VHDX más reciente no se admite en Azure. Puede convertir el disco al formato VHD mediante el Administrador de Hyper-V o el cmdlet convert-vhd.
• Al instalar el sistema Linux, se recomienda usar particiones estándar en lugar de Administrador de volúmenes lógicos (LVM), que suele ser el valor predeterminado para muchas instalaciones. El uso de particiones evita conflictos de nombres de LVM con máquinas virtuales clonadas, especialmente si es necesario conectar un disco del sistema operativo a otra máquina virtual para solucionar problemas. LVM o RAID también se pueden usar en discos de datos.
• No configure una partición de intercambio en el disco del SO. El agente de Linux de Azure se puede configurar para crear un archivo de intercambio en el disco de recursos temporal. Puede encontrar más información en los pasos siguientes.
• Todos los VHD de Azure deben tener un tamaño virtual alineado a 1 MB. Al convertir un disco sin formato a VHD, debe asegurarse de que el tamaño del disco sin formato sea un múltiplo de 1 MB antes de convertirlo. Para obtener más información, consulte Notas de instalación de Linux.

Preparación de una imagen de Debian para Azure

Puede crear la imagen base de la nube de Azure Debian con el generador de imágenes en la nube de instalación totalmente automática (FAI). Para preparar una imagen sin FAI, consulte el artículo de pasos genéricos.

Los siguientes comandos de `git clone` y de instalación con `apt` se extrajeron del repositorio de imágenes en la nube de Debian. Empiece por clonar el repositorio e instalar dependencias:

$ 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

Opcional: personalice la compilación agregando scripts (por ejemplo, scripts de shell) a ./config_space/scripts/AZURE.

Ejemplo de script para personalizar la imagen

$ 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

Anteponga $ROOTCMD a cualquier comando que quiera usar para personalizar la imagen. Tiene el alias chroot $target.

Validación de la configuración del disco de Debian

Para las imágenes SCSI y NVMe, agregue un script de personalización de FAI que valide /etc/fstab y rechace nombres de disco no persistentes:

$ 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

Preparación de la imagen de Debian para NVMe remoto

Complete esta sección solo si va a crear una imagen para un controlador de disco NVMe remoto. De lo contrario, continúe con Build the Azure Debian image without adding this script (Compilar la imagen de Debian Azure sin agregar este script).

Agregue otro script de personalización de FAI antes de compilar la imagen NVMe. El script pone los controladores NVMe a disposición durante las fases iniciales del arranque y establece el tiempo de espera de E/S para Azure NVMe.

$ 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

Compilación de la imagen de Azure Debian

$ make image_[release]_azure_amd64

Este comando genera una serie de archivos en el directorio actual, en particular el archivo de imagen image_[release]_azure_amd64.raw.

Convierta la imagen sin procesar en VHD para 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"

Este proceso crea un VHD image_[release]_azure_amd64.vhd con un tamaño redondeado para que se pueda copiar correctamente en un disco de Azure.

Después de crear una imagen estable de VHD de Debian y antes de cargarla, compruebe que se instalan los siguientes paquetes:

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

A continuación, realice una actualización completa:

sudo apt full-upgrade

Ahora se deben crear los recursos de Azure para esta imagen. En este ejemplo se usa la variable $rounded_size_adjusted, por lo que debe estar dentro del mismo proceso de shell del paso anterior.

Establezca la generación de Hyper-V antes de crear el disco administrado. El ejemplo tiene como valor predeterminado V1 una imagen SCSI estándar. Cámbielo a V2 solo si completa la sección de preparación remota de NVMe o, de lo contrario, prepara una imagen de generación 2.

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)

Si el ancho de banda entre su equipo local y el disco de Azure hace que la carga con azcopy tarde mucho en procesarse, puede usar una máquina virtual de Azure como servidor de salto para acelerar el proceso. Este es el modo en que se puede realizar este proceso:

1. Cree un archivo tar del archivo VHD en su equipo local: tar -czvf ./image_buster_azure_amd64.vhd.tar.gz ./image_[release]_azure_amd64.vhd.
2. Cree una máquina virtual Linux de Azure (distribución de su elección). Asegúrese de crearlo con un disco con suficiente capacidad para contener el VHD extraído.
3. Descargue la utilidad azcopy en la máquina virtual Linux de Azure. Puede recuperarlo de Introducción a AzCopy.
4. Copie el archivo tar a la máquina virtual: scp ./image_buster_azure_amd64.vhd.tar.gz <vm>:~.
5. En la máquina virtual, extraiga el VHD: tar -xf ./image_buster_azure_amd64.vhd.tar.gz. Este paso tarda un poco de tiempo en función del tamaño del archivo.
6. Por último, en la máquina virtual, copie el VHD al disco de Azure con azcopy (el comando anterior).

Contenido relacionado

Ya está listo para usar el disco duro virtual de Debian Linux para crear nuevas máquinas virtuales en Azure. Si es la primera vez que carga el archivo .vhd en Azure, vea Crear una VM Linux a partir de un disco personalizado.

Para una máquina virtual de Azure existente que necesita migrar de SCSI a NVMe, use Convertir máquinas virtuales Linux y Windows de SCSI a NVMe. Para obtener información sobre arquitectura y soporte técnico, consulte Introducción a NVMe.