How to configure a managed network for Azure AI Foundry hubs

We have two network isolation aspects. One is the network isolation to access an Azure AI Foundry hub. Another is the network isolation of computing resources for both your hub and project (such as compute instance, serverless and managed online endpoint.) This document explains the latter highlighted in the diagram. You can use hub built-in network isolation to protect your computing resources.

You need to configure following network isolation configurations.

• Choose network isolation mode. You have two options: allow internet outbound mode or allow only approved outbound mode.
• If you use Visual Studio Code integration with allow only approved outbound mode, create FQDN outbound rules described in the use Visual Studio Code section.
• If you use HuggingFace models in Models with allow only approved outbound mode, create FQDN outbound rules described in the use HuggingFace models section.
• If you use one of the open-source models with allow only approved outbound mode, create FQDN outbound rules described in the curated by Azure AI section.

Network isolation architecture and isolation modes

When you enable managed virtual network isolation, a managed virtual network is created for the hub. Managed compute resources you create for the hub automatically use this managed virtual network. The managed virtual network can use private endpoints for Azure resources that are used by your hub, such as Azure Storage, Azure Key Vault, and Azure Container Registry.

There are three different configuration modes for outbound traffic from the managed virtual network:

Outbound mode	Description	Scenarios
Allow internet outbound	Allow all internet outbound traffic from the managed virtual network.	You want unrestricted access to machine learning resources on the internet, such as python packages or pretrained models.1
Allow only approved outbound	Outbound traffic is allowed by specifying service tags.	* You want to minimize the risk of data exfiltration, but you need to prepare all required machine learning artifacts in your private environment. * You want to configure outbound access to an approved list of services, service tags, or FQDNs.
Disabled	Inbound and outbound traffic isn't restricted.	You want public inbound and outbound from the hub.

¹ You can use outbound rules with allow only approved outbound mode to achieve the same result as using allow internet outbound. The differences are:

• Always use private endpoints to access Azure resources.
• You must add rules for each outbound connection you need to allow.
• Adding FQDN outbound rules increase your costs as this rule type uses Azure Firewall. If you use outbound FQDN rules, charges for Azure Firewall are included in your billing. For more information, see Pricing.
• The default rules for allow only approved outbound are designed to minimize the risk of data exfiltration. Any outbound rules you add might increase your risk.

The managed virtual network is preconfigured with required default rules. It's also configured for private endpoint connections to your hub, the hub's default storage, container registry, and key vault if they're configured as private or the hub isolation mode is set to allow only approved outbound. After choosing the isolation mode, you only need to consider other outbound requirements you might need to add.

The following diagram shows a managed virtual network configured to allow internet outbound:

The following diagram shows a managed virtual network configured to allow only approved outbound:

Note

In this configuration, the storage, key vault, and container registry used by the hub are flagged as private. Since they are flagged as private, a private endpoint is used to communicate with them.

Prerequisites

Before following the steps in this article, make sure you have the following prerequisites:

Azure portal

• An Azure subscription. If you don't have an Azure subscription, create a free account before you begin.

• The Microsoft.Network resource provider must be registered for your Azure subscription. This resource provider is used by the hub when creating private endpoints for the managed virtual network.

  For information on registering resource providers, see Resolve errors for resource provider registration.

• The Azure identity you use when deploying a managed network requires the following Azure role-based access control (Azure RBAC) actions to create private endpoints:

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

Azure CLI

• An Azure subscription. If you don't have an Azure subscription, create a free account before you begin.

• The Microsoft.Network resource provider must be registered for your Azure subscription. This resource provider is used by the hub when creating private endpoints for the managed virtual network.

  For information on registering resource providers, see Resolve errors for resource provider registration.

• The Azure identity you use when deploying a managed network requires the following Azure role-based access control (Azure RBAC) actions to create private endpoints:

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

• The Azure CLI and the ml extension to the Azure CLI. For more information, see Install, set up, and use the CLI (v2).

• The CLI examples in this article assume that you're using the Bash (or compatible) shell. For example, from a Linux system or Windows Subsystem for Linux.

• The Azure CLI examples in this article use ws to represent the name of the hub, and rg to represent the name of the resource group. Change these values as needed when using the commands with your Azure subscription.

