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. Selezionare + Crea e cercare Endpoint privato. Selezionare la risorsa dell'endpoint privato e quindi selezionare Crea.

La procedura guidata include più pagine da completare.

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

Se si utilizzano condivisioni di file classiche:

Nella pagina Risorsa, scegliere Microsoft.Storage/storageAccounts dal menu a discesa del tipo di risorsa. Selezionare quindi l'account di archiviazione specifico a cui connettersi come risorsa. La sotto-risorsa di destinazione viene popolata automaticamente con file. Selezionare Avanti: Rete virtuale.

Se si usa la nuova condivisione file:

Nella pagina 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 viene popolata automaticamente con FileShare. Selezionare Avanti: Rete virtuale.

La pagina Rete virtuale consente di selezionare il virtual network e la subnet specifici a cui si vuole aggiungere l'endpoint privato. Selezionare l'allocazione dell'indirizzo IP statico o dinamico per il nuovo endpoint privato. Se si seleziona statico, è necessario specificare anche un nome e un indirizzo IP privato. È anche possibile specificare facoltativamente un gruppo di sicurezza delle applicazioni. Al termine, selezionare Avanti: DNS.

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

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

Infine, selezionare Crea per creare l'endpoint privato.

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

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

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

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

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

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

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

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

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

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

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

 # Disable private endpoint network policies
 $subnet.PrivateEndpointNetworkPolicies = "Disabled"
 $virtualNetwork = $virtualNetwork | `
     Set-AzVirtualNetwork -ErrorAction Stop
 
 # Create a private link service connection.
 $privateEndpointConnection = New-AzPrivateLinkServiceConnection `
         -Name "$dnsRecordName-Connection" `
         -PrivateLinkServiceId $privateLinkResourceId `
         -GroupId $groupId `
         -ErrorAction Stop
 
 # Create a new private endpoint.
 $privateEndpoint = New-AzPrivateEndpoint `
         -ResourceGroupName $resourceGroupName `
         -Name "$dnsRecordName-PrivateEndpoint" `
         -Location $virtualNetwork.Location `
         -Subnet $subnet `
         -PrivateLinkServiceConnection $privateEndpointConnection `
         -ErrorAction Stop

Se si crea una zona DNS privata di Azure, il nome host originale viene risolto nell'indirizzo IP privato all'interno della rete virtuale. Sebbene 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, ottenere prima di tutto un riferimento all'account di archiviazione o alla condivisione file, oltre alla subnet della rete virtuale in cui si vuole aggiungere l'endpoint privato. Sostituire i valori segnaposto nei passaggi seguenti con i propri valori.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Se si crea una zona DNS privato di Azure, il nome host originale viene risolto in un indirizzo IP privato all'interno della rete virtuale. Anche se facoltativo dal punto di vista della creazione di un endpoint privato, è necessario per montare la condivisione file Azure usando un'entità utente di Active Directory o accedendo 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 si è configurato l'inoltro DNS come descritto in Configurazione dell'inoltro DNS per File di Azure, è possibile verificare che l'endpoint privato sia configurato correttamente. Eseguire i comandi seguenti da PowerShell, dalla riga di comando o dal terminale (funziona per Windows, Linux o macOS).

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

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

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

nslookup <file-share-host-name>

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

Per le condivisioni di file classiche:

Server:  UnKnown
Address:  10.2.4.4

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

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

Server:  UnKnown
Address:  10.2.4.4

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

Se si dispone di una macchina virtuale all'interno della rete virtuale o si è configurato l'inoltro DNS come descritto in Configurazione dell'inoltro DNS per File di Azure, è possibile verificare che l'endpoint privato sia configurato correttamente eseguendo i comandi seguenti:

Per le condivisioni di file classiche:

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

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

 Resolve-DnsName -Name $fileShare.HostName

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

Per le condivisioni di file classiche:

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

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

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

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

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

Se si dispone di una macchina virtuale all'interno della rete virtuale o si è configurato l'inoltro DNS come descritto in Configurazione dell'inoltro DNS per File di Azure, è possibile verificare che l'endpoint privato sia configurato correttamente eseguendo i comandi seguenti:

Per le condivisioni di file classiche:

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

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

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

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

nslookup $hostName

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

Per le condivisioni di file classiche:

Server:         127.0.0.53
Address:        127.0.0.53#53

Non-authoritative answer:
storageaccount.file.core.windows.net      canonical name = storageaccount.privatelink.file.core.windows.net.
Name:   storageaccount.privatelink.file.core.windows.net
Address: 192.168.0.5

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

Server:         127.0.0.53
Address:        127.0.0.53#53

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

Per le condivisioni di file classiche:

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

Nella parte superiore della pagina selezionare l'opzione Abilitato dalle reti virtuali e dagli indirizzi IP selezionati . Questa selezione rivela le impostazioni per controllare la 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.

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

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

Per le condivisioni file classiche, il comando di PowerShell seguente nega tutto il traffico all'endpoint pubblico dell'account di archiviazione. Impostare il -Bypass parametro su AzureServices per consentire ai servizi proprietari attendibili, ad esempio Sincronizzazione file di Azure di accedere all'account di archiviazione tramite l'endpoint pubblico.

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

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

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

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

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

Per le condivisioni file classiche, il comando CLI seguente blocca tutto il traffico verso l'endpoint pubblico dell'account di archiviazione. Impostare il --bypass parametro su AzureServices per consentire ai servizi proprietari attendibili, ad esempio Sincronizzazione file di Azure di accedere all'account di archiviazione tramite l'endpoint pubblico.

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

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

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

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

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

Per le condivisioni di file classiche:

Passare all'account di archiviazione in cui si vuole limitare l'endpoint pubblico a reti virtuali specifiche. Nel sommario per l'account di archiviazione selezionare Rete.

Nella parte superiore della pagina selezionare l'opzione Abilitato dalle reti virtuali e dagli indirizzi IP selezionati . Questa selezione rivela una serie di impostazioni per controllare la 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 presenti nell'elenco dei servizi attendibili di accedere a questo account di archiviazione per consentire ai servizi Microsoft proprietari attendibili, ad esempio 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 in 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, aggiungere le reti virtuali e le subnet autorizzate ad accedere alla condivisione e selezionare Salva.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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=$(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 servizio alla subnet della rete virtuale. I seguenti comandi CLI aggiungono l'endpoint di servizio Microsoft.Storage alla subnet, se non è già incluso.

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

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

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

    for serviceEndpoint in $serviceEndpoints
    do
        serviceEndpointList+=$serviceEndpoint
        serviceEndpointList+=" "
    done

    serviceEndpointList+="Microsoft.Storage"

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

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

az storage account network-rule add \
        --resource-group $storageAccountResourceGroupName \
        --account-name $storageAccountName \
        --subnet $subnet \
        --output none

az storage account update \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --bypass "AzureServices" \
        --default-action "Deny" \
        --output none

Per le condivisioni di file create con il provider di risorse Microsoft.FileShares, passa direttamente gli ID delle risorse delle subnet consentite a az fileshare update tramite --allowed-subnets. Non è necessario configurare un endpoint di servizio separato né regole di rete nell'account di archiviazione.

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

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

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

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