Comment configurer un réseau managé pour Microsoft hubs Foundry (classique)

• Un abonnement Azure. Si vous n'avez pas d'abonnement Azure, créez un compte gratuit avant de commencer.

• Inscrivez le fournisseur de ressources Microsoft.Network pour votre abonnement Azure. Le hub utilise ce fournisseur pour créer des points de terminaison privés pour le réseau virtuel managé.

  Pour plus d’informations sur l’inscription des fournisseurs de ressources, consultez Résoudre les erreurs d’inscription du fournisseur de ressources.

• Utilisez une identité Azure avec les actions suivantes Azure contrôle d’accès en fonction du rôle (Azure RBAC) pour créer des points de terminaison privés pour le réseau virtuel managé :

  • Microsoft.MachineLearningServices/workspaces/privateEndpointConnections/read
  • Microsoft.MachineLearningServices/workspaces/privateEndpointConnections/write

  Conseil

  L’approbateur de connexion Azure AI Enterprise Network Connection Appr inclut ces autorisations. Attribuez ce rôle à l’identité managée du hub pour approuver les connexions de point de terminaison privé.

• Un abonnement Azure. Si vous n'avez pas d'abonnement Azure, créez un compte gratuit avant de commencer.

• Le fournisseur de ressources Microsoft.Network doit être enregistré dans votre abonnement Azure. Le hub utilise ce fournisseur de ressources lors de la création de points de terminaison privés pour le réseau virtuel managé.

  Pour plus d’informations sur l’inscription des fournisseurs de ressources, consultez Résoudre les erreurs d’inscription du fournisseur de ressources.

• Utilisez une identité Azure avec les actions suivantes Azure contrôle d’accès en fonction du rôle (Azure RBAC) pour créer des points de terminaison privés pour le réseau virtuel managé :

  • Microsoft. MachineLearningServices/workspaces/privateEndpointConnections/read
  • Microsoft. MachineLearningServices/workspaces/privateEndpointConnections/write

  Conseil

  L'approbateur de connexion Azure AI Enterprise Network Connection Approver inclut ces autorisations. Attribuez ce rôle à l’identité managée du hub pour approuver les connexions de point de terminaison privé.

• Installez la Azure CLI et l’extension ml pour le Azure CLI. Pour plus d’informations, consultez Installer, configurer et utiliser l’interface CLI (v2).

• Un interpréteur de commandes compatible Bash pour l’exécution des exemples CLI dans cet article. Par exemple, utilisez un système Linux ou Sous-système Windows pour Linux.

• Les exemples Azure CLI de cet article utilisent ws pour le nom du hub et rg pour le nom du groupe de ressources. Modifiez ces valeurs si nécessaire lorsque vous exécutez les commandes dans votre abonnement Azure.

• Un abonnement Azure. Si vous n'avez pas d'abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante.

• Le fournisseur de ressources Microsoft.Network doit être enregistré sur votre abonnement Azure. Le hub utilise ce fournisseur de ressources lors de la création de points de terminaison privés pour le réseau virtuel managé.

  Pour plus d’informations sur l’inscription des fournisseurs de ressources, consultez Résoudre les erreurs d’inscription du fournisseur de ressources.

• L’identité Azure que vous utilisez lors du déploiement d’un réseau managé nécessite les actions suivantes Azure contrôle d’accès en fonction du rôle (Azure RBAC) pour créer des points de terminaison privés :

  • Microsoft. MachineLearningServices/workspaces/privateEndpointConnections/read
  • Microsoft. MachineLearningServices/workspaces/privateEndpointConnections/write

  Conseil

  L'approbateur de la connexion du réseau d'entreprise Azure AI inclut ces autorisations. Attribuez ce rôle à l’identité managée du hub pour approuver les connexions de point de terminaison privé.

• Kit de développement logiciel (SDK) Azure Machine Learning Python v2. Pour plus d’informations sur le Kit de développement logiciel (SDK), consultez Installer le sdk Python v2 pour Azure Machine Learning.

