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

✔️ Aplica-se a: Partilhas de ficheiros clássicas criadas com o fornecedor de recursos Microsoft.Storage

✔️ Aplica-se a: Partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares

O Ficheiros do Azure fornece dois tipos principais de endpoints para aceder às partilhas de ficheiros do Azure.

Endpoints públicos, que têm um endereço IP público e aos quais pode aceder a partir de qualquer lugar do mundo.
Endpoints privados, que existem dentro de uma rede virtual e têm um endereço IP privado no espaço de endereçamento dessa rede virtual.

Para partilhas de ficheiros clássicas (criadas com o fornecedor de Microsoft.Storage recursos), a conta de armazenamento do Azure tem endpoints públicos e privados. Para partilhas de ficheiros criadas com o fornecedor de Microsoft.FileShares recursos, cria-se endpoints públicos e privados ao nível da partilha de ficheiros em vez de ao nível da conta de armazenamento.

Este artigo foca-se em como configurar um endpoint privado para aceder diretamente à partilha de ficheiros do Azure. Uma grande parte deste artigo também se aplica à forma como o Azure File Sync funciona com os pontos de extremidade públicos e privados da conta de armazenamento. Para mais informações sobre considerações de rede para o Azure File Sync, consulte configurar as definições do proxy e firewall do Azure File Sync.

Antes de ler este guia, reveja as considerações sobre redes do Ficheiros do Azure.

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.
Vais precisar de uma partilha de ficheiros Azure à qual queiras ligar-te. Para aprender a criar uma partilha de ficheiros Azure, veja Criar uma partilha de ficheiros clássica ou Criar uma partilha de ficheiros Azure com a Microsoft. Partilhas de ficheiros.
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.

Criar e configurar pontos finais

Podes configurar os teus endpoints para restringir o acesso à rede à tua conta de armazenamento e partilhas de ficheiros. Para restringir o acesso a uma rede virtual, use uma das seguintes abordagens:

Crie um ou mais endpoints privados e restrinja todo o acesso ao endpoint público (recomendado). Esta abordagem garante que apenas o tráfego originado dentro das redes virtuais desejadas pode aceder às partilhas de ficheiros do Azure. Consulte Custo do link privado.
Restrinja o ponto de extremidade público a uma ou mais redes virtuais. Esta abordagem utiliza uma capacidade da rede virtual denominada endpoints de serviço. Quando restringe o tráfego para uma conta de armazenamento através de um endpoint de serviço, está a aceder à conta de armazenamento ou à partilha de ficheiros através do endereço IP público, mas o acesso só é possível a partir dos locais que especifica na sua configuração.

Criar um ponto final privado

Quando cria um endpoint privado para as suas partilhas de ficheiros, implementa os seguintes recursos do Azure:

Um endpoint privado: Um recurso Azure que representa o endpoint privado. Pode pensar neste recurso como um conector entre um recurso alvo 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 virtual e sub-rede especificadas. Este recurso é o mesmo que implementas quando implementas uma máquina virtual (VM). No entanto, em vez de o atribuir a uma VM, este pertence ao endpoint privado.
Uma zona privada de Sistema de Nomes de Domínio (DNS): Se não implementou anteriormente um endpoint privado para esta rede virtual, uma nova zona DNS privada é implementada para a sua rede virtual. Um registo DNS também é criado nesta zona DNS. Se já implementou um endpoint privado nesta rede virtual, um novo registo é 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 utiliza o sufixo DNS para as regiões públicas do Azure, core.windows.net. Este comentário aplica-se também às clouds Azure Sovereign, como a cloud Azure US Government e a Azure operada pela cloud 21Vianet. Basta substituir os sufixos apropriados para o seu ambiente.

O processo de criação de endpoints privados varia ligeiramente dependendo se está a usar partilhas de ficheiros clássicas ou o novo modelo de partilha de ficheiros. Para partilhas de ficheiros clássicas, cria-se um endpoint privado para a conta de armazenamento que contém as partilhas de ficheiros. Para partilhas de ficheiros criadas com Microsoft.FileShares, cria um ponto final privado para a própria partilha de ficheiros.

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

	Compartilhamentos de arquivos clássicos (`Microsoft.Storage`)	Novas partilhas de ficheiros (`Microsoft.FileShares`)
