Configurer des points de terminaison de réseau public et privé Azure File Sync

Article
06/05/2024

Azure Files et Azure File Sync fournissent deux principaux types de points de terminaison pour l’accès aux partages de fichiers Azure :

Les points de terminaison publics, qui ont une adresse IP publique et sont accessibles partout dans le monde.
Les points de terminaison privés, qui existent au sein d’un réseau virtuel et ont une adresse IP privée comprise dans l’espace d’adressage de ce réseau virtuel.

Pour Azure Files et Azure File Sync, les objets de gestion Azure, le compte de stockage et le service de synchronisation du stockage, contrôlent les points de terminaison publics et privés. Le compte de stockage est une construction de gestion qui représente un pool de stockage partagé dans lequel vous pouvez déployer plusieurs partages de fichiers, ainsi que d’autres ressources de stockage, telles que des objets blob ou des files d’attente. Le service de synchronisation de stockage est une construction de gestion qui représente les serveurs inscrits, qui sont des serveurs de fichiers Windows avec une relation d’approbation établie avec Azure File Sync, ainsi que des groupes de synchronisation, qui définissent la topologie de la relation de synchronisation.

Cet article se concentre sur la configuration des points de terminaison réseau pour Azure Files et Azure File Sync. Pour en savoir plus sur la configuration des points de terminaison réseau pour accéder directement aux partages de fichiers Azure, plutôt que d’effectuer une mise en cache locale avec Azure File Sync, consultez Configuration des points de terminaison réseau Azure Files.

Avant de lire le présent guide, nous vous recommandons de lire Considérations relatives aux réseaux Azure File Sync.

Prérequis

Cet article suppose que vous avez :

Vous avez un abonnement Azure. Si vous n’avez pas d’abonnement, vous pouvez créer un compte gratuit avant de commencer.
Vous avez déjà créé un partage de fichiers Azure dans un compte de stockage auquel vous souhaitez vous connecter à partir d’un emplacement local. Pour savoir comment créer un partage de fichiers Azure, consultez Créer un partage de fichiers Azure.
Pour autoriser le trafic de domaine vers les points de terminaison suivants, consultez Points de terminaison de service Azure :

De plus :

Si vous envisagez d’utiliser Azure PowerShell, installez-en la dernière version.
Si vous envisagez d’utiliser Azure CLI, installez-en la dernière version.

Créer les points de terminaison privés

Lorsque vous créez un point de terminaison privé pour une ressource Azure, les ressources suivantes sont déployées :

Un point de terminaison privé : Ressource Azure représentant le point de terminaison privé pour le compte de stockage ou le service de synchronisation de stockage. Considérez-la comme une ressource qui connecte votre ressource Azure à une interface réseau.
Une interface réseau (NIC) : interface réseau qui gère une adresse IP privée au sein du réseau virtuel ou du sous-réseau spécifié. C’est exactement la même ressource que celle déployée lors du déploiement d’une machine virtuelle, mais au lieu d’être attribuée à une machine virtuelle, elle est détenue par le point de terminaison privé.
Une zone DNS privée : si vous n’avez jamais déployé de point de terminaison privé pour ce réseau virtuel, une nouvelle zone DNS privée sera déployée pour votre réseau virtuel. Un enregistrement DNS A est également créé pour la ressource Azure dans cette zone DNS. Si vous avez déjà déployé un point de terminaison privé dans ce réseau virtuel, un nouvel enregistrement A est ajouté à la zone DNS existante pour la ressource Azure. Le déploiement d’une zone DNS est facultatif, mais il est fortement recommandé pour simplifier la gestion DNS requise.

Notes

Cet article utilise les suffixes DNS pour les régions publiques Azure, core.windows.net pour les comptes de stockage et afs.azure.net pour les services de synchronisation de stockage. Cela vaut aussi pour les clouds souverains Azure que sont notamment le cloud Azure US Government (il vous suffit de remplacer les suffixes appropriés pour votre environnement).

Créer le point de terminaison privé du compte de stockage

Accédez au compte de stockage pour lequel vous souhaitez créer un point de terminaison privé. Dans la table des matières du compte de stockage, sélectionnez Réseau, Connexions de point de terminaison privé, puis + Point de terminaison privé pour créer un point de terminaison privé.