• Les exemples de cet article supposent que votre code commence par le code Python suivant. Il importe les classes requises pour créer un hub avec un réseau virtuel managé, définit des variables pour votre abonnement et groupe de ressources Azure, puis crée le ml_client. Dans l’exemple suivant, remplacez le texte <SUBSCRIPTION_ID> de l’espace réservé et <RESOURCE_GROUP> par vos propres valeurs :

  from azure.ai.ml import MLClient
  from azure.ai.ml.entities import (
      Hub,
      ManagedNetwork,
      IsolationMode,
      ServiceTagDestination,
      PrivateEndpointDestination,
      FqdnDestination
  )
  from azure.identity import DefaultAzureCredential
  
  # Replace with the values for your Azure subscription and resource group.
  subscription_id = "<SUBSCRIPTION_ID>"
  resource_group = "<RESOURCE_GROUP>"
  
  # get a handle to the subscription
  ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group)
  

• Créez un hub :

  1. Connectez-vous au portail Azure, puis sélectionnez Foundry dans le menu Create a resource.

  2. Sélectionnez + Nouveau IA Azure.

  3. Entrez les informations requises sous l’onglet Informations de base .

  4. Sous l’onglet Mise en réseau , sélectionnez Privé avec Internet Sortant.

  5. Pour ajouter une règle de trafic sortant, sélectionnez Ajouter des règles sortantes définies par l’utilisateur à partir de l’onglet Mise en réseau . Dans la barre latérale des règles de trafic sortant , entrez les informations suivantes :

     • Nom de la règle : nom de la règle. Le nom doit être unique pour ce hub.
     • Type de destination : le point de terminaison privé est la seule option lorsque l’isolation réseau est privée avec Internet Sortant. Un réseau virtuel géré par hub ne prend pas en charge la création de points de terminaison privés pour tous les types de ressources Azure. Pour obtenir la liste des ressources prises en charge, consultez la section Points de terminaison privés .
     • Subscription : abonnement qui contient la ressource Azure pour laquelle vous souhaitez ajouter un point de terminaison privé.
     • Resource group : groupe de ressources contenant la ressource Azure pour laquelle vous souhaitez ajouter un point de terminaison privé.
     • Resource type : type de la ressource Azure.
     • Resource name : nom de la ressource Azure.
     • Sub Resource : sous-ressource du type de ressource Azure.

     Sélectionnez Enregistrer. Pour ajouter d’autres règles, sélectionnez Ajouter des règles sortantes définies par l’utilisateur.

  6. Continuez à créer le hub.

• Mettez à jour un hub existant :

  1. Connectez-vous au portail Azure, puis sélectionnez le hub pour activer l’isolation du réseau virtuel managé.

  2. Sélectionnez Réseautage>Privé avec trafic Internet sortant.

     • Pour ajouter une règle de trafic sortant, sélectionnez Ajouter des règles sortantes définies par l’utilisateur à partir de l’onglet Mise en réseau . Dans la barre latérale des règles de trafic sortant , fournissez les mêmes informations que celles utilisées lors de la création d’un hub dans la section « Créer un hub ».

     • Pour supprimer une règle de trafic sortant, sélectionnez Supprimer pour la règle.

  3. Sélectionnez Enregistrer en haut de la page pour appliquer les modifications au réseau virtuel managé.

Pour configurer un réseau virtuel managé qui autorise le trafic sortant Internet, utilisez le --managed-network allow_internet_outbound paramètre ou un fichier de configuration YAML avec les entrées suivantes :

managed_network:
  isolation_mode: allow_internet_outbound

Définissez règles de trafic sortant à d’autres services Azure sur lesquels le hub s’appuie. Ces règles définissent des points de terminaison private qui permettent à une ressource Azure de communiquer en toute sécurité avec le réseau virtuel managé. La règle suivante montre comment ajouter un point de terminaison privé à un compte Stockage Blob Azure. Dans l’exemple suivant, remplacez le texte <SUBSCRIPTION_ID>de l’espace réservé, <RESOURCE_GROUP>et <STORAGE_ACCOUNT_NAME> par vos propres valeurs.

managed_network:
  isolation_mode: allow_internet_outbound
  outbound_rules:
  - name: added-perule
    destination:
      service_resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>
      spark_enabled: true
      subresource_target: blob
    type: private_endpoint

Configurez un réseau virtuel managé en utilisant soit la commande az ml workspace create soit la commande az ml workspace update.

