Konfigurieren von Netzwerkendpunkten für die Azure-Dateisynchronisierung

Navigieren Sie zu dem Speicherkonto, für das Sie einen privaten Endpunkt erstellen möchten. Wählen Sie im Dienstmenü unter Sicherheit + Netzwerk die Option Netzwerk, Private Endpunktverbindungen und dann +Privater Endpunkt aus, um einen neuen privaten Endpunkt zu erstellen.

Im anschließend angezeigten Assistenten müssen mehrere Seiten ausgefüllt werden.

Wählen Sie auf dem Blatt Grundlagen das gewünschte Abonnement, die Ressourcengruppe, den Namen, den Namen der Netzwerkschnittstelle und die Region für Ihren privaten Endpunkt aus. Diese können beliebig sein und müssen nicht mit dem Speicherkonto übereinstimmen. Allerdings müssen Sie den privaten Endpunkt in derselben Region erstellen wie das virtuelle Netzwerk, in dem Sie den privaten Endpunkt erstellen möchten. Wählen Sie dann Weiter: Ressource aus.

Wählen Sie auf dem Blatt Ressource die Option Datei für die untergeordnete Zielressource aus. Wählen Sie anschließend Weiter: Virtuelles Netzwerk aus.

Auf dem Blatt Virtuelles Netzwerk können Sie das spezifische virtuelle Netzwerk und das Subnetz auswählen, dem Sie Ihren privaten Endpunkt hinzufügen möchten. Wählen Sie die dynamische oder statische IP-Adresszuordnung für den neuen privaten Endpunkt aus. Wenn Sie sich für eine statische Zuordnung entscheiden, müssen Sie auch einen Namen und eine private IP-Adresse angeben. Optional können Sie auch eine Anwendungssicherheitsgruppe angeben. Wenn Sie fertig sind, wählen Sie Weiter: DNS aus.

Das Blatt DNS enthält die Informationen zur Integration Ihres privaten Endpunkts in eine private DNS-Zone. Vergewissern Sie sich, dass Abonnement und Ressourcengruppe korrekt sind, und wählen Sie dann Weiter: Tags aus.

Sie können optional Tags anwenden, um Ihre Ressourcen zu kategorisieren, und beispielsweise den Namen Umgebung und den Wert Test auf alle Testressourcen anwenden. Geben Sie bei Bedarf Name-Wert-Paare ein, und wählen Sie dann Weiter: Überprüfen + erstellen aus.

Wählen Sie Erstellen aus, um den privaten Endpunkt zu erstellen.

Wenn Sie eine VM in Ihrem virtuellen Netzwerk haben oder DNS-Weiterleitung wie in Konfigurieren von DNS-Weiterleitung für Azure Files beschrieben konfiguriert haben, können Sie testen, ob Ihr privater Endpunkt korrekt eingerichtet ist, indem Sie folgende Befehle aus PowerShell, der Kommandozeile oder dem Terminal ausführen (funktioniert für Windows, Linux oder macOS). Ersetzen Sie <storage-account-name> durch den Namen Ihres Speicherkontos:

nslookup <storage-account-name>.file.core.windows.net

Falls alles richtig funktioniert, sollte die folgende Ausgabe angezeigt werden (Beispiel für Windows), wobei 192.168.0.5 die private IP-Adresse des privaten Endpunkts in Ihrem virtuellen Netzwerk ist:

Server:  UnKnown
Address:  10.2.4.4

Non-authoritative answer:
Name:    storageaccount.privatelink.file.core.windows.net
Address:  192.168.0.5
Aliases:  storageaccount.file.core.windows.net

Für die Erstellung eines privaten Endpunkts für Ihr Speicherkonto müssen Sie zuerst einen Verweis auf Ihr Speicherkonto und das Subnetz des virtuellen Netzwerks einrichten, dem Sie den privaten Endpunkt hinzufügen möchten. Ersetzen Sie unten <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> und <vnet-subnet-name> entsprechend:

$storageAccountResourceGroupName = "<storage-account-resource-group-name>"
$storageAccountName = "<storage-account-name>"
$virtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$virtualNetworkName = "<vnet-name>"
$subnetName = "<vnet-subnet-name>"

# Get storage account reference, and throw error if it doesn't exist
$storageAccount = Get-AzStorageAccount `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name $storageAccountName `
        -ErrorAction SilentlyContinue

