Konfigurieren von Netzwerkendpunkten für den Zugriff auf Azure-Dateifreigaben

Wechseln Sie zu der Ressourcengruppe, in der Sie einen privaten Endpunkt erstellen möchten. Wählen Sie +Erstellen und suchen Sie nach privatem Endpunkt. Wählen Sie die private Endpunktressource und dann "Erstellen" aus.

Der Assistent hat mehrere Seiten, die ausgefüllt werden müssen.

Wählen Sie auf der Seite "Grundlagen " das Abonnement, die Ressourcengruppe, den Namen, den Netzwerkschnittstellennamen und die Region für Ihren privaten Endpunkt aus. Sie müssen den privaten Endpunkt in derselben Region wie das virtuelle Netzwerk erstellen, in dem Sie den privaten Endpunkt erstellen möchten. Wählen Sie dann Weiter: Ressource aus.

Wenn du klassische Dateifreigaben in einem Speicherkonto verwendest:

Auf der Seite Ressource wählen Sie Microsoft.Storage/storageAccounts aus dem Dropdownmenü für Ressourcentyp aus. Für Resource wählen Sie das spezifische Speicherkonto aus, mit dem Sie sich verbinden möchten. Für Ziel-Subressource wählen Sie file. Wählen Sie anschließend Weiter: Virtuelles Netzwerk aus.

Wenn du Dateifreigaben verwendest, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

Auf der Ressourcenseite wählen Sie Microsoft aus. FileShares/fileShares aus dem Dropdown-Menü für den Ressourcentyp. Für Resource wählen Sie die spezifische Dateifreigabe aus, mit der Sie sich verbinden möchten. Die Ziel-Unterressource wird automatisch mit FileShare ausgefüllt. Wählen Sie anschließend Weiter: Virtuelles Netzwerk aus.

Auf der Seite 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 statisch auswählen, 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.

Die DNS-Seite enthält die Informationen zum Integrieren Ihres privaten Endpunkts in eine private DNS-Zone. Stellen Sie sicher, dass die Abonnement- und Ressourcengruppe korrekt ist, und wählen Sie dann "Weiter: Kategorien" 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.

Um einen privaten Endpunkt zu erstellen, rufen Sie zuerst einen Verweis auf Ihr Speicherkonto oder Ihre Dateifreigabe und das virtuelle Netzwerk-Subnetz ab, in dem Sie den privaten Endpunkt hinzufügen möchten. Ersetzen Sie die Platzhalterwerte im folgenden Code durch Ihre eigenen Werte.

Rufen Sie für klassische Dateifreigaben einen Verweis auf das Speicherkonto ab:

$storageAccountResourceGroupName = "<storage-account-resource-group-name>"
$storageAccountName = "<storage-account-name>"

$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
}

# Set common variables for private endpoint creation
$resourceGroupName = $storageAccountResourceGroupName
$privateLinkResourceId = $storageAccount.Id
$groupId = "file"
$dnsRecordName = $storageAccountName

