Este artigo aborda algumas perguntas comuns sobre o suporte a discos NVMe (Express de Memória Não Volátil) temporários em VMs (máquinas virtuais) criadas no Azure. Neste artigo, o termo "disco temporário" está se referindo ao disco temporário criado no SSD local.
Quais são os pré-requisitos para criar disco temporário que usa a interface NVMe para minha VM?
O suporte NVMe para discos temporários locais varia em um nível de família de VM (máquina virtual). Todas as novas VMs v6 com disco local dão suporte a discos temporários NVMe, mas as VMs v5 e versões anteriores podem não dar suporte a discos temporários locais NVMe, pois a maioria desses tamanhos de discos locais está na interface SCSI. Algumas famílias de VM, como a série L, anexaram localmente SSDs NVMe de VMs de geração Lsv2 em diante. Consulte as visões gerais da família VM para determinar se há suporte para discos temporários NVMe. Além disso, observe que o sistema operacional convidado precisa ter suporte ao driver NVMe para usar o NVMe local, que a maioria das versões recentes do sistema operacional tem por padrão.
Como os discos NVMe temporários em meu VMs Dl/D/E_v6 são diferentes dos discos NVMe remotos?
Uma diferença importante é que os discos temporários NVMe são transitórios e os dados nas VMs podem desaparecer, mas os dados em discos NVMe remotos permanecem. Considere essa diferença ao escolher as opções de armazenamento da VM.
Ao contrário das VMs anteriores da série D/E, as novas VMs v6 vêm com discos NVMe brutos e não formatados. Os clientes devem inicializar e formatar os discos em um sistema de arquivos de sua preferência após a inicialização da VM.
As VMs da série DI/D/E v6 são otimizadas para usar o disco NVMe temporário local no nó anexado diretamente à VM, em vez de discos SCSI (Small Computer System Interface) locais usados anteriormente. Esse método permite operações de entrada/saída mais altas por segundo e maior taxa de transferência para suas cargas de trabalho.
Para quais alterações devo me preparar ao configurar minhas VMs com discos NVMe temporários?
Os discos devem ser inicializados e formatados após a inicialização da VM. Após paradas iniciadas pelo usuário, desalocações ou manutenção planejada e eventos de recuperação automática iniciados pelo Azure, as VMs começam com apenas discos NVMe temporários brutos. Nenhum disco temporário NVMe fica visível para aplicativos até que eles sejam inicializados e formatados.
Você pode abranger unidades NVMe separadas em uma conforme necessário após o início da VM.
Um arquivo de página do Windows é colocado em discos persistentes do sistema operacional (a menos que você esteja usando o recurso de sistema operacional efêmero), mas você pode movê-lo para discos temporários NVMe conforme necessário após a inicialização da VM.
O recurso de sistema operacional efêmero, se usado, converte um ou vários discos NVMe (dependendo da VM e do tamanho da imagem) em um disco baseado em SCSI/VHD mais lento, semelhante a como ele estava em VMs v5 e mais antigas. Para os tamanhos de VM maiores, as unidades restantes permanecerão como NVMe não formatados brutos.
A lista de SKUs (Unidades de Manutenção de Estoque) de recursos na API REST expõe vários recursos de máquinas virtuais. A próxima iteração de tamanhos de VM usa o protocolo NVMe mais rápido e eficiente para armazenamento local, em vez do protocolo SCSI usado por tamanhos de VMs anteriores.
Para máquinas virtuais do Azure, o armazenamento local baseado em SCSI é um disco de recurso temporário, e o valor
MaxResourceVolumeMB
especifica o tamanho desse disco. Por outro lado, o valorNVMeDiskSizeInMiB
especifica o tamanho do armazenamento local baseado em NVMe.
Qual é a criptografia mínima oferecida pelo Azure para os discos temporários NVMe?
Todos os discos NVMe locais em VMs (máquinas virtuais) do Azure têm criptografia interna habilitada por padrão para proteção de dados. Os discos Temp NVMe dão suporte ao recurso de criptografia de dados em repouso. Uma chave de criptografia de dados exclusiva (DEK) criptografa os dados de cada disco temporário NVMe atribuído à VM. Uma KEK (chave de criptografia de chave) ajuda a proteger o DEK. Quando você exclui uma VM, os dados em seu disco NVMe temporário serão apagados criptograficamente. Todas as VMs v6 introduzidas a partir de 2024 e em diante têm as unidades NVMe locais criptografadas por padrão por meio da criptografia baseada em hardware com uma chave gerenciada pela plataforma.
- Os dados são criptografados usando XTS-AES-256, AES-256-GCM ou uma criptografia mais forte.
- O dispositivo gera uma MEK (Chave de Criptografia de Mídia) exclusiva para cada disco na VM.
- O MEK é:
- Gerado e armazenado inteiramente dentro do hardware do dispositivo.
- Nunca exposto ao host, VM ou qualquer componente externo, incluindo o operador ou o sistema do Azure.
- Todas as operações de criptografia e descriptografia ocorrem dentro do dispositivo usando o MEK.
- O MEK é destruído quando você exclui sua VM, garantindo que nenhum componente possa acessar os dados posteriormente.
O que é criptografia avançada em repouso?
A Criptografia Aprimorada em repouso é outra camada de proteção que está disponível nas VMs das séries V6 e Lsv4 do Azure por meio do suporte para padrões de TCG-OPAL. Você não precisa executar nenhuma ação para esse recurso, ele é o padrão para esses tipos de VM.
- Um valor PIN é gerado e armazenado com segurança pela infraestrutura do Azure para cada MEK.
- O PIN é passado por meio de uma KDF (Função de Derivação de Chave) dentro do dispositivo de armazenamento para gerar uma KEK (Chave de Criptografia de Chave). O PIN atua como uma PMK (chave de gerenciamento de plataforma).
- O MEK é criptografado usando o KEK e armazenado internamente dentro do dispositivo de armazenamento.
- O KEK não é armazenado em nenhum lugar e é gerado dinamicamente pelo dispositivo de armazenamento quando o PIN é usado para autenticá-lo com êxito. Sem esse PIN, o dispositivo não pode descriptografar seus próprios dados armazenados, mesmo que fisicamente acessados.
- O dispositivo de armazenamento é autenticado quando a VM é iniciada e é bloqueada quando a VM é interrompida, garantindo que o acesso aos dados só esteja disponível quando a VM estiver em execução.
Como posso redimensionar uma VM v5 ou mais antiga com um disco temporário para v6?
Como posso identificar meus discos NVMe temporários?
Você pode executar o seguinte comando no Windows:
Get-PhysicalDisk | where { $_.FriendlyName.contains("NVMe Direct Disk")}
Você pode executar o seguinte comando no Linux:
sudo nvme id-ns /dev/nvme0n1 -b | dd bs=1 skip=384 status=none | sed 's/\x00*$//'
Como posso formatar e inicializar discos NVMe temporários no Windows quando crio uma VM?
Você pode usar a GUI ou o Azure PowerShell.
GUI
Dica
O exemplo de GUI a seguir destina-se a fins ilustrativos. Recomendamos que você crie scripts para automatizar esse fluxo de trabalho para implantações de produção.
Selecione a tecla de logotipo do Windows + R para abrir a caixa de diálogo Executar. Digite diskmgmt.msc e selecione a tecla Enter.
Selecione um estilo de partição (MBR ou GPT) e os discos a serem inicializados e selecione OK.
Clique com o botão direito do mouse no disco a ser particionado e selecione o item de menu Novo Volume Simples.
Para especificar itens como tamanho do volume, letra da unidade, sistema de arquivos e rótulo de volume, siga o Novo Assistente de Volume Simples. Selecione o botão Próximo para avançar pelo assistente.
Para concluir a partição e o formato, revise as configurações e selecione Concluir.
Confirme se os discos NVMe formatados e inicializados aparecem na ferramenta gerenciamento de disco do Windows, semelhante à forma como Novo Volume (E:) aparece neste exemplo.
Script do PowerShell do Azure
Dica
O script a seguir inicializa, formata e atribui letras de unidade. No entanto, ele apaga todos os dados no disco. Você deve testá-lo minuciosamente em suas VMs antes de implantá-lo na produção.
# Select the raw NVMe disks to partition and format
$RawNvmeDisks = Get-PhysicalDisk -CanPool $True | where { $_.FriendlyName.contains("NVMe Direct Disk")}
# Create a pool of the existing disks
New-StoragePool -FriendlyName NVMePool -StorageSubsystemFriendlyName "Windows Storage*" -PhysicalDisks $RawNvmeDisks -ResiliencySettingNameDefault Simple
#Create a new disk, initialize, partition, and format
$Disk = New-VirtualDisk -FriendlyName NVMeTemporary -StoragePoolFriendlyName NVMePool -NumberOfColumns @($RawNvmeDisks).count -PhysicalDiskRedundancy 0 -ResiliencySettingName "Simple" -UseMaximumSize
$Disk | Initialize-Disk
#Create a partition and format. Ignore the pop-up.
New-Partition -DiskId $Disk.UniqueId -AssignDriveLetter -UseMaximumSize | Format-Volume
Como posso formatar e inicializar discos NVMe temporários no Linux?
O script a seguir fornece um exemplo de inicialização de discos NVMe temporários no Linux. O script enumera todos os discos NVMe temporários na VM, combina os discos em uma única matriz RAID 0 e cria uma partição formatada do sistema de arquivos especificado.
Os discos NVMe temporários podem ser distinguidos pelo número do modelo, que aparece como Microsoft NVMe Direct Disk
para o sistema operacional convidado. Esse script usa o comando nvme-cli id-ctrl
para consultar o número de modelo de cada dispositivo NVMe.
O script verifica primeiro se há volumes de disco NVMe temporários já criados (identificados pelo rótulo filesystem
). Se uma matriz parecer estar presente, o script verificará a integridade da matriz e repetirá o processo de inicialização, se necessário. A matriz será inicializada novamente nos seguintes casos:
- Um ou mais discos temporários de matriz estão ausentes.
- Ainda não há discos temporários incorporados à matriz.
- A matriz de disco está em um estado inválido ou desconhecido.
- Os arquivos de configuração associados estão ausentes ou inválidos.
#!/bin/bash
# Script requirements:
# nvme-cli
# mdadm
# gdisk
readonly USAGE="Usage: $(basename "$0") <filesystem> <filesystem mount point (optional)>"
# Label used to identify the NVMe array file system and associated disks
# Can't exceed 16 characters
readonly RAID0_FILESYSTEM_LABEL="azure_nvme_temp"
# Device path used for the RAID 0 NVMe array
# Choose any unoccupied device path of format /dev/mdX (X = 0 to 99)
readonly RAID0_DEVICE_PATH="/dev/md0"
# Formatted RAID 0 partition is mounted here
readonly DEFAULT_MOUNT_POINT="/mnt/${RAID0_FILESYSTEM_LABEL}"
filesystem="$1"
if [ ! "$filesystem" ]; then
printf "No filesystem specified. Usage: $USAGE\n"
exit 1
fi
if ! [ -x "$(command -v mkfs.$filesystem)" ]; then
printf "Filesystem \"$filesystem\" not supported by mkfs\n$USAGE\n"
exit 1
fi
mount_point="$2"
if [ ! "$mount_point" ]; then
printf "No mount point specified. Using default: $DEFAULT_MOUNT_POINT\n"
mount_point=$DEFAULT_MOUNT_POINT
fi
# Make sure mdadm.conf is present
mdadm_conf_path=""
if [ -e "/etc/mdadm/mdadm.conf" ]; then
mdadm_conf_path="/etc/mdadm/mdadm.conf"
elif [ -e "/etc/mdadm.conf" ]; then
mdadm_conf_path="/etc/mdadm.conf"
else
print "Couldn't find mdadm.conf file"
exit 1
fi
# Enumerate unmounted NVMe direct disks
devices=$(lsblk -p -o NAME,TYPE,MOUNTPOINT | grep "nvme" | awk '$2 == "disk" && $3 == "" {print $1}')
nvme_direct_disks=()
for device in $devices
do
if nvme id-ctrl "$device" | grep -q "Microsoft NVMe Direct Disk"; then
nvme_direct_disks+=("$device")
fi
done
nvme_direct_disk_count=${#nvme_direct_disks[@]}
printf "Found $nvme_direct_disk_count NVMe Direct Disks\n"
# Check if there's already an NVMe Direct Disk RAID 0 disk (or remnant data)
if grep "$RAID0_FILESYSTEM_LABEL" /etc/fstab > /dev/null; then
fstab_entry_present=true
fi
if grep "$RAID0_FILESYSTEM_LABEL" $mdadm_conf_path > /dev/null; then
mdadm_conf_entry_present=true
fi
if [ -e $RAID0_DEVICE_PATH ]; then
nvme_raid0_present=true
fi
if [ "$fstab_entry_present" = true ] || [ "$mdadm_conf_entry_present" = true ] || [ "$nvme_raid0_present" = true ]; then
# Check if the RAID 0 volume and associated configurations are still intact or need to be reinitialized
#
# If reinitialization is needed, clear the old RAID 0 information and associated files
reinit_raid0=false
if [ "$fstab_entry_present" = true ] && [ "$mdadm_conf_entry_present" = true ] && [ "$nvme_raid0_present" = true ]; then
# Check RAID 0 device status
if ! mdadm --detail --test $RAID0_DEVICE_PATH &> /dev/null; then
reinit_raid0=true
# Test the NVMe direct disks for valid mdadm superblocks
else
for device in "${nvme_direct_disks[@]}"
do
if ! mdadm --examine $device &> /dev/null; then
reinit_raid0=true
break
fi
done
fi
else
reinit_raid0=true
fi
if [ "$reinit_raid0" = true ]; then
echo "Errors found in NVMe RAID 0 temp array device or configuration. Reinitializing."
# Remove the file system and partition table, and stop the RAID 0 array
if [ "$nvme_raid0_present" = true ]; then
if [ -e ${RAID0_DEVICE_PATH}p1 ]; then
umount ${RAID0_DEVICE_PATH}p1
wipefs -a -f ${RAID0_DEVICE_PATH}p1
fi
sgdisk -o $RAID0_DEVICE_PATH &> /dev/null
mdadm --stop $RAID0_DEVICE_PATH
fi
# Remove any mdadm metadata from all NVMe Direct Disks
for device in "${nvme_direct_disks[@]}"
do
printf "Clearing mdadm superblock from $device\n"
mdadm --zero-superblock $device &> /dev/null
done
# Remove any associated entries in fstab and mdadm.conf
sed -i.bak "/$RAID0_FILESYSTEM_LABEL/d" /etc/fstab
sed -i.bak "/$RAID0_FILESYSTEM_LABEL/d" $mdadm_conf_path
else
printf "Valid NVMe RAID 0 array present and no additional Direct Disks found. Skipping\n"
exit 0
fi
fi
if [ "$nvme_direct_disk_count" -eq 0 ]; then
printf "No NVMe Direct Disks found\n"
exit 1
elif [ "$nvme_direct_disk_count" -eq 1 ]; then
additional_mdadm_params="--force"
fi
# Initialize enumerated disks as RAID 0
printf "Creating RAID 0 array from:\n"
printf "${nvme_direct_disks[*]}\n\n"
if ! mdadm --create $RAID0_DEVICE_PATH --verbose $additional_mdadm_params --name=$RAID0_FILESYSTEM_LABEL --level=0 --raid-devices=$nvme_direct_disk_count ${nvme_direct_disks[*]}; then
printf "Failed to create RAID 0 array\n"
exit 1
fi
# Create a GPT partition entry
readonly GPT_PARTITION_TYPE_GUID="0FC63DAF-8483-4772-8E79-3D69D8477DE4"
printf "\nCreating GPT on $RAID0_DEVICE_PATH..\n"
sgdisk -o $RAID0_DEVICE_PATH &> /dev/null
if ! sgdisk --new 1::0 --typecode 1:$GPT_PARTITION_TYPE_GUID $RAID0_DEVICE_PATH &> /dev/null; then
printf "Failed to create partition on $RAID0_DEVICE_PATH\n"
exit 1
fi
# Format the partition
partition_path="${RAID0_DEVICE_PATH}p1"
printf "\nCreating $filesystem filesystem..\n"
if ! mkfs.$filesystem -q -L $RAID0_FILESYSTEM_LABEL $partition_path; then
printf "Failed to create $filesystem filesystem\n"
exit 1
fi
printf "The operation has completed successfully.\n"
# Add the partition to /etc/fstab
echo "LABEL=$RAID0_FILESYSTEM_LABEL $mount_point $filesystem defaults,nofail 0 0" >> /etc/fstab
# Add RAID 0 array to mdadm.conf
mdadm --detail --scan >> $mdadm_conf_path
update-initramfs -u
# Mount the partition
printf "\nMounting filesystem to $mount_point..\n"
mkdir $mount_point &> /dev/null
if ! mount -a; then
printf "Failed to automount partition\n"
exit 1
fi
printf "The operation has completed successfully.\n"
exit 0
Como posso mover o arquivo de página do Windows do disco do sistema operacional para um disco NVMe temporário?
Você pode usar a GUI ou o Azure PowerShell.
GUI
Dica
O exemplo de GUI a seguir destina-se a fins ilustrativos. Recomendamos que você crie scripts para automatizar esse fluxo de trabalho para implantações de produção.
Selecione a tecla de logotipo do Windows + R para abrir a caixa de diálogo Executar. Digite sysdm.cpl e selecione a tecla Enter.
Selecione a guia Avançado e, em seguida, selecione o botão Configurações na seção Desempenho.
Na caixa de diálogo Opções de desempenho, selecione a guia Avançado e, em seguida, selecione o botão Alterar na seção Memória virtual.
Desmarque a caixa de seleção Gerenciar automaticamente o tamanho do arquivo de paginação de todas as unidades. Se um arquivo de página estiver definido para o disco do sistema operacional, selecione o disco do sistema operacional, selecione a opção Nenhum arquivo de paginação e selecione o botão Definir. Selecione sua unidade NVMe temporária local e selecione a opção Tamanho gerenciado pelo sistema e selecione o botão Definir. Selecione OK para fechar todas as caixas de diálogo.
Pode ser necessário reiniciar a VM para que essas alterações entrem em vigor.
Script do PowerShell do Azure
$OsDisk = "C:"
# This value can vary, depending on which drive letter is assigned to the disk
$NVMeDisk = "E:"
# Disable automatic pagefile management
$Computer = Get-WmiObject Win32_computersystem -EnableAllPrivileges
$Computer.AutomaticManagedPagefile = $false
$Computer.Put()
# Delete the pagefile on the OS disk
$PageFile = Get-WmiObject -Query "select * from Win32_PageFileSetting where name='$OsDisk\\pagefile.sys'"
$PageFile.Delete()
# Create a new pagefile on the NVMe drive with system-managed size
Set-WMIInstance -Class Win32_PageFileSetting -Arguments @{name="$NVMeDisk\\pagefile.sys"; InitialSize=0; MaximumSize=0} -EnableAllPrivileges
Pode ser necessário reiniciar a VM para que essas alterações entrem em vigor.
Como posso mover o arquivo de permuta do Linux do disco de um sistema operacional para um disco NVMe temporário?
Selecione o disco NVMe usado para o espaço de troca:
root@D2adsv6:/ # lsblk -p NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT /dev/nvme1n1 259:0 0 30G 0 disk ├─/dev/nvme1n1p1 259:1 0 29.9G 0 part / └─/dev/nvme1n1p15 259:3 0 106M 0 part /boot/efi /dev/nvme0n1 259:4 0 75G 0 disk
Crie espaço de troca no disco:
root@D2adsv6:/ # mkswap /dev/nvme0n1 Setting up swapspace version 1, size = 75 GiB (80530632704 bytes) no label, UUID=064bdcfb-86ae-49f3-bf9d-b956493e2a1d
Habilite o espaço de troca:
root@D2adsv6:/ # swapon /dev/nvme0n1
Verifique se o espaço de troca está sendo configurado corretamente:
root@D2adsv6:/ # swapon -s Filename Type Size Used Priority /dev/nvme0n1 partition 78643196 0 -2
Acrescente o espaço de troca a
/etc/fstab
para torná-lo persistente entre reinicializações:root@D2adsv6:/ # echo '/dev/nvme0n1 swap swap defaults 0 0' >> /etc/fstab
Quais considerações preciso estar ciente para eventos de manutenção, reimplantações de VM e reinicializações de VM?
Os discos NVMe temporários anexados a VMs V6 são efêmeros, semelhantes às unidades temporárias em outras séries de VM. Isso significa que você perderá todos os dados na VM após a reimplantação ou durante um evento de manutenção. Para obter mais informações sobre eventos de manutenção e tempo de inatividade, consulte Noções básicas sobre reinicializações: Manutenção versus tempo de inatividade.
Se a VM for movida para um novo hardware, essas unidades serão desmontadas e novos discos desmontados serão apresentados ao sistema operacional quando ele voltar a funcionar. Se a VM não alterou o hardware, os discos NVMe temporários ainda poderão estar presentes. Os scripts anteriores para montar as unidades verificam se há unidades desmontadas antes de tentar montar.
É uma melhor prática executar o script de montagem automaticamente sempre que a VM inicializar e atrasar quaisquer outros scripts de inicialização que precisem das unidades até que o script de montagem conclua a execução.