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

Articolo
05/10/2024

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 e sono accessibili da qualsiasi parte del mondo.
Endpoint privati, presenti all'interno di una rete virtuale, che hanno un indirizzo IP privato all'interno dello spazio di indirizzi della rete virtuale.

Gli endpoint pubblici e privati sono disponibili nell'account di archiviazione di Azure. Un account di archiviazione è un costrutto di gestione che rappresenta un pool di archiviazione condiviso in cui è possibile distribuire più condivisioni file oltre ad altre risorse di archiviazione, ad esempio contenitori BLOB o code.

Questo articolo è incentrato su come configurare gli endpoint di un account di archiviazione per l'accesso diretto alle condivisioni file di 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 altre informazioni sulle considerazioni sulla rete per Sincronizzazione file di Azure, vedere Configurazione delle impostazioni proxy e firewall Sincronizzazione file di Azure.

È consigliabile leggere File di Azure considerazioni sulla rete prima di leggere questa guida.

Si applica a

Tipo di condivisione file	SMB	NFS
Condivisioni file Standard (GPv2), archiviazione con ridondanza locale/archiviazione con ridondanza della zona
Condivisioni file Standard (GPv2), archiviazione con ridondanza geografica/archiviazione con ridondanza geografica della zona
Condivisioni file Premium (FileStorage), archiviazione con ridondanza locale/archiviazione con ridondanza della zona

Prerequisiti

Questo articolo presuppone che sia già stata creata una sottoscrizione di Azure. Se non si ha già una sottoscrizione, creare un account gratuito prima di iniziare.
Questo articolo presuppone che sia già stata creata una condivisione file di Azure in un account di archiviazione a cui ci si vuole connettere dall'ambiente locale. Per informazioni su come creare una condivisione file di Azure, vedere Creare una condivisione file di Azure.
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.

Configurazioni degli endpoint

È possibile configurare gli endpoint per limitare l'accesso di rete all'account di archiviazione. Per limitare l'accesso a un account di archiviazione consentendolo solo a una rete virtuale, sono disponibili due approcci:

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

Creare un endpoint privato

Quando si crea un endpoint privato per l'account di archiviazione, vengono distribuite le risorse di Azure seguenti:

Endpoint privato: una risorsa di Azure che rappresenta l'endpoint privato dell'account di archiviazione. È possibile considerarlo come una risorsa che connette un account di archiviazione e un'interfaccia di rete.
Interfaccia di rete :interfaccia di rete che gestisce un indirizzo IP privato all'interno della rete virtuale/subnet specificata. Si tratta della stessa risorsa che viene distribuita quando si distribuisce una macchina virtuale (VM), ma anziché essere assegnata a una macchina virtuale, è di proprietà dell'endpoint privato.
Zona DNS (Domain Name System) privato: se non è stato distribuito un endpoint privato per questa rete virtuale, verrà distribuita una nuova zona DNS privata per la rete virtuale. In questa zona DNS verrà inoltre creato un record A DNS. Se in questa rete virtuale è già stato distribuito un endpoint privato, nella zona DNS esistente verrà aggiunto un nuovo record A per l'account di archiviazione. La distribuzione di una zona DNS è facoltativa. Tuttavia, è consigliabile e necessario se si montano le condivisioni file di Azure con un'entità servizio di Active Directory o si usa l'API FileREST.

Nota

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

Passare all'account di archiviazione per cui creare un endpoint privato. Nel sommario per l'account di archiviazione selezionare Rete, Connessioni endpoint privato e quindi + Endpoint privato per creare un nuovo endpoint privato.

La procedura guidata risultante include più pagine da completare.

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

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

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

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

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

Fare clic su Rivedi e crea per creare l'endpoint privato.

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

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

# Get storage account reference, and throw error if it doesn't exist
$storageAccount = Get-AzStorageAccount `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name $storageAccountName `
        -ErrorAction SilentlyContinue

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

# Get virtual network reference, and throw error if it doesn't exist
$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $virtualNetworkName `
        -ErrorAction SilentlyContinue

if ($null -eq $virtualNetwork) {
    $errorMessage = "Virtual network $virtualNetworkName not found "
    $errorMessage += "in resource group $virtualNetworkResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Get reference to virtual network subnet, and throw error if it doesn't exist
$subnet = $virtualNetwork | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    Write-Error `
            -Message "Subnet $subnetName not found in virtual network $virtualNetworkName." `
            -ErrorAction Stop
}

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

# Disable private endpoint network policies
$subnet.PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork = $virtualNetwork | `
    Set-AzVirtualNetwork -ErrorAction Stop

# Create a private link service connection to the storage account.
$privateEndpointConnection = New-AzPrivateLinkServiceConnection `
        -Name "$storageAccountName-Connection" `
        -PrivateLinkServiceId $storageAccount.Id `
        -GroupId "file" `
        -ErrorAction Stop

