Attachement et gestion d’un pool Spark Synapse dans Azure Machine Learning

S’APPLIQUE À :Extension Azure CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)

Dans cet article, vous allez apprendre à attacher un pool Spark Synapse dans Azure Machine Learning. Il existe différentes manières de le faire :

• Avec l’interface utilisateur d’Azure Machine Learning studio
• Avec l’interface CLI d’Azure Machine Learning
• Avec le kit de développement logiciel (SDK) Python d’Azure Machine Learning

Prérequis

Interface utilisateur du studio

• Un abonnement Azure : si vous n’en possédez pas, créez un compte gratuit avant de commencer.
• Un espace de travail Azure Machine Learning. Consultez Créer des ressources d’espace de travail.
• Créez un espace de travail Azure Synapse Analytics dans le portail Azure.
• Créez un pool Apache Spark avec le Portail Azure.

INTERFACE DE LIGNE DE COMMANDE

S’APPLIQUE À : Extension Azure CLI ml v2 (actuelle)

• Un abonnement Azure : si vous n’en possédez pas, créez un compte gratuit avant de commencer.
• Un espace de travail Azure Machine Learning. Consultez Créer des ressources d’espace de travail.
• Créez un espace de travail Azure Synapse Analytics dans le portail Azure.
• Créez un pool Apache Spark avec le Portail Azure.
• Créer une instance de calcul Azure Machine Learning.
• Installez l’interface CLI d’Azure Machine Learning.

Kit de développement logiciel (SDK) Python

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

• Un abonnement Azure : si vous n’en possédez pas, créez un compte gratuit avant de commencer.
• Un espace de travail Azure Machine Learning. Consultez Créer des ressources d’espace de travail.
• Créez un espace de travail Azure Synapse Analytics dans le portail Azure.
• Créez un pool Apache Spark avec le Portail Azure.
• Configurez votre environnement de développement ou créez une instance de calcul Azure Machine Learning.
• Installer le kit de développement logiciel (SDK) Azure Machine Learning pour Python.

Attachement d’un pool Spark Synapse dans Azure Machine Learning

Azure Machine Learning offre différentes façons d’attacher et de gérer un pool Spark Synapse.

Interface utilisateur du studio

Pour attacher un pool Spark Synapse sous l’onglet Calcul du studio :

1. Dans la section Gérer située dans le volet gauche, sélectionnez Calcul.
2. Sélectionnez Calculs attachés.
3. Sur l’écran Calculs attachés, sélectionnez Nouveau pour afficher les options permettant d’attacher différents types de calculs.
4. Sélectionnez Pool Spark Synapse.

Le panneau Attacher un pool Spark Synapse s’ouvre sur le côté droit de l’écran. Procédez comme suit dans ce panneau :

1. Entrez un Nom, qui fait référence au pool Spark Synapse attaché dans la ressource Azure Machine Learning.

2. Sélectionnez un abonnement Azure dans le menu déroulant.

3. Sélectionnez un espace de travail Synapse dans le menu déroulant.

4. Sélectionnez un pool Spark dans le menu déroulant.

5. Activez l’option Affecter une identité managée.

6. Sélectionnez un Type d’identité managé à utiliser avec ce pool Spark Synapse attaché.

7. SélectionnezMettre à jour pour terminer le processus d’attachement de pool Spark Synapse.

INTERFACE DE LIGNE DE COMMANDE

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

Avec l’interface CLI Azure Machine Learning, nous pouvons utiliser la syntaxe et les commandes YAML intuitives à partir de l’interface de ligne de commande pour attacher et gérer un pool Spark Synapse.

Pour définir un pool Spark Synapse attaché à l’aide de la syntaxe YAML, vous devez vous assurer que le fichier YAML couvre les propriétés suivantes :

• name : nom du pool Spark Synapse attaché.

• type : propriété à définir sur synapsespark.

• resource_id : cette propriété doit fournir la valeur d’ID de ressource du pool Spark Synapse créé dans l’espace de travail Azure Synapse Analytics. L’ID de ressource Azure inclut les informations suivantes :

  • l’ID d’abonnement Azure ;

  • le nom du groupe de ressources ;

  • le nom de l’espace de travail Azure Synapse Analytics ;

  • le nom du pool Spark Synapse.

    name: <ATTACHED_SPARK_POOL_NAME>
    
    type: synapsespark
    
    resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>
    

