Perguntas frequentes sobre discos NVMe temporários

O suporte do NVMe para discos temporários locais varia no nível da família da VM (máquina virtual). Todas as novas VMs v6 com disco local são compatíveis com discos NVMe temporários, mas as VMs v5 e versões anteriores podem não ser compatíveis com discos locais NVMe temporários, já que a maioria dos discos locais desse tamanho se encontra na interface SCSI. Algumas famílias de VM, como a série L, incluem SSDs NVMe anexados de VMs de geração Lsv2 em diante. Consulte as visões gerais da família VM para determinar se há suporte para discos NVMe temporários. Além disso, o SO convidado precisa ser compatível com o driver NVMe para usar o NVMe local, o que é o padrão para a maioria das versões recentes do SO.

Uma diferença importante é que os discos NVMe temporários são transitórios e os dados nas VMs podem desaparecer, mas os dados em discos NVMe remotos são mantidos. Leve essa diferença em consideração ao escolher as opções de armazenamento da VM.

Diferente 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 no sistema de arquivos de preferência após a inicialização da VM.

As VMs das séries 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. Com esse método, é possível ter mais operações de entrada/saída por segundo e maior taxa de transferência para as cargas de trabalho.

• 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ções planejadas e eventos de recuperação automática iniciados pelo Azure, as VMs são inicializadas apenas com discos NVMe temporários brutos. Nenhum disco NVMe temporário é exibido para os aplicativos até que eles sejam inicializados e formatados.

• Após a inicialização da VM, você pode abranger unidades NVMe separadas em uma só, conforme necessário.

• Um arquivo de paginação do Windows é colocado em discos persistentes do SO (a menos que você esteja usando o recurso de SO efêmero), mas é possível movê-lo para discos NVMe temporários conforme necessário após a inicialização da VM.

• O recurso de SO 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, de maneira semelhante ao que era feito na v5 e em VMs 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) 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 o armazenamento local, em vez do protocolo SCSI utilizado pelos 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 valor NVMeDiskSizeInMiB especifica o tamanho do armazenamento local baseado em NVMe.

Todos os discos NVMe locais em máquinas virtuais (VMs) do Azure têm criptografia interna habilitada por padrão para proteção de dados. Os discos NVMe temporários oferecem suporte ao recurso de criptografia de dados inativos. Uma chave de criptografia de dados exclusiva (DEK) faz a criptografia dos dados de cada disco NVMe temporário atribuído à VM. Uma chave de criptografia de chave (KEK) ajuda a proteger o DEK. Quando você exclui uma VM, os dados no respectivo disco NVMe temporário são apagados de forma criptografada. Todas as VMs v6 introduzidas a partir de 202 têm as unidades NVMe locais criptografadas por padrão, usando a 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 chave de criptografia de mídia (MEK) exclusiva para cada disco na VM.
• O MEK é:
  • Gerada e armazenada inteiramente no hardware do dispositivo.
  • Nunca exposta ao host, VM ou qualquer componente externo, incluindo o operador ou o sistema do Azure.
• Todas as operações de criptografia e descriptografia são feitas no dispositivo usando a MEK.
• A MEK é destruída quando você apaga a VM, o que garante que nenhum componente consiga acessar os dados posteriormente.

A Criptografia Aprimorada em repouso é outra camada de proteção disponível nas VMs das séries V6 e Lsv4 do Azure por meio do suporte para padrões TCG-OPAL. Você não precisa executar nenhuma ação para esse recurso, é o padrão para esses tipos de VM.

• A infraestrutura do Azure gera e armazena com segurança um valor PIN para cada MEK.
• O PIN é transmitido usando uma função de derivação de chave (KDF) no dispositivo de armazenamento, a fim de gerar uma chave de criptografia de chave (KEK). O PIN atua como uma chave de gerenciamento de plataforma (PMK).
• A MEK é criptografada usando a KEK e armazenada internamente no dispositivo de armazenamento.
• O KEK não é armazenado em nenhum lugar e o dispositivo de armazenamento gera dinamicamente o KEK 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. Ela é bloqueada quando a VM é interrompida, o que garante que os dados só sejam acessíveis enquanto a VM estiver em execução.

Consulta as perguntas frequentes sobre tamanhos de VM do Azure sem disco temporário local.

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*$//'

Use a GUI ou o PowerShell do Azure.

GUI

1. Selecione a tecla com o logotipo do Windows + R para abrir a caixa de diálogo Executar. Digite diskmgmt.msc e selecione a tecla Enter.

   

2. Selecione um estilo de partição (MBR ou GPT) e os discos a serem inicializados. Em seguida, selecione OK.

   

