Określ alokację woluminów w Storage Spaces Direct

Dotyczy: ✅ Windows Server 2025, ✅ Windows Server 2022, ✅ Windows Server 2019, ✅ Windows Server 2016, ✅ Azure Local 2311.2 and later

System Windows Server 2019 wprowadza opcję ręcznego określania alokacji woluminów w Storage Spaces Direct. Może to znacznie zwiększyć odporność na uszkodzenia w pewnych warunkach, ale nakłada pewne dodatkowe zagadnienia i złożoność zarządzania. W tym temacie wyjaśniono, jak to działa i przedstawiono przykłady w programie PowerShell.

Important

Ta funkcja jest nowa w systemie Windows Server 2019. Nie jest on dostępny w systemie Windows Server 2016.

Prerequisites

Rozważ użycie tej opcji, jeśli:

Klaster ma co najmniej sześć serwerów; i
Klaster używa tylko odporności dublowania trójstopniowego

Nie używaj tej opcji, jeśli:

Klaster ma mniej niż sześć serwerów; lub
Klaster używa odporności parzystości lub parzystości przyspieszanej przez dublowanie

Understand

Przegląd: regularna alokacja

W przypadku potrójnego odwzorowania wolumin jest podzielony na wiele małych segmentów, które są kopiowane trzy razy i równomiernie rozprowadzane na każdym dysku w każdym serwerze klastru. Aby uzyskać więcej informacji, przeczytaj ten blog szczegółowy.

Diagram przedstawiający wolumin podzielony na trzy stosy płyt i równomiernie rozmieszczony na każdym serwerze.

Ta domyślna alokacja maksymalizuje równoległe odczyty i zapisy, co prowadzi do lepszej wydajności i jest atrakcyjne dla jego prostoty: każdy serwer jest równie zajęty, każdy dysk jest równie pełny, a wszystkie woluminy pozostają w trybie online lub przechodzą w tryb offline razem. Każdy wolumin ma gwarancję, że przetrwa maksymalnie dwa współbieżne błędy, jak pokazano w tych przykładach .

Jednak w przypadku tej alokacji woluminy nie mogą przetrwać trzech współbieżnych awarii. W przypadku awarii trzech serwerów jednocześnie lub awarii dysków na trzech serwerach woluminy staną się niedostępne, ponieważ co najmniej niektóre płyty były (z bardzo dużym prawdopodobieństwem) przydzielone do dokładnie trzech dysków lub serwerów, które uległy awarii.

W poniższym przykładzie serwery 1, 3 i 5 kończą się niepowodzeniem w tym samym czasie. Chociaż wiele płyt ma zachowane kopie, niektóre nie mają:

Diagram przedstawiający trzy z sześciu serwerów wyróżnionych na czerwono, a ogólny wolumin jest czerwony.

Wolumen przechodzi w tryb offline i staje się niedostępny aż do przywrócenia serwerów.

Nowy: ograniczona alokacja

W przypadku alokacji rozdzielanej należy określić podzbiór serwerów do użycia (co najmniej cztery). Zasób jest podzielony na segmenty, które są kopiowane trzykrotnie, jak wcześniej, lecz zamiast przydzielać je do każdego serwera, segmenty są przydzielane tylko do wybranej grupy serwerów.

Jeśli na przykład masz klaster z 8 węzłami (węzły od 1 do 8), możesz określić wolumin, który ma znajdować się tylko na dyskach w węzłach 1, 2, 3, 4.

Advantages

Przy przykładowej alokacji wolumin prawdopodobnie przetrwa trzy współbieżne awarie. Jeśli węzły 1, 2 i 6 spadną, tylko 2 węzły, które przechowują 3 kopie danych dla woluminu, zostaną wyłączone, a wolumin pozostanie w trybie online.

Prawdopodobieństwo przetrwania zależy od liczby serwerów i innych czynników — zobacz Analiza , aby uzyskać szczegółowe informacje.

Disadvantages

Alokacja z ograniczeniami nakłada dodatkowe rozważania i złożoność zarządzania.

Administrator jest odpowiedzialny za rozdzielanie alokacji każdego woluminu w celu zrównoważenia wykorzystania magazynu między serwerami i utrzymania wysokiego prawdopodobieństwa przetrwania, zgodnie z opisem w sekcji Najlepsze rozwiązania .
W przypadku alokacji rozdzielanej należy zarezerwować odpowiednik jednego dysku pojemności na serwer (bez maksymalnej). Jest to więcej niż opublikowana rekomendacja dotycząca regularnej alokacji, która maksymalnie obejmuje łącznie cztery dyski pojemności.
Jeśli serwer ulegnie awarii i musi zostać zastąpiony, zgodnie z opisem w temacie Usuwanie serwera i jego dysków, administrator jest odpowiedzialny za aktualizowanie ograniczeń woluminów, których dotyczy problem, dodając nowy serwer i usuwając jeden z nich, który uległ awarii — przykład poniżej.

Użycie w programie PowerShell

Możesz użyć New-Volume polecenia cmdlet, aby utworzyć woluminy w funkcji Bezpośrednia przestrzeń dyskowa.

Aby na przykład utworzyć zwykły trójdrożny wolumin lustrzany:

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

Utwórz wolumin i ogranicz jego alokację

Aby utworzyć trójdrożny wolumin lustra i określić jego alokację:

Najpierw przypisz serwery w klastrze do zmiennej $Servers:
```
$Servers = Get-StorageFaultDomain -Type StorageScaleUnit | Sort FriendlyName
```
Tip