Python SDK

• An Azure subscription. If you don't have an Azure subscription, create a free account before you begin. Try the free or paid version of Azure Machine Learning.

• The Microsoft.Network resource provider must be registered for your Azure subscription. This resource provider is used by hub when creating private endpoints for the managed virtual network.

  For information on registering resource providers, see Resolve errors for resource provider registration.

• The Azure identity you use when deploying a managed network requires the following Azure role-based access control (Azure RBAC) actions to create private endpoints:

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

• The Azure Machine Learning Python SDK v2. For more information on the SDK, see Install the Python SDK v2 for Azure Machine Learning.

• The examples in this article assume that your code begins with the following Python. This code imports the classes required when creating a hub with managed virtual network, sets variables for your Azure subscription and resource group, and creates the ml_client:

  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)
  

Limitations

• Azure AI Foundry currently doesn't support bringing your own virtual network, it only supports managed virtual network isolation.
• Once you enable managed virtual network isolation of your Azure AI, you can't disable it.
• Managed virtual network uses private endpoint connection to access your private resources. You can't have a private endpoint and a service endpoint at the same time for your Azure resources, such as a storage account. We recommend using private endpoints in all scenarios.
• The managed virtual network is deleted when the Azure AI is deleted.
• Data exfiltration protection is automatically enabled for the only approved outbound mode. If you add other outbound rules, such as to FQDNs, Microsoft can't guarantee that you're protected from data exfiltration to those outbound destinations.
• Using FQDN outbound rules increases the cost of the managed virtual network because FQDN rules use Azure Firewall. For more information, see Pricing.
• FQDN outbound rules only support ports 80 and 443.
• When using a compute instance with a managed network, use the az ml compute connect-ssh command to connect to the compute using SSH.
• If your managed network is configured to allow only approved outbound, you can't use an FQDN rule to access Azure Storage Accounts. You must use a private endpoint instead.

Configure a managed virtual network to allow internet outbound

Tip

The creation of the managed VNet is deferred until a compute resource is created or provisioning is manually started. When allowing automatic creation, it can take around 30 minutes to create the first compute resource as it is also provisioning the network.

Azure portal

• Create a new hub:

  1. Sign in to the Azure portal, and choose Azure AI Foundry from Create a resource menu.

  2. Select + New Azure AI.

  3. Provide the required information on the Basics tab.

  4. From the Networking tab, select Private with Internet Outbound.

  5. To add an outbound rule, select Add user-defined outbound rules from the Networking tab. From the Outbound rules sidebar, provide the following information:

     • Rule name: A name for the rule. The name must be unique for this hub.
     • Destination type: Private Endpoint is the only option when the network isolation is private with internet outbound. Hub managed virtual network doesn't support creating a private endpoint to all Azure resource types. For a list of supported resources, see the Private endpoints section.
     • Subscription: The subscription that contains the Azure resource you want to add a private endpoint for.
     • Resource group: The resource group that contains the Azure resource you want to add a private endpoint for.
     • Resource type: The type of the Azure resource.
     • Resource name: The name of the Azure resource.
     • Sub Resource: The sub resource of the Azure resource type.

     Select Save to save the rule. You can continue using Add user-defined outbound rules to add rules.

  6. Continue creating the hub as normal.

• Update an existing hub:

  1. Sign in to the Azure portal, and select the hub that you want to enable managed virtual network isolation for.

  2. Select Networking, then select Private with Internet Outbound.

     • To add an outbound rule, select Add user-defined outbound rules from the Networking tab. From the Outbound rules sidebar, provide the same information as used when creating a hub in the 'Create a new hub' section.

     • To delete an outbound rule, select delete for the rule.

  3. Select Save at the top of the page to save the changes to the managed virtual network.

Azure CLI

To configure a managed virtual network that allows internet outbound communications, you can use either the --managed-network allow_internet_outbound parameter or a YAML configuration file that contains the following entries:

managed_network:
  isolation_mode: allow_internet_outbound

You can also define outbound rules to other Azure services that the hub relies on. These rules define private endpoints that allow an Azure resource to securely communicate with the managed virtual network. The following rule demonstrates adding a private endpoint to an Azure Blob resource.

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

