Azure File Sync-netwerkeindpunten configureren

Azure File Sync gebruikt twee Azure-resources, elk met eigen netwerkeindpunten: het opslagaccount (dat de Azure-bestandsdeling bevat) en de Storage Sync Service (die synchronisatie, serverregistratie en synchronisatiegroepen coördineert). Beide bronnen gebruiken standaard publieke eindpunten.

De Azure File Sync-agent communiceert met beide bronnen via HTTPS (poort 443). Voor servers die via het internet verbinding maken met Azure zonder VPN of ExpressRoute, kun je het publieke eindpunt gebruiken en is er geen configuratie nodig. De meeste Azure File Sync-klanten willen echter privé-endpoints configureren.

Gebruik de volgende tabel om te bepalen of je private endpoints nodig hebt. Als je ze nodig hebt, maak dan privé-endpoints aan voor beide resources.

Ik moet...	Gebruik
Synchroniseer servers die via het internet verbinding maken met Azure zonder VPN of ExpressRoute	Publieke eindpunten (geen configuratie nodig)
Leid al het synchronisatieverkeer via ExpressRoute of site-to-site VPN-verbinding	Privé-eindpunten voor beide bronnen
Voldoe aan compliance-eisen die gegevensoverdracht via het openbare internet verbieden	Privé-eindpunten voor beide bronnen
Schakel het publieke eindpunt uit als beveiligingsverstevigingsmaatregel	Eerst privé-endpoints voor beide bronnen, daarna de toegang beperken
Implementeer zero-trust netwerktoegang	Privé-eindpunten voor beide bronnen

Voor bredere netwerkconcepten, zie Azure File Sync netwerkoverwegingen. Om endpoints te configureren voor directe toegang tot Azure file shares (zonder Azure File Sync), zie Configure Azure Files network endpoints.

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.
Je hebt een SMB Azure Classic file share aangemaakt in een opslagaccount waarmee je vanuit on-premises verbinding wilt maken. Om te leren hoe je een Azure classic file share maakt, zie Create an Azure classic file share.
Je firewall maakt de benodigde domeinen voor communicatie mogelijk. Zie Azure File Sync firewall instellingen.

Bijkomend:

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

De privé-eindpunten aanmaken

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

Geïmplementeerde resource	Description	Wat u doet
Privé-eindpunt	Een Azure-bron die je opslagaccount of Storage Sync Service verbindt met een netwerkinterface in je virtuele netwerk	Maak er voor elke resource één in Het privé-eindpunt voor het opslagaccount maken en Het privé-eindpunt voor de Storage Sync Service maken
netwerkinterface (NIC)	Bevat het privé-IP-adres van het privé-eindpunt binnen je subnet	Automatisch aangemaakt met het privé-eindpunt; Geen extra actie nodig
Privé-DNS-zone	Koppelt de publieke hostnaam van de bron aan het IP-adres van het privé-eindpunt, zodat clients worden omgezet naar het privé-eindpunt zonder verbindingsreeksen te wijzigen	Automatisch aangemaakt als er geen bestaat; wordt aanbevolen om handmatige DNS-configuratie te vermijden

Notitie

Dit artikel gebruikt de DNS-achtervoegsels voor de Azure Public regio's: core.windows.net voor opslagaccounts en afs.azure.net voor Storage Sync Services. Deze nomenclatuur geldt ook voor Azure Sovereign-clouds zoals de Azure US Government-cloud. Vervang gewoon de juiste achtervoegsels voor uw omgeving.

Maak het private eindpunt voor het storageaccount aan

Ga naar het opslagaccount waarvoor u een privé-eindpunt wilt maken. Selecteer in het servicemenu onder Beveiliging en netwerken de optie Netwerken, Privé-eindpuntverbindingen en vervolgens + Privé-eindpunt om een nieuw privé-eindpunt te maken.

De resulterende wizard bevat meerdere pagina's die compleet moeten worden ingevuld.

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. Klik op Vervolgens: Resource.

Selecteer op de blade Resource het bestand voor de doelsubresource. Selecteer 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 DNS-blade bevat de informatie voor het integreren van uw private eindpunt met een private DNS-zone. Zorg ervoor dat het abonnement en de resource-groep juist zijn en selecteer vervolgens Volgende: Tags.

