Delimitar a alocação de volumes em Storage Spaces Direct (Espaços de Armazenamento Directo)

O Windows Server 2019 apresenta uma opção para delimitar manualmente a alocação de volumes em Espaços de Armazenamento Diretos. Fazer isso pode aumentar significativamente a tolerância a falhas sob certas condições, mas impõe algumas considerações adicionais de gerenciamento e complexidade. Este tópico explica como funciona e dá exemplos no PowerShell.

Prerequisites

Considere usar esta opção se:

• Seu cluster tem seis ou mais servidores; e ainda
• Seu cluster usa apenas resiliência de espelho de três vias

Não utilize esta opção se:

• Seu cluster tem menos de seis servidores; ou
• Seu cluster usa paridade ou resiliência de paridade acelerada por espelho

Understand

Revisão: atribuição regular

Com o espelhamento regular por três vias, o volume é dividido em muitos pequenos "blocos" que são copiados três vezes e distribuídos uniformemente por cada unidade em cada servidor do cluster. Para mais detalhes, leia este blog de mergulho profundo.

Essa alocação padrão maximiza leituras e gravações paralelas, levando a um melhor desempenho, e é atraente em sua simplicidade: todos os servidores estão igualmente ocupados, todas as unidades estão igualmente cheias e todos os volumes permanecem on-line ou ficam off-line juntos. Cada volume tem a garantia de sobreviver a até duas falhas simultâneas, como ilustram estes exemplos .

No entanto, com essa alocação, os volumes não podem sobreviver a três falhas simultâneas. Se três servidores falharem ao mesmo tempo, ou se os drives em três servidores falharem ao mesmo tempo, os volumes tornam-se inacessíveis porque, com uma probabilidade muito alta, pelo menos algumas partições foram alocadas precisamente nos três drives ou servidores que falharam.

No exemplo abaixo, os servidores 1, 3 e 5 falham ao mesmo tempo. Embora muitas lajes tenham cópias sobreviventes, algumas não:

O volume fica offline e fica inacessível até que os servidores sejam recuperados.

Novo: dotação delimitada

Com alocação delimitada, você especifica um subconjunto de servidores a serem usados (mínimo quatro). O volume é dividido em lajes que são copiadas três vezes, como antes, mas em vez de alocar em todos os servidores, as lajes são alocadas apenas ao subconjunto de servidores que especificar.

Por exemplo, se você tiver um cluster de 8 nós (nós 1 a 8), poderá especificar um volume a ser localizado somente em discos nos nós 1, 2, 3, 4.

Advantages

Com a alocação de exemplo, é provável que o volume sobreviva a três falhas simultâneas. Se os nós 1, 2 e 6 falharem, apenas 2 dos nós que armazenam as 3 cópias de dados para o volume estarão inativos e o volume permanecerá online.

A probabilidade de sobrevivência depende do número de servidores e de outros fatores – consulte Análise para obter detalhes.

Disadvantages

A alocação delimitada impõe algumas considerações adicionais de gerenciamento e complexidade:

1. O administrador é responsável por delimitar a alocação de cada volume para equilibrar a utilização do armazenamento entre servidores e manter a alta probabilidade de sobrevivência, conforme descrito na seção Práticas recomendadas .

2. Com alocação delimitada, reserve o equivalente a uma unidade de capacidade por servidor (sem limite máximo). Isso é mais do que a recomendação publicada para alocação regular, que atinge o máximo de quatro drives de capacidade total.

3. Se um servidor falhar e precisar ser substituído, conforme descrito em Remover um servidor e suas unidades, o administrador é responsável por atualizar a delimitação dos volumes afetados, adicionando o novo servidor e removendo o que falhou – exemplo abaixo.

Utilização no PowerShell

Você pode usar o cmdlet New-Volume para criar volumes no Storage Spaces Direct.

Por exemplo, para criar um volume de espelho triplo regular:

New-Volume -FriendlyName "MyRegularVolume" -Size 100GB

Criar um volume e delimitar sua alocação

Para criar um volume de espelho de três vias e delimitar sua alocação:

