Configurare gli endpoint di rete per l'accesso alle condivisioni file di Azure

✔️ Si applica a: condivisioni file classiche create con il provider di risorse Microsoft.Storage

✔️ Si applica a: Condivisioni di file create con il provider di risorse Microsoft.FileShares

File di Azure prevede due tipi principali di endpoint per l'accesso alle condivisioni file di Azure:

Endpoint pubblici, che hanno un indirizzo IP pubblico ed è possibile accedere 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.

Per le condivisioni file classiche (create con il Microsoft.Storage provider di risorse), l'account di archiviazione Azure ha endpoint pubblici e privati. Per le condivisioni file create con il Microsoft.FileShares provider di risorse, è possibile creare endpoint pubblici e privati a livello di condivisione file anziché a livello di account di archiviazione.

Questo articolo è incentrato su come configurare un endpoint privato per l'accesso diretto alla condivisione file Azure. Gran parte di questo articolo si applica anche al modo in cui Sincronizzazione file di Azure interagisce con endpoint pubblici e privati per l'account di archiviazione. Per maggiori informazioni sulle considerazioni di rete per Sincronizzazione file di Azure, vedi configurare le impostazioni del proxy e firewall di Sincronizzazione file di Azure.

Prima di leggere questa guida, esaminare considerazioni sulla rete di File di Azure.

Prerequisiti

Questo articolo presuppone che sia già stata creata una sottoscrizione di Azure. Se non si ha già una sottoscrizione, creare un account gratuito.
Avrai bisogno di una condivisione file Azure a cui vuoi connetterti. Per imparare a creare una condivisione file Azure, vedi Crea una condivisione file classica o Crea una condivisione file Azure con Microsoft. Condivisione di file.
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 e configurare gli endpoint

Puoi configurare i tuoi endpoint per limitare l'accesso alla rete all'account di archiviazione e alle condivisioni file. Per limitare l'accesso a una rete virtuale, si utilizza uno dei seguenti approcci:

Crea uno o più endpoint privati e limita ogni accesso all'endpoint pubblico (consigliato). Questo approccio garantisce che solo il traffico proveniente dalle reti virtuali desiderate possa accedere alle condivisioni file Azure. Vedere Costo di Collegamento privato.
Limitare l'endpoint pubblico a una o più reti virtuali. Questo approccio usa una funzionalità della rete virtuale denominata endpoint di servizio. Quando limiti il traffico a un account di archiviazione tramite un endpoint di servizio, accedi all'account di archiviazione o alla condivisione file tramite l'indirizzo IP pubblico, ma l'accesso è possibile solo dalle posizioni che specifichi nella configurazione.

Creare un endpoint privato

Quando si crea un endpoint privato per le condivisioni file, si distribuiscono le risorse Azure seguenti:

Endpoint privato: una risorsa Azure che rappresenta l'endpoint privato. Questa risorsa può essere considerata come un connettore tra una risorsa di destinazione e un'interfaccia di rete.
Interfaccia di rete :interfaccia di rete che gestisce un indirizzo IP privato all'interno della rete virtuale e della subnet specificate. Questa risorsa corrisponde a quella che si distribuisce quando si distribuisce una macchina virtuale .This resource is the same as the one you deploy when you deploy a virtual machine (VM). Tuttavia, invece di assegnarlo a una macchina virtuale, l'endpoint privato lo possiede.
Una zona DNS (Domain Name System) privata: se in precedenza non è stato distribuito un endpoint privato per questa rete virtuale, viene distribuita una nuova zona DNS privata per la rete virtuale. In questa zona DNS viene creato anche un record DNS. Se in questa rete virtuale è già stato distribuito un endpoint privato, viene aggiunto un nuovo record alla zona DNS esistente. La distribuzione di una zona DNS è facoltativa. È tuttavia consigliata e diventa obbligatoria se le condivisioni file di Azure vengono montate con un'entità servizio di AD oppure se si usa l'API FileREST.

Note

Questo articolo usa il suffisso DNS per le aree pubbliche Azure, core.windows.net. Questo commento si applica anche ai cloud sovrani Azure, ad esempio il cloud Azure Governo Statunitense e il Azure gestito dal cloud 21Vianet. È sufficiente sostituire i suffissi appropriati per l'ambiente in uso.

Il processo di creazione degli endpoint privati differisce leggermente a seconda che si usi la condivisione file classica o il nuovo modello di condivisione file. Per le condivisioni file classiche, si crea un endpoint privato per l'account di archiviazione che contiene le condivisioni file. Per le condivisioni file create con Microsoft.FileShares, si crea un endpoint privato per la condivisione file stessa.