• identity : propriété définissant le type d’identité à affecter au pool Spark Synapse attaché, qui peut prendre les valeurs suivantes :

  • system_assigned

  • user_assigned

    name: <ATTACHED_SPARK_POOL_NAME>
    
    type: synapsespark
    
    resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>
    
    identity:
    type: system_assigned
    

• Pour le type identityuser_assigned, vous devez également fournir une liste de valeurs user_assigned_identities. Chaque identité affectée par l’utilisateur doit, à l’aide de la valeur resource_id correspondante, être déclarée comme un élément de la liste. La première identité affectée par l’utilisateur dans la liste est utilisée pour soumettre un travail par défaut.

  name: <ATTACHED_SPARK_POOL_NAME>
  
  type: synapsespark
  
  resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>
  
  identity:
    type: user_assigned
    user_assigned_identities:
      - resource_id: /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID>
  

Les fichiers YAML suivants peuvent être utilisés dans la commande az ml compute attach comme paramètre --file. La commande az ml compute attach permet d’attacher un pool Spark Synapse à un espace de travail Azure Machine Learning, dans un groupe de ressources spécifié au sein d’un abonnement :

az ml compute attach --file <YAML_SPECIFICATION_FILE_NAME>.yaml --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME>

Cet exemple montre la sortie attendue de la commande ci-dessus :

Class SynapseSparkCompute: This is an experimental class, and may change at any time. Please visit https://aka.ms/azuremlexperimental for more information.

{
    "auto_pause_settings": {
    "auto_pause_enabled": true,
    "delay_in_minutes": 15
    },
    "created_on": "2022-09-13 19:01:05.109840+00:00",
    "id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.MachineLearningServices/workspaces/<AML_WORKSPACE_NAME>/computes/<ATTACHED_SPARK_POOL_NAME>",
    "location": "eastus2",
    "name": "<ATTACHED_SPARK_POOL_NAME>",
    "node_count": 5,
    "node_family": "MemoryOptimized",
    "node_size": "Small",
    "provisioning_state": "Succeeded",
    "resourceGroup": "<RESOURCE_GROUP>",
    "resource_id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>",
    "scale_settings": {
    "auto_scale_enabled": false,
    "max_node_count": 0,
    "min_node_count": 0
    },
    "spark_version": "3.2",
    "type": "synapsespark"
}

Si le pool Spark Synapse attaché portant le nom précisé dans le fichier de spécification YAML existe déjà dans l’espace de travail, la commande az ml compute attach met à jour ce pool avec les informations fournies dans le fichier de spécification YAML. Dans ce fichier, vous pouvez mettre à jour les éléments suivants :

• le type d’identité ;
• les identités affectées par l’utilisateur ;
• tags

les valeurs.

Pour afficher les détails d’un pool Spark Synapse attaché, exécutez la commande az ml compute show. Transmettez le nom du pool Spark Synapse attaché avec le paramètre --name :

az ml compute show --name <ATTACHED_SPARK_POOL_NAME> --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME>

Cet exemple montre la sortie attendue de la commande ci-dessus :

<ATTACHED_SPARK_POOL_NAME>
{
    "auto_pause_settings": {
    "auto_pause_enabled": true,
    "delay_in_minutes": 15
    },
    "created_on": "2022-09-13 19:01:05.109840+00:00",
    "id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.MachineLearningServices/workspaces/<AML_WORKSPACE_NAME>/computes/<ATTACHED_SPARK_POOL_NAME>",
    "location": "eastus2",
    "name": "<ATTACHED_SPARK_POOL_NAME>",
    "node_count": 5,
    "node_family": "MemoryOptimized",
    "node_size": "Small",
    "provisioning_state": "Succeeded",
    "resourceGroup": "<RESOURCE_GROUP>",
    "resource_id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>",
    "scale_settings": {
    "auto_scale_enabled": false,
    "max_node_count": 0,
    "min_node_count": 0
    },
    "spark_version": "3.2",
    "type": "synapsespark"
}

Pour afficher la liste de tous les calculs, y compris les pools Spark Synapse attachés dans un espace de travail, utilisez la commande az ml compute list. Utilisez le paramètre name pour transmettre le nom de l’espace de travail :

az ml compute list --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME>

Cet exemple montre la sortie attendue de la commande ci-dessus :