• Créez un hub :

  L’exemple suivant crée un hub. Le --managed-network allow_internet_outbound paramètre configure un réseau virtuel managé pour le hub :

  az ml workspace create --name ws --resource-group rg --kind hub --managed-network allow_internet_outbound
  

  Pour créer un hub à l’aide d’un fichier YAML, utilisez le --file paramètre et spécifiez le fichier YAML qui contient les paramètres de configuration :

  az ml workspace create --file hub.yaml --resource-group rg --name ws --kind hub
  

  L’exemple YAML suivant définit un hub avec un réseau virtuel managé :

  name: myhub
  location: EastUS
  managed_network:
    isolation_mode: allow_internet_outbound
  

• Mettez à jour un hub existant :

  Avertissement

  Avant de mettre à jour un espace de travail existant pour utiliser un réseau virtuel managé, vous devez supprimer toutes les ressources informatiques de l’espace de travail. Cela inclut l’instance de calcul, le cluster de calcul et les points de terminaison en ligne gérés.

  L’exemple suivant met à jour un hub existant. Le --managed-network allow_internet_outbound paramètre configure un réseau virtuel managé pour le hub :

  az ml workspace update --name ws --resource-group rg --kind hub --managed-network allow_internet_outbound
  

  Pour mettre à jour un hub existant à l’aide d’un fichier YAML, utilisez le --file paramètre et spécifiez le fichier YAML qui contient les paramètres de configuration :

  az ml workspace update --file hub.yaml --name ws --kind hub --resource-group MyGroup
  

  L’exemple YAML suivant définit un réseau virtuel managé pour le hub. Il montre également comment ajouter une connexion de point de terminaison privé à une ressource utilisée par le hub. Dans cet exemple, il ajoute un point de terminaison privé pour un compte Stockage Blob Azure. Dans l’exemple suivant, remplacez le texte <SUBSCRIPTION_ID>de l’espace réservé, <RESOURCE_GROUP>et <STORAGE_ACCOUNT_NAME> par vos propres valeurs :

  name: myhub
  managed_network:
    isolation_mode: allow_internet_outbound
    outbound_rules:
    - name: added-perule
      destination:
        service_resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>
        spark_enabled: true
        subresource_target: blob
      type: private_endpoint
  

Références

• az ml workspace create
• az ml workspace update

Pour configurer un réseau virtuel managé qui autorise le trafic sortant Internet, utilisez la ManagedNetwork classe avec IsolationMode.ALLOW_INTERNET_OUTBOUND. Utilisez ensuite l’objet ManagedNetwork pour créer un hub ou mettre à jour un hub existant. Pour définir règles de trafic sortant pour Azure services sur lesquels le hub s’appuie, utilisez la classe PrivateEndpointDestination pour définir un nouveau point de terminaison privé au service.

• Créez un hub :

  L’exemple suivant crée un hub nommé myhub, avec une règle sortante nommée myrule qui ajoute un point de terminaison privé pour un compte Stockage Blob Azure. Dans l’exemple suivant, remplacez le texte <SUBSCRIPTION_ID>de l’espace réservé, <RESOURCE_GROUP>et <STORAGE_ACCOUNT_NAME> par vos propres valeurs :

  from azure.ai.ml.entities import ManagedNetwork, IsolationMode, Hub, PrivateEndpointDestination
  
  # Basic managed VNet configuration
  network = ManagedNetwork(isolation_mode=IsolationMode.ALLOW_INTERNET_OUTBOUND)
  
  # Hub configuration
  ws = Hub(
      name="myhub",
      location="eastus",
      managed_network=network
  )
  
  # Example private endpoint to Azure Blob Storage
  rule_name = "myrule"
  service_resource_id = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>"
  subresource_target = "blob"
  spark_enabled = True
  
  # Add the outbound rule
  ws.managed_network.outbound_rules = [PrivateEndpointDestination(
      name=rule_name, 
      service_resource_id=service_resource_id, 
      subresource_target=subresource_target, 
      spark_enabled=spark_enabled)]
  
  # Create the hub
  ws = ml_client.workspaces.begin_create(ws).result()
  

  Références

  • ManagedNetwork
  • IsolationMode
  • Hub
  • PrivateEndpointDestination