Molti dei passaggi sono identici per entrambe le esperienze. Solo il riferimento alla risorsa, l'ID del gruppo e il nome del record DNS differiscono, come mostrato nella tabella seguente.

	Condivisioni file classiche (`Microsoft.Storage`)	Nuove condivisioni di file (`Microsoft.FileShares`)
Endpoint privato di destinazione	Account di archiviazione	Condivisione di file
Cmdlet di risorsa	`Get-AzStorageAccount`	`Get-AzFileShare`
ID del gruppo (sotto-risorsa)	`file`	`FileShare`
Nome del record DNS A	Nome dell'account di archiviazione	Prefisso del nome host (ad esempio, `fs-xxxxxxxxxxxxxxxxx`)

Passare al gruppo di risorse in cui si vuole creare un endpoint privato. Selezionare + Crea e cercare Endpoint privato. Selezionare la risorsa dell'endpoint privato e quindi selezionare Crea.

La procedura guidata include più pagine da completare.

Nella pagina Informazioni di base selezionare la sottoscrizione, il gruppo di risorse, il nome, il nome dell'interfaccia di rete e l'area per l'endpoint privato. È necessario creare l'endpoint privato nella stessa area della rete virtuale in cui si vuole creare l'endpoint privato. Quindi selezionare Avanti: Risorsa.

Se stai usando condivisioni file classic in un account di archiviazione:

Nella pagina Risorse, seleziona Microsoft. Storage/storageAccount dal menu a tendina per Tipo di risorsa. Per Risorsa, seleziona l'account di archiviazione specifico a cui vuoi connetterti. Per la sotto-risorsa Target, seleziona file. Selezionare Avanti: Rete virtuale.

Se usi condivisioni di file create con il provider di risorse Microsoft.FileShares:

Nella pagina Risorse, seleziona Microsoft. FileShares/fileShares dal menu a tendina per il tipo di risorsa. Per Risorsa, seleziona la condivisione file specifica a cui vuoi collegarti. La sotto-risorsa di destinazione viene popolata automaticamente con FileShare. Selezionare Avanti: Rete virtuale.

La pagina Rete virtuale consente di selezionare il virtual network e la subnet specifici a cui si vuole aggiungere l'endpoint privato. Selezionare l'allocazione dell'indirizzo IP statico o dinamico per il nuovo endpoint privato. Se si seleziona statico, è 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.

La pagina 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 e 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.

Per creare un endpoint privato, ottenere prima di tutto un riferimento all'account di archiviazione o alla condivisione file e alla subnet della rete virtuale in cui si vuole aggiungere l'endpoint privato. Sostituire i valori segnaposto nel codice seguente con i propri valori.

Per le condivisioni file classiche, ottenere un riferimento all'account di archiviazione:

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

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

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

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares, recuperare un riferimento alla condivisione di file:

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

