Openbare en privénetwerkeindpunten van Azure File Sync configureren

Artikel
06/13/2024

Azure Files en Azure File Sync bieden twee hoofdtypen eindpunten voor toegang tot Azure-bestandsshares:

Openbare eindpunten, die een openbaar IP-adres hebben en overal ter wereld toegankelijk zijn.
Privé-eindpunten, die zich binnen een virtueel netwerk bevinden en een privé-IP-adres hebben in de adresruimte van het virtuele netwerk.

Voor zowel Azure Files als Azure File Sync beheren de Azure-beheerobjecten (het opslagaccount en de opslagsynchronisatieservice) zowel de openbare als de privé-eindpunten. Het opslagaccount is een beheerconstructie die een gedeelde opslaggroep vertegenwoordigt waarin u meerdere bestandsshares kunt implementeren, evenals andere opslagbronnen, zoals blobs of wachtrijen. De opslagsynchronisatieservice is een beheerconstructie die geregistreerde servers vertegenwoordigt, d.w.z. Windows-bestandsservers met een gevestigde vertrouwensrelatie met Azure File Sync, en synchronisatiegroepen, die de topologie van de synchronisatierelatie definiëren.

Dit artikel is gericht op het configureren van de netwerkeindpunten voor zowel Azure Files als Azure File Sync. Zie Azure Files-netwerkeindpunten configureren voor toegang tot Azure-bestandsshares, in plaats van on-premises te cachen met Azure File Sync voor meer informatie over het configureren van netwerkeindpunten voor toegang tot Azure-bestandsshares.

Het is raadzaam azure File Sync-netwerkoverwegingen te lezen voordat u deze handleiding leest.

Vereisten

In dit artikel wordt ervan uitgegaan dat:

U een Azure-abonnement heeft. Als u nog geen abonnement hebt, maakt u een gratis account voordat u begint.
U hebt al een Azure-bestandsshare gemaakt in een opslagaccount waarmee u verbinding wilt maken vanuit on-premises. Zie Een Azure-bestandsshare maken als u wilt lezen hoe u een Azure-bestandsshare maakt.
U staat domeinverkeer toe naar de volgende eindpunten, zie Azure-service-eindpunten:

Bijkomend:

Als u van plan bent om Azure PowerShell te gebruiken, installeert u de nieuwste versie.
Als u van plan bent om de Artikel CLI te gebruiken, installeert u de nieuwste versie.

De privé-eindpunten aanmaken

Wanneer u een privé-eindpunt voor een Azure-resource maakt, worden de volgende resources geïmplementeerd:

Een privé-eindpunt: een Azure-resource die het privé-eindpunt voor het opslagaccount of de opslagsynchronisatieservice vertegenwoordigt. U kunt dit beschouwen als een resource die uw Azure-resource en een netwerkinterface verbindt.
Een netwerkinterface (NIC):de netwerkinterface die een privé-IP-adres onderhoudt binnen het opgegeven virtuele netwerk/subnet. Dit is precies dezelfde resource die wordt geïmplementeerd wanneer u een virtuele machine (VM) implementeert, maar in plaats van te worden toegewezen aan een virtuele machine, is deze eigendom van het privé-eindpunt.
Een privé-DNS-zone: Als u nog nooit een privé-eindpunt voor dit virtuele netwerk hebt geïmplementeerd, wordt er een nieuwe privé-DNS-zone geïmplementeerd voor uw virtuele netwerk. Er wordt ook een DNS A-record gemaakt voor de Azure-resource in deze DNS-zone. Als u al een privé-eindpunt hebt geïmplementeerd in dit virtuele netwerk, wordt er een nieuwe A-record voor de Azure-resource toegevoegd aan de bestaande DNS-zone. Een DNS-zone implementeren is optioneel, maar sterk aanbevolen om het vereiste DNS-beheer te vereenvoudigen.

Notitie

In dit artikel worden de DNS-achtervoegsels voor de openbare Azure-regio's gebruikt, core.windows.net voor opslagaccounts en afs.azure.net voor opslagsynchronisatieservices. Dit is ook van toepassing op Onafhankelijke Azure-clouds, zoals de Azure US Government-cloud. Vervang hiervoor alleen de juiste achtervoegsels voor uw omgeving.

De privé-eindpunt voor opslagaccounts maken

Ga naar het opslagaccount waarvoor u een privé-eindpunt wilt maken. Selecteer in de inhoudsopgave voor het opslagaccount netwerken, privé-eindpuntverbindingen en vervolgens + privé-eindpunt om een nieuw privé-eindpunt te maken.

