Udostępnij za pośrednictwem

Przykładowe skrypty usługi Azure Disk Encryption dla maszyn wirtualnych z systemem Linux

Ważne

Usługa Azure Disk Encryption ma zostać wycofana 15 września 2028 r. Do tej pory można nadal korzystać z usługi Azure Disk Encryption bez zakłóceń. 15 września 2028 r. obciążenia z obsługą programu ADE będą nadal działać, ale zaszyfrowane dyski nie będą mogły zostać odblokowane po ponownym uruchomieniu maszyny wirtualnej, co spowoduje przerwy w działaniu usługi.

Użyj szyfrowania na hoście dla nowych maszyn wirtualnych lub rozważ poufne rozmiary maszyn wirtualnych z szyfrowaniem dysków systemu operacyjnego na potrzeby obciążeń przetwarzania poufnego. Wszystkie maszyny wirtualne z obsługą programu ADE (w tym kopie zapasowe) muszą migrować do szyfrowania na hoście przed datą wycofania, aby uniknąć przerw w działaniu usługi. Aby uzyskać szczegółowe informacje, zobacz Migrowanie z usługi Azure Disk Encryption do szyfrowania na hoście .

Uwaga

W tym artykule odwołuje się do systemu CentOS — dystrybucji systemu Linux, która jest stanem End Of Life (EOL). Zastanów się nad sposobem użycia i zaplanuj odpowiednio. Aby uzyskać więcej informacji, zobacz wskazówki dotyczące zakończenia życia systemu CentOS.

Dotyczy: ✔️ Maszyny wirtualne z systemem Linux — elastyczne zestawy skalowania ✔️

Ten artykuł zawiera przykładowe skrypty do przygotowywania wstępnie zaszyfrowanych dysków VHD i innych zadań.

Uwaga

Wszystkie skrypty odnoszą się do najnowszej, innej niż AAD wersji usługi ADE, z wyjątkiem przypadków, w których określono.

Przykładowe skrypty programu PowerShell dla usługi Azure Disk Encryption

  • Wyświetlanie listy wszystkich zaszyfrowanych maszyn wirtualnych w ramach subskrypcji

    Za pomocą tego skryptu programu PowerShell można znaleźć wszystkie maszyny wirtualne zaszyfrowane za pomocą programu ADE i wersję rozszerzenia we wszystkich grupach zasobów znajdujących się w subskrypcji.

    Alternatywnie te polecenia cmdlet będą wyświetlać wszystkie maszyny wirtualne szyfrowane za pomocą programu ADE (ale nie wersję rozszerzenia):

    $osVolEncrypted = {(Get-AzVMDiskEncryptionStatus -ResourceGroupName $_.ResourceGroupName -VMName $_.Name).OsVolumeEncrypted}
$dataVolEncrypted= {(Get-AzVMDiskEncryptionStatus -ResourceGroupName $_.ResourceGroupName -VMName $_.Name).DataVolumesEncrypted}
Get-AzVm | Format-Table @{Label="MachineName"; Expression={$_.Name}}, @{Label="OsVolumeEncrypted"; Expression=$osVolEncrypted}, @{Label="DataVolumesEncrypted"; Expression=$dataVolEncrypted}

  • Wyświetlanie listy wszystkich zaszyfrowanych wystąpień usługi VMSS w ramach subskrypcji

    Wszystkie wystąpienia usługi VMSS szyfrowane za pomocą programu ADE i wersję rozszerzenia można znaleźć we wszystkich grupach zasobów znajdujących się w subskrypcji przy użyciu tego skryptu programu PowerShell.

  • Spisz wszystkie tajne dane szyfrowania dysków używane do szyfrowania maszyn wirtualnych w magazynie kluczy

    Get-AzKeyVaultSecret -VaultName $KeyVaultName | where {$_.Tags.ContainsKey('DiskEncryptionKeyFileName')} | format-table @{Label="MachineName"; Expression={$_.Tags['MachineName']}}, @{Label="VolumeLetter"; Expression={$_.Tags['VolumeLetter']}}, @{Label="EncryptionKeyURL"; Expression={$_.Id}}

Korzystanie ze skryptu PowerShell dotyczącego wymagań wstępnych dla Azure Disk Encryption

