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

Article
03/01/2024

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 :

Charge plusieurs fichiers de données d’entrée dans un conteneur d’objets blob Stockage Azure à utiliser pour le 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 20.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 que les tâches retournent.

À 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.

Prérequis

Compte Azure avec un abonnement actif. Si vous n’en avez pas un, créez un compte gratuitement.
Un compte Batch et un compte 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 effectuer ce guide de démarrage rapide, vous téléchargez ou clonez l’application Python, fournissez les valeurs des comptes, exécutez l’application, puis vérifiez la sortie.

Télécharger ou cloner l’application

Téléchargez ou clonez l’application Azure Batch Python Quickstart à partir de GitHub. Utilisez la commande ci-dessous pour cloner le référentiel 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 de pip.
```
pip install -r requirements.txt
```

Fournir les informations sur les comptes

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

Pour obtenir les informations sur vos comptes à partir du portail Azure :

Dans la barre recherche Azure, recherchez et sélectionnez le nom de votre compte Batch.
Sur la page de votre compte Batch, sélectionnez Clés dans le volet de navigation de gauche.
Sur 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 l’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 la source de l’application n’est pas recommandée pour l’utilisation en production. Vous devez restreindre l’accès aux informations d’identification et y faire référence 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

Le temps d’exécution standard est d’environ trois minutes. La configuration initial des nœuds du pool prend le plus de temps.

L’application retourne un résultat semblable à 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 dans Monitoring all tasks for 'Completed' state, timeout in 00:30:00... au moment où 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 des nœuds, des tâches et des travaux à 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 de l’application Azure Batch Python Quickstart.

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 référence blob_service_client pour créer un conteneur dans le compte de stockage, ainsi que pour charger des fichiers de données vers 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, la taille de machine virtuelle et la configuration du pool. L’objet VirtualMachineConfiguration suivant spécifie une référence ImageReference sur une image Ubuntu Server 20.04 LTS publiée dans la Place de marché Azure. Batch prend en charge une large plage d’images Linux et Windows Server dans la Place de marché, ainsi que des images de machines virtuelles personnalisées.

Les éléments POOL_NODE_COUNT et POOL_VM_SIZE sont des constantes définies. L’application crée un pool de 2 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 soumet 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="20_04-lts",
                version="latest"
            ),
            node_agent_sku_id="batch.node.ubuntu 20.04"),
        vm_size=config.POOL_VM_SIZE,
        target_dedicated_nodes=config.POOL_NODE_COUNT
    )
    batch_service_client.pool.add(new_pool)

Création d’un travail Batch

Un travail Batch est un regroupement logique d’une ou de 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 un travail sur le pool. La méthode job.add ajoute le travail au compte Batch spécifié. Dans un premier temps, le travail n’a aucune tâche.

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. L’application crée une liste d’objets de tâches à l’aide de la classe TaskAddParameter. Chaque tâche traite un fichier d’entrée à l’aide d’un paramètre command_line pour spécifier une application ou un script.

Le script suivant traite les objets d’entrée resource_files en exécutant la commande d’interpréteur de commandes Bash cat pour afficher les fichiers texte. L’application utilise ensuite la méthode task.add_collection pour ajouter chaque tâche au travail, ce 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 de la tâche pour s’assurer que les tâches s’achèvent. Lorsque chaque tâche est exécutée correctement, la sortie de la commande de tâche est écrite 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 créé et vous donne la possibilité de supprimer le travail et le pool Azure 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.

Quand 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 concerné, 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, des nœuds, un travail et des tâches Batch. 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 pour parcourir une charge de travail parallèle avec une application réelle, accédez au tutoriel Python Batch.

Traitement d’une charge de travail parallèle avec Python

Partager via