You can configure a managed virtual network using either the az ml workspace create or az ml workspace update commands:

• Create a new hub:

  The following example creates a new hub. The --managed-network allow_internet_outbound parameter configures a managed virtual network for the hub:

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

  To create a hub using a YAML file instead, use the --file parameter and specify the YAML file that contains the configuration settings:

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

  The following YAML example defines a hub with a managed virtual network:

  name: myhub
  location: EastUS
  managed_network:
    isolation_mode: allow_internet_outbound
  

• Update an existing hub:

  Warning

  Before updating an existing workspace to use a managed virtual network, you must delete all computing resources for the workspace. This includes compute instance, compute cluster, and managed online endpoints.

  The following example updates an existing hub. The --managed-network allow_internet_outbound parameter configures a managed virtual network for the hub:

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

  To update an existing hub using the YAML file, use the --file parameter and specify the YAML file that contains the configuration settings:

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

  The following YAML example defines a managed virtual network for the hub. It also demonstrates how to add a private endpoint connection to a resource used by the hub; in this example, a private endpoint for a blob store:

  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
  

Python SDK

To configure a managed virtual network that allows internet outbound communications, use the ManagedNetwork class to define a network with IsolationMode.ALLOW_INTERNET_OUTBOUND. You can then use the ManagedNetwork object to create a new hub or update an existing one. To define outbound rules to Azure services that the hub relies on, use the PrivateEndpointDestination class to define a new private endpoint to the service.

• Create a new hub:

  The following example creates a new hub named myhub, with an outbound rule named myrule that adds a private endpoint for an Azure Blob store:

  # 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 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 
  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()
  

• Update an existing hub:

  The following example demonstrates how to create a managed virtual network for an existing hub named myhub:

  # Get the existing hub
  ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, "myhub")
  ws = ml_client.workspaces.get()
  
  # Basic managed VNet configuration
  my_hub.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 
  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)
  

Configure a managed virtual network to allow only approved outbound

Tip

The managed VNet is automatically provisioned when you create a compute resource. When allowing automatic creation, it can take around 30 minutes to create the first compute resource as it is also provisioning the network. If you configured FQDN outbound rules, the first FQDN rule adds around 10 minutes to the provisioning time.

Azure portal

• Create a new hub:

  1. Sign in to the Azure portal, and choose Azure AI Foundry from Create a resource menu.

  2. Select + New Azure AI.

  3. Provide the required information on the Basics tab.

  4. From the Networking tab, select Private with Approved Outbound.

  5. To add an outbound rule, select Add user-defined outbound rules from the Networking tab. From the Outbound rules sidebar, provide the following information:

     • Rule name: A name for the rule. The name must be unique for this hub.
     • Destination type: Private Endpoint, Service Tag, or FQDN. Service Tag and FQDN are only available when the network isolation is private with approved outbound.

     If the destination type is Private Endpoint, provide the following information:

     • Subscription: The subscription that contains the Azure resource you want to add a private endpoint for.
     • Resource group: The resource group that contains the Azure resource you want to add a private endpoint for.
     • Resource type: The type of the Azure resource.
     • Resource name: The name of the Azure resource.
     • Sub Resource: The sub resource of the Azure resource type.

     Tip

     The hub managed VNet doesn't support creating a private endpoint to all Azure resource types. For a list of supported resources, see the Private endpoints section.

     If the destination type is Service Tag, provide the following information:

     • Service tag: The service tag to add to the approved outbound rules.
     • Protocol: The protocol to allow for the service tag.
     • Port ranges: The port ranges to allow for the service tag.

     If the destination type is FQDN, provide the following information:

     • FQDN destination: The fully qualified domain name to add to the approved outbound rules.

     Select Save to save the rule. You can continue using Add user-defined outbound rules to add rules.

  6. Continue creating the hub as normal.

• Update an existing hub:

  1. Sign in to the Azure portal, and select the hub that you want to enable managed virtual network isolation for.

  2. Select Networking, then select Private with Approved Outbound.

     • To add an outbound rule, select Add user-defined outbound rules from the Networking tab. From the Outbound rules sidebar, provide the same information as when creating a hub in the previous 'Create a new hub' section.

     • To delete an outbound rule, select delete for the rule.

  3. Select Save at the top of the page to save the changes to the managed virtual network.

