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

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

La procedura guidata risultante include più pagine da completare.

Nel pannello Dati principali selezionare la sottoscrizione, il gruppo di risorse, il nome, il nome dell'interfaccia di rete e l'area desiderati 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 si utilizzano condivisioni di file classiche:

Nel pannello Risorsa scegliere Microsoft. Storage/storageAccounts dal menu a discesa per il tipo di risorsa. Selezionare quindi l'account di archiviazione specifico a cui connettersi come risorsa. La sotto-risorsa di destinazione verrà popolata automaticamente con file. Selezionare Avanti: Rete virtuale.

Se si usa la nuova condivisione file:

Nel pannello Risorsa scegliere Microsoft. FileShares/fileShares dal menu a discesa per il tipo di risorsa. Selezionare quindi la condivisione file specifica a cui connettersi come risorsa. La sotto-risorsa di destinazione verrà popolata automaticamente con FileShare. 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 dell'indirizzo IP statico o dinamico 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.

Per creare un endpoint privato, è prima necessario ottenere un riferimento all'account di archiviazione o alla condivisione file e alla subnet della rete virtuale a cui si vuole aggiungere l'endpoint privato. Sostituire i valori segnaposto seguenti con i valori personalizzati.

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

La creazione di una zona DNS privata di Azure consente al nome host originale di risolversi 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 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, è prima necessario ottenere un riferimento all'account di archiviazione o alla condivisione file, oltre alla subnet di rete virtuale a cui si vuole aggiungere l'endpoint privato. Sostituire i valori segnaposto seguenti con i valori personalizzati.

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 fileshares extension
az extension add --name fileshares

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 precedenti, 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, 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)

La creazione di una zona DNS privata di Azure consente al nome host originale di risolversi 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'identità utente di AD o per l'accesso 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

Se si dispone di una macchina virtuale all'interno della rete virtuale o se 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, 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, verrà 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

Se si dispone di una macchina virtuale all'interno della rete virtuale o se 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:

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, verrà 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

Se si dispone di una macchina virtuale all'interno della rete virtuale o se 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:

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, verrà 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

Per le condivisioni di file classiche:

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 dalle reti virtuali e dagli indirizzi IP selezionati. 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 ai servizi Microsoft attendibili come Sincronizzazione file di Azure di accedere all'account di archiviazione.

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

Passare alla condivisione file per 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. Il parametro -Bypass è impostato 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 di file create con il provider di risorse Microsoft.FileShares, impostare -PublicNetworkAccess su Disabled sulla condivisione di file.

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

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

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

Per le condivisioni file classiche, il seguente comando da riga di comando nega tutto il traffico diretto all'endpoint pubblico dell'account di archiviazione. Il parametro --bypass è impostato 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 di file create con il provider di risorse Microsoft.FileShares, impostare --public-network-access su Disabled sulla condivisione di file.

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

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

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

Per le condivisioni di file classiche:

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 dalle reti virtuali e dagli indirizzi IP selezionati. 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 tale rete virtuale, quindi selezionare Abilita.

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

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

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

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

$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 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, è possibile passare direttamente gli ID risorsa delle subnet consentite a Update-AzFileShare tramite -PublicAccessPropertyAllowedSubnet. Non è richiesta alcuna configurazione separata dell'endpoint di servizio o della regola di rete nell'account di archiviazione.

# To learn more about the Az.FileShare module, see https://www.powershellgallery.com/packages/Az.FileShare/0.1.0
Install-Module -Name Az.FileShare -Repository psgallery -RequiredVersion 0.1.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 `
        -PublicAccessPropertyAllowedSubnet @($subnet.Id)

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

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)

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 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, passare gli ID delle risorse delle subnet consentite direttamente a az fileshare update utilizzando --allowed-subnets. Non è necessaria alcuna configurazione separata dell'endpoint di servizio o della regola di rete nell'account di archiviazione.

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

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