U kunt eventueel tags toepassen om uw resources te categoriseren, zoals door de naam Omgeving en de waarde Test toe te passen op alle testen. Voer desgewenst naam-/waardeparen in en selecteer vervolgens Volgende: Beoordelen en maken.

Selecteer Maken om het privé-eindpunt te maken.

Als je een VM hebt in je virtuele netwerk, of DNS forwarding hebt geconfigureerd zoals beschreven in Configuring DNS forwarding for Azure Files, kun je testen of je privé-endpoint correct is ingesteld door de volgende commando's uit te voeren vanuit PowerShell, de opdrachtregel of de terminal (werkt voor Windows, Linux of macOS). Vervang <storage-account-name> het door de naam van je 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. De privé-link serviceverbinding wordt gebruikt 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 het optioneel is vanuit het oogpunt van het creëren van een privé-eindpunt, is dit expliciet vereist voor het direct mounten van de Azure-bestandsshare met behulp van een AD-gebruikersaccount of toegang via 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 je een VM hebt binnen je virtuele netwerk, of je hebt DNS-forwarding geconfigureerd zoals beschreven in Configure DNS forwarding for Azure Files, kun je testen of je private endpoint correct is ingesteld met de volgende commando's:

$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 Center door Private Link in de zoekbalk bovenaan het Azure-portaal te typen. Selecteer in de inhoudsopgave van het Private Link Center Private endpoints en selecteer vervolgens + Add om een nieuw privé-endpoint aan te maken.

De resulterende wizard bevat meerdere pagina's die compleet moeten worden ingevuld.

Selecteer in het tabblad Basics de resourcegroep, naam en regio voor je privé-endpoint. Deze waarden kunnen elke geldige waarde zijn. Ze hoeven op geen enkele manier overeen te komen met de Storage Sync Service, maar je moet wel het privé-eindpunt aanmaken in dezelfde regio als het virtuele netwerk dat je kiest.

Een screenshot van het gedeelte Basis in de sectie Privé-eindpunt maken

Selecteer Op het tabblad Resource verbinding maken met een Azure-resource in mijn directory. Selecteer onder het resourcetypeMicrosoft.StorageSync/storageSyncServices.

Het tabblad Configuratie stelt je in staat het specifieke virtuele netwerk en subnet te selecteren waaraan je je privé-endpoint wilt toevoegen. Selecteer hetzelfde virtuele netwerk als het netwerk dat je voor het opslagaccount hebt gebruikt. Het tabblad Configuratie bevat ook de informatie voor het aanmaken en updaten van de private 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

Om een privé-endpoint voor je Storage Sync Service te maken, haal je eerst een referentie naar je Storage Sync Service. Vervang <storage-sync-service-resource-group> en <storage-sync-service> door de correcte waarden voor uw omgeving. De volgende PowerShell-commando's gaan ervan uit dat je de virtuele netwerkinformatie 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 wordt als invoer gebruikt bij het maken van een private endpoint.

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

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
}

Om een privé-endpoint voor je Storage Sync Service te maken, haal je eerst een referentie naar je Storage Sync Service. Vervang <storage-sync-service-resource-group> en <storage-sync-service> door de correcte waarden voor uw omgeving. De volgende CLI-commando's gaan ervan uit dat je de virtuele netwerkinformatie 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 '"')

Om een privé-endpoint te creëren, zorg je er eerst voor dat het private endpoint-netwerkbeleid van het subnet op uitgeschakeld staat. Maak vervolgens een privé-endpoint aan met het az network private-endpoint create commando.

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

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

Je kunt de toegang tot het publieke eindpunt beperken door gebruik te maken van de firewall-instellingen van het opslagaccount. Over het algemeen beperken de meeste firewallbeleidsregels voor een opslagaccount netwerktoegang tot een of meer virtuele netwerken. Gebruik een van de volgende methoden om de toegang tot een opslagaccount tot een virtueel netwerk te beperken:

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. Deze aanpak werkt door gebruik te maken van een capaciteit van het virtuele netwerk, genaamd service endpoints. Wanneer je het verkeer beperkt tot een opslagaccount via een service-endpoint, heb je nog steeds toegang tot het opslagaccount via het publieke IP-adres.

Notitie

Om vertrouwde first-party Microsoft-services zoals Azure File Sync toegang te geven tot het opslagaccount, selecteer je het selectievakje 'Allow trusted Microsoft-services to access this resource in je opslagaccount. Voor meer informatie, zie Beperk de toegang tot het publieke eindpunt tot specifieke netwerken.