• Mettez à jour un hub existant :

  L’exemple suivant montre comment créer un réseau virtuel managé pour un hub existant nommé myhub:

  from azure.ai.ml import MLClient
  from azure.identity import DefaultAzureCredential
  from azure.ai.ml.entities import ManagedNetwork, IsolationMode, PrivateEndpointDestination
  
  # Get the existing hub
  ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, "myhub")
  ws = ml_client.workspaces.get(name="myhub")
  
  # Basic managed VNet configuration
  ws.managed_network = ManagedNetwork(isolation_mode=IsolationMode.ALLOW_INTERNET_OUTBOUND)
  
  # Example private endpoint outbound to a blob
  rule_name = "myrule"
  service_resource_id = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>"
  subresource_target = "blob"
  spark_enabled = True
  
  # Add the outbound rule
  ws.managed_network.outbound_rules = [PrivateEndpointDestination(
      name=rule_name, 
      service_resource_id=service_resource_id, 
      subresource_target=subresource_target, 
      spark_enabled=spark_enabled)]
  
  # Update the hub
  ml_client.workspaces.begin_update(ws)
  

  Références

  • ManagedNetwork
  • IsolationMode
  • PrivateEndpointDestination
  • MLClient

• Créez un hub :

  1. Connectez-vous au portail Azure et choisissez Foundry dans le menu Créer une ressource.

  2. Sélectionnez + Nouvelle IA Azure.

  3. Fournissez les informations requises sous l’onglet Informations de base .

  4. Sous l’onglet Mise en réseau , sélectionnez Privé avec trafic sortant approuvé.

  5. Pour ajouter une règle de trafic sortant, sélectionnez Ajouter des règles sortantes définies par l’utilisateur à partir de l’onglet Mise en réseau . Dans la barre latérale des règles de trafic sortant , fournissez les informations suivantes :

     • Nom de la règle : nom de la règle. Le nom doit être unique pour ce hub.
     • Type de destination : point de terminaison privé, balise de service ou nom de domaine complet. L’étiquette de service et le nom de domaine complet (FQDN) ne sont disponibles que lorsque l’isolation réseau est privée avec le trafic sortant autorisé.

     Si le type de destination est Private Endpoint, entrez les informations suivantes :

     • Subscription : abonnement qui contient la ressource Azure pour laquelle vous souhaitez ajouter un point de terminaison privé.
     • Resource group : groupe de ressources contenant la ressource Azure pour laquelle vous souhaitez ajouter un point de terminaison privé.
     • Resource type : type de la ressource Azure.
     • Resource name : nom de la ressource Azure.
  • Sub Resource : sous-ressource du type de ressource Azure.

  Conseil

  Le réseau virtuel managé du hub ne prend pas en charge les points de terminaison privés pour tous les types de ressources Azure. Pour obtenir la liste des ressources prises en charge, consultez la section Points de terminaison privés .

  Si le type de destination est Une balise de service, entrez les informations suivantes :

  • Étiquette de service : L'étiquette de service à ajouter aux règles de trafic sortant approuvées.
  • Protocole : protocole permettant l’étiquette de service.
  • Plages de ports : plages de ports à autoriser pour la balise de service.

  Si le type de destination est FQDN, entrez les informations suivantes :

  • FQDN de destination: Le nom de domaine complet à ajouter aux règles de trafic sortant approuvées.

    Sélectionnez Enregistrer pour enregistrer la règle. Pour ajouter d’autres règles, sélectionnez à nouveau ajouter des règles sortantes définies par l’utilisateur .

  1. Continuez à créer le hub comme d’habitude.

• Mettez à jour un hub existant :

  1. Connectez-vous au portail Azure et sélectionnez le hub pour lequel vous souhaitez activer l’isolation du réseau virtuel managé.

  2. Sélectionnez Réseau>privé avec trafic sortant approuvé.

     • Pour ajouter une règle de trafic sortant, sélectionnez Ajouter des règles sortantes définies par l’utilisateur à partir de l’onglet Mise en réseau . Dans la barre latérale des règles de trafic sortant , entrez les mêmes informations que lors de la création d’un hub dans la section précédente « Créer un hub ».

     • Pour supprimer une règle de trafic sortant, sélectionnez Supprimer pour la règle.

  3. Sélectionnez Enregistrer en haut de la page pour enregistrer les modifications apportées au réseau virtuel managé.

Pour configurer un réseau virtuel managé qui autorise uniquement les communications sortantes approuvées, utilisez le --managed-network allow_only_approved_outbound paramètre ou un fichier de configuration YAML qui contient les entrées suivantes :

managed_network:
  isolation_mode: allow_only_approved_outbound

