Configurer Azure Private Link pour un compte Azure Cosmos DB

S’APPLIQUE À : NoSQL MongoDB Cassandra Gremlin Table

À l’aide d’Azure Private Link, vous pouvez vous connecter à un compte Azure Cosmos DB via un point de terminaison privé. Le point de terminaison privé est un ensemble d’adresses IP privées dans un sous-réseau au sein de votre réseau virtuel. Vous pouvez alors limiter l’accès à un compte Azure Cosmos DB via des adresses IP privées. Lorsque Private Link est combiné à des stratégies NSG limitées, il permet de réduire le risque d’exfiltration de données. Pour plus d’informations sur les points de terminaison privés, consultez Qu’est-ce qu’Azure Private Link ?.

Notes

Azure Private Link n’empêche pas la résolution de vos points de terminaison Azure Cosmos DB par le DNS public. Le filtrage des requêtes entrantes se produit au niveau de l’application, et non au niveau du transport ou du réseau.

Private Link permet aux utilisateurs d’accéder à un compte Azure Cosmos DB à partir du réseau virtuel ou de tout réseau virtuel appairé. Les ressources mappées à Private Link sont également accessibles localement via un Peering privé par le biais d’un VPN ou d’Azure ExpressRoute.

Vous pouvez vous connecter à un compte Azure Cosmos DB configuré avec Private Link en utilisant les méthodes d’approbation automatique ou manuelle. Pour plus d’informations, consultez la section sur le flux de travail d’approbation de la documentation Liaison privée (Private Link).

Cet article décrit comment configurer les points de terminaison privés pour le magasin transactionnel d’Azure Cosmos DB. Il suppose que vous utilisez la méthode d’approbation automatique. Si vous utilisez le magasin analytique, consultez Configurer les points de terminaison privés pour le magasin analytique.

Créer un point de terminaison privé au moyen du Portail Azure

Procédez comme suit pour créer un point de terminaison privé pour un compte Azure Cosmos DB existant à l’aide du portail Azure :

1. Connectez-vous au portail Azure, puis sélectionnez un compte Azure Cosmos DB.

2. Sélectionnez Mise en réseau dans la liste des paramètres, puis sélectionnez + Point de terminaison privé sous l’onglet Accès privé :

   

3. Dans le volet Créer un point de terminaison privé – Concepts de base, entrez ou sélectionnez les informations suivantes :

   Paramètre	Valeur
   Détails du projet
   Abonnement	Sélectionnez votre abonnement.
   Resource group	Sélectionnez un groupe de ressources.
   Détails de l’instance
   Nom	Entrez un nom pour votre point de terminaison privé. Si ce nom est utilisé, créez-en un unique.
   Région	Sélectionnez la région dans laquelle vous souhaitez déployer Private Link. Créez le point de terminaison privé au même emplacement que votre réseau virtuel.

4. Sélectionnez Suivant : Ressource.

5. Dans le volet Créer un point de terminaison privé – Ressource, entrez ou sélectionnez les informations suivantes :

   Paramètre	Valeur
   Méthode de connexion	Sélectionnez Se connecter à une ressource Azure dans mon répertoire. Vous pouvez ensuite choisir l’une de vos ressources pour configurer Private Link. Ou vous pouvez vous connecter à la ressource d’un autre utilisateur à l’aide d’un ID ou d’un alias de ressource qu’il a partagé avec vous.
   Abonnement	Sélectionnez votre abonnement.
   Type de ressource	Sélectionnez Microsoft.AzureCosmosDB/databaseAccounts.
   Ressource	Sélectionnez votre compte Azure Cosmos DB.
   Sous-ressource cible	Sélectionnez le type d’API Azure Cosmos DB que vous souhaitez mapper. Par défaut, il n’y a qu’un seul choix pour les API pour SQL, MongoDB et Cassandra. Pour les API pour Gremlin et Table, vous pouvez également choisir NoSQL, car ces API sont interopérables avec l’API pour NoSQL. Si vous disposez d’une passerelle dédiée approvisionnée pour un compte d’API pour NoSQL, vous voyez également une option pour SqlDedicated.

6. Sélectionnez Suivant : réseau virtuel.

7. Dans le volet Créer un point de terminaison privé – réseau virtuel, entrez ou sélectionnez les informations suivantes :

   Paramètre	Valeur
   Réseau virtuel	Sélectionnez votre réseau virtuel.
   Subnet	Sélectionnez votre sous-réseau.

8. Sélectionnez Suivant : DNS.

