Cómo habilitar BitLocker en el sistema de plataforma de nube (CPS)

Resumen

En este artículo se explica cómo habilitar BitLocker® proporcionar datos de encriptación en sistema de plataforma de nube Microsoft (CPS).

Más información

Sistema de plataforma de nube de Microsoft aprovecha la capacidad de Windows Server 2012 para cifrar volúmenes compartidos de clúster (CSV) mediante BitLocker®. En este artículo se explica cómo habilitar BitLocker. También proporciona las secuencias de comandos para automatizar el proceso.

Nota: BitLocker debe estar habilitado tan pronto como sea posible en el ciclo de vida de CPS porque el proceso genera un importante downtime. Es decir, debe desactivar todos los inquilinos VMs y toda la administración de máquinas virtuales (excepto las VMs AD/DC) con el fin de habilitar BitLocker.

Sigue estos pasos cuidadosamente. Hacerlo podría resultar en extendida corrupción de datos y el tiempo de inactividad.
  1. Habilitar la característica cifrado de unidad BitLocker en todos los nodos del clúster de almacenamiento

    1.1 Copie el código siguiente y guárdelo como habilitar BitLockerFeature.ps1 en <MiCarpeta> en la máquina virtual de la consola:

     <#################################################### #
    # 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 desde la consola de máquina virtual, abrir una consola de PowerShell con derechos de administrador, vaya a <MiCarpeta> y, a continuación, escriba lo siguiente:
    ./Enable-BitLockerFeature.ps1 -storageClusterName <yourStorageCluster> -verbose
    La secuencia de comandos se recorra en iteración todos los nodos del clúster de almacenamiento e instalar BitLocker. Los nodos se reiniciará durante el proceso.

    1.3 cuando finalice el script ejecuta correctamente, vaya al paso 2.

  2. Crear GPO para la recuperación basada en Active Directory de BitLocker

    2.1 desde la consola de máquina virtual, abra el editor de administración de directivas de grupo.

    2.2 expanda el bosque, (ratón) en el dominio de la CPS y, a continuación, haga clic en crear un GPO en este dominio y vincularlo aquí.

    2.3 Asigne un nombre de su elección (por ejemplo, BitLocker) el GPO y, a continuación, haga clic en Aceptar.

    2.4 un nuevo GPO debe aparecer bajo el dominio de CPS. Haga clic en la ficha configuración del GPO de BitLocker, haga clic en Configuración del equipoy, a continuación, haga clic en Editar. Se abrirá otra ventana de Editor de administración de directiva de grupo.

    2.5 en el panel izquierdo del Editor de administración de directiva de grupo, desplácese a Configuración del equipo -> directivas -> Plantillas administrativas -> Componentes de Windows -> Cifrado de unidad BitLocker -> Unidades de datos fijasy pulse el botón derecho se pueden recuperar unidades de elegir cómo protegidas con BitLocker fijada.

    2.6 en el cuadro de diálogo emergente de configuración de directiva, habilite la directiva y defina las siguientes opciones:
    1. Permitir que el agente de recuperación de datos
    2. Guardar información de recuperación de BitLocker en AD DS para unidades de datos fijas
    3. No habilite BitLocker hasta que se almacena la información de recuperación en AD DS para unidades de datos fijas

    2.7, haga clic en Aceptary, a continuación, cierre la ventana del Editor.

    2.8 en el marco de filtrado de seguridad, haga clic en Agregar para agregar todas las cuentas de equipo de nodos de almacenamiento de información. En CPS, hay cuatro nodos por rack. Después de agregarlos, todos los nodos deben aparecer en el marco de filtrado de seguridad. Puede quitar el grupo de usuarios autorizados.

    2.9 en el panel izquierdo, haga clic en la directiva de BitLocker y, a continuación, haga clic en Enforced. Cierre el Editor de administración de directiva de grupo.

    2.10 en este punto, se aplica la directiva, pero puede tardar hasta una hora para propagar.
    1. En caso de que no desea esperar a la directiva propagar, manualmente puede forzar inicio de sesión en cada nodo de almacenamiento de información y ejecutando PS C:\Users\admin1\Desktop > gpupdate /force.
    2. Compruebe que la directiva se ha aplicado correctamente ejecutando el cmdlet siguiente en cada nodo de almacenamiento de información:

      PS C:\Users\admin1\Desktop > gpresult /scope computer /v
    3. En la salida, busque los objetos de directiva de grupo aplicada. Si aparece la directiva (en este ejemplo lo llamamos BitLocker), se aplica la directiva, y puede ir al paso 3.

  3. Importante [no se salte este paso]: Si tienen cargas de trabajo ejecutan en el clúster de inquilinos que requieren una determinada secuencia de apagado, hágalo ahora. La secuencia de comandos en el paso 4 se apaga todas las máquinas virtuales activas en el sello. Desactivar las VMs AD/DC. Después de que los volúmenes tienen un estado con conexión (redirigido) , se puede reiniciar con seguridad el inquilino VMs.
  4. Habilitar el cifrado de BitLocker en todos los volúmenes de almacenamiento de información. Importante: Este procedimiento debe repetirse en cada rack de su sello CPS como cada rack tiene su propio clúster de almacenamiento de información.

    4.1 Copie el código siguiente y guárdelo como habilitar ClusterDiskBitlocker.ps1 en <MiCarpeta> en uno de los nodos del clúster de almacenamiento de información. Vamos a llamar a ese nodo <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 utilizar Escritorio remoto para conectarse a <myStorageNode> utilizando sus credenciales de administrador y, a continuación, abrir una consola de PowerShell con derechos de administrador. Si no puede conectarse, habilitar Escritorio remoto en los nodos de almacenamiento de información. Para obtener instrucciones sobre cómo habilitar Escritorio remoto, consulte: Windows 2012 Core Survival Guide – escritorio remoto.

    4.3 vaya a <MiCarpeta> y, a continuación, escriba la siguiente línea de comandos:
    PS C:\Users\admin1\Desktop> .\Enable-ClusterDiskBitlocker.ps1 –bitlockerEncryptionKey <myEncryptionKey> -Verbose
    La clave de cifrado es la clave que desea utilizar para BitLocker. La secuencia de comandos solicita las credenciales de administrador y los nombres de clúster de la administración, el clúster de cálculo y el clúster de borde.

    4.5 la secuencia de comandos primero desactivar todas las máquinas virtuales de las marcas (excepto las VMs AD/DC), por lo que se pierde la conectividad a la consola de máquina virtual. La secuencia de comandos se pasan por cada disco de clúster y habilitar el cifrado de BitLocker. Después de habilitar BitLocker en todos los discos de clúster, la secuencia de comandos mostrará todas las máquinas virtuales en línea desactivados durante el proceso.

    Si está interesado en aprender lo que está ocurriendo bajo el capó, la secuencia de comandos está estrechamente relacionado con los pasos descritos en la siguiente entrada de blog:

    Cómo configurar discos de clúster cifrados mediante BitLocker en Windows Server 2012

    Este proceso dura aproximadamente 30 minutos por cada clúster de almacenamiento de información.

    4.6 cuando finalice la secuencia de comandos, abra el Administrador de clúster de conmutación por error. Todos los discos del clúster deben tener el estado Online (redirigido) . Ahora puede activar todas las máquinas virtuales que desactivó anteriormente y funcionan como de costumbre el rack de CPS. El proceso de cifrado podría tardar varios días en completarse, dependiendo de la cantidad de datos que se escriben en los discos. Después de que un disco de clúster está totalmente cifrado, devuelve automáticamente su estado a en línea.

    4.7 una vez completado el proceso de cifrado, deshabilite Escritorio remoto en los nodos de almacenamiento de información. Para obtener instrucciones acerca de cómo deshabilitar Escritorio remoto, consulte: Windows 2012 Core Survival Guide – escritorio remoto.
  5. Comprobar el estado de cifrado de la marca

    Para obtener una actualización de estado en el proceso de cifrado, o para obtener una copia impresa del estado cifrado por razones de cumplimiento de normas, ejecute el siguiente cmdlet Get-VolumeEncryptionStatus .

    <#################################################### #
    # 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 copia este código y guardarlo como Get-VolumeEncryptionStatus.ps1 en <MiCarpeta> en una consola de máquina virtual.

    5.2 abrir una consola de Powershell con derechos de administrador y ejecute el siguiente cmdlet para pasar el nombre de su clúster de almacenamiento:
    PS C:\Users\admin1\Desktop> .\Get-VolumeEncryptionStatus.ps1 -storageClusterName
Propiedades

Id. de artículo: 3078425 - Última revisión: 22 ene. 2017 - Revisión: 1

Comentarios