L’activation de BitLocker dans le système de plateforme Cloud (CPS)

Résumé

Cet article explique comment activer BitLocker® fournir des données au cryptage du reste de Microsoft Cloud plate-forme système (CPS).

Plus d'informations

Le système de plate-forme Microsoft Cloud s’appuie sur la capacité de Windows Server 2012 de crypter des Volumes de Cluster partagés (CSV) à l’aide de BitLocker®. Cet article explique comment activer BitLocker. Il fournit également les scripts pour automatiser le processus.

Remarque BitLocker doit être activée dès que possible dans le cycle de vie de CPS, car le processus génère des temps d’arrêt important. En d’autres termes, vous devez désactiver tous les clients de machines virtuelles et la gestion de toutes les machines virtuelles (à l’exception des ordinateurs virtuels d’AD/DC) pour activer BitLocker.

Suivre ces étapes scrupuleusement. Cela peut provoquer une altération des interruptions de service et de données étendues.
  1. Activer la fonctionnalité de chiffrement de lecteur BitLocker sur tous les nœuds du cluster de stockage

    1.1 Copiez le code suivant, puis enregistrez-le en tant que BitLockerFeature.ps1-activer dans <MonDossier> sur la machine virtuelle de Console :

     <#################################################### #
    # Copyright (c) Microsoft. All rights reserved. #
    # #
    ##################################################>
    <#
    .SYNOPSIS
    Install BitLocker Drive Encryption feature on each of the storage cluster nodes
    .DESCRIPTION
    Install BitLocker Drive Encryption feature on each node of the storage cluster.
    THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
    IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
    #>
     
    Param(
    [Parameter (Mandatory = $true)] [string] $storageClusterName
    )
    $clusterNodes =Invoke-Command -ComputerName $storageClusterName {Get-ClusterNode}
    if($clusterNodes -eq $null)
    {
    $errorMessageForUser = "Failed while retrieving the nodes of the storage cluster $storageClusterName"
    throw $errorMessageForUser
    }
    foreach ($node in $clusterNodes.Name)
    {
    Write-Verbose "Installing BitLocker feature on node $node..."
    $BitlockerStatus = Invoke-Command -ComputerName $node {Add-WindowsFeature Bitlocker -Verbose}
    if(($BitlockerStatus -eq $null) -or (!$BitlockerStatus.Success))
    {
    $errorMessageForUser = "Add-WindowsFeature failed on node $node. Please try to install the feature on this node manually and then rerun this script to continue with the installation on the other nodes. "
    throw $errorMessageForUser
    }
    if($BitlockerStatus.RestartNeeded -eq "Yes")
    {
    Write-Verbose "Restarting Node $node..."
    Restart-Computer -ComputerName $BitlockerStatus.PSComputerName -wait
    Write-Verbose "Node $node restarted."
    }
    }
    $installedCounter=0
    foreach ($node in $clusterNodes.Name)
    {
    $featureState = Invoke-Command -ComputerName $node {Get-WindowsFeature "bitlocker"}
    if($featureState -eq $null)
    {
    $errorMessageForUser = "Could not verify that BitLocker feature is correctly installed on storage node $node. Please connect to the node and run 'Get-WindowsFeature bitlocker' to verify the correct installation."
    Write-Warning $errorMessageForUser
    }
    if ($featureState.InstallState -eq "Installed")
    {
    $installedCounter++
    }
    }
    if($installedCounter -eq $clusterNodes.Count)
    {
    Write-Verbose "BitLocker feature is now installed on all the nodes of the storage cluster"
    }
    else
    {
    Write-Error "BitLocker feature was not properly installed on all the nodes of the storage cluster"
    }

    1.2 à partir de la console de machine virtuelle, ouvrez une console PowerShell avec des droits d’administration, accédez à <MonDossier> et puis entrez les informations suivantes :
    ./Enable-BitLockerFeature.ps1 -storageClusterName <yourStorageCluster> -verbose
    Le script va effectuer une itération dans tous les nœuds du cluster de stockage et installer BitLocker. Les nœuds seront redémarrés au cours du processus.

    1.3 après la fin du script exécuté avec succès, passez à l’étape 2.

  2. Créer un objet stratégie de groupe pour la récupération basée sur Active Directory de BitLocker

    2.1 à partir de la console de machine virtuelle, ouvrez l’éditeur de gestion des stratégies de groupe.

    2.2 développer la forêt, droit sur le domaine de CPS, puis cliquez sur créer un objet GPO dans ce domaine et le Lier ici.

    2.3 nommez l’objet stratégie de groupe de votre choix (par exemple, BitLocker), puis cliquez sur OK.

    2.4 un nouvel objet de stratégie de groupe s’affiche désormais dans le domaine de CPS. Cliquez sur l’onglet paramètres de l’objet de stratégie de groupe BitLocker, cliquez sur Configuration de l’ordinateur, puis cliquez sur Modifier. Ceci ouvrira une autre fenêtre de l’éditeur de gestion de stratégie de groupe.

    2.5 dans le volet gauche de l’éditeur de gestion de stratégie de groupe, accédez à Configuration ordinateur -> stratégies -> Modèles d’administration -> Composants Windows -> Chiffrement de lecteur BitLocker -> les Lecteurs de données fixeset avec le bouton droit puis Choisir comment protégé par BitLocker fixé lecteurs peuvent être récupérées.

    2.6 dans la boîte de dialogue paramètre de stratégie, activez la stratégie et définir les options suivantes :
    1. Autoriser l’agent de récupération de données
    2. Enregistrer les informations de récupération BitLocker dans les services AD DS pour les lecteurs de données fixes
    3. Ne pas activer BitLocker jusqu'à ce que les informations de récupération sont stockées dans les services AD DS pour les lecteurs de données fixes

    2.7 Cliquez sur OK, puis fermez la fenêtre de l’éditeur.

    2.8 dans le cadre de filtrage de sécurité, cliquez sur Ajouter pour ajouter tous les comptes ordinateur aux nœuds de stockage. Dans la déclaration CPS, il y a quatre nœuds par rack. Après les avoir créées, tous les nœuds doivent être répertoriés dans le cadre du filtrage de sécurité. Vous pouvez supprimer le groupe autorisé les utilisateurs par défaut.

    2.9 dans le volet gauche, cliquez sur la stratégie de BitLocker, puis cliquez sur appliqué. Fermez l’éditeur de gestion de stratégie de groupe.

    2.10 à ce stade, la stratégie est appliquée, mais il peut prendre une heure pour se propager.
    1. Dans le cas où vous ne souhaitez pas attendre la stratégie propager, vous pouvez appliquer manuellement il en ouvrant une session sur chaque nœud de stockage et en exécutant PS C:\Users\admin1\Desktop > gpupdate /force.
    2. Vérifiez que la stratégie a été appliquée correctement en exécutant l’applet de commande suivante sur chaque nœud de stockage :

      PS C:\Users\admin1\Desktop > gpresult /scope ordinateur /v
    3. Dans la sortie, recherchez les objets de stratégie de groupe appliqués. Si votre stratégie (dans cet exemple, nous avons appelé BitLocker) est répertorié, la stratégie est appliquée, et vous pouvez passer à l’étape 3.

  3. IMPORTANT [n’ignorez pas cette étape] : Si vous avez des charges de travail en cours d’exécution dans le cluster de clients qui requièrent une séquence particulière de mise hors tension, faites-le maintenant. Le script à l’étape 4 est désactivée sur tous les ordinateurs virtuels actifs sur le cachet. Ne désactivez pas les ordinateurs virtuels d’AD/DC. Une fois les volumes ont le statut en ligne (redirigé) , le locataire VM peut être redémarré en toute sécurité.
  4. Activer le cryptage BitLocker sur tous les volumes de stockage. IMPORTANT : Cette procédure doit être répétée sur chaque rack de votre tampon de CPS que chaque rack possède son propre stockage de cluster.

    4.1 Copiez le code suivant, puis enregistrez-le en tant que ClusterDiskBitlocker.ps1 de l’activer dans <MonDossier> sur l’un des nœuds du cluster de stockage. Appelons ce nœud <myStorageNode>.
    <################################################### #                                                 #
    # Copyright (c) Microsoft. All rights reserved. #
    # #
    ##################################################>
    <#
    .SYNOPSIS
    Enable Bitlocker on all the Cluster Shared Volumes in CPS.
    .DESCRIPTION
    Enable Bitlocker on all the Cluster Shared Volumes on the rack. The volumes will be fully encrypted. The encryption process may take long time (48-72h), depending on the amount of data stored. During that time,
    the volumes will be in a redirected state. The volumes will automatically go back to Online once the encryption process is complete.
    NOTE: Please put all the VMs, both management and tenants, into a save state. Failing to do so will result in the VMs crashing and possibly getting into an inconsistent state.
    Once the volumes are in Online (Redirected) status, the VMs can be safely restarted.
    THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
    IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
    #>

    Function Stop-ClusterVMs
    {
    #Stop all VMs passed as input
    param([string]$ClusterName,[Object[]]$TargetVMs)
    $proceed = Get-Confirmation -question "The script will now turn off ALL the virtual machines in the $ClusterName cluster"
    $TargetVMs | Out-File ".\$ClusterName.txt"
    if($proceed -eq $true)
    {
    $counter=1
    foreach ($vm in $TargetVMs)
    {
    $progress= [int] ($counter / $TargetVMs.Count * 100 )
    Write-Progress -Activity "Stopping $ClusterName Virtual Machines..." `
    -PercentComplete $progress `
    -CurrentOperation "$progress% complete" `
    -Status "Please wait."
    $counter++
    Write-Verbose "Now turning off $vm.Name on node $vm.OwnerNode"
    Stop-VM -Name $vm.Name -ComputerName $vm.OwnerNode -Force

    }
    Write-Progress -Activity "Stopping $ClusterName Virtual Machines..." `
    -Completed -Status "All VMs are shut down."
    }
    else
    {
    exit
    }
    }
    Function Start-ClusterVMs
    {
    #start all the VMs passed as input
    param([string]$ClusterName,[Object[]]$TargetVMs)

    $counter=1
    foreach ($vm in $TargetVMs)
    {
    $progress= [int] ($counter / $TargetVMs.Count * 100 )
    Write-Progress -Activity "Starting $ClusterName Virtual Machines..." `
    -PercentComplete $progress `
    -CurrentOperation "$progress% complete" `
    -Status "Please wait."
    $counter++
    Write-Verbose "Now turning on $vm.Name..."
    Start-VM -Name $vm.Name -ComputerName $vm.OwnerNode
    }
    Write-Progress -Activity "Starting $ClusterName Virtual Machines..." `
    -Completed -Status "All VMs are running."
    }
    Function Get-ClusterVMs
    {
    #create a table with VM, OwnerNode for the given cluster
    param([string]$Cluster)
    $resultTable = @{Expression={$_.Name};Label="Volume Name";width=80},`
    @{Expression={$_.OwnerNode};Label="Owner Node";width=50}


    $nodes = Get-ClusterNode -Cluster $Cluster

    foreach($node in $nodes)
    {
    $targetVMs = Get-VM -ComputerName $node | Where{$_.State -like "Running"}
    foreach($vm in $targetVMs)
    {
    [PSCustomObject] @{
    "Name" = $vm.Name
    "OwnerNode" = $node
    }
    }
    }
    }
    Function Get-Confirmation
    {
    param([string]$Question, [string]$message="Do you want to proceed?")
    $optionYes = New-Object System.Management.Automation.Host.ChoiceDescription "&Yes", "Yes"
    $optionNo = New-Object System.Management.Automation.Host.ChoiceDescription "&No", "No"
    $options = [System.Management.Automation.Host.ChoiceDescription[]]($optionYes, $optionNo)
    $result = $host.ui.PromptForChoice($Question, $message, $options, 0)
    switch ($result)
    {
    0 {Return $true }
    1 {Return $false }
    }
    }
    Function Suspend-ClusterVMs
    {
    #stop the cluster and put all VMs in saved state
    param([string]$ClusterName)
    $proceed = Get-Confirmation -question "The script will now suspend ALL the virtual machines in the $ClusterName cluster"

    Get-ClusterNode -Cluster $ClusterName | Out-File ".\$ClusterName.txt"
    if($proceed -eq $true)
    {
    Stop-Cluster -Cluster $ClusterName -Verbose -Force
    }
    else
    {
    exit
    }
    }
    Function Enable-ClusterDiskBitlocker
    {
    Param(
    [Parameter (Mandatory = $true)] [System.Security.SecureString] $bitlockerEncryptionKey,
    [Parameter (Mandatory = $false)] [String] $managementClusterName,
    [Parameter (Mandatory = $true)] [String] $computeClusterName,
    [Parameter (Mandatory = $true)] [String] $edgeClusterName
    )
    $ErrorActionPreference = "Stop"
    $creds = get-credential -Message "Please provide Admin credentials to enable BitLocker"
    if($managementClusterName -eq $null)
    {
    $managementClusterName = Read-Host "If you are enabling BitLocker on rack #1, please provide the name of the management cluster. If you are enabling BitLocker on rack #2, 3 or 4, please leave this null"
    }
    #Verifying that cluster names are correct
    if($managementClusterName -ne $null)
    {
    while ((Get-Cluster $managementClusterName) -eq $null)
    {
    $managementClusterName = Read-Host "The name provided for the management cluster is not correct. Please provide name of the management cluster"
    }
    }
    while ((Get-Cluster $computeClusterName) -eq $null)
    {
    $computeClusterName = Read-Host "The name provided for the compute cluster is not correct. Please provide name of the compute cluster"
    }

    while ((Get-Cluster $edgeClusterName) -eq $null)
    {
    $edgeClusterName = Read-Host "The name provided for the edge cluster is not correct. Please provide name of the edge cluster"
    }
    #enabling hyper-v-powershell feature on the storage node
    if(!(Get-WindowsFeature |?{$_.Name -match "Hyper-V-Powershell"} | select -ExpandProperty Installed))
    {
    Write-Verbose "Installing Hyper-V-Powershell feature..."
    Add-WindowsFeature "Hyper-V-Powershell" -Verbose
    }


    #data structures needed to restart the vms later
    if($managementClusterName -ne $null)
    {
    $managementClusterNodes = Get-ClusterNode -Cluster $managementClusterName
    if($managementClusterNodes -eq $null)
    {
    Write-Warning "Could not retrieve the nodes of the management cluster"
    }
    }
    $edgeClusterVMs = Get-ClusterVMs -Cluster $edgeClusterName
    if($edgeClusterVMs -eq $null)
    {
    Write-Warning "Could not retrieve the virtual machines of the edge cluster"
    }
    $computeClusterVMs = Get-ClusterVMs -Cluster $computeClusterName
    if($computeClusterVMs -eq $null)
    {
    Write-Warning "Could not retrieve the virtual machines of the compute cluster"
    }

    #turning off all VMs to prevent them from crashing and risk of data corruption
    $proceed = Get-Confirmation -Question "Have you enabled RDP connectivity on a storage node?"
    if($proceed -eq $false)
    {
    Write-Error "This script must be run from a storage node. Please enable RDP on a storage node, connect to it and restart the script."
    exit
    }
    $proceed = Get-Confirmation -Question "Are you running this script from a storage node?"
    if($proceed -eq $false)
    {
    Write-Error "This script must be run from a storage node. Please RDP into a storage node and restart the script."
    exit
    }
    Stop-ClusterVMs -ClusterName $computeClusterName -targetVMs $computeClusterVMs
    Stop-ClusterVMs -ClusterName $edgeClusterName -targetVMs $edgeClusterVMs
    if($managementClusterName -ne $null)
    {
    Suspend-ClusterVMs -ClusterName $managementClusterName
    }
    $storageClusterName = (Get-Cluster).name
    while ($storageClusterName -eq $null)
    {
    $storageClusterName = Read-Host "Please provide name of the storage cluster"
    }
    $clusterNodes = (Get-ClusterNode -Cluster $storageClusterName).Name
    if($clusterNodes -eq $null)
    {
    Write-Error "Could not retrieve the nodes of the storage cluster"
    }
    $ClusterSharedVolumes = Get-ClusterSharedVolume -Cluster $storageClusterName
    if($ClusterSharedVolumes -eq $null)
    {
    Write-Error "'Get-ClusterSharedVolume -Cluster' $storageClusterName failed. Could not retrieve the list of volumes of the storage cluster"
    }
    #temporarily enable CredSSP on the SOFS nodes
    foreach($clusterNode in $clusterNodes)
    {
    Write-Verbose "Enabling CredSSP Client role for $clusterNode..."
    Enable-WSManCredSSP -role Client -DelegateComputer * -Force
    Write-Verbose "Enabling CredSSP Server role on $clusterNode..."
    Invoke-Command -ComputerName $clusterNode {Enable-WSManCredSSP -Role Server -Force}
    }


    $counter = 1
    foreach ($clusterSharedVolumeObject in $ClusterSharedVolumes) {

    $progress= [int] ($counter / $ClusterSharedVolumes.Count * 100 )
    Write-Progress -Activity "Enabling BitLocker on the volumes..." `
    -PercentComplete $progress `
    -CurrentOperation "$progress% complete" `
    -Status "Please wait."
    $counter++

    $clusterSharedVolume = $clusterSharedVolumeObject.Name
    $CSVPhysicalOwner = $clusterSharedVolumeObject.OwnerNode


    #Verifying the status of the volume before starting the encryption process. only fullydecrypted is acceptable.
    $clusterSharedVolumeStatus = (Invoke-Command -Authentication Credssp -Credential $creds -ComputerName $CSVPhysicalOwner -ArgumentList $clusterSharedVolumeObject {param($clusterSharedVolumeObject) Get-BitlockerVolume -MountPoint $clusterSharedVolumeObject.SharedVolumeInfo.FriendlyVolumeName}).VolumeStatus
    switch ($clusterSharedVolumeStatus) {
    "FullyDecrypted" {"Starting encryption process for $clusterSharedVolume..."; $continueWithEncryption = $true}
    "FullyEncrypted" {"$clusterSharedVolume is already encrypted. Moving to the next volume."; $continueWithEncryption = $false}
    "EncryptionInProgress" {"$clusterSharedVolume is currently being encrypted. Moving to the next volume"; $continueWithEncryption = $false}
    default {"$clusterSharedVolume status is unknown. Moving to the next volume"; $continueWithEncryption = $false}
    }
    if (!$continueWithEncryption){continue}
    try{
    #Put ClusterSharedVolume in Maintenance Mode
    Write-Verbose "Putting the $clusterSharedVolume in maintenance mode..."
    Invoke-Command -ComputerName $CSVPhysicalOwner -ArgumentList $clusterSharedVolume {param($clusterSharedVolume) Get-ClusterSharedVolume $clusterSharedVolume | Suspend-ClusterResource -Force}

    #Configure BitLocker on the volume
    $CSVMountPoint = Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $clusterSharedVolume {param($clusterSharedVolume) (Get-ClusterSharedVolume $clusterSharedVolume).SharedVolumeInfo.FriendlyVolumeName}
    if($CSVMountPoint -eq $null)
    {
    $errorMessageForUser = "Failed while retrieving the MountPoint associated with $clusterSharedVolume on server node $CSVPhysicalOwner"
    throw $errorMessageForUser
    }
    Write-Verbose "Invoking Enable-Bitlocker on $clusterSharedVolume..."
    Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $CSVMountPoint {param($CSVMountPoint) Enable-BitLocker $CSVMountPoint -RecoveryPasswordProtector}
    Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $CSVMountPoint,$bitlockerEncryptionKey {param($CSVMountPoint, $bitlockerEncryptionKey) Add-BitLockerKeyProtector $CSVMountPoint -PasswordProtector –Password $bitlockerEncryptionKey}
    #enable using a recovery password protector and backup the protector to Active Directory
    write-verbose "Backup BitLocker Key Protector on AD for $clusterSharedVolume..."
    $protectorId = Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $CSVMountPoint {param($CSVMountPoint) (Get-BitLockerVolume $CSVMountPoint).Keyprotector | Where-Object {$_.KeyProtectorType -eq "RecoveryPassword”
    }} if($protectorId -eq $null) {
    $errorMessageForUser = "Failed while retrieving the protector Id associated with $CSVMountPoint on server node $CSVPhysicalOwner"
    throw $errorMessageForUser
    }

    Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $CSVMountPoint,$protectorId {param($CSVMountPoint, $protectorId) Backup-BitLockerKeyProtector $CSVMountPoint -KeyProtectorId $protectorId.KeyProtectorId}
    #Determine the Cluster Name Object for your cluster:
    $cno = $storageClusterName + "$"
    #Add an Active Directory Security Identifier (SID) to the CSV disk using the Cluster Name Object (CNO)
    Write-Verbose "Enabling ADProtector on $clusterSharedVolume..."
    Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $CSVMountPoint,$cno {param($CSVMountPoint, $cno) Add-BitLockerKeyProtector $CSVMountPoint -ADAccountOrGroupProtector –ADAccountOrGroup $cno}

    #Put the ClusterSharedVolume back online
    Write-Verbose "Putting $clusterSharedVolume back online..."
    Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $clusterSharedVolume {param($clusterSharedVolume) Get-ClusterSharedVolume $clusterSharedVolume | Resume-ClusterResource}
    }
    catch
    {
    Invoke-Command -ComputerName $CSVPhysicalOwner -Authentication Credssp -Credential $creds -ArgumentList $CSVMountPoint{param($CSVMountPoint) manage-bde -off $CSVMountPoint}
    Write-Host "The encryption process of $CSVMountPoint encountered a problem. Execution stopped. Disabling BitLocker and decrypting volume $CSVMountPoint" -ForegroundColor Red
    Write-Host "Exception Message: $($_.Exception.Message)" -ForegroundColor Red
    exit
    }

    }

    #restart all VMs that were previously shut down or suspended
    Write-Verbose "Encryption enabled on all the CSVs. Restarting now all the VMs that were previously shut down or suspended"
    if($managementClusterName -ne $null)
    {
    #restarting management cluster
    $tempCounter = 0
    $sizeManagementCluster = $managementClusterNodes.length - 1
    $managmentClusterObject = Start-Cluster $managementClusterNodes[$tempCounter]
    while (($managementClusterObject -eq $null ) -and ($tempCounter -lt $sizeManagementCluster))
    {
    Write-Verbose "Management Cluster did not start on node $managementClusterNodes[$tempCounter]"
    $tempCounter++
    Write-Verbose "Trying now to start the management cluster on node $managementClusterNodes[$tempCounter]"
    $managmentClusterObject = Start-Cluster $managementClusterNodes[$tempCounter]
    }
    if ($managementClusterObject -eq $null)
    {
    Write-Host "Management cluster could not be started. Please restart it manually" -ForegroundColor Red
    }
    }
    Start-ClusterVMs -ClusterName $edgeClusterName -TargetVMs $edgeClusterVMs
    Start-ClusterVMs -ClusterName $computeClusterName -TargetVMs $computeClusterVMs

    #disable credSSP on the SOFS nodes
    foreach($clusterNode in $listOfNodes)
    {
    write-verbose "Disabling CredSSP on $clusterNode..."
    Invoke-Command -ComputerName $clusterNode {Disable-WSManCredSSP -Role Server}
    }
    write-verbose "Disabling CredSSP on local machine..."
    Disable-WSManCredSSP -role Client

    Write-Progress -Activity "Enabling BitLocker on the volumes..." `
    -Completed -Status "All done."
    }
    Enable-ClusterDiskBitlocker -Verbose


    4.2 utiliser Bureau à distance pour vous connecter à <myStorageNode> à l’aide de vos informations d’identification d’administrateur et ouvrez une console PowerShell avec des droits d’administrateur. Si vous ne pouvez pas vous connecter, activer le Bureau à distance sur les nœuds de stockage. Pour obtenir des instructions sur l’activation du Bureau à distance, reportez-vous à : Guide de survie Core Windows 2012 – Bureau à distance.

    4.3 atteindre <MonDossier> et entrez la ligne de commande suivante :
    PS C:\Users\admin1\Desktop> .\Enable-ClusterDiskBitlocker.ps1 –bitlockerEncryptionKey <myEncryptionKey> -Verbose
    La clé de cryptage est la clé que vous souhaitez utiliser pour BitLocker. Le script invite à entrer vos informations d’identification d’administration et les noms de cluster management, le cluster de calcul et le cluster de bord.

    4.5 le script premier désactive tous les ordinateurs virtuels sur les timbres (à l’exception de la VM AD/DC), afin que vous perdrez la connectivité de la console de machine virtuelle. Le script sera chaque disque de cluster, activez le chiffrement BitLocker. Une fois que BitLocker a été activé sur chaque disque de cluster, le script affichera tous les ordinateurs virtuels en ligne qui étaient éteints au cours du processus.

    Si vous souhaitez en savoir ce qui se passe dans les coulisses, le script suit scrupuleusement les étapes décrites dans le billet de blog suivant :

    Comment configurer les disques de cluster chiffré BitLocker dans Windows Server 2012

    Ce processus prend environ 30 minutes par cluster de stockage.

    4.6 après la fin du script en cours d’exécution, ouvrez le Gestionnaire du Cluster de basculement. Tous les disques de cluster doivent avoir le statut en ligne (redirigé) . Vous pouvez maintenant activer sur tous les ordinateurs virtuels que vous avez désactivés précédemment et fonctionner le rack CPS comme d’habitude. Le processus de cryptage peut prendre plusieurs jours, selon la quantité de données écrites sur les disques. Une fois un disque de cluster est entièrement crypté, son état retourne automatiquement en ligne.

    4.7 une fois le processus de chiffrement effectué, veuillez désactiver le Bureau à distance sur les nœuds de stockage. Pour obtenir des instructions sur la façon de désactiver le Bureau à distance, reportez-vous à : Guide de survie Core Windows 2012 – Bureau à distance.
  5. Vérifier l’état de cryptage du cachet

    Pour obtenir une mise à jour de l’état sur le processus de cryptage, ou pour obtenir une impression de l’état de chiffrement pour des raisons de conformité, exécutez l’applet de commande Get-VolumeEncryptionStatus suivant.

    <#################################################### #
    # Copyright (c) Microsoft. All rights reserved. #
    # #
    ##################################################>
    <#
    .SYNOPSIS
    Collect encryption status for each of the volumes in the storage cluster.
    .DESCRIPTION
    Collect encryption status for each of the volumes in the storage cluster. For each volume, this script returns Volume Name, Owner Node, Encryption Status and Encryption Percentage.
    The script requires the Bitlocker Feature installed on every node of the cluster and credssp enabled.
    THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
    IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
    #>
    Param(
    [Parameter (Mandatory = $true)] [string] $storageClusterName
    )
    $ClusterSharedVolumes = Get-ClusterSharedVolume -Cluster $storageClusterName
    if($ClusterSharedVolumes -eq $null)
    {
    Write-Error "'Get-ClusterSharedVolume -Cluster' $storageClusterName failed. Could not retrieve the list of volumes of the storage cluster"
    }
    try{
    $resultTable = @{Expression={$_.Name};Label="Volume Name";width=45},`
    @{Expression={$_.OwnerNode};Label="Owner Node";width=15}, `
    @{Expression={$_.VolumeStatus};Label="Encryption Status";width=25}, `
    @{Expression={$_.EncryptionPercentage};Label="Encryption Percentage";width=15}
     
    $counter = 1
    $temp = foreach($clusterSharedVolumeObject in $ClusterSharedVolumes)
    {
    $progress= [int] ($counter / $ClusterSharedVolumes.Count * 100 )
    Write-Progress -Activity "Collecting data..." `
    -PercentComplete $progress `
    -CurrentOperation "$progress% complete" `
    -Status "Please wait."
    $bitlockerVolume = Invoke-Command -ComputerName $clusterSharedVolumeObject.OwnerNode.Name -ArgumentList $clusterSharedVolumeObject {param($clusterSharedVolumeObject) Get-BitlockerVolume -MountPoint $clusterSharedVolumeObject.SharedVolumeInfo.FriendlyVolumeName}
    [PSCustomObject] @{
    "Name" = $clusterSharedVolumeObject.Name
    "OwnerNode" = $clusterSharedVolumeObject.OwnerNode.Name
    "VolumeStatus" = $bitlockerVolume.VolumeStatus
    "EncryptionPercentage" = $bitlockerVolume.EncryptionPercentage
    }
    $counter++
    }
     
    $temp | Format-Table $resultTable
    Write-Progress -Activity "Collecting data..." `
    -Completed -Status "All done."
    }
    catch
    {
    Write-Host "The cmdlet encountered a problem. Execution stopped." -ForegroundColor Red
    write-host "Exception Message: $($_.Exception.Message)" -ForegroundColor Red
    }

    5.1 copier ce code et l’enregistrer en tant que dans <MonDossier> Get-VolumeEncryptionStatus.ps1 sur une console de machine virtuelle.

    5.2 ouvrir une console Powershell avec des droits d’administrateur et exécuter l’applet de commande suivante pour passer le nom de votre cluster de stockage :
    PS C:\Users\admin1\Desktop> .\Get-VolumeEncryptionStatus.ps1 -storageClusterName
Propriétés

ID d'article : 3078425 - Dernière mise à jour : 27 janv. 2017 - Révision : 1

Cloud Platform System, Windows Server 2012 R2 Datacenter

Commentaires