Vous pouvez également définir des règles de trafic sortant pour la communication sortante approuvée. Créez une règle sortante de type service_tag, fqdn, ou private_endpoint. L’exemple suivant ajoute un point de terminaison privé à une ressource Blob Azure, une balise de service pour Azure Data Factory et un nom de domaine complet pour pypi.org. Dans l’exemple suivant, remplacez le texte <SUBSCRIPTION_ID>de l’espace réservé, <RESOURCE_GROUP>et <STORAGE_ACCOUNT_NAME> par vos valeurs.

managed_network:
  isolation_mode: allow_only_approved_outbound
  outbound_rules:
  - name: added-servicetagrule
    destination:
      port_ranges: 80, 8080
      protocol: TCP
      service_tag: DataFactory
    type: service_tag
  - name: add-fqdnrule
    destination: 'pypi.org'
    type: fqdn
  - name: added-perule
    destination:
      service_resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>
      spark_enabled: true
      subresource_target: blob
    type: private_endpoint

Vous pouvez configurer un réseau virtuel géré à l’aide des commandes az ml workspace create ou az ml workspace update.

• Créez un hub :

  L’exemple suivant utilise le --managed-network allow_only_approved_outbound paramètre pour configurer le réseau virtuel managé :

  az ml workspace create --name ws --resource-group rg --kind hub --managed-network allow_only_approved_outbound
  

  Le fichier YAML suivant définit un hub avec un réseau virtuel managé :

  name: myhub
  location: EastUS
  managed_network:
    isolation_mode: allow_only_approved_outbound
  

  Pour créer un hub à l’aide du fichier YAML, utilisez le --file paramètre :

  az ml workspace create --file hub.yaml --resource-group rg --name ws --kind hub
  

• Mettre à jour un hub existant

  Avertissement

  Avant de mettre à jour un espace de travail existant pour utiliser un réseau virtuel managé, vous devez supprimer toutes les ressources informatiques de l’espace de travail. Cela inclut l’instance de calcul, le cluster de calcul et les points de terminaison en ligne gérés.

  L’exemple suivant utilise le --managed-network allow_only_approved_outbound paramètre pour configurer le réseau virtuel managé pour un hub existant :

  az ml workspace update --name ws --resource-group rg --kind hub --managed-network allow_only_approved_outbound
  

  Le fichier YAML suivant définit un réseau virtuel managé pour le hub et montre comment ajouter des règles de trafic sortant approuvées. Dans cet exemple, les règles de trafic sortant sont ajoutées pour une balise de service, un nom de domaine complet et un point de terminaison privé :

  name: myhub_dep
  managed_network:
    isolation_mode: allow_only_approved_outbound
    outbound_rules:
    - name: added-servicetagrule
      destination:
        port_ranges: 80, 8080
        protocol: TCP
        service_tag: DataFactory
      type: service_tag
    - name: add-fqdnrule
      destination: 'pypi.org'
      type: fqdn
    - name: added-perule
      destination:
        service_resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>
        spark_enabled: true
        subresource_target: blob
      type: private_endpoint
  

Références

• az ml workspace create
• az ml workspace update

Pour configurer un réseau virtuel managé qui autorise uniquement les communications sortantes approuvées, utilisez la ManagedNetwork classe pour définir un réseau avec IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND. Utilisez l’objet ManagedNetwork pour créer un hub ou mettre à jour un hub existant. Pour définir des règles de trafic sortant, utilisez les classes suivantes :