9. Dans le volet Créer un point de terminaison privé – DNS, entrez ou sélectionnez les informations suivantes :

   Paramètre	Valeur
   Intégrer à une zone DNS privée	Sélectionnez Oui. Pour vous connecter en privé à votre point de terminaison privé, vous avez besoin d’un enregistrement DNS. Nous vous recommandons d’intégrer votre point de terminaison privé à une zone DNS privée. Vous pouvez également utiliser vos propres serveurs DNS ou créer des enregistrements DNS à l’aide des fichiers hôtes sur vos machines virtuelles. Quand vous sélectionnez Oui pour cette option, un groupe de zones DNS privées est également créé. Le groupe de zones DNS est un lien entre la zone DNS privée et le point de terminaison privé. Ce lien vous permet de mettre à jour automatiquement la zone DNS privée lorsqu’il existe une mise à jour du point de terminaison privé. Par exemple, lorsque vous ajoutez ou supprimez des régions, la zone DNS privée est automatiquement mise à jour.
   Nom de la configuration	Sélectionnez votre abonnement et votre groupe de ressources. La zone DNS privée est déterminée automatiquement. Vous ne pouvez pas la modifier à l’aide du Portail Azure.

10. Sélectionnez Suivant : Balises>Vérifier + créer. Sur la page Revoir + créer, Azure valide votre configuration.

11. Lorsque le message Validation passed (Validation réussie) apparaît, sélectionnez Créer.

Si vous avez approuvé Private Link pour un compte Azure Cosmos DB, dans le portail Azure, l’option Tous les réseaux dans le volet Pare-feu et réseaux virtuels est désactivée.

Types d’API et noms de zones privées

Consultez configuration DNS des points de terminaison privés Azure pour obtenir une explication plus détaillée sur les zones privées et les configurations DNS pour le point de terminaison privé. Le tableau suivant montre le mappage entre différents types d’API de compte Azure Cosmos DB, les sous-ressources prises en charge et les noms de zones privées correspondants. Vous pouvez également accéder aux comptes API pour Table via l’API pour NoSQL : il y a donc deux entrées pour ces API. Il existe également une entrée supplémentaire pour l’API pour NoSQL pour les comptes utilisant la passerelle dédiée.

Type d’API de compte Azure Cosmos DB	Sous-ressources ou ID de groupe pris en charge	Nom de zone privée
NoSQL	SQL	privatelink.documents.azure.com
NoSQL	SqlDedicated	privatelink.sqlx.cosmos.azure.com
Cassandra	Cassandra	privatelink.cassandra.cosmos.azure.com
Mongo	MongoDB	privatelink.mongo.cosmos.azure.com
Gremlin	Gremlin	privatelink.gremlin.cosmos.azure.com
Gremlin	SQL	privatelink.documents.azure.com
Table de charge de travail	Table de charge de travail	privatelink.table.cosmos.azure.com
Table de charge de travail	SQL	privatelink.documents.azure.com

Récupérer les adresses IP privées

Une fois le point de terminaison privé provisionné, vous pouvez interroger les adresses IP. Pour afficher les adresses IP à partir du Portail Azure :

1. Recherchez le point de terminaison privé que vous avez créé précédemment. Dans ce cas, il s’agit de cdbPrivateEndpoint3.
2. Sélectionnez l’onglet Vue d’ensemble pour afficher les paramètres DNS et les adresses IP.

Plusieurs adresses IP sont créées par point de terminaison privé :

• Une pour le point de terminaison global (indépendant de la région) du compte Azure Cosmos DB.
• Une pour chaque région dans laquelle le compte Azure Cosmos DB est déployé.

Créer un point de terminaison privé à l’aide d’Azure PowerShell

Exécutez le script PowerShell suivant afin de créer un point de terminaison privé nommé MyPrivateEndpoint pour un compte Azure Cosmos DB existant. Remplacez les valeurs des variables par les informations de votre environnement.

$SubscriptionId = "<your Azure subscription ID>"
# Resource group where the Azure Cosmos DB account and virtual network resources are located
$ResourceGroupName = "myResourceGroup"
# Name of the Azure Cosmos DB account
$CosmosDbAccountName = "mycosmosaccount"

# Resource for the Azure Cosmos DB account: Sql, SqlDedicated, MongoDB, Cassandra, Gremlin, or Table
$CosmosDbSubResourceType = "Sql"
# Name of the existing virtual network
$VNetName = "myVnet"
# Name of the target subnet in the virtual network
$SubnetName = "mySubnet"
# Name of the private endpoint to create
$PrivateEndpointName = "MyPrivateEndpoint"
# Location where the private endpoint can be created. The private endpoint should be created in the same location where your subnet or the virtual network exists
$Location = "westcentralus"

$cosmosDbResourceId = "/subscriptions/$($SubscriptionId)/resourceGroups/$($ResourceGroupName)/providers/Microsoft.DocumentDB/databaseAccounts/$($CosmosDbAccountName)"

$privateEndpointConnection = New-AzPrivateLinkServiceConnection -Name "myConnectionPS" -PrivateLinkServiceId $cosmosDbResourceId -GroupId $CosmosDbSubResourceType
 
$virtualNetwork = Get-AzVirtualNetwork -ResourceGroupName  $ResourceGroupName -Name $VNetName  
 
$subnet = $virtualNetwork | Select -ExpandProperty subnets | Where-Object  {$_.Name -eq $SubnetName}  
 
