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

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. O acesso depende do protocolo e das regras da rede. Os clientes NFS usam endpoints de serviço a partir de sub-redes permitidas.
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 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 partilha de ficheiros também se aplica a contas de armazenamento usadas com o Azure File Sync, que suporta partilhas de ficheiros SMB clássicas. Para requisitos de rede de sincronização de ficheiros, 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

Pode restringir o acesso à rede às suas partilhas de ficheiros configurando a conta de armazenamento para partilhas clássicas ou para o recurso individual Microsoft.FileShares. 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 endpoints de serviço nas sub-redes do cliente e regras de rede na conta de armazenamento ou partilha de ficheiros. Os clientes acedem ao endpoint público através da backbone do Azure.

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): Estes passos criam ou reutilizam uma zona DNS privada do Azure ligada à rede virtual e adicionam um registo A para o endpoint privado. Pode usar a sua própria infraestrutura DNS, desde que os clientes resolvam o nome do host da partilha de ficheiros para o endereço IP do endpoint privado.

Nota

Na cloud pública do Azure, ambos os fornecedores de recursos utilizam a zona privatelink.file.core.windows.netDNS privada . Os nomes de host dos clientes diferem; ver Verificar conectividade para exemplos. Para partilhas de ficheiros clássicas noutras clouds Azure, use o sufixo endpoint de armazenamento dessa cloud. Verifique a disponibilidade regional antes de implementar o Microsoft.FileShares.

Clássico versus Microsoft.FileShares

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

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.

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.

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 a 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

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

Ligue a zona DNS privada do Azure à rede virtual para que os clientes resolvam o nome do anfitrião original da partilha de ficheiros para o endereço IP do endpoint privado. Os seguintes passos aplicam-se a ambos os fornecedores 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 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.

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

# 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

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

Execute a seguinte consulta DNS a partir do PowerShell, da linha de comandos ou de um terminal no Windows, Linux ou macOS.

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

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

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

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

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

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

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

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 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 utilizar o nome original do anfitrião (storageaccount.file.core.windows.net) para montar a partilha de ficheiros 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 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 hostName original da partilha de ficheiros para montar a partilha de ficheiros 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 o acesso público ao endpoint

Pode desativar o acesso à rede pública ou mantê-lo ativado para redes selecionadas. Estas são configurações separadas. Os endpoints privados continuam a funcionar em qualquer uma das configurações.

Para partilhas de ficheiros clássicas, configure o acesso público na conta de armazenamento. No Microsoft.FileShares, configure-o na partilha individual de ficheiros. As partilhas de ficheiros clássicas também podem usar um perímetro de segurança de rede, sujeito às limitações do protocolo. No modo Forçado, um perímetro bloqueia o tráfego NFS através dos pontos finais de serviço.

Desativar o acesso ao ponto de extremidade público

Quando desativar o acesso à rede pública, os clientes não conseguem ligar-se através do endpoint público, incluindo através dos endpoints de serviço. Os clientes ainda podem conectar-se através de endpoints privados. Esta configuração não restringe o tráfego de saída dos clientes.

Nota

Para partilhas de ficheiros clássicas, exceções existentes a serviços confiáveis e instâncias de recursos podem permanecer em vigor após desativar o acesso à rede pública. Revise estas exceções se precisar de acesso apenas através de endpoints privados. Veja limitações de segurança de rede no Armazenamento do Azure.

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.

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, 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 como 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, defina --public-network-access para 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 como 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

Para permitir clientes a partir de sub-redes selecionadas, manter o acesso público à rede ativado, ativar endpoints de serviço nessas sub-redes e adicionar as subredes às regras de rede do recurso. 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 à rede pública já está ativado. Os exemplos de Microsoft. FileShares também assumem que a sub-rede do cliente já tem o Microsoft.Storage endpoint do serviço. Para configurar esse endpoint, veja Ativar endpoints de serviço numa sub-rede.

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.
Para acesso SMB ou FileREST, use endereços IPv4 para especificar quaisquer endereços IP públicos de internet que queira permitir. As regras de endereço IP não concedem acesso ao NFS.
Se a integração de um serviço exigir acesso a serviços de confiança, selecione a opção Permitir serviços Microsoft de confiança para aceder a este recurso.
Selecione Guardar.

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

Estes comandos preservam as definições de bypass existentes. Se uma integração exigir acesso a serviços de confiança, adicione -Bypass AzureServices ao comando update. O parâmetro substitui a definição de bypass, por isso inclui quaisquer outras opções de bypass que a tua carga de trabalho ainda necessite.