Dopo aver impostato le variabili comuni, i passaggi rimanenti sono gli stessi per entrambe le esperienze. Ottenere riferimenti alla rete virtuale e alla subnet:

 $virtualNetworkResourceGroupName = "<vnet-resource-group-name>"
 $virtualNetworkName = "<vnet-name>"
 $subnetName = "<vnet-subnet-name>"
 
 # Get virtual network reference, and throw error if it doesn't exist
 $virtualNetwork = Get-AzVirtualNetwork `
         -ResourceGroupName $virtualNetworkResourceGroupName `
         -Name $virtualNetworkName `
         -ErrorAction SilentlyContinue
 
 if ($null -eq $virtualNetwork) {
     $errorMessage = "Virtual network $virtualNetworkName not found "
     $errorMessage += "in resource group $virtualNetworkResourceGroupName."
     Write-Error -Message $errorMessage -ErrorAction Stop
 }
 
 # Get reference to virtual network subnet, and throw error if it doesn't exist
 $subnet = $virtualNetwork | `
     Select-Object -ExpandProperty Subnets | `
     Where-Object { $_.Name -eq $subnetName }
 
 if ($null -eq $subnet) {
     Write-Error `
             -Message "Subnet $subnetName not found in virtual network $virtualNetworkName." `
             -ErrorAction Stop
 }

Per creare un endpoint privato, è necessario creare una connessione al servizio di collegamento privato. 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.
 $privateEndpointConnection = New-AzPrivateLinkServiceConnection `
         -Name "$dnsRecordName-Connection" `
         -PrivateLinkServiceId $privateLinkResourceId `
         -GroupId $groupId `
         -ErrorAction Stop
 
 # Create a new private endpoint.
 $privateEndpoint = New-AzPrivateEndpoint `
         -ResourceGroupName $resourceGroupName `
         -Name "$dnsRecordName-PrivateEndpoint" `
         -Location $virtualNetwork.Location `
         -Subnet $subnet `
         -PrivateLinkServiceConnection $privateEndpointConnection `
         -ErrorAction Stop

Se si crea una zona DNS privata di Azure, il nome host originale viene risolto nell'indirizzo IP privato all'interno della rete virtuale. Sebbene opzionale dal punto di vista della creazione di un endpoint privato, è esplicitamente necessario per montare direttamente la condivisione file Azure usando un user principal Active Directory (AD) o per accedere tramite l'API REST.

 # Get the host name suffix (core.windows.net for public cloud).
 # This is done like this so this script will seamlessly work for non-public Azure.
 $hostNameSuffix = Get-AzContext | `
     Select-Object -ExpandProperty Environment | `
     Select-Object -ExpandProperty StorageEndpointSuffix
 
 # For public cloud, this will generate the following DNS suffix:
 # privatelink.file.core.windows.net.
 $dnsZoneName = "privatelink.file.$hostNameSuffix"
 
 # Find a DNS zone matching desired name attached to this virtual network.
 $dnsZone = Get-AzPrivateDnsZone | `
     Where-Object { $_.Name -eq $dnsZoneName } | `
     Where-Object {
         $privateDnsLink = Get-AzPrivateDnsVirtualNetworkLink `
                 -ResourceGroupName $_.ResourceGroupName `
                 -ZoneName $_.Name `
                 -ErrorAction SilentlyContinue
         
         $privateDnsLink.VirtualNetworkId -eq $virtualNetwork.Id
     }
 
 if ($null -eq $dnsZone) {
     # No matching DNS zone attached to virtual network, so create new one.
     $dnsZone = New-AzPrivateDnsZone `
             -ResourceGroupName $virtualNetworkResourceGroupName `
             -Name $dnsZoneName `
             -ErrorAction Stop
 
     $privateDnsLink = New-AzPrivateDnsVirtualNetworkLink `
             -ResourceGroupName $virtualNetworkResourceGroupName `
             -ZoneName $dnsZoneName `
             -Name "$virtualNetworkName-DnsLink" `
             -VirtualNetworkId $virtualNetwork.Id `
             -ErrorAction Stop
 }

Ora che si dispone di un riferimento alla zona DNS privata, è necessario creare un record.

 $privateEndpointIP = $privateEndpoint | `
     Select-Object -ExpandProperty NetworkInterfaces | `
     Select-Object @{ 
         Name = "NetworkInterfaces"; 
         Expression = { Get-AzNetworkInterface -ResourceId $_.Id } 
     } | `
     Select-Object -ExpandProperty NetworkInterfaces | `
     Select-Object -ExpandProperty IpConfigurations | `
     Select-Object -ExpandProperty PrivateIpAddress
 
 $privateDnsRecordConfig = New-AzPrivateDnsRecordConfig `
         -IPv4Address $privateEndpointIP
 
 New-AzPrivateDnsRecordSet `
         -ResourceGroupName $virtualNetworkResourceGroupName `
         -Name $dnsRecordName `
         -RecordType A `
         -ZoneName $dnsZoneName `
         -Ttl 600 `
         -PrivateDnsRecords $privateDnsRecordConfig `
         -ErrorAction Stop | `
     Out-Null

Per creare un endpoint privato, ottenere prima di tutto un riferimento all'account di archiviazione o alla condivisione file, oltre alla subnet della rete virtuale in cui si vuole aggiungere l'endpoint privato. Sostituire i valori segnaposto nei passaggi seguenti con i propri valori.

Per le condivisioni file classiche, ottenere un riferimento all'account di archiviazione:

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

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

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares, recuperare un riferimento alla condivisione di file:

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

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

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

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

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

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

Dopo aver impostato le variabili comuni, i passaggi rimanenti sono gli stessi per entrambe le esperienze. Ottenere riferimenti alla rete virtuale e alla subnet:

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

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

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

Per creare un endpoint privato, verificare che i criteri di rete dell'endpoint privato della subnet siano disabilitati e quindi creare l'endpoint privato con az network private-endpoint create.

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

