Agende cargas de trabalho de GPU e componha tarefas

Importante

Esse recurso está em Visualização Pública. Para usá-lo, um administrador do espaço de trabalho deve ativar a prévia do AI Runtime na página Previews. Consulte Gerenciar visualizações do Azure Databricks.

Use Pacotes de Automação Declarativa para agendar uma carga de trabalho de GPU do AI Runtime e combiná-la com outros trabalhos, como a preparação de dados upstream. Defina a carga de trabalho e seu cronograma no YAML, depois implante tudo como um job. Para um pipeline de treinamento, execute pré-processamento na computação da CPU e comece o treinamento da GPU depois que os dados estiverem prontos.

Este guia começa com uma carga de trabalho que imprime "Hello world", depois constrói um pipeline de pré-processamento e treinamento programados. Se você já tem um arquivo YAML de carga de trabalho do AI Runtime, consulte Converter uma carga de trabalho do AI Runtime em um pacote.

Como funciona

Um bundle contém seu código e uma databricks.yml configuração.
Um job agrupa as tarefas e define quando elas são executadas.
Um ai_runtime_task executa seu comando em computação GPU serverless.

O depends_on campo conecta as tarefas a um grafo acíclico direcionado (DAG), e o schedule campo agenda seu trabalho para rodar em cadência.

databricks bundle deploy Faz upload do código e cria ou atualiza o job. databricks bundle run inicia uma execução de trabalho imediatamente. Em cada execução, o AI Runtime provisiona o cálculo da GPU, executa seu comando e registra a execução no experimento MLflow nomeado.

Requirements

Um workspace em uma região com suporte. Veja Requisitos.
A CLI do Databricks mais recente, autenticada em seu workspace. Atualize uma instalação existente antes de usar esses exemplos.
Para o exemplo de pré-processamento, um volume existente do Catálogo do Unity. A identidade de execução do trabalho precisa dos privilégios USE CATALOG, USE SCHEMA, READ VOLUME e WRITE VOLUME para esse volume. Consulte Privileges para volumes do Unity Catalog.

Exemplo "Olá, mundo!" com `ai_runtime_task`

Este exemplo executa um comando shell em uma GPU A10.

Crie um diretório para o bundle. Nesse diretório, crie command.sh com o seguinte conteúdo:
```
#!/usr/bin/env bash
set -euo pipefail
echo "Hello world"
```

Crie databricks.yml no mesmo diretório:

bundle:
  name: hello-ai-runtime

resources:
  jobs:
    hello:
      name: hello-ai-runtime
      tasks:
        - task_key: hello
          environment_key: default
          ai_runtime_task:
            experiment: hello-ai-runtime
            deployments:
              - command_path: ${workspace.file_path}/command.sh
                compute:
                  accelerator_type: GPU_1xA10
                  accelerator_count: 1
      environments:
        - environment_key: default
          spec:
            environment_version: '6'

targets:
  dev:
    mode: development
    default: true

A partir do diretório do bundle, valide, implante e execute o job:

databricks bundle validate --target dev
databricks bundle deploy --target dev
databricks bundle run hello --target dev

Abra a URL de execução impressa pela CLI e visualize a saída da tarefa hello. Ele contém Hello world. O run também aparece no experimento hello-ai-runtime MLflow.

Exemplo mais complexo: Agende um pipeline de pré-processamento e treinamento

Este exemplo prepara um pequeno conjunto de dados sobre computação de CPU e depois treina um modelo linear em uma GPU A10. Ambas as tarefas usam o mesmo arquivo de volume para passar dados entre elas. O trabalho está programado para as 09:00 UTC diariamente, com o cronograma pausado até você testá-lo.

Criar o projeto

Crie um diretório separado com o seguinte layout:

scheduled-training/
├── databricks.yml
├── prep.py
├── command.sh
└── src/
    └── train.py

Escreva prep.py com o seguinte conteúdo. Substitua <catalog>, <schema>, e <volume> pelos nomes do seu volume. Este notebook de origem normaliza os valores de entrada e grava os dados preparados no volume:

# Databricks notebook source
import json
from pathlib import Path

data_path = Path("/Volumes/<catalog>/<schema>/<volume>/scheduled-training/data.json")
inputs = [value / 10 for value in range(10)]
data = {"x": inputs, "y": [2 * value + 1 for value in inputs]}
data_path.parent.mkdir(parents=True, exist_ok=True)
data_path.write_text(json.dumps(data))
print(f"Prepared {len(inputs)} rows at {data_path}")

Escreva src/train.py com o seguinte conteúdo. Use o mesmo caminho de volume que em prep.py:

import json
from pathlib import Path

import torch