Er wordt een wizard gestart waarin u meerdere pagina's moet invullen.

Selecteer op de blade Basisinformatie het gewenste abonnement, de resourcegroep, de naam, de netwerkinterfacenaam en de regio voor uw privé-eindpunt. U kunt hier kiezen wat u wilt. De waarden hoeven niet overeen te komen met die van het opslagaccount. U moet het privé-eindpunt wel maken in dezelfde regio als het virtuele netwerk waarin u het privé-eindpunt wilt maken. Selecteer vervolgens Volgende: Resource.

Selecteer op de blade Resource het bestand voor de doelsubresource. Selecteer vervolgens Volgende: Virtueel netwerk.

Met de blade Virtueel netwerk kunt u het specifieke virtuele netwerk en subnet selecteren waaraan u uw privé-eindpunt wilt toevoegen. Selecteer dynamische of statische IP-adrestoewijzing voor het nieuwe privé-eindpunt. Als u statisch selecteert, moet u ook een naam en een privé-IP-adres opgeven. U kunt eventueel ook een toepassingsbeveiligingsgroep opgeven. Wanneer u klaar bent, selecteert u Volgende: DNS.

De BLADE DNS bevat de informatie voor het integreren van uw privé-eindpunt met een privé-DNS-zone. Zorg ervoor dat het abonnement en de resourcegroep juist zijn en selecteer vervolgens Volgende: Tags.

U kunt eventueel tags toepassen om uw resources te categoriseren, zoals het toepassen van de naamomgeving en de waarde Testen op alle testbronnen. Voer desgewenst naam-/waardeparen in en selecteer vervolgens Volgende: Beoordelen en maken.

Klik op Beoordelen en maken om het privé-eindpunt te maken.

Als u een VIRTUELE machine in uw virtuele netwerk hebt of als u DNS-doorsturen hebt geconfigureerd zoals beschreven in Dns-doorsturen configureren voor Azure Files, kunt u testen of uw privé-eindpunt correct is ingesteld door de volgende opdrachten uit te voeren vanuit PowerShell, de opdrachtregel of de terminal (werkt voor Windows, Linux of macOS). U moet <storage-account-name> door de juiste naam van het opslagaccount:

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

Als alles goed werkt, ziet u de volgende uitvoer, waarbij 192.168.0.5 het privé-IP-adres van het privé-eindpunt in uw virtuele netwerk is (uitvoer weergegeven voor Windows):

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

Als u een privé-eindpunt wilt maken voor uw opslagaccount, moet u eerst een verwijzing naar uw opslagaccount opvragen, evenals naar het subnet in het virtuele netwerk waaraan u het privé-eindpunt wilt toevoegen. Vervang <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> en <vnet-subnet-name> hieronder:

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

Als u een privé-eindpunt wilt maken, moet u een Private Link-serviceverbinding maken met het opslagaccount. Deze verbinding geeft u op als invoer bij het maken van het privé-eindpunt.

# 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

Door het maken van een privé-DNS-zone in Azure kan de oorspronkelijke naam van het opslagaccount, zoals storageaccount.file.core.windows.net, worden omgezet in het privé-IP-adres in het virtuele netwerk. Hoewel optioneel vanuit het perspectief van het maken van een privé-eindpunt, is dit expliciet vereist voor het rechtstreeks koppelen van de Azure-bestandsshare met behulp van een AD-principal van een gebruiker of de REST-API.

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

U beschikt nu over een verwijzing naar de privé-DNS-zone en kunt daarom een A-record gaan maken voor uw opslagaccount.

$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

Als u een VIRTUELE machine in uw virtuele netwerk hebt of als u DNS-doorsturen hebt geconfigureerd zoals beschreven in DNS-doorsturen configureren voor Azure Files, kunt u testen of uw privé-eindpunt correct is ingesteld met de volgende opdrachten:

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

Resolve-DnsName -Name $storageAccountHostName

Als alles goed werkt, ziet u de volgende uitvoer, waarbij 192.168.0.5 het privé-IP-adres van het privé-eindpunt zich in uw virtuele netwerk bevindt:

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

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 '"')

Als u een privé-eindpunt wilt maken, moet u er eerst voor zorgen dat het netwerkbeleid voor het privé-eindpunt van het subnet is uitgeschakeld. Vervolgens kunt u een privé-eindpunt maken met de opdracht 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" | \
    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 '"')