Destino de ponto final privado	Conta de armazenamento	Partilha de ficheiros
Cmdlet de recursos	`Get-AzStorageAccount`	`Get-AzFileShare`
ID de grupo (sub-recurso)	`file`	`FileShare`
DNS Nome de registo A	Nome da conta de armazenamento	Prefixo do nome do host (por exemplo, `fs-xxxxxxxxxxxxxxxxx`)

Vai ao grupo de recursos onde queres criar um endpoint privado. Selecione + Criar e pesquise por Ponto Final Privado. Selecione o recurso de endpoint privado e depois selecione Criar.

O mago tem várias páginas para completar.

Na página Básicos , selecione a subscrição, grupo de recursos, nome, nome da interface de rede e região do seu endpoint privado. Tens de criar o endpoint privado na mesma região da rede virtual onde queres criar o endpoint privado. Em seguida, selecione Next: Resource.

Se estiveres a usar partilhas de ficheiros clássicas numa conta de armazenamento:

Na página de Recursos, selecione Microsoft. Storage/storageAccounts no menu suspenso para Tipo de Recursos. Para o Recurso, selecione a conta de armazenamento específica à qual quer ligar-se. Para sub-recurso de destino, selecione file. Em seguida, selecione Next: Rede Virtual.

Se estiver a utilizar partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares:

Na página de Recursos, selecione Microsoft. FileShares/fileShares no menu suspenso para Tipo de Recursos. Para o Recurso, selecione a partilha de ficheiros específica a que quer ligar. O sub-recurso alvo é preenchido automaticamente com FileShare. Em seguida, selecione Next: Rede Virtual.

A página Rede Virtual permite-lhe selecionar a virtual network e a subnet específicas onde pretende adicionar o seu endpoint privado. Selecione a alocação de endereço IP dinâmico ou estático para o novo ponto de extremidade privado. Se selecionares estática, também precisas de 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 página DNS contém a informação para integrar o seu endpoint privado com uma zona DNS privada. Certifique-se de que a subscrição e o grupo de recursos estão corretos e depois selecione Próximo: Etiquetas.

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.

Selecione Criar para criar o ponto de extremidade privado.

Para criar um endpoint privado, primeiro obtenha uma referência à sua conta de armazenamento ou à partilha de ficheiros e à sub-rede virtual onde quer adicionar o endpoint privado. Substitua os valores provisórios no código seguinte pelos seus próprios valores.

Para partilhas de ficheiros clássicas, 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

Para partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, obtenha uma referência à partilha de ficheiros:

 $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, os passos restantes são os mesmos 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 endpoint privado, deve criar uma ligação privada de serviço de link. 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 criares uma zona DNS privada do Azure, o nome original do host é resolvido para o IP privado dentro da rede virtual. Embora opcional na perspetiva da criação de um endpoint privado, é explicitamente exigido para montar diretamente a partilha de ficheiros do Azure utilizando um principal de utilizador do Active Directory (AD) ou para aceder através da 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 tem uma referência à zona DNS privada, deve criar um registo.

 $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 endpoint privado, primeiro obtenha uma referência à sua conta de armazenamento ou partilha de ficheiros, além da sub-rede virtual onde quer adicionar o endpoint privado. Substitua os valores provisórios nos passos seguintes pelos seus próprios valores.

Para partilhas de ficheiros clássicas, 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

Para partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, obtenha uma referência à partilha de ficheiros:

# 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, os passos restantes são os mesmos 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 endpoint privado, certifique-se de que a política de rede de endpoint privado da sub-rede está desativada e depois crie o endpoint 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 criar uma zona DNS privada do Azure, o nome original do anfitrião é resolvido para o IP privado dentro da rede virtual. Embora opcional do ponto de vista de criar um endpoint privado, é necessário para montar a partilha de ficheiros do Azure usando um principal de utilizador AD ou acedendo através da 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 tem uma referência à zona DNS privada, crie um registo 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 a conectividade