Für Dateifreigaben, die mit dem Microsoft.FileShares-Ressourcenanbieter erstellt wurden, rufen Sie einen Verweis auf die Dateifreigabe ab:

 $fileShareResourceGroupName = "<resource-group-name>"
 $fileShareName = "<file-share-name>"
 
 $fileShare = Get-AzFileShare `
         -ResourceGroupName $fileShareResourceGroupName `
         -ResourceName $fileShareName `
         -ErrorAction SilentlyContinue
 
 if ($null -eq $fileShare) {
     $errorMessage = "File share $fileShareName not found "
     $errorMessage += "in resource group $fileShareResourceGroupName."
     Write-Error -Message $errorMessage -ErrorAction Stop
 }
 
 # Extract hostName and hostNamePrefix for DNS record
 $hostName = $fileShare.HostName
 $hostNamePrefix = $hostName.Split('.')[0]
 
 # Set common variables for private endpoint creation
 $resourceGroupName = $fileShareResourceGroupName
 $privateLinkResourceId = $fileShare.Id
 $groupId = "FileShare"
 $dnsRecordName = $hostNamePrefix

Nach dem Festlegen der allgemeinen Variablen sind die verbleibenden Schritte für beide Umgebungen identisch. Rufen Sie Referenzen auf das virtuelle Netzwerk und das Subnetz ab:

 $virtualNetworkResourceGroupName = "<vnet-resource-group-name>"
 $virtualNetworkName = "<vnet-name>"
 $subnetName = "<vnet-subnet-name>"
 
 # 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
 }

Zum Erstellen eines privaten Endpunkts müssen Sie eine Verbindung mit einem privaten Linkdienst 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.
 $privateEndpointConnection = New-AzPrivateLinkServiceConnection `
         -Name "$dnsRecordName-Connection" `
         -PrivateLinkServiceId $privateLinkResourceId `
         -GroupId $groupId `
         -ErrorAction Stop
 
 # Create a new private endpoint.
 $privateEndpoint = New-AzPrivateEndpoint `
         -ResourceGroupName $resourceGroupName `
         -Name "$dnsRecordName-PrivateEndpoint" `
         -Location $virtualNetwork.Location `
         -Subnet $subnet `
         -PrivateLinkServiceConnection $privateEndpointConnection `
         -ErrorAction Stop

Wenn Sie eine Azure private DNS-Zone erstellen, wird der ursprüngliche Hostname in die private IP innerhalb des virtuellen Netzwerks aufgelöst. Obwohl es aus Sicht der Erstellung eines privaten Endpunkts optional ist, ist es ausdrücklich erforderlich, um die Azure-Dateifreigabe direkt mit einem Active Directory (AD) Benutzerprinzip zu mounten oder über die REST-API zuzugreifen.

 # Get the host name suffix (core.windows.net for public cloud).
 # This is done like this so this script will seamlessly work for non-public Azure.
 $hostNameSuffix = 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.$hostNameSuffix"
 
 # 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 einen Verweis auf die private DNS-Zone haben, müssen Sie einen Eintrag 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 $dnsRecordName `
         -RecordType A `
         -ZoneName $dnsZoneName `
         -Ttl 600 `
         -PrivateDnsRecords $privateDnsRecordConfig `
         -ErrorAction Stop | `
     Out-Null

Um einen privaten Endpunkt zu erstellen, benötigen Sie zunächst einen Verweis auf Ihr Speicherkonto oder Ihre Dateifreigabe sowie das virtuelle Netzwerk-Subnetz, dem Sie den privaten Endpunkt hinzufügen möchten. Ersetzen Sie die Platzhalterwerte in den folgenden Schritten durch Ihre eigenen Werte.

Rufen Sie für klassische Dateifreigaben einen Verweis auf das Speicherkonto ab:

storageAccountResourceGroupName="<storage-account-resource-group-name>"
storageAccountName="<storage-account-name>"

# Get storage account ID
privateLinkResourceId=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" --output tsv)

# Set common variables for private endpoint creation
resourceGroupName=$storageAccountResourceGroupName
groupId="file"
dnsRecordName=$storageAccountName

Für Dateifreigaben, die mit dem Microsoft.FileShares-Ressourcenanbieter erstellt wurden, rufen Sie einen Verweis auf die Dateifreigabe ab:

# Install the fileshare extension
az extension add --name fileshare

fileShareResourceGroupName="<resource-group-name>"
fileShareName="<file-share-name>"

# Get the file share resource ID and host name
privateLinkResourceId=$(az fileshare show \
        --resource-group $fileShareResourceGroupName \
        --name $fileShareName \
        --query "id" --output tsv)

hostName=$(az fileshare show \
        --resource-group $fileShareResourceGroupName \
        --name $fileShareName \
        --query "properties.hostName" --output tsv)

hostNamePrefix=$(echo $hostName | cut -d'.' -f1)

# Set common variables for private endpoint creation
resourceGroupName=$fileShareResourceGroupName
groupId="FileShare"
dnsRecordName=$hostNamePrefix

Nach dem Festlegen der allgemeinen Variablen sind die verbleibenden Schritte für beide Umgebungen identisch. Rufen Sie Referenzen auf das virtuelle Netzwerk und das Subnetz ab:

virtualNetworkResourceGroupName="<vnet-resource-group-name>"
virtualNetworkName="<vnet-name>"
subnetName="<vnet-subnet-name>"

virtualNetwork=$(az network vnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --name $virtualNetworkName \
        --query "id" --output tsv)

subnet=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "id" --output tsv)

Um einen privaten Endpunkt zu erstellen, stellen Sie sicher, dass die Richtlinie für das private Endpunktnetzwerk des Subnetzes deaktiviert ist, und erstellen Sie dann den privaten Endpunkt mit az network private-endpoint create.

# 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" --output tsv)

# Create a private endpoint
privateEndpoint=$(az network private-endpoint create \
        --resource-group $resourceGroupName \
        --name "$dnsRecordName-PrivateEndpoint" \
        --location $region \
        --subnet $subnet \
        --private-connection-resource-id $privateLinkResourceId \
        --group-id $groupId \
        --connection-name "$dnsRecordName-Connection" \
        --query "id" --output tsv)

Wenn Sie eine Azure private DNS-Zone erstellen, wird der ursprüngliche Hostname in die private IP innerhalb des virtuellen Netzwerks aufgelöst. Obwohl es aus Sicht der Erstellung eines privaten Endpunkts optional ist, ist es erforderlich, um die Azure-Dateifreigabe mit einem AD-Benutzerprinzip zu mounten oder über die FileREST-API zuzugreifen.

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done so the script will work for non-public Azure clouds.
storageAccountSuffix=$(az cloud show \
        --query "suffixes.storageEndpoint" --output tsv)

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

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

dnsZone=""
for possibleDnsZone in $possibleDnsZones
do
    possibleResourceGroupName=$(az resource show \
            --ids $possibleDnsZone \
            --query "resourceGroup" --output tsv)

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

    if [ -n "$link" ]
    then
        dnsZoneResourceGroup=$possibleResourceGroupName
        dnsZone=$possibleDnsZone
        break
    fi
done

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

    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 einen Verweis auf die private DNS-Zone haben, erstellen Sie einen A-Eintrag.

privateEndpointNIC=$(az network private-endpoint show \
        --ids $privateEndpoint \
        --query "networkInterfaces[0].id" --output tsv)

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

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

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

Wenn Sie über einen virtuellen Computer in Ihrem virtuellen Netzwerk verfügen oder die DNS-Weiterleitung wie unter Konfigurieren der DNS-Weiterleitung für Azure Files beschrieben konfiguriert haben, können Sie testen, ob Ihr privater Endpunkt ordnungsgemäß eingerichtet ist. Führen Sie die folgenden Befehle über PowerShell, die Befehlszeile oder das Terminal aus (funktioniert für Windows, Linux oder macOS).

Für klassische Dateifreigaben ersetzen Sie <storage-account-name> durch den Namen des entsprechenden Speicherkontos:

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

Verwenden Sie für Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden, den Hostnamen der Dateifreigabe. Wählen Sie auf der Registerkarte "Übersicht" der Dateifreigabe die JSON-Ansicht oben rechts aus. Kopieren Sie in der JSON-Ansicht unter "Eigenschaften" den Wert für "hostName". Das Format hat die Form fs-xxxxxxxxxxxxxxxxx.xx.file.storage.azure.net.

nslookup <file-share-host-name>

Bei erfolgreicher Ausführung wird die Ausgabe ähnlich wie die folgende angezeigt. Dabei 192.168.0.5 handelt es sich um die private IP-Adresse des privaten Endpunkts in Ihrem virtuellen Netzwerk (Ausgabe für Windows).

Für klassische Dateifreigaben:

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 Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

Server:  UnKnown
Address:  10.2.4.4

Non-authoritative answer:
Name:    <hostNamePrefix>.privatelink.file.core.windows.net
Address:  192.168.0.5
Aliases:  <hostNamePrefix>.<zone>.file.storage.azure.net

Wenn Sie über einen virtuellen Computer in Ihrem virtuellen Netzwerk verfügen oder die DNS-Weiterleitung wie unter Konfigurieren der DNS-Weiterleitung für Azure Files beschrieben konfiguriert haben, können Sie testen, ob Ihr privater Endpunkt ordnungsgemäß eingerichtet ist, indem Sie die folgenden Befehle ausführen:

Für klassische Dateifreigaben:

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

Für Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

 Resolve-DnsName -Name $fileShare.HostName

Bei erfolgreicher Ausführung wird die Ausgabe ähnlich wie die folgende angezeigt. Dabei 192.168.0.5 handelt es sich um die private IP-Adresse des privaten Endpunkts in Ihrem virtuellen Netzwerk.

Für klassische Dateifreigaben:

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 Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

Name                                       Type   TTL   Section    NameHost
----                                       ----   ---   -------    --------
<hostNamePrefix>.<zone>.file.storage.azur  CNAME  60    Answer     <hostNamePrefix>.privatelink.file.core.windows.net
e.net

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

Wenn Sie über einen virtuellen Computer in Ihrem virtuellen Netzwerk verfügen oder die DNS-Weiterleitung wie unter Konfigurieren der DNS-Weiterleitung für Azure Files beschrieben konfiguriert haben, können Sie testen, ob Ihr privater Endpunkt ordnungsgemäß eingerichtet ist, indem Sie die folgenden Befehle ausführen:

Für klassische Dateifreigaben:

httpEndpoint=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "primaryEndpoints.file" --output tsv)

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

Für Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

hostName=$(az fileshare show \
        --resource-group $fileShareResourceGroupName \
        --name $fileShareName \
        --query "properties.hostName" --output tsv)

nslookup $hostName

Bei erfolgreicher Ausführung wird die Ausgabe ähnlich wie die folgende angezeigt. Dabei 192.168.0.5 handelt es sich um die private IP-Adresse des privaten Endpunkts in Ihrem virtuellen Netzwerk. Sie sollten weiterhin den ursprünglichen Hostnamen (storageaccount.file.core.windows.net für die klassische oder hostName für die neue Oberfläche) verwenden, um Ihre Dateifreigabe anstelle des privatelink-Pfads einzubinden.

Für klassische Dateifreigaben:

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

Für Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
<hostNamePrefix>.<zone>.file.storage.azure.net      canonical name = <hostNamePrefix>.privatelink.file.core.windows.net.
Name:   <hostNamePrefix>.privatelink.file.core.windows.net
Address: 192.168.0.5

Um den öffentlichen Netzwerkzugriff für klassische Dateifreigaben zu deaktivieren, folgen Sie diesen Schritten:

1. Gehe zu dem Speicherkonto, bei dem du alle eingehenden Zugriffe auf den öffentlichen Endpunkt einschränken möchtest.
2. Wählen Sie im Dienstmenü unter Sicherheit und Netzwerk die Option Azure-Netzwerk aus.
3. Wählen Sie unter "Öffentlicher Netzwerkzugriff" die Option "Verwalten" aus.
4. Wählen Sie Deaktivieren und dann Fahren aus.
5. Klicken Sie auf Speichern.

Für Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

Wechseln Sie zur Dateifreigabe, in der Sie den öffentlichen Zugriff deaktivieren möchten. Wählen Sie im Dienstmenü unter Einstellungen die Option Konfiguration aus. Legen Sie den Zugriff des öffentlichen Netzwerks auf "Deaktiviert" fest, und wählen Sie dann " Speichern" aus.

Bei klassischen Dateifreigaben blockiert der folgende PowerShell-Befehl jeglichen Datenverkehr zum öffentlichen Endpunkt des Speicherkontos. Legen Sie den Parameter -Bypass auf AzureServices fest, damit vertrauenswürdige First-Party-Dienste wie Azure-Dateisynchronisierung über den öffentlichen Endpunkt auf das Speicherkonto zugreifen können.

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

Bei Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden, muss -PublicNetworkAccess auf Disabled für die Dateifreigabe eingestellt werden.

# To learn more about the Az.FileShare module, see https://www.powershellgallery.com/packages/Az.FileShare/1.0.0
Install-Module -Name Az.FileShare -Repository PSGallery -RequiredVersion 1.0.0

$fileShareResourceGroupName = "<resource-group-name>"
$fileShareName = "<file-share-name>"

Update-AzFileShare `
        -ResourceGroupName $fileShareResourceGroupName `
        -ResourceName $fileShareName `
        -PublicNetworkAccess Disabled