L’Assistant obtenu comprend plusieurs pages dont vous devez suivre les instructions.

Dans le panneau Informations de base, sélectionnez l’abonnement, le groupe de ressources, le nom, le nom de l’interface réseau et la région souhaités pour votre point de terminaison privé. Vous pouvez choisir ceux que vous voulez. Ils ne doivent pas nécessairement correspondre au compte de stockage. Vous devez simplement créer le point de terminaison privé dans la même région que le réseau virtuel dans lequel vous souhaitez créer le point de terminaison privé. Sélectionnez ensuite Suivant : Ressource .

Dans le panneau Ressource, sélectionnez fichier pour la sous-ressource cible. Sélectionnez ensuite Suivant : réseau virtuel.

Le panneau Réseau virtuel vous permet de sélectionner le réseau virtuel et le sous-réseau auxquels vous souhaitez ajouter votre point de terminaison privé. Sélectionnez l’allocation d’adresse IP dynamique ou statique pour le nouveau point de terminaison privé. Si vous sélectionnez le mode statique, vous devez également fournir un nom et une adresse IP privée. Si vous le souhaitez, vous pouvez également spécifier un groupe de sécurité d’application. Quand vous avez terminé, cliquez sur Suivant : DNS.

Le panneau DNS contient les informations permettant d’intégrer votre point de terminaison privé à une zone DNS privée. Vérifiez que l’abonnement et le groupe de ressources sont corrects, puis sélectionnez Suivant : Étiquettes.

Vous pouvez éventuellement appliquer des étiquettes pour classer vos ressources, telles que l’application du nom Environnement et de la valeur Test à toutes les ressources de test. Si vous le souhaitez, entrez des paires nom/valeur, puis sélectionnez Suivant : Vérifier + créer.

Cliquez sur Vérifier + créer pour créer le point de terminaison privé.

Si vous disposez d’une machine virtuelle dans votre réseau virtuel, ou si vous avez configuré le transfert DNS comme décrit dans Configuration du transfert DNS pour Azure Files, vous pouvez vérifier que votre point de terminaison privé est correctement configuré en exécutant les commandes suivantes à partir de PowerShell, de la ligne de commande ou du terminal (fonctionne sur Windows, Linux et macOS). Vous devez remplacer <storage-account-name> par le nom du compte de stockage approprié :

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

Si tout fonctionne correctement, vous devriez voir la sortie suivante, où 192.168.0.5 correspond à l’adresse IP privée du point de terminaison privé de votre réseau virtuel (sortie affichée pour 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

Si vous souhaitez créer un point de terminaison privé pour votre compte de stockage, vous devez d’abord obtenir une référence à votre compte de stockage et au sous-réseau du réseau virtuel auquel vous souhaitez ajouter le point de terminaison privé. Remplacez <storage-account-resource-group-name>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> et <vnet-subnet-name> ci-dessous :

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

Pour créer un point de terminaison privé, vous devez créer une connexion de service sous forme de liaison privée au compte de stockage. La connexion au service sous forme de liaison privée est une entrée pour la création du point de terminaison privé.

# 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

La création d’une zone DNS privée Azure permet au nom d’origine du compte de stockage (par exemple storageaccount.file.core.windows.net) d’être résolu en adresse IP privée dans le réseau virtuel. Bien que cela soit facultatif pour la création d’un point de terminaison privé, c’est obligatoire pour le montage du partage de fichiers Azure directement à l’aide d’un principal d’utilisateur Active Directory, ainsi que pour l’accès via l’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
}

Maintenant que vous disposez d’une référence à la zone DNS privée, vous devez créer un enregistrement A pour votre compte de stockage.

$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

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

Resolve-DnsName -Name $storageAccountHostName

Si tout a fonctionné correctement, vous devriez voir la sortie suivante, où 192.168.0.5 correspond à l’adresse IP privée du point de terminaison privé de votre réseau virtuel :

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 '"')

Pour créer un point de terminaison privé, vous devez d’abord vérifier que la stratégie réseau du point de terminaison privé du sous-réseau est définie sur Désactivée. Vous pouvez ensuite créer un point de terminaison privé avec la commande 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 '"')