Se tiver uma VM dentro da sua rede virtual, ou se configurou o encaminhamento DNS conforme descrito em Configuring DNS forwarding for Ficheiros do Azure, pode testar se o seu endpoint privado está corretamente configurado. Execute os seguintes comandos a partir do PowerShell, da linha de comandos ou do terminal (funciona para Windows, Linux ou macOS).

Para partilhas de ficheiros clássicas, substitua <storage-account-name> pelo nome de conta de armazenamento apropriado:

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

Para partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, utilize o nome do anfitrião da partilha de ficheiros. No separador Descrição geral da partilha de ficheiros, selecione Vista JSON no canto superior direito. Na visualização JSON, em properties, copie o valor para hostName. O formato é fs-xxxxxxxxxxxxxxxxx.xx.file.storage.azure.net.

nslookup <file-share-host-name>

Se for bem-sucedido, verá uma saída semelhante à seguinte, onde 192.168.0.5 é o endereço IP privado do ponto final privado na sua rede virtual (saída mostrada para Windows).

Para partilhas de ficheiros clássicas:

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 partilhas de ficheiros criadas com o fornecedor 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

Para partilhas de ficheiros clássicas:

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

Para partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares:

 Resolve-DnsName -Name $fileShare.HostName

Se for bem-sucedido, verá uma saída semelhante à seguinte, onde 192.168.0.5 é o endereço IP privado do ponto final privado na sua rede virtual.

Para partilhas de ficheiros clássicas:

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 partilhas de ficheiros criadas com o fornecedor 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

Para partilhas de ficheiros clássicas:

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 partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares:

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

nslookup $hostName

Se for bem-sucedido, verá uma saída semelhante à seguinte, onde 192.168.0.5 é o endereço IP privado do ponto final privado na sua rede virtual. Deves continuar a usar o nome do anfitrião original (storageaccount.file.core.windows.net para a experiência clássica, ou a hostName da partilha de ficheiros para a nova experiência) para montar a tua partilha de ficheiros, em vez do caminho privatelink.

Para partilhas de ficheiros clássicas:

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 partilhas de ficheiros criadas com o fornecedor 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

Restringir o acesso público ao endpoint

Para limitar o acesso ao endpoint público, primeiro desative o acesso geral ao endpoint público. Desativar o acesso ao endpoint público não afeta os endpoints privados. Depois de desativar o endpoint público, selecione redes ou endereços IP específicos que possam continuar a aceder a ele. Em geral, a maioria das políticas de firewall para uma conta de armazenamento restringe o acesso à rede a uma ou mais redes virtuais.

Também pode usar um perímetro de segurança de rede para gerir centralmente as regras de acesso de entrada e saída.

Desativar o acesso ao ponto de extremidade público

Quando desativa o acesso à rede pública, restringe o acesso de entrada enquanto permite o acesso de saída. Ainda podes aceder à conta de armazenamento através dos seus endpoints privados. Caso contrário, os pedidos para o endpoint público da conta de armazenamento são rejeitados, a menos que sejam de uma fonte especificamente permitida.

Para desativar o acesso público à rede para partilhas de ficheiros clássicas, siga estes passos:

Vai à conta de armazenamento onde queres 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 Gerir.
Selecione Desabilitar e depois selecione Prosseguir.
Selecione Guardar.

Para partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares:

Aceda à partilha de ficheiros onde pretende desativar o acesso público. No menu de serviço, em Configurações, selecione Configuração. Defina o acesso à rede pública como Desativado e depois selecione Guardar.

Para partilhas de ficheiros clássicas, o seguinte comando PowerShell nega todo o tráfego para o endpoint público da conta de armazenamento. Defina o parâmetro -Bypass como AzureServices para permitir que serviços fidedignos de origem, como o Azure File Sync, acedam à conta de armazenamento através 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 partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, defina -PublicNetworkAccess para Disabled na partilha de ficheiros.

