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

Artigo
05/11/2024

O Azure Files fornece dois tipos principais de pontos de extremidade para acessar compartilhamentos de arquivos do Azure:

Pontos finais públicos, que têm um endereço IP público e podem ser acessados de qualquer lugar do mundo.
Pontos de extremidade privados, que existem dentro de uma rede virtual e têm um endereço IP privado de dentro do espaço de endereço dessa rede virtual.

Os pontos de extremidade públicos e privados existem na conta de armazenamento do Azure. Uma conta de armazenamento é uma construção de gerenciamento que representa um pool compartilhado de armazenamento no qual você pode implantar vários compartilhamentos de arquivos, bem como outros recursos de armazenamento, como contêineres de blob ou filas.

Este artigo se concentra em como configurar os pontos de extremidade de uma conta de armazenamento para acessar o compartilhamento de arquivos do Azure diretamente. Grande parte deste artigo também se aplica à forma como o Azure File Sync interopera com pontos de extremidade públicos e privados para a conta de armazenamento. Para obter mais informações sobre considerações de rede para a Sincronização de Arquivos do Azure, consulte Definindo as configurações de proxy e firewall do Azure File Sync.

Recomendamos ler as considerações de rede dos Arquivos do Azure antes de ler este guia.

Aplica-se a

Tipo de partilhas de ficheiros	SMB	NFS
Partilhas de ficheiros Standard (GPv2), LRS/ZRS
Partilhas de ficheiros Standard (GPv2), GRS/GZRS
Partilhas de ficheiros Premium (FileStorage), LRS/ZRS

Pré-requisitos

Este artigo pressupõe que você já criou uma assinatura do Azure. Se ainda não tiver uma subscrição, crie uma conta gratuita antes de começar.
Este artigo pressupõe que você já tenha criado um compartilhamento de arquivos do Azure em uma conta de armazenamento à qual deseja se conectar localmente. Para saber como criar um compartilhamento de arquivos do Azure, consulte Criar um compartilhamento de arquivos do Azure.
Se você pretende usar o Azure PowerShell, instale a versão mais recente.
Se você pretende usar a CLI do Azure, instale a versão mais recente.

Configurações de ponto de extremidade

Você pode configurar seus pontos de extremidade para restringir o acesso à rede à sua conta de armazenamento. Há duas abordagens para restringir o acesso a uma conta de armazenamento a uma rede virtual:

Crie um ou mais pontos de extremidade privados para a conta de armazenamento e restrinja todo o acesso ao ponto de extremidade público. Isso garante que apenas o tráfego originado de dentro das redes virtuais desejadas possa acessar os compartilhamentos de arquivos do Azure na conta de armazenamento. Consulte Custo do link privado.
Restrinja o ponto de extremidade público a uma ou mais redes virtuais. Isso funciona usando um recurso da rede virtual chamado pontos de extremidade de serviço. Quando você restringe o tráfego a uma conta de armazenamento por meio de um ponto de extremidade de serviço, ainda está acessando a conta de armazenamento por meio do endereço IP público, mas o acesso só é possível a partir dos locais especificados em sua configuração.

Criar um ponto final privado

Quando você cria um ponto de extremidade privado para sua conta de armazenamento, os seguintes recursos do Azure são implantados:

Um ponto de extremidade privado: um recurso do Azure que representa o ponto de extremidade privado da conta de armazenamento. Você pode pensar nisso como um recurso que conecta uma conta de armazenamento e uma interface de rede.
Uma interface de rede (NIC): A interface de rede que mantém um endereço IP privado dentro da rede/sub-rede virtual especificada. Esse é exatamente o mesmo recurso que é implantado quando você implanta uma máquina virtual (VM), no entanto, em vez de ser atribuído a uma VM, ele pertence ao ponto de extremidade privado.
Uma zona DNS (Sistema de Nomes de Domínio) privada: se você não tiver implantado um ponto de extremidade privado para essa rede virtual antes, uma nova zona DNS privada será implantada para sua rede virtual. Um registro DNS A também será criado para a conta de armazenamento nessa zona DNS. Se você já implantou um ponto de extremidade privado nessa rede virtual, um novo registro A para a conta de armazenamento será adicionado à zona DNS existente. A implantação de uma zona DNS é opcional. No entanto, é altamente recomendado e necessário se você estiver montando seus compartilhamentos de arquivos do Azure com uma entidade de serviço do AD ou usando a API FileREST.