La création d’une zone DNS privée Azure permet au nom d’origine du compte de stockage (par exemple storageaccount.file.core.windows.net) d’être résolu en adresse IP privée dans le réseau virtuel. Bien que cela soit facultatif pour la création d’un point de terminaison privé, c’est obligatoire pour le montage du partage de fichiers Azure à l’aide d’un principal d’utilisateur Active Directory, ainsi que pour l’accès via l’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

Maintenant que vous disposez d’une référence à la zone DNS privée, vous devez créer un enregistrement A pour votre compte de stockage.

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

Si tout a fonctionné correctement, vous devriez voir la sortie suivante, où 192.168.0.5 correspond à l’adresse IP privée du point de terminaison privé de votre réseau virtuel :

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

Créer le point de terminaison privé du service de synchronisation de stockage

Accédez au Centre de liaisons privées en tapant Liaison privée dans la barre de recherche en haut du portail Azure. Dans la table des matières du Centre de liaisons privées, sélectionnez Points de terminaison privés, puis + Ajouter pour créer un point de terminaison privé.

L’Assistant obtenu comprend plusieurs pages dont vous devez suivre les instructions.

Dans le panneau De base, sélectionnez le groupe de ressources, le nom et la région souhaités pour votre point de terminaison privé. Vous pouvez choisir ceux que vous voulez. Ils ne doivent pas nécessairement correspondre au service de synchronisation du stockage. Vous devez simplement créer le point de terminaison privé dans la même région que le réseau virtuel dans lequel vous souhaitez créer le point de terminaison privé.

Capture d’écran de la section De base de la fenêtre Créer un point de terminaison privé

Dans le panneau Ressource, activez la case d’option Se connecter à une ressource Azure de mon annuaire. Sous Type de ressource, sélectionnez Microsoft.StorageSync/storageSyncServices pour le type de ressource.

Le panneau Configuration vous permet de sélectionner le réseau virtuel et le sous-réseau auxquels vous souhaitez ajouter votre point de terminaison privé. Sélectionnez le même réseau virtuel que celui que vous avez utilisé pour le compte de stockage ci-dessus. Le panneau Configuration contient également les informations relatives à la création et à la mise à jour de la zone DNS privée.

Sélectionnez Vérifier + créer pour créer le point de terminaison privé.

Vous pouvez tester que votre point de terminaison privé est configuré correctement en exécutant les commandes PowerShell suivantes.

$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

Si tout fonctionne correctement, vous devez voir la sortie suivante, où 192.168.1.4, 192.168.1.5, 192.168.1.6 et 192.168.1.7 sont les adresses IP privées attribuées au point de terminaison privé :

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

Pour créer un point de terminaison privé pour votre service de synchronisation du stockage, vous devez d’abord obtenir une référence à ce dernier. Pensez à remplacer <storage-sync-service-resource-group> et <storage-sync-service> par les valeurs correctes de votre environnement. Les commandes PowerShell suivantes supposent que vous avez déjà rempli les informations de réseau virtuel.

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

Pour créer un point de terminaison privé, vous devez créer une connexion de service sous forme de liaison privée au service de synchronisation du stockage. La connexion sous forme de liaison privée est une entrée pour la création du point de terminaison privé.

# 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

La création d’une zone DNS privée Azure permet de faire correspondre les noms d’hôte du service de synchronisation du stockage, tels que mysssmanagement.westus2.afs.azure.net, aux adresses IP privées appropriées pour le service de synchronisation du stockage dans le réseau virtuel. Même si cela est facultatif du point de vue de la création d’un point de terminaison privé, cela est explicitement requis pour que l’agent Azure File Sync puisse accéder au service de synchronisation du stockage.

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

Maintenant que vous disposez d’une référence à la zone DNS privée, vous devez créer un enregistrement A pour votre service de synchronisation du stockage.

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

Pour créer un point de terminaison privé pour votre service de synchronisation du stockage, vous devez d’abord obtenir une référence à ce dernier. Pensez à remplacer <storage-sync-service-resource-group> et <storage-sync-service> par les valeurs correctes de votre environnement. Les commandes CLI suivantes supposent que vous avez déjà rempli les informations de réseau virtuel.

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