$privateEndpoint = New-AzPrivateEndpoint -ResourceGroupName $ResourceGroupName -Name $PrivateEndpointName -Location $Location -Subnet  $subnet -PrivateLinkServiceConnection $privateEndpointConnection

Intégrer le point de terminaison privé à une zone DNS privée

Après avoir créé le point de terminaison privé, vous pouvez l’intégrer à une zone DNS privée à l’aide du script PowerShell suivant :

Import-Module Az.PrivateDns

# Zone name differs based on the API type and group ID you are using. 
$zoneName = "privatelink.documents.azure.com"
$zone = New-AzPrivateDnsZone -ResourceGroupName $ResourceGroupName `
  -Name $zoneName

$link  = New-AzPrivateDnsVirtualNetworkLink -ResourceGroupName $ResourceGroupName `
  -ZoneName $zoneName `
  -Name "myzonelink" `
  -VirtualNetworkId $virtualNetwork.Id  
 
$pe = Get-AzPrivateEndpoint -Name $PrivateEndpointName `
  -ResourceGroupName $ResourceGroupName

$networkInterface = Get-AzResource -ResourceId $pe.NetworkInterfaces[0].Id `
  -ApiVersion "2019-04-01"

# Create DNS configuration

$PrivateDnsZoneId = $zone.ResourceId

$config = New-AzPrivateDnsZoneConfig -Name $zoneName `
 -PrivateDnsZoneId $PrivateDnsZoneId

## Create a DNS zone group
New-AzPrivateDnsZoneGroup -ResourceGroupName $ResourceGroupName `
 -PrivateEndpointName $PrivateEndpointName `
 -Name "MyPrivateZoneGroup" `
 -PrivateDnsZoneConfig $config

Récupérer les adresses IP privées

Une fois le point de terminaison privé configuré, vous pouvez interroger les adresses IP et le mappage FQDNS à l’aide du script PowerShell suivant :

$pe = Get-AzPrivateEndpoint -Name MyPrivateEndpoint -ResourceGroupName myResourceGroup
$networkInterface = Get-AzNetworkInterface -ResourceId $pe.NetworkInterfaces[0].Id
foreach ($IPConfiguration in $networkInterface.IpConfigurations)
{
    Write-Host $IPConfiguration.PrivateIpAddress ":" $IPConfiguration.PrivateLinkConnectionProperties.Fqdns
}

Créer un point de terminaison privé à l’aide d’Azure CLI

Exécutez le script Azure CLI suivant pour créer un point de terminaison privé nommé myPrivateEndpoint pour un compte Azure Cosmos DB existant. Remplacez les valeurs des variables par les informations de votre environnement.

# Resource group where the Azure Cosmos DB account and virtual network resources are located
ResourceGroupName="myResourceGroup"

# Subscription ID where the Azure Cosmos DB account and virtual network resources are located
SubscriptionId="<your Azure subscription ID>"

# Name of the existing Azure Cosmos DB account
CosmosDbAccountName="mycosmosaccount"

# API type of your Azure Cosmos DB account: Sql, SqlDedicated, MongoDB, Cassandra, Gremlin, or Table
CosmosDbSubResourceType="Sql"

# Name of the virtual network to create
VNetName="myVnet"

# Name of the subnet to create
SubnetName="mySubnet"

# Name of the private endpoint to create
PrivateEndpointName="myPrivateEndpoint"

# Name of the private endpoint connection to create
PrivateConnectionName="myConnection"

az network vnet create \
 --name $VNetName \
 --resource-group $ResourceGroupName \
 --subnet-name $SubnetName

az network vnet subnet update \
 --name $SubnetName \
 --resource-group $ResourceGroupName \
 --vnet-name $VNetName \
 --disable-private-endpoint-network-policies true

az network private-endpoint create \
    --name $PrivateEndpointName \
    --resource-group $ResourceGroupName \
    --vnet-name $VNetName  \
    --subnet $SubnetName \
    --private-connection-resource-id "/subscriptions/$SubscriptionId/resourceGroups/$ResourceGroupName/providers/Microsoft.DocumentDB/databaseAccounts/$CosmosDbAccountName" \
    --group-ids $CosmosDbSubResourceType \
    --connection-name $PrivateConnectionName

Intégrer le point de terminaison privé à une zone DNS privée

Après avoir créé le point de terminaison privé, vous pouvez l’intégrer à une zone DNS privée à l’aide du script Azure CLI suivant :

#Zone name differs based on the API type and group ID you are using. 
zoneName="privatelink.documents.azure.com"

az network private-dns zone create --resource-group $ResourceGroupName \
   --name  $zoneName

az network private-dns link vnet create --resource-group $ResourceGroupName \
   --zone-name  $zoneName\
   --name myzonelink \
   --virtual-network $VNetName \
   --registration-enabled false 

#Create a DNS zone group
az network private-endpoint dns-zone-group create \
   --resource-group $ResourceGroupName \
   --endpoint-name $PrivateEndpointName \
   --name "MyPrivateZoneGroup" \
   --private-dns-zone $zoneName \
   --zone-name "myzone"