Door het maken van een privé-DNS-zone in Azure kan de oorspronkelijke naam van het opslagaccount, zoals storageaccount.file.core.windows.net, worden omgezet in het privé-IP-adres in het virtuele netwerk. Hoewel optioneel vanuit het perspectief van het maken van een privé-eindpunt, is dit expliciet vereist voor het koppelen van de Azure-bestandsshare met behulp van een AD-principal van een gebruiker of de REST-API.

# 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

U beschikt nu over een verwijzing naar de privé-DNS-zone en kunt daarom een A-record gaan maken voor uw opslagaccount.

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

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

Als alles goed werkt, ziet u de volgende uitvoer, waarbij 192.168.0.5 het privé-IP-adres van het privé-eindpunt zich in uw virtuele netwerk bevindt:

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

Het privé-eindpunt van de opslagsynchronisatieservice maken

Ga naar het Private Link-centrum door Private Link te typen in de zoekbalk bovenaan het Azure-portal. Selecteer Privé-eindpunten in de inhoudsopgave van het Private Link-centrum en selecteer vervolgens + Toevoegen om een nieuw privé-eindpunt te maken.

Er wordt een wizard gestart waarin u meerdere pagina's moet invullen.

Selecteer op de blade Algemeen de gewenste resourcegroep, geef een naam op en selecteer de regio voor het privé-eindpunt. U kunt hier kiezen wat u wilt. De waarden hoeven niet overeen te komen met die van de opslagsynchronisatieservice. Het is wel zo dat u het privé-eindpunt moet maken in dezelfde regio als het virtuele netwerk waarin u het privé-eindpunt wilt maken.

Een schermopname van de blade Algemeen in de sectie Een privé-eindpunt maken

Schakel op de blade Resource het keuzerondje Verbinding maken met een Azure-resource in mijn directory in. Selecteer Microsoft.StorageSync/storageSyncServices als resourcetype onder Resourcetype.

Op de blade Configuratie kunt u het specifieke virtuele netwerk en het subnet selecteren waaraan u het privé-eindpunt wilt toevoegen. Selecteer het virtuele netwerk dat u hebt gebruikt voor het opslagaccount hierboven. De blade Configuratie bevat ook de gegevens voor het maken/bijwerken van de privé-DNS-zone.

Selecteer Beoordelen en maken om het privé-eindpunt te maken.

U kunt testen of uw privé-eindpunt correct is ingesteld door de volgende PowerShell-opdrachten uit te voeren.

$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

Als alles correct werkt, ziet u de volgende uitvoer waarbij 192.168.1.4, 192.168.1.5192.168.1.6en 192.168.1.7 zijn de privé-IP-adressen die zijn toegewezen aan het privé-eindpunt:

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

Als u een privé-eindpunt voor uw opslagsynchronisatieservice wilt maken, moet u eerst een verwijzing naar uw opslagsynchronisatieservice krijgen. Vergeet niet om <storage-sync-service-resource-group> en <storage-sync-service> te vervangen door de correcte waarden voor uw omgeving. Bij de volgende PowerShell-opdrachten wordt ervan uitgegaan dat u de gegevens van het virtuele netwerk al hebt ingevuld.

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

Als u een privé-eindpunt wilt maken, moet u een Private Link-serviceverbinding maken met de opslagsynchronisatieservice. Deze verbinding geeft u op als invoer bij het maken van het privé-eindpunt.

# 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

Door een Azure privé-DNS-zone te maken kunnen de hostnamen voor de opslagsynchronisatieservice, zoals mysssmanagement.westus2.afs.azure.net, worden omgezet naar de correcte privé-IP-adressen voor de opslagsynchronisatieservice in het virtueel netwerk. Hoewel dit optioneel is vanuit het perspectief van het maken van een privé-eindpunt, is het expliciet vereist dat de Azure File Sync-agent toegang heeft tot de opslagsynchronisatieservice.

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

Nu u een verwijzing naar de privé-DNS-zone hebt, moet u een A-record maken voor uw opslagsynchronisatieservice.

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

Als u een privé-eindpunt voor uw opslagsynchronisatieservice wilt maken, moet u eerst een verwijzing naar uw opslagsynchronisatieservice krijgen. Vergeet niet om <storage-sync-service-resource-group> en <storage-sync-service> te vervangen door de correcte waarden voor uw omgeving. Bij de volgende CLI-opdrachten wordt ervan uitgegaan dat u de gegevens van het virtuele netwerk al hebt ingevuld.

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 '"')

# 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 '"')

# 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:
# privatelinke.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