[
    {
    "auto_pause_settings": {
        "auto_pause_enabled": true,
        "delay_in_minutes": 15
    },
    "created_on": "2022-09-09 21:28:54.871251+00:00",
    "id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.MachineLearningServices/workspaces/<AML_WORKSPACE_NAME>/computes/<ATTACHED_SPARK_POOL_NAME>",
    "identity": {
        "principal_id": "<PRINCIPAL_ID>",
        "tenant_id": "<TENANT_ID>",
        "type": "system_assigned"
    },
    "location": "eastus2",
    "name": "<ATTACHED_SPARK_POOL_NAME>",
    "node_count": 5,
    "node_family": "MemoryOptimized",
    "node_size": "Small",
    "provisioning_state": "Succeeded",
    "resourceGroup": "<RESOURCE_GROUP>",
    "resource_id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>",
    "scale_settings": {
        "auto_scale_enabled": false,
        "max_node_count": 0,
        "min_node_count": 0
    },
    "spark_version": "3.2",
    "type": "synapsespark"
    },
    ...
]

Kit de développement logiciel (SDK) Python

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Le kit SDK Python de Azure Machine Learning fournit des fonctions pratiques pour attacher et gérer un pool Spark Synapse à l’aide de code Python dans les notebooks Azure Machine Learning.

Pour attacher un calcul Synapse à l’aide du kit SDK Python, créez d’abord une instance de la classe azure.ai.ml.MLClient. Elle fournit des fonctions pratiques pour interagir avec les services Azure Machine Learning. L’exemple de code suivant utilise azure.identity.DefaultAzureCredential pour se connecter à un espace de travail dans le groupe de ressources d’un abonnement Azure spécifié. Dans l’exemple de code suivant, définissez SynapseSparkCompute avec ces paramètres :

• name : nom défini par l’utilisateur du nouveau pool Spark Synapse attaché.
• resource_id : ID de ressource du pool Spark Synapse créé précédemment dans l’espace de travail Azure Synapse Analytics

Un appel de fonction azure.ai.ml.MLClient.begin_create_or_update() attache le pool Spark Synapse défini à l’espace de travail Azure Machine Learning.

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

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace_name = "<AML_WORKSPACE_NAME>"

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

synapse_name = "<ATTACHED_SPARK_POOL_NAME>"
synapse_resource = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>"

synapse_comp = SynapseSparkCompute(name=synapse_name, resource_id=synapse_resource)
ml_client.begin_create_or_update(synapse_comp)

Pour attacher un pool Spark Synapse qui utilise une identité affectée par le système, transmettez IdentityConfiguration avec le type SystemAssigned défini sur identity comme paramètre de la classe SynapseSparkCompute. Cet extrait de code attache un pool Spark Synapse qui utilise une identité affectée par le système :

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import SynapseSparkCompute, IdentityConfiguration
from azure.identity import DefaultAzureCredential

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace_name = "<AML_WORKSPACE_NAME>"

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

synapse_name = "<ATTACHED_SPARK_POOL_NAME>"
synapse_resource = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>"
synapse_identity = IdentityConfiguration(type="SystemAssigned")

synapse_comp = SynapseSparkCompute(
    name=synapse_name, resource_id=synapse_resource, identity=synapse_identity
)
ml_client.begin_create_or_update(synapse_comp)

Un pool Spark Synapse peut également utiliser une identité affectée par l’utilisateur. Pour une identité affectée par l’utilisateur, vous pouvez transmettre une définition d’identité managée, à l’aide de la classe IdentityConfiguration, comme paramètre identity de la classe SynapseSparkCompute. Dans le cas de la définition d’identité managée utilisée de cette façon, définissez type sur UserAssigned. Transmettez également un paramètre user_assigned_identities. Le paramètre user_assigned_identities est une liste d'objets de la classe UserAssignedIdentityid. Le resource_id de l’identité affectée par l’utilisateur remplit chaque objet de classe UserAssignedIdentity. Cet extrait de code attache un pool Spark Synapse qui utilise une identité affectée par l’utilisateur.

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    SynapseSparkCompute,
    IdentityConfiguration,
    UserAssignedIdentity,
)
from azure.identity import DefaultAzureCredential

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace_name = "<AML_WORKSPACE_NAME>"

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

synapse_name = "<ATTACHED_SPARK_POOL_NAME>"
synapse_resource = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>"
synapse_identity = IdentityConfiguration(
    type="UserAssigned",
    user_assigned_identities=[
        UserAssignedIdentity(
            resource_id="/subscriptions/<SUBSCRIPTION_ID/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID>"
        )
    ],
)

synapse_comp = SynapseSparkCompute(
    name=synapse_name, resource_id=synapse_resource, identity=synapse_identity
)
ml_client.begin_create_or_update(synapse_comp)