Bei klassischen Dateifreigaben blockiert der folgende CLI-Befehl den gesamten Datenverkehr zum öffentlichen Endpunkt des Speicherkontos. Legen Sie den Parameter --bypass auf AzureServices fest, damit vertrauenswürdige First-Party-Dienste wie Azure-Dateisynchronisierung über den öffentlichen Endpunkt auf das Speicherkonto zugreifen können.

# 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

Bei Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden, muss --public-network-access auf Disabled für die Dateifreigabe eingestellt werden.

# Install the fileshare extension
az extension add --name fileshare

fileShareResourceGroupName="<resource-group-name>"
fileShareName="<file-share-name>"

az fileshare update \
    --name $fileShareName \
    --resource-group $fileShareResourceGroupName \
    --public-network-access Disabled

Für klassische Dateifreigaben folgen Sie diesen Schritten, um den öffentlichen Endpunkt auf bestimmte Netzwerke zu beschränken.

1. Geh zu dem Speicherkonto, bei dem du den öffentlichen Endpunkt auf bestimmte Netzwerke beschränken möchtest.
2. Wählen Sie im Dienstmenü unter Sicherheit und Netzwerk die Option Azure-Netzwerk aus.
3. Wählen Sie unter "Zugriffsbereich für öffentliche Netzwerke" die Option "Aus ausgewählten Netzwerken aktivieren" aus. Diese Auswahl zeigt eine Reihe von Einstellungen zum Steuern der Einschränkung des öffentlichen Endpunkts an.
4. Unter Virtuelle Netzwerke wählen Sie "Hinzufügen eines virtuellen Netzwerks">"Bestehendes virtuelles Netzwerk hinzufügen ", um das virtuelle Netzwerk auszuwählen, das über den öffentlichen Endpunkt auf das Speicherkonto zugreifen darf. Wählen Sie ein virtuelles Netzwerk und ein Subnetz für dieses virtuelle Netzwerk und dann Aktivieren aus. Wenn Sie ein neues virtuelles Netzwerk für diesen Zweck erstellen möchten, wählen Sie "Hinzufügen eines virtuellen Netzwerks>""Neues virtuelles Netzwerk hinzufügen", geben Sie die Details an und wählen Sie dann Erstellen.
5. Unter IPv4-Adressen geben Sie alle öffentlichen Internet-IP-Adressen an, auf die Sie auf das Speicherkonto zugreifen möchten.
6. Wählen Sie das Kästchen "Vertrauenswürdige Microsoft Services zum Zugriff auf diese Ressource erlauben, damit vertrauenswürdige First-Party-Microsoft Services wie Azure-Dateisynchronisierung auf das Speicherkonto zugreifen können.
7. Klicken Sie auf Speichern.