Maintenant que vous disposez d’une référence à la zone DNS privée, vous devez créer un enregistrement A pour votre service de synchronisation du stockage.

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

Limiter l’accès aux points de terminaison publics

Vous pouvez restreindre l’accès aux points de terminaison publics du compte de stockage et du service de synchronisation du stockage. Restreindre l’accès au point de terminaison public fournit une sécurité supplémentaire en garantissant que les paquets réseau sont uniquement acceptés à partir des emplacements approuvés.

Restreindre l’accès au point de terminaison public du compte de stockage

Les restrictions d’accès au point de terminaison public s’effectuent à l’aide des paramètres de pare-feu du compte de stockage. En général, la plupart des stratégies de pare-feu d’un compte de stockage limitent l’accès réseau à un ou plusieurs réseaux virtuels. Il existe deux approches pour limiter l’accès d’un compte de stockage à un réseau virtuel :

Créer un ou plusieurs points de terminaison privés pour le compte de stockage et désactiver l’accès au point de terminaison public. Seul le trafic en provenance des réseaux virtuels souhaités accède alors aux partages de fichiers Azure du compte de stockage.
Limiter le point de terminaison public à un ou plusieurs réseaux virtuels. Cette approche s’appuie sur une fonctionnalité du réseau virtuel appelée points de terminaison de service. Quand vous limitez le trafic à un compte de stockage via un point de terminaison de service, vous continuez d’accéder au compte de stockage via l’adresse IP publique.

Remarque

L’exception Autoriser les services Azure figurant dans la liste des services approuvés à accéder à ce compte de stockage doit être sélectionnée sur votre compte de stockage pour autoriser les services Microsoft premier tiers approuvés, comme Azure File Sync, à accéder au compte de stockage. Pour en savoir plus, consultez Octroyer l’accès aux services Azure approuvés.

Octroyer l’accès aux services Azure approuvés et désactiver l’accès au point de terminaison public du compte de stockage

Lorsque l’accès au point de terminaison public est désactivé, le compte de stockage reste accessible via ses points de terminaison privés. Si ce n’est pas le cas, les requêtes valides envoyées au point de terminaison public du compte de stockage seront rejetées.

Accédez au compte de stockage pour lequel vous souhaitez limiter tous les accès au point de terminaison public. Dans la table des matières du compte de stockage, sélectionnez Réseaux.

En haut de la page, sélectionnez la case d’option Activé à partir des réseaux virtuels et des adresses IP sélectionnés. Cela aura pour effet d’afficher un certain nombre de paramètres permettant de contrôler la restriction du point de terminaison public. Sélectionnez Autoriser les services Azure figurant dans la liste des services approuvés à accéder à ce compte de stockage pour autoriser les services Microsoft tiers approuvés, comme Azure File Sync, à accéder au compte de stockage.

La commande PowerShell suivante refusera tout le trafic vers le point de terminaison public du compte de stockage. Notez que le paramètre -Bypass de cette commande est défini sur AzureServices. Cela permet aux services tiers approuvés, comme Azure File Sync, d’accéder au compte de stockage via le point de terminaison public.

# 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

La commande CLI suivante refusera tout le trafic vers le point de terminaison public du compte de stockage. Notez que le paramètre -bypass de cette commande est défini sur AzureServices. Cela permet aux services tiers approuvés, comme Azure File Sync, d’accéder au compte de stockage via le point de terminaison public.

# 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

Octroyer l’accès aux services Azure approuvés et restreindre l’accès au point de terminaison public du compte de stockage à des réseaux virtuels spécifiques

Quand vous limitez le compte de stockage à des réseaux virtuels spécifiques, vous autorisez les requêtes vers le point de terminaison public depuis les réseaux virtuels spécifiés. Cette approche s’appuie sur une fonctionnalité du réseau virtuel appelée points de terminaison de service. Cela peut être utilisé avec ou sans points de terminaison privés.

Accédez au compte de stockage dont le point de terminaison public ne doit être accessible qu’à certains réseaux virtuels. Dans la table des matières du compte de stockage, sélectionnez Réseaux.