if ($null -eq $storageAccount) {
    $errorMessage = "Storage account $storageAccountName not found "
    $errorMessage += "in resource group $storageAccountResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Get virtual network reference, and throw error if it doesn't exist
$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $virtualNetworkName `
        -ErrorAction SilentlyContinue

if ($null -eq $virtualNetwork) {
    $errorMessage = "Virtual network $virtualNetworkName not found "
    $errorMessage += "in resource group $virtualNetworkResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Get reference to virtual network subnet, and throw error if it doesn't exist
$subnet = $virtualNetwork | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    Write-Error `
            -Message "Subnet $subnetName not found in virtual network $virtualNetworkName." `
            -ErrorAction Stop
}

Für die Erstellung eines privaten Endpunkts müssen Sie eine Private Link-Dienstverbindung mit dem Speicherkonto erstellen. Die Private Link-Dienstverbindung ist eine Voraussetzung für die Erstellung des privaten Endpunkts.

# Disable private endpoint network policies
$subnet.PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork = $virtualNetwork | `
    Set-AzVirtualNetwork -ErrorAction Stop

# Create a private link service connection to the storage account.
$privateEndpointConnection = New-AzPrivateLinkServiceConnection `
        -Name "$storageAccountName-Connection" `
        -PrivateLinkServiceId $storageAccount.Id `
        -GroupId "file" `
        -ErrorAction Stop

# Create a new private endpoint.
$privateEndpoint = New-AzPrivateEndpoint `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name "$storageAccountName-PrivateEndpoint" `
        -Location $virtualNetwork.Location `
        -Subnet $subnet `
        -PrivateLinkServiceConnection $privateEndpointConnection `
        -ErrorAction Stop

Die Erstellung einer privaten Azure DNS-Zone ermöglicht es, dass der Originalname des Speicherkontos, z. B. storageaccount.file.core.windows.net, in die private IP-Adresse im virtuellen Netzwerk aufgelöst wird. Diese Vorgehensweise ist für die Erstellung eines privaten Endpunkts zwar optional, aber für die direkte Einbindung der Azure-Dateifreigabe mit einem AD-Benutzerprinzipal oder per Zugriff über die REST-API ist dies zwingend erforderlich.

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done like this so this script will seamlessly work for non-public Azure.
$storageAccountSuffix = Get-AzContext | `
    Select-Object -ExpandProperty Environment | `
    Select-Object -ExpandProperty StorageEndpointSuffix

# For public cloud, this will generate the following DNS suffix:
# privatelink.file.core.windows.net.
$dnsZoneName = "privatelink.file.$storageAccountSuffix"

# Find a DNS zone matching desired name attached to this virtual network.
$dnsZone = Get-AzPrivateDnsZone | `
    Where-Object { $_.Name -eq $dnsZoneName } | `
    Where-Object {
        $privateDnsLink = Get-AzPrivateDnsVirtualNetworkLink `
                -ResourceGroupName $_.ResourceGroupName `
                -ZoneName $_.Name `
                -ErrorAction SilentlyContinue
        
        $privateDnsLink.VirtualNetworkId -eq $virtualNetwork.Id
    }

if ($null -eq $dnsZone) {
    # No matching DNS zone attached to virtual network, so create new one.
    $dnsZone = New-AzPrivateDnsZone `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -Name $dnsZoneName `
            -ErrorAction Stop

    $privateDnsLink = New-AzPrivateDnsVirtualNetworkLink `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -ZoneName $dnsZoneName `
            -Name "$virtualNetworkName-DnsLink" `
            -VirtualNetworkId $virtualNetwork.Id `
            -ErrorAction Stop
}

Nachdem Sie nun über einen Verweis auf die private DNS-Zone verfügen, müssen Sie einen A-Eintrag für Ihr Speicherkonto erstellen.

$privateEndpointIP = $privateEndpoint | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object @{ 
        Name = "NetworkInterfaces"; 
        Expression = { Get-AzNetworkInterface -ResourceId $_.Id } 
    } | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty IpConfigurations | `
    Select-Object -ExpandProperty PrivateIpAddress

$privateDnsRecordConfig = New-AzPrivateDnsRecordConfig `
        -IPv4Address $privateEndpointIP

New-AzPrivateDnsRecordSet `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $storageAccountName `
        -RecordType A `
        -ZoneName $dnsZoneName `
        -Ttl 600 `
        -PrivateDnsRecords $privateDnsRecordConfig `
        -ErrorAction Stop | `
    Out-Null

Wenn Sie eine VM in Ihrem virtuellen Netzwerk haben oder DNS-Weiterleitung wie in Configure DNS forwarding for Azure Files beschrieben konfiguriert haben, können Sie mit folgenden Befehlen testen, ob Ihr privater Endpunkt korrekt eingerichtet ist:

$storageAccountHostName = [System.Uri]::new($storageAccount.PrimaryEndpoints.file) | `
    Select-Object -ExpandProperty Host

Resolve-DnsName -Name $storageAccountHostName

Falls alles richtig funktioniert, sollte die folgende Ausgabe angezeigt werden, wobei 192.168.0.5 die private IP-Adresse des privaten Endpunkts in Ihrem virtuellen Netzwerk ist:

Name                             Type   TTL   Section    NameHost
----                             ----   ---   -------    --------
storageaccount.file.core.windows CNAME  60    Answer     storageaccount.privatelink.file.core.windows.net
.net

Name       : storageaccount.privatelink.file.core.windows.net
QueryType  : A
TTL        : 600
Section    : Answer
IP4Address : 192.168.0.5

Für die Erstellung eines privaten Endpunkts für Ihr Speicherkonto müssen Sie zuerst einen Verweis auf Ihr Speicherkonto und das Subnetz des virtuellen Netzwerks einrichten, dem Sie den privaten Endpunkt hinzufügen möchten. Ersetzen Sie unten <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> und <vnet-subnet-name> entsprechend:

storageAccountResourceGroupName="<storage-account-resource-group-name>"
storageAccountName="<storage-account-name>"
virtualNetworkResourceGroupName="<vnet-resource-group-name>"
virtualNetworkName="<vnet-name>"
subnetName="<vnet-subnet-name>"

