Configurar pontos de extremidade de rede pública e privada do Sincronização de Arquivos do Azure

Artigo
06/05/2024

Os Arquivos do Azure e a Sincronização de Arquivos do Azure fornecem dois tipos principais de pontos de extremidade para acessar compartilhamentos de arquivo do Azure:

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

Tanto para os Ficheiros do Azure como para o Sincronização de Arquivos do Azure, os objetos de gestão do Azure (a conta de armazenamento e o Serviço de Sincronização de Armazenamento) controlam os pontos de extremidade privado e públicos. A conta de armazenamento é uma construção de gestão que representa um conjunto partilhado de armazenamento no qual pode implementar várias partilhas de ficheiros, bem como outros recursos de armazenamento, como bolhas ou filas. O Serviço de Sincronização de Armazenamento é um constructo de gerenciamento que representa servidores registrados, que são servidores de arquivos do Windows com uma relação de confiança estabelecida com a Sincronização de Arquivos do Azure e grupos de sincronização, que definem a topologia do relacionamento de sincronização.

Este artigo se concentra em como configurar os pontos de extremidade de rede para Arquivos do Azure e Sincronização de Arquivos do Azure. Para saber mais sobre como configurar pontos de extremidade de rede para acessar os compartilhamentos de arquivos do Azure diretamente, em vez de armazenar em cache local com a Sincronização de Arquivos do Azure, confira Como configurar os pontos de extremidade de rede de Arquivos do Azure.

Recomendamos a leitura de Considerações de rede do Sincronização de Arquivos do Azure antes de ler esse guia prático.

Pré-requisitos

Este artigo supõe que:

Você tem uma assinatura do Azure. Se você ainda não tiver uma assinatura, crie uma conta gratuita antes de começar.
Você já criou um compartilhamento de arquivos do Azure em uma conta de armazenamento à qual gostaria de se conectar no local. Para saber como criar um compartilhamento de arquivo do Azure, confira Criar um compartilhamento de arquivo do Azure.
Você permite o tráfego de domínio para os seguintes pontos de extremidade, consultepontos de extremidade de serviço do Azure:

Adicionalmente:

Se pretende usar o Azure PowerShell, instale a versão mais recente.
Se pretende usar a CLI do Azure, instale a versão mais recente.

Criar os pontos de extremidade privados

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

Um ponto de extremidade privado: Um recurso do Azure que representa o ponto de extremidade privado para a conta de armazenamento ou o Serviço de Sincronização de Armazenamento. Pense nisso como um recurso que conecta seu recurso do Azure e uma interface de rede.
Uma NIC (adaptador de rede) : o adaptador de rede que mantém um endereço IP privado dentro da rede virtual/sub-rede especificada. É exatamente o mesmo recurso que é implantado quando você implanta uma máquina virtual (VM). No entanto, em vez de ser atribuído a uma VM, ele pertence ao ponto de extremidade privado.
Uma zona DNS privada: se você nunca tiver implantado um ponto de extremidade privado para essa rede virtual, uma nova zona DNS privada será implantada em sua rede virtual. Um registro DNS A também será criado para o recurso do Azure nesta zona DNS. Se você já tiver implantado um ponto de extremidade privado nessa rede virtual, um novo registro A para o recurso do Azure será adicionado à zona DNS existente. A implantação de uma zona DNS é opcional, porém altamente recomendável para simplificar o gerenciamento de DNS necessário.

Observação

Este artigo usa 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. Isso também se aplica às nuvens Azure Sovereign, como a nuvem Azure do Governo dos EUA - basta substituir os sufixos apropriados para o seu ambiente.

Criar o ponto de extremidade privado da conta de armazenamento

Navegue até a conta de armazenamento para a qual gostaria de criar o ponto de extremidade privado. Na sumário da conta de armazenamento, selecione Rede, Conexões de ponto de extremidade privado e + Ponto de extremidade privado para criar um ponto de extremidade privado.