Créer un point de terminaison privé à l’aide d’un modèle Resource Manager

Vous pouvez configurer une Liaison privée (Private Link) en créant un point de terminaison privé dans un sous-réseau de réseau virtuel. Pour ce faire, utilisez un modèle Azure Resource Manager.

Utilisez le code suivant pour créer un modèle Resource Manager nommé PrivateEndpoint_template.json. Ce modèle crée un point de terminaison privé pour un compte vAPI Azure Cosmos DB for NoSQL existant dans un réseau virtuel existant.

Bicep

@description('Location for all resources.')
param location string = resourceGroup().location
param privateEndpointName string
param resourceId string
param groupId string
param subnetId string

resource privateEndpoint 'Microsoft.Network/privateEndpoints@2019-04-01' = {
  name: privateEndpointName
  location: location
  properties: {
    subnet: {
      id: subnetId
    }
    privateLinkServiceConnections: [
      {
        name: 'MyConnection'
        properties: {
          privateLinkServiceId: resourceId
          groupIds: [
            groupId
          ]
          requestMessage: ''
        }
      }
    ]
  }
}

output privateEndpointNetworkInterface string = privateEndpoint.properties.networkInterfaces[0].id

JSON

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "location": {
          "type": "string",
          "defaultValue": "[resourceGroup().location]",
          "metadata": {
            "description": "Location for all resources."
          }
        },
        "privateEndpointName": {
            "type": "string"
        },
        "resourceId": {
            "type": "string"
        },
        "groupId": {
            "type": "string"
        },
        "subnetId": {
            "type": "string"
        }
    },
    "resources": [
        {
            "name": "[parameters('privateEndpointName')]",
            "type": "Microsoft.Network/privateEndpoints",
            "apiVersion": "2019-04-01",
            "location": "[parameters('location')]",
            "properties": {
                "subnet": {
                    "id": "[parameters('subnetId')]"
                },
                "privateLinkServiceConnections": [
                    {
                        "name": "MyConnection",
                        "properties": {
                            "privateLinkServiceId": "[parameters('resourceId')]",
                            "groupIds": [ "[parameters('groupId')]" ],
                            "requestMessage": ""
                        }
                    }
                ]
            }
        }
    ],
    "outputs": {
        "privateEndpointNetworkInterface": {
          "type": "string",
          "value": "[reference(concat('Microsoft.Network/privateEndpoints/', parameters('privateEndpointName'))).networkInterfaces[0].id]"
        }
    }
}

Définir le fichier de paramètres pour le modèle

Créez un fichier de paramètres pour le modèle, puis nommez-le PrivateEndpoint_parameters.json. Ajoutez le code suivant au fichier de paramètres :

Bicep/JSON

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "privateEndpointName": {
            "value": ""
        },
        "resourceId": {
            "value": ""
        },
        "groupId": {
            "value": ""
        },
        "subnetId": {
            "value": ""
        }
    }
}

Déployer le modèle à l’aide d’un script PowerShell

Créez un script PowerShell en utilisant le code suivant. Avant d’exécuter le script, remplacez l’ID d’abonnement, le nom du groupe de ressources et d’autres valeurs de variables par les informations de votre environnement.

### This script creates a private endpoint for an existing Azure Cosmos DB account in an existing virtual network

## Step 1: Fill in these details. Replace the variable values with the details for your environment.
$SubscriptionId = "<your Azure subscription ID>"
# Resource group where the Azure Cosmos DB account and virtual network resources are located
$ResourceGroupName = "myResourceGroup"
# Name of the Azure Cosmos DB account
$CosmosDbAccountName = "mycosmosaccount"
# API type of the Azure Cosmos DB account. It can be one of the following: "Sql", "SqlDedicated", "MongoDB", "Cassandra", "Gremlin", "Table"
$CosmosDbSubResourceType = "Sql"
# Name of the existing virtual network
$VNetName = "myVnet"
# Name of the target subnet in the virtual network
$SubnetName = "mySubnet"
# Name of the private endpoint to create
$PrivateEndpointName = "myPrivateEndpoint"

$cosmosDbResourceId = "/subscriptions/$($SubscriptionId)/resourceGroups/$($ResourceGroupName)/providers/Microsoft.DocumentDB/databaseAccounts/$($CosmosDbAccountName)"
$VNetResourceId = "/subscriptions/$($SubscriptionId)/resourceGroups/$($ResourceGroupName)/providers/Microsoft.Network/virtualNetworks/$($VNetName)"
$SubnetResourceId = "$($VNetResourceId)/subnets/$($SubnetName)"
$PrivateEndpointTemplateFilePath = "PrivateEndpoint_template.json"
$PrivateEndpointParametersFilePath = "PrivateEndpoint_parameters.json"

## Step 2: Sign in to your Azure account and select the target subscription.
Login-AzAccount
Select-AzSubscription -SubscriptionId $subscriptionId

