Udostępnij za pośrednictwem

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

  • Artykuł

Uwaga

W tym artykule odwołuje się do systemu CentOS — dystrybucji systemu Linux, która jest stanem End Of Life (EOL). Rozważ odpowiednie użycie i zaplanuj. 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.

  • Wyświetlanie listy wszystkich wpisów tajnych szyfrowania dysków używanych 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 programu PowerShell wymagań wstępnych usługi Azure Disk Encryption

Jeśli znasz już wymagania wstępne dotyczące usługi Azure Disk Encryption, możesz użyć skryptu programu PowerShell wymagań wstępnych usługi Azure Disk Encryption. Przykład użycia tego skryptu programu PowerShell można znaleźć w przewodniku Szybki start szyfrowanie maszyny wirtualnej. 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. Jeśli nie istnieje, zostanie utworzony nowy magazyn o tej nazwie. Prawda
$location Lokalizacja usługi KeyVault. Upewnij się, że maszyny wirtualne i keyvault, 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 pobrać identyfikator subskrypcji za pomocą polecenia 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 Wpis tajny klienta utworzonej wcześniej 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 Firmy 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 programu 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=... aby określić dyski danych w /etc/fstab zamiast określać nazwę urządzenia bloku (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ć zabite 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 osiągnięciu przez maszynę wirtualną "Uruchomiono szyfrowanie dysków systemu operacyjnego", na maszynie wirtualnej z magazynem w warstwie Premium trwa od 40 do 50 minut.

    Ze względu na problem #388 w WALinuxAgent i OsVolumeEncrypted DataVolumesEncrypted jest wyświetlany jak 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 dane wyjściowe, 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 wystąpienia 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 rozkładu. 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 hasło przekazane do magazynu kluczy.

    Konfiguracja systemu Ubuntu 16.04 — podaj hasło

  4. Kończenie partycjonowania.

    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 w obszarze /usr/local/sbin/azure_crypt_key.sh, z zawartością w poniższym skry skryptzie. 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, aby zastosować keyscript efekt.

  6. Teraz możesz anuluj aprowizować 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 magazynu.

    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 (poprzedniej wersji) klucz tajny szyfrowania dysku uzyskany wcześniej musi zostać przekazany jako wpis tajny w magazynie kluczy. Magazyn kluczy musi mieć włączone szyfrowanie dysków i uprawnienia dla klienta Firmy 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ć wpis tajny w magazynie kluczy, użyj polecenia 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 instrukcji $secretUrl w następnym kroku, aby dołączyć dysk systemu operacyjnego bez użycia klucza KEK.

Klucz tajny szyfrowania dysków zaszyfrowany przy użyciu klucza KEK

Przed przekazaniem wpisu tajnego do magazynu kluczy możesz opcjonalnie zaszyfrować go przy użyciu klucza szyfrowania kluczy. Użyj zawijania interfejsu API , aby najpierw zaszyfrować wpis tajny przy użyciu klucza szyfrowania klucza. Dane wyjściowe tej operacji zawijania to ciąg zakodowany w adresie URL base64, który następnie można przekazać jako wpis tajny przy użyciu Set-AzKeyVaultSecret polecenia 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 instrukcji $KeyEncryptionKey i $secretUrl w następnym kroku w celu dołączenia dysku systemu operacyjnego przy użyciu klucza 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ć $secretUrlpolecenie . Adres URL został wygenerowany w sekcji "Klucz tajny szyfrowania dysków, który nie jest 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 klucza KEK

Po dołączeniu dysku systemu operacyjnego przekaż $KeyEncryptionKey polecenie i $secretUrl. Adres URL został wygenerowany w sekcji "Klucz tajny szyfrowania dysku zaszyfrowany przy użyciu klucza 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