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

Os Arquivos do Azure fornecem dois tipos principais de pontos de extremidade para acessar compartilhamentos de arquivos do Azure:

Endpoints públicos, que possuem um endereço IP público. O acesso depende do protocolo e das regras da rede. Clientes NFS usam endpoints de serviço a partir de sub-redes permitidas.
Pontos de extremidade privados, que existem em uma rede virtual e têm um endereço IP privado dentro do espaço de endereço dessa rede virtual.

Para compartilhamentos de arquivos clássicos (criados com o provedor de recursos Microsoft.Storage), a conta de armazenamento do Azure tem pontos de extremidade públicos e privados. Para compartilhamentos de arquivos criados com o provedor de recursos Microsoft.FileShares, você cria pontos de extremidade públicos e privados no nível do compartilhamento de arquivos, e não no nível da conta de armazenamento.

Este artigo explica como configurar endpoints privados e restringir o acesso a endpoints públicos para ambos os provedores de recursos. A orientação clássica de compartilhamento de arquivos também se aplica a contas de armazenamento usadas com o Sincronização de Arquivos do Azure, que oferecem suporte a compartilhamentos clássicos de arquivos SMB. Para os requisitos de rede do Sincronização de Arquivos do Azure, veja Configurar as configurações de proxy e firewall do Sincronização de Arquivos do Azure.

Antes de ler este guia, consulte considerações de rede do Arquivos do Azure.

Pré-requisitos

Este artigo pressupõe que você já tenha criado uma assinatura do Azure. Se você ainda não tiver uma assinatura, crie uma conta gratuita.
Você vai precisar de um compartilhamento de arquivos do Azure ao qual queira se conectar. Para aprender a criar um compartilhamento de arquivos no Azure, veja Criar um compartilhamento clássico ou Criar um compartilhamento de arquivos Azure com a Microsoft. Compartilhamentos de Arquivos.
Se pretende usar o Azure PowerShell, instale a versão mais recente.
Se pretende usar a CLI do Azure, instale a versão mais recente.

Criar e configurar endpoints

Você pode restringir o acesso à rede aos seus compartilhamentos de arquivos configurando a conta de armazenamento para compartilhamentos clássicos ou para o recurso individual Microsoft.FileShares. Para restringir o acesso a uma rede virtual, utilize uma das seguintes abordagens:

Crie um ou mais endpoints privados e restreina todo o acesso ao endpoint público (recomendado). Essa abordagem garante que somente o tráfego proveniente das redes virtuais desejadas possa acessar os compartilhamentos de arquivos Azure. Confira os Custos do Link Privado.
Restrinja o ponto de extremidade público a uma ou mais redes virtuais. Essa abordagem utiliza endpoints de serviço nas sub-redes do cliente e regras de rede na conta de armazenamento ou compartilhamento de arquivos. Os clientes alcançam o endpoint público via backbone do Azure.

Criar um ponto de extremidade privado

Ao criar um ponto de extremidade privado para seus compartilhamentos de arquivos, você implanta os seguintes recursos de Azure:

Um ponto de extremidade privado: um recurso de Azure que representa o ponto de extremidade privado. Você pode pensar nesse recurso como um conector entre um recurso de destino e um adaptador de rede.
Uma NIC (interface de rede): a interface de rede que mantém um endereço IP privado dentro da rede virtual e da sub-rede especificadas. Esse recurso é o mesmo que você implanta ao implantar uma VM (máquina virtual). No entanto, em vez de atribuí-lo a uma VM, o ponto de extremidade privado o possui.
Uma zona privada do Sistema de Nomes de Domínio (DNS): Essas etapas criam ou reutilizam uma zona DNS privada do Azure vinculada à rede virtual e adicionam um registro A para o endpoint privado. Você pode usar sua própria infraestrutura DNS, desde que os clientes resolvam o nome do host do compartilhamento de arquivos para o endereço IP do endpoint privado.

Observação

No Azure Public Cloud, ambos os provedores de recursos usam a zona privatelink.file.core.windows.netDNS privada . Seus nomes de host de clientes diferem; veja Verificar conectividade para exemplos. Para compartilhamentos clássicos de arquivos em outras nuvens do Azure, use o sufixo endpoint de armazenamento para essa nuvem. Verifique a disponibilidade regional antes de implantar Microsoft.FileShares.

Clássico versus Microsoft.FileShares

O processo de criação de endpoints privados varia um pouco dependendo se você está usando compartilhamentos clássicos ou o novo modelo de compartilhamento de arquivos. Para compartilhamentos de arquivos clássicos, você cria um endpoint privado para a conta de armazenamento que contém os compartilhamentos de arquivos. Para compartilhamentos de arquivos criados com Microsoft.FileShares, você cria um ponto de extremidade privado para o próprio compartilhamento de arquivos.