# Create a new private endpoint.
$privateEndpoint = New-AzPrivateEndpoint `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name "$storageAccountName-PrivateEndpoint" `
        -Location $virtualNetwork.Location `
        -Subnet $subnet `
        -PrivateLinkServiceConnection $privateEndpointConnection `
        -ErrorAction Stop

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

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done like this so this script will seamlessly work for non-public Azure.
$storageAccountSuffix = Get-AzContext | `
    Select-Object -ExpandProperty Environment | `
    Select-Object -ExpandProperty StorageEndpointSuffix

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

# Find a DNS zone matching desired name attached to this virtual network.
$dnsZone = Get-AzPrivateDnsZone | `
    Where-Object { $_.Name -eq $dnsZoneName } | `
    Where-Object {
        $privateDnsLink = Get-AzPrivateDnsVirtualNetworkLink `
                -ResourceGroupName $_.ResourceGroupName `
                -ZoneName $_.Name `
                -ErrorAction SilentlyContinue
        
        $privateDnsLink.VirtualNetworkId -eq $virtualNetwork.Id
    }

if ($null -eq $dnsZone) {
    # No matching DNS zone attached to virtual network, so create new one.
    $dnsZone = New-AzPrivateDnsZone `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -Name $dnsZoneName `
            -ErrorAction Stop

    $privateDnsLink = New-AzPrivateDnsVirtualNetworkLink `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -ZoneName $dnsZoneName `
            -Name "$virtualNetworkName-DnsLink" `
            -VirtualNetworkId $virtualNetwork.Id `
            -ErrorAction Stop
}

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

$privateEndpointIP = $privateEndpoint | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object @{ 
        Name = "NetworkInterfaces"; 
        Expression = { Get-AzNetworkInterface -ResourceId $_.Id } 
    } | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty IpConfigurations | `
    Select-Object -ExpandProperty PrivateIpAddress

$privateDnsRecordConfig = New-AzPrivateDnsRecordConfig `
        -IPv4Address $privateEndpointIP

New-AzPrivateDnsRecordSet `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $storageAccountName `
        -RecordType A `
        -ZoneName $dnsZoneName `
        -Ttl 600 `
        -PrivateDnsRecords $privateDnsRecordConfig `
        -ErrorAction Stop | `
    Out-Null

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

# Get storage account ID 
storageAccount=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" | \
    tr -d '"')

# Get virtual network ID
virtualNetwork=$(az network vnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --name $virtualNetworkName \
        --query "id" | \
    tr -d '"')

# Get subnet ID
subnet=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "id" | \
    tr -d '"')

Per creare un endpoint privato, è prima di tutto necessario assicurarsi che i criteri di rete dell'endpoint privato della subnet siano disabilitati. Quindi, è possibile creare un endpoint privato con il comando az network private-endpoint create.

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

# Get virtual network location
region=$(az network vnet show \
        --ids $virtualNetwork \
        --query "location" | \
    tr -d '"')

# Create a private endpoint
privateEndpoint=$(az network private-endpoint create \
        --resource-group $storageAccountResourceGroupName \
        --name "$storageAccountName-PrivateEndpoint" \
        --location $region \
        --subnet $subnet \
        --private-connection-resource-id $storageAccount \
        --group-id "file" \
        --connection-name "$storageAccountName-Connection" \
        --query "id" | \
    tr -d '"')

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

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done like this so this script will seamlessly work for non-public Azure.
storageAccountSuffix=$(az cloud show \
        --query "suffixes.storageEndpoint" | \
    tr -d '"')

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

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

dnsZone=""
possibleDnsZone=""
for possibleDnsZone in $possibleDnsZones
do
    possibleResourceGroupName=$(az resource show \
            --ids $possibleDnsZone \
            --query "resourceGroup" | \
        tr -d '"')
    
    link=$(az network private-dns link vnet list \
            --resource-group $possibleResourceGroupName \
            --zone-name $dnsZoneName \
            --query "[?virtualNetwork.id == '$virtualNetwork'].id" \
            --output tsv)
    
    if [ -z $link ]
    then
        echo "1" > /dev/null
    else 
        dnsZoneResourceGroup=$possibleResourceGroupName
        dnsZone=$possibleDnsZone
        break
    fi  
done

if [ -z $dnsZone ]
then
    # No matching DNS zone attached to virtual network, so create a new one
    dnsZone=$(az network private-dns zone create \
            --resource-group $virtualNetworkResourceGroupName \
            --name $dnsZoneName \
            --query "id" | \
        tr -d '"')
    
    az network private-dns link vnet create \
            --resource-group $virtualNetworkResourceGroupName \
            --zone-name $dnsZoneName \
            --name "$virtualNetworkName-DnsLink" \
            --virtual-network $virtualNetwork \
            --registration-enabled false \
            --output none
    
    dnsZoneResourceGroup=$virtualNetworkResourceGroupName
fi

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

privateEndpointNIC=$(az network private-endpoint show \
        --ids $privateEndpoint \
        --query "networkInterfaces[0].id" | \
    tr -d '"')

privateEndpointIP=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[0].privateIPAddress" | \
    tr -d '"')

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

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

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). È necessario sostituire <storage-account-name> con il nome dell'account di archiviazione appropriato:

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

In caso di esito positivo, verrà visualizzato l'output seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale (output mostrato per Windows):

Server:  UnKnown
Address:  10.2.4.4

Non-authoritative answer:
Name:    storageaccount.privatelink.file.core.windows.net
Address:  192.168.0.5
Aliases:  storageaccount.file.core.windows.net

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

Resolve-DnsName -Name $storageAccountHostName

In caso di esito positivo, verrà visualizzato l'output seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale:

Name                             Type   TTL   Section    NameHost
----                             ----   ---   -------    --------
storageaccount.file.core.windows CNAME  60    Answer     storageaccount.privatelink.file.core.windows.net
.net

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

httpEndpoint=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "primaryEndpoints.file" | \
    tr -d '"')

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

Se tutto ha esito positivo, verrà visualizzato l'output seguente, dove 192.168.0.5 è l'indirizzo IP privato dell'endpoint privato nella rete virtuale. È comunque consigliabile usare storageaccount.file.core.windows.net per montare la condivisione file anziché il privatelink percorso.

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

Limitare l'accesso agli endpoint pubblici

La limitazione dell'accesso all'endpoint pubblico richiede innanzitutto di disabilitare l'accesso generale all'endpoint pubblico. La disabilitazione dell'accesso all'endpoint pubblico non influisce sugli endpoint privati. Dopo aver disabilitato l'endpoint pubblico, è possibile selezionare reti o indirizzi IP specifici che potrebbero 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.

Disabilitare l'accesso all'endpoint pubblico

Se si disabilita l'accesso all'endpoint pubblico, l'account di archiviazione rimane comunque accessibile tramite i relativi endpoint privati. In caso contrario, le richieste valide all'endpoint pubblico dell'account di archiviazione verranno rifiutate, a meno che non provenano da un'origine specificatamente consentita.

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

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

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

# This assumes $storageAccount is still defined from the beginning of this of this guide.
$storageAccount | Update-AzStorageAccountNetworkRuleSet `
        -DefaultAction Deny `
        -Bypass AzureServices `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

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