Notes

La fonction azure.ai.ml.MLClient.begin_create_or_update() attache un nouveau pool Spark Synapse, s’il n’existe pas encore de pool portant le nom spécifié dans l’espace de travail. Dans le cas contraire où un pool Spark Synapse de ce nom est déjà attaché à l’espace de travail, un appel de la fonction azure.ai.ml.MLClient.begin_create_or_update() met à jour le pool attaché existant avec la ou les nouvelles identités.

Ajout d’attributions de rôles dans Azure Synapse Analytics

Pour que le pool Spark Synapse attaché fonctionne correctement, attribuez-lui le rôle Administrateur dans l’interface utilisateur d’Azure Synapse Analytics Studio. Pour ce faire, procédez comme suit :

1. Ouvrez votre espace de travail Synapse sur le Portail Azure.

2. Dans le volet gauche, sélectionnez Vue d’ensemble.

   

3. Sélectionnez Ouvrir Synapse Studio.

4. Dans Azure Synapse Analytics Studio, sélectionnez Gérer dans le volet gauche.

5. Sélectionnez Contrôle d’accès dans la section Sécurité du volet gauche (le deuxième en partant de la gauche).

6. Sélectionnez Ajouter.

7. Le panneau Ajouter une attribution de rôle s’ouvre sur le côté droit de l’écran. Procédez comme suit dans ce panneau :

   1. Sélectionnez Élément d’espace de travail comme Étendue.

   2. Dans le menu déroulant Type d’élément, sélectionnez Pool Apache Spark.

   3. Dans le menu déroulant Élément, sélectionnez votre pool Apache Spark.

   4. Dans le menu déroulant Rôle, sélectionnez Administrateur Synapse.

   5. Dans la zone de recherche Sélectionner un utilisateur, commencez à taper le nom de votre espace de travail Azure Machine Learning. La liste des pools Spark Synapse attachés s’affiche. Sélectionnez le pool Spark Synapse souhaité dans la liste.

   6. Sélectionnez Appliquer.

      

Mise à jour du pool Spark Synapse

Interface utilisateur du studio

Vous pouvez gérer le pool Spark Synapse attaché dans l’interface utilisateur d’Azure Machine Learning studio. Les fonctionnalités de gestion des pools Spark comprennent la mise à jour de l’identité managée associée à un pool Spark Synapse attaché. Vous pouvez attribuer une identité affectée par le système ou par l’utilisateur lors de la mise à jour d’un pool Spark Synapse. Vous devez créer une identité managée affectée par l’utilisateur dans le portail Azure avant de l’attribuer à un pool Spark Synapse.

Pour mettre à jour l’identité managée du pool Spark Synapse attaché, procédez comme suit :

1. Ouvrez la page Détail du pool Spark Synapse dans Azure Machine Learning studio.

2. Localisez l’icône de modification sur le côté droit de la section Identité managée.

3. Pour affecter une identité managée pour la première fois, activez l’option Affecter une identité managée.

4. Pour attribuer une identité managée affectée par le système, procédez comme suit :

   1. Sélectionnez Affectée par le système comme Type d’identité.
   2. Sélectionnez Update.

5. Pour attribuer une identité managée affectée par l’utilisateur, procédez comme suit :

   1. Sélectionnez Affectée par l’utilisateur comme Type d’identité.
   2. Sélectionnez un abonnement Azure dans le menu déroulant.
   3. Tapez les premières lettres du nom de l’identité managée affectée par l’utilisateur dans la zone de texte Rechercher par nom. La liste des noms d’identités managées affectées par l’utilisateur correspondants s’affiche. Sélectionnez l’identité managée affectée par l’utilisateur souhaitée dans la liste. Vous pouvez en choisir plusieurs et les attribuer au pool Spark Synapse attaché.
   4. Sélectionnez Mettre à jour.

INTERFACE DE LIGNE DE COMMANDE

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

Pour mettre à jour l’identité associée à un pool Spark Synapse attaché, exécutez la commande az ml compute update avec les paramètres appropriés. Pour attribuer une identité affectée par le système, définissez le paramètre --identity de la commande sur SystemAssigned :

az ml compute update --identity SystemAssigned --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME> --name <ATTACHED_SPARK_POOL_NAME>

Cet exemple montre la sortie attendue de la commande ci-dessus :