# Get storage account ID 
storageAccount=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" | \
    tr -d '"')

# Get virtual network ID
virtualNetwork=$(az network vnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --name $virtualNetworkName \
        --query "id" | \
    tr -d '"')

# Get subnet ID
subnet=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "id" | \
    tr -d '"')

Für die Erstellung eines privaten Endpunkts müssen Sie zunächst sicherstellen, dass die Netzwerkrichtlinie für den privaten Endpunkt des Subnetzes auf „Deaktiviert“ festgelegt ist. Anschließend können Sie mit dem Befehl az network private-endpoint create einen privaten Endpunkt erstellen.

# Disable private endpoint network policies
az network vnet subnet update \
        --ids $subnet \
        --disable-private-endpoint-network-policies \
        --output none

# Get virtual network location
region=$(az network vnet show \
        --ids $virtualNetwork \
        --query "location" | \
    tr -d '"')

# Create a private endpoint
privateEndpoint=$(az network private-endpoint create \
        --resource-group $storageAccountResourceGroupName \
        --name "$storageAccountName-PrivateEndpoint" \
        --location $region \
        --subnet $subnet \
        --private-connection-resource-id $storageAccount \
        --group-id "file" \
        --connection-name "$storageAccountName-Connection" \
        --query "id" | \
    tr -d '"')

Die Erstellung einer privaten Azure DNS-Zone ermöglicht es, dass der Originalname des Speicherkontos, z. B. storageaccount.file.core.windows.net, in die private IP-Adresse im virtuellen Netzwerk aufgelöst wird. Diese Vorgehensweise ist für die Erstellung eines privaten Endpunkts zwar optional, aber für die Einbindung der Azure-Dateifreigabe mit einem AD-Benutzerprinzipal oder per Zugriff über die REST-API ist dies zwingend erforderlich.

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done like this so this script will seamlessly work for non-public Azure.
storageAccountSuffix=$(az cloud show \
        --query "suffixes.storageEndpoint" | \
    tr -d '"')

# For public cloud, this will generate the following DNS suffix:
# privatelink.file.core.windows.net.
dnsZoneName="privatelink.file.$storageAccountSuffix"

# Find a DNS zone matching desired name attached to this virtual network.
possibleDnsZones=""
possibleDnsZones=$(az network private-dns zone list \
        --query "[?name == '$dnsZoneName'].id" \
        --output tsv)

dnsZone=""
possibleDnsZone=""
for possibleDnsZone in $possibleDnsZones
do
    possibleResourceGroupName=$(az resource show \
            --ids $possibleDnsZone \
            --query "resourceGroup" | \
        tr -d '"')
    
    link=$(az network private-dns link vnet list \
            --resource-group $possibleResourceGroupName \
            --zone-name $dnsZoneName \
            --query "[?virtualNetwork.id == '$virtualNetwork'].id" \
            --output tsv)
    
    if [ -z $link ]
    then
        echo "1" > /dev/null
    else 
        dnsZoneResourceGroup=$possibleResourceGroupName
        dnsZone=$possibleDnsZone
        break
    fi  
done

if [ -z $dnsZone ]
then
    # No matching DNS zone attached to virtual network, so create a new one
    dnsZone=$(az network private-dns zone create \
            --resource-group $virtualNetworkResourceGroupName \
            --name $dnsZoneName \
            --query "id" | \
        tr -d '"')
    
    az network private-dns link vnet create \
            --resource-group $virtualNetworkResourceGroupName \
            --zone-name $dnsZoneName \
            --name "$virtualNetworkName-DnsLink" \
            --virtual-network $virtualNetwork \
            --registration-enabled false \
            --output none
    
    dnsZoneResourceGroup=$virtualNetworkResourceGroupName
fi

Nachdem Sie nun über einen Verweis auf die private DNS-Zone verfügen, müssen Sie einen A-Eintrag für Ihr Speicherkonto erstellen.

privateEndpointNIC=$(az network private-endpoint show \
        --ids $privateEndpoint \
        --query "networkInterfaces[0].id" | \
    tr -d '"')

privateEndpointIP=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[0].privateIPAddress" | \
    tr -d '"')

az network private-dns record-set a create \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --name $storageAccountName \
        --output none

az network private-dns record-set a add-record \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --record-set-name $storageAccountName \
        --ipv4-address $privateEndpointIP \
        --output none

Wenn Sie eine VM in Ihrem virtuellen Netzwerk haben oder DNS-Weiterleitung wie in Configure DNS forwarding for Azure Files beschrieben konfiguriert haben, können Sie mit folgenden Befehlen testen, ob Ihr privater Endpunkt korrekt eingerichtet ist:

httpEndpoint=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "primaryEndpoints.file" | \
    tr -d '"')

hostName=$(echo $httpEndpoint | cut -c7-$(expr length $httpEndpoint) | tr -d "/")
nslookup $hostName

Falls alles richtig funktioniert, sollte die folgende Ausgabe angezeigt werden, wobei 192.168.0.5 die private IP-Adresse des privaten Endpunkts in Ihrem virtuellen Netzwerk ist:

Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
storageaccount.file.core.windows.net      canonical name = storageaccount.privatelink.file.core.windows.net.
Name:   storageaccount.privatelink.file.core.windows.net
Address: 192.168.0.5