Für Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden:

Wechseln Sie zur Dateifreigabe, in der Sie den öffentlichen Zugriff einschränken möchten. Wählen Sie im Menü "Dienst" unter "Einstellungen" die Option "Konfiguration" aus. Wählen Sie unter Öffentlicher Netzwerkzugriff die Option Aktiviert über ausgewählte virtuelle Netzwerke aus, fügen Sie die virtuellen Netzwerke und Subnetze hinzu, die auf die Freigabe zugreifen dürfen, und wählen Sie Speichern aus.

Beschränken Sie für klassische Dateifreigaben den Zugriff auf den öffentlichen Endpunkt des Speicherkontos auf bestimmte virtuelle Netzwerke mithilfe von Dienstendpunkten. Sammeln Sie zunächst Informationen über das Speicherkonto und das virtuelle Netzwerk. Ersetzen Sie die Platzhalterwerte in den folgenden Schritten durch Ihre eigenen Werte.

$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
}

Um Datenverkehr aus dem virtuellen Netzwerk zuzulassen, muss die Azure Netzwerk fabric den Microsoft.Storage Dienstendpunkt für das Subnetz des virtuellen Netzwerks verfügbar machen. Die folgenden PowerShell-Befehle fügen den Microsoft.Storage-Dienstendpunkt zum Subnetz hinzu, wenn 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 beim Einschränken des Datenverkehrs auf das Speicherkonto besteht darin, eine Netzwerkregel zu erstellen und sie dem Netzwerkregelsatz des Speicherkontos hinzuzufügen.

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

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

