Démarrage rapide : Utiliser Python pour créer un pool Batch et exécuter un travail

Ce guide de démarrage rapide vous montre comment commencer à utiliser Azure Batch en exécutant une application qui utilise les bibliothèques Azure Batch pour Python. L’application Python :

Télécharge plusieurs fichiers de données d’entrée dans un conteneur de blob de Stockage Azure pour traitement des tâches Batch.
Crée un pool de deux machines virtuelles ou nœuds de calcul, exécutant le système d’exploitation Ubuntu 22.04 LTS.
Création d’un travail et de trois tâches à exécuter sur les nœuds. Chaque tâche traite l’un des fichiers d’entrée à l’aide d’une ligne de commande d’interpréteur de commandes Bash.
Affiche les fichiers de sortie retournés par les tâches.

À l’issue de ce guide de démarrage rapide, vous maîtriserez les concepts clés du service Batch et serez prêt à utiliser Batch avec des charges de travail plus réalistes à plus grande échelle.

Prerequisites

Un compte Azure avec un abonnement actif. Si vous n’en avez pas un, créez un compte gratuitement.
Un compte Batch avec un compte de stockage Azure lié. Vous pouvez créer les comptes à l'aide de l'une des méthodes suivantes : Azure CLI | , portail Azure | , Bicep | , modèle ARM | , Terraform.
Python version 3.8 ou ultérieure, qui inclut le gestionnaire de package pip .

Exécuter l’application

Pour suivre ce guide de démarrage rapide, vous téléchargez ou clonez l’application Python, fournissez vos valeurs de compte, exécutez l’application et vérifiez la sortie.

Télécharger ou cloner l’application

Téléchargez ou clonez l’application de démarrage rapide Python Azure Batch à partir de GitHub. Utilisez la commande suivante pour cloner le dépôt d’application avec un client Git :
```
git clone https://github.com/Azure-Samples/batch-python-quickstart.git
```
Basculez vers le dossier batch-python-quickstart/src et installez les packages requis à l’aide pipde .
```
pip install -r requirements.txt
```

Fournissez les informations de votre compte

L’application Python doit utiliser les noms de vos comptes Batch et Stockage, les valeurs de clé de compte et le point de terminaison du compte Batch. Vous pouvez obtenir ces informations à partir du portail Azure, des API Azure ou des outils en ligne de commande.

Pour obtenir des informations sur votre compte à partir du portail Azure :

Dans la barre Recherche Azure, recherchez et sélectionnez le nom de votre compte Batch.
Dans la page de votre compte Batch, sélectionnez Clés dans le volet de navigation gauche.
Dans la page Clés , copiez les valeurs suivantes :

Compte Batch
Point de terminaison de compte
Clé d’accès primaire
Nom du compte de stockage
Key1

Dans votre application Python téléchargée, modifiez les chaînes suivantes dans le fichier config.py pour fournir les valeurs que vous avez copiées.

BATCH_ACCOUNT_NAME = '<batch account>'
BATCH_ACCOUNT_KEY = '<primary access key>'
BATCH_ACCOUNT_URL = '<account endpoint>'
STORAGE_ACCOUNT_NAME = '<storage account name>'
STORAGE_ACCOUNT_KEY = '<key1>'

Important

L’exposition des clés de compte dans le code source de l’application n’est pas recommandée en environnement de production. Vous devez restreindre l’accès aux informations d’identification et les référencer dans votre code à l’aide de variables ou d’un fichier de configuration. Il est préférable de stocker les clés de compte Batch et de stockage dans Azure Key Vault.

Exécuter l’application et afficher la sortie

Exécutez l’application pour afficher le flux de travail Batch en action.

python python_quickstart_client.py

La durée d’exécution classique est d’environ trois minutes. La configuration initiale du nœud de pool prend le plus de temps.

L’application retourne une sortie similaire à l’exemple suivant :

Sample start: 11/26/2012 4:02:54 PM

