Configurar pontos de extremidade de rede para acessar compartilhamentos de arquivos do Azure

Acesse o grupo de recursos no qual você deseja criar um ponto de extremidade privado. Selecione + Criar e pesquise por Private Endpoint. Selecione o recurso de ponto de extremidade privado e, em seguida, selecione Criar.

O assistente tem várias páginas a serem preenchidas.

Na página Noções básicas , selecione a assinatura, o grupo de recursos, o nome, o nome da interface de rede e a região do ponto de extremidade privado. Você deve criar o ponto de extremidade privado na mesma região que a rede virtual na qual deseja criar o ponto de extremidade privado. Em seguida, selecione Avançar: Recurso .

Se você está usando compartilhamentos clássicos de arquivos em uma conta de armazenamento:

Na página Recurso, selecione Microsoft.Storage/storageAccounts no menu suspenso de Tipo de recurso. Para o Resource, selecione a conta de armazenamento específica à qual você quer se conectar. Para o sub-recurso de destino, selecione file. Selecione Próximo: Rede Virtual.

Se você estiver usando compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares:

Na página Recurso, selecione Microsoft.FileShares/fileShares no menu suspenso de Tipo de recurso. Para o Resource, selecione o compartilhamento de arquivos específico ao qual você quer se conectar. O sub-recurso de destino é preenchido automaticamente com FileShare. Selecione Próximo: Rede Virtual.

A página Rede Virtual permite que você selecione a virtual network específica e a sub-rede à qual deseja adicionar seu ponto de extremidade privado. Selecione a alocação de endereço IP dinâmico ou estático para o novo ponto de extremidade privado. Se você selecionar estático, também precisará fornecer um nome e um endereço IP privado. Você também pode especificar um grupo de segurança do aplicativo. Quando terminar, selecione Avançar: DNS.

A página DNS contém as informações para integrar seu ponto de extremidade privado a uma zona DNS privada. Verifique se a assinatura e o grupo de recursos estão corretos e selecione Avançar: Marcas.

Opcionalmente, você pode aplicar marcas para categorizar seus recursos, como aplicar o Ambiente de nome e o Teste de valor a todos os recursos de teste. Insira pares de nome/valor, se desejar, e selecione Avançar: Examinar + criar.

Selecione Criar para criar o ponto de extremidade privado.

Para criar um ponto de extremidade privado, primeiro obtenha uma referência à sua conta de armazenamento ou ao compartilhamento de arquivos e à sub-rede de rede virtual em que você deseja adicionar o ponto de extremidade privado. Substitua os valores de marcador no código a seguir pelos seus próprios valores.

Para compartilhamentos de arquivos clássicos, obtenha uma referência à conta de armazenamento:

$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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, obtenha uma referência para o compartilhamento de arquivos:

 $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

Depois de definir as variáveis comuns, as etapas restantes são as mesmas para ambas as experiências. Obtenha referências à rede virtual e à sub-rede:

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

Para criar um ponto de extremidade privado, você deve criar uma conexão com um serviço de link privado. A conexão do serviço de link privado é uma entrada para a criação do ponto de extremidade privado.

 # 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 você criar uma zona DNS privada do Azure, o nome de host original será resolvido para o IP privado dentro da rede virtual. Embora opcional do ponto de vista de criar um endpoint privado, é explicitamente necessário para montar o compartilhamento de arquivos do Azure diretamente usando um principal de usuário do Active Directory (AD) ou acessando via a 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
 }

Agora que você tem uma referência à zona DNS privada, você deve criar um registro.

 $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

Para criar um ponto de extremidade privado, primeiro obtenha uma referência à sua conta de armazenamento ou compartilhamento de arquivos, além da sub-rede de rede virtual em que você deseja adicionar o ponto de extremidade privado. Substitua os valores de marcador nas etapas a seguir pelos seus próprios valores.

Para compartilhamentos de arquivos clássicos, obtenha uma referência à conta de armazenamento:

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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, obtenha uma referência para o compartilhamento de arquivos:

# 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

Depois de definir as variáveis comuns, as etapas restantes são as mesmas para ambas as experiências. Obtenha referências à rede virtual e à sub-rede:

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)