Jeśli znasz już wymagania wstępne dotyczące usługi Azure Disk Encryption, możesz użyć skryptu programu PowerShell dotyczącego wymagań wstępnych usługi Azure Disk Encryption. Przykład użycia tego skryptu programu PowerShell można znaleźć w przewodniku Szyfrowanie maszyny wirtualnej — Szybki start. Komentarze można usunąć z sekcji skryptu, począwszy od wiersza 211, aby zaszyfrować wszystkie dyski dla istniejących maszyn wirtualnych w istniejącej grupie zasobów.

W poniższej tabeli przedstawiono parametry, których można użyć w skryscie programu PowerShell:

Parametr Opis Obowiązkowe?
$resourceGroupName Nazwa grupy zasobów, do której należy usługa KeyVault. Jeśli grupa zasobów nie istnieje, zostanie utworzona nowa grupa zasobów o tej nazwie. Prawda
$keyVaultName Nazwa magazynu kluczy, w którym mają zostać umieszczone klucze szyfrowania. Zostanie utworzony nowy sejf o tej nazwie, jeśli już nie istnieje. Prawda
$location Lokalizacja usługi KeyVault. Upewnij się, że KeyVault i maszyny wirtualne, które mają być szyfrowane, znajdują się w tej samej lokalizacji. Pobierz listę lokalizacji za pomocą polecenia Get-AzLocation. Prawda
$subscriptionId Identyfikator subskrypcji platformy Azure, która ma być używana. Możesz uzyskać identyfikator subskrypcji za pomocą Get-AzSubscription. Prawda
$aadAppName Nazwa aplikacji Microsoft Entra, która będzie używana do zapisywania wpisów tajnych w usłudze KeyVault. Jeśli taka aplikacja nie istnieje, zostanie utworzona nowa aplikacja o podanej nazwie. Jeśli ta aplikacja już istnieje, przekaż parametr aadClientSecret do skryptu. Fałsz
$aadClientSecret Tajny klucz klienta wcześniej utworzonej aplikacji Microsoft Entra. Fałsz
$keyEncryptionKeyName Nazwa opcjonalnego klucza szyfrowania klucza w usłudze KeyVault. Jeśli ten klucz nie istnieje, zostanie utworzony nowy klucz o tej nazwie. Fałsz

Szyfrowanie lub odszyfrowywanie maszyn wirtualnych bez aplikacji Microsoft Entra

Szyfrowanie lub odszyfrowywanie maszyn wirtualnych przy użyciu aplikacji Microsoft Entra (poprzedniej wersji)

Szyfrowanie dysku systemu operacyjnego na uruchomionej maszynie wirtualnej z systemem Linux

Wymagania wstępne dotyczące szyfrowania dysków systemu operacyjnego

  • Maszyna wirtualna musi używać dystrybucji zgodnej z szyfrowaniem dysków systemu operacyjnego, jak pokazano w obsługiwanych systemach operacyjnych Azure Disk Encryption
  • Maszyna wirtualna musi zostać utworzona na podstawie obrazu witryny Marketplace w usłudze Azure Resource Manager.
  • Maszyna wirtualna platformy Azure z co najmniej 4 GB pamięci RAM (zalecany rozmiar to 7 GB). Aby uzyskać więcej informacji, zobacz Wymagania dotyczące pamięci.
  • (W przypadku systemów RHEL i CentOS) Wyłącz selinux. Aby wyłączyć seLinux, zobacz "4.4.2. Wyłączenie SELinux w przewodniku użytkownika i administratora SELinux na maszynie wirtualnej.
  • Po wyłączeniu programu SELinux uruchom ponownie maszynę wirtualną co najmniej raz.

