Configurar pontos finais de rede do Azure File Sync

O Azure File Sync utiliza dois recursos do Azure, cada um com os seus próprios pontos finais de rede: a conta de armazenamento (que detém a partilha de ficheiros do Azure) e o Serviço de Sincronização de Armazenamento (que coordena sincronização, registo do servidor e grupos de sincronização). Ambos os recursos usam endpoints públicos por defeito.

O agente Azure File Sync comunica com ambos os recursos via HTTPS (porta 443). Para servidores que se ligam ao Azure via internet sem VPN ou ExpressRoute, pode usar o endpoint público e não é necessária qualquer configuração. No entanto, a maioria dos clientes do Azure File Sync quer configurar endpoints privados.

Use a tabela seguinte para decidir se precisa de endpoints privados. Se precisares deles, cria endpoints privados para ambos os recursos.

Preciso de...	Use
Servidores de sincronização que se ligam ao Azure via internet sem VPN ou ExpressRoute	Endpoints públicos (sem necessidade de configuração)
Encaminhe todo o tráfego sincronizado através do ExpressRoute ou da ligação VPN site-to-site	Endpoints privados para ambos os recursos
Cumprir os requisitos de conformidade que proíbem dados na internet pública	Endpoints privados para ambos os recursos
Desativar o endpoint público como medida de reforço de segurança	Pontos finais privados primeiro para ambos os recursos e, depois, restringir o acesso
Implementar o acesso à rede de confiança zero	Endpoints privados para ambos os recursos

Para conceitos mais amplos de rede, veja considerações sobre rede do Azure File Sync. Para configurar endpoints para aceder diretamente a partilhas de ficheiros Azure (sem Azure File Sync), veja Configurar endpoints de rede Ficheiros do Azure.

Pré-requisitos

Este artigo parte do princípio de que:

Tem uma subscrição do Azure. Se ainda não tiver uma subscrição, crie uma conta gratuita antes de começar.
Criou uma partilha de ficheiros SMB clássica do Azure numa conta de armazenamento à qual pretende ligar-se a partir do ambiente no local. Para aprender a criar uma partilha de ficheiros Azure classic, consulte Criar uma partilha de ficheiros Azure classic.
O teu firewall permite os domínios necessários para comunicação. Consulte as definições do firewall do Azure File Sync.

Além disso:

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 os pontos de extremidade privados

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

Recurso implementado	Description	O que fazes
Ponto final privado	Um recurso Azure que liga a sua conta de armazenamento ou Serviço de Sincronização de Armazenamento a uma interface de rede na sua rede virtual	Crie um para cada recurso em Criar o endpoint privado da conta de armazenamento e criar o endpoint privado do Storage Sync Service
Interface de rede (NIC)	Detém o endereço IP privado do endpoint privado dentro da sua sub-rede	Criado automaticamente com o endpoint privado; Não é necessária ação extra
Zona DNS privada	Associa o nome do anfitrião público do recurso ao endereço IP do endpoint privado, para que os clientes se liguem ao endpoint privado sem alterar as cadeias de ligação	Criado automaticamente se não existir um; recomendado evitar a configuração manual do DNS

Nota

Este artigo utiliza os sufixos DNS para as regiões públicas do Azure: core.windows.net para contas de armazenamento e afs.azure.net para Serviços de Sincronização de Armazenamento. Esta nomenclatura aplica-se também às clouds Azure Sovereign, como a cloud Azure US Government. Basta substituir os sufixos apropriados para o seu ambiente.

Criar o ponto de extremidade privado da conta de armazenamento

Navega até à conta de armazenamento para a qual gostarias de criar um endereço privado. No menu de serviço, em Segurança + rede, selecione Rede, Conexões de ponto de extremidade privado e, em seguida , + Ponto de extremidade privado para criar um novo ponto de extremidade privado.

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

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

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

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

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

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

Selecione Criar para criar o ponto de extremidade privado.

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 executando os seguintes comandos a partir do PowerShell, da linha de comandos ou do terminal (funciona para Windows, Linux ou macOS). Substitua <storage-account-name> pelo nome da sua conta de armazenamento:

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

Se tudo funcionar com sucesso, você verá a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado em sua rede virtual (saída mostrada para Windows):

Server:  UnKnown
Address:  10.2.4.4

Non-authoritative answer:
Name:    storageaccount.privatelink.file.core.windows.net
Address:  192.168.0.5
Aliases:  storageaccount.file.core.windows.net

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

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

# Get storage account reference, and throw error if it doesn't exist
$storageAccount = Get-AzStorageAccount `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name $storageAccountName `
        -ErrorAction SilentlyContinue