Class SynapseSparkCompute: This is an experimental class, and may change at any time. Please see https://aka.ms/azuremlexperimental for more information.
{
    "auto_pause_settings": {
    "auto_pause_enabled": true,
    "delay_in_minutes": 15
    },
    "created_on": "2022-09-13 20:02:15.746490+00:00",
    "id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.MachineLearningServices/workspaces/<AML_WORKSPACE_NAME>/computes/<ATTACHED_SPARK_POOL_NAME>",
    "identity": {
    "principal_id": "<PRINCIPAL_ID>",
    "tenant_id": "<TENANT_ID>",
    "type": "system_assigned"
    },
    "location": "eastus2",
    "name": "<ATTACHED_SPARK_POOL_NAME>",
    "node_count": 5,
    "node_family": "MemoryOptimized",
    "node_size": "Small",
    "provisioning_state": "Succeeded",
    "resourceGroup": "<RESOURCE_GROUP>",
    "resource_id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<AML_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>",
    "scale_settings": {
    "auto_scale_enabled": false,
    "max_node_count": 0,
    "min_node_count": 0
    },
    "spark_version": "3.2",
    "type": "synapsespark"
}

Pour attribuer une identité affectée par l’utilisateur, définissez le paramètre --identity de la commande sur UserAssigned. Vous devez également utiliser le paramètre --user-assigned-identities afin de transmettre l’ID de ressource pour l’identité affectée par l’utilisateur, comme indiqué ici :

az ml compute update --identity UserAssigned --user-assigned-identities /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID> --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME> --name <ATTACHED_SPARK_POOL_NAME>

Cet exemple montre la sortie attendue de la commande ci-dessus :

Class SynapseSparkCompute: This is an experimental class, and may change at any time. Please see https://aka.ms/azuremlexperimental for more information.
{
  "auto_pause_settings": {
    "auto_pause_enabled": true,
    "delay_in_minutes": 15
  },
  "created_on": "2022-09-13 20:02:15.746490+00:00",
  "id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.MachineLearningServices/workspaces/<AML_WORKSPACE_NAME>/computes/<ATTACHED_SPARK_POOL_NAME>",
  "identity": {
    "type": "user_assigned",
    "user_assigned_identities": [
      {
        "client_id": "<CLIENT_ID>",
        "principal_id": "<PRINCIPAL_ID>",
        "resource_id": "/subscriptions/<SUBSCRIPTION_ID>/resourcegroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID>"
      }
    ]
  },
  "location": "eastus2",
  "name": "<ATTACHED_SPARK_POOL_NAME>",
  "node_count": 5,
  "node_family": "MemoryOptimized",
  "node_size": "Small",
  "provisioning_state": "Succeeded",
  "resourceGroup": "<RESOURCE_GROUP>",
  "resource_id": "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>",
  "scale_settings": {
    "auto_scale_enabled": false,
    "max_node_count": 0,
    "min_node_count": 0
  },
  "spark_version": "3.2",
  "type": "synapsespark"
}

Notes

Le paramètre --user-assigned-identities peut prendre une liste d’ID de ressource et affecter plusieurs identités définies par l’utilisateur à un pool Spark Synapse attaché. La première identité affectée par l’utilisateur de la liste sera utilisée pour soumettre un travail par défaut.

Kit de développement logiciel (SDK) Python

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Pour utiliser l’identité affectée par le système, transmettez IdentityConfiguration, avec le type défini sur SystemAssigned, comme paramètre identity de la classe SynapseSparkCompute. L’extrait de code suivant met à jour un pool Spark Synapse de façon à utiliser une identité affectée par le système :

# import required libraries 
from azure.ai.ml import MLClient
from azure.ai.ml.entities import SynapseSparkCompute, IdentityConfiguration 
from azure.identity import DefaultAzureCredential
    
subscription_id = "<SUBSCRIPTION_ID>" 
resource_group_name = "<RESOURCE_GROUP>" 
workspace_name = "<AML_WORKSPACE_NAME>"

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

synapse_name = "<ATTACHED_SPARK_POOL_NAME>" 
synapse_resource ="/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>" 
synapse_identity = IdentityConfiguration(type="SystemAssigned") 

synapse_comp = SynapseSparkCompute(name=synapse_name, resource_id=synapse_resource,identity=synapse_identity) ml_client.begin_create_or_update(synapse_comp) 