Kroki

  1. Utwórz maszynę wirtualną przy użyciu jednej z wcześniej określonych dystrybucji.

  2. Skonfiguruj maszynę wirtualną zgodnie z potrzebami. Jeśli zamierzasz zaszyfrować wszystkie dyski (system operacyjny + dane), dyski danych muszą być określone i możliwe do zainstalowania z /etc/fstab.

    Uwaga

    Użyj identyfikatora UUID=... w /etc/fstab, aby określić dyski danych zamiast nazwy urządzenia blokowego (na przykład /dev/sdb1). Podczas szyfrowania kolejność dysków zmienia się na maszynie wirtualnej. Jeśli maszyna wirtualna korzysta z określonej kolejności zablokowanych urządzeń, instalacja ich po zaszyfrowaniu zakończy się niepowodzeniem.

  3. Wyloguj się z sesji SSH.

  4. Aby zaszyfrować system operacyjny, określ wartość volumeType jako Wszystkie lub system operacyjny po włączeniu szyfrowania.

    Uwaga

    Wszystkie procesy użytkownika, które nie są uruchomione jako systemd usługi, powinny zostać zakończone za pomocą polecenia SIGKILL. Uruchom ponownie maszynę wirtualną. Po włączeniu szyfrowania dysków systemu operacyjnego na uruchomionej maszynie wirtualnej zaplanuj przestój maszyny wirtualnej.

  5. Okresowo monitoruj postęp szyfrowania, korzystając z instrukcji w następnej sekcji.

  6. Gdy polecenie Get-AzVmDiskEncryptionStatus wyświetli komunikat "VMRestartPending", uruchom ponownie maszynę wirtualną, logując się do niej lub używając portalu, programu PowerShell lub interfejsu wiersza polecenia.

    C:\> Get-AzVmDiskEncryptionStatus  -ResourceGroupName $ResourceGroupName -VMName $VMName
-ExtensionName $ExtensionName

    OsVolumeEncrypted          : VMRestartPending
DataVolumesEncrypted       : NotMounted
OsVolumeEncryptionSettings : Microsoft.Azure.Management.Compute.Models.DiskEncryptionSettings
ProgressMessage            : OS disk successfully encrypted, reboot the VM

    Przed ponownym uruchomieniem zalecamy zapisanie diagnostyki rozruchu maszyny wirtualnej.

Monitorowanie postępu szyfrowania systemu operacyjnego

Postęp szyfrowania systemu operacyjnego można monitorować na trzy sposoby:

  • Get-AzVmDiskEncryptionStatus Użyj polecenia cmdlet i sprawdź pole ProgressMessage:

    Get-AzVMDiskEncryptionStatus -ResourceGroupName $_.ResourceGroupName -VMName $_.Name

    OsVolumeEncrypted          : EncryptionInProgress
DataVolumesEncrypted       : NotMounted
OsVolumeEncryptionSettings : Microsoft.Azure.Management.Compute.Models.DiskEncryptionSettings
ProgressMessage            : OS disk encryption started

    Po tym, jak MV osiągnie stan "Uruchomiono szyfrowanie dysków systemu operacyjnego", proces ten trwa od 40 do 50 minut na maszynie wirtualnej z magazynem Premium.

    Ze względu na problem #388 w WALinuxAgent, OsVolumeEncrypted i DataVolumesEncrypted są wyświetlane jako Unknown w niektórych dystrybucjach. W przypadku programu WALinuxAgent w wersji 2.1.5 lub nowszej ten problem został rozwiązany automatycznie. Jeśli widzisz Unknown w danych wyjściowych, możesz zweryfikować stan szyfrowania dysków przy użyciu Eksploratora zasobów platformy Azure.

    Przejdź do eksploratora zasobów platformy Azure, a następnie rozwiń tę hierarchię w panelu wyboru po lewej stronie:

    |-- subscriptions
   |-- [Your subscription]
        |-- resourceGroups
             |-- [Your resource group]
                  |-- providers
                       |-- Microsoft.Compute
                            |-- virtualMachines
                                 |-- [Your virtual machine]
                                      |-- InstanceView

    W widoku InstanceView przewiń w dół, aby zobaczyć stan szyfrowania dysków.

    Widok instancji maszyny wirtualnej

  • Zapoznaj się z diagnostyką rozruchu. Komunikaty z rozszerzenia programu ADE powinny być poprzedzone prefiksem [AzureDiskEncryption].

  • Zaloguj się do maszyny wirtualnej za pośrednictwem protokołu SSH i pobierz dziennik rozszerzenia z:

    /var/log/azure/Microsoft.Azure.Security.AzureDiskEncryptionForLinux

    Zalecamy, aby nie logować się do maszyny wirtualnej, gdy trwa szyfrowanie systemu operacyjnego. Skopiuj dzienniki tylko wtedy, gdy inne dwie metody nie powiodły się.