Azure CLI

To configure a managed virtual network that allows only approved outbound communications, you can use either the --managed-network allow_only_approved_outbound parameter or a YAML configuration file that contains the following entries:

managed_network:
  isolation_mode: allow_only_approved_outbound

You can also define outbound rules to define approved outbound communication. An outbound rule can be created for a type of service_tag, fqdn, and private_endpoint. The following rule demonstrates adding a private endpoint to an Azure Blob resource, a service tag to Azure Data Factory, and an FQDN to pypi.org:

Important

• Adding an outbound for a service tag or FQDN is only valid when the managed VNet is configured to allow_only_approved_outbound.
• If you add outbound rules, Microsoft can't guarantee data exfiltration.

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

You can configure a managed virtual network using either the az ml workspace create or az ml workspace update commands:

• Create a new hub:

  The following example uses the --managed-network allow_only_approved_outbound parameter to configure the managed virtual network:

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

  The following YAML file defines a hub with a managed virtual network:

  name: myhub
  location: EastUS
  managed_network:
    isolation_mode: allow_only_approved_outbound
  

  To create a hub using the YAML file, use the --file parameter:

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

• Update an existing hub

  Warning

  Before updating an existing workspace to use a managed virtual network, you must delete all computing resources for the workspace. This includes compute instance, compute cluster, and managed online endpoints.

  The following example uses the --managed-network allow_only_approved_outbound parameter to configure the managed virtual network for an existing hub:

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

  The following YAML file defines a managed virtual network for the hub. It also demonstrates how to add an approved outbound to the managed virtual network. In this example, an outbound rule is added for both a service tag:

  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
  

Python SDK

To configure a managed virtual network that allows only approved outbound communications, use the ManagedNetwork class to define a network with IsolationMode.ALLOw_ONLY_APPROVED_OUTBOUND. You can then use the ManagedNetwork object to create a new hub or update an existing one. To define outbound rules, use the following classes:

Destination	Class
Azure service that the hub relies on	PrivateEndpointDestination
Azure service tag	ServiceTagDestination
Fully qualified domain name (FQDN)	FqdnDestination

• Create a new hub:

  The following example creates a new hub named myhub, with several outbound rules:

  • myrule - Adds a private endpoint for an Azure Blob store.
  • datafactory - Adds a service tag rule to communicate with Azure Data Factory.

  Important

  • Adding an outbound for a service tag or FQDN is only valid when the managed VNet is configured to IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND.
  • If you add outbound rules, Microsoft can't guarantee data exfiltration.

  # 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()
  

• Update an existing hub:

  The following example demonstrates how to create a managed virtual network for an existing Azure Machine Learning hub named myhub. The example also adds several outbound rules for the managed virtual network:

  • myrule - Adds a private endpoint for an Azure Blob store.
  • datafactory - Adds a service tag rule to communicate with Azure Data Factory.

  Tip

  Adding an outbound for a service tag or FQDN is only valid when the managed VNet is configured to IsolationMode.ALLOW_ONLY_APPROVED_OUTBOUND.

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

Manually provision a managed VNet

The managed virtual network is automatically provisioned when you create a compute instance. When you rely on automatic provisioning, it can take around 30 minutes to create the first compute instance as it is also provisioning the network. If you configured FQDN outbound rules (only available with allow only approved mode), the first FQDN rule adds around 10 minutes to the provisioning time. If you have a large set of outbound rules to be provisioned in the managed network, it can take longer for provisioning to complete. The increased provisioning time can cause your first compute instance creation to time out.

To reduce the wait time and avoid potential timeout errors, we recommend manually provisioning the managed network. Then wait until the provisioning completes before you create a compute instance.

Alternatively, you can use the provision_network_now flag to provision the managed network as part of hub creation. This flag is in preview.

Note

To create an online deployment, you must manually provision the managed network, or create a compute instance first which will automatically provision it.

Azure portal

During hub creation, select Provision managed network proactively at creation to provision the managed network. Charges are incurred from network resources, such as private endpoints, once the virtual network is provisioned. This configuration option is only available during workspace creation, and is in preview.