Nota

Este artigo usa o sufixo DNS da conta de armazenamento para as regiões Públicas do Azure, core.windows.net. Este comentário também se aplica às nuvens Sovereign do Azure, como a nuvem Azure US Government e o Microsoft Azure operado pela nuvem 21Vianet. Basta substituir os sufixos apropriados para o seu ambiente.

Navegue até a conta de armazenamento para a qual você gostaria de criar um ponto de extremidade privado. No sumário da conta de armazenamento, selecione Rede, Conexões de ponto de extremidade privado e, em seguida, + Ponto de extremidade privado para criar um novo ponto de extremidade privado.

O assistente resultante tem várias páginas para concluir.

Na folha Noções básicas, selecione a assinatura desejada, o grupo de recursos, o nome, o nome da interface de rede e a região para seu ponto de extremidade privado. Eles podem ser o que você quiser, eles não precisam corresponder à conta de armazenamento de forma alguma, embora você deva criar o ponto de extremidade privado na mesma região da rede virtual na qual deseja criar o ponto de extremidade privado. Em seguida, selecione Next: Resource.

Na folha Recurso, selecione o arquivo para o subrecurso de destino. Em seguida, selecione Next: Virtual Network.

A folha Rede Virtual permite que você selecione a rede virtual específica e a sub-rede à qual você gostaria de 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, opcionalmente, especificar um grupo de segurança do aplicativo. Quando terminar, selecione Avançar: DNS.

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

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

Clique em Rever + criar para criar o ponto de extremidade privado.

Para criar um ponto de extremidade privado para sua conta de armazenamento, primeiro você precisa obter uma referência à sua conta de armazenamento e à sub-rede de rede virtual à qual deseja adicionar o ponto de extremidade privado. Substitua <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name>, e <vnet-subnet-name> abaixo:

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

Para criar um ponto de extremidade privado, você deve criar uma conexão de serviço de link privado com a conta de armazenamento. 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 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

Criar uma zona DNS privada do Azure habilita o nome original da conta de armazenamento, como storageaccount.file.core.windows.net resolver para o IP privado dentro da rede virtual. Embora opcional da perspetiva da criação de um ponto de extremidade privado, ele é explicitamente necessário para montar o compartilhamento de arquivos do Azure diretamente usando uma entidade de usuário do AD ou acessando por meio da 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
}

Agora que você tem uma referência à zona DNS privada, você deve criar um registro A para sua conta de armazenamento.

$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 '"')

Para criar um ponto de extremidade privado, você deve primeiro garantir que a diretiva de rede de ponto de extremidade privado da sub-rede esteja definida como desabilitada. Em seguida, você pode criar um ponto de extremidade privado com o az network private-endpoint create comando.

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

Criar uma zona DNS privada do Azure habilita o nome original da conta de armazenamento, como storageaccount.file.core.windows.net resolver para o IP privado dentro da rede virtual. Embora opcional do ponto de vista da criação de um ponto de extremidade privado, ele é explicitamente necessário para montar o compartilhamento de arquivos do Azure usando uma entidade de usuário do AD ou acessando por meio da 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

Agora que você tem uma referência à zona DNS privada, você deve criar um registro A para sua conta de armazenamento.

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

Verificar a conectividade

Se você tiver uma VM dentro de sua rede virtual ou tiver configurado o encaminhamento de DNS conforme descrito em Configurando o encaminhamento de DNS para Arquivos do Azure, poderá testar se seu ponto de extremidade privado está configurado corretamente. Execute os seguintes comandos a partir do PowerShell, da linha de comandos ou do terminal (funciona para Windows, Linux ou macOS). Você deve substituir <storage-account-name> pelo nome da conta de armazenamento apropriado:

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