Nu u een verwijzing naar de privé-DNS-zone hebt, moet u een A-record maken voor uw opslagsynchronisatieservice.

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

Toegang tot de openbare eindpunten beperken

U kunt de toegang tot de openbare eindpunten van zowel het opslagaccount als de opslagsynchronisatieservices beperken. Het beperken van de toegang tot het openbare eindpunt biedt extra beveiliging door ervoor te zorgen dat netwerkpakketten alleen worden geaccepteerd vanaf goedgekeurde locaties.

Toegang tot het openbare eindpunt van het opslagaccount beperken

U kunt de toegang tot het openbare eindpunt beperken via de firewallinstellingen voor het opslagaccount. Over het algemeen beperken de meeste beleidsregels van firewalls voor een opslagaccount de netwerktoegang tot een of meer virtuele netwerken. Er zijn twee benaderingen voor het beperken van de toegang van een opslagaccount tot een virtueel netwerk:

Een of meer privé-eindpunten maken voor het opslagaccount en alle toegang tot het openbare eindpunt uitschakelen. Hierdoor heeft alleen verkeer dat afkomstig is uit de gewenste virtuele netwerken toegang tot de Azure-bestandsshares binnen het opslagaccount.
Het openbare eindpunt beperken tot een of meer virtuele netwerken. Hiervoor wordt een voorziening van het virtuele netwerk gebruikt met de naam service-eindpunten. Wanneer u het verkeer naar een opslagaccount beperkt via een service-eindpunt, hebt u nog steeds toegang tot het opslagaccount via het openbare IP-adres.

Notitie

De lijst Azure-services toestaan in de lijst met vertrouwde services voor toegang tot deze opslagaccount-uitzondering moet worden geselecteerd in uw opslagaccount om vertrouwde first party-Microsoft-services, zoals Azure File Sync, toegang te geven tot het opslagaccount. Zie Toegang verlenen tot vertrouwde Azure-services voor meer informatie.

Toegang verlenen tot vertrouwde Azure-services en toegang tot het openbare eindpunt van het opslagaccount uitschakelen

Wanneer alle toegang tot het openbare eindpunt wordt uitgeschakeld, is het opslagaccount nog toegankelijk via de privé-eindpunten van het account. Anderszins geldige aanvragen naar het openbare eindpunt van het opslagaccount worden geweigerd.

Ga naar het opslagaccount waarvoor u alle toegang tot het openbare eindpunt wilt beperken. Selecteer Netwerken in de inhoudsopgave voor het opslagaccount.

Selecteer boven aan de pagina het keuzerondje Ingeschakeld in geselecteerde virtuele netwerken en IP-adressen . Hierdoor komen er een aantal instellingen beschikbaar voor het beperken van de toegang tot het openbare eindpunt. Selecteer Azure-services toestaan in de lijst met vertrouwde services om toegang te krijgen tot dit opslagaccount om vertrouwde first party-Microsoft-services zoals Azure File Sync toegang te geven tot het opslagaccount.

Met de volgende PowerShell-opdracht wordt al het verkeer geweigerd naar het openbare eindpunt van het opslagaccount. In deze opdracht is de parameter -Bypass ingesteld op AzureServices. Hierdoor kunnen vertrouwde Microsoft-services, zoals Azure File Sync, via het openbare eindpunt toegang krijgen tot het opslagaccount.

# 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

Met de volgende CLI-opdracht wordt al het verkeer geweigerd naar het openbare eindpunt van het opslagaccount. In deze opdracht is de parameter -bypass ingesteld op AzureServices. Hierdoor kunnen vertrouwde Microsoft-services, zoals Azure File Sync, via het openbare eindpunt toegang krijgen tot het opslagaccount.

# 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

Toegang verlenen tot vertrouwde Azure-services en de toegang tot het openbare eindpunt van het opslagaccount beperken tot specifieke virtuele netwerken

Wanneer u het opslagaccount beperkt tot specifieke virtuele netwerken, kunt u aanvragen naar het openbare eindpunt toestaan vanuit de opgegeven virtuele netwerken. Hiervoor wordt een voorziening van het virtuele netwerk gebruikt met de naam service-eindpunten. Deze voorziening kan worden gebruikt met of zonder privé-eindpunten.

Ga naar het opslagaccount waarvoor u het openbare eindpunt wilt beperken tot bepaalde virtuele netwerken. Selecteer Netwerken in de inhoudsopgave voor het opslagaccount.