Muitos dos passos são idênticos para ambas as experiências. Apenas a referência do recurso, ID do grupo e nome do registro DNS diferem, conforme mostrado na tabela a seguir.

	Compartilhamentos de arquivos clássicos (`Microsoft.Storage`)	Compartilhamentos de arquivos (`Microsoft.FileShares`)
Destino do endpoint privado	Conta de armazenamento	Compartilhamento de arquivo
Cmdlet de recursos	`Get-AzStorageAccount`	`Get-AzFileShare`
ID do grupo (sub-recurso)	`file`	`FileShare`
Nome do registro DNS A	Nome da conta de armazenamento	Prefixo do nome do host (por exemplo, `fs-xxxxxxxxxxxxxxxxx`)

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 .

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.

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.

Obtenha uma referência para a 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

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

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

Conecte a zona DNS privada do Azure à rede virtual para que os clientes resolvam o nome do host original do compartilhamento de arquivos para o endereço IP do ponto de extremidade privado. Os passos a seguir se aplicam a ambos os provedores de recursos.

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

Obtenha uma referência para a 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

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)

# 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

Verificar conectividade

Execute as verificações a partir de um cliente na rede virtual, ou de uma rede conectada com DNS configurado para resolver o endpoint privado. Para as diferenças entre provedores de recursos, veja resolução DNS. Use o nome original do host para montar o compartilhamento, não o nome privatelink.

Execute a seguinte consulta DNS no PowerShell, na linha de comando ou em um terminal no Windows, Linux ou macOS.

Substitua <storage-account-name> pelo nome apropriado da conta de armazenamento:

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

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

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

Use o nome de 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).

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

Execute os seguintes comandos PowerShell para verificar a resolução DNS:

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

Resolve-DnsName -Name $storageAccountHostName

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.

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

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.

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

Execute os seguintes comandos para recuperar o nome do host e verificar a resolução DNS:

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

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 original do host (storageaccount.file.core.windows.net) para montar o compartilhamento de arquivos em vez do caminho privatelink.

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

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 hostName original do compartilhamento de arquivos para montar seu compartilhamento de arquivos, em vez do caminho privatelink.

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

Restringir acesso ao ponto de extremidade público

Você pode desativar o acesso à rede pública ou mantê-lo ativado para redes selecionadas. São configurações separadas. Endpoints privados continuam funcionando em qualquer uma das configurações.

Para compartilhamentos de arquivos clássicos, configure o acesso público na conta de armazenamento. Para Microsoft.FileShares, configure-o no compartilhamento individual de arquivos. Compartilhamentos de arquivos clássicos também podem usar um perímetro de segurança de rede, sujeito às limitações de seus protocolos. No modo Forçado, um perímetro bloqueia o tráfego NFS através dos endpoints de serviço.

Desabilitar o acesso ao ponto de extremidade público

Quando você desativa o acesso à rede pública, os clientes não conseguem se conectar pelo endpoint público, inclusive pelos endpoints de serviço. Os clientes ainda podem se conectar por meio de endpoints privados. Essa configuração não restringe o tráfego de saída dos clientes.

Observação

Para compartilhamentos clássicos de arquivos, exceções existentes a serviços confiáveis e instâncias de recursos podem permanecer em vigor após você desativar o acesso à rede pública. Revise essas exceções se você precisar de acesso apenas por meio de endpoints privados. Veja limitações de segurança de rede do Armazenamento do Azure.

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

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

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, defina -PublicNetworkAccess como Disabled na conta de armazenamento.