1. Primeiro, atribua os servidores em seu cluster à variável $Servers:

   $Servers = Get-StorageFaultDomain -Type StorageScaleUnit | Sort FriendlyName
   

   Tip

   Em Storage Spaces Direct, o termo "Storage Scale Unit" refere-se a todo o armazenamento bruto conectado a um servidor, incluindo unidades de conexão direta e gabinetes externos de conexão direta com drives. Neste contexto, é o mesmo que 'servidor'.

2. Especifique que servidores deve usar com o novo parâmetro -StorageFaultDomainsToUse e indexando em $Servers. Por exemplo, para delimitar a alocação para o primeiro, segundo, terceiro e quarto servidores (índices 0, 1, 2 e 3):

   New-Volume -FriendlyName "MyVolume" -Size 100GB -StorageFaultDomainsToUse $Servers[0,1,2,3]
   

Ver uma dotação delimitada

Para ver como MyVolume é alocado, use o Get-VirtualDiskFootprintBySSU.ps1 script no Apêndice:

PS C:\> .\Get-VirtualDiskFootprintBySSU.ps1

VirtualDiskFriendlyName TotalFootprint Server1 Server2 Server3 Server4 Server5 Server6
----------------------- -------------- ------- ------- ------- ------- ------- -------
MyVolume                300 GB         100 GB  100 GB  100 GB  100 GB  0       0

Observe que apenas Server1, Server2, Server3 e Server4 contêm placas de MyVolume.

Alterar uma alocação delimitada

Utilize os novos cmdlets Add-StorageFaultDomain e Remove-StorageFaultDomain para alterar a forma como a alocação é delimitada.

Por exemplo, para mover MyVolume por um servidor:

1. Especifique que o quinto servidor pode armazenar lajes de MyVolume:

   Get-VirtualDisk MyVolume | Add-StorageFaultDomain -StorageFaultDomains $Servers[4]
   

2. Especifique que o primeiro servidor não pode armazenar lajes de MyVolume:

   Get-VirtualDisk MyVolume | Remove-StorageFaultDomain -StorageFaultDomains $Servers[0]
   

3. Reequilibre o pool de armazenamento para que a alteração entre em vigor:

   Get-StoragePool S2D* | Optimize-StoragePool
   

Você pode monitorar o progresso do reequilíbrio com Get-StorageJob.

Quando estiver concluído, verifique se o MyVolume foi movido executando Get-VirtualDiskFootprintBySSU.ps1 novamente.

PS C:\> .\Get-VirtualDiskFootprintBySSU.ps1

VirtualDiskFriendlyName TotalFootprint Server1 Server2 Server3 Server4 Server5 Server6
----------------------- -------------- ------- ------- ------- ------- ------- -------
MyVolume                300 GB         0       100 GB  100 GB  100 GB  100 GB  0

Observe que o Server1 não contém mais placas de MyVolume – em vez disso, o Server5 contém.

Melhores práticas

Aqui estão as práticas recomendadas a serem seguidas ao usar a alocação de volume delimitado:

Escolha quatro servidores

Delimite cada volume de espelho de três vias para quatro servidores, não mais.

Armazenamento de equilíbrio

Equilibre a quantidade de armazenamento alocada para cada servidor, contabilizando o tamanho do volume.

Volumes de atribuição delimitados e escalonados

Para maximizar a tolerância a falhas, torne a alocação de cada volume única, o que significa que ele não compartilha todos os seus servidores com outro volume (alguma sobreposição é aceitável).

Por exemplo, em um sistema de oito nós: Volume 1: Servidores 1, 2, 3, 4 Volume 2: Servidores 5, 6, 7, 8 Volume 3: Servidores 3, 4, 5, 6 Volume 4: Servidores 1, 2, 7, 8

Analysis

Esta seção deriva a probabilidade matemática de que um volume permaneça online e acessível (ou equivalentemente, a fração esperada do armazenamento geral que permanece online e acessível) em função do número de falhas e do tamanho do cluster.

Até duas falhas é sempre ok

Cada volume de espelho de três vias pode sobreviver a até duas falhas ao mesmo tempo, independentemente da sua distribuição. Se duas unidades falharem, ou dois servidores falharem, ou um de cada, cada volume de espelho de três vias permanecerá on-line e acessível, mesmo com alocação regular.