Przygotowywanie wstępnie zaszyfrowanego wirtualnego dysku twardego systemu Linux

Przygotowanie wstępnie zaszyfrowanych dysków VHD może się różnić w zależności od dystrybucji. Dostępne są przykłady przygotowywania systemów Ubuntu, openSUSE i CentOS 7.

Skonfiguruj szyfrowanie podczas instalacji dystrybucji, wykonując następujące czynności:

  1. Wybierz pozycję Konfiguruj zaszyfrowane woluminy podczas partycjonowania dysków.

    Konfiguracja systemu Ubuntu 16.04 — konfigurowanie zaszyfrowanych woluminów

  2. Utwórz oddzielny dysk rozruchowy, który nie może być zaszyfrowany. Szyfruj dysk główny.

    Konfiguracja systemu Ubuntu 16.04 — wybieranie urządzeń do szyfrowania

  3. Podaj hasło. Jest to fraza hasła, którą załadowałeś do magazynu kluczy.

    Konfiguracja systemu Ubuntu 16.04 — podaj hasło

  4. Zakończ partycjonowanie.

    Instalacja systemu Ubuntu 16.04 — kończenie partycjonowania

  5. Po uruchomieniu maszyny wirtualnej i wyświetleniu monitu o podanie hasła użyj hasła podanego w kroku 3.

    Instalacja systemu Ubuntu 16.04 — podaj hasło podczas rozruchu

  6. Przygotuj maszynę wirtualną do przekazania na platformę Azure, korzystając z tych instrukcji. Nie uruchamiaj jeszcze ostatniego kroku (anulowania aprowizacji maszyny wirtualnej).

Skonfiguruj szyfrowanie do pracy z platformą Azure, wykonując następujące czynności:

  1. Utwórz plik pod /usr/local/sbin/azure_crypt_key.sh, z zawartością w poniższym skrypcie. Zwróć uwagę na wartość KeyFileName, ponieważ jest to nazwa pliku hasła używana przez platformę Azure.

    #!/bin/sh
MountPoint=/tmp-keydisk-mount
KeyFileName=LinuxPassPhraseFileName
echo "Trying to get the key from disks ..." >&2
mkdir -p $MountPoint
modprobe vfat >/dev/null 2>&1
modprobe ntfs >/dev/null 2>&1
sleep 2
OPENED=0
cd /sys/block
for DEV in sd*; do

    echo "> Trying device: $DEV ..." >&2
    mount -t vfat -r /dev/${DEV}1 $MountPoint >/dev/null||
    mount -t ntfs -r /dev/${DEV}1 $MountPoint >/dev/null
    if [ -f $MountPoint/$KeyFileName ]; then
            cat $MountPoint/$KeyFileName
            umount $MountPoint 2>/dev/null
            OPENED=1
            break
    fi
    umount $MountPoint 2>/dev/null
done

  if [ $OPENED -eq 0 ]; then
    echo "FAILED to find suitable passphrase file ..." >&2
    echo -n "Try to enter your password: " >&2
    read -s -r A </dev/console
    echo -n "$A"
 else
    echo "Success loading keyfile!" >&2
fi

  2. Zmień konfigurację krypty w / etc/crypttab. Powinien on wyglądać następująco:

     xxx_crypt uuid=xxxxxxxxxxxxxxxxxxxxx none luks,discard,keyscript=/usr/local/sbin/azure_crypt_key.sh

  3. Dodaj uprawnienia wykonywalne do skryptu:

     sudo chmod +x /usr/local/sbin/azure_crypt_key.sh

  4. Edytuj /etc/initramfs-tools/modules , dołączając wiersze:

     vfat
 ntfs
 nls_cp437
 nls_utf8
 nls_iso8859-1

  5. Uruchom polecenie update-initramfs -u -k all, aby zaktualizować initramfs, w celu zastosowania efektu keyscript.

  6. Teraz możesz zdeprowizować maszynę wirtualną.

    Instalacja systemu Ubuntu 16.04 — update-initramfs

  7. Przejdź do następnego kroku i przekaż dysk VHD na platformę Azure.

Przekazywanie zaszyfrowanego wirtualnego dysku twardego do konta usługi Azure Storage