# Use the storage account variables from the beginning of this guide.
Set-AzStorageAccount `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name $storageAccountName `
        -PublicNetworkAccess Disabled `
        -ErrorAction Stop |
    Out-Null

Defina -PublicNetworkAccess para 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, defina --public-network-access como Disabled na conta de armazenamento.

# This assumes $storageAccountResourceGroupName and $storageAccountName
# are still defined from the beginning of this guide.
az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --public-network-access Disabled \
    --output none

Defina --public-network-access para 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

Restringa o acesso ao endpoint público a redes específicas

Para permitir clientes de sub-redes selecionadas, mantenha o acesso à rede pública habilitado, habilite endpoints de serviço nessas sub-redes e adicione as sub-redes às regras de rede do recurso. Você pode usar endpoints de serviço com ou sem endpoints privados. O acesso clássico SMB e FileREST também pode usar regras de endereço IP; O acesso NFS requer sub-redes permitidas.

Os exemplos do PowerShell e da CLI assumem que o acesso público à rede já está habilitado. Os exemplos de Microsoft. FileShares também assumem que a sub-rede do cliente já possui o Microsoft.Storage endpoint de serviço. Para configurar esse endpoint, veja Habilitar endpoints de serviço em uma sub-rede.

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

Vá para a conta de armazenamento onde você quer restringir o endpoint público a redes específicas.
No menu de serviço, em Segurança + Rede, selecione Rede.
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.
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.
Para acesso SMB ou FileREST, use endereços IPv4 para especificar quaisquer endereços IP públicos de internet que você queira permitir. Regras de endereço IP não concedem acesso ao NFS.
Se uma integração de serviço exigir acesso a serviço confiável, selecione a caixa Permitir que serviços confiáveis da Microsoft acessem este recurso.
Selecione Salvar.

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 `
        -VirtualNetworkRule $networkRule `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

Esses comandos preservam as configurações de bypass existentes. Se uma integração exigir acesso a serviço confiável, adicione -Bypass AzureServices ao comando update. O parâmetro substitui a configuração de bypass, então inclua quaisquer outras opções de bypass que sua carga de trabalho ainda exigir.

Passe os IDs de recursos de sub-rede permitidos para Update-AzFileShare usando -AllowedSubnet. As regras de rede se aplicam diretamente ao compartilhamento de arquivos, então não há conta de armazenamento para configurar. A sub-rede do cliente ainda precisa de um endpoint de serviço, conforme descrito nos pré-requisitos acima.

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

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 \
        --default-action "Deny" \
        --output none

Esses comandos preservam as configurações de bypass existentes. Se uma integração exigir acesso a serviço confiável, adicione --bypass AzureServices ao comando update. A opção substitui a configuração de bypass, então inclua quaisquer outras opções de bypass que sua carga de trabalho ainda exija.

Passe os IDs de recurso das sub-redes permitidas para az fileshare update usando --allowed-subnets. As regras de rede se aplicam diretamente ao compartilhamento de arquivos, então não há conta de armazenamento para configurar. A sub-rede do cliente ainda precisa de um endpoint de serviço, conforme descrito nos pré-requisitos acima.

# 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

Restringa o acesso de saída a contas de armazenamento específicas

Regras de rede para compartilhamento de arquivo controlam o acesso de entrada. Eles não limitam quais outros recursos de armazenamento os clientes podem acessar. Para compartilhamentos clássicos de arquivos, você pode opcionalmente usar uma política de endpoint de serviço para limitar quais contas de armazenamento os clientes em uma sub-rede podem acessar através de endpoints de serviço. A política filtra destinos para tráfego que contorna o Firewall do Azure e appliances virtuais de rede. Não restringe outros caminhos de saída nem substitui as regras de rede e os requisitos de autorização do destino. Para mais informações, veja Restringir acesso de saída com políticas de endpoint de serviço.

Importante

No momento, não há suporte a políticas de ponto de extremidade de serviço em compartilhamentos de arquivos do Microsoft.FileShares. Uma política na sub-rede do cliente bloqueia o acesso a esses compartilhamentos de arquivos por meio dos pontos de extremidade de serviço, mesmo que ela permita a assinatura ou o grupo de recursos. Essa restrição também se aplica a sub-redes que acessam os compartilhamentos de arquivos clássicos e do Microsoft.FileShares. Clientes nessa sub-rede devem usar um ponto de extremidade privado para acessar os compartilhamentos de arquivos do Microsoft.FileShares.

Uma política de endpoint de serviço define os destinos de armazenamento permitidos para clientes na sub-rede associada. Ele bloqueia esses clientes de acessar outras contas de armazenamento por meio dos endpoints de serviço. Tenha estes pontos em mente:

Adicione todas as contas de armazenamento que os clientes da sub-rede usam antes de associar a política à sub-rede. Esta lista inclui contas de armazenamento que outras cargas de trabalho na sub-rede utilizam.
A política de endpoint de serviço deve estar na mesma região e assinatura da rede virtual.
Uma política pode conter apenas uma definição de política para o Microsoft.Storage serviço. Para permitir mais contas de armazenamento, adicione os IDs de recurso dessas contas à mesma definição de política. Você também pode permitir todas as contas de armazenamento de um grupo de recursos ou de uma assinatura.
Depois que você associa uma política a uma sub-rede, a política se aplica ao tráfego para contas de armazenamento em todas as regiões.
Esses passos assumem que a sub-rede não possui políticas de endpoint de serviço. Se as políticas já estiverem associadas, revise e atualize essas políticas em vez de substituir suas associações. Os exemplos de PowerShell e CLI interrompem se encontrarem associações já existentes.

Para criar uma política de endpoint de serviço e associá-la a uma sub-rede, siga estes passos. Para etapas detalhadas, veja Criar e associar políticas de endpoint de serviço.

Na caixa de busca no topo do portal do Azure, insira política de endpoint de serviço. Selecione Políticas de ponto de extremidade de serviço nos resultados da pesquisa.
Selecione + Criar.
Na aba Basics , selecione a assinatura e a região da sua rede virtual. Selecione um grupo de recursos e insira um nome para a política.
Selecione Avançar: definições de política.
Selecione + Adicionar um recurso. Em Serviço, selecione Microsoft.Storage. Para Escopo, selecione Conta Única e depois selecione a conta de armazenamento que contém seus compartilhamentos de arquivos. Selecione Adicionar. Repita essa etapa para cada conta de armazenamento que os clientes na sub-rede utilizam.
Clique em Examinar + Criar, depois em Criar.
Acesse a nova política de ponto de extremidade de serviço. No menu de serviço, em Configurações, selecione Sub-redes associadas.
Selecione + Editar associação de sub-rede, selecione a rede virtual e a sub-rede, e então selecione Aplicar.

Os seguintes comandos PowerShell criam uma política de endpoint de serviço e a associam a uma sub-rede. A política limita o acesso do cliente dessa sub-rede a uma conta de armazenamento através do endpoint de serviço. A sub-rede já deve ter o Microsoft.Storage endpoint do serviço. Substitua os valores de placeholder pelos seus próprios valores.

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

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

$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $virtualNetworkName `
        -ErrorAction Stop