Selecteer boven aan de pagina het keuzerondje Ingeschakeld in geselecteerde virtuele netwerken en IP-adressen . Hierdoor komen er een aantal instellingen beschikbaar voor het beperken van de toegang tot het openbare eindpunt. Selecteer +Bestaand virtueel netwerk toevoegen om het specifieke virtuele netwerk te selecteren dat toegang moet hebben tot het opslagaccount via het openbare eindpunt. Selecteer een virtueel netwerk en een subnet voor dat virtuele netwerk en selecteer vervolgens Inschakelen.

Selecteer Azure-services toestaan in de lijst met vertrouwde services om toegang te krijgen tot dit opslagaccount om vertrouwde first party-Microsoft-services zoals Azure File Sync toegang te geven tot het opslagaccount.

Om de toegang tot het openbare eindpunt van het opslagaccount met behulp van service-eindpunten te beperken tot specifieke virtuele netwerken, moeten we eerst gegevens verzamelen van het opslagaccount en het virtuele netwerk. Geef waarden op voor <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> en <subnet-name> om deze gegevens te verzamelen.

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

Om verkeer vanuit het virtuele netwerk via de netwerkinfrastructuur van Azure door te laten naar het openbare eindpunt van het opslagaccount, moet het service-eindpunt Microsoft.Storage beschikbaar zijn in het subnet van het virtuele netwerk. Met de volgende PowerShell-opdrachten wordt het Microsoft.Storage service-eindpunt toegevoegd aan het subnet als dit nog niet is gebeurd.

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

De laatste stap om verkeer naar het opslagaccount te beperken, is het opstellen van een netwerkregel en die toe te voegen aan de set met netwerkregels voor het opslagaccount.

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

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

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 '"')

Om verkeer vanuit het virtuele netwerk via de netwerkinfrastructuur van Azure door te laten naar het openbare eindpunt van het opslagaccount, moet het service-eindpunt Microsoft.Storage beschikbaar zijn in het subnet van het virtuele netwerk. Met de volgende CLI-opdrachten wordt het Microsoft.Storage service-eindpunt toegevoegd aan het subnet als dit nog niet is gebeurd.

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

De laatste stap om verkeer naar het opslagaccount te beperken, is het opstellen van een netwerkregel en die toe te voegen aan de set met netwerkregels voor het opslagaccount.

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

Toegang tot het openbare eindpunt van de opslagsynchronisatieservice uitschakelen

Met Azure File Sync kunt u alleen de toegang tot specifieke virtuele netwerken beperken via privé-eindpunten; Azure File Sync biedt geen ondersteuning voor service-eindpunten voor het beperken van de toegang tot het openbare eindpunt tot specifieke virtuele netwerken. Dit betekent dat de twee statussen voor het openbare eindpunt van de opslagsynchronisatieservice zijn ingeschakeld en uitgeschakeld.

Belangrijk

U moet een privé-eindpunt maken voordat u de toegang tot het openbare eindpunt uitschakelt. Als het openbare eindpunt is uitgeschakeld en er geen privé-eindpunt is geconfigureerd, kan synchronisatie niet werken.

Voer de volgende stappen uit om de toegang tot het openbare eindpunt van de opslagsynchronisatieservice uit te schakelen:

Meld u aan bij het Azure-portaal.
Navigeer naar de opslagsynchronisatieservice en selecteer Instellingennetwerk> in de linkernavigatiebalk.
Selecteer onder Toegang toestaan alleen privé-eindpunten.
Selecteer een privé-eindpunt in de lijst met privé-eindpuntverbindingen .

Als u de toegang tot het openbare eindpunt van de opslagsynchronisatieservice wilt uitschakelen, stelt u de incomingTrafficPolicy eigenschap in op de opslagsynchronisatieservice op AllowVirtualNetworksOnly. Als u toegang tot het openbare eindpunt van de opslagsynchronisatieservice wilt inschakelen, stelt u in plaats daarvan in incomingTrafficPolicy AllowAllTraffic . Vergeet niet om uw eigen waarden te vervangen en <storage-sync-service> te vervangen<storage-sync-service-resource-group>.

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

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

Azure Policy

Azure Policy helpt bij het afdwingen van organisatiestandaarden en het beoordelen van naleving van deze standaarden op schaal. Azure Files en Azure File Sync bieden verschillende nuttige controle- en herstelnetwerkbeleidsregels waarmee u uw implementatie kunt bewaken en automatiseren.

