Configurare Sincronizzazione file di Azure endpoint di rete pubblici e privati

Articolo
06/05/2024

File di Azure e Sincronizzazione file di Azure prevedono due tipi principali di endpoint per l'accesso alle condivisioni file di Azure:

Endpoint pubblici, che hanno un indirizzo IP pubblico e sono accessibili da qualsiasi parte del mondo.
Endpoint privati, presenti all'interno di una rete virtuale, che hanno un indirizzo IP privato all'interno dello spazio di indirizzi della rete virtuale.

Sia per File di Azure che per Sincronizzazione file di Azure, gli oggetti di gestione di Azure (l'account di archiviazione e il servizio di sincronizzazione archiviazione) controllano sia gli endpoint pubblici che privati. L'account di archiviazione è un costrutto di gestione che rappresenta un pool condiviso di archiviazione in cui è possibile distribuire più condivisioni file, nonché altre risorse di archiviazione, ad esempio BLOB o code. Il servizio di sincronizzazione archiviazione è un costrutto di gestione che rappresenta i server registrati, ovvero file server Windows con una relazione di trust stabilita con Sincronizzazione file di Azure, e i gruppi di sincronizzazione, che definiscono la topologia della relazione di sincronizzazione.

Questo articolo illustra come configurare gli endpoint di rete per File di Azure e Sincronizzazione file di Azure. Per altre informazioni su come configurare gli endpoint di rete per l'accesso diretto alle condivisioni file di Azure, anziché memorizzare nella cache locale con Sincronizzazione file di Azure, vedere Configurazione degli endpoint di rete File di Azure.

È consigliabile leggere Sincronizzazione file di Azure considerazioni sulla rete prima di leggere questa guida pratica.

Prerequisiti

Questo articolo presuppone quanto segue:

Che si abbia una sottoscrizione di Azure. Se non si ha già una sottoscrizione, creare un account gratuito prima di iniziare.
È già stata creata una condivisione file di Azure in un account di archiviazione a cui connettersi dall'ambiente locale. Per informazioni su come creare una condivisione file di Azure, vedere Creare una condivisione file di Azure.
È possibile consentire il traffico di dominio agli endpoint seguenti, vedere Endpoint di servizio di Azure:

Inoltre:

Se si intende usare Azure PowerShell, installare l'ultima versione.
Se si intende usare l'interfaccia della riga di comando di Azure, installare l'ultima versione.

Creare gli endpoint privati

Quando si crea un endpoint privato per una risorsa di Azure, vengono distribuite le risorse seguenti:

Un endpoint privato: una risorsa di Azure che rappresenta l'endpoint privato per l'account di archiviazione o il servizio di sincronizzazione archiviazione. Si consideri questa risorsa che connette la risorsa di Azure e un'interfaccia di rete.
Interfaccia di rete :interfaccia di rete che gestisce un indirizzo IP privato all'interno della rete virtuale/subnet specificata. Si tratta della stessa risorsa che viene distribuita quando si distribuisce una macchina virtuale (VM), ma anziché essere assegnata a una macchina virtuale, è di proprietà dell'endpoint privato.
Una zona DNS privata: se non è mai stato distribuito un endpoint privato per questa rete virtuale in precedenza, verrà distribuita una nuova zona DNS privata per la rete virtuale. In questa zona DNS verrà anche creato un record A DNS per la risorsa di Azure. Se in questa rete virtuale è già stato distribuito un endpoint privato, nella zona DNS esistente verrà aggiunto un nuovo record A per la risorsa di Azure. La distribuzione di una zona DNS è facoltativa, ma è altamente consigliata per semplificare la gestione DNS necessaria.

Nota

Questo articolo usa i suffissi DNS per le aree pubbliche di Azure, core.windows.net per gli account di archiviazione e afs.azure.net per i servizi di sincronizzazione archiviazione. Questo vale anche per i cloud sovrani di Azure, ad esempio il cloud di Azure US Government, che è sufficiente sostituire i suffissi appropriati per l'ambiente in uso.

Creare l'endpoint privato per l'account di archiviazione

Passare all'account di archiviazione per cui creare un endpoint privato. Dal menu del servizio, in Sicurezza e rete selezionare Rete, Connessioni endpoint privati e quindi + Endpoint privato per creare un nuovo endpoint privato.

La procedura guidata risultante include più pagine da completare.

Nel pannello Informazioni di base selezionare la sottoscrizione, il gruppo di risorse, il nome, il nome dell'interfaccia di rete e l'area desiderati per l'endpoint privato. che non devono necessariamente corrispondere a quelli dell'account di archiviazione, anche se l'endpoint privato deve essere creato nella stessa area della rete virtuale in cui inserirlo. Selezionare quindi Avanti: Risorsa.

Nel pannello Risorsa selezionare il file per la sotto-risorsa di destinazione. Selezionare Avanti: Rete virtuale.

Il pannello Rete virtuale consente di selezionare la rete virtuale e la subnet specifiche a cui si vuole aggiungere l'endpoint privato. Selezionare l'allocazione dinamica o statica degli indirizzi IP per il nuovo endpoint privato. Se si seleziona statico, sarà necessario specificare anche un nome e un indirizzo IP privato. È anche possibile specificare facoltativamente un gruppo di sicurezza delle applicazioni. Al termine, selezionare Avanti: DNS.

Il pannello DNS contiene le informazioni per l'integrazione dell'endpoint privato con una zona DNS privata. Assicurarsi che la sottoscrizione e il gruppo di risorse siano corretti, quindi selezionare Avanti: Tag.

Facoltativamente, è possibile applicare tag per classificare le risorse, ad esempio applicare il nome Ambiente e il valore Test a tutte le risorse di test. Immettere coppie nome/valore se necessario e quindi selezionare Avanti: Rivedi e crea.

Infine, selezionare Crea per creare l'endpoint privato.

Se si dispone di una macchina virtuale all'interno della rete virtuale o si è configurato l'inoltro DNS come descritto in Configurazione dell'inoltro DNS per File di Azure, è possibile verificare che l'endpoint privato sia configurato correttamente eseguendo i comandi seguenti da PowerShell, dalla riga di comando o dal terminale (funziona per Windows, Linux o macOS). È necessario sostituire <storage-account-name> con il nome dell'account di archiviazione appropriato:

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

Se tutto funziona correttamente, verrà visualizzato l'output seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale (output mostrato per 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

Per creare un endpoint privato per l'account di archiviazione, è prima di tutto necessario ottenere un riferimento all'account di archiviazione e alla subnet della rete virtuale in cui aggiungerlo. Sostituire <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> e <vnet-subnet-name> di seguito:

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

Per creare un endpoint privato, è necessario creare una connessione del servizio Collegamento privato all'account di archiviazione. La connessione del servizio Collegamento privato è un input per la creazione dell'endpoint privato.

# 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

La creazione di una zona DNS privato di Azure consente di risolvere il nome originale dell'account di archiviazione, ad esempio storageaccount.file.core.windows.net, nell'indirizzo IP privato all'interno della rete virtuale. Sebbene sia facoltativa dal punto di vista della creazione di un endpoint privato, si tratta di un'operazione esplicitamente necessaria per montare direttamente la condivisione file di Azure con un'entità utente di AD o per accedere tramite l'API REST.

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

Una volta ottenuto un riferimento alla zona DNS privato, è necessario creare un record A per l'account di archiviazione.

$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

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

Resolve-DnsName -Name $storageAccountHostName

Se tutto funziona correttamente, verrà visualizzato l'output seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale:

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

Per creare un endpoint privato, è prima di tutto necessario assicurarsi che i criteri di rete dell'endpoint privato della subnet siano disabilitati. Quindi, è possibile creare un endpoint privato con il comando 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 '"')

La creazione di una zona DNS privato di Azure consente di risolvere il nome originale dell'account di archiviazione, ad esempio storageaccount.file.core.windows.net, nell'indirizzo IP privato all'interno della rete virtuale. Sebbene sia facoltativa dal punto di vista della creazione di un endpoint privato, si tratta di un'operazione esplicitamente necessaria per montare la condivisione file di Azure con un'entità utente di AD o per accedere tramite l'API REST.

# 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

Una volta ottenuto un riferimento alla zona DNS privato, è necessario creare un record A per l'account di archiviazione.

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

Se tutto funziona correttamente, verrà visualizzato l'output seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale:

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

Creare l'endpoint privato del servizio di sincronizzazione archiviazione

Passare a Centro collegamento privato digitando Collegamento privato nella barra di ricerca nella parte superiore del portale di Azure. Nel sommario del Centro collegamento privato selezionare Endpoint privati e quindi + Aggiungi per creare un nuovo endpoint privato.

La procedura guidata risultante include più pagine da completare.

Nel pannello Informazioni di base selezionare il gruppo di risorse, il nome e l'area da usare per l'endpoint privato, che non devono necessariamente corrispondere a quelli del servizio sincronizzazione archiviazione, anche se l'endpoint privato deve essere creato nella stessa area della rete virtuale in cui inserirlo.

Screenshot della sezione Informazioni di base della sezione per creare un endpoint privato

Nel pannello Risorsa selezionare il pulsante di opzione Connettersi a una risorsa di Azure nella directory. In Tipo di risorsa selezionare Microsoft.StorageSync/storageSyncServices.

Il pannello Configurazione consente di selezionare la rete virtuale e la subnet specifiche a cui aggiungere l'endpoint privato. Selezionare la stessa rete virtuale di quella usata per l'account di archiviazione. Il pannello Configurazione contiene anche le informazioni per la creazione o l'aggiornamento della zona DNS privato.

Selezionare Rivedi e crea per creare l'endpoint privato.

È possibile verificare che l'endpoint privato sia configurato correttamente eseguendo i comandi di PowerShell seguenti.

$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

Se tutto funziona correttamente, verrà visualizzato l'output seguente in cui 192.168.1.4, 192.168.1.6192.168.1.5, e 192.168.1.7 sono gli indirizzi IP privati assegnati all'endpoint privato:

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

Per creare un endpoint privato per il servizio di sincronizzazione archiviazione, è prima necessario ottenere un riferimento al servizio di sincronizzazione archiviazione. Assicurarsi di sostituire <storage-sync-service-resource-group> e <storage-sync-service> con i valori appropriati per l'ambiente. I comandi di PowerShell seguenti presuppongono che siano già state popolate le informazioni sulla rete virtuale.

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

Per creare un endpoint privato, è necessario creare una connessione di Collegamento privato al servizio di sincronizzazione archiviazione. La connessione di Collegamento privato è un input per la creazione dell'endpoint privato.

# 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

La creazione di una zona DNS privato di Azure consente di risolvere i nomi host per il servizio di sincronizzazione archiviazione, ad esempio mysssmanagement.westus2.afs.azure.net, negli indirizzi IP privati corretti per tale servizio all'interno della rete virtuale. Anche se facoltativo dal punto di vista della creazione di un endpoint privato, è richiesto in modo esplicito per l'agente Sincronizzazione file di Azure di accedere al servizio di sincronizzazione archiviazione.

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

Ora che si dispone di un riferimento alla zona DNS privata, è necessario creare un record A per il servizio di sincronizzazione archiviazione.

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

Per creare un endpoint privato per il servizio di sincronizzazione archiviazione, è prima necessario ottenere un riferimento al servizio di sincronizzazione archiviazione. Assicurarsi di sostituire <storage-sync-service-resource-group> e <storage-sync-service> con i valori appropriati per l'ambiente. I comandi dell'interfaccia della riga di comando seguenti presuppongono che siano già state popolate le informazioni sulla rete virtuale.

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

Ora che si dispone di un riferimento alla zona DNS privata, è necessario creare un record A per il servizio di sincronizzazione archiviazione.

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

Limitare l'accesso agli endpoint pubblici

È possibile limitare l'accesso agli endpoint pubblici sia dell'account di archiviazione che dei servizi di sincronizzazione archiviazione. La limitazione dell'accesso all'endpoint pubblico garantisce una maggiore sicurezza assicurando che i pacchetti di rete vengano accettati solo da posizioni approvate.

Limitare l'accesso all'endpoint pubblico dell'account di archiviazione

Per limitare l'accesso all'endpoint pubblico, usare le impostazioni del firewall dell'account di archiviazione. In generale, la maggior parte dei criteri del firewall per un account di archiviazione limiterà l'accesso di rete a una o più reti virtuali. Per limitare l'accesso a un account di archiviazione consentendolo solo a una rete virtuale, sono disponibili due approcci:

Creare uno o più endpoint privati per l'account di archiviazione e disabilitare l'accesso all'endpoint pubblico. In questo modo si garantisce che solo il traffico originato dalle reti virtuali desiderate possa accedere alle condivisioni file di Azure nell'account di archiviazione.
Limitare l'endpoint pubblico a una o più reti virtuali. Questa operazione può essere eseguita usando una funzionalità della rete virtuale denominata endpoint di servizio. Quando si limita il traffico a un account di archiviazione tramite un endpoint di servizio, si accede comunque all'account di archiviazione tramite l'indirizzo IP pubblico.

Nota

L'opzione Consenti ai servizi di Azure nell'elenco dei servizi attendibili di accedere a questa eccezione dell'account di archiviazione deve essere selezionata nell'account di archiviazione per consentire servizi Microsoft attendibili, ad esempio Sincronizzazione file di Azure di accedere all'account di archiviazione. Per altre informazioni, vedere Concedere l'accesso ai servizi di Azure attendibili.

Concedere l'accesso ai servizi di Azure attendibili e disabilitare l'accesso all'endpoint pubblico dell'account di archiviazione

Se si disabilita l'accesso all'endpoint pubblico, l'account di archiviazione rimane comunque accessibile tramite i relativi endpoint privati. Altrimenti le richieste valide inviate all'endpoint pubblico dell'account di archiviazione verranno rifiutate.

Passare all'account di archiviazione per cui limitare tutto l'accesso all'endpoint pubblico. Nel sommario per l'account di archiviazione selezionare Rete.

Nella parte superiore della pagina selezionare il pulsante di opzione Abilitato nelle reti virtuali selezionate e negli indirizzi IP. Verranno rese visibili diverse impostazioni nascoste per il controllo della restrizione dell'endpoint pubblico. Selezionare Consenti ai servizi di Azure nell'elenco dei servizi attendibili di accedere a questo account di archiviazione per consentire a servizi Microsoft proprietari attendibili, ad esempio Sincronizzazione file di Azure di accedere all'account di archiviazione.

Il comando di PowerShell seguente negherà tutto il traffico diretto all'endpoint pubblico dell'account di archiviazione. Si noti che il parametro -Bypass di questo comando è impostato su AzureServices. Questa impostazione consentirà ai servizi Microsoft attendibili, come Sincronizzazione file di Azure, di accedere all'account di archiviazione tramite l'endpoint pubblico.

# 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

Il comando dell'interfaccia della riga di comando seguente negherà tutto il traffico diretto all'endpoint pubblico dell'account di archiviazione. Si noti che il parametro -bypass di questo comando è impostato su AzureServices. Questa impostazione consentirà ai servizi Microsoft attendibili, come Sincronizzazione file di Azure, di accedere all'account di archiviazione tramite l'endpoint pubblico.

# 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

Concedere l'accesso ai servizi di Azure attendibili e limitare l'accesso all'endpoint pubblico dell'account di archiviazione a reti virtuali specifiche

Quando si limita l'account di archiviazione a reti virtuali specifiche, è possibile consentire le richieste all'endpoint pubblico dall'interno delle reti virtuali specificate. Questa operazione può essere eseguita usando una funzionalità della rete virtuale denominata endpoint di servizio. Si può usare con o senza endpoint privati.

Passare all'account di archiviazione per cui limitare tutto l'accesso all'endpoint pubblico consentendolo solo a specifiche reti virtuali. Nel sommario per l'account di archiviazione selezionare Rete.

Nella parte superiore della pagina selezionare il pulsante di opzione Abilitato nelle reti virtuali selezionate e negli indirizzi IP. Verranno rese visibili diverse impostazioni nascoste per il controllo della restrizione dell'endpoint pubblico. Selezionare +Aggiungi rete virtuale esistente per selezionare la rete virtuale specifica che deve essere autorizzata ad accedere all'account di archiviazione tramite l'endpoint pubblico. Selezionare una rete virtuale e una subnet per la rete virtuale e quindi selezionare Abilita.

Selezionare Consenti ai servizi di Azure nell'elenco dei servizi attendibili di accedere a questo account di archiviazione per consentire a servizi Microsoft proprietari attendibili, ad esempio Sincronizzazione file di Azure di accedere all'account di archiviazione.

Per limitare l'accesso all'endpoint pubblico dell'account di archiviazione consentendolo solo a specifiche reti virtuali tramite endpoint di servizio, è necessario prima di tutto raccogliere informazioni sull'account di archiviazione e sulla rete virtuale. Compilare i campi <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> e <subnet-name> per raccogliere tali informazioni.

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

Affinché l'infrastruttura di rete di Azure consenta al traffico proveniente dalla rete virtuale di accedere all'endpoint pubblico dell'account di archiviazione, è necessario che l'endpoint di servizio Microsoft.Storage della subnet della rete virtuale sia esposto. I comandi di PowerShell seguenti aggiungeranno l'endpoint Microsoft.Storage di servizio alla subnet, se non è già presente.

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

Il passaggio finale per limitare il traffico diretto all'account di archiviazione consiste nel creare una regola di rete e aggiungerla al set di regole di rete dell'account di archiviazione.

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

Affinché l'infrastruttura di rete di Azure consenta al traffico proveniente dalla rete virtuale di accedere all'endpoint pubblico dell'account di archiviazione, è necessario che l'endpoint di servizio Microsoft.Storage della subnet della rete virtuale sia esposto. I comandi dell'interfaccia della riga di comando seguenti aggiungeranno l'endpoint Microsoft.Storage di servizio alla subnet, se non è già presente.

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

Il passaggio finale per limitare il traffico diretto all'account di archiviazione consiste nel creare una regola di rete e aggiungerla al set di regole di rete dell'account di archiviazione.

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

Disabilitare l'accesso all'endpoint pubblico del servizio di sincronizzazione archiviazione

Sincronizzazione file di Azure consente di limitare l'accesso a reti virtuali specifiche solo tramite endpoint privati; Sincronizzazione file di Azure non supporta gli endpoint di servizio per limitare l'accesso all'endpoint pubblico a reti virtuali specifiche. Ciò significa che i due stati per l'endpoint pubblico del servizio di sincronizzazione archiviazione sono abilitati e disabilitati.

Importante

È necessario creare un endpoint privato prima di disabilitare l'accesso all'endpoint pubblico. Se l'endpoint pubblico è disabilitato e non è configurato alcun endpoint privato, la sincronizzazione non può funzionare.

Per disabilitare l'accesso all'endpoint pubblico del servizio di sincronizzazione archiviazione, seguire questa procedura:

Accedere al portale di Azure.
Passare al servizio di sincronizzazione archiviazione e selezionare Impostazioni>rete nel riquadro di spostamento a sinistra.
In Consenti l'accesso da selezionare Solo endpoint privati.
Selezionare un endpoint privato dall'elenco Connessioni endpoint privato.

Per disabilitare l'accesso all'endpoint pubblico del servizio di sincronizzazione archiviazione, impostare la incomingTrafficPolicy proprietà nel servizio di sincronizzazione archiviazione su AllowVirtualNetworksOnly. Se si vuole abilitare l'accesso all'endpoint pubblico del servizio di sincronizzazione archiviazione, impostare invece su incomingTrafficPolicy AllowAllTraffic . Ricordarsi di sostituire <storage-sync-service-resource-group> e <storage-sync-service> con i propri valori.

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

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

Criteri di Azure

Criteri di Azure consente di applicare gli standard dell'organizzazione e di valutare la conformità a tali standard su larga scala. File di Azure e Sincronizzazione file di Azure esporre diversi criteri di rete utili per il controllo e la correzione che consentono di monitorare e automatizzare la distribuzione.

I criteri controllano l'ambiente e avvisano se gli account di archiviazione o i servizi di sincronizzazione archiviazione differiscono dal comportamento definito. Ad esempio, se un endpoint pubblico è abilitato quando i criteri sono stati impostati in modo che gli endpoint pubblici siano disabilitati. La modifica/distribuzione dei criteri consente di modificare ulteriormente e in modo proattivo una risorsa(ad esempio il servizio di sincronizzazione archiviazione) o distribuire risorse (ad esempio endpoint privati) per allinearsi ai criteri.

Per File di Azure e Sincronizzazione file di Azure sono disponibili i criteri predefiniti seguenti:

Azione	Service	Condizione	Nome del criterio
Controllo	File di Azure	L'endpoint pubblico dell'account di archiviazione è abilitato. Per altre informazioni, vedere Concedere l'accesso ai servizi di Azure attendibili e disabilitare l'accesso all'endpoint pubblico dell'account di archiviazione.	Gli account di archiviazione devono limitare l'accesso alla rete
Controllo	Sincronizzazione file di Azure	L'endpoint pubblico del servizio di sincronizzazione archiviazione è abilitato. Per altre informazioni, vedere Disabilitare l'accesso all'endpoint pubblico del servizio di sincronizzazione archiviazione.	L'accesso alla rete pubblica deve essere disabilitato per Sincronizzazione file di Azure
Controllo	File di Azure	L'account di archiviazione richiede almeno un endpoint privato. Per altre informazioni, vedere Creare l'endpoint privato dell'account di archiviazione.	L'account di archiviazione deve usare una connessione collegamento privato
Controllo	Sincronizzazione file di Azure	Il servizio di sincronizzazione archiviazione richiede almeno un endpoint privato. Per altre informazioni, vedere Creare l'endpoint privato del servizio di sincronizzazione archiviazione.	Sincronizzazione file di Azure deve usare collegamenti privati
Modifica	Sincronizzazione file di Azure	Disabilitare l'endpoint pubblico del servizio di sincronizzazione archiviazione.	Modificare - Configurare la Sincronizzazione file di Azure per disabilitare l'accesso alla rete pubblica
Distribuzione	Sincronizzazione file di Azure	Distribuire un endpoint privato per il servizio di sincronizzazione archiviazione.	Configurare Sincronizzazione file di Azure con endpoint privati
Distribuzione	Sincronizzazione file di Azure	Distribuire un record A nella zona DNS privatelink.afs.azure.net.	Configurare Sincronizzazione file di Azure per usare zone private DNS

Configurare un criterio di distribuzione dell'endpoint privato

Per configurare un criterio di distribuzione dell'endpoint privato, passare alla portale di Azure e cercare Criteri. Il centro Criteri di Azure deve essere un risultato principale. Passare a Authoring Definitions (Definizioni di creazione>) nel sommario del Centro criteri. Il riquadro Definizioni risultante contiene i criteri predefiniti in tutti i servizi di Azure. Per trovare i criteri specifici, selezionare la categoria Archiviazione nel filtro categoria oppure cercare Configura Sincronizzazione file di Azure con endpoint privati. Selezionare ... e Assegna per creare un nuovo criterio dalla definizione.

Il pannello Informazioni di base della procedura guidata Assegna criteri consente di impostare un ambito, una risorsa o un elenco di esclusione di gruppi di risorse e assegnare al criterio un nome descrittivo per distinguerlo. Non è necessario modificarli per il funzionamento del criterio, ma è possibile apportare modifiche. Selezionare Avanti per passare alla pagina Parametri.

Nel pannello Parametri selezionare ... accanto all'elenco a discesa privateEndpointSubnetId per selezionare la rete virtuale e la subnet in cui devono essere distribuiti gli endpoint privati per le risorse del servizio di sincronizzazione archiviazione. La procedura guidata risultante può richiedere alcuni secondi per caricare le reti virtuali disponibili nella sottoscrizione. Selezionare la rete virtuale/subnet appropriata per l'ambiente e fare clic su Seleziona. Selezionare Avanti per passare al pannello Correzione .

Affinché l'endpoint privato venga distribuito quando viene identificato un servizio di sincronizzazione archiviazione senza un endpoint privato, è necessario selezionare l'attività Crea una correzione nella pagina Correzione. Infine, selezionare Rivedi e crea per esaminare l'assegnazione dei criteri e Crea per crearla.

L'assegnazione dei criteri risultante verrà eseguita su base periodica e potrebbe non essere eseguita immediatamente dopo la creazione.

Condividi tramite