## Step 3: Make sure private endpoint network policies are disabled in the subnet.
$VirtualNetwork= Get-AzVirtualNetwork -Name "$VNetName" -ResourceGroupName "$ResourceGroupName"
($virtualNetwork | Select -ExpandProperty subnets | Where-Object  {$_.Name -eq "$SubnetName"} ).PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork | Set-AzVirtualNetwork

## Step 4: Create the private endpoint.
Write-Output "Deploying private endpoint on $($resourceGroupName)"
$deploymentOutput = New-AzResourceGroupDeployment -Name "PrivateCosmosDbEndpointDeployment" `
    -ResourceGroupName $resourceGroupName `
    -TemplateFile $PrivateEndpointTemplateFilePath `
    -TemplateParameterFile $PrivateEndpointParametersFilePath `
    -SubnetId $SubnetResourceId `
    -ResourceId $CosmosDbResourceId `
    -GroupId $CosmosDbSubResourceType `
    -PrivateEndpointName $PrivateEndpointName

$deploymentOutput

Dans le script PowerShell, la variable GroupId ne peut contenir qu’une seule valeur. Cette valeur est le type d’API du compte. Les valeurs autorisées sont Sql, SqlDedicated, MongoDB, Cassandra, Gremlin et Table. Certains types de comptes Azure Cosmos DB sont accessibles par le biais de plusieurs API. Par exemple :

• Le compte API pour NoSQL dispose d’une option supplémentaire pour les comptes configurés pour utiliser la passerelle dédiée.
• Le compte API pour Gremlin est accessible à partir de comptes Gremlin et API pour NoSQL.
• Le compte API pour Table est accessible à partir de comptes Table et API pour NoSQL.

Pour ces comptes, vous devez créer un point de terminaison privé pour chaque type d’API. Si vous créez un point de terminaison privé pour SqlDedicated, vous ne devez ajouter un deuxième point de terminaison pour Sql que si vous souhaitez également vous connecter à votre compte avec la passerelle standard. Le type d’API correspondant est spécifié dans le tableau GroupId.

Une fois que le modèle a bien été déployé, vous pouvez voir une sortie similaire à ce que montre l’image suivante. La valeur provisioningState est Succeeded si les points de terminaison privés sont configurés correctement.

Une fois le modèle déployé, les adresses IP privées sont réservées dans le sous-réseau. La règle de pare-feu du compte Azure Cosmos DB est configurée pour accepter uniquement les connexions à partir du point de terminaison privé.

Intégrer le point de terminaison privé à une zone DNS privée

Utilisez le code suivant pour créer un modèle Resource Manager nommé PrivateZone_template.json. Ce modèle crée une zone DNS privée pour un compte d’API Azure Cosmos DB for NoSQL existant dans un réseau virtuel existant.

{
    "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "privateZoneName": {
            "type": "string"
        },
        "VNetId": {
            "type": "string"
        }        
    },
    "resources": [
        {
            "name": "[parameters('privateZoneName')]",
            "type": "Microsoft.Network/privateDnsZones",
            "apiVersion": "2018-09-01",
            "location": "global",
            "properties": {                
            }
        },
        {
            "type": "Microsoft.Network/privateDnsZones/virtualNetworkLinks",
            "apiVersion": "2018-09-01",
            "name": "[concat(parameters('privateZoneName'), '/myvnetlink')]",
            "location": "global",
            "dependsOn": [
                "[resourceId('Microsoft.Network/privateDnsZones', parameters('privateZoneName'))]"
            ],
            "properties": {
                "registrationEnabled": false,
                "virtualNetwork": {
                    "id": "[parameters('VNetId')]"
                }
            }
        }        
    ]
}

Définir le fichier de paramètres pour le modèle

Créez les deux fichiers de paramètres suivants pour le modèle. Créez le fichier PrivateZone_parameters.json avec le code suivant :

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "privateZoneName": {
            "value": ""
        },
        "VNetId": {
            "value": ""
        }
    }
}

Utilisez le code suivant pour créer un modèle Resource Manager nommé PrivateZoneGroup_template.json. Ce modèle crée un groupe de zones DNS privées pour un compte d’API Azure Cosmos DB for NoSQL existant dans un réseau virtuel existant.

{
    "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "privateZoneName": {
            "type": "string"
        },
        "PrivateEndpointDnsGroupName": {
            "value": "string"
        },
        "privateEndpointName":{
            "value": "string"
        }        
    },
    "resources": [
        {
            "type": "Microsoft.Network/privateEndpoints/privateDnsZoneGroups",
            "apiVersion": "2020-06-01",
            "name": "[parameters('PrivateEndpointDnsGroupName')]",
            "location": "global",
            "dependsOn": [
                "[resourceId('Microsoft.Network/privateDnsZones', parameters('privateZoneName'))]",
                "[variables('privateEndpointName')]"
            ],
          "properties": {
            "privateDnsZoneConfigs": [
              {
                "name": "config1",
                "properties": {
                  "privateDnsZoneId": "[resourceId('Microsoft.Network/privateDnsZones', parameters('privateZoneName'))]"
                }
              }
            ]
          }
        }
    ]
}

Définir le fichier de paramètres pour le modèle

Créez les deux fichiers de paramètres suivants pour le modèle. Créez le modèle PrivateZoneGroup_parameters.json. par le code suivant :

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "privateZoneName": {
            "value": ""
        },
        "PrivateEndpointDnsGroupName": {
            "value": ""
        },
        "privateEndpointName":{
            "value": ""
        }
    }
}

Déployer le modèle à l’aide d’un script PowerShell

Créez un script PowerShell en utilisant le code suivant. Avant d’exécuter le script, remplacez l’ID d’abonnement, le nom du groupe de ressources et d’autres valeurs de variables par les informations de votre environnement.

### This script:
### - creates a private zone
### - creates a private endpoint for an existing Azure Cosmos DB account in an existing VNet
### - maps the private endpoint to the private zone

## Step 1: Fill in these details. Replace the variable values with the details for your environment.
$SubscriptionId = "<your Azure subscription ID>"
# Resource group where the Azure Cosmos DB account and virtual network resources are located
$ResourceGroupName = "myResourceGroup"
# Name of the Azure Cosmos DB account
$CosmosDbAccountName = "mycosmosaccount"
# API type of the Azure Cosmos DB account. It can be one of the following: "Sql", "SqlDedicated", "MongoDB", "Cassandra", "Gremlin", "Table"
$CosmosDbSubResourceType = "Sql"
# Name of the existing virtual network
$VNetName = "myVnet"
# Name of the target subnet in the virtual network
$SubnetName = "mySubnet"
# Name of the private zone to create
$PrivateZoneName = "myPrivateZone.documents.azure.com"
# Name of the private endpoint to create
$PrivateEndpointName = "myPrivateEndpoint"

# Name of the DNS zone group to create
$PrivateEndpointDnsGroupName = "myPrivateDNSZoneGroup"

$cosmosDbResourceId = "/subscriptions/$($SubscriptionId)/resourceGroups/$($ResourceGroupName)/providers/Microsoft.DocumentDB/databaseAccounts/$($CosmosDbAccountName)"
$VNetResourceId = "/subscriptions/$($SubscriptionId)/resourceGroups/$($ResourceGroupName)/providers/Microsoft.Network/virtualNetworks/$($VNetName)"
$SubnetResourceId = "$($VNetResourceId)/subnets/$($SubnetName)"
$PrivateZoneTemplateFilePath = "PrivateZone_template.json"
$PrivateZoneParametersFilePath = "PrivateZone_parameters.json"
$PrivateEndpointTemplateFilePath = "PrivateEndpoint_template.json"
$PrivateEndpointParametersFilePath = "PrivateEndpoint_parameters.json"
$PrivateZoneGroupTemplateFilePath = "PrivateZoneGroup_template.json"
$PrivateZoneGroupParametersFilePath = "PrivateZoneGroup_parameters.json"

## Step 2: Login your Azure account and select the target subscription
Login-AzAccount 
Select-AzSubscription -SubscriptionId $subscriptionId

## Step 3: Make sure private endpoint network policies are disabled in the subnet
$VirtualNetwork= Get-AzVirtualNetwork -Name "$VNetName" -ResourceGroupName "$ResourceGroupName"
($virtualNetwork | Select -ExpandProperty subnets | Where-Object  {$_.Name -eq "$SubnetName"} ).PrivateEndpointNetworkPolicies = "Disabled"
$virtualNetwork | Set-AzVirtualNetwork

## Step 4: Create the private zone
New-AzResourceGroupDeployment -Name "PrivateZoneDeployment" `
    -ResourceGroupName $ResourceGroupName `
    -TemplateFile $PrivateZoneTemplateFilePath `
    -TemplateParameterFile $PrivateZoneParametersFilePath `
    -PrivateZoneName $PrivateZoneName `
    -VNetId $VNetResourceId