Un pool Spark Synapse peut également utiliser une identité affectée par l’utilisateur. Pour une identité affectée par l’utilisateur, vous pouvez transmettre une définition d’identité managée, à l’aide de la classe IdentityConfiguration, comme paramètre identity de la classe SynapseSparkCompute. Dans le cas de la définition d’identité managée utilisée de cette façon, définissez type sur UserAssigned. Transmettez également un paramètre user_assigned_identities. Le paramètre user_assigned_identities est une liste d'objets de la classe UserAssignedIdentityid. Le resource_id de l’identité affectée par l’utilisateur remplit chaque objet de classe UserAssignedIdentity. L’extrait de code suivant met à jour un pool Spark Synapse de façon à utiliser une identité affectée par l’utilisateur :

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    SynapseSparkCompute,
    IdentityConfiguration,
    UserAssignedIdentity,
)
from azure.identity import DefaultAzureCredential

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace_name = "<AML_WORKSPACE_NAME>"

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

synapse_name = "<ATTACHED_SPARK_POOL_NAME>"
synapse_resource = "/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.Synapse/workspaces/<SYNAPSE_WORKSPACE_NAME>/bigDataPools/<SPARK_POOL_NAME>"
synapse_identity = IdentityConfiguration(
    type="UserAssigned",
    user_assigned_identities=[
        UserAssignedIdentity(
            resource_id="/subscriptions/<SUBSCRIPTION_ID/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<AML_USER_MANAGED_ID>"
        )
    ],
)

synapse_comp = SynapseSparkCompute(
    name=synapse_name, resource_id=synapse_resource, identity=synapse_identity
)
ml_client.begin_create_or_update(synapse_comp)

Notes

La fonction azure.ai.ml.MLClient.begin_create_or_update() attache un nouveau pool Spark Synapse, s’il n’existe pas encore de pool portant le nom spécifié dans l’espace de travail. Dans le cas contraire où un pool Spark Synapse de ce nom est déjà attaché à l’espace de travail, un appel de la fonction azure.ai.ml.MLClient.begin_create_or_update() met à jour le pool attaché existant avec la ou les nouvelles identités.

Détachement du pool Spark Synapse

Il est parfois nécessaire, pour nettoyer un espace de travail, de détacher un pool Spark Synapse attaché.

---

Interface utilisateur du studio

L’interface utilisateur d’Azure Machine Learning studio fournit également un moyen de détacher un pool Spark Synapse attaché. Pour ce faire, procédez comme suit :

1. Ouvrez la page Détail du pool Spark Synapse dans Azure Machine Learning studio.

2. Sélectionnez Détacher pour détacher le pool Spark Synapse attaché.

INTERFACE DE LIGNE DE COMMANDE

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

Pour détacher un pool Spark Synapse attaché, exécutez la commande az ml compute detach en transmettant le nom du pool à l’aide du paramètre --name, comme indiqué ici :

az ml compute detach --name <ATTACHED_SPARK_POOL_NAME> --subscription <SUBSCRIPTION_ID> --resource-group <RESOURCE_GROUP> --workspace-name <AML_WORKSPACE_NAME>

Cet exemple montre la sortie attendue de la commande ci-dessus :

Are you sure you want to perform this operation? (y/n): y

Kit de développement logiciel (SDK) Python

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Nous allons utiliser un appel de fonction MLClient.compute.begin_delete(). Transmettez le name du pool Spark Synapse attaché, ainsi que l’action Detach, à la fonction. L’extrait de code suivant détache un pool Spark Synapse d’un espace de travail Azure Machine Learning :

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import SynapseSparkCompute
from azure.identity import DefaultAzureCredential

subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace_name = "<AML_WORKSPACE_NAME>"

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

synapse_name = "<ATTACHED_SPARK_POOL_NAME>"
ml_client.compute.begin_delete(name=synapse_name, action="Detach")

Calcul Spark serverless dans les Notebooks de Azure Machine Learning

Certains scénarios utilisateur peuvent nécessiter l’accès à une ressource de calcul Spark serverless, lors d’une soumission de travaux Azure Machine Learning, sans qu’il soit nécessaire d’attacher un pool Spark. L’intégration Azure Synapse Analytics à Azure Machine Learning offre également une expérience de calcul Spark serverless. Cela permet d’accorder l’accès au calcul Spark dans une tâche sans qu’il y ai besoin de joindre le calcul à un espace de travail au préalable. En savoir plus sur l’expérience de calcul Spark serverless.

Étapes suivantes

• Data Wrangling interactif avec Apache Spark dans Azure Machine Learning

• Soumettre des travaux Spark dans Azure Machine Learning