W Przestrzeniach magazynowania Direct termin "Jednostka skalowania magazynu" odnosi się do całej surowej pamięci masowej dołączonej do jednego serwera, w tym bezpośrednio dołączonych dysków i bezpośrednio dołączonych zewnętrznych obudów z dyskami. W tym kontekście jest to samo co "serwer".
Określ, które serwery mają być używane z nowym parametrem -StorageFaultDomainsToUse oraz poprzez indeksowanie w $Servers. Aby na przykład rozdzielić alokację na pierwsze, drugie, trzecie i czwarte serwery (indeksy 0, 1, 2 i 3):
```
New-Volume -FriendlyName "MyVolume" -Size 100GB -StorageFaultDomainsToUse $Servers[0,1,2,3]
```

Zobacz przydział o określonych granicach

Aby zobaczyć, jak MyVolume jest przydzielony, użyj skryptu Get-VirtualDiskFootprintBySSU.ps1 w Dodatku:

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

Należy pamiętać, że tylko serwery Server1, Server2, Server3 i Server4 zawierają segmenty MyVolume.

Zmień ograniczoną alokację

Użyj nowych cmdletów Add-StorageFaultDomain i Remove-StorageFaultDomain, aby zmienić sposób określania alokacji.

Aby na przykład przenieść MyVolume na inny serwer:

Określ, że piąty serwer może przechowywać bloki danych MyVolume:

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

Określ, że pierwszy serwer nie może przechowywać bloków MyVolume:

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

Ponownie zrównoważ pulę magazynów, aby zmiana weszła w życie:
```
Get-StoragePool S2D* | Optimize-StoragePool
```

Postęp ponownego równoważenia można monitorować za pomocą polecenia Get-StorageJob.

Po zakończeniu sprawdź, czy MyVolume został przeniesiony, ponownie uruchamiając Get-VirtualDiskFootprintBySSU.ps1.

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

Należy pamiętać, że Serwer1 nie zawiera już płyt MyVolume — zamiast tego, Serwer5 zawiera.

Najlepsze rozwiązania

Poniżej przedstawiono najlepsze rozwiązania, które należy stosować podczas korzystania z alokacji woluminu rozdzielanego:

Wybieranie czterech serwerów

Ogranicz każdy wolumin trójstronnego lustra do czterech serwerów, nie więcej.

Równoważenie pamięci masowej

Zrównoważ ilość miejsca do magazynowania przydzielonego do każdego serwera, co odpowiada rozmiarowi woluminu.

Stopniowo rozdzielane woluminy alokacji

Aby zmaksymalizować odporność na uszkodzenia, należy zapewnić unikatowość alokacji każdego woluminu, co oznacza, że nie współużytkuje wszystkich serwerów z innym woluminem (niektóre nakładanie się jest akceptowalne).

Na przykład w systemie ośmiu węzłów: Wolumin 1: Serwery 1, 2, 3, 4 Wolumin 2: Serwery 5, 6, 7, 8 Wolumin 3: Serwery 3, 4, 5, 6 Wolumin 4: Serwery 1, 2, 7, 8

Analysis

Ta sekcja wyprowadza matematyczne prawdopodobieństwo, że wolumin pozostaje aktywny online i dostępny (lub co jest równoważne, oczekiwana część całkowitej pamięci masowej, która pozostaje aktywna online i dostępna) jako funkcja liczby awarii oraz rozmiaru klastra.

Note

Ta sekcja jest opcjonalna. Jeśli chcesz zobaczyć matematykę, przeczytaj dalej! Ale jeśli nie, nie martw się: użycie w programie PowerShell i najlepsze praktyki to wszystko, co musisz zrobić, aby pomyślnie zaimplementować rozdzielaną alokację.

Maksymalnie dwa błędy są zawsze w porządku

Każdy wolumin lustrzany trzystopniowy może przetrwać do dwóch awarii jednocześnie, niezależnie od alokacji. W przypadku awarii dwóch dysków lub awarii dwóch serwerów lub jednego z nich każdy wolumin dublowania trzystopniowego pozostaje w trybie online i dostępny, nawet z regularną alokacją.

Więcej niż połowa awarii klastra nigdy nie jest w porządku

Z drugiej strony, w skrajnym przypadku, gdy ponad połowa serwerów lub dysków w klastrze ulegnie awarii jednocześnie, kworum zostanie utracone , a każdy wolumin dublowania trzystopniowego przechodzi w tryb offline i staje się niedostępny, niezależnie od alokacji.

Co z między nimi?

Jeśli co najmniej trzy awarie wystąpią jednocześnie, ale co najmniej połowa serwerów i dysków nadal działa, woluminy z wydzieloną alokacją mogą pozostać dostępne online, w zależności od tego, które serwery uległy awarii.

Najczęściej zadawane pytania

Czy mogę rozdzielić niektóre woluminy, ale nie inne?

Yes. Możesz zdecydować osobno dla każdego woluminu, czy ograniczyć alokację.

Czy alokacja z ograniczeniami zmienia sposób działania procesu wymiany dysku?

Nie, jest taka sama jak w przypadku zwykłej alokacji.

Dodatkowe referencje

Appendix

Ten skrypt pomaga zobaczyć, jak są przydzielane woluminy.

Aby użyć go zgodnie z powyższym opisem, skopiuj/wklej i zapisz jako 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

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-08-16