• Créez un hub :

  L’exemple suivant crée un hub nommé myhub, avec plusieurs règles de trafic sortant :

  • myrule - ajoute un point de terminaison privé pour un compte de stockage Azure Blob.
  • datafactory : ajoute une règle d’étiquette de service pour communiquer avec Azure Data Factory.

  Important

  • Ajoutez une règle de trafic sortant pour une balise de service ou un nom de domaine complet uniquement lorsque vous configurez le réseau virtuel managé sur IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND.
  • Si vous ajoutez des règles de trafic sortant, Microsoft ne pouvez pas garantir la protection contre l'exfiltration des données.

  from azure.ai.ml.entities import ManagedNetwork, IsolationMode, Hub, PrivateEndpointDestination, ServiceTagDestination, FqdnDestination
  
  # Basic managed VNet configuration
  network = ManagedNetwork(isolation_mode=IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND)
  
  # Hub configuration
  ws = Hub(
      name="myhub",
      location="eastus",
      managed_network=network
  )
  
  # Append some rules
  ws.managed_network.outbound_rules = []
  # Example private endpoint outbound to a blob
  rule_name = "myrule"
  service_resource_id = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>"
  subresource_target = "blob"
  spark_enabled = True
  ws.managed_network.outbound_rules.append(
      PrivateEndpointDestination(
          name=rule_name, 
          service_resource_id=service_resource_id, 
          subresource_target=subresource_target, 
          spark_enabled=spark_enabled
      )
  )
  
  # Example service tag rule
  rule_name = "datafactory"
  service_tag = "DataFactory"
  protocol = "TCP"
  port_ranges = "80, 8080-8089"
  ws.managed_network.outbound_rules.append(
      ServiceTagDestination(
          name=rule_name, 
          service_tag=service_tag, 
          protocol=protocol, 
          port_ranges=port_ranges
      )
  )
  
  # Example FQDN rule
  ws.managed_network.outbound_rules.append(
      FqdnDestination(
          name="fqdnrule", 
          destination="pypi.org"
      )
  )
  
  # Create the hub
  ws = ml_client.workspaces.begin_create(ws).result()
  

  Références

  • ManagedNetwork
  • IsolationMode
  • Hub
  • PrivateEndpointDestination
  • ServiceTagDestination
  • FqdnDestination

• Mettez à jour un hub existant :

  L’exemple suivant montre comment configurer un réseau virtuel managé pour un hub existant nommé myhub. Il ajoute également plusieurs règles sortantes :

  • myrule : ajoute un point de terminaison privé pour un stockage Blob Azure.
  • datafactory : ajoute une règle d’étiquette de service pour communiquer avec Azure Data Factory.

  Conseil

  Vous pouvez ajouter une règle de trafic sortant pour une balise de service ou un nom de domaine complet uniquement lorsque vous configurez le réseau virtuel géré pour utiliser IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND.

  from azure.ai.ml import MLClient
  from azure.identity import DefaultAzureCredential
  from azure.ai.ml.entities import ManagedNetwork, IsolationMode, PrivateEndpointDestination, ServiceTagDestination, FqdnDestination
  
  # Get the existing hub
  ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, "myhub")
  ws = ml_client.workspaces.get()
  
  # Basic managed VNet configuration
  ws.managed_network = ManagedNetwork(isolation_mode=IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND)
  
  # Append some rules
  ws.managed_network.outbound_rules = []
  # Example private endpoint outbound to a blob
  rule_name = "myrule"
  service_resource_id = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Storage/storageAccounts/<STORAGE_ACCOUNT_NAME>"
  subresource_target = "blob"
  spark_enabled = True
  ws.managed_network.outbound_rules.append(
      PrivateEndpointDestination(
          name=rule_name, 
          service_resource_id=service_resource_id, 
          subresource_target=subresource_target, 
          spark_enabled=spark_enabled
      )
  )
  
  # Example service tag rule
  rule_name = "datafactory"
  service_tag = "DataFactory"
  protocol = "TCP"
  port_ranges = "80, 8080-8089"
  ws.managed_network.outbound_rules.append(
      ServiceTagDestination(
          name=rule_name, 
          service_tag=service_tag, 
          protocol=protocol, 
          port_ranges=port_ranges
      )
  )
  
  # Example FQDN rule
  ws.managed_network.outbound_rules.append(
      FqdnDestination(
          name="fqdnrule", 
          destination="pypi.org"
      )
  )
  
  # Update the hub
  ml_client.workspaces.begin_update(ws)
  

  Références

  • ManagedNetwork
  • IsolationMode
  • PrivateEndpointDestination
  • ServiceTagDestination
  • FqdnDestination
  • MLClient

Lors de la création de l’espace de travail, sélectionnez Provisionner un réseau managé de manière proactive lors de la création pour configurer le réseau managé. La facturation démarre pour les ressources réseau, telles que les points de terminaison privés, une fois le réseau virtuel configuré. Cette option est disponible uniquement lors de la création de l’espace de travail.

L’exemple suivant montre comment provisionner un réseau virtuel managé lors de la création du hub.

az ml workspace create -n my_ai_hub_name -g my_resource_group --kind hub --managed-network AllowInternetOutbound --provision-network-now true

L’exemple suivant montre comment provisionner un réseau virtuel managé.

az ml workspace provision-network -g my_resource_group -n my_ai_hub_name

Pour vérifier que l’approvisionnement est terminé, exécutez la commande suivante :

az ml workspace show -n my_ai_hub_name -g my_resource_group --query managed_network

Références

• az ml workspace create
• az ml workspace provision-network
• az ml workspace show

Utilisez le Kit de développement logiciel (SDK) pour provisionner un réseau virtuel managé, puis vérifiez son état.

from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient

subscription_id = "00000000-0000-0000-0000-000000000000"
resource_group = "my_resource_group"
workspace_name = "my_ai_hub_name"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace_name=workspace_name)

# Start provisioning the managed network for the workspace.
provision_result = ml_client.workspaces.begin_provision_network(workspace_name=workspace_name).result()

# Check the managed network status.
ws = ml_client.workspaces.get(name=workspace_name)
print(ws.managed_network.status)

Références

• MLClient
• begin_provision_network

1. Connectez-vous au portail Azure et sélectionnez le hub pour lequel vous souhaitez activer l’isolation du réseau virtuel managé.
2. Sélectionnez Mise en réseau. La section Accès sortant Foundry vous permet de gérer les règles de trafic sortant.

• Pour ajouter une règle de trafic sortant, sélectionnez Règles sortantes définies par l’utilisateur sous l’onglet Networking. À partir de la Azure règles de trafic sortant IA, entrez les valeurs requises.

• Pour activer ou désactiver une règle, utilisez le bouton bascule dans la colonne Active .

• Pour supprimer une règle de trafic sortant, sélectionnez Supprimer pour la règle.

Dans les commandes suivantes, remplacez le texte <workspace-name>de l’espace réservé, <resource-group>et <rule-name> par vos valeurs. Pour répertorier les règles de trafic sortant de réseau virtuel managé pour un hub, exécutez :

az ml workspace outbound-rule list --workspace-name <workspace-name> --resource-group <resource-group>

Pour afficher les détails d’une règle de trafic sortant de réseau virtuel managé, exécutez :

az ml workspace outbound-rule show --rule <rule-name> --workspace-name <workspace-name> --resource-group <resource-group>

Pour supprimer une règle de trafic sortant du réseau virtuel managé, exécutez :

az ml workspace outbound-rule remove --rule <rule-name> --workspace-name <workspace-name> --resource-group <resource-group>

Références

• La commande az ml workspace outbound-rule list est utilisée pour lister les règles de sortie dans un espace de travail Azure Machine Learning.
• Afficher la règle sortante de l'espace de travail avec az ml workspace outbound-rule show
• az ml workspace outbound-rule remove - Commande pour supprimer une règle sortante du workspace Azure Machine Learning

L’exemple suivant montre comment gérer les règles de trafic sortant pour un hub nommé myhub. Dans l’exemple, remplacez le texte <some-rule-name> de l’espace réservé par le nom de votre règle :

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# Connect to the hub
ws_name = "myhub"
ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace_name=ws_name)

# Specify the rule name
rule_name = "<some-rule-name>"

# Get a rule by name
rule = ml_client._workspace_outbound_rules.get(resource_group, ws_name, rule_name)

# List rules for a hub
rule_list = ml_client._workspace_outbound_rules.list(resource_group, ws_name)

# Delete a rule from a hub
ml_client._workspace_outbound_rules.begin_remove(resource_group, ws_name, rule_name).result()

Références

• MLClient

Après avoir sélectionné le mode autoriser uniquement les flux sortants approuvés, l’option permettant de sélectionner la version (SKU) d'Pare-feu Azure s’affiche. Sélectionnez Standard ou De base. Sélectionnez Enregistrer.

Pour définir la version du pare-feu à l’aide de Azure CLI, utilisez un fichier YAML et spécifiez firewall_sku. L’exemple suivant définit la référence SKU du pare-feu sur basic:

name: test-ws
resource_group: test-rg
location: eastus2 
managed_network:
  isolation_mode: allow_only_approved_outbound
  outbound_rules:
  - category: required
    destination: 'contoso.com'
    name: contosofqdn
    type: fqdn
  firewall_sku: basic
tags: {}

Pour définir la version du pare-feu à l’aide du SDK Python, définissez la propriété firewall_sku de l’objet ManagedNetwork. L’exemple suivant définit la référence SKU du pare-feu sur basic:

from azure.ai.ml.entities import ManagedNetwork, IsolationMode

network = ManagedNetwork(isolation_mode=IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND,
                         firewall_sku='basic')

Références

• ManagedNetwork
• IsolationMode