Se for bem-sucedido, você verá a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado em sua rede virtual (saída mostrada para 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

Se você tiver uma VM dentro de sua rede virtual ou tiver configurado o encaminhamento DNS conforme descrito em Configurando o encaminhamento de DNS para Arquivos do Azure, poderá testar se seu ponto de extremidade privado está configurado corretamente executando os seguintes comandos:

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

Resolve-DnsName -Name $storageAccountHostName

Se for bem-sucedido, você verá a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado em sua rede virtual:

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 tudo for bem-sucedido, você verá a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado em sua rede virtual. Você ainda deve usar storageaccount.file.core.windows.net para montar seu compartilhamento de arquivos em vez do privatelink caminho.

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

Restringir o acesso público ao endpoint

Limitar o acesso ao ponto de extremidade público primeiro exige que você desabilite o acesso geral ao ponto de extremidade público. A desativação do acesso ao ponto de extremidade público não afeta os pontos de extremidade privados. Depois que o ponto de extremidade público estiver desativado, você poderá selecionar redes ou endereços IP específicos que podem continuar a acessá-lo. Em geral, a maioria das políticas de firewall para uma conta de armazenamento restringe o acesso à rede a uma ou mais redes virtuais.

Desativar o acesso ao ponto de extremidade público

Quando o acesso ao ponto de extremidade público é desativado, a conta de armazenamento ainda pode ser acessada por meio de seus pontos de extremidade privados. Caso contrário, solicitações válidas para o ponto de extremidade público da conta de armazenamento serão rejeitadas, a menos que sejam de uma fonte especificamente permitida.

Navegue até a conta de armazenamento para a qual você gostaria de restringir todo o acesso ao ponto de extremidade público. No sumário da conta de armazenamento, selecione Rede.

Na parte superior da página, selecione o botão de opção Ativado a partir de redes virtuais selecionadas e endereços IP. Isso ocultará várias configurações para controlar a restrição do ponto de extremidade público. Selecione Permitir que os serviços do Azure na lista de serviços confiáveis acessem essa conta de armazenamento para permitir que serviços confiáveis da Microsoft, como o Azure File Sync, acessem a conta de armazenamento.

O comando PowerShell a seguir negará todo o tráfego para o ponto de extremidade público da conta de armazenamento. Observe que este comando tem o -Bypass parâmetro definido como AzureServices. Isso permitirá que serviços primários confiáveis, como o Azure File Sync, acessem a conta de armazenamento por meio do ponto de extremidade público.

# 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

O comando da CLI a seguir negará todo o tráfego para o ponto de extremidade público da conta de armazenamento. Observe que este comando tem o -bypass parâmetro definido como AzureServices. Isso permitirá que serviços primários confiáveis, como o Azure File Sync, 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

Restringir o acesso ao ponto de extremidade público a redes virtuais específicas

Ao restringir a conta de armazenamento a redes virtuais específicas, você está permitindo solicitações para o ponto de extremidade público de dentro das redes virtuais especificadas. Isso funciona usando um recurso da rede virtual chamado pontos de extremidade de serviço. Isso pode ser usado com ou sem pontos de extremidade privados.

Navegue até a conta de armazenamento para a qual você gostaria de restringir o ponto de extremidade público a redes virtuais específicas. No sumário da conta de armazenamento, selecione Rede.

Na parte superior da página, selecione o botão de opção Ativado a partir de redes virtuais selecionadas e endereços IP. Isso ocultará várias configurações para controlar a restrição do ponto de extremidade público. Selecione +Adicionar rede virtual existente para selecionar a rede virtual específica que deve ter permissão para acessar a conta de armazenamento por meio do ponto de extremidade público. Selecione uma rede virtual e uma sub-rede para essa rede virtual e, em seguida, selecione Ativar.

Selecione Permitir que os serviços do Azure na lista de serviços confiáveis acessem essa conta de armazenamento para permitir que serviços confiáveis da Microsoft, como o Azure File Sync, acessem a conta de armazenamento.

Para restringir 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 precisamos coletar informações sobre a conta de armazenamento e a rede virtual. Preencha <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name>, e <subnet-name> recolha esta informação.

$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 que o tráfego da rede virtual seja permitido pela malha de rede do Azure para chegar ao ponto de extremidade público da conta de armazenamento, a sub-rede da rede virtual deve ter o Microsoft.Storage ponto de extremidade de serviço exposto. Os comandos do PowerShell a seguir adicionarão o Microsoft.Storage ponto de extremidade do serviço à 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 adicionar 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

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 '"')

Para que o tráfego da rede virtual seja permitido pela malha de rede do Azure para chegar ao ponto de extremidade público da conta de armazenamento, a sub-rede da rede virtual deve ter o Microsoft.Storage ponto de extremidade de serviço exposto. Os comandos da CLI a seguir adicionarão o ponto de extremidade do Microsoft.Storage serviço à sub-rede, se ele ainda não estiver lá.

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