# This assumes $storageAccountResourceGroupName and $storageAccountName 
# are still defined from the beginning of this guide.
az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --bypass "AzureServices" \
    --default-action "Deny" \
    --output none

Limitare l'accesso all'endpoint pubblico consentendolo solo a reti virtuali specifiche

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

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

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

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

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

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

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

$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $restrictToVirtualNetworkResourceGroupName `
        -Name $restrictToVirtualNetworkName `
        -ErrorAction Stop

$subnet = $virtualNetwork | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    Write-Error `
            -Message "Subnet $subnetName not found in virtual network $restrictToVirtualNetworkName." `
            -ErrorAction Stop
}

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

$serviceEndpoints = $subnet | `
    Select-Object -ExpandProperty ServiceEndpoints | `
    Select-Object -ExpandProperty Service

if ($serviceEndpoints -notcontains "Microsoft.Storage") {
    if ($null -eq $serviceEndpoints) {
        $serviceEndpoints = @("Microsoft.Storage")
    } elseif ($serviceEndpoints -is [string]) {
        $serviceEndpoints = @($serviceEndpoints, "Microsoft.Storage")
    } else {
        $serviceEndpoints += "Microsoft.Storage"
    }

    $virtualNetwork = $virtualNetwork | Set-AzVirtualNetworkSubnetConfig `
            -Name $subnetName `
            -AddressPrefix $subnet.AddressPrefix `
            -ServiceEndpoint $serviceEndpoints `
            -WarningAction SilentlyContinue `
            -ErrorAction Stop | `
        Set-AzVirtualNetwork `
            -ErrorAction Stop
}

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

$networkRule = $storageAccount | Add-AzStorageAccountNetworkRule `
    -VirtualNetworkResourceId $subnet.Id `
    -ErrorAction Stop

$storageAccount | Update-AzStorageAccountNetworkRuleSet `
        -DefaultAction Deny `
        -Bypass AzureServices `
        -VirtualNetworkRule $networkRule `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

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

storageAccount=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" | \
    tr -d '"')

virtualNetwork=$(az network vnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --name $restrictToVirtualNetworkName \
        --query "id" | \
    tr -d '"')

subnet=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "id" | \
    tr -d '"')

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

serviceEndpoints=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "serviceEndpoints[].service" \
        --output tsv)

foundStorageServiceEndpoint=false
for serviceEndpoint in $serviceEndpoints
do
    if [ $serviceEndpoint = "Microsoft.Storage" ]
    then
        foundStorageServiceEndpoint=true
    fi
done

if [ $foundStorageServiceEndpoint = false ] 
then
    serviceEndpointList=""

    for serviceEndpoint in $serviceEndpoints
    do
        serviceEndpointList+=$serviceEndpoint
        serviceEndpointList+=" "
    done
    
    serviceEndpointList+="Microsoft.Storage"

    az network vnet subnet update \
            --ids $subnet \
            --service-endpoints $serviceEndpointList \
            --output none
fi