Po włączeniu szyfrowania DM-Crypt należy przekazać lokalny zaszyfrowany wirtualny dysk twardy na konto storage.

    Add-AzVhd [-Destination] <Uri> [-LocalFilePath] <FileInfo> [[-NumberOfUploaderThreads] <Int32> ] [[-BaseImageUriToPatch] <Uri> ] [[-OverWrite]] [ <CommonParameters>]

Przekazywanie wpisu tajnego dla wstępnie zaszyfrowanej maszyny wirtualnej do magazynu kluczy

Podczas szyfrowania przy użyciu aplikacji Microsoft Entra (poprzednia wersja) tajny klucz szyfrowania dysku uzyskany wcześniej musi zostać przesłany jako tajemnica do magazynu kluczy. Magazyn kluczy musi mieć włączone szyfrowanie dysków i uprawnienia dla klienta platformy Microsoft Entra.

 $AadClientId = "My-AAD-Client-Id"
 $AadClientSecret = "My-AAD-Client-Secret"

 $key vault = New-AzKeyVault -VaultName $KeyVaultName -ResourceGroupName $ResourceGroupName -Location $Location

 Set-AzKeyVaultAccessPolicy -VaultName $KeyVaultName -ResourceGroupName $ResourceGroupName -ServicePrincipalName $AadClientId -PermissionsToKeys all -PermissionsToSecrets all
 Set-AzKeyVaultAccessPolicy -VaultName $KeyVaultName -ResourceGroupName $ResourceGroupName -EnabledForDiskEncryption

Klucz tajny szyfrowania dysków nie jest szyfrowany przy użyciu klucza KEK

Aby skonfigurować tajemnicę w magazynie kluczy, użyj Set-AzKeyVaultSecret. Hasło jest kodowane jako ciąg base64, a następnie przekazywane do magazynu kluczy. Ponadto upewnij się, że następujące tagi są ustawione podczas tworzenia wpisu tajnego w magazynie kluczy.


 # This is the passphrase that was provided for encryption during the distribution installation
 $passphrase = "contoso-password"

 $tags = @{"DiskEncryptionKeyEncryptionAlgorithm" = "RSA-OAEP"; "DiskEncryptionKeyFileName" = "LinuxPassPhraseFileName"}
 $secretName = [guid]::NewGuid().ToString()
 $secretValue = [Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($passphrase))
 $secureSecretValue = ConvertTo-SecureString $secretValue -AsPlainText -Force

 $secret = Set-AzKeyVaultSecret -VaultName $KeyVaultName -Name $secretName -SecretValue $secureSecretValue -tags $tags
 $secretUrl = $secret.Id

Użyj $secretUrl w następnym kroku, aby dołączyć dysk systemu operacyjnego bez użycia KEK.

Tajemnica szyfrowania dysku zaszyfrowana kluczem KEK