Para criar um ponto de extremidade privado, verifique se a política de rede de ponto de extremidade privado da sub-rede está desabilitada e crie o ponto de extremidade privado com 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 você criar uma zona DNS privada do Azure, o nome de host original será resolvido para o IP privado dentro da rede virtual. Embora opcional do ponto de vista de criar um endpoint privado, é necessário para montar o compartilhamento de arquivos do Azure usando um principal de usuário do AD ou acessando pela 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

Agora que você tem uma referência à zona DNS privada, crie um registro 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 você tiver uma VM dentro de sua rede virtual ou tiver configurado o encaminhamento de DNS conforme descrito na configuração do encaminhamento de DNS para Arquivos do Azure, poderá testar se o ponto de extremidade privado está configurado corretamente. Execute os seguintes comandos do PowerShell, da linha de comando ou do terminal (funciona para Windows, Linux ou macOS).

Para compartilhamentos de arquivos clássicos, substitua <storage-account-name> pelo nome de conta de armazenamento apropriado:

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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, use o nome do host do compartilhamento de arquivos. Na guia Visão geral do compartilhamento de arquivos, selecione visualização JSON no canto superior direito. No modo de exibição JSON, em propriedades, copie o valor para hostName. O formato se parece com fs-xxxxxxxxxxxxxxxxx.xx.file.storage.azure.net.

nslookup <file-share-host-name>

Se tiver êxito, você verá uma saída semelhante à seguinte, onde 192.168.0.5 está o endereço IP privado do ponto de extremidade privado em sua rede virtual (saída mostrada para Windows).

Para compartilhamentos de arquivos clássicos:

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

Para compartilhamentos de arquivos criados no provedor de recursos 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 você tiver uma VM dentro de sua rede virtual ou tiver configurado o encaminhamento DNS conforme descrito na configuração do encaminhamento DNS para Arquivos do Azure, poderá testar se o ponto de extremidade privado está configurado corretamente executando os seguintes comandos:

Para compartilhamentos de arquivos clássicos:

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

Para compartilhamentos de arquivos criados no provedor de recursos Microsoft.FileShares:

 Resolve-DnsName -Name $fileShare.HostName

Se tiver êxito, você verá uma saída semelhante à seguinte, em que 192.168.0.5 é o endereço IP privado do endpoint privado em sua rede virtual.

Para compartilhamentos de arquivos clássicos:

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

Para compartilhamentos de arquivos criados no provedor de recursos 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 você tiver uma VM dentro de sua rede virtual ou tiver configurado o encaminhamento DNS conforme descrito na configuração do encaminhamento DNS para Arquivos do Azure, poderá testar se o ponto de extremidade privado está configurado corretamente executando os seguintes comandos:

Para compartilhamentos de arquivos clássicos:

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

Para compartilhamentos de arquivos criados no provedor de recursos Microsoft.FileShares:

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

nslookup $hostName

Se tiver êxito, você verá uma saída semelhante à seguinte, em que 192.168.0.5 é o endereço IP privado do endpoint privado em sua rede virtual. Você ainda deve usar o nome de host original (storageaccount.file.core.windows.net para clássico, ou o hostName do compartilhamento de arquivo para a nova experiência) para montar o compartilhamento de arquivo, em vez do caminho privatelink.

Para compartilhamentos de arquivos clássicos:

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

Para compartilhamentos de arquivos criados no provedor de recursos 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

Para desativar o acesso público à rede para compartilhamentos clássicos de arquivos, siga estes passos:

1. Vá para a conta de armazenamento onde você quer restringir todo o acesso de entrada ao endpoint público.
2. No menu de serviço, em Segurança + Rede, selecione Rede.
3. Em Acesso à rede pública, selecione Gerenciar.
4. Selecione Desativar e depois selecione Prosseguir.
5. Selecione Salvar.

Para compartilhamentos de arquivos criados no provedor de recursos Microsoft.FileShares:

Vá para o compartilhamento de arquivos em que você deseja desabilitar o acesso público. No menu de serviço, em Configurações, selecione Configuração. Defina o acesso à rede pública como Desabilitado e selecione Salvar.

Para compartilhamentos de arquivos clássicos, o comando do PowerShell a seguir nega todo o tráfego para o ponto de extremidade público da conta de armazenamento. Defina o parâmetro -Bypass como AzureServices, para permitir que serviços primários confiáveis, como o Sincronização de Arquivos do Azure, acessem a conta de armazenamento por meio do ponto de extremidade público.

# 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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, defina -PublicNetworkAccess como Disabled no compartilhamento de arquivos.