En haut de la page, sélectionnez la case d’option Activé à partir des réseaux virtuels et des adresses IP sélectionnés. Cela aura pour effet d’afficher un certain nombre de paramètres permettant de contrôler la restriction du point de terminaison public. Sélectionnez + Ajouter un réseau virtuel existant pour sélectionner le réseau virtuel qui doit être autorisé à accéder au compte de stockage via le point de terminaison public. Sélectionnez un réseau virtuel et un sous-réseau pour ce réseau virtuel, puis sélectionnez Activer.

Sélectionnez Autoriser les services Azure figurant dans la liste des services approuvés à accéder à ce compte de stockage pour autoriser les services Microsoft tiers approuvés, comme Azure File Sync, à accéder au compte de stockage.

Si vous souhaitez utiliser des points de terminaison de service pour limiter l’accès au point de terminaison public du compte de stockage à certains réseaux virtuels, vous devez d’abord collecter des informations sur le compte de stockage et le réseau virtuel. Renseignez <storage-account-resource-group>, <storage-account-name>, <vnet-resource-group-name>, <vnet-name> et <subnet-name> pour recueillir ces informations.

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

Pour que le trafic provenant du réseau virtuel soit autorisé par la structure fabric réseau Azure à accéder au point de terminaison public du compte de stockage, le point de terminaison de service Microsoft.Storage du sous-réseau du réseau virtuel doit être exposé. Les commandes PowerShell suivantes ajoutent le point de terminaison de service Microsoft.Storage au sous-réseau, s’il n’y figure pas déjà.

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

La dernière étape concernant la restriction du trafic vers le compte de stockage consiste à créer une règle de réseau, puis à l’ajouter au jeu de règles de réseau du compte de stockage.

$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 '"')

Pour que le trafic provenant du réseau virtuel soit autorisé par la structure fabric réseau Azure à accéder au point de terminaison public du compte de stockage, le point de terminaison de service Microsoft.Storage du sous-réseau du réseau virtuel doit être exposé. Les commandes CLI suivantes ajoutent le point de terminaison de service Microsoft.Storage au sous-réseau, s’il n’y figure pas déjà.

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

La dernière étape concernant la restriction du trafic vers le compte de stockage consiste à créer une règle de réseau, puis à l’ajouter au jeu de règles de réseau du compte de stockage.

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

Désactiver l’accès au point de terminaison public du service de synchronisation du stockage

Azure File Sync vous permet de restreindre l’accès à des réseaux virtuels spécifiques par le biais de points de terminaison privés uniquement. Azure File Sync ne prend pas en charge les points de terminaison de service pour restreindre l’accès au point de terminaison public à des réseaux virtuels spécifiques. Cela signifie que les deux états du point de terminaison public du service de synchronisation du stockage sont Activé et Désactivé.

Important

Vous devez créer un point de terminaison privé avant de désactiver l’accès au point de terminaison public. Si le point de terminaison public est désactivé et qu’aucun point de terminaison privé n’est configuré, la synchronisation ne peut pas fonctionner.

Pour désactiver l’accès au point de terminaison public du service de synchronisation de stockage, procédez comme suit :

Connectez-vous au portail Azure.
Accédez au service de synchronisation de stockage et sélectionnez Paramètres>Réseau dans la navigation de gauche.
Sous Autoriser l’accès à partir de, sélectionnez Points de terminaison privés uniquement.
Sélectionnez un point de terminaison privé dans la liste Connexions de point de terminaison privé.

Pour désactiver l’accès au point de terminaison public du service de synchronisation de stockage, définissez la propriété incomingTrafficPolicy du service de synchronisation du stockage sur AllowVirtualNetworksOnly. Si vous souhaitez activer l’accès au point de terminaison public du service de synchronisation du stockage, définissez plutôt incomingTrafficPolicy sur AllowAllTraffic. Assurez-vous de remplacer <storage-sync-service-resource-group> et <storage-sync-service> par vos propres valeurs.

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

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

Azure Policy

Azure Policy permet d’appliquer les normes de l’organisation et d’évaluer la conformité par rapport à ces normes à grande échelle. Azure Files et Azure File Sync exposent plusieurs stratégies réseau d’audit et de correction utiles qui vous aident à superviser et à automatiser votre déploiement.