Przed przesłaniem sekretu do magazynu kluczy możesz opcjonalnie zaszyfrować go przy użyciu klucza do szyfrowania kluczy. Użyj interfejsu API wrap, aby najpierw zaszyfrować tajny klucz przy użyciu klucza szyfrującego. Dane wyjściowe tej operacji zawijania to ciąg zakodowany jako base64 URL, który następnie można przekazać jako wpis tajny przy użyciu Set-AzKeyVaultSecret cmdlet.

    # This is the passphrase that was provided for encryption during the distribution installation
    $passphrase = "contoso-password"

    Add-AzKeyVaultKey -VaultName $KeyVaultName -Name "keyencryptionkey" -Destination Software
    $KeyEncryptionKey = Get-AzKeyVaultKey -VaultName $KeyVault.OriginalVault.Name -Name "keyencryptionkey"

    $apiversion = "2015-06-01"

    ##############################
    # Get Auth URI
    ##############################

    $uri = $KeyVault.VaultUri + "/keys"
    $headers = @{}

    $response = try { Invoke-RestMethod -Method GET -Uri $uri -Headers $headers } catch { $_.Exception.Response }

    $authHeader = $response.Headers["www-authenticate"]
    $authUri = [regex]::match($authHeader, 'authorization="(.*?)"').Groups[1].Value

    Write-Host "Got Auth URI successfully"

    ##############################
    # Get Auth Token
    ##############################

    $uri = $authUri + "/oauth2/token"
    $body = "grant_type=client_credentials"
    $body += "&client_id=" + $AadClientId
    $body += "&client_secret=" + [Uri]::EscapeDataString($AadClientSecret)
    $body += "&resource=" + [Uri]::EscapeDataString("https://vault.azure.net")
    $headers = @{}

    $response = Invoke-RestMethod -Method POST -Uri $uri -Headers $headers -Body $body

    $access_token = $response.access_token

    Write-Host "Got Auth Token successfully"

    ##############################
    # Get KEK info
    ##############################

    $uri = $KeyEncryptionKey.Id + "?api-version=" + $apiversion
    $headers = @{"Authorization" = "Bearer " + $access_token}

    $response = Invoke-RestMethod -Method GET -Uri $uri -Headers $headers

    $keyid = $response.key.kid

    Write-Host "Got KEK info successfully"

    ##############################
    # Encrypt passphrase using KEK
    ##############################

    $passphraseB64 = [Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($Passphrase))
    $uri = $keyid + "/encrypt?api-version=" + $apiversion
    $headers = @{"Authorization" = "Bearer " + $access_token; "Content-Type" = "application/json"}
    $bodyObj = @{"alg" = "RSA-OAEP"; "value" = $passphraseB64}
    $body = $bodyObj | ConvertTo-Json

    $response = Invoke-RestMethod -Method POST -Uri $uri -Headers $headers -Body $body

    $wrappedSecret = $response.value

    Write-Host "Encrypted passphrase successfully"

    ##############################
    # Store secret
    ##############################

    $secretName = [guid]::NewGuid().ToString()
    $uri = $KeyVault.VaultUri + "/secrets/" + $secretName + "?api-version=" + $apiversion
    $secretAttributes = @{"enabled" = $true}
    $secretTags = @{"DiskEncryptionKeyEncryptionAlgorithm" = "RSA-OAEP"; "DiskEncryptionKeyFileName" = "LinuxPassPhraseFileName"}
    $headers = @{"Authorization" = "Bearer " + $access_token; "Content-Type" = "application/json"}
    $bodyObj = @{"value" = $wrappedSecret; "attributes" = $secretAttributes; "tags" = $secretTags}
    $body = $bodyObj | ConvertTo-Json

    $response = Invoke-RestMethod -Method PUT -Uri $uri -Headers $headers -Body $body

    Write-Host "Stored secret successfully"

    $secretUrl = $response.id

Użyj $KeyEncryptionKey i $secretUrl w następnym kroku w celu dołączenia dysku OS przy użyciu KEK.

Określanie tajnego adresu URL podczas dołączania dysku systemu operacyjnego

Bez używania klucza KEK

Podczas dołączania dysku systemu operacyjnego należy przekazać $secretUrl. Adres URL został wygenerowany w sekcji "Tajny klucz szyfrowania dysku, który nie został zaszyfrowany przy użyciu klucza KEK".

    Set-AzVMOSDisk `
            -VM $VirtualMachine `
            -Name $OSDiskName `
            -SourceImageUri $VhdUri `
            -VhdUri $OSDiskUri `
            -Linux `
            -CreateOption FromImage `
            -DiskEncryptionKeyVaultId $KeyVault.ResourceId `
            -DiskEncryptionKeyUrl $SecretUrl

Korzystanie z KEK

Po dołączeniu dysku systemu operacyjnego przekaż $KeyEncryptionKey i $secretUrl. Adres URL został wygenerowany w sekcji "Sekret szyfrowania dysku zaszyfrowany przy użyciu KEK".

    Set-AzVMOSDisk `
            -VM $VirtualMachine `
            -Name $OSDiskName `
            -SourceImageUri $CopiedTemplateBlobUri `
            -VhdUri $OSDiskUri `
            -Linux `
            -CreateOption FromImage `
            -DiskEncryptionKeyVaultId $KeyVault.ResourceId `
            -DiskEncryptionKeyUrl $SecretUrl `
            -KeyEncryptionKeyVaultId $KeyVault.ResourceId `
            -KeyEncryptionKeyURL $KeyEncryptionKey.Id
  • Last updated on