$subnet = $virtualNetwork.Subnets | Where-Object { $_.Name -eq $subnetName }
if ($null -eq $subnet) {
    throw "Subnet '$subnetName' wasn't found in virtual network '$virtualNetworkName'."
}

if ($subnet.ServiceEndpointPolicies.Count -gt 0) {
    throw "The subnet already has service endpoint policies. Review and update them before changing the configuration."
}

# To allow clients to access more storage accounts, add their resource IDs to -ServiceResource.
$policyDefinition = New-AzServiceEndpointPolicyDefinition `
        -Name "allowed-storage-accounts" `
        -Service "Microsoft.Storage" `
        -ServiceResource @($storageAccount.Id) `
        -ErrorAction Stop

$policy = New-AzServiceEndpointPolicy `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $policyName `
        -Location $virtualNetwork.Location `
        -ServiceEndpointPolicyDefinition $policyDefinition `
        -ErrorAction Stop

$subnet.ServiceEndpointPolicies = @($policy)
$virtualNetwork | Set-AzVirtualNetwork -ErrorAction Stop | Out-Null

Os seguintes comandos CLI criam uma política de endpoint de serviço e a associam a uma sub-rede. A política limita o acesso do cliente dessa sub-rede a uma conta de armazenamento através do endpoint de serviço. A sub-rede já deve ter o Microsoft.Storage endpoint do serviço. Substitua os valores de placeholder pelos seus próprios valores.

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

existingPolicyIds=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "serviceEndpointPolicies[].id" --output tsv) || exit 1

if [ -n "$existingPolicyIds" ]; then
    echo "The subnet already has service endpoint policies. Review and update them before changing the configuration." >&2
    exit 1
fi

storageAccountId=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" --output tsv) || exit 1

location=$(az network vnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --name $virtualNetworkName \
        --query "location" --output tsv) || exit 1

az network service-endpoint policy create \
        --resource-group $virtualNetworkResourceGroupName \
        --name $policyName \
        --location $location \
        --output none || exit 1

# To allow clients to access more storage accounts, add their resource IDs to --service-resources.
az network service-endpoint policy-definition create \
        --resource-group $virtualNetworkResourceGroupName \
        --policy-name $policyName \
        --name "allowed-storage-accounts" \
        --service "Microsoft.Storage" \
        --service-resources $storageAccountId \
        --output none || exit 1

az network vnet subnet update \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --service-endpoint-policy $policyName \
        --output none || exit 1

Para acessar um compartilhamento de arquivos Microsoft. FileShares a partir de uma sub-rede que tenha uma política de endpoint de serviço, crie um endpoint privado para o compartilhamento de arquivos. Políticas de endpoint de serviço não se aplicam ao tráfego que passa por um endpoint privado.

Confira também

Comentários

Esta página foi útil?

Última atualização em 2026-10-05