Bei Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden, übergeben Sie die zulässigen Subnetzressourcen-IDs direkt an Update-AzFileShare, indem Sie -AllowedSubnet verwenden. Es ist keine separate Konfiguration des Dienstendpunkts oder der Netzwerkregelkonfiguration für das Speicherkonto erforderlich.

# To learn more about the Az.FileShare module, see https://www.powershellgallery.com/packages/Az.FileShare/1.0.0
Install-Module -Name Az.FileShare -Repository PSGallery -RequiredVersion 1.0.0

$fileShareResourceGroupName = "<resource-group-name>"
$fileShareName = "<file-share-name>"
$virtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$virtualNetworkName = "<vnet-name>"
$subnetName = "<subnet-name>"

$subnet = Get-AzVirtualNetwork `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $virtualNetworkName | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

Update-AzFileShare `
        -ResourceGroupName $fileShareResourceGroupName `
        -ResourceName $fileShareName `
        -AllowedSubnet @($subnet.Id)

Beschränken Sie für klassische Dateifreigaben den Zugriff auf den öffentlichen Endpunkt des Speicherkontos auf bestimmte virtuelle Netzwerke mithilfe von Dienstendpunkten. Sammeln Sie zunächst Informationen über das Speicherkonto und das virtuelle Netzwerk. Ersetzen Sie die Platzhalterwerte in den folgenden Schritten durch Ihre eigenen Werte.

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" --output tsv)

