Condividi tramite

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:

  • Carica diversi file di dati di input in un contenitore BLOB di Archiviazione di Azure da usare per l'elaborazione di attività batch.
  • Crea un pool di due macchine virtuali (VM) o nodi di calcolo che eseguono ubuntu 22.04 LTS OS.
  • Crea un processo e tre attività da eseguire nei nodi. Ogni attività elabora uno dei file di input usando una riga di comando della shell Bash.
  • Visualizza i file di output restituiti dalle attività.

Dopo aver completato questo avvio rapido, si comprendono i concetti chiave del servizio Batch e si è pronti per usare Batch con carichi di lavoro più realistici su larga scala.

Prerequisiti

Eseguire l'app

Per completare questa guida rapida, scaricare o clonare l'applicazione Python, inserire i valori dell'account, eseguire l'applicazione e controllare l'output.

Scaricare o clonare l'app

  1. Scaricare o clonare l'app Guida introduttiva di Azure Batch Python 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 degli account Batch e di archiviazione, i valori delle chiavi degli account e l'endpoint dell'account Batch. È possibile ottenere queste informazioni dal 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 dal menu di navigazione a sinistra.
  3. Nella pagina Chiavi copiare i valori seguenti:
  • Account Batch
  • Endpoint dell'account
  • Chiave di accesso primaria
  • Nome dell'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>'

Importante

L'esposizione delle chiavi dell'account nelle sorgenti dell'app non è consigliata per un utilizzo in produzione. È consigliabile limitare l'accesso alle credenziali e farvi riferimento nel codice usando variabili o un file di configurazione. È consigliabile archiviare le chiavi dell'account Batch e dell'account di Archiviazione in Azure Key Vault.

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 nel punto Monitoring all tasks for 'Completed' state, timeout in 00:30:00... durante 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 di nodo, attività e 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 di 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 di 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' ImageReference a un'immagine di Ubuntu Server 22.04 LTS del Marketplace di Azure. Batch supporta un'ampia gamma di immagini Linux e Windows Server Marketplace e supporta anche immagini di macchine virtuali personalizzate.

Le costanti POOL_NODE_COUNT 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="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)

Creare un processo Batch

Un processo Batch è un raggruppamento logico di una o più attività. Il processo include le impostazioni comuni per le attività, ad esempio la priorità e il pool nel quale eseguire le attività.

L'applica utilizza la classe JobAddParameter per creare un job 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 monitora lo stato dell'attività per assicurarsi che le attività vengano completate. 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 eliminare il pool e il processo 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. Nel 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, i nodi, un processo e le 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 approfondire Azure Batch ed eseguire un carico di lavoro parallelo con un'applicazione reale, seguire l'esercitazione su Batch Python.

Elaborare un carico di lavoro parallelo con Python

  • Last updated on