Gehen Sie zum Private Link Center, indem Sie Private Link in die Suchleiste oben im Azure-Portal eingeben. Im Inhaltsverzeichnis des Private Link Centers wählen Sie Private Endpunkte aus und wählen Sie dann + Hinzufügen, um einen neuen privaten Endpunkt zu erstellen.

Im anschließend angezeigten Assistenten müssen mehrere Seiten ausgefüllt werden.

Auf der Registerkarte Grundlagen wählen Sie die Ressourcengruppe, den Namen und die Region für Ihren privaten Endpunkt aus. Diese Werte können beliebige gültige Werte sein. Sie müssen in keiner Weise mit dem Storage Sync Service übereinstimmen, aber du musst den privaten Endpunkt in derselben Region wie das von dir ausgewählte virtuelle Netzwerk erstellen.

Wählen Sie auf der Registerkarte Ressource die Option Verbindung mit einer Azure-Ressource in meinem Verzeichnis herstellen aus. Wählen Sie unter dem RessourcentypMicrosoft aus. StorageSync/storageSyncServices.

Der Konfigurationstab ermöglicht es Ihnen, das spezifische virtuelle Netzwerk und Subnetz auszuwählen, dem Sie Ihren privaten Endpunkt hinzufügen möchten. Wählen Sie dasselbe virtuelle Netzwerk aus, das Sie für das Speicherkonto verwendet haben. Der Konfigurationstab enthält außerdem die Informationen zum Erstellen und Aktualisieren der privaten DNS-Zone.

Klicken Sie auf Überprüfen + erstellen, um den privaten Endpunkt zu erstellen.

Sie können testen, ob Ihr privater Endpunkt richtig eingerichtet wurde, indem Sie die folgenden PowerShell-Befehle ausführen.

$privateEndpointResourceGroupName = "<your-private-endpoint-resource-group>"
$privateEndpointName = "<your-private-endpoint-name>"

Get-AzPrivateEndpoint `
        -ResourceGroupName $privateEndpointResourceGroupName `
        -Name $privateEndpointName `
        -ErrorAction Stop | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty Id | `
    ForEach-Object { Get-AzNetworkInterface -ResourceId $_ } | `
    Select-Object -ExpandProperty IpConfigurations | `
    Select-Object -ExpandProperty PrivateLinkConnectionProperties | `
    Select-Object -ExpandProperty Fqdns | `
    ForEach-Object { Resolve-DnsName -Name $_ } | `
    Format-List

Wenn alles richtig funktioniert, sollte die folgende Ausgabe angezeigt werden, in der 192.168.1.4, 192.168.1.5, 192.168.1.6 und 192.168.1.7 für die privaten IP-Adressen stehen, die dem privaten Endpunkt zugewiesen sind:

Name     : mysssmanagement.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : mysssmanagement.westus2.privatelink.afs.azure.net


Name       : mysssmanagement.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.4

Name     : myssssyncp.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : myssssyncp.westus2.privatelink.afs.azure.net


Name       : myssssyncp.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.5

Name     : myssssyncs.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : myssssyncs.westus2.privatelink.afs.azure.net


Name       : myssssyncs.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.6

Name     : mysssmonitoring.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : mysssmonitoring.westus2.privatelink.afs.azure.net


Name       : mysssmonitoring.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.7

Zum Erstellen eines privaten Endpunkts für Ihren Speichersynchronisierungsdienst benötigen Sie zunächst einen Verweis auf den Speichersynchronisierungsdienst. Ersetzen Sie <storage-sync-service-resource-group> und <storage-sync-service> durch die entsprechenden Werte für Ihre Umgebung. Die folgenden PowerShell-Befehle gehen davon aus, dass Sie die virtuellen Netzwerkinformationen bereits ausgefüllt haben.

$storageSyncServiceResourceGroupName = "<storage-sync-service-resource-group>"
$storageSyncServiceName = "<storage-sync-service>"

$storageSyncService = Get-AzStorageSyncService `
        -ResourceGroupName $storageSyncServiceResourceGroupName `
        -Name $storageSyncServiceName `
        -ErrorAction SilentlyContinue