# Get virtual network location
region=$(az network vnet show \
        --ids $virtualNetwork \
        --query "location" --output tsv)

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

Se si crea una zona DNS privata di Azure, il nome host originale viene risolto nell'indirizzo IP privato all'interno della rete virtuale. Sebbene sia facoltativo ai fini della creazione di un endpoint privato, è necessario per montare la condivisione file di Azure usando un'entità utente di AD o per accedervi tramite l'API FileREST.

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

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

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

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

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

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

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

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

    dnsZoneResourceGroup=$virtualNetworkResourceGroupName
fi

Ora che si dispone di un riferimento alla zona DNS privata, creare un record A.

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

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

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

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

Verificare la connettività

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. Eseguire i comandi seguenti da PowerShell, dalla riga di comando o dal terminale (funziona per Windows, Linux o macOS).

Per le condivisioni file classiche, sostituire <storage-account-name> con il nome dell'account di archiviazione appropriato:

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares, usare il nome host della condivisione di file. Nella scheda Panoramica della condivisione file selezionare Visualizzazione JSON in alto a destra. Nella visualizzazione JSON, in proprietà copiare il valore per hostName. Il formato è simile a fs-xxxxxxxxxxxxxxxxx.xx.file.storage.azure.net.

nslookup <file-share-host-name>

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale (output visualizzato per Windows).

Per le condivisioni di file classiche:

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 le condivisioni di file create con il provider di risorse Microsoft.FileShares:

Server:  UnKnown
Address:  10.2.4.4

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

Per le condivisioni di file classiche:

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares:

 Resolve-DnsName -Name $fileShare.HostName

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale.

Per le condivisioni di file classiche:

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares:

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

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

Per le condivisioni di file classiche:

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

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares:

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

nslookup $hostName

In caso di esito positivo, viene visualizzato un output simile al seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale. Dovresti comunque usare il nome host originale (storageaccount.file.core.windows.net per la versione classica oppure il hostName della condivisione file per la nuova esperienza) per montare la tua condivisione file anziché il percorso privatelink.

Per le condivisioni di file classiche:

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares:

Server:         127.0.0.53
Address:        127.0.0.53#53

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

Limitare l'accesso agli endpoint pubblici

Per limitare l'accesso all'endpoint pubblico, disabilitare prima di tutto l'accesso generale all'endpoint pubblico. La disabilitazione dell'accesso all'endpoint pubblico non influisce sugli endpoint privati. Dopo aver disabilitato l'endpoint pubblico, selezionare reti o indirizzi IP specifici che possono continuare ad accedervi. In generale, la maggior parte dei criteri firewall per un account di archiviazione limita l'accesso alla rete a una o più reti virtuali.

Puoi anche utilizzare un perimetro di sicurezza di rete per gestire centralmente le regole di accesso in entrata e in uscita.

Disabilitare l'accesso all'endpoint pubblico

Quando disabiliti l'accesso alla rete pubblica, limiti l'accesso in entrata pur permettendo l'accesso in uscita. Puoi comunque accedere all'account di archiviazione tramite i suoi endpoint privati. Altrimenti, le richieste all'endpoint pubblico dell'account di archiviazione vengono rifiutate, a meno che non provengano da una fonte specificamente consentita.

Per disabilitare l'accesso pubblico alla rete per le classiche condivisioni file, segui questi passaggi:

Vai all'account di archiviazione dove vuoi limitare tutti gli accessi in entrata all'endpoint pubblico.
Dal menu del servizio, in Sicurezza e rete, selezionare Rete.
In Accesso alla rete pubblica selezionare Gestisci.
Seleziona Disabilita, poi seleziona Procedi.
Seleziona Salva.

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares:

Passare alla condivisione file in cui si vuole disabilitare l'accesso pubblico. Nel menu di servizio, selezionare Configurazione in Impostazioni. Impostare Accesso alla rete pubblica su Disabilitato e quindi selezionare Salva.