Mais de metade do cluster a falhar nunca é aceitável

Por outro lado, no caso extremo de mais da metade dos servidores ou unidades no cluster falharem de uma só vez, o quórum é perdido e cada volume de espelho de três vias fica offline e se torna inacessível, independentemente de sua alocação.

E pelo meio?

Se ocorrerem três ou mais falhas ao mesmo tempo, mas pelo menos metade dos servidores e das unidades ainda estiverem ativos, os volumes com alocação limitada podem permanecer online e acessíveis, dependendo de quais servidores apresentam falhas.

Perguntas frequentes

Posso delimitar alguns volumes, mas não outros?

Yes. Você pode escolher por volume se deseja ou não delimitar a alocação.

A alocação delimitada altera a forma como funciona a substituição de discos rígidos?

Não, é o mesmo que com a alocação regular.

Referências Adicionais

• Visão geral do Storage Spaces Direct
• Tolerância a falhas em espaços de armazenamento diretos

Appendix

Esse script ajuda você a ver como seus volumes são alocados.

Para usá-lo como descrito acima, copie/cole e salve como Get-VirtualDiskFootprintBySSU.ps1.

Function ConvertTo-PrettyCapacity {
    Param (
        [Parameter(
            Mandatory = $True,
            ValueFromPipeline = $True
            )
        ]
    [Int64]$Bytes,
    [Int64]$RoundTo = 0
    )
    If ($Bytes -Gt 0) {
        $Base = 1024
        $Labels = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
        $Order = [Math]::Floor( [Math]::Log($Bytes, $Base) )
        $Rounded = [Math]::Round($Bytes/( [Math]::Pow($Base, $Order) ), $RoundTo)
        [String]($Rounded) + " " + $Labels[$Order]
    }
    Else {
        "0"
    }
    Return
}