if ($null -eq $storageSyncService) {
    $errorMessage = "Storage Sync Service $storageSyncServiceName not found "
    $errorMessage += "in resource group $storageSyncServiceResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

Für die Erstellung eines privaten Endpunkts müssen Sie eine Private Link-Dienstverbindung mit dem Speichersynchronisierungsdienst herstellen. Die Private Link-Verbindung ist eine Voraussetzung für die Erstellung des privaten Endpunkts.

# Disable private endpoint network policies
$subnet.PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork = $virtualNetwork | `
    Set-AzVirtualNetwork -ErrorAction Stop

# Create a private link service connection to the storage account
$privateEndpointConnection = New-AzPrivateLinkServiceConnection `
        -Name "$storageSyncServiceName-Connection" `
        -PrivateLinkServiceId $storageSyncService.ResourceId `
        -GroupId "Afs" `
        -ErrorAction Stop

# Create a new private endpoint
$privateEndpoint = New-AzPrivateEndpoint `
        -ResourceGroupName $storageSyncServiceResourceGroupName `
        -Name "$storageSyncServiceName-PrivateEndpoint" `
        -Location $virtualNetwork.Location `
        -Subnet $subnet `
        -PrivateLinkServiceConnection $privateEndpointConnection `
        -ErrorAction Stop

Die Erstellung einer Zone mit privatem Azure-DNS ermöglicht es, dass Hostnamen für den Speichersynchronisierungsdienst, z. B. mysssmanagement.westus2.afs.azure.net, in die richtigen privaten IP-Adressen für den Speichersynchronisierungsdienst im virtuellen Netzwerk aufgelöst werden. Dies ist in Bezug auf die Erstellung eines privaten Endpunkts zwar optional, aber dennoch unbedingt erforderlich, wenn der Azure-Dateisynchronisierungs-Agent auf den Speichersynchronisierungsdienst zugreifen soll.

# Get the desired Storage Sync Service suffix (afs.azure.net for public cloud)
# This is done like this so this script will seamlessly work for non-public Azure
$azureEnvironment = Get-AzContext | `
    Select-Object -ExpandProperty Environment | `
    Select-Object -ExpandProperty Name

switch($azureEnvironment) {
    "AzureCloud" {
        $storageSyncSuffix = "afs.azure.net"
    }

    "AzureUSGovernment" {
        $storageSyncSuffix = "afs.azure.us"
    }

   "AzureChinaCloud" {
        $storageSyncSuffix = "afs.azure.cn"
    }

    default {
        Write-Error
                -Message "The Azure environment $_ is not currently supported by Azure File Sync." `
                -ErrorAction Stop
    }
}

# For public cloud, this will generate the following DNS suffix:
# privatelink.afs.azure.net
$dnsZoneName = "privatelink.$storageSyncSuffix"