# 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

Para compartilhamentos de arquivos clássicos, o comando da CLI a seguir bloqueia todo o tráfego para o ponto de extremidade público da conta de armazenamento. Defina o parâmetro --bypass como AzureServices, para permitir que serviços primários confiáveis, como o Sincronização de Arquivos do Azure, acessem a conta de armazenamento por meio do ponto de extremidade público.

# 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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, defina --public-network-access como Disabled no compartilhamento de arquivos.

# 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

Para compartilhamentos clássicos de arquivos, siga estes passos para restringir o endpoint público a redes específicas.

1. Vá para a conta de armazenamento onde você quer restringir o endpoint público a redes específicas.
2. No menu de serviço, em Segurança + Rede, selecione Rede.
3. No escopo de acesso à rede pública, selecione Habilitar em redes selecionadas. Esta seleção exibe diversas configurações para controlar a restrição de acesso ao endpoint público.
4. Em redes virtuais, selecione Adicionar uma rede> virtualAdicionar rede virtual existente para selecionar a rede virtual que deve ser permitida acessar a conta de armazenamento pelo endpoint público. Selecione uma rede virtual e uma sub-rede para essa rede virtual e depois, Habilitar. Se quiser criar uma nova rede virtual para esse fim, selecione Adicionar uma rede> virtualAdicionar nova rede virtual, forneça os detalhes e então selecione Criar.
5. Em Endereços IPv4, especifique quaisquer endereços IP públicos de internet que você queira que possam acessar a conta de armazenamento.
6. Selecione a caixa de seleção Permitir que serviços confiáveis da Microsoft acessem este recurso para permitir que serviços confiáveis da própria Microsoft, como o Sincronização de Arquivos do Azure, acessem a conta de armazenamento.
7. Selecione Salvar.

Para compartilhamentos de arquivos criados no provedor de recursos Microsoft.FileShares:

Vá para o compartilhamento de arquivos no qual você deseja restringir o acesso público. No menu de serviço, em Configurações, selecione Configuração. Em acesso à rede pública, selecione Habilitado em redes virtuais selecionadas, adicione as redes virtuais e sub-redes permitidas para acessar o compartilhamento e selecione Salvar.

Para compartilhamentos de arquivos clássicos, restrinja o acesso ao ponto de extremidade público da conta de armazenamento a redes virtuais específicas usando pontos de extremidade de serviço. Primeiro, colete informações sobre a conta de armazenamento e a rede virtual. Substitua os valores de marcador nas etapas a seguir pelos seus próprios valores.

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

Para permitir o tráfego proveniente da rede virtual, a malha de rede do Azure deve disponibilizar o ponto de extremidade de serviço Microsoft.Storage à sub-rede da rede virtual. Os comandos do PowerShell a seguir adicionam o ponto de extremidade de serviço Microsoft.Storage à sub-rede se ele ainda não estiver lá.

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

A etapa final para restringir o tráfego à conta de armazenamento é criar uma regra de rede e adicioná-la ao conjunto de regras de rede da conta de armazenamento.

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

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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, passe os IDs de recurso de sub-rede permitidos diretamente para Update-AzFileShare usando -AllowedSubnet. Não há necessidade de uma configuração separada de regras de rede ou ponto de extremidade de serviço na conta de armazenamento.

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

Para compartilhamentos de arquivos clássicos, restrinja o acesso ao ponto de extremidade público da conta de armazenamento a redes virtuais específicas usando pontos de extremidade de serviço. Primeiro, colete informações sobre a conta de armazenamento e a rede virtual. Substitua os valores de marcador nas etapas a seguir pelos seus próprios valores.

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)

Para permitir o tráfego proveniente da rede virtual, a malha de rede do Azure deve disponibilizar o ponto de extremidade de serviço Microsoft.Storage à sub-rede da rede virtual. Os comandos da CLI a seguir adicionam o endpoint de serviço Microsoft.Storage à sub-rede, caso ele ainda não esteja presente nela.

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

A etapa final para restringir o tráfego à conta de armazenamento é criar uma regra de rede e adicioná-la ao conjunto de regras de rede da conta de armazenamento.

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

Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, passe os IDs de recurso de sub-rede permitidos diretamente para az fileshare update usando --allowed-subnets. Não há necessidade de uma configuração separada de regras de rede ou ponto de extremidade de serviço na conta de armazenamento.

# 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