Guida introduttiva: Usare Python per creare un pool di Batch ed eseguire un processo

Questa guida introduttiva illustra come iniziare a usare Azure Batch eseguendo un'app che usa le librerie di Azure Batch per Python. L'app Python:

Dopo aver completato questa guida introduttiva, si conoscono i concetti chiave del servizio Batch e si è pronti per l'uso di Batch con carichi di lavoro su larga scala più realistici.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Se non si dispone di un account, crearne uno gratuitamente.

• Un account Batch con un account Archiviazione di Azure collegato. È possibile creare gli account usando uno dei metodi seguenti: l'interfaccia della riga di comando di Azure portale di Azure | Modello arm | Di | Azure | Terraform.

• Python versione 3.6 o successiva, che include la gestione pacchetti pip .

Eseguire l'app

Per completare questa guida introduttiva, scaricare o clonare l'app Python, specificare i valori dell'account, eseguire l'app e verificare l'output.

Scaricare o clonare l'app

1. Scaricare o clonare l'app di avvio rapido python di Azure Batch da GitHub. Usare il comando seguente per clonare il repository dell'app con un client Git:

   git clone https://github.com/Azure-Samples/batch-python-quickstart.git
   

2. Passare alla cartella batch-python-quickstart/src e installare i pacchetti necessari usando pip.

   pip install -r requirements.txt
   

Specificare le informazioni sull'account

L'app Python deve usare i nomi di account Batch e Archiviazione, i valori delle chiavi dell'account e l'endpoint dell'account Batch. È possibile ottenere queste informazioni dai portale di Azure, dalle API di Azure o dagli strumenti da riga di comando.

Per ottenere le informazioni sull'account dal portale di Azure:

1. Nella barra di Ricerca di Azure cercare e selezionare il nome dell'account Batch.
2. Nella pagina Account Batch selezionare Chiavi nel riquadro di spostamento a sinistra.
3. Nella pagina Chiavi copiare i valori seguenti:

• Account Batch
• Endpoint dell'account
• Chiave di accesso primaria
• Nome account di archiviazione
• Key1

Nell'app Python scaricata modificare le stringhe seguenti nel file config.py per specificare i valori copiati.

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>'

Eseguire l'app e visualizzare l'output

Eseguire l'app per visualizzare il flusso di lavoro batch in azione.

python python_quickstart_client.py

Il tempo di esecuzione tipico è di circa tre minuti. La configurazione iniziale del nodo del pool richiede più tempo.

L'app restituisce un output simile all'esempio seguente:

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

Si verifica una pausa durante Monitoring all tasks for 'Completed' state, timeout in 00:30:00... l'avvio dei nodi di calcolo del pool. Durante la creazione delle attività, Batch li accoda per l'esecuzione nel pool. Non appena è disponibile il primo nodo di calcolo, la prima attività viene eseguita nel nodo. È possibile monitorare lo stato del nodo, dell'attività e del processo dalla pagina dell'account Batch nel portale di Azure.

Al termine di ogni attività, viene visualizzato un output simile all'esempio seguente:

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

Esaminare il codice

Esaminare il codice per comprendere i passaggi descritti nell'avvio rapido per Python di Azure Batch.

Creare client di servizio e caricare file di risorse

1. L'app crea un oggetto BlobServiceClient per interagire con l'account Archiviazione.

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

2. L'app usa il blob_service_client riferimento per creare un contenitore nell'account Archiviazione e caricare i file di dati nel contenitore. I file nel contenitore di archiviazione sono definiti come oggetti ResourceFile di Batch che successivamente Batch può scaricare nei nodi di calcolo.

   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]
   

3. L'app crea un oggetto BatchServiceClient per creare e gestire pool, processi e attività nell'account Batch. Il client Batch usa l'autenticazione con chiave condivisa. Batch supporta anche l'autenticazione di Microsoft Entra.

   credentials = SharedKeyCredentials(config.BATCH_ACCOUNT_NAME,
           config.BATCH_ACCOUNT_KEY)
   
       batch_client = BatchServiceClient(
           credentials,
           batch_url=config.BATCH_ACCOUNT_URL)
   

Creare un pool di nodi di calcolo

Per creare un pool di Batch, l'app usa la classe PoolAddParameter per impostare il numero di nodi, le dimensioni della macchina virtuale e la configurazione del pool. L'oggetto VirtualMachineConfiguration seguente specifica un oggetto ImageReference a un'immagine ubuntu Server 20.04 LTS di Azure Marketplace. Batch supporta un'ampia gamma di immagini Linux e Windows Server Marketplace e supporta anche immagini di macchine virtuali personalizzate.

Le POOL_NODE_COUNT costanti e POOL_VM_SIZE sono definite. L'app crea un pool di due dimensioni Standard_DS1_v2 nodi. Questa dimensione offre un buon equilibrio tra prestazioni e costi per questa guida introduttiva.

Il metodo pool.add invia il pool al servizio 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)

Creare un processo Batch

Un processo Batch è un gruppo logico di una o più attività. Il processo include impostazioni comuni alle attività, ad esempio priorità e pool in cui eseguire le attività.

L'app usa la classe JobAddParameter per creare un processo nel pool. Il metodo job.add aggiunge il processo all'account Batch specificato. Inizialmente il processo è privo di attività.

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

batch_service_client.job.add(job)

Creare attività

Batch offre diversi modi per distribuire app e script nei nodi di calcolo. Questa app crea un elenco di oggetti attività usando la classe TaskAddParameter . Ogni attività elabora un file di input usando un command_line parametro per specificare un'app o uno script.

Lo script seguente elabora gli oggetti di input resource_files eseguendo il comando della shell cat Bash per visualizzare i file di testo. L'app usa quindi il metodo task.add_collection per aggiungere ogni attività al processo, che accoda le attività da eseguire nei nodi di calcolo.

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)

Visualizzare l'output dell'attività

L'app esegue il monitoraggio dello stato dell'attività affinché venga completata. Quando ogni attività viene eseguita correttamente, l'output del comando attività scrive nel file stdout.txt . L'app visualizza quindi il file stdout.txt per ogni attività completata.

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)

Pulire le risorse

L'app elimina automaticamente il contenitore di archiviazione creato e consente di scegliere se eliminare il processo e il pool di Batch. I pool e i nodi comportano addebiti durante l'esecuzione dei nodi, anche se non eseguono processi. Se il pool non è più necessario, eliminarlo.

Quando le risorse di Batch non sono più necessarie, è possibile eliminare il gruppo di risorse che li contiene. Nella portale di Azure selezionare Elimina gruppo di risorse nella parte superiore della pagina del gruppo di risorse. Nella schermata Elimina un gruppo di risorse immettere il nome del gruppo di risorse e quindi selezionare Elimina.

Passaggi successivi

In questa guida introduttiva è stata eseguita un'app che usa l'API Python di Batch per creare un pool, nodi, processi e attività di Batch. Il processo caricava i file di risorse in un contenitore di archiviazione, eseguiva attività sui nodi e visualizzava l'output dei nodi.

Dopo aver compreso i concetti chiave del servizio Batch, è possibile usare Batch con carichi di lavoro più realistici e su larga scala. Per altre informazioni su Azure Batch e per un carico di lavoro parallelo con un'applicazione reale, continuare con l'esercitazione su Batch Python.