## Step 5: Create the private endpoint
Write-Output "Deploying private endpoint on $($resourceGroupName)"
$deploymentOutput = New-AzResourceGroupDeployment -Name "PrivateCosmosDbEndpointDeployment" `
    -ResourceGroupName $resourceGroupName `
    -TemplateFile $PrivateEndpointTemplateFilePath `
    -TemplateParameterFile $PrivateEndpointParametersFilePath `
    -SubnetId $SubnetResourceId `
    -ResourceId $CosmosDbResourceId `
    -GroupId $CosmosDbSubResourceType `
    -PrivateEndpointName $PrivateEndpointName
$deploymentOutput

## Step 6: Create the private zone
New-AzResourceGroupDeployment -Name "PrivateZoneGroupDeployment" `
    -ResourceGroupName $ResourceGroupName `
    -TemplateFile $PrivateZoneGroupTemplateFilePath `
    -TemplateParameterFile $PrivateZoneGroupParametersFilePath `
    -PrivateZoneName $PrivateZoneName `
    -PrivateEndpointName $PrivateEndpointName`
    -PrivateEndpointDnsGroupName $PrivateEndpointDnsGroupName

Configurer un système DNS personnalisé

Vous devez utiliser une zone DNS privée dans le sous-réseau où vous avez créé le point de terminaison privé. Configurez les points de terminaison de façon à ce que chaque adresse IP privée soit mappée à une entrée DNS. Consultez la propriété fqdns dans la réponse indiquée plus haut.

Lorsque vous créez le point de terminaison privé, vous pouvez intégrer celui-ci à une zone DNS privée dans Azure. Si vous choisissez plutôt d’utiliser une zone DNS personnalisée, vous devez la configurer afin d’ajouter des enregistrements DNS pour toutes les adresses IP privées réservées au point de terminaison privé.

Important

Il s’agit de la résolution DNS de vos demandes qui détermine si ces requêtes passent par vos points de terminaison privés ou prennent l’itinéraire public standard. Assurez-vous que votre DNS local fait correctement référence au protocole IP privé adressé mappé par votre point de terminaison privé.

Private Link combiné à des règles de pare-feu

Les situations et résultats suivants sont possibles lorsque vous utilisez Private Link en association avec des règles de pare-feu :

• Si vous ne configurez pas de règles de pare-feu, par défaut, tout le trafic peut accéder à un compte Azure Cosmos DB.

• Si vous configurez un trafic public ou un point de terminaison de service et que vous créez des points de terminaison privés, différents types de trafic entrant sont alors autorisés par le type de règle de pare-feu correspondant. Si un point de terminaison privé est configuré dans un sous-réseau où le point de terminaison de service est également configuré :

  • le trafic vers le compte de base de données mappé par le point de terminaison privé est routé via un point de terminaison privé,
  • le trafic vers d’autres comptes de bases de données à partir du sous-réseau est routé via le point de terminaison de service.

• Si vous ne configurez aucun trafic public ni point de terminaison de service et que vous créez des points de terminaison privés, le compte Azure Cosmos DB est alors uniquement accessible via les points de terminaison privés. Si vous ne configurez aucun trafic public ni point de terminaison de service, après le rejet ou la suppression de tous les points de terminaison privés approuvés, le compte est ouvert sur l’ensemble du réseau à moins que PublicNetworkAccess soit défini sur Désactivé.

Blocage de l’accès au réseau public pendant la création du compte

Comme décrit dans la section précédente, et à moins que des règles de pare-feu spécifiques n’aient été définies, l’ajout d’un point de terminaison privé rend votre compte Azure Cosmos DB accessible via des points de terminaison privés uniquement. Cela signifie que le compte Azure Cosmos DB peut être atteint à partir du trafic public, après sa création et avant l’ajout d’un point de terminaison privé. Pour vous assurer que l’accès au réseau public est désactivé avant même la création de points de terminaison privés, vous pouvez définir l’indicateur publicNetworkAccess sur Désactivé pendant la création du compte. Notez que cet indicateur est prioritaire sur n’importe quelle adresse IP ou règle de réseau virtuel. Tout le trafic public et de réseau virtuel est bloqué lorsque l’indicateur est défini sur Désactivé, même si l’adresse IP source ou le réseau virtuel est autorisé dans la configuration du pare-feu.

Pour voir un exemple d’utilisation de cet indicateur, consultez ce modèle Azure Resource Manager.

Ajout de points de terminaison privés à un compte Cosmos DB existant sans temps d’arrêt

Par défaut, l’ajout d’un point de terminaison privé à un compte existant entraîne un court temps d’arrêt d’environ cinq minutes. Suivez les instructions ci-dessous pour éviter ce temps d’arrêt :

1. Ajoutez des règles de réseau virtuel ou d’adresse IP à votre configuration de pare-feu pour autoriser explicitement vos connexions client.
2. Attendez dix minutes pour vous assurer que la mise à jour de la configuration est appliquée.
3. Configurez votre nouveau point de terminaison privé.
4. Supprimez les règles de pare-feu définies à l’étape 1.

Notes

Si certaines de vos applications s’exécutent avec les SDK Azure Cosmos DB, la mise à jour de la configuration peut entraîner des expirations de délai d’attente temporaires. Vérifiez que votre application est conçue pour être résiliente aux échecs de connectivité temporaires et que vous avez une logique de nouvelle tentative en place si nécessaire.

Plage de ports lors de l’utilisation du mode direct

Lorsque vous utilisez Private Link avec un compte Azure Cosmos DB via une connexion en mode direct, vous devez vous assurer que la plage de ports TCP complète (0 à 65535) est ouverte.

Mettre à jour un point de terminaison privé lors de l’ajout ou de la suppression d’une région

Il existe trois régions pour les déploiements de comptes Azure Cosmos DB : USA Ouest, USA Centre et Europe Ouest. Lorsque vous créez un point de terminaison privé pour votre compte, quatre adresses IP privées sont réservées dans le sous-réseau. Il existe une adresse IP pour chacune des trois régions et une adresse IP pour le point de terminaison global indépendant de la région. Plus tard, vous pouvez ajouter une nouvelle région au compte Azure Cosmos DB. La zone DNS privée est mise à jour comme suit :

• Si le groupe de zones DNS privées est utilisé :

  Si vous utilisez un groupe de zones DNS privées, la zone DNS privée est automatiquement mise à jour lorsque le point de terminaison privé est mis à jour. Dans l’exemple précédent, après l’ajout d’une nouvelle région, la zone DNS privée est automatiquement mise à jour.

• Si le groupe de zones DNS privées n’est pas utilisé :

  Si vous n’utilisez pas de groupe de zones DNS privées, l’ajout ou la suppression de régions dans un compte Azure Cosmos DB vous oblige à ajouter ou supprimer des entrées DNS pour ce compte. Après l’ajout ou la suppression des régions, vous pouvez mettre à jour la zone DNS privée du sous-réseau pour refléter les entrées DNS ajoutées ou supprimées et leurs adresses IP privées correspondantes.

  Dans l’exemple précédent, après avoir ajouté la nouvelle région, vous devez ajouter un enregistrement DNS correspondant à votre zone DNS privée ou à votre DNS personnalisé. Vous pouvez utiliser les mêmes étapes lorsque vous supprimez une région. Après avoir supprimé la région, vous devez supprimer l’enregistrement DNS correspondant de votre zone DNS privée ou de votre DNS personnalisé.

Limites actuelles

Les limitations suivantes s’appliquent lorsque vous utilisez Private Link avec un compte Azure Cosmos DB :

• Vous ne pouvez pas avoir plus de 200 points de terminaison privés sur un seul compte Azure Cosmos DB.

• Lorsque vous utilisez Private Links avec un compte Azure Cosmos DB à travers une connexion en mode direct, vous ne pouvez utiliser que le protocole TCP. Le protocole HTTP n’est pas pris en charge actuellement.

• Lorsque vous utilisez l’API Azure Cosmos DB pour un compte MongoDB, un point de terminaison privé est pris en charge pour les comptes sur le serveur version 3.6 ou supérieure (c’est-à-dire les comptes utilisant le point de terminaison au format *.mongo.cosmos.azure.com). Private Link n’est pas pris en charge pour les comptes sur le serveur version 3.2 (c’est-à-dire les comptes utilisant le point de terminaison au format *.documents.azure.com). Pour utiliser Private Link, vous devez migrer les anciens comptes vers la nouvelle version.

• Quand vous utilisez un compte API Azure Cosmos DB pour MongoDB avec Private Link, les outils et les bibliothèques doivent prendre en charge l’identification du nom de service (SNI) ou transmettre le paramètre appName de la chaîne de connexion pour pouvoir se connecter correctement. Certains outils et bibliothèques plus anciens peuvent ne pas être compatibles avec la fonctionnalité Private Link.

• Un administrateur réseau doit disposer au moins de l’autorisation Microsoft.DocumentDB/databaseAccounts/PrivateEndpointConnectionsApproval/action dans l’étendue du compte Azure Cosmos DB pour créer des points de terminaison privés approuvés automatiquement.

• Pour l’instant, vous ne pouvez pas approuver une connexion de point de terminaison privée refusée. À la place, recréez le point de terminaison privé pour reprendre la connectivité privée. Le service de liaison privée Azure Cosmos DB approuve automatiquement le point de terminaison privé qui a été recréé.

Limitations de l’intégration à une zone DNS privée

À moins que vous n’utilisiez un groupe de zones DNS privées, les enregistrements DNS dans la zone DNS privée ne sont pas supprimés automatiquement lorsque vous supprimez un point de terminaison privé ou une région du compte Azure Cosmos DB. Vous devez supprimer manuellement les enregistrements DNS avant d’effectuer les actions suivantes :

• Ajout d’un nouveau point de terminaison privé lié à cette zone DNS privée.
• Ajout d’une nouvelle région à un compte de base de données qui dispose de points de terminaison privés liés à cette zone DNS privée.

Si vous ne nettoyez pas les enregistrements DNS, des problèmes de plan de données inattendus peuvent se produire. Ces problèmes incluent l’indisponibilité des données dans les régions ajoutées après la suppression du point de terminaison privé ou de la région.

Étapes suivantes

Pour en savoir plus sur les fonctionnalités de sécurité d’Azure Cosmos DB, consultez l’article suivant :

• Pour configurer un pare-feu pour Azure Cosmos DB, consultez Prise en charge du pare-feu.

• Pour découvrir comment configurer un point de terminaison de service de réseau virtuel pour votre compte Azure Cosmos DB, consultez Configurer l’accès à partir de réseaux virtuels.

• Pour en savoir plus sur Liaison privée (Private Link), consultez la documentation Azure Private Link.