Les stratégies auditent votre environnement et vous alertent si vos comptes de stockage ou services de synchronisation de stockage divergent du comportement défini, par exemple si un point de terminaison public est activé alors que votre stratégie a été définie de façon à ce que les points de terminaison publics soient désactivés. Les stratégies de modification/déploiement vont au-delà et permettent de modifier de manière proactive une ressource (telle que le service de synchronisation de stockage) ou de déployer des ressources (telles que des points de terminaison privés) afin d’être en adéquation avec les stratégies.

Les stratégies prédéfinies suivantes sont disponibles pour Azure Files et Azure File Sync :

Action	Service	Condition	Nom de stratégie
Audit	Azure Files	Le point de terminaison public du compte de stockage est activé. Consultez Octroyer l’accès aux services Azure approuvés et désactiver l’accès au point de terminaison public du compte de stockage pour plus d’informations.	Les comptes de stockage doivent limiter l’accès réseau
Audit	Azure File Sync	Le point de terminaison public du service de synchronisation de stockage est activé. Pour plus d’informations, consultez Désactiver l’accès au point de terminaison public du service de synchronisation de stockage.	L’accès au réseau public doit être désactivé pour Azure File Sync
Audit	Azure Files	Le compte de stockage a besoin d’au moins un point de terminaison privé. Pour plus d’informations, consultez Créer le point de terminaison privé du compte de stockage.	Le compte de stockage doit utiliser une connexion de liaison privée
Audit	Azure File Sync	Le service de synchronisation de stockage a besoin d’au moins un point de terminaison privé. Pour plus d’informations, consultez Créer le point de terminaison privé du service de synchronisation de stockage.	Azure File Sync doit utiliser une liaison privée
Modifier	Azure File Sync	Désactiver le point de terminaison public du service de synchronisation de stockage.	Modifier - Configurer Azure File Sync pour désactiver l’accès au réseau public
Déployer	Azure File Sync	Déployer un point de terminaison privé pour le service de synchronisation de stockage.	Configurer Azure File Sync avec des points de terminaison privés
Déployer	Azure File Sync	Déployer un enregistrement A dans la zone DNS privatelink.afs.azure.net.	Configurer Azure File Sync pour utiliser des zones DNS privées

Configurer une stratégie de déploiement de points de terminaison privé

Pour configurer une stratégie de déploiement de points de terminaison privé, accédez au portail Azure et recherchez Stratégie. Le centre Azure Policy doit être l’un des premiers résultats. Accédez à Création>Définitions dans la table des matières du centre de stratégie. Le volet Définitions qui s’affiche contient les stratégies prédéfinies pour tous les services Azure. Pour trouver la stratégie spécifique, sélectionnez la catégorie Stockage dans le filtre de catégorie, ou recherchez Configurer Azure File Sync avec des points de terminaison privés. Sélectionnez ... et Attribuer pour créer une nouvelle stratégie à partir de la définition.

Le panneau Informations de base de l’Assistant Attribuer la stratégie vous permet de définir une étendue, une liste d’exclusion de ressource ou de groupe de ressources, et de donner à votre stratégie un nom convivial pour vous aider à la distinguer. Vous n’avez pas besoin de modifier ces éléments pour que la stratégie fonctionne, mais vous pouvez le faire si vous souhaitez apporter des modifications. Sélectionnez Suivant pour accéder à la page Paramètres.

Dans le panneau Paramètres, sélectionnez ... en regard de la liste déroulante privateEndpointSubnetId pour sélectionner le réseau virtuel et le sous-réseau où les points de terminaison privés pour vos ressources de service de synchronisation de stockage doivent être déployés. L’Assistant peut mettre plusieurs secondes à charger les réseaux virtuels disponibles dans votre abonnement. Sélectionnez le réseau/sous-réseau virtuel approprié pour votre environnement, puis cliquez sur Sélectionner. Sélectionnez Suivant pour accéder au panneau Correction.

Pour que le point de terminaison privé soit déployé quand un service de synchronisation de stockage sans point de terminaison privé est identifié, vous devez sélectionner la tâche Créer une correction dans la page Correction. Pour finir, sélectionnez Vérifier + créer pour passer en revue l’attribution de stratégie et Créer pour la créer.

L’attribution de stratégie résultante sera exécutée régulièrement, et risque de ne pas être exécutée immédiatement après sa création.

Partager via