# Find a DNS zone matching desired name attached to this virtual network
$dnsZone = Get-AzPrivateDnsZone | `
    Where-Object { $_.Name -eq $dnsZoneName } | `
    Where-Object {
        $privateDnsLink = Get-AzPrivateDnsVirtualNetworkLink `
                -ResourceGroupName $_.ResourceGroupName `
                -ZoneName $_.Name `
                -ErrorAction SilentlyContinue

        $privateDnsLink.VirtualNetworkId -eq $virtualNetwork.Id
    }

if ($null -eq $dnsZone) {
    # No matching DNS zone attached to virtual network, so create a new one
    $dnsZone = New-AzPrivateDnsZone `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -Name $dnsZoneName `
            -ErrorAction Stop

    $privateDnsLink = New-AzPrivateDnsVirtualNetworkLink `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -ZoneName $dnsZoneName `
            -Name "$virtualNetworkName-DnsLink" `
            -VirtualNetworkId $virtualNetwork.Id `
            -ErrorAction Stop
}

Nachdem Sie nun über einen Verweis auf die private DNS-Zone verfügen, müssen Sie einen A-Eintrag für Ihren Speichersynchronisierungsdienst erstellen.

$privateEndpointIpFqdnMappings = $privateEndpoint | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty Id | `
    ForEach-Object { Get-AzNetworkInterface -ResourceId $_ } | `
    Select-Object -ExpandProperty IpConfigurations | `
    ForEach-Object {
        $privateIpAddress = $_.PrivateIpAddress;
        $_ | `
            Select-Object -ExpandProperty PrivateLinkConnectionProperties | `
            Select-Object -ExpandProperty Fqdns | `
            Select-Object `
                @{
                    Name = "PrivateIpAddress";
                    Expression = { $privateIpAddress }
                }, `
                @{
                    Name = "FQDN";
                    Expression = { $_ }
                }
    }

foreach($ipFqdn in $privateEndpointIpFqdnMappings) {
    $privateDnsRecordConfig = New-AzPrivateDnsRecordConfig `
        -IPv4Address $ipFqdn.PrivateIpAddress

    $dnsEntry = $ipFqdn.FQDN.Substring(0,
        $ipFqdn.FQDN.IndexOf(".", $ipFqdn.FQDN.IndexOf(".") + 1))

    New-AzPrivateDnsRecordSet `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -Name $dnsEntry `
            -RecordType A `
            -ZoneName $dnsZoneName `
            -Ttl 600 `
            -PrivateDnsRecords $privateDnsRecordConfig `
            -ErrorAction Stop | `
        Out-Null
}

Zum Erstellen eines privaten Endpunkts für Ihren Speichersynchronisierungsdienst benötigen Sie zunächst einen Verweis auf den Speichersynchronisierungsdienst. Ersetzen Sie <storage-sync-service-resource-group> und <storage-sync-service> durch die entsprechenden Werte für Ihre Umgebung. Die folgenden CLI-Befehle gehen davon aus, dass Sie die virtuellen Netzwerkinformationen bereits ausgefüllt haben.

storageSyncServiceResourceGroupName="<storage-sync-service-resource-group>"
storageSyncServiceName="<storage-sync-service>"

storageSyncService=$(az resource show \
        --resource-group $storageSyncServiceResourceGroupName \
        --name $storageSyncServiceName \
        --resource-type "Microsoft.StorageSync/storageSyncServices" \
        --query "id" | \
    tr -d '"')

storageSyncServiceRegion=$(az resource show \
        --resource-group $storageSyncServiceResourceGroupName \
        --name $storageSyncServiceName \
        --resource-type "Microsoft.StorageSync/storageSyncServices" \
        --query "location" | \
    tr -d '"')

Um einen privaten Endpunkt zu erstellen, stellen Sie zunächst sicher, dass die Netzwerkrichtlinie für den privaten Endpunkt des Subnetzes auf deaktiviert eingestellt ist. Erstellen Sie dann einen privaten Endpunkt mit dem az network private-endpoint create Befehl.

# Disable private endpoint network policies
az network vnet subnet update \
        --ids $subnet \
        --disable-private-endpoint-network-policies \
        --output none

# Get virtual network location
region=$(az network vnet show \
        --ids $virtualNetwork \
        --query "location" | \
    tr -d '"')

# Create a private endpoint
privateEndpoint=$(az network private-endpoint create \
        --resource-group $storageSyncServiceResourceGroupName \
        --name "$storageSyncServiceName-PrivateEndpoint" \
        --location $region \
        --subnet $subnet \
        --private-connection-resource-id $storageSyncService \
        --group-id "Afs" \
        --connection-name "$storageSyncServiceName-Connection" \
        --query "id" | \
    tr -d '"')

Die Erstellung einer Zone mit privatem Azure-DNS ermöglicht es, dass Hostnamen für den Speichersynchronisierungsdienst, z. B. mysssmanagement.westus2.afs.azure.net, in die richtigen privaten IP-Adressen für den Speichersynchronisierungsdienst im virtuellen Netzwerk aufgelöst werden. Dies ist in Bezug auf die Erstellung eines privaten Endpunkts zwar optional, aber dennoch unbedingt erforderlich, wenn der Azure-Dateisynchronisierungs-Agent auf den Speichersynchronisierungsdienst zugreifen soll.

# Get the desired storage account suffix (afs.azure.net for public cloud)
# This is done like this so this script will seamlessly work for non-public Azure
azureEnvironment=$(az cloud show \
        --query "name" |
    tr -d '"')

storageSyncSuffix=""
if [ $azureEnvironment == "AzureCloud" ]
then
    storageSyncSuffix="afs.azure.net"
elif [ $azureEnvironment == "AzureUSGovernment" ]
then
    storageSyncSuffix="afs.azure.us"
else
    echo "Unsupported Azure environment $azureEnvironment."
fi

# For public cloud, this will generate the following DNS suffix:
# privatelink.afs.azure.net
dnsZoneName="privatelink.$storageSyncSuffix"

# Find a DNS zone matching desired name attached to this virtual network
possibleDnsZones=""
possibleDnsZones=$(az network private-dns zone list \
        --query "[?name == '$dnsZoneName'].id" \
        --output tsv)

dnsZone=""
possibleDnsZone=""
for possibleDnsZone in $possibleDnsZones
do
    possibleResourceGroupName=$(az resource show \
            --ids $possibleDnsZone \
            --query "resourceGroup" | \
        tr -d '"')

    link=$(az network private-dns link vnet list \
            --resource-group $possibleResourceGroupName \
            --zone-name $dnsZoneName \
            --query "[?virtualNetwork.id == '$virtualNetwork'].id" \
            --output tsv)

    if [ -z $link ]
    then
        echo "1" > /dev/null
    else
        dnsZoneResourceGroup=$possibleResourceGroupName
        dnsZone=$possibleDnsZone
        break
    fi
done

if [ -z $dnsZone ]
then
    # No matching DNS zone attached to virtual network, so create a new one
    dnsZone=$(az network private-dns zone create \
            --resource-group $virtualNetworkResourceGroupName \
            --name $dnsZoneName \
            --query "id" | \
        tr -d '"')

    az network private-dns link vnet create \
            --resource-group $virtualNetworkResourceGroupName \
            --zone-name $dnsZoneName \
            --name "$virtualNetworkName-DnsLink" \
            --virtual-network $virtualNetwork \
            --registration-enabled false \
            --output none

    dnsZoneResourceGroup=$virtualNetworkResourceGroupName
fi

Nachdem Sie nun über einen Verweis auf die private DNS-Zone verfügen, müssen Sie einen A-Eintrag für Ihren Speichersynchronisierungsdienst erstellen.

privateEndpointNIC=$(az network private-endpoint show \
        --ids $privateEndpoint \
        --query "networkInterfaces[0].id" | \
    tr -d '"')

privateIpAddresses=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[].privateIpAddress" \
        --output tsv)

hostNames=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[].privateLinkConnectionProperties.fqdns[]" \
        --output tsv)

i=0
for privateIpAddress in $privateIpAddresses
do
    j=0
    targetHostName=""
    for hostName in $hostNames
    do
        if [ $i == $j ]
        then
            targetHostName=$hostName
            break
        fi

        j=$(expr $j + 1)
    done

    endpointName=$(echo $targetHostName | \
        cut -c1-$(expr $(expr index $targetHostName ".") - 1))

    az network private-dns record-set a create \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --name "$endpointName.$storageSyncServiceRegion" \
        --output none

    az network private-dns record-set a add-record \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --record-set-name "$endpointName.$storageSyncServiceRegion" \
        --ipv4-address $privateIpAddress \
        --output none

    i=$(expr $i + 1)
done

Navigieren Sie zu dem Speicherkonto, für das Sie den gesamten Zugriff auf den öffentlichen Endpunkt einschränken möchten. Wählen Sie im Inhaltsverzeichnis des Speicherkontos den Eintrag Netzwerke aus.

Wählen Sie oben auf der Seite das Optionsfeld Aktiviert aus ausgewählten virtuellen Netzwerken und IP-Adressen aus. Hierdurch werden einige Einstellungen zum Steuern der Einschränkung des öffentlichen Endpunkts eingeblendet. Aktivieren Sie Azure-Diensten auf der Liste der vertrauenswürdigen Dienste den Zugriff auf dieses Speicherkonto erlauben, um vertrauenswürdigen Microsoft-Erstanbieterdiensten, z. B. der Azure-Dateisynchronisierung, den Zugriff auf das Speicherkonto zu erlauben.

Mit dem folgenden PowerShell-Befehl wird der gesamte Datenverkehr an den öffentlichen Endpunkt des Speicherkontos abgelehnt. Beachten Sie, dass für diesen Befehl der Parameter -Bypass auf AzureServices festgelegt ist. Hierdurch können vertrauenswürdige Erstanbieterdienste, z. B. die Azure-Dateisynchronisierung, über den öffentlichen Endpunkt auf das Speicherkonto zugreifen.

# This assumes $storageAccount is still defined from the beginning of this of this guide.
$storageAccount | Update-AzStorageAccountNetworkRuleSet `
        -DefaultAction Deny `
        -Bypass AzureServices `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

Mit dem folgenden CLI-Befehl wird der gesamte Datenverkehr an den öffentlichen Endpunkt des Speicherkontos abgelehnt. Beachten Sie, dass für diesen Befehl der Parameter -bypass auf AzureServices festgelegt ist. Hierdurch können vertrauenswürdige Erstanbieterdienste, z. B. die Azure-Dateisynchronisierung, über den öffentlichen Endpunkt auf das Speicherkonto zugreifen.

# This assumes $storageAccountResourceGroupName and $storageAccountName 
# are still defined from the beginning of this guide.
az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --bypass "AzureServices" \
    --default-action "Deny" \
    --output none

Navigieren Sie zu dem Speicherkonto, für das Sie den öffentlichen Endpunkt auf bestimmte virtuelle Netzwerke einschränken möchten. Wählen Sie im Inhaltsverzeichnis des Speicherkontos den Eintrag Netzwerke aus.

Wählen Sie oben auf der Seite das Optionsfeld Aktiviert aus ausgewählten virtuellen Netzwerken und IP-Adressen aus. Hierdurch werden einige Einstellungen zum Steuern der Einschränkung des öffentlichen Endpunkts eingeblendet. Wählen Sie + Vorhandenes virtuelles Netzwerk hinzufügen aus, um das jeweilige virtuelle Netzwerk auszuwählen, für das der Zugriff auf das Speicherkonto über den öffentlichen Endpunkt zulässig sein soll. Wählen Sie ein virtuelles Netzwerk und ein Subnetz für dieses virtuelle Netzwerk und dann Aktivieren aus.

Aktivieren Sie Azure-Diensten auf der Liste der vertrauenswürdigen Dienste den Zugriff auf dieses Speicherkonto erlauben, um vertrauenswürdigen Microsoft-Erstanbieterdiensten, z. B. der Azure-Dateisynchronisierung, den Zugriff auf das Speicherkonto zu erlauben.

Zum Einschränken des Zugriffs auf den öffentlichen Endpunkt des Speicherkontos auf bestimmte virtuelle Netzwerke mit Dienstendpunkten müssen wir zunächst Informationen zum Speicherkonto und virtuellen Netzwerk sammeln. Geben Sie die Werte für <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> und <subnet-name> ein, um diese Informationen zu sammeln.

$storageAccountResourceGroupName = "<storage-account-resource-group>"
$storageAccountName = "<storage-account-name>"
$restrictToVirtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$restrictToVirtualNetworkName = "<vnet-name>"
$subnetName = "<subnet-name>"

$storageAccount = Get-AzStorageAccount `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name $storageAccountName `
        -ErrorAction Stop

$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $restrictToVirtualNetworkResourceGroupName `
        -Name $restrictToVirtualNetworkName `
        -ErrorAction Stop

$subnet = $virtualNetwork | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    Write-Error `
            -Message "Subnet $subnetName not found in virtual network $restrictToVirtualNetworkName." `
            -ErrorAction Stop
}

Damit der Datenverkehr aus dem virtuellen Netzwerk von der Azure-Netzwerkfabric zugelassen wird und an den öffentlichen Endpunkt des Speicherkontos fließen kann, muss für das Subnetz des virtuellen Netzwerks der Dienstendpunkt Microsoft.Storage verfügbar gemacht werden. Mit den folgenden PowerShell-Befehlen wird der Dienstendpunkt Microsoft.Storage dem Subnetz hinzugefügt, falls er noch nicht vorhanden ist.

$serviceEndpoints = $subnet | `
    Select-Object -ExpandProperty ServiceEndpoints | `
    Select-Object -ExpandProperty Service

if ($serviceEndpoints -notcontains "Microsoft.Storage") {
    if ($null -eq $serviceEndpoints) {
        $serviceEndpoints = @("Microsoft.Storage")
    } elseif ($serviceEndpoints -is [string]) {
        $serviceEndpoints = @($serviceEndpoints, "Microsoft.Storage")
    } else {
        $serviceEndpoints += "Microsoft.Storage"
    }

    $virtualNetwork = $virtualNetwork | Set-AzVirtualNetworkSubnetConfig `
            -Name $subnetName `
            -AddressPrefix $subnet.AddressPrefix `
            -ServiceEndpoint $serviceEndpoints `
            -WarningAction SilentlyContinue `
            -ErrorAction Stop | `
        Set-AzVirtualNetwork `
            -ErrorAction Stop
}

Der letzte Schritt zum Einschränken des Datenverkehrs für das Speicherkonto ist das Erstellen einer Netzwerkregel und das Hinzufügen zum Netzwerkregelsatz des Speicherkontos.

$networkRule = $storageAccount | Add-AzStorageAccountNetworkRule `
    -VirtualNetworkResourceId $subnet.Id `
    -ErrorAction Stop

$storageAccount | Update-AzStorageAccountNetworkRuleSet `
        -DefaultAction Deny `
        -Bypass AzureServices `
        -VirtualNetworkRule $networkRule `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

Zum Einschränken des Zugriffs auf den öffentlichen Endpunkt des Speicherkontos auf bestimmte virtuelle Netzwerke mit Dienstendpunkten müssen wir zunächst Informationen zum Speicherkonto und virtuellen Netzwerk sammeln. Geben Sie die Werte für <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> und <subnet-name> ein, um diese Informationen zu sammeln.

storageAccountResourceGroupName="<storage-account-resource-group>"
storageAccountName="<storage-account-name>"
restrictToVirtualNetworkResourceGroupName="<vnet-resource-group-name>"
restrictToVirtualNetworkName="<vnet-name>"
subnetName="<subnet-name>"

storageAccount=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" | \
    tr -d '"')

virtualNetwork=$(az network vnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --name $restrictToVirtualNetworkName \
        --query "id" | \
    tr -d '"')

subnet=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "id" | \
    tr -d '"')

Damit der Datenverkehr aus dem virtuellen Netzwerk von der Azure-Netzwerkfabric zugelassen wird und an den öffentlichen Endpunkt des Speicherkontos fließen kann, muss für das Subnetz des virtuellen Netzwerks der Dienstendpunkt Microsoft.Storage verfügbar gemacht werden. Mit den folgenden CLI-Befehlen wird der Dienstendpunkt Microsoft.Storage dem Subnetz hinzugefügt, falls er noch nicht vorhanden ist.

serviceEndpoints=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "serviceEndpoints[].service" \
        --output tsv)

foundStorageServiceEndpoint=false
for serviceEndpoint in $serviceEndpoints
do
    if [ $serviceEndpoint = "Microsoft.Storage" ]
    then
        foundStorageServiceEndpoint=true
    fi
done

if [ $foundStorageServiceEndpoint = false ] 
then
    serviceEndpointList=""

    for serviceEndpoint in $serviceEndpoints
    do
        serviceEndpointList+=$serviceEndpoint
        serviceEndpointList+=" "
    done
    
    serviceEndpointList+="Microsoft.Storage"

    az network vnet subnet update \
            --ids $subnet \
            --service-endpoints $serviceEndpointList \
            --output none
fi

Der letzte Schritt zum Einschränken des Datenverkehrs für das Speicherkonto ist das Erstellen einer Netzwerkregel und das Hinzufügen zum Netzwerkregelsatz des Speicherkontos.

az storage account network-rule add \
        --resource-group $storageAccountResourceGroupName \
        --account-name $storageAccountName \
        --subnet $subnet \
        --output none

az storage account update \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --bypass "AzureServices" \
        --default-action "Deny" \
        --output none

Führen Sie die folgenden Schritte aus, um den Zugriff auf den öffentlichen Endpunkt des Speichersynchronisierungsdiensts zu deaktivieren:

1. Melden Sie sich beim Azure-Portal an.
2. Gehe zum Storage Sync Service und wähleSettings> in der linken Navigation.
3. Wählen Sie unter Zugriff zulassen von die Option Nur von privaten Endpunkten aus.
4. Wählen Sie in der Liste Private Endpunktverbindungen einen privaten Endpunkt aus.

Um den Zugriff auf den öffentlichen Endpunkt des Storage Sync Service zu deaktivieren, setzen Sie die incomingTrafficPolicy Eigenschaft im Storage Sync Service auf AllowVirtualNetworksOnly. Um den Zugriff auf den öffentlichen Endpunkt des Storage Sync Service zu ermöglichen, setzen Sie incomingTrafficPolicy auf AllowAllTraffic. Ersetzen Sie <storage-sync-service-resource-group> und <storage-sync-service> durch Ihre eigenen Werte.

$storageSyncServiceResourceGroupName = "<storage-sync-service-resource-group>"
$storageSyncServiceName = "<storage-sync-service>"

Set-AzStorageSyncService `
    -ResourceGroupName $storageSyncServiceResourceGroupName `
    -Name $storageSyncServiceName `
    -IncomingTrafficPolicy AllowVirtualNetworksOnly

Das Festlegen der incomingTrafficPolicy-Eigenschaft für den Speichersynchronisierungsdienst wird von Azure CLI nicht unterstützt. Wählen Sie den Tab Azure PowerShell für Anweisungen, wie man den Public Endpoint Storage Sync Service deaktiviert.