data_path = Path("/Volumes/<catalog>/<schema>/<volume>/scheduled-training/data.json")
data = json.loads(data_path.read_text())
x = torch.tensor(data["x"], device="cuda").reshape(-1, 1)
y = torch.tensor(data["y"], device="cuda").reshape(-1, 1)
model = torch.nn.Linear(1, 1).to("cuda")
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

for _ in range(200):
    optimizer.zero_grad()
    loss = torch.nn.functional.mse_loss(model(x), y)
    loss.backward()
    optimizer.step()

print(f"Trained on {x.device}: loss={loss.item():.4f}")

Crie command.sh para rodar o código de treinamento. O pacote abaixo empacota src/, então CODE_SOURCE_PATH aponta para o diretório extraído src :
```
#!/usr/bin/env bash
set -euo pipefail
cd "$CODE_SOURCE_PATH"
python train.py
```

Escreva databricks.yml com o seguinte conteúdo. Os pacotes src/ para a tarefa de GPU. O prep notebook roda com computação sem servidor e depends_on só começa train após prep ser bem-sucedido. max_concurrent_runs: 1 impede que as execuções deste trabalho sobrescrevam o arquivo de entrada umas das outras:

bundle:
  name: scheduled-training

artifacts:
  code:
    type: tgz
    path: .
    include: [src]
    files:
      - source: ./dist/code.tgz

resources:
  jobs:
    train_pipeline:
      name: scheduled-training
      max_concurrent_runs: 1
      schedule:
        quartz_cron_expression: '0 0 9 * * ?'
        timezone_id: UTC
        pause_status: PAUSED
      tasks:
        - task_key: prep
          notebook_task:
            notebook_path: ./prep.py
        - task_key: train
          depends_on:
            - task_key: prep
          environment_key: training
          ai_runtime_task:
            experiment: scheduled-training
            code_source_path: ./dist/code.tgz
            deployments:
              - command_path: ${workspace.file_path}/command.sh
                compute:
                  accelerator_type: GPU_1xA10
                  accelerator_count: 1
      environments:
        - environment_key: training
          spec:
            environment_version: '6'
            dependencies:
              - torch

targets:
  dev:
    mode: development
    default: true

Teste e habilite o agendamento

A partir de scheduled-training/, implante o pacote e inicie uma execução manual:

databricks bundle validate --target dev
databricks bundle deploy --target dev
databricks bundle run train_pipeline --target dev

Abra a URL da execução impressa pela CLI. Confirme que prep seja concluído com êxito antes que train comece. A saída prep relata 10 linhas preparadas, e a saída train relata Trained on cuda:0 e a perda.
Em databricks.yml, altere o pause_status do agendamento de PAUSED para UNPAUSED. O bloco de cronograma agora é:
```
schedule:
  quartz_cron_expression: '0 0 9 * * ?'
  timezone_id: UTC
  pause_status: UNPAUSED
```
Implante a mudança para ativar a rotina diária:
```
databricks bundle deploy --target dev
```
Definir pause_status: UNPAUSED explicitamente permite esse agendamento mesmo para um destino de desenvolvimento. Em Trabalhos & Pipelines, abra o trabalho implantado e confirme se o agendamento está ativo para 09:00 UTC. Consulte Execução de trabalhos agendados.

Para pausar as execuções agendadas, configure pause_status: PAUSED e implante novamente. Para remover o job de exemplo e os arquivos carregados pelo bundle, execute o seguinte a partir do diretório bundle:

databricks bundle destroy --target dev

Os dados preparados no seu volume permanecem. Exclua o scheduled-training diretório de dados quando não precisar mais dele.

Recursos adicionais

Converta um YAML de carga de trabalho existente do AI Runtime em um bundle. Consulte Converter uma carga de trabalho do AI Runtime em um pacote.
Configure o empacotamento de código, computação, ambientes e parâmetros de tarefa. Veja Configurar tarefas do pacote de tempo de execução da IA.
Agende um notebook existente na GPU. Consulte Agendar com a API Jobs e Pacotes de Automação Declarativa.
Rastreie as execuções de treinamento. Veja Rastreamento de experimentos e observabilidade.
Modelo do ponto de verificação, otimizador e estado do pipeline de dados. Veja Como melhorar o desempenho e a resiliência do treinamento no AI Runtime.

Comentários

Esta página foi útil?

Última atualização em 2026-10-09

Agende cargas de trabalho de GPU e componha tarefas

Como funciona

Requirements

Exemplo "Olá, mundo!" com ai_runtime_task

Exemplo mais complexo: Agende um pipeline de pré-processamento e treinamento

Criar o projeto

Teste e habilite o agendamento

Recursos adicionais

Comentários

Recursos adicionais

Exemplo "Olá, mundo!" com `ai_runtime_task`