if ($null -eq $storageAccount) {
    $errorMessage = "Storage account $storageAccountName not found "
    $errorMessage += "in resource group $storageAccountResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Get virtual network reference, and throw error if it doesn't exist
$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $virtualNetworkName `
        -ErrorAction SilentlyContinue

if ($null -eq $virtualNetwork) {
    $errorMessage = "Virtual network $virtualNetworkName not found "
    $errorMessage += "in resource group $virtualNetworkResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

# Get reference to virtual network subnet, and throw error if it doesn't exist
$subnet = $virtualNetwork | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    Write-Error `
            -Message "Subnet $subnetName not found in virtual network $virtualNetworkName." `
            -ErrorAction Stop
}

Para criar um ponto de extremidade privado, deve-se criar uma ligação de serviço privado com a conta de armazenamento. A conexão de serviço de ligação privada é uma entrada para a criação do ponto de extremidade privado.

# Disable private endpoint network policies
$subnet.PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork = $virtualNetwork | `
    Set-AzVirtualNetwork -ErrorAction Stop

# Create a private link service connection to the storage account.
$privateEndpointConnection = New-AzPrivateLinkServiceConnection `
        -Name "$storageAccountName-Connection" `
        -PrivateLinkServiceId $storageAccount.Id `
        -GroupId "file" `
        -ErrorAction Stop

# Create a new private endpoint.
$privateEndpoint = New-AzPrivateEndpoint `
        -ResourceGroupName $storageAccountResourceGroupName `
        -Name "$storageAccountName-PrivateEndpoint" `
        -Location $virtualNetwork.Location `
        -Subnet $subnet `
        -PrivateLinkServiceConnection $privateEndpointConnection `
        -ErrorAction Stop

Criar uma zona DNS privada do Azure permite que o nome original da conta de armazenamento, como storageaccount.file.core.windows.net, seja resolvido para o endereço IP privado dentro da rede virtual. Embora opcional da perspetiva da criação de um ponto de extremidade privado, ele é explicitamente necessário para montar o compartilhamento de arquivos do Azure diretamente usando uma entidade de usuário do AD ou acessando por meio da API REST.

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done like this so this script will seamlessly work for non-public Azure.
$storageAccountSuffix = Get-AzContext | `
    Select-Object -ExpandProperty Environment | `
    Select-Object -ExpandProperty StorageEndpointSuffix

# For public cloud, this will generate the following DNS suffix:
# privatelink.file.core.windows.net.
$dnsZoneName = "privatelink.file.$storageAccountSuffix"

# Find a DNS zone matching desired name attached to this virtual network.
$dnsZone = Get-AzPrivateDnsZone | `
    Where-Object { $_.Name -eq $dnsZoneName } | `
    Where-Object {
        $privateDnsLink = Get-AzPrivateDnsVirtualNetworkLink `
                -ResourceGroupName $_.ResourceGroupName `
                -ZoneName $_.Name `
                -ErrorAction SilentlyContinue
        
        $privateDnsLink.VirtualNetworkId -eq $virtualNetwork.Id
    }

if ($null -eq $dnsZone) {
    # No matching DNS zone attached to virtual network, so create new one.
    $dnsZone = New-AzPrivateDnsZone `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -Name $dnsZoneName `
            -ErrorAction Stop

    $privateDnsLink = New-AzPrivateDnsVirtualNetworkLink `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -ZoneName $dnsZoneName `
            -Name "$virtualNetworkName-DnsLink" `
            -VirtualNetworkId $virtualNetwork.Id `
            -ErrorAction Stop
}

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

$privateEndpointIP = $privateEndpoint | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object @{ 
        Name = "NetworkInterfaces"; 
        Expression = { Get-AzNetworkInterface -ResourceId $_.Id } 
    } | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty IpConfigurations | `
    Select-Object -ExpandProperty PrivateIpAddress

$privateDnsRecordConfig = New-AzPrivateDnsRecordConfig `
        -IPv4Address $privateEndpointIP

New-AzPrivateDnsRecordSet `
        -ResourceGroupName $virtualNetworkResourceGroupName `
        -Name $storageAccountName `
        -RecordType A `
        -ZoneName $dnsZoneName `
        -Ttl 600 `
        -PrivateDnsRecords $privateDnsRecordConfig `
        -ErrorAction Stop | `
    Out-Null

Se tiver uma VM dentro da sua rede virtual, ou se configurou o encaminhamento DNS conforme descrito em Configurar encaminhamento DNS para Ficheiros do Azure, pode testar se o seu endpoint privado está corretamente configurado usando os seguintes comandos:

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

Resolve-DnsName -Name $storageAccountHostName

Se tudo funcionar com sucesso, você verá a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado em sua rede virtual:

Name                             Type   TTL   Section    NameHost
----                             ----   ---   -------    --------
storageaccount.file.core.windows CNAME  60    Answer     storageaccount.privatelink.file.core.windows.net
.net

Name       : storageaccount.privatelink.file.core.windows.net
QueryType  : A
TTL        : 600
Section    : Answer
IP4Address : 192.168.0.5

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

# Get storage account ID 
storageAccount=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" | \
    tr -d '"')

# Get virtual network ID
virtualNetwork=$(az network vnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --name $virtualNetworkName \
        --query "id" | \
    tr -d '"')

# Get subnet ID
subnet=$(az network vnet subnet show \
        --resource-group $virtualNetworkResourceGroupName \
        --vnet-name $virtualNetworkName \
        --name $subnetName \
        --query "id" | \
    tr -d '"')

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

# Disable private endpoint network policies
az network vnet subnet update \
        --ids $subnet \
        --disable-private-endpoint-network-policies \
        --output none

# Get virtual network location
region=$(az network vnet show \
        --ids $virtualNetwork \
        --query "location" | \
    tr -d '"')

# Create a private endpoint
privateEndpoint=$(az network private-endpoint create \
        --resource-group $storageAccountResourceGroupName \
        --name "$storageAccountName-PrivateEndpoint" \
        --location $region \
        --subnet $subnet \
        --private-connection-resource-id $storageAccount \
        --group-id "file" \
        --connection-name "$storageAccountName-Connection" \
        --query "id" | \
    tr -d '"')

Criar uma zona DNS privada do Azure permite que o nome original da conta de armazenamento, como storageaccount.file.core.windows.net, seja resolvido para o endereço IP privado dentro da rede virtual. Embora opcional ao criar um ponto de extremidade privado, é explicitamente necessário para montar o partilhamento de ficheiros do Azure usando um principal de utilizador do AD ou aceder através da API REST.

# Get the desired storage account suffix (core.windows.net for public cloud).
# This is done like this so this script will seamlessly work for non-public Azure.
storageAccountSuffix=$(az cloud show \
        --query "suffixes.storageEndpoint" | \
    tr -d '"')

# For public cloud, this will generate the following DNS suffix:
# privatelink.file.core.windows.net.
dnsZoneName="privatelink.file.$storageAccountSuffix"

# Find a DNS zone matching desired name attached to this virtual network.
possibleDnsZones=""
possibleDnsZones=$(az network private-dns zone list \
        --query "[?name == '$dnsZoneName'].id" \
        --output tsv)

dnsZone=""
possibleDnsZone=""
for possibleDnsZone in $possibleDnsZones
do
    possibleResourceGroupName=$(az resource show \
            --ids $possibleDnsZone \
            --query "resourceGroup" | \
        tr -d '"')
    
    link=$(az network private-dns link vnet list \
            --resource-group $possibleResourceGroupName \
            --zone-name $dnsZoneName \
            --query "[?virtualNetwork.id == '$virtualNetwork'].id" \
            --output tsv)
    
    if [ -z $link ]
    then
        echo "1" > /dev/null
    else 
        dnsZoneResourceGroup=$possibleResourceGroupName
        dnsZone=$possibleDnsZone
        break
    fi  
done

if [ -z $dnsZone ]
then
    # No matching DNS zone attached to virtual network, so create a new one
    dnsZone=$(az network private-dns zone create \
            --resource-group $virtualNetworkResourceGroupName \
            --name $dnsZoneName \
            --query "id" | \
        tr -d '"')
    
    az network private-dns link vnet create \
            --resource-group $virtualNetworkResourceGroupName \
            --zone-name $dnsZoneName \
            --name "$virtualNetworkName-DnsLink" \
            --virtual-network $virtualNetwork \
            --registration-enabled false \
            --output none
    
    dnsZoneResourceGroup=$virtualNetworkResourceGroupName
fi

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

privateEndpointNIC=$(az network private-endpoint show \
        --ids $privateEndpoint \
        --query "networkInterfaces[0].id" | \
    tr -d '"')

privateEndpointIP=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[0].privateIPAddress" | \
    tr -d '"')

az network private-dns record-set a create \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --name $storageAccountName \
        --output none

az network private-dns record-set a add-record \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --record-set-name $storageAccountName \
        --ipv4-address $privateEndpointIP \
        --output none

httpEndpoint=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "primaryEndpoints.file" | \
    tr -d '"')

hostName=$(echo $httpEndpoint | cut -c7-$(expr length $httpEndpoint) | tr -d "/")
nslookup $hostName

Se tudo funcionar com sucesso, você verá a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado em sua rede virtual:

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

Criar o ponto de extremidade privado do Serviço de Sincronização de Armazenamento

Vá ao Private Link Center escrevendo Private Link na barra de pesquisa no topo do portal Azure. No índice do Private Link Center, selecione endpoints privados e depois selecione + Adicionar para criar um novo endpoint privado.

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

No separador Noções básicas, selecione o grupo de recursos, o nome e a região do seu ponto final privado. Estes valores podem ser quaisquer valores válidos. Eles não precisam de corresponder de forma alguma ao Serviço de Sincronização de Armazenamento, mas tens de criar o endpoint privado na mesma região da rede virtual que selecionas.

Uma captura de tela da seção Noções básicas da seção Criar ponto de extremidade privado

Na guia Recurso, selecione Conectar a um recurso do Azure em meu diretório. Em Tipo de Recurso, selecione Microsoft. StorageSync/storageSyncServices.

O separador Configuração permite-lhe selecionar a rede virtual e a sub-rede específicas onde quer adicionar o seu endpoint privado. Selecione a mesma rede virtual que usou para a conta de armazenamento. O separador de Configuração contém também a informação para criar e atualizar a zona DNS privada.

Selecione Rever e Criar para criar o ponto de extremidade privado.

Você pode testar se seu ponto de extremidade privado está configurado corretamente executando os seguintes comandos do PowerShell.

$privateEndpointResourceGroupName = "<your-private-endpoint-resource-group>"
$privateEndpointName = "<your-private-endpoint-name>"

Get-AzPrivateEndpoint `
        -ResourceGroupName $privateEndpointResourceGroupName `
        -Name $privateEndpointName `
        -ErrorAction Stop | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty Id | `
    ForEach-Object { Get-AzNetworkInterface -ResourceId $_ } | `
    Select-Object -ExpandProperty IpConfigurations | `
    Select-Object -ExpandProperty PrivateLinkConnectionProperties | `
    Select-Object -ExpandProperty Fqdns | `
    ForEach-Object { Resolve-DnsName -Name $_ } | `
    Format-List

Se tudo funcionar corretamente, você verá a seguinte saída onde 192.168.1.4, 192.168.1.5, 192.168.1.6, e 192.168.1.7 são os endereços IP privados atribuídos ao ponto de extremidade privado:

Name     : mysssmanagement.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : mysssmanagement.westus2.privatelink.afs.azure.net


Name       : mysssmanagement.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.4

Name     : myssssyncp.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : myssssyncp.westus2.privatelink.afs.azure.net


Name       : myssssyncp.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.5

Name     : myssssyncs.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : myssssyncs.westus2.privatelink.afs.azure.net


Name       : myssssyncs.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.6

Name     : mysssmonitoring.westus2.afs.azure.net
Type     : CNAME
TTL      : 60
Section  : Answer
NameHost : mysssmonitoring.westus2.privatelink.afs.azure.net


Name       : mysssmonitoring.westus2.privatelink.afs.azure.net
QueryType  : A
TTL        : 60
Section    : Answer
IP4Address : 192.168.1.7

Para criar um endpoint privado para o seu Serviço de Sincronização de Armazenamento, primeiro obtenha uma referência ao seu Serviço de Sincronização de Armazenamento. Substitua <storage-sync-service-resource-group> e <storage-sync-service> pelos valores corretos para o seu ambiente. Os seguintes comandos PowerShell assumem que já preencheu a informação da rede virtual.

$storageSyncServiceResourceGroupName = "<storage-sync-service-resource-group>"
$storageSyncServiceName = "<storage-sync-service>"

$storageSyncService = Get-AzStorageSyncService `
        -ResourceGroupName $storageSyncServiceResourceGroupName `
        -Name $storageSyncServiceName `
        -ErrorAction SilentlyContinue

if ($null -eq $storageSyncService) {
    $errorMessage = "Storage Sync Service $storageSyncServiceName not found "
    $errorMessage += "in resource group $storageSyncServiceResourceGroupName."
    Write-Error -Message $errorMessage -ErrorAction Stop
}

Para criar um ponto de extremidade privado, você deve criar uma conexão de serviço de link privado com o Serviço de Sincronização de Armazenamento. A ligação privada é uma entrada para a criação de um ponto final privado.

# Disable private endpoint network policies
$subnet.PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork = $virtualNetwork | `
    Set-AzVirtualNetwork -ErrorAction Stop

# Create a private link service connection to the storage account
$privateEndpointConnection = New-AzPrivateLinkServiceConnection `
        -Name "$storageSyncServiceName-Connection" `
        -PrivateLinkServiceId $storageSyncService.ResourceId `
        -GroupId "Afs" `
        -ErrorAction Stop

# Create a new private endpoint
$privateEndpoint = New-AzPrivateEndpoint `
        -ResourceGroupName $storageSyncServiceResourceGroupName `
        -Name "$storageSyncServiceName-PrivateEndpoint" `
        -Location $virtualNetwork.Location `
        -Subnet $subnet `
        -PrivateLinkServiceConnection $privateEndpointConnection `
        -ErrorAction Stop

A criação de uma zona DNS privada do Azure permite que os nomes de host do Serviço de Sincronização de Armazenamento, como mysssmanagement.westus2.afs.azure.net, sejam resolvidos para os IPs privados corretos para o Serviço de Sincronização de Armazenamento dentro da rede virtual. Embora seja opcional do ponto de vista da criação de um ponto de extremidade privado, é explicitamente necessário que o agente de Sincronização de Arquivos do Azure acesse o Serviço de Sincronização de Armazenamento.

# Get the desired Storage Sync Service suffix (afs.azure.net for public cloud)
# This is done like this so this script will seamlessly work for non-public Azure
$azureEnvironment = Get-AzContext | `
    Select-Object -ExpandProperty Environment | `
    Select-Object -ExpandProperty Name

switch($azureEnvironment) {
    "AzureCloud" {
        $storageSyncSuffix = "afs.azure.net"
    }

    "AzureUSGovernment" {
        $storageSyncSuffix = "afs.azure.us"
    }

   "AzureChinaCloud" {
        $storageSyncSuffix = "afs.azure.cn"
    }

    default {
        Write-Error
                -Message "The Azure environment $_ is not currently supported by Azure File Sync." `
                -ErrorAction Stop
    }
}

# For public cloud, this will generate the following DNS suffix:
# privatelink.afs.azure.net
$dnsZoneName = "privatelink.$storageSyncSuffix"

# 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 a 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, deve criar um registro A para o Serviço de Sincronização de Armazenamento.

$privateEndpointIpFqdnMappings = $privateEndpoint | `
    Select-Object -ExpandProperty NetworkInterfaces | `
    Select-Object -ExpandProperty Id | `
    ForEach-Object { Get-AzNetworkInterface -ResourceId $_ } | `
    Select-Object -ExpandProperty IpConfigurations | `
    ForEach-Object {
        $privateIpAddress = $_.PrivateIpAddress;
        $_ | `
            Select-Object -ExpandProperty PrivateLinkConnectionProperties | `
            Select-Object -ExpandProperty Fqdns | `
            Select-Object `
                @{
                    Name = "PrivateIpAddress";
                    Expression = { $privateIpAddress }
                }, `
                @{
                    Name = "FQDN";
                    Expression = { $_ }
                }
    }

foreach($ipFqdn in $privateEndpointIpFqdnMappings) {
    $privateDnsRecordConfig = New-AzPrivateDnsRecordConfig `
        -IPv4Address $ipFqdn.PrivateIpAddress

    $dnsEntry = $ipFqdn.FQDN.Substring(0,
        $ipFqdn.FQDN.IndexOf(".", $ipFqdn.FQDN.IndexOf(".") + 1))

    New-AzPrivateDnsRecordSet `
            -ResourceGroupName $virtualNetworkResourceGroupName `
            -Name $dnsEntry `
            -RecordType A `
            -ZoneName $dnsZoneName `
            -Ttl 600 `
            -PrivateDnsRecords $privateDnsRecordConfig `
            -ErrorAction Stop | `
        Out-Null
}

Para criar um endpoint privado para o seu Serviço de Sincronização de Armazenamento, primeiro obtenha uma referência ao seu Serviço de Sincronização de Armazenamento. Substitua <storage-sync-service-resource-group> e <storage-sync-service> pelos valores corretos para o seu ambiente. Os comandos CLI seguintes assumem que já preencheu a informação da rede virtual.

storageSyncServiceResourceGroupName="<storage-sync-service-resource-group>"
storageSyncServiceName="<storage-sync-service>"

storageSyncService=$(az resource show \
        --resource-group $storageSyncServiceResourceGroupName \
        --name $storageSyncServiceName \
        --resource-type "Microsoft.StorageSync/storageSyncServices" \
        --query "id" | \
    tr -d '"')

storageSyncServiceRegion=$(az resource show \
        --resource-group $storageSyncServiceResourceGroupName \
        --name $storageSyncServiceName \
        --resource-type "Microsoft.StorageSync/storageSyncServices" \
        --query "location" | \
    tr -d '"')

Para criar um endpoint privado, certifique-se primeiro de que a política de rede de endpoint privado da sub-rede está definida como desativada. Depois cria um endpoint privado usando o az network private-endpoint create comando.

# Disable private endpoint network policies
az network vnet subnet update \
        --ids $subnet \
        --disable-private-endpoint-network-policies \
        --output none

# Get virtual network location
region=$(az network vnet show \
        --ids $virtualNetwork \
        --query "location" | \
    tr -d '"')

# Create a private endpoint
privateEndpoint=$(az network private-endpoint create \
        --resource-group $storageSyncServiceResourceGroupName \
        --name "$storageSyncServiceName-PrivateEndpoint" \
        --location $region \
        --subnet $subnet \
        --private-connection-resource-id $storageSyncService \
        --group-id "Afs" \
        --connection-name "$storageSyncServiceName-Connection" \
        --query "id" | \
    tr -d '"')

# Get the desired storage account suffix (afs.azure.net for public cloud)
# This is done like this so this script will seamlessly work for non-public Azure
azureEnvironment=$(az cloud show \
        --query "name" |
    tr -d '"')

storageSyncSuffix=""
if [ $azureEnvironment == "AzureCloud" ]
then
    storageSyncSuffix="afs.azure.net"
elif [ $azureEnvironment == "AzureUSGovernment" ]
then
    storageSyncSuffix="afs.azure.us"
else
    echo "Unsupported Azure environment $azureEnvironment."
fi

# For public cloud, this will generate the following DNS suffix:
# privatelink.afs.azure.net
dnsZoneName="privatelink.$storageSyncSuffix"

# Find a DNS zone matching desired name attached to this virtual network
possibleDnsZones=""
possibleDnsZones=$(az network private-dns zone list \
        --query "[?name == '$dnsZoneName'].id" \
        --output tsv)

dnsZone=""
possibleDnsZone=""
for possibleDnsZone in $possibleDnsZones
do
    possibleResourceGroupName=$(az resource show \
            --ids $possibleDnsZone \
            --query "resourceGroup" | \
        tr -d '"')

    link=$(az network private-dns link vnet list \
            --resource-group $possibleResourceGroupName \
            --zone-name $dnsZoneName \
            --query "[?virtualNetwork.id == '$virtualNetwork'].id" \
            --output tsv)

    if [ -z $link ]
    then
        echo "1" > /dev/null
    else
        dnsZoneResourceGroup=$possibleResourceGroupName
        dnsZone=$possibleDnsZone
        break
    fi
done

if [ -z $dnsZone ]
then
    # No matching DNS zone attached to virtual network, so create a new one
    dnsZone=$(az network private-dns zone create \
            --resource-group $virtualNetworkResourceGroupName \
            --name $dnsZoneName \
            --query "id" | \
        tr -d '"')

    az network private-dns link vnet create \
            --resource-group $virtualNetworkResourceGroupName \
            --zone-name $dnsZoneName \
            --name "$virtualNetworkName-DnsLink" \
            --virtual-network $virtualNetwork \
            --registration-enabled false \
            --output none

    dnsZoneResourceGroup=$virtualNetworkResourceGroupName
fi

Agora que você tem uma referência à zona DNS privada, deve criar um registro A para o Serviço de Sincronização de Armazenamento.

privateEndpointNIC=$(az network private-endpoint show \
        --ids $privateEndpoint \
        --query "networkInterfaces[0].id" | \
    tr -d '"')

privateIpAddresses=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[].privateIpAddress" \
        --output tsv)

hostNames=$(az network nic show \
        --ids $privateEndpointNIC \
        --query "ipConfigurations[].privateLinkConnectionProperties.fqdns[]" \
        --output tsv)

i=0
for privateIpAddress in $privateIpAddresses
do
    j=0
    targetHostName=""
    for hostName in $hostNames
    do
        if [ $i == $j ]
        then
            targetHostName=$hostName
            break
        fi

        j=$(expr $j + 1)
    done

    endpointName=$(echo $targetHostName | \
        cut -c1-$(expr $(expr index $targetHostName ".") - 1))

    az network private-dns record-set a create \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --name "$endpointName.$storageSyncServiceRegion" \
        --output none

    az network private-dns record-set a add-record \
        --resource-group $dnsZoneResourceGroup \
        --zone-name $dnsZoneName \
        --record-set-name "$endpointName.$storageSyncServiceRegion" \
        --ipv4-address $privateIpAddress \
        --output none

    i=$(expr $i + 1)
done

Restringir o acesso aos pontos finais públicos

Você pode restringir o acesso aos pontos de extremidade públicos da conta de armazenamento e dos Serviços de Sincronização de Armazenamento. Restringir o acesso ao ponto de extremidade público fornece segurança adicional, garantindo que os pacotes de rede só sejam aceitos de locais aprovados.

Restringir o acesso ao ponto de extremidade público da conta de armazenamento

Podes restringir o acesso ao endpoint público usando as definições do firewall da conta de armazenamento. Em geral, a maioria das políticas de firewall para uma conta de armazenamento restringe o acesso à rede a uma ou mais redes virtuais. Para restringir o acesso a uma conta de armazenamento a uma rede virtual, utilize uma das seguintes abordagens:

Crie um ou mais pontos de extremidade privados para a conta de armazenamento e desative o acesso ao ponto de extremidade público. Isso garante que apenas o tráfego originado de dentro das redes virtuais desejadas possa acessar os compartilhamentos de arquivos do Azure na conta de armazenamento.
Restrinja o ponto de extremidade público a uma ou mais redes virtuais. Esta abordagem funciona ao utilizar 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, continua a aceder à conta de armazenamento através do endereço IP público.

Nota

Para permitir que serviços serviços Microsoft confiáveis e de primeira parte, como o Azure File Sync, acedam à conta de armazenamento, selecione a opção Permitir que serviços serviços Microsoft confiáveis acedam a esta caixa de recurso na sua conta de armazenamento. Para mais informações, veja Restringir o acesso ao endpoint público a redes específicas.

Importante

O Azure File Sync tem uma limitação conhecida nos perímetros de segurança de rede (NSP). Os Serviços de Sincronização de Armazenamento não podem ser colocados dentro de um perímetro, e a integração total do perímetro não é suportada.

Para ligar um Serviço de Sincronização de Armazenamento a uma conta de armazenamento protegida por um NSP:

Configure o Serviço de Sincronização de Armazenamento para usar Identidades Geridas.
Crie uma regra de perfil de entrada NSP que permita listar a subscrição que aloja o Serviço de Sincronização de Armazenamento.

Os Serviços de Sincronização de Armazenamento devem permanecer fora do perímetro para que a sincronização funcione corretamente.

Conceder acesso a serviços confiáveis do Azure e desabilitar o acesso ao ponto de extremidade público da conta de armazenamento

Quando desativa o acesso ao endpoint público, ainda pode aceder à conta de armazenamento através do endpoint privado, mas os pedidos ao endpoint público da conta de armazenamento são rejeitados.

Aceda à conta de armazenamento para a qual pretende restringir todo o acesso ao endpoint público. No sumário da conta de armazenamento, selecione Rede.

No topo da página, selecione o seletor Ativado a partir de redes virtuais selecionadas e endereços IP. Isto revelará um conjunto de configurações para controlar a restrição do endpoint público. Selecione Permitir que os serviços do Azure na lista de serviços confiáveis acessem essa conta de armazenamento para permitir que serviços confiáveis da Microsoft, como o Azure File Sync, acessem a conta de armazenamento.

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

# This assumes $storageAccount is still defined from the beginning of this of this guide.
$storageAccount | Update-AzStorageAccountNetworkRuleSet `
        -DefaultAction Deny `
        -Bypass AzureServices `
        -WarningAction SilentlyContinue `
        -ErrorAction Stop | `
    Out-Null

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

# This assumes $storageAccountResourceGroupName and $storageAccountName 
# are still defined from the beginning of this guide.
az storage account update \
    --resource-group $storageAccountResourceGroupName \
    --name $storageAccountName \
    --bypass "AzureServices" \
    --default-action "Deny" \
    --output none

Conceder acesso a serviços confiáveis do Azure e restringir o acesso ao ponto de extremidade público da conta de armazenamento a redes virtuais específicas

Ao restringir a conta de armazenamento a redes virtuais específicas, você está permitindo solicitações para o ponto de extremidade público de dentro das redes virtuais especificadas. Isso funciona utilizando uma capacidade da rede virtual denominada pontos de extremidade de serviço. Isto pode ser utilizado com ou sem endpoints privados.

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

No topo da página, selecione o seletor Ativado a partir de redes virtuais selecionadas e endereços IP. Isto revelará um conjunto de configurações para controlar a restrição do endpoint público. Selecione +Adicionar rede virtual existente para selecionar a rede virtual específica que deve ter permissão para acessar a conta de armazenamento por meio do ponto de extremidade público. Selecione uma rede virtual e uma sub-rede para essa rede virtual e, em seguida, selecione Ativar.

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

Para restringir o acesso ao ponto de extremidade público da conta de armazenamento a redes virtuais específicas usando pontos de extremidade de serviço, primeiro precisamos coletar informações sobre a conta de armazenamento e a rede virtual. Preencha <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> e <subnet-name> para recolher esta informação.

$storageAccountResourceGroupName = "<storage-account-resource-group>"
$storageAccountName = "<storage-account-name>"
$restrictToVirtualNetworkResourceGroupName = "<vnet-resource-group-name>"
$restrictToVirtualNetworkName = "<vnet-name>"
$subnetName = "<subnet-name>"

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

$virtualNetwork = Get-AzVirtualNetwork `
        -ResourceGroupName $restrictToVirtualNetworkResourceGroupName `
        -Name $restrictToVirtualNetworkName `
        -ErrorAction Stop

$subnet = $virtualNetwork | `
    Select-Object -ExpandProperty Subnets | `
    Where-Object { $_.Name -eq $subnetName }

if ($null -eq $subnet) {
    Write-Error `
            -Message "Subnet $subnetName not found in virtual network $restrictToVirtualNetworkName." `
            -ErrorAction Stop
}

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

$serviceEndpoints = $subnet | `
    Select-Object -ExpandProperty ServiceEndpoints | `
    Select-Object -ExpandProperty Service

if ($serviceEndpoints -notcontains "Microsoft.Storage") {
    if ($null -eq $serviceEndpoints) {
        $serviceEndpoints = @("Microsoft.Storage")
    } elseif ($serviceEndpoints -is [string]) {
        $serviceEndpoints = @($serviceEndpoints, "Microsoft.Storage")
    } else {
        $serviceEndpoints += "Microsoft.Storage"
    }

    $virtualNetwork = $virtualNetwork | Set-AzVirtualNetworkSubnetConfig `
            -Name $subnetName `
            -AddressPrefix $subnet.AddressPrefix `
            -ServiceEndpoint $serviceEndpoints `
            -WarningAction SilentlyContinue `
            -ErrorAction Stop | `
        Set-AzVirtualNetwork `
            -ErrorAction Stop
}

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

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

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

storageAccountResourceGroupName="<storage-account-resource-group>"
storageAccountName="<storage-account-name>"
restrictToVirtualNetworkResourceGroupName="<vnet-resource-group-name>"
restrictToVirtualNetworkName="<vnet-name>"
subnetName="<subnet-name>"

storageAccount=$(az storage account show \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --query "id" | \
    tr -d '"')

virtualNetwork=$(az network vnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --name $restrictToVirtualNetworkName \
        --query "id" | \
    tr -d '"')

subnet=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "id" | \
    tr -d '"')

Para que o tráfego da rede virtual seja autorizado pela malha de rede do Azure a alcançar o ponto de extremidade público da conta de armazenamento, a sub-rede da rede virtual deve ter o Microsoft.Storage ponto de extremidade de serviço exposto. Os seguintes comandos da CLI adicionarão o ponto de extremidade de serviço Microsoft.Storage à sub-rede, caso ainda não esteja lá.

serviceEndpoints=$(az network vnet subnet show \
        --resource-group $restrictToVirtualNetworkResourceGroupName \
        --vnet-name $restrictToVirtualNetworkName \
        --name $subnetName \
        --query "serviceEndpoints[].service" \
        --output tsv)

foundStorageServiceEndpoint=false
for serviceEndpoint in $serviceEndpoints
do
    if [ $serviceEndpoint = "Microsoft.Storage" ]
    then
        foundStorageServiceEndpoint=true
    fi
done

if [ $foundStorageServiceEndpoint = false ] 
then
    serviceEndpointList=""

    for serviceEndpoint in $serviceEndpoints
    do
        serviceEndpointList+=$serviceEndpoint
        serviceEndpointList+=" "
    done
    
    serviceEndpointList+="Microsoft.Storage"

    az network vnet subnet update \
            --ids $subnet \
            --service-endpoints $serviceEndpointList \
            --output none
fi

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

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

Desativar o acesso ao terminal público do Serviço de Sincronização de Armazenamento

A Sincronização de Ficheiros do Azure permite-lhe restringir o acesso a redes virtuais específicas apenas através de pontos de extremidade privados; A Sincronização de Ficheiros do Azure não suporta pontos de extremidade de serviço para restringir o acesso ao ponto de extremidade público a redes virtuais específicas. Isso significa que os dois estados do ponto final público do serviço de sincronização de armazenamento são ativado e desativado.

Importante

Você deve criar um ponto de extremidade privado antes de desabilitar o acesso ao ponto de extremidade público. Se o ponto de extremidade público estiver desativado e não houver nenhum ponto de extremidade privado configurado, a sincronização não poderá funcionar.

Para desativar o acesso ao ponto de extremidade público do Serviço de Sincronização de Armazenamento, siga estas etapas:

Inicie sessão no portal do Azure.
Aceda ao Serviço de Sincronização de Armazenamento e selecione Definições>Rede na navegação à esquerda.
Em Permitir acesso de, selecione Somente pontos de extremidade privados.
Selecione um ponto de extremidade privado na lista de Conexões de ponto de extremidade privado.

Para desativar o acesso ao endpoint público do Serviço de Sincronização de Armazenamento, defina a incomingTrafficPolicy propriedade no Serviço de Sincronização de Armazenamento para AllowVirtualNetworksOnly. Para permitir o acesso ao endpoint público do Serviço de Sincronização de Armazenamento, defina incomingTrafficPolicy para AllowAllTraffic. Substitua <storage-sync-service-resource-group> e <storage-sync-service> pelos seus próprios valores.

$storageSyncServiceResourceGroupName = "<storage-sync-service-resource-group>"
$storageSyncServiceName = "<storage-sync-service>"

Set-AzStorageSyncService `
    -ResourceGroupName $storageSyncServiceResourceGroupName `
    -Name $storageSyncServiceName `
    -IncomingTrafficPolicy AllowVirtualNetworksOnly

Azure Policy para Ficheiros do Azure e Azure File Sync

A Política do Azure ajuda a impor os padrões da organização e a avaliar a conformidade em relação a esses padrões em escala. Os Arquivos do Azure e a Sincronização de Arquivos do Azure expõem várias políticas de rede úteis de auditoria e correção que ajudam você a monitorar e automatizar sua implantação.

As políticas auditam seu ambiente e alertam você se suas contas de armazenamento ou o Storage Sync Services divergirem do comportamento definido. Por exemplo, a política alerta-te se um endpoint público estiver ativado quando a tua política foi definida para desativar os endpoints públicos. Modificar e implementar políticas pode modificar proativamente um recurso (como o Serviço de Sincronização de Armazenamento) ou implementar recursos (como endpoints privados) para alinhar com as políticas.

As seguintes políticas predefinidas estão disponíveis para os Arquivos do Azure e a Sincronização de Arquivos do Azure:

Ação	Serviço	Condição	Nome da política
Auditoria	Ficheiros do Azure	O ponto de extremidade público da conta de armazenamento está habilitado. Veja Conceder acesso a serviços fidedignos do Azure e desativar o acesso ao ponto final público da conta de armazenamento para mais informações.	As contas de armazenamento devem restringir o acesso à rede
Auditoria	Azure File Sync	O ponto de extremidade público do Serviço de Sincronização de Armazenamento está habilitado. Consulte Desativar o acesso ao endpoint público do Serviço de Sincronização de Armazenamento para obter mais informações.	O acesso à rede pública deve ser desabilitado para o Azure File Sync
Auditoria	Ficheiros do Azure	A conta de armazenamento precisa de pelo menos um ponto de extremidade privado. Consulte Criar o ponto de extremidade privado da conta de armazenamento para obter mais informações.	A conta de armazenamento deve usar uma conexão de link privado
Auditoria	Azure File Sync	O Serviço de Sincronização de Armazenamento precisa de pelo menos um ponto de extremidade privado. Consulte Criar o ponto de extremidade privado do Serviço de Sincronização de Armazenamento para mais informações.	O Azure File Sync deve usar o link privado
Modificar	Azure File Sync	Desative o ponto de extremidade público do Serviço de Sincronização de Armazenamento.	Modificar - Configurar a Sincronização de Ficheiros do Azure para desativar o acesso à rede pública
Implementar	Azure File Sync	Implemente um ponto de extremidade privado para o Serviço de Sincronização de Armazenamento.	Configurar a sincronização de ficheiros do Azure utilizando pontos finais privados
Implementar	Azure File Sync	Implante um registro A em privatelink.afs.azure.net zona DNS.	Configurar a Sincronização de Ficheiros do Azure para utilizar zonas DNS privadas

Configurar uma política de implantação de ponto de extremidade privado

Para configurar uma política de implementação de endpoint privado, siga estes passos:

Inicie sessão no portal do Azure e pesquise por Policy. Selecione Política nos resultados.
Vá a Autoria>Definições no índice do Centro de Políticas.
No painel de Definições, selecione a categoria Armazenamento no filtro de categoria, ou pesquise por Configurar Azure File Sync com endpoints privados.
Selecione ... ao lado da apólice e depois selecione Atribuir.
Na página Básicos , opcionalmente defina um âmbito, uma lista de exclusão e um nome amigável para a apólice. Selecione Seguinte.
Na página Parâmetros , selecione ... ao lado do campo privateEndpointSubnetId . Selecione a rede virtual e a sub-rede onde os endpoints privados para os seus recursos do Storage Sync Service devem ser implementados. O assistente pode demorar vários segundos a carregar as redes virtuais disponíveis. Selecione Seguinte.
Na página de Remediação , selecione Criar uma tarefa de remediação para que o endpoint privado seja implementado quando um Serviço de Sincronização de Armazenamento sem um endpoint privado for identificado.
Selecione Rever + criar para rever a atribuição da política e depois selecione Criar.

A atribuição de política resultante será executada periodicamente e pode não ser executada imediatamente após a criação.

Consulte também

Comentários

Esta página foi útil?

Last updated on 2026-07-24