Belangrijk

Azure File Sync heeft een bekende beperking met netwerkbeveiligingsperimeter (NSP). Opslagsynchronisatieservices kunnen niet binnen een perimeter worden geplaatst en volledige perimeterintegratie wordt niet ondersteund.

Een opslagsynchronisatieservice verbinden met een opslagaccount dat wordt beveiligd door een NSP:

Configureer de opslagsynchronisatieservice voor het gebruik van beheerde identiteiten.
Maak een inkomende netwerkbeveiligingsprofielregel waarmee het abonnement dat als host fungeert voor de opslagsynchronisatieservice, wordt toegestaan.

Opslagsynchronisatieservices moeten buiten de perimeter blijven zodat synchronisatie correct werkt.

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

Wanneer je de toegang tot het publieke eindpunt uitschakelt, kun je nog steeds toegang krijgen tot het opslagaccount via het privé-eindpunt, maar verzoeken naar het publieke 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 bovenaan de pagina het keuzerondvakje Ingeschakeld in geselecteerde virtuele netwerken en IP-adressen. Hierdoor worden een aantal instellingen zichtbaar voor het beheersen van de beperking van 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 bovenaan de pagina het keuzerondvakje Ingeschakeld in geselecteerde virtuele netwerken en IP-adressen. Hierdoor worden een aantal instellingen zichtbaar voor het beheersen van de beperking van 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.
Ga naar de Storage Sync Service en selecteer Instellingen>Netwerk vanuit de linker navigatie.
Onder Toegang toestaan vanaf, selecteer alleen privé-eindpunten.
Selecteer een privé-eindpunt in de lijst met privé-eindpuntverbindingen .

Om toegang tot het publieke eindpunt van de Storage Sync Service uit te schakelen, zet u de incomingTrafficPolicy eigenschap op de Storage Sync Service op AllowVirtualNetworksOnly. Om toegang tot het openbare eindpunt van de Storage Sync Service mogelijk te maken, stelt u incomingTrafficPolicy in op AllowAllTraffic. Vervang <storage-sync-service-resource-group> en <storage-sync-service> door uw eigen waarden.

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

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

Azure Policy voor Azure Files en Azure File Sync

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. Het beleid waarschuwt je bijvoorbeeld als een openbaar eindpunt is ingeschakeld terwijl je beleid is ingesteld om de publieke eindpunten uit te schakelen. Beleidsregels van het type Wijzigen en Implementeren kunnen proactief een resource (zoals de Storage Sync Service) aanpassen of resources (zoals privé-eindpunten) implementeren, zodat deze aan het beleid voldoen.

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

Actie	Dienst	Conditie	Beleidsnaam
Controle	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
Controle	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
Controle	Azure Files	Het opslagaccount heeft ten minste één privé-eindpunt nodig. Zie Het privé-eindpunt voor het opslagaccount maken voor meer informatie.	Een opslagaccount moet een verbinding via een privékoppeling gebruiken.
Controle	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

Om een beleid voor de uitrol van een privé-endpoint op te zetten, volgt u deze stappen:

Log in op het Azure-portaal en zoek naar Beleid. Selecteer beleid uit de resultaten.
Ga naar Authoring>Definitions in de inhoudsopgave van het Policy Center.
Selecteer in het Definities-paneel de categorie Opslag in het categoriefilter, of zoek naar Configure Azure File Sync with private endpoints.
Selecteer ... naast het beleid en selecteer dan Toewijzen.
Op de pagina Basisprincipes kun je optioneel een scope, uitsluitingslijst en een vriendelijke naam voor het beleid instellen. Kies Volgende.
Selecteer op de pagina Parameters... naast het privateEndpointSubnetId-veld . Selecteer het virtuele netwerk en subnet waar de privé-eindpunten voor je Storage Sync Service-resources moeten worden uitgerold. De wizard kan enkele seconden nodig hebben om beschikbare virtuele netwerken te laden. Kies Volgende.
Selecteer op de pagina RemediationEen hersteltaak maken, zodat het privé-eindpunt wordt geïmplementeerd wanneer een Storage Sync Service zonder privé-eindpunt wordt gedetecteerd.
Selecteer Beoordelen + creëren om de beleidsopdracht te bekijken, en selecteer vervolgens Aanmaken.

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

Zie ook

Feedback

Is deze pagina nuttig?

Last updated on 2026-07-24