Uploading file taskdata0.txt to container [input]...
Uploading file taskdata1.txt to container [input]...
Uploading file taskdata2.txt to container [input]...
Creating pool [PythonQuickstartPool]...
Creating job [PythonQuickstartJob]...
Adding 3 tasks to job [PythonQuickstartJob]...
Monitoring all tasks for 'Completed' state, timeout in 00:30:00...

Il y a une pause à Monitoring all tasks for 'Completed' state, timeout in 00:30:00... pendant que les nœuds de calcul du pool démarrent. À mesure que les tâches sont créées, Batch les met en file d’attente pour qu’elles s’exécutent sur le pool. Dès que le premier nœud de calcul est disponible, la première tâche s’exécute sur le nœud. Vous pouvez surveiller l’état du nœud, de la tâche et du travail à partir de la page de votre compte Batch dans le portail Azure.

Une fois chaque tâche terminée, vous voyez une sortie similaire à l’exemple suivant :

Printing task output...
Task: Task0
Node: tvm-2850684224_3-20171205t000401z
Standard output:
Batch processing began with mainframe computers and punch cards. Today it still plays a central role...

Vérifier le code

Passez en revue le code pour comprendre les étapes du guide de démarrage rapide Azure Batch Python.

Créer des clients de service et charger des fichiers de ressources

L’application crée un objet BlobServiceClient pour interagir avec le compte de stockage.

blob_service_client = BlobServiceClient(
        account_url=f"https://{config.STORAGE_ACCOUNT_NAME}.{config.STORAGE_ACCOUNT_DOMAIN}/",
        credential=config.STORAGE_ACCOUNT_KEY
    )

L’application utilise la blob_service_client référence pour créer un conteneur dans le compte de stockage et charger des fichiers de données dans le conteneur. Les fichiers de stockage sont définis en tant qu’objets Batch ResourceFile que Batch peut télécharger ultérieurement sur les nœuds de calcul.

input_file_paths = [os.path.join(sys.path[0], 'taskdata0.txt'),
                    os.path.join(sys.path[0], 'taskdata1.txt'),
                    os.path.join(sys.path[0], 'taskdata2.txt')]

input_files = [
    upload_file_to_container(blob_service_client, input_container_name, file_path)
    for file_path in input_file_paths]

L’application crée un objet BatchServiceClient pour créer et gérer des pools, des travaux et des tâches dans le compte Batch. Le client Batch utilise l’authentification par clé partagée. Batch prend également en charge l’authentification Microsoft Entra.
```
credentials = SharedKeyCredentials(config.BATCH_ACCOUNT_NAME,
        config.BATCH_ACCOUNT_KEY)

    batch_client = BatchServiceClient(
        credentials,
        batch_url=config.BATCH_ACCOUNT_URL)
```

Créer un pool de nœuds de calcul

Pour créer un pool Batch, l’application utilise la classe PoolAddParameter pour définir le nombre de nœuds, de taille de machine virtuelle et de configuration du pool. L'objet VirtualMachineConfiguration suivant spécifie un ImageReference vers une image Ubuntu Server 22.04 LTS du Azure Marketplace. Batch prend en charge un large éventail d’images Linux et Windows Server Marketplace, et prend également en charge les images de machine virtuelle personnalisées.

POOL_NODE_COUNT et POOL_VM_SIZE sont des constantes définies. L’application crée un pool de deux nœuds de taille Standard_DS1_v2. Cette taille offre un bon compromis entre performance et coût dans ce guide de démarrage rapide.

La méthode pool.add envoie le pool au service Batch.

new_pool = batchmodels.PoolAddParameter(
        id=pool_id,
        virtual_machine_configuration=batchmodels.VirtualMachineConfiguration(
            image_reference=batchmodels.ImageReference(
                publisher="canonical",
                offer="0001-com-ubuntu-server-focal",
                sku="22_04-lts",
                version="latest"
            ),
            node_agent_sku_id="batch.node.ubuntu 22.04"),
        vm_size=config.POOL_VM_SIZE,
        target_dedicated_nodes=config.POOL_NODE_COUNT
    )
    batch_service_client.pool.add(new_pool)