Passe os IDs de recurso das sub-redes permitidas para Update-AzFileShare usando -AllowedSubnet. As regras de rede aplicam-se diretamente à partilha de ficheiros, por isso não há conta de armazenamento para configurar. A sub-rede do cliente ainda necessita 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 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 \
        --default-action "Deny" \
        --output none

Estes comandos preservam as definições de bypass existentes. Se uma integração exigir acesso a serviços de confiança, adicione --bypass AzureServices ao comando update. A opção substitui a definição de bypass, por isso inclua quaisquer outras opções de bypass que a sua carga de trabalho ainda exija.

Passe os IDs de recursos das sub-redes permitidas para az fileshare update usando --allowed-subnets. As regras de rede aplicam-se diretamente à partilha de ficheiros, por isso não há conta de armazenamento para configurar. A sub-rede do cliente ainda necessita 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

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

As regras de rede para a partilha de ficheiro controlam o acesso de entrada. Eles não limitam os outros recursos de armazenamento a que os clientes podem aceder. Para partilhas de ficheiros clássicas, pode opcionalmente usar uma política de endpoint de serviço para limitar a que contas de armazenamento os clientes numa sub-rede podem aceder através dos endpoints de serviço. A política filtra os destinos para tráfego que contorna o Azure Firewall e os 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 o acesso de saída com políticas de endpoint de serviço.

Importante

As políticas de ponto final de serviço não são atualmente suportadas para as partilhas de ficheiros Microsoft.FileShares. Uma política na sub-rede do cliente bloqueia o acesso a essas partilhas de ficheiros através dos endpoints de serviço, mesmo que permita a respetiva subscrição ou grupo de recursos. Esta restrição aplica-se também a sub-redes que acedam tanto a partilhas de ficheiros classic como a partilhas de ficheiros Microsoft.FileShares. Os clientes nessa sub-rede têm de usar um endpoint privado para aceder às partilhas de ficheiros Microsoft.FileShares.

Uma política de endpoint de serviço define os destinos de armazenamento permitidos para os clientes na sub-rede associada. Bloqueia esses clientes de aceder a outras contas de armazenamento através dos endpoints de serviço. Tenha em consideração estes pontos:

Adicione todas as contas de armazenamento que os clientes na 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 subscrição da rede virtual.
Uma política só pode conter uma definição de política para o Microsoft.Storage serviço. Para permitir mais contas de armazenamento, adicione os seus IDs de recursos à mesma definição de política. Também pode permitir todas as contas de armazenamento num grupo de recursos ou subscrição.
Depois de associar uma política a uma sub-rede, a política aplica-se ao tráfego para contas de armazenamento em todas as regiões.
Estes passos assumem que a sub-rede não tem políticas de endpoint de serviço. Se as políticas já estiverem associadas, reveja e atualize essas políticas em vez de substituir as suas associações. Os exemplos do PowerShell e da CLI param se encontrarem associações existentes.

Para criar uma política de endpoint de serviço e associá-la a uma subrede, siga estes passos. Para passos detalhados, consulte Criar e associar políticas de endpoint de serviço.

Na caixa de pesquisa no topo do portal Azure, introduza Service endpoint policy. Selecione Políticas de Ponto de Extremidade de Serviço nos resultados da pesquisa.
Selecione + Criar.
No separador Noções básicas, selecione a subscrição e a região da sua rede virtual. Selecione um grupo de recursos e insira um nome para a política.
Selecione Seguinte: definições de política.
Selecionar + Adicionar um recurso. Para Serviço, selecione Microsoft.Storage. Em Âmbito, selecione Conta única e depois selecione a conta de armazenamento que contém as suas partilhas de ficheiros. Selecione Adicionar. Repita este passo para cada conta de armazenamento que os clientes na sub-rede utilizem.
Selecione Rever e criar e, em seguida, selecione Criar.
Vá para a nova política de endpoint de serviço. No menu de serviço, em Definições, selecione Sub-redes Associadas.
Selecione + Editar associação de sub-rede, selecione a rede virtual e a sub-rede, e depois selecione Aplicar.

Os seguintes comandos PowerShell criam uma política de endpoint de serviço e associam-na a uma subrede. A política limita o acesso do cliente a partir 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. Substitui os valores provisórios pelos teus 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 associam-na a uma subrede. A política limita o acesso do cliente a partir de essa 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. Substitui os valores provisórios pelos teus 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 aceder a uma partilha de ficheiros Microsoft.FileShares a partir de uma sub-rede que tenha uma política de endpoint de serviço, crie um endpoint privado para a partilha de ficheiros. As políticas de endpoint de serviço não se aplicam ao tráfego que passa por um endpoint privado.

Consulte também

Comentários

Esta página foi útil?

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