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

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. L'accesso dipende dal protocollo e dalle regole di rete. I client NFS utilizzano endpoint di servizio da subnet consentite.
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 spiega come configurare endpoint privati e limitare l'accesso agli endpoint pubblici per entrambi i provider di risorse. La guida classica per la condivisione file si applica anche agli account di archiviazione utilizzati con Sincronizzazione file di Azure, che supporta le classiche condivisioni file SMB. Per i requisiti di rete di File Sync, consulta Configura le impostazioni 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 limitare l'accesso di rete alle tue condivisioni file configurando l'account di archiviazione per le condivisioni classiche o per la singola risorsa Microsoft.FileShares. 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 utilizza endpoint di servizio sulle subnet client e regole di rete sull'account di archiviazione o sulla condivisione file. I client raggiungono l'endpoint pubblico tramite la backbone di Azure.

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 privata del Sistema di Nomi di Dominio (DNS): Questi passaggi creano o riutilizzano una zona DNS privata Azure collegata alla rete virtuale e aggiungono un record A per l'endpoint privato. Puoi invece usare la tua infrastruttura DNS, a condizione che i client risolvano il nome host della condivisione file nell'indirizzo IP dell'endpoint privato.

Note

Nel cloud pubblico di Azure, entrambi i provider di risorse utilizzano la zona DNS privata privatelink.file.core.windows.net. I nomi host dei loro client differiscono; vedi Verifica connettività per esempi. Per le condivisioni classiche di file in altri cloud Azure, usa il suffisso endpoint di storage per quel cloud. Controlla la disponibilità regionale prima di distribuire Microsoft.FileShares.

Classic rispetto a Microsoft.FileShares

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`)	Condivisione 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.

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.

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.

Ottieni 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

Ottieni un riferimento alla condivisione 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

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

Collega la zona DNS privata di Azure alla rete virtuale in modo che i client risolvano il nome host originale della condivisione file nell'indirizzo IP dell'endpoint privato. I seguenti passaggi si applicano a entrambi i fornitori di risorse.

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

Ottieni 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

Ottieni un riferimento alla condivisione 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)

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

Esegui i controlli da un client nella rete virtuale, o da una rete connessa con DNS configurato per risolvere l'endpoint privato. Per le differenze tra i provider di risorse, vedi risoluzione DNS. Usa il nome host originale per montare la condivisione, non il privatelink nome.

Esegui la seguente ricerca DNS da PowerShell, dalla riga di comando o da un terminale su Windows, Linux o macOS.

Sostituisci <storage-account-name> con il nome appropriato dell'account di archiviazione:

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

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

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

Usa 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).

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

Esegui i seguenti comandi PowerShell per verificare la risoluzione DNS:

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

Resolve-DnsName -Name $storageAccountHostName

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.

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

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.

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

Esegui i seguenti comandi per recuperare il nome host e verificare la risoluzione DNS:

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

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 montare la condivisione di file anziché il percorso privatelink.

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

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. Si deve comunque usare il hostName originale della condivisione file per montare la condivisione file invece del percorso privatelink.

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

Puoi disabilitare l'accesso pubblico alla rete o mantenerlo abilitato per reti selezionate. Queste sono configurazioni separate. Gli endpoint privati continuano a funzionare in entrambe le configurazioni.

Per le condivisioni file classiche, configura l'accesso pubblico sull'account di archiviazione. Per Microsoft.FileShares, configurarlo sulla singola condivisione file. Le condivisioni file classiche possono anche utilizzare un perimetro di sicurezza di rete, soggetto alle limitazioni del relativo protocollo. In modalità Enforced, un perimetro blocca il traffico NFS attraverso gli endpoint di servizio.

Disabilitare l'accesso all'endpoint pubblico

Quando disabiliti l'accesso alla rete pubblica, i client non possono connettersi tramite l'endpoint pubblico, inclusi gli endpoint di servizio. I client possono ancora connettersi tramite endpoint privati. Questa impostazione non limita il traffico in uscita dai client.

Note

Per le condivisioni file classiche, le eccezioni esistenti per servizi affidabili e istanze di risorse possono rimanere valide dopo aver disabilitato l'accesso alla rete pubblica. Rivedi queste eccezioni se hai bisogno di accesso solo tramite endpoint privati. Vedi limitazioni di sicurezza di rete di Archiviazione di Azure.

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.

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, imposta -PublicNetworkAccess su Disabled sull'account di archiviazione.

# Use the storage account variables from the beginning of this guide.
Set-AzStorageAccount `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name $storageAccountName `
        -PublicNetworkAccess Disabled `
        -ErrorAction Stop |
    Out-Null

Imposta -PublicNetworkAccess su Disabled nella condivisione di 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, imposta --public-network-access su Disabled sull'account di archiviazione.

# This assumes $storageAccountResourceGroupName and $storageAccountName
# are still defined from the beginning of this guide.
az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --public-network-access Disabled \
    --output none