Azure CLI

The following example shows how to provision a managed virtual network during hub creation. The --provision-network-now flag is in preview.

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

The following example shows how to provision a managed virtual network.

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

To verify that the provisioning has completed, use the following command:

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

Python SDK

The following example shows how to provision a managed virtual network during hub creation. The --provision-network-now flag is in preview.

az ml workspace create -n myworkspace -g my_resource_group --managed-network AllowInternetOutbound --provision-network-now

The following example shows how to provision a managed virtual network:

# Connect to a workspace named "myworkspace"
ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace_name="myAIHubName")

provision_network_result = ml_client.workspaces.begin_provision_network(workspace_name=ai_hub_name).result()

To verify that the AI Hub has been provisioned, use ml_client.workspaces.get() to get the AI Hub information. The managed_network property contains the status of the managed network.

ws = ml_client.workspaces.get()
print(ws.managed_network.status)

Manage outbound rules

Azure portal

1. Sign in to the Azure portal, and select the hub that you want to enable managed virtual network isolation for.
2. Select Networking. The Azure AI Outbound access section allows you to manage outbound rules.

• To add an outbound rule, select Add user-defined outbound rules from the Networking tab. From the Azure AI outbound rules sidebar, provide the following information:

• To enable or disable a rule, use the toggle in the Active column.

• To delete an outbound rule, select delete for the rule.

Azure CLI

To list the managed virtual network outbound rules for a hub, use the following command:

az ml workspace outbound-rule list --workspace-name myhub --resource-group rg

To view the details of a managed virtual network outbound rule, use the following command:

az ml workspace outbound-rule show --rule rule-name --workspace-name myhub --resource-group rg

To remove an outbound rule from the managed virtual network, use the following command:

az ml workspace outbound-rule remove --rule rule-name --workspace-name myhub --resource-group rg

Python SDK

The following example demonstrates how to manage outbound rules for a hub named myhub:

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

# 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()

List of required rules

Tip

These rules are automatically added to the managed VNet.

Private endpoints:

• When the isolation mode for the managed virtual network is Allow internet outbound, private endpoint outbound rules are automatically created as required rules from the managed virtual network for the hub and associated resources with public network access disabled (Key Vault, Storage Account, Container Registry, hub).
• When the isolation mode for the managed virtual network is Allow only approved outbound, private endpoint outbound rules are automatically created as required rules from the managed virtual network for the hub and associated resources regardless of public network access mode for those resources (Key Vault, Storage Account, Container Registry, hub).

Outbound service tag rules:

• AzureActiveDirectory
• Azure Machine Learning
• BatchNodeManagement.region
• AzureResourceManager
• AzureFrontDoor.FirstParty
• MicrosoftContainerRegistry
• AzureMonitor

Inbound service tag rules:

• AzureMachineLearning

List of scenario specific outbound rules

Scenario: Access public machine learning packages

To allow installation of Python packages for training and deployment, add outbound FQDN rules to allow traffic to the following host names:

Note

This is not a complete list of the hosts required for all Python resources on the internet, only the most commonly used. For example, if you need access to a GitHub repository or other host, you must identify and add the required hosts for that scenario.

Host name	Purpose
anaconda.com *.anaconda.com	Used to install default packages.
*.anaconda.org	Used to get repo data.
pypi.org	Used to list dependencies from the default index, if any, and the index isn't overwritten by user settings. If the index is overwritten, you must also allow *.pythonhosted.org.
pytorch.org *.pytorch.org	Used by some examples based on PyTorch.
*.tensorflow.org	Used by some examples based on Tensorflow.

Scenario: Use Visual Studio Code

Visual Studio Code relies on specific hosts and ports to establish a remote connection.

Hosts

If you plan to use Visual Studio Code with the hub, add outbound FQDN rules to allow traffic to the following hosts:

• *.vscode.dev
• vscode.blob.core.windows.net
• *.gallerycdn.vsassets.io
• raw.githubusercontent.com
• *.vscode-unpkg.net
• *.vscode-cdn.net
• *.vscodeexperiments.azureedge.net
• default.exp-tas.com
• code.visualstudio.com
• update.code.visualstudio.com
• *.vo.msecnd.net
• marketplace.visualstudio.com
• pkg-containers.githubusercontent.com
• github.com