O assistente resultante tem várias páginas a serem preenchidas.

Na folha Básico, selecione a assinatura, o grupo de recursos, o nome, o nome do adaptador de rede e a região desejados para o ponto de extremidade privado. Essas configurações podem ter o valor que você quiser, elas não precisam corresponder à conta de armazenamento, embora seja necessário criar o ponto de extremidade privado na mesma região que a rede virtual na qual você deseja criá-lo. Em seguida, selecione Avançar: Recurso .

Na folha Recurso, selecione o arquivo para o sub-recurso de destino. Selecione Próximo: Rede Virtual.

A folha Rede Virtual permite que você selecione a rede virtual específica e a sub-rede à qual deseja adicionar o 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 selecionar estático, você também precisará fornecer um nome e um endereço IP privado. Você também pode especificar um grupo de segurança do aplicativo. Quando terminar, selecione Avançar: DNS.

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

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

Clique em Examinar + Criar para criar o ponto de extremidade privado.

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

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

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

Server:  UnKnown
Address:  10.2.4.4

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

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 da rede virtual à qual deseja adicionar o ponto de extremidade privado. Substitua <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> e <vnet-subnet-name> abaixo:

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

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

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

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

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

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

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

Para criar um ponto de extremidade privado, você precisa criar uma conexão de serviço de link privado com a conta de armazenamento. A conexão do serviço de link privado é uma entrada para a criação do ponto de extremidade privado.

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

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

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

A criação de 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 IP privado dentro da rede virtual. Embora seja opcional do ponto de vista da criação de um ponto de extremidade privado, ela é explicitamente necessária para montar o compartilhamento de arquivo do Azure diretamente usando uma entidade de usuário do AD ou acessando pela 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 tem uma referência à zona DNS privada, você precisa 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 um VM dentro da sua rede virtual ou tiver configurado o encaminhamento de DNS conforme descrito em Configurar o encaminhamento de DNS para Arquivos do Azure, pode testar executando se o Ponto de extremidade privado está configurado corretamente com os seguintes comandos:

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

Resolve-DnsName -Name $storageAccountHostName

Se tudo funcionar bem, você deverá ver a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade 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

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, primeiro você precisa garantir que a política de rede do ponto de extremidade privado da sub-rede esteja configurada como desabilitada. Em seguida, você pode criar o ponto de extremidade privado com o comando 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" | \
    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 '"')

A criação de 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 IP privado dentro da rede virtual. Embora seja opcional do ponto de vista da criação de um ponto de extremidade privado, ela é explicitamente necessária para montar o compartilhamento de arquivo do Azure usando uma entidade de usuário do AD ou acessando pela 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 tem uma referência à zona DNS privada, você precisa 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 bem, você deverá ver a seguinte saída, onde 192.168.0.5 é o endereço IP privado do ponto de extremidade privado na 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

Navegue até o Centro de Link Privado digitando Link Privado na barra de pesquisa na parte superior do portal do Azure. No sumário do Centro de Link Privado, selecione Pontos de extremidade privados e, em seguida, + Adicionar para criar um ponto de extremidade privado.

O assistente resultante tem várias páginas a serem preenchidas.

Na folha Básico, selecione o grupo de recursos, o nome e a região desejados para o ponto de extremidade privado. Essas configurações podem ter o valor que você quiser, elas não precisam corresponder ao Serviço de Sincronização de Armazenamento, embora seja necessário criar o ponto de extremidade privado na mesma região que a rede virtual na qual você deseja criá-lo.

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

Na folha Recurso, selecione o botão de opção para Conectar-se a um recurso do Azure em meu diretório. Em Tipo de recurso, selecione Microsoft.StorageSync/storageSyncServices para o tipo de recurso.

A folha Configuração permite que você selecione a rede virtual específica e a sub-rede à qual deseja adicionar o ponto de extremidade privado. Selecione a mesma rede virtual que você usou para a conta de armazenamento acima. A folha Configuração também contém as informações para criar/atualizar a zona DNS privado.