Imposta --public-network-access su Disabled nella condivisione di 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

Per consentire ai client da subnet selezionate, mantenere abilitato l'accesso pubblico alla rete, abilitare gli endpoint di servizio su tali subnet e aggiungere le subnet alle regole di rete della risorsa. Puoi usare endpoint di servizio con o senza endpoint privati. L'accesso classico SMB e FileREST può anch'esso utilizzare regole di indirizzo IP; l'accesso NFS richiede subreti consentite.

Gli esempi di PowerShell e CLI assumono che l'accesso pubblico alla rete sia già abilitato. Gli esempi di Microsoft. FileShares assumono anche che la subnet client abbia già l'endpoint Microsoft.Storage del servizio. Per configurare quell'endpoint, vedi Abilita gli endpoint di servizio su una subnet.

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.
Per l'accesso SMB o FileREST, usa gli indirizzi IPv4 per specificare eventuali indirizzi IP internet pubblici che vuoi permettere. Le regole relative agli indirizzi IP non consentono l'accesso tramite NFS.
Se un'integrazione di un servizio richiede l'accesso a un servizio affidabile, seleziona la casella Consenti ai servizi Microsoft attendibili di accedere a questa risorsa.
Seleziona Salva.

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 `
        -VirtualNetworkRule $networkRule `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

Questi comandi preservano le impostazioni di bypass esistenti. Se un'integrazione richiede l'accesso a un servizio affidabile, aggiungi -Bypass AzureServices al comando update. Il parametro sostituisce l'impostazione di bypass, quindi includi tutte le altre opzioni di bypass che il tuo carico di lavoro richiede ancora.

Passa gli ID delle risorse di subnet consentiti a Update-AzFileShare usando -AllowedSubnet. Le regole di rete si applicano direttamente alla condivisione file, quindi non c'è un account di archiviazione da configurare. La subnet client necessita ancora di un endpoint di servizio, come descritto nei prerequisiti sopra.

# 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 \
        --default-action "Deny" \
        --output none

Questi comandi preservano le impostazioni di bypass esistenti. Se un'integrazione richiede l'accesso a un servizio affidabile, aggiungi --bypass AzureServices al comando update. L'opzione sostituisce l'impostazione di bypass, quindi includi tutte le altre opzioni di bypass che il tuo carico di lavoro richiede ancora.

Passa gli ID delle risorse di subnet consentiti a az fileshare update usando --allowed-subnets. Le regole di rete si applicano direttamente alla condivisione file, quindi non c'è un account di archiviazione da configurare. La subnet client necessita ancora di un endpoint di servizio, come descritto nei prerequisiti sopra.

# 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

Limita l'accesso in uscita a specifici account di archiviazione

Le regole di rete per una condivisione file controllano l'accesso in entrata. Non limitano a quali altre risorse di archiviazione tali client possono accedere. Per le condivisioni file classiche, puoi opzionalmente usare una policy di endpoint di servizio per limitare a quali account di archiviazione i client in una subnet possono accedere tramite endpoint di servizio. La policy filtra le destinazioni del traffico che bypassano Firewall di Azure e gli appliance virtuali di rete. Non limita altri percorsi in uscita né sostituisce le regole di rete e i requisiti di autorizzazione della destinazione. Per maggiori informazioni, vedi Restringi l'accesso in uscita con le policy degli endpoint di servizio.

Importante

Le policy degli endpoint di servizio attualmente non sono supportate per le condivisioni file Microsoft.FileShares. Un criterio applicato alla subnet del client blocca l’accesso a tali condivisioni di file tramite gli endpoint di servizio, anche se autorizza la sottoscrizione o il gruppo di risorse a cui appartengono. Questa restrizione si applica anche alle subnet che accedono sia alle condivisioni file classic che alle condivisioni file Microsoft.FileShares. I client in quella subnet devono utilizzare un endpoint privato per accedere alle condivisioni file Microsoft.FileShares.

Una policy di endpoint di servizio definisce le destinazioni di archiviazione consentite per i client nella subnet associata. Blocca quei client dall'accedere ad altri account di storage tramite i service endpoint. Tenere presenti questi punti:

Aggiungi ogni account di archiviazione che i client della subnet usano prima di associare la policy alla subnet. Questa lista include account di storage utilizzati da altri carichi di lavoro nella subnet.
Il criterio dell’endpoint di servizio deve trovarsi nella stessa area geografica e nella stessa sottoscrizione della rete virtuale.
Una policy può contenere una sola definizione di policy per il Microsoft.Storage servizio. Per permettere più account di storage, aggiungi i loro ID di risorse alla stessa definizione di policy. Puoi anche permettere a tutti gli account di archiviazione in un gruppo di risorse o in un abbonamento.
Dopo aver associato una policy a una subnet, la policy si applica al traffico verso account di archiviazione in tutte le regioni.
Questi passaggi presuppongono che la subnet non abbia politiche di endpoint di servizio. Se le politiche sono già associate, rivedi e aggiorna tali politiche invece di sostituirle. Gli esempi di PowerShell e CLI si fermano se trovano associazioni esistenti.