Créer un travail par lots

Un travail Batch est un regroupement logique d’une ou plusieurs tâches. Le travail inclut les paramètres communs aux tâches, tels que la priorité et le pool pour exécuter les tâches.

L'application utilise la classe JobAddParameter pour créer une tâche sur le pool. La méthode job.add ajoute le travail au compte Batch spécifié. Au début, le travail n’a pas de tâches.

job = batchmodels.JobAddParameter(
    id=job_id,
    pool_info=batchmodels.PoolInformation(pool_id=pool_id))

batch_service_client.job.add(job)

Créer des tâches

Azure Batch fournit plusieurs façons de déployer des applications et des scripts sur des nœuds de calcul. Cette application crée une liste d’objets de tâche à l’aide de la classe TaskAddParameter . Chaque tâche traite un fichier d’entrée à l’aide d’un command_line paramètre pour spécifier une application ou un script.

Le script suivant traite les objets d’entrée resource_files en exécutant la commande Shell cat Bash pour afficher les fichiers texte. L’application utilise ensuite la méthode task.add_collection pour ajouter chaque tâche au travail, qui met en file d’attente les tâches à exécuter sur les nœuds de calcul.

tasks = []

for idx, input_file in enumerate(resource_input_files):
    command = f"/bin/bash -c \"cat {input_file.file_path}\""
    tasks.append(batchmodels.TaskAddParameter(
        id=f'Task{idx}',
        command_line=command,
        resource_files=[input_file]
    )
    )

batch_service_client.task.add_collection(job_id, tasks)

Afficher la sortie des tâches

L’application surveille l’état des tâches pour vous assurer que les tâches se terminent. Lorsque chaque tâche s’exécute correctement, la commande de tâche écrit le résultat dans le fichier stdout.txt. L’application affiche ensuite le fichier stdout.txt pour chaque tâche terminée.

tasks = batch_service_client.task.list(job_id)

for task in tasks:

    node_id = batch_service_client.task.get(job_id, task.id).node_info.node_id
    print(f"Task: {task.id}")
    print(f"Node: {node_id}")

    stream = batch_service_client.file.get_from_task(
        job_id, task.id, config.STANDARD_OUT_FILE_NAME)

    file_text = _read_stream_as_string(
        stream,
        text_encoding)

    if text_encoding is None:
        text_encoding = DEFAULT_ENCODING

    sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding = text_encoding)
    sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding = text_encoding)

    print("Standard output:")
    print(file_text)

Nettoyer les ressources

L’application supprime automatiquement le conteneur de stockage qu’elle crée et vous donne la possibilité de supprimer le pool et le travail Batch. Les pools et les nœuds entraînent des frais pendant l’exécution des nœuds, même s’ils n’exécutent pas de travaux. Si vous n’avez plus besoin du pool, supprimez-le.

Lorsque vous n’avez plus besoin de vos ressources Batch, vous pouvez supprimer le groupe de ressources qui les contient. Dans le portail Azure, sélectionnez Supprimer le groupe de ressources en haut de la page du groupe de ressources. Dans l’écran Supprimer un groupe de ressources , entrez le nom du groupe de ressources, puis sélectionnez Supprimer.

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez exécuté une application qui utilise l’API Python Batch pour créer un pool Batch, des nœuds, un travail et des tâches. Le travail a chargé des fichiers de ressources dans un conteneur de stockage, exécuté des tâches sur les nœuds et affiché la sortie des nœuds.

Maintenant que vous maîtrisez les concepts clés du service Batch, vous êtes prêt à utiliser Azure Batch avec des charges de travail plus réalistes à plus grande échelle. Pour en savoir plus sur Azure Batch et parcourir une charge de travail parallèle avec une application réelle, passez au tutoriel Batch Python.

Traiter une charge de travail parallèle avec Python

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-10-08