Selecione revisar + 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ê deverá 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 ponto de extremidade privado para o seu Serviço de Sincronização de Armazenamento, primeiro terá de obter uma referência ao seu Serviço de Sincronização de Armazenamento. Lembre-se de substituir <storage-sync-service-resource-group> e <storage-sync-service> pelos valores corretos para seu ambiente. Os comandos do PowerShell a seguir pressupõem que você já preencheu as informações 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ê precisa criar uma conexão de serviço de link privado com o Serviço de Sincronização de Armazenamento. A conexão do link privado é uma entrada para a criação do ponto de extremidade privado.

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

# Create a private link service connection to the storage account.
$privateEndpointConnection = New-AzPrivateLinkServiceConnection `
        -Name "$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 privado do Azure habilita os nomes de host para o Serviço de Sincronização de Armazenamento, como mysssmanagement.westus2.afs.azure.net, para resolver 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 Sincronização de Arquivos do Azure aceda ao 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 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 privado, você precisa criar um registro A para seu 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 ponto de extremidade privado para o seu Serviço de Sincronização de Armazenamento, primeiro terá de obter uma referência ao seu Serviço de Sincronização de Armazenamento. Lembre-se de substituir <storage-sync-service-resource-group> e <storage-sync-service> pelos valores corretos para seu ambiente. Os comandos CLI a seguir pressupõem que você já preencheu as informações 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 '"')

# 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:
# privatelinke.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 tem uma referência à zona DNS privado, você precisa criar um registro A para seu 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 de extremidade 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 sejam aceitos apenas em locais aprovados.

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

A restrição de acesso ao ponto de extremidade público é feita usando as configurações de firewall da conta de armazenamento. Em geral, a maioria das políticas de firewall para uma conta de armazenamento restringirá o acesso de rede a uma ou mais redes virtuais. Há duas abordagens para a restrição do acesso a uma conta de armazenamento a uma rede virtual:

Criar um ou mais pontos de extremidade privados para a conta de armazenamento e desabilitar o acesso ao ponto de extremidade público. Com isso, apenas o tráfego proveniente de dentro das redes virtuais desejadas poderá acessar os compartilhamentos de arquivo do Azure dentro da conta de armazenamento.
Restrinja o ponto de extremidade público a uma ou mais redes virtuais. Isso funciona usando uma funcionalidade da rede virtual denominada pontos de extremidade de serviço. Ao restringir o tráfego a uma conta de armazenamento através de um ponto de extremidade de serviço, ainda está a aceder à conta de armazenamento através do endereço IP público.

Observação

A exceção Permitir que os serviços do azure na lista de serviços confiáveis acessem esta conta de armazenamento deve ser selecionada na sua conta de armazenamento para permitir que serviços confiáveis da Microsoft, como a Sincronização de Arquivos do Azure, acessem a conta de armazenamento. Para saber mais, confira Permitir acesso a serviços confiáveis do Azure.

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

Quando o acesso ao ponto de extremidade público está desabilitado, a conta de armazenamento ainda pode ser acessada por meio de seus pontos de extremidade privados. Caso contrário, as solicitações válidas para o ponto de extremidade público da conta de armazenamento serão rejeitadas.

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

Na parte superior da página, selecione o botão de opção Habilitado de redes virtuais e endereços IP selecionados. Isso exibirá várias configurações para controlar a restrição do ponto de extremidade público. Selecione Permitir que os serviços do azure na lista de serviços confiáveis acessem esta conta de armazenamento para permitir que serviços confiáveis da Microsoft, como a Sincronização de Arquivos do Azure, acessem a conta de armazenamento.

O comando do PowerShell a seguir negará todo o tráfego para o ponto de extremidade público da conta de armazenamento. Observe que esse comando tem o parâmetro -Bypass definido como AzureServices. Isso permitirá que serviços próprios confiáveis, como a Sincronização de Arquivos do Azure, 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 esse comando tem o parâmetro -bypass definido como AzureServices. Isso permitirá que serviços próprios confiáveis, como a Sincronização de Arquivos do Azure, 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 para redes virtuais específicas, você permite solicitações ao ponto de extremidade público de dentro das redes virtuais especificadas. Isso funciona usando uma funcionalidade da rede virtual denominada pontos de extremidade de serviço. Isso pode ser usado com ou sem pontos de extremidade privados.

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

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

Selecione Permitir que os serviços do azure na lista de serviços confiáveis acessem esta conta de armazenamento para permitir que serviços confiáveis da Microsoft, como a Sincronização de Arquivos do Azure, acessem a conta de armazenamento.

Para restringir o acesso ao ponto de extremidade público da conta de armazenamento para redes virtuais específicas usando pontos de extremidades 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 coletar essas informações.

$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 a malha de rede do Azure permita que o tráfego da rede virtual chegue ao ponto de extremidade público da conta de armazenamento, a sub-rede da rede virtual deverá ter o ponto de extremidade de serviço Microsoft.Storage exposto. Os comandos do PowerShell a seguir adicionarão o ponto de extremidade de serviço Microsoft.Storage à sub-rede, se ele ainda não estiver lá.

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

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

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

A etapa final para restringir o tráfego para a conta de armazenamento é criar uma regra de rede e adicioná-la ao conjunto de regras de rede da conta de armazenamento.

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

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

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 a malha de rede do Azure permita que o tráfego da rede virtual chegue ao ponto de extremidade público da conta de armazenamento, a sub-rede da rede virtual deverá ter o ponto de extremidade de serviço Microsoft.Storage exposto. Os comandos da CLI a seguir adicionarão o ponto de extremidade de serviço Microsoft.Storage à sub-rede, se ele ainda não estiver lá.

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

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

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

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

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

A etapa final para restringir o tráfego para a conta de armazenamento é criar uma regra de rede e adicioná-la ao conjunto de regras de rede da conta de armazenamento.

az storage account network-rule add \
        --resource-group $storageAccountResourceGroupName \
        --account-name $storageAccountName \
        --subnet $subnet \
        --output none

az storage account update \
        --resource-group $storageAccountResourceGroupName \
        --name $storageAccountName \
        --bypass "AzureServices" \
        --default-action "Deny" \
        --output none

Desabilitar o acesso ao ponto de extremidade público do Serviço de Sincronização de Armazenamento

A Sincronização de Arquivos do Azure permite restringir o acesso a redes virtuais específicas somente por meio de pontos de extremidade privados. A Sincronização de Arquivos do Azure não dá suporte a pontos de extremidade de serviço para restringir o acesso ao ponto de extremidade público para redes virtuais específicas. Isso significa que os dois estados do ponto de extremidade público do Serviço de Sincronização de Armazenamento são: habilitado e desabilitado.

Importante

Você precisa 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 desabilitado e não houver nenhum ponto de extremidade privado configurado, a sincronização não poderá funcionar.

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

Entre no portal do Azure.
Navegue até o Serviço de Sincronização de Armazenamento e selecione Configurações>Rede no painel de navegação esquerdo.
Em Permitir acesso a partir de, selecione Somente pontos de extremidade privados.
Selecione um ponto de extremidade privado na lista de Conexões de ponto de extremidade privado .

Para desabilitar o acesso ao ponto de extremidade público do Serviço de Sincronização de Armazenamento, configure a propriedade incomingTrafficPolicy no Serviço de Sincronização de Armazenamento como AllowVirtualNetworksOnly. Se, por outro lado, você quiser habilitar o acesso ao ponto de extremidade público do Serviço de Sincronização de Armazenamento, configure incomingTrafficPolicy como AllowAllTraffic. Substitua <storage-sync-service-resource-group> e <storage-sync-service> por valores próprios.

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

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

Azure Policy

O Azure Policy ajuda a reforçar os padrões da organização e a avaliar a conformidade com 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 de correção, que ajudam a monitorar e automatizar a implantação.

As políticas auditam o ambiente e alertam se as contas de armazenamento ou os Serviços de Sincronização de Armazenamento divergem do comportamento definido. Por exemplo, se houver um ponto de extremidade público habilitado quando a política foi definida para ter os pontos de extremidades públicos desabilitados. Modificar/implantar políticas vai um passo além e modifica proativamente um recurso (como o Serviço de Sincronização de Armazenamento) ou implanta recursos (como pontos de extremidade privados) para se alinhar às políticas.

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

Ação	Serviço	Condição	Nome de política
Audit	Arquivos do Azure	O ponto de extremidade público da conta de armazenamento está habilitado. Consulte Conceder acesso a serviços confiáveis do Azure e desabilitar o acesso ao ponto de extremidade público da conta de armazenamento para obter mais informações.	As contas de armazenamento devem restringir o acesso da rede
Audit	Sincronização de Arquivos do Azure	O ponto de extremidade público do Serviço de Sincronização de Armazenamento está habilitado. Consulte Desabilitar o acesso ao ponto de extremidade público do Serviço de Sincronização de Armazenamento para obter mais informações.	O acesso à rede pública deve ser desabilitado para a Sincronização de Arquivos do Azure
Audit	Arquivos 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
Audit	Sincronização de Arquivos do Azure	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 obter mais informações.	A Sincronização de Arquivos do Azure deve usar o link privado
Modificar	Sincronização de Arquivos do Azure	Desabilitar o ponto de extremidade público do Serviço de Sincronização de Armazenamento.	Modificar – configurar a Sincronização de Arquivos do Azure para desabilitar o acesso à rede pública
Implantar	Sincronização de Arquivos do Azure	Implantar um ponto de extremidade privado para o Serviço de Sincronização de Armazenamento.	Configurar a Sincronização de Arquivos do Azure com pontos de extremidade privados
Implantar	Sincronização de Arquivos do Azure	Implantar um registro A na zona DNS privatelink.afs.azure.net.	Configurar a Sincronização de Arquivos do Azure para usar zonas DNS privadas

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

Para configurar uma política de implantação de ponto de extremidade privado, vá para o portal do Azuree procure Política. O centro do Azure Policy deve ser um resultado superior. Navegue até Definições>de Criação no Sumário da Central de Políticas. O painel de Definições resultante conterá as políticas predefinidas em todos os serviços do Azure. Para localizar a política específica, selecione a categoria Armazenamento no filtro de categoria ou procure Configurar Sincronização de Arquivos do Azure com pontos de extremidade privados. Selecione ... e Atribuir para criar uma nova política a partir da definição.

A folha do assistente Noções Básicas para Atribuir política permite definir um escopo da reserva ou uma lista de exclusão de grupo de recursos e dar um nome amigável à sua política que ajudará a distingui-la. Não é necessário modificar os parâmetros para que a política funcione, mas é possível que se deseje fazer modificações. Selecione Próximo para avançar à página de Parâmetros.

Na folha Parâmetros, selecione ... ao lado da lista suspensa privateEndpointSubnetId para selecionar a rede virtual e a sub-rede em que os pontos de extremidade privados para os recursos do Serviço de Sincronização de Armazenamento devem ser implantados. O assistente resultante pode levar vários segundos para carregar as redes virtuais disponíveis em sua assinatura. Selecione a rede virtual/sub-rede apropriada para seu ambiente e clique em Selecionar. Selecione Avançar para ir para a folha de Correção.

Para que o ponto de extremidade privado seja implantado quando um Serviço de Sincronização de Armazenamento sem um ponto de extremidade privado for identificado, é necessário selecionar Criar uma tarefa de correção na página Correção. Por fim, selecione Examinar + criar para examinar a atribuição de política e Criar para criá-la.

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

Compartilhar via