Function Get-VirtualDiskFootprintByStorageFaultDomain {

    ################################################
    ### Step 1: Gather Configuration Information ###
    ################################################

    Write-Progress -Activity "Get-VirtualDiskFootprintByStorageFaultDomain" -CurrentOperation "Gathering configuration information..." -Status "Step 1/4" -PercentComplete 00

    $ErrorCannotGetCluster = "Cannot proceed because 'Get-Cluster' failed."
    $ErrorNotS2DEnabled = "Cannot proceed because the cluster is not running Storage Spaces Direct."
    $ErrorCannotGetClusterNode = "Cannot proceed because 'Get-ClusterNode' failed."
    $ErrorClusterNodeDown = "Cannot proceed because one or more cluster nodes is not Up."
    $ErrorCannotGetStoragePool = "Cannot proceed because 'Get-StoragePool' failed."
    $ErrorPhysicalDiskFaultDomainAwareness = "Cannot proceed because the storage pool is set to 'PhysicalDisk' fault domain awareness. This cmdlet only supports 'StorageScaleUnit', 'StorageChassis', or 'StorageRack' fault domain awareness."

    Try  {
        $GetCluster = Get-Cluster -ErrorAction Stop
    }
    Catch {
        throw $ErrorCannotGetCluster
    }

    If ($GetCluster.S2DEnabled -Ne 1) {
        throw $ErrorNotS2DEnabled
    }

    Try  {
        $GetClusterNode = Get-ClusterNode -ErrorAction Stop
    }
    Catch {
        throw $ErrorCannotGetClusterNode
    }

    If ($GetClusterNode | Where State -Ne Up) {
        throw $ErrorClusterNodeDown
    }

    Try {
        $GetStoragePool = Get-StoragePool -IsPrimordial $False -ErrorAction Stop
    }
    Catch {
        throw $ErrorCannotGetStoragePool
    }

    If ($GetStoragePool.FaultDomainAwarenessDefault -Eq "PhysicalDisk") {
        throw $ErrorPhysicalDiskFaultDomainAwareness
    }

    ###########################################################
    ### Step 2: Create SfdList[] and PhysicalDiskToSfdMap{} ###
    ###########################################################

    Write-Progress -Activity "Get-VirtualDiskFootprintByStorageFaultDomain" -CurrentOperation "Analyzing physical disk information..." -Status "Step 2/4" -PercentComplete 25

    $SfdList = Get-StorageFaultDomain -Type ($GetStoragePool.FaultDomainAwarenessDefault) | Sort FriendlyName # StorageScaleUnit, StorageChassis, or StorageRack

    $PhysicalDiskToSfdMap = @{} # Map of PhysicalDisk.UniqueId -> StorageFaultDomain.FriendlyName
    $SfdList | ForEach {
        $StorageFaultDomain = $_
        $_ | Get-StorageFaultDomain -Type PhysicalDisk | ForEach {
            $PhysicalDiskToSfdMap[$_.UniqueId] = $StorageFaultDomain.FriendlyName
        }
    }

    ##################################################################################################
    ### Step 3: Create VirtualDisk.FriendlyName -> { StorageFaultDomain.FriendlyName -> Size } Map ###
    ##################################################################################################

    Write-Progress -Activity "Get-VirtualDiskFootprintByStorageFaultDomain" -CurrentOperation "Analyzing virtual disk information..." -Status "Step 3/4" -PercentComplete 50

    $GetVirtualDisk = Get-VirtualDisk | Sort FriendlyName

    $VirtualDiskMap = @{}

    $GetVirtualDisk | ForEach {
        # Map of PhysicalDisk.UniqueId -> Size for THIS virtual disk
        $PhysicalDiskToSizeMap = @{}
        $_ | Get-PhysicalExtent | ForEach {
            $PhysicalDiskToSizeMap[$_.PhysicalDiskUniqueId] += $_.Size
        }
        # Map of StorageFaultDomain.FriendlyName -> Size for THIS virtual disk
        $SfdToSizeMap = @{}
        $PhysicalDiskToSizeMap.keys | ForEach {
            $SfdToSizeMap[$PhysicalDiskToSfdMap[$_]] += $PhysicalDiskToSizeMap[$_]
        }
        # Store
        $VirtualDiskMap[$_.FriendlyName] = $SfdToSizeMap
    }

    #########################
    ### Step 4: Write-Out ###
    #########################

    Write-Progress -Activity "Get-VirtualDiskFootprintByStorageFaultDomain" -CurrentOperation "Formatting output..." -Status "Step 4/4" -PercentComplete 75

    $Output = $GetVirtualDisk | ForEach {
        $Row = [PsCustomObject]@{}

        $VirtualDiskFriendlyName = $_.FriendlyName
        $Row | Add-Member -MemberType NoteProperty "VirtualDiskFriendlyName" $VirtualDiskFriendlyName

        $TotalFootprint = $_.FootprintOnPool | ConvertTo-PrettyCapacity
        $Row | Add-Member -MemberType NoteProperty "TotalFootprint" $TotalFootprint

        $SfdList | ForEach {
            $Size = $VirtualDiskMap[$VirtualDiskFriendlyName][$_.FriendlyName] | ConvertTo-PrettyCapacity
            $Row | Add-Member -MemberType NoteProperty $_.FriendlyName $Size
        }

        $Row
    }

    # Calculate width, in characters, required to Format-Table
    $RequiredWindowWidth = ("TotalFootprint").length + 1 + ("VirtualDiskFriendlyName").length + 1
    $SfdList | ForEach {
        $RequiredWindowWidth += $_.FriendlyName.Length + 1
    }

    $ActualWindowWidth = (Get-Host).UI.RawUI.WindowSize.Width

    If (!($ActualWindowWidth)) {
        # Cannot get window width, probably ISE, Format-List
        Write-Warning "Could not determine window width. For the best experience, use a Powershell window instead of ISE"
        $Output | Format-Table
    }
    ElseIf ($ActualWindowWidth -Lt $RequiredWindowWidth) {
        # Narrower window, Format-List
        Write-Warning "For the best experience, try making your PowerShell window at least $RequiredWindowWidth characters wide. Current width is $ActualWindowWidth characters."
        $Output | Format-List
    }
    Else {
        # Wider window, Format-Table
        $Output | Format-Table
    }
}

Get-VirtualDiskFootprintByStorageFaultDomain