Beleid controleert uw omgeving en waarschuwt u als uw opslagaccounts of Opslagsynchronisatieservices afwijken van het gedefinieerde gedrag. Als een openbaar eindpunt bijvoorbeeld is ingeschakeld wanneer uw beleid is ingesteld op het uitschakelen van de openbare eindpunten. Het wijzigen/implementeren van beleidsregels neemt een stap verder en wijzigt proactief een resource (zoals de opslagsynchronisatieservice) of implementeer resources (zoals privé-eindpunten) om te worden afgestemd op het beleid.

De volgende vooraf gedefinieerde beleidsregels zijn beschikbaar voor Azure Files en Azure File Sync:

Actie	Service	Conditie	Beleidsnaam
Audit	Azure Files	Het openbare eindpunt van het opslagaccount is ingeschakeld. Zie Toegang verlenen tot vertrouwde Azure-services en toegang tot het openbare eindpunt van het opslagaccount uitschakelen voor meer informatie.	Netwerktoegang tot opslagaccounts moet zijn beperkt
Audit	Azure File Sync	Het openbare eindpunt van de opslagsynchronisatieservice is ingeschakeld. Zie Toegang tot het openbare eindpunt van de opslagsynchronisatieservice uitschakelen voor meer informatie.	Openbare netwerktoegang moet zijn uitgeschakeld voor Azure File Sync
Audit	Azure Files	Het opslagaccount heeft ten minste één privé-eindpunt nodig. Zie Het privé-eindpunt voor het opslagaccount maken voor meer informatie.	Voor een opslagaccount moet een verbinding via een privékoppeling worden gebruikt
Audit	Azure File Sync	De opslagsynchronisatieservice heeft ten minste één privé-eindpunt nodig. Zie Het privé-eindpunt van de opslagsynchronisatieservice maken voor meer informatie.	Azure File Sync moet gebruikmaken van private link
Wijzigen	Azure File Sync	Schakel het openbare eindpunt van de opslagsynchronisatieservice uit.	Wijzigen - Azure File Sync configureren om openbare netwerktoegang uit te schakelen
Implementeren	Azure File Sync	Implementeer een privé-eindpunt voor de opslagsynchronisatieservice.	Azure File Sync configureren met privé-eindpunten
Implementeren	Azure File Sync	Een A-record implementeren in privatelink.afs.azure.net DNS-zone.	Azure File Sync configureren voor het gebruik van privé-DNS-zones

Een implementatiebeleid voor privé-eindpunten instellen

Als u een implementatiebeleid voor privé-eindpunten wilt instellen, gaat u naar Azure Portal en zoekt u naar Beleid. Het Azure Policy-centrum moet een topresultaat zijn. Navigeer naar Ontwerpdefinities>in de inhoudsopgave van het beleidscentrum. Het deelvenster Definities bevat het vooraf gedefinieerde beleid voor alle Azure-services. Als u het specifieke beleid wilt vinden, selecteert u de categorie Opslag in het categoriefilter of zoekt u naar Azure File Sync configureren met privé-eindpunten. Selecteer ... en Wijs toe om een nieuw beleid te maken op basis van de definitie.

Met de blade Basisbeginselen van de wizard Beleid toewijzen kunt u een bereik, resource- of resourcegroepuitsluitingslijst instellen en uw beleid een beschrijvende naam geven om deze te onderscheiden. U hoeft deze niet te wijzigen zodat het beleid werkt, maar als u wijzigingen wilt aanbrengen. Selecteer Volgende om naar de pagina Parameters te gaan.

Selecteer op de blade Parameters de ... naast de vervolgkeuzelijst privateEndpointSubnetId om het virtuele netwerk en subnet te selecteren waarin de privé-eindpunten voor uw opslagsynchronisatieservice-resources moeten worden geïmplementeerd. Het kan enkele seconden duren voordat de resulterende wizard de beschikbare virtuele netwerken in uw abonnement laadt. Selecteer het juiste virtuele netwerk/subnet voor uw omgeving en klik op Selecteren. Selecteer Volgende om naar de blade Herstel te gaan.

Als u wilt dat het privé-eindpunt wordt geïmplementeerd wanneer een opslagsynchronisatieservice zonder een privé-eindpunt wordt geïdentificeerd, moet u de hersteltaak maken selecteren op de pagina Herstel . Selecteer Ten slotte Beoordelen en maken om de beleidstoewijzing te controleren en Maken om deze te maken.

De resulterende beleidstoewijzing wordt periodiek uitgevoerd en wordt mogelijk niet onmiddellijk na het maken uitgevoerd.

Share via