virtualNetwork=$(az network vnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --name $restrictToVirtualNetworkName \
        --query "id" --output tsv)

subnet=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "id" --output tsv)

Um Datenverkehr aus dem virtuellen Netzwerk zuzulassen, muss die Azure Netzwerk fabric den Microsoft.Storage Dienstendpunkt für das Subnetz des virtuellen Netzwerks verfügbar machen. Die folgenden CLI-Befehle fügen den Microsoft.Storage-Dienstendpunkt zum Subnetz hinzu, wenn 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 beim Einschränken des Datenverkehrs auf das Speicherkonto besteht darin, eine Netzwerkregel zu erstellen und sie dem Netzwerkregelsatz des Speicherkontos hinzuzufügen.

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

Bei Dateifreigaben, die mit dem Ressourcenanbieter Microsoft.FileShares erstellt wurden, übergeben Sie die zulässigen Subnetzressourcen-IDs direkt an az fileshare update, indem Sie --allowed-subnets verwenden. Es ist keine separate Konfiguration des Dienstendpunkts oder der Netzwerkregelkonfiguration für das Speicherkonto erforderlich.

# Install the fileshare extension
az extension add --name fileshare

fileShareResourceGroupName="<resource-group-name>"
fileShareName="<file-share-name>"
virtualNetworkResourceGroupName="<vnet-resource-group-name>"
virtualNetworkName="<vnet-name>"
subnetName="<subnet-name>"

subnetId=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "id" --output tsv)

az fileshare update \
        --name $fileShareName \
        --resource-group $fileShareResourceGroupName \
        --allowed-subnets $subnetId