Preparar um VHD do Debian para o Azure

Aplica-se a: ✔️ VMs do Linux ✔️ Conjuntos de dimensionamento flexíveis

Pré-requisitos

Esta seção pressupõe que você já instalou um sistema operacional Linux Debian a partir de um arquivo .iso baixado do site do Debian para um disco rígido virtual. Existem várias ferramentas para criar arquivos .vhd; Hyper-V é apenas um exemplo. Para obter instruções sobre como usar a Hyper-V, consulte Instalar a função Hyper-V e configurar uma máquina Virtual.

Notas de instalação

  • Veja também as Notas de Instalação Geral do Linux para obter mais dicas sobre como preparar o Linux para o Azure.
  • Não há suporte para o formato VHDX mais recente no Azure. Você pode converter o disco em formato VHD usando o Gerenciador do Hyper-V ou o cmdlet convert-vhd .
  • Ao instalar o sistema Linux, é recomendável que você use partições padrão em vez de LVM (geralmente o padrão para muitas instalações). Isso irá evitar conflitos de nome LVM com VMs clonadas, especialmente se um disco do sistema operacional precisar ser anexado a outra VM para solução de problemas. Se você preferir, é possível usar LVM ou RAID em discos de dados.
  • Não configure uma partição de permuta no disco do SO. O agente Linux do Azure pode ser configurado para criar um arquivo de permuta no disco de recursos temporários. Verifique as etapas a seguir para obter mais informações.
  • Todos os VHDs no Azure devem ter um tamanho virtual alinhado a 1 MB. Ao converter de um disco não processado para VHD, certifique-se de que o tamanho do disco não processado seja um múltiplo de 1 MB antes da conversão. Para obter mais informações, consulte Notas de Instalação do Linux.

Usar o gerenciamento do Azure para criar VHDs Debian

Existem ferramentas disponíveis para gerar VHDs Debian para o Azure, como os scripts azure-manage do Credativ. Essa é a abordagem recomendada em vez de criar uma imagem do zero. Por exemplo, para criar um VHD no Debian 8, execute os seguintes comandos para baixar o azure-manage utilitário (e dependências) e executar o azure_build_image script:

# sudo apt-get update
# sudo apt-get install git qemu-utils mbr kpartx debootstrap

# sudo apt-get install python3-pip python3-dateutil python3-cryptography
# sudo pip3 install azure-storage azure-servicemanagement-legacy azure-common pytest pyyaml
# git clone https://github.com/credativ/azure-manage.git
# cd azure-manage
# sudo pip3 install .

# sudo azure_build_image --option release=jessie --option image_size_gb=30 --option image_prefix=debian-jessie-azure section

Preparar uma imagem do Debian para o Azure

É possível criar uma imagem base da Nuvem do Debian do Azure usando um construtor de imagens de nuvem do FAI.

Comece clonando o repositório e instalando dependências (os comandos git clone e apt install mostrados abaixo foram retirados do repositório de Imagens de Nuvem do Debian):

$ 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

Personalize o build adicionando scripts, como scripts de shell, a ./config_space/scripts/AZURE (opcional).

Um exemplo de script usado para personalizar uma imagem é:

$ 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

Observe que é importante prefixar os comandos que você deseja usar para personalizar a imagem com $ROOTCMD, pois o alias dele é chroot $target.

Crie uma imagem do Debian 10 do Azure:

$ make image_buster_azure_amd64

Isso gerar vários arquivos no diretório atual, sobretudo o arquivo de imagem image_buster_azure_amd64.raw.

É possível executar a etapa abaixo a fim de converter a imagem bruta em VHD para o Azure:

rawdisk="image_buster_azure_amd64.raw"
vhddisk="image_buster_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"

Isso vai criar um image_buster_azure_amd64.vhd de VHD com um tamanho arredondado para que seja possível copiá-lo com êxito em um Disco do Azure.

Agora precisamos criar recursos do Azure para essa imagem (esse tipo de ação usa a variável $rounded_size_adjusted, portanto, ela deve ser executada dentro do mesmo processo de shell mostrado acima).

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 V1

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 \
    --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)

Observação

Caso a largura de banda do computador local para o Disco do Azure esteja levando muito tempo para processar o upload com o comando azcopy, será possível usar um jumpbox da VM do Azure para acelerar o processo. Veja abaixo de que modo executar isso:

  1. Crie um tarball do VHD em seu computador local: tar -czvf ./image_buster_azure_amd64.vhd.tar.gz ./image_buster_azure_amd64.vhd.
  2. Crie uma VM do Linux no Azure (usando a distribuição de sua escolha). Verifique se ela foi criada com um disco grande o suficiente para manter a extração do VHD!
  3. Baixe um utilitário azcopy para a VM do Linux no Azure. Ele pode ser recuperado aqui.
  4. Copie o tarball para a VM: scp ./image_buster_azure_amd64.vhd.tar.gz <vm>:~.
  5. Na VM, extraia o VHD: tar -xf ./image_buster_azure_amd64.vhd.tar.gz (isso levará algum tempo considerando o tamanho do arquivo).
  6. Por fim, copie o VHD para o Disco do Azure usando azcopy (o comando mostrado acima) na VM.

Próximas etapas: agora, você está pronto para usar o disco rígido virtual Debian Linux para criar novas máquinas virtuais no Azure. Se esta é a primeira vez que você está carregando o arquivo .vhd para o Azure, consulte Criar uma VM do Linux a partir de um disco personalizado.