Per le condivisioni file classiche, il comando di PowerShell seguente nega tutto il traffico all'endpoint pubblico dell'account di archiviazione. Impostare il -Bypass parametro su AzureServices per consentire ai servizi proprietari attendibili, ad esempio 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 guide.
$storageAccount | Update-AzStorageAccountNetworkRuleSet `
        -DefaultAction Deny `
        -Bypass AzureServices `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

Per le condivisioni file create con il provider di risorse Microsoft.FileShares, impostare -PublicNetworkAccess su Disabled sulla condivisione file.

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

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

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

Per le condivisioni file classiche, il comando CLI seguente blocca tutto il traffico verso l'endpoint pubblico dell'account di archiviazione. Impostare il --bypass parametro su AzureServices per consentire ai servizi proprietari attendibili, ad esempio 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

Per le condivisioni file create con il provider di risorse Microsoft.FileShares, impostare --public-network-access su Disabled sulla condivisione file.

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

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

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

Limitare l'accesso all'endpoint pubblico a reti specifiche

Quando si limita l'accesso all'endpoint pubblico a reti specifiche, si permettono richieste all'endpoint pubblico provenienti da reti virtuali o indirizzi IP specificati. Questa restrizione funziona utilizzando una capacità chiamata service endpoint. Puoi usare endpoint di servizio con o senza endpoint privati.

Per le condivisioni file classiche, segui questi passaggi per limitare l'endpoint pubblico a reti specifiche.

Vai all'account di archiviazione dove vuoi limitare l'endpoint pubblico a reti specifiche.
Dal menu del servizio, in Sicurezza e rete, selezionare Rete.
In Ambito di accesso alla rete pubblica selezionare Abilita dalle reti selezionate. Questa selezione rivela una serie di impostazioni per controllare la restrizione dell'endpoint pubblico.
Sotto Reti virtuali, seleziona Aggiungi una rete>virtuale Aggiungi rete virtuale esistente per selezionare la rete virtuale che dovrebbe poter accedere all'account di archiviazione tramite l'endpoint pubblico. Selezionare una rete virtuale e una subnet per tale rete virtuale, quindi selezionare Abilita. Se vuoi creare una nuova rete virtuale a questo scopo, seleziona Aggiungi una rete>virtuale Aggiungi nuova rete virtuale, fornisci i dettagli e poi seleziona Crea.
Sotto IPv4 Addresses, specifica tutti gli indirizzi IP internet pubblici che vuoi poter accedere all'account di archiviazione.
Seleziona la casella Consenti ai servizi servizi Microsoft affidabili di accedere a questa risorsa per permettere ai servizi servizi Microsoft affidabili di prima parte come Sincronizzazione file di Azure di accedere all'account di archiviazione.
Seleziona Salva.

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares:

Passare alla condivisione file in cui si vuole limitare l'accesso pubblico. Dal menu del servizio, in Impostazioni, selezionare Configurazione. In Accesso alla rete pubblica selezionare Abilitato nelle reti virtuali selezionate, aggiungere le reti virtuali e le subnet autorizzate ad accedere alla condivisione e selezionare Salva.

Per le condivisioni file classiche, limitare l'accesso all'endpoint pubblico dell'account di archiviazione a reti virtuali specifiche usando gli endpoint di servizio. Prima di tutto, raccogliere informazioni sull'account di archiviazione e sulla rete virtuale. Sostituire i valori segnaposto nei passaggi seguenti con i propri valori.

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

Per consentire il traffico dalla rete virtuale, l'infrastruttura di rete Azure deve esporre l'Microsoft.Storageendpoint del servizio alla subnet della rete virtuale. I comandi di PowerShell seguenti aggiungono l'endpoint di servizio Microsoft.Storage 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 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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares, specificare direttamente gli ID delle risorse delle subnet consentite in Update-AzFileShare tramite -AllowedSubnet. Non è necessario configurare separatamente un endpoint di servizio o una regola di rete nell'account di archiviazione.

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

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

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

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

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

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

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

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

Per consentire il traffico dalla rete virtuale, l'infrastruttura di rete Azure deve esporre l'Microsoft.Storageendpoint del servizio alla subnet della rete virtuale. I seguenti comandi CLI aggiungono l'endpoint di servizio Microsoft.Storage alla subnet, se non è già incluso.

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

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares, specificare direttamente gli ID delle risorse delle subnet consentite in az fileshare update tramite --allowed-subnets. Non è necessario configurare separatamente un endpoint di servizio o una regola di rete nell'account di archiviazione.

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

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

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

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

Vedere anche

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-07-16

Configurare gli endpoint di rete per l'accesso alle condivisioni file di Azure

Prerequisiti

Creare e configurare gli endpoint

Creare un endpoint privato

Esperienza classica e nuova condivisione file

Verificare la connettività

Limitare l'accesso agli endpoint pubblici

Disabilitare l'accesso all'endpoint pubblico

Limitare l'accesso all'endpoint pubblico a reti specifiche

Vedere anche

Commenti e suggerimenti

Risorse aggiuntive