3. Clique com o botão direito do mouse no disco a ser particionado e, em seguida. selecione Novo volume simples.

   

4. Para especificar itens como tamanho do volume, letra da unidade, sistema de arquivos e rótulo de volume, siga as instruções exibidas pelo assistente após selecionar Novo volume simples. Selecione o botão Próximo para avançar pelo assistente.

   

   

   

5. Para concluir a partição e o formato, confira as configurações e selecione Concluir.

   

6. Confirme se os discos NVMe formatados e inicializados aparecem na ferramenta de gerenciamento de disco do Windows, de maneira semelhante a como Novo volume (E:) aparece neste exemplo.

   

Script do PowerShell do Azure

# 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

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 SO convidado. Esse script usa o comando nvme-cli id-ctrl para consultar o número de modelo de cada dispositivo NVMe.

Primeiramente, o script verifica se há volumes de discos NVMe temporários já criados (identificados pelo rótulo filesystem). Se houver sinal de uma matriz presente, o script verifica a integridade da matriz e repete o processo de inicialização, se necessário. A matriz é 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
    printf "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

Para distribuições baseadas em RHEL/CentOS, substitua update-initramfs -u por dracut --force para regenerar o arquivo initramfs. Se o script interromper a execução com "Não foi possível localizar o arquivo mdadm.conf", você poderá criar um arquivo mdadm.conf usando o seguinte comando:

sudo touch /etc/mdadm/mdadm.conf

Use a GUI ou o PowerShell do Azure.

GUI

1. Selecione a tecla com o logotipo do Windows + R para abrir a caixa de diálogo Executar. Digite sysdm.cpl e selecione a tecla Enter.

   

2. Selecione a guia Avançado e, em seguida, selecione o botão Configurações na seção Desempenho.

   

3. 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.

   

4. Desmarque a caixa de seleção Gerenciar automaticamente o tamanho do arquivo de paginação de todas as unidades. Se um arquivo de paginação estiver definido para o disco do SO, selecione o disco do SO, selecione a opção Nenhum arquivo de paginação e, em seguida, selecione o botão Definir. Selecione a unidade NVMe temporária local, selecione a opção Tamanho gerenciado pelo sistema e, em seguida, selecione o botão Definir. Selecione OK para fechar todas as caixas de diálogo.

   

Talvez seja necessário reiniciar a VM para as novas alterações entrarem 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

Talvez seja necessário reiniciar a VM para as novas alterações entrarem em vigor.

1. 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
   

2. Criar 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
   

3. Habilitar o espaço de troca:

   root@D2adsv6:/ # swapon /dev/nvme0n1
   

4. Verificar se o espaço de troca está configurado corretamente:

   root@D2adsv6:/ # swapon -s
   Filename                                Type            Size    Used    Priority
   /dev/nvme0n1                            partition       78643196        0       -2
   

5. Acrescente o espaço de troca a /etc/fstab para torná-lo persistente em diferentes reinicializações:

   root@D2adsv6:/ # echo '/dev/nvme0n1 swap swap defaults 0 0' >> /etc/fstab 
   

Os discos NVMe temporários anexados a VMs V6 são efêmeros, semelhantes às unidades temporárias em outras séries de VM. Nesse caso, você perderá todos os dados na VM após a reimplantação ou durante um evento de manutenção. Para 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 transferida para um novo hardware, essas unidades serão desmontadas e novos discos desmontados serão apresentados ao sistema operacional quando ele voltar a funcionar. Caso a VM não tenha alterado 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 realizar a montagem.

É recomendado executar o script de montagem automaticamente sempre que a VM inicializar e atrasar qualquer outro script de inicialização que precise das unidades até que o script de montagem conclua a execução.

O desempenho temporário do disco é influenciado por vários fatores, como tamanho do bloco, padrões de leitura/gravação da carga de trabalho, QD (profundidade da fila). As especificações de desempenho publicadas consistem em cenários ideais, que têm como base blocos aleatórios de 4 mil com vários trabalhadores (≥8) a QD≥64 por trabalhador para picos de IOPS e tamanhos de bloco grandes e sequenciais (≥128 mil) para máxima taxa de transferência. O desempenho de gravação também pode ser afetado por padrões de dados, estado SSD (capacidade superprovisionada, porcentagem de LBA gravada) e atividades em segundo plano, como coleta de lixo. Os números de desempenho pressupõem que o dispositivo esteja em um estado FOB (recém-pronto para uso), que fornece as velocidades mais altas. Depois que o disco atingir o estado estável após as especificações de pré-condição padrão do SNIA, o desempenho de gravação poderá ser menor que os níveis de FOB.