# 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 partilhas de ficheiros clássicas, o seguinte comando CLI bloqueia todo o tráfego para o endpoint público da conta de armazenamento. Defina o parâmetro --bypass como AzureServices para permitir que serviços fidedignos de origem, como o Azure File Sync, acedam à conta de armazenamento através 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 partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, defina --public-network-access para Disabled na partilha de ficheiros.

# 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

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

Quando restringe o acesso ao endpoint público a redes específicas, permite pedidos para o endpoint público a partir de redes virtuais ou endereços IP especificados. Esta restrição funciona utilizando uma capacidade chamada endpoints de serviço. Pode usar endpoints de serviço com ou sem endpoints privados.

Para partilhas de ficheiros clássicas, siga estes passos para restringir o endpoint público a redes específicas.

Vai à conta de armazenamento onde queres restringir o endpoint público a redes específicas.
No menu de serviço, em Segurança + rede, selecione Rede.
Em âmbito de acesso à rede pública, selecione Ativar a partir de redes selecionadas. Esta seleção revela um conjunto de definições para controlar a forma como o endpoint público é restringido.
Em redes virtuais, selecione Adicionar uma rede> virtualAdicionar rede virtual existente para selecionar a rede virtual que deve ser autorizada a aceder à conta de armazenamento através do endpoint público. Selecione uma rede virtual e uma sub-rede para essa rede virtual e, em seguida, selecione Ativar. Se quiser criar uma nova rede virtual para este fim, selecione Adicionar uma rede> virtualAdicionar nova rede virtual, forneça os detalhes e depois selecione Criar.
Em Endereços IPv4, especifique quaisquer endereços IP públicos da internet que queira poder aceder à conta de armazenamento.
Selecione a caixa de verificação Permitir que serviços Microsoft fidedignos acedam a este recurso para permitir que serviços Microsoft próprios fidedignos, como o Azure File Sync, acedam à conta de armazenamento.
Selecione Guardar.

Para partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares:

Vá à partilha de ficheiros onde pretende restringir o acesso público. No menu de serviço, em Definições, selecione Configuração. Em Acesso à Rede Pública, selecione Ativado entre redes virtuais selecionadas, adicione as redes virtuais e sub-redes permitidas para aceder à partilha e selecione Guardar.

Para partilhas de ficheiros clássicas, restrinja o acesso ao endpoint público da conta de armazenamento a redes virtuais específicas usando endpoints de serviço. Primeiro, recolha informações sobre a conta de armazenamento e a rede virtual. Substitua os valores provisórios nos passos seguintes 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 infraestrutura de rede do Azure tem de expor o ponto final de serviço Microsoft.Storage à sub-rede da rede virtual. Os seguintes comandos PowerShell adicionam o endpoint de serviço Microsoft.Storage à sub-rede, caso ainda não exista.

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

O passo final para restringir o tráfego para a 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 partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, passe diretamente para Update-AzFileShare os IDs de recurso das sub-redes permitidas utilizando -AllowedSubnet. Não é necessária uma configuração separada de ponto final de serviço ou de regras de rede 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)

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 infraestrutura de rede do Azure tem de expor o ponto final de serviço Microsoft.Storage à sub-rede da rede virtual. Os comandos CLI seguintes adicionam o endpoint de serviço Microsoft.Storage à sub-rede, caso ainda não exista.

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

O passo final para restringir o tráfego para a 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 partilhas de ficheiros criadas com o fornecedor de recursos Microsoft.FileShares, passe diretamente para az fileshare update os IDs de recurso das sub-redes permitidas utilizando --allowed-subnets. Não é necessária uma configuração separada de ponto final de serviço ou de regras de rede 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

Consulte também

Comentários

Esta página foi útil?

Last updated on 2026-07-16

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

Pré-requisitos

Criar e configurar pontos finais

Criar um ponto final privado

Experiência clássica vs. nova partilha de ficheiros

Verificar a conectividade

Restringir o acesso público ao endpoint

Desativar o acesso ao ponto de extremidade público

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

Consulte também

Comentários

Recursos adicionais