Per creare una policy di endpoint di servizio e associarla a una subnet, segui questi passaggi. Per passaggi dettagliati, vedi Crea e associa policy di endpoint di servizio.

Nella casella di ricerca in alto del portale Azure, inserisci Service endpoint policy. Selezionare Criteri endpoint servizio nei risultati della ricerca.
Seleziona + Crea.
Nella scheda Nozioni di base, seleziona l'abbonamento e la regione della tua rete virtuale. Seleziona un gruppo di risorse e inserisci un nome per il criterio.
Selezionare Avanti: Definizioni dei criteri.
Seleziona + Aggiungi una risorsa. Per il servizio, seleziona Microsoft.Storage. Per Ambito, seleziona Singolo account e poi seleziona l'account di archiviazione che contiene le condivisioni dei tuoi file. Selezionare Aggiungi. Ripeti questo passaggio per ogni account di archiviazione utilizzato dai client nella subnet.
Selezionare Rivedi e crea e quindi Crea.
Vai al nuovo criterio dell'endpoint di servizio. Dal menu di servizio, sotto Impostazioni, seleziona Subnet associate.
Seleziona + Modifica associazione subnet, seleziona la rete virtuale e la subnet, e poi seleziona Applica.

I seguenti comandi PowerShell creano una policy di endpoint di servizio e la associano a una subnet. La policy limita l'accesso dei client da quella subnet a un solo account di storage tramite l'endpoint di servizio. La subnet deve già avere l'endpoint Microsoft.Storage del servizio. Sostituire i valori segnaposto con i propri valori.

$storageAccountResourceGroupName = "<storage-account-resource-group>"
$storageAccountName = "<storage-account-name>"
$virtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$virtualNetworkName = "<vnet-name>"
$subnetName = "<subnet-name>"
$policyName = "<service-endpoint-policy-name>"

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

$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $virtualNetworkName `
        -ErrorAction Stop

$subnet = $virtualNetwork.Subnets | Where-Object { $_.Name -eq $subnetName }
if ($null -eq $subnet) {
    throw "Subnet '$subnetName' wasn't found in virtual network '$virtualNetworkName'."
}

if ($subnet.ServiceEndpointPolicies.Count -gt 0) {
    throw "The subnet already has service endpoint policies. Review and update them before changing the configuration."
}

# To allow clients to access more storage accounts, add their resource IDs to -ServiceResource.
$policyDefinition = New-AzServiceEndpointPolicyDefinition `
        -Name "allowed-storage-accounts" `
        -Service "Microsoft.Storage" `
        -ServiceResource @($storageAccount.Id) `
        -ErrorAction Stop

$policy = New-AzServiceEndpointPolicy `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $policyName `
        -Location $virtualNetwork.Location `
        -ServiceEndpointPolicyDefinition $policyDefinition `
        -ErrorAction Stop

$subnet.ServiceEndpointPolicies = @($policy)
$virtualNetwork | Set-AzVirtualNetwork -ErrorAction Stop | Out-Null

I seguenti comandi CLI creano una policy di endpoint di servizio e la associano a una subrete. La policy limita l'accesso dei client da quella subnet a un solo account di storage tramite l'endpoint di servizio. La subnet deve già avere l'endpoint Microsoft.Storage del servizio. Sostituire i valori segnaposto con i propri valori.

storageAccountResourceGroupName="<storage-account-resource-group>"
storageAccountName="<storage-account-name>"
virtualNetworkResourceGroupName="<vnet-resource-group-name>"
virtualNetworkName="<vnet-name>"
subnetName="<subnet-name>"
policyName="<service-endpoint-policy-name>"

existingPolicyIds=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "serviceEndpointPolicies[].id" --output tsv) || exit 1

if [ -n "$existingPolicyIds" ]; then
    echo "The subnet already has service endpoint policies. Review and update them before changing the configuration." >&2
    exit 1
fi

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

location=$(az network vnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --name $virtualNetworkName \
        --query "location" --output tsv) || exit 1

az network service-endpoint policy create \
        --resource-group $virtualNetworkResourceGroupName \
        --name $policyName \
        --location $location \
        --output none || exit 1

# To allow clients to access more storage accounts, add their resource IDs to --service-resources.
az network service-endpoint policy-definition create \
        --resource-group $virtualNetworkResourceGroupName \
        --policy-name $policyName \
        --name "allowed-storage-accounts" \
        --service "Microsoft.Storage" \
        --service-resources $storageAccountId \
        --output none || exit 1

az network vnet subnet update \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --service-endpoint-policy $policyName \
        --output none || exit 1

Per accedere a una condivisione file Microsoft. FileShares da una subnet che ha una policy di service endpoint, crea un endpoint privato per la condivisione file. Le policy dei service endpoint non si applicano al traffico che passa attraverso un endpoint privato.

Vedere anche

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-10-05