Ports

You must allow network traffic to ports 8704 to 8710. The VS Code server dynamically selects the first available port within this range.

Scenario: Use HuggingFace models

If you plan to use HuggingFace models with the hub, add outbound FQDN rules to allow traffic to the following hosts:

• docker.io
• *.docker.io
• *.docker.com
• production.cloudflare.docker.com
• cnd.auth0.com
• cdn-lfs.huggingface.co

Scenario: Curated by Azure AI

These models involve dynamic installation of dependencies at runtime, and require outbound FQDN rules to allow traffic to the following hosts:

*.anaconda.org *.anaconda.com anaconda.com pypi.org *.pythonhosted.org *.pytorch.org pytorch.org

Private endpoints

Private endpoints are currently supported for the following Azure services:

• AI Foundry hub
• Azure AI Search
• Azure AI services
• Azure API Management
• Azure Container Registry
• Azure Cosmos DB (all sub resource types)
• Azure Data Factory
• Azure Database for MariaDB
• Azure Database for MySQL
• Azure Database for PostgreSQL Single Server
• Azure Database for PostgreSQL Flexible Server
• Azure Databricks
• Azure Event Hubs
• Azure Key Vault
• Azure Machine Learning
• Azure Machine Learning registries
• Azure Redis Cache
• Azure SQL Server
• Azure Storage (all sub resource types)

When you create a private endpoint, you provide the resource type and subresource that the endpoint connects to. Some resources have multiple types and subresources. For more information, see what is a private endpoint.

When you create a private endpoint for hub dependency resources, such as Azure Storage, Azure Container Registry, and Azure Key Vault, the resource can be in a different Azure subscription. However, the resource must be in the same tenant as the hub.

A private endpoint is automatically created for a connection if the target resource is an Azure resource listed previously. A valid target ID is expected for the private endpoint. A valid target ID for the connection can be the Azure Resource Manager ID of a parent resource. The target ID is also expected in the target of the connection or in metadata.resourceid. For more on connections, see How to add a new connection in Azure AI Foundry portal.

Select an Azure Firewall version for allowed only approved outbound (Preview)

An Azure Firewall is deployed if an FQDN outbound rule is created while in the allow only approved outbound mode. Charges for the Azure Firewall are included in your billing. By default, a Standard version of AzureFirewall is created. Optionally, you can select to use a Basic version. You can change the firewall version used as needed. To figure out which version is best for you, visit Choose the right Azure Firewall version.

Important

The firewall isn't created until you add an outbound FQDN rule. For more information on pricing, see Azure Firewall pricing and view prices for the standard version.

Use the following tabs to learn how to select the firewall version for your managed virtual network.

Azure portal

After selecting the allow only approved outbound mode, an option to select the Azure Firewall version (SKU) appears. Select Standard to use the standard version or Basic to use the basic version. Select Save to save your configuration.

Azure CLI

To configure the firewall version from the CLI, use a YAML file and specify the firewall_sku. The following example demonstrates a YAML file that sets the firewall SKU to 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: {}

Python SDK

To configure the firewall version from the Python SDK, set the firewall_sku property of the ManagedNetwork object. The following example demonstrates how to set the firewall SKU to basic:

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

Pricing

The hub managed virtual network feature is free. However, you're charged for the following resources that are used by the managed virtual network:

• Azure Private Link - Private endpoints used to secure communications between the managed virtual network and Azure resources relies on Azure Private Link. For more information on pricing, see Azure Private Link pricing.

• FQDN outbound rules - FQDN outbound rules are implemented using Azure Firewall. If you use outbound FQDN rules, charges for Azure Firewall are included in your billing. A standard version of Azure Firewall is used by default. For information on selecting the basic version, see Select an Azure Firewall version. Azure Firewall is provisioned per hub.

  Important

  The firewall isn't created until you add an outbound FQDN rule. If you don't use FQDN rules, you will not be charged for Azure Firewall. For more information on pricing, see Azure Firewall pricing.

Related content

• Create AI Foundry hub and project using the SDK