Integração e entrega contínuas no Azure Databricks por meio do Azure DevOps

Artigo
08/29/2024

Observação

Este artigo aborda o Azure DevOps, que não é fornecido nem tem suporte do Databricks. Para entrar em contato com o provedor, confira o Suporte do Azure DevOps Services.

Este artigo orienta você pela configuração da automação do Azure DevOps para seu código e artefatos que funcionam com o Azure Databricks. Especificamente, você configurará um fluxo de trabalho de CI/CD (integração e entrega contínua) para se conectar a um repositório Git, executar trabalhos usando o Azure Pipelines para criar e testar uma roda do Python (*.whl) e implantá-la para uso nos notebooks do Databricks.

Fluxo de trabalho de desenvolvimento de CI/CD

A Databricks sugere o seguinte fluxo de trabalho para o desenvolvimento de CI/CD com o Azure DevOps:

Crie um repositório ou use um repositório existente com seu provedor Git de terceiros.
Conecte seu computador de desenvolvimento local no mesmo repositório de terceiros. Para obter instruções, consulte a documentação do seu provedor Git de terceiros.
Efetue pull de todos os artefatos atualizados existentes (como notebooks, arquivos de código e scripts de compilação) em seu computador de desenvolvimento local a partir do repositório de terceiros.
Conforme necessário, crie, atualize e teste artefatos no seu computador de desenvolvimento local. Em seguida, efetue push de todos os artefatos novos e alterados de seu computador de desenvolvimento local para o repositório de terceiros. Para obter instruções, consulte a documentação do seu provedor Git de terceiros.
Repita as etapas 3 e 4 conforme necessário.
Use o Azure DevOps periodicamente como uma abordagem integrada para efetuar automaticamente a extração de artefatos do seu repositório de terceiros, criar, testar e executar códigos em seu workspace do Azure Databricks e relatar os resultados dos testes e execuções. Embora você possa executar o Azure DevOps manualmente, em implementações reais, você deve instruir seu provedor Git de terceiros a executar o Azure DevOps toda vez que ocorrer um evento específico, como um pull request de repositório.

Há várias ferramentas de CI/CD que você pode usar para gerenciar e executar seu pipeline. Este artigo ilustra como usar o Azure DevOps. A CI/CD é um padrão de design, portanto, as etapas e os estágios descritos neste exemplo do artigo devem ser transferidos com algumas alterações para a linguagem de definição de pipeline de cada ferramenta. Além disso, grande parte do código nesse pipeline de exemplo é um código Python padrão que pode ser invocado em outras ferramentas.

Dica

Para obter informações sobre como usar o Jenkins com o Azure Databricks em vez do Azure DevOps, consulte CI/CD com Jenkins no Azure Databricks.

O restante deste artigo descreve um par de pipelines de exemplo no Azure DevOps que você pode adaptar às suas próprias necessidades para o Azure Databricks.

Sobre o exemplo

O exemplo deste artigo usa dois pipelines para coletar, implantar e executar exemplos de código Python e notebooks Python armazenados em um repositório Git remoto.

O primeiro pipeline, conhecido como pipeline de build, prepara artefatos de build para o segundo pipeline, conhecido como pipeline de lançamento. A separação do pipeline de build do pipeline de lançamento permite que você crie um artefato de build sem implantá-lo ou implante simultaneamente artefatos de várias builds. Para construir os pipelines de build e lançamento:

Crie uma máquina virtual do Azure para o pipeline de build.
Copie os arquivos do repositório Git para a máquina virtual.
Crie um arquivo gzip’ed tar que contém o código Python, notebooks Python e arquivos de configurações de build, implantação e execução relacionados.
Copie o arquivo tar gzip’ed como um arquivo zip em um local para o pipeline de lançamento acessar.
Crie outra máquina virtual do Azure para o pipeline de lançamento.
Obtenha o arquivo zip do local do pipeline de build e, em seguida, descompacte o arquivo zip para obter o código Python, notebooks Python e arquivos de configurações de build, implantação e execução relacionados.
Implante o código Python, os notebooks Python e os arquivos de configuração de build, implantação e execução relacionados ao workspace remoto do Azure Databricks.
Crie os arquivos de código de componente da biblioteca de roda do Python em um arquivo de roda do Python.
Execute testes de unidade no código do componente para verificar a lógica no arquivo de roda do Python.
Execute os notebooks Python, um dos quais chama a funcionalidade do arquivo de roda do Python.

Sobre a CLI do Databricks

O exemplo deste artigo demonstra como usar a CLI do Databricks em um modo não interativo em um pipeline. O exemplo de pipeline deste artigo implanta códigos, cria uma biblioteca e executa notebooks no seu workspace do Azure Databricks.

Se estiver usando a CLI do Databricks no seu pipeline sem implementar o código de exemplo, a biblioteca e os notebooks deste artigo, siga estas etapas:

Prepare seu workspace do Azure Databricks para usar a autenticação OAuth máquina-a-máquina (M2M) para autenticar uma entidade de serviço. Antes de iniciar, confirme que você tem uma entidade de serviço do Microsoft Entra ID com um segredo OAuth do Azure Databricks. Consulte Autenticar o acesso ao Azure Databricks com uma entidade de serviço usando OAuth (OAuth M2M).
Instale a CLI do Databricks em seu pipeline. Para fazer isso, adicione uma tarefa Script Bash no seu pipeline que executa o seguinte script:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
```
Para adicionar uma tarefa Script Bash no seu pipeline, consulte a Etapa 3.6. Instale a CLI do Databricks e as ferramentas de criação do wheel do Python.
Configure seu pipeline para permitir que a CLI do Databricks instalada autentique sua entidade de serviço com seu espaço de trabalho. Para isso, confira a Etapa 3.1: definir variáveis de ambiente para o pipeline de lançamento.
Adicione mais tarefas do Script Bash no seu pipeline, conforme necessário, para executar os comandos da CLI do Databricks. Consulte Comandos da CLI do Databricks.

Antes de começar

Para usar o exemplo deste artigo, você deve ter:

Um projeto existente do Azure DevOps. Se ainda não tiver um projeto, criar um projeto no Azure DevOps.
Um repositório existente com um provedor Git com suporte do Azure DevOps. Você adicionará o código de exemplo do Python, o notebook Python de exemplo e os arquivos de configurações de versão relacionados a esse repositório. Se você ainda não tiver um repositório, crie um seguindo as instruções do provedor Git. Em seguida, conecte seu projeto do Azure DevOps a esse repositório, se você já não o tiver feito. Para obter instruções, siga os links em Repositórios de origem com suporte.
O exemplo deste artigo utiliza a autenticação OAuth máquina a máquina (M2M) para autenticar uma entidade de serviço do Microsoft Entra ID em um workspace do Azure Databricks. Você deve ter uma entidade de serviço do Microsoft Entra ID com um segredo OAuth do Azure Databricks para essa entidade de serviço. Consulte Autenticar o acesso ao Azure Databricks com uma entidade de serviço usando OAuth (OAuth M2M).

Etapa 1: adicionar os arquivos do exemplo ao seu repositório

Nesta etapa, no repositório com seu provedor Git de terceiros, você adiciona todos os arquivos de exemplo deste artigo que seus pipelines do Azure DevOps criam, implantam e executam em seu workspace remoto do Azure Databricks.

Etapa 1.1: adicionar os arquivos de componentes do pacote wheel do Python

No exemplo deste artigo, seus pipelines do Azure DevOps criam e testam a unidade de um arquivo wheel do Python. Em seguida, um notebook do Azure Databricks chama a funcionalidade do arquivo wheel do Python criado.

Para definir a lógica e os testes de unidade para o arquivo wheel do Python no qual os notebooks são executados, na raiz do repositório, crie dois arquivos chamados addcol.py e test_addcol.py e adicione-os a uma estrutura de pastas chamada python/dabdemo/dabdemo em uma pasta Libraries, visualizada da seguinte forma:

└── Libraries
      └── python
            └── dabdemo
                  └── dabdemo
                        ├── addcol.py
                        └── test_addcol.py

O arquivo addcol.py contém uma função de biblioteca que é compilada posteriormente em um arquivo wheel do Python e depois instalada em clusters do Azure Databricks. É uma função simples que adiciona uma nova coluna, populada por um literal, a um DataFrame do Apache Spark:

# Filename: addcol.py
import pyspark.sql.functions as F

def with_status(df):
  return df.withColumn("status", F.lit("checked"))

O arquivo test_addcol.py contém testes para passar um objeto DataFrame simulado para a função with_status, definida em addcol.py. O resultado é então comparado a um objeto do DataFrame que contém os valores esperados. Se os valores corresponderem, o teste será aprovado:

# Filename: test_addcol.py
import pytest
from pyspark.sql import SparkSession
from dabdemo.addcol import *

class TestAppendCol(object):

  def test_with_status(self):
    spark = SparkSession.builder.getOrCreate()

    source_data = [
      ("paula", "white", "paula.white@example.com"),
      ("john", "baer", "john.baer@example.com")
    ]

    source_df = spark.createDataFrame(
      source_data,
      ["first_name", "last_name", "email"]
    )

    actual_df = with_status(source_df)

    expected_data = [
      ("paula", "white", "paula.white@example.com", "checked"),
      ("john", "baer", "john.baer@example.com", "checked")
    ]
    expected_df = spark.createDataFrame(
      expected_data,
      ["first_name", "last_name", "email", "status"]
    )

    assert(expected_df.collect() == actual_df.collect())

Para permitir que a CLI do Databricks empacote corretamente esse código de biblioteca em um arquivo wheel do Python, crie dois arquivos chamados __init__.py e __main__.py na mesma pasta que os dois arquivos anteriores. Crie também um arquivo denominado setup.py na pasta python/dabdemo, visualizado da seguinte forma:

└── Libraries
      └── python
            └── dabdemo
                  ├── dabdemo
                  │     ├── __init__.py
                  │     ├── __main__.py
                  │     ├── addcol.py
                  │     └── test_addcol.py
                  └── setup.py

O arquivo __init__.py contém o número da versão e o autor da biblioteca. Substitua <my-author-name> por seu nome:

# Filename: __init__.py
__version__ = '0.0.1'
__author__ = '<my-author-name>'

import sys, os

sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))

O arquivo __main__.py contém o ponto de entrada da biblioteca:

# Filename: __main__.py
import sys, os

sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))

from addcol import *

def main():
  pass

if __name__ == "__main__":
  main()

O arquivo setup.py contém configurações adicionais para a compilação da biblioteca em um arquivo wheel do Python. Substitua <my-url>, <my-author-name>@<my-organization> e <my-package-description> por valores válidos:

# Filename: setup.py
from setuptools import setup, find_packages

import dabdemo

setup(
  name = "dabdemo",
  version = dabdemo.__version__,
  author = dabdemo.__author__,
  url = "https://<my-url>",
  author_email = "<my-author-name>@<my-organization>",
  description = "<my-package-description>",
  packages = find_packages(include = ["dabdemo"]),
  entry_points={"group_1": "run=dabdemo.__main__:main"},
  install_requires = ["setuptools"]
)

Etapa 1.2: Adicionar um notebook de teste de unidade ao arquivo wheel do Python

Posteriormente, a CLI do Databricks executa um trabalho de notebook. Esse trabalho executa um notebook Python com o nome de arquivo run_unit_tests.py. Esse notebook executa pytest contra a logica da biblioteca do pacote wheel do Python.

Para executar os testes de unidade do exemplo deste artigo, adicione à raiz do seu repositório um arquivo de notebook denominado run_unit_tests.py com o seguinte conteúdo:

# Databricks notebook source

# COMMAND ----------

# MAGIC %sh
# MAGIC
# MAGIC mkdir -p "/Workspace${WORKSPACEBUNDLEPATH}/Validation/reports/junit/test-reports"

# COMMAND ----------

# Prepare to run pytest.
import sys, pytest, os

# Skip writing pyc files on a readonly filesystem.
sys.dont_write_bytecode = True

# Run pytest.
retcode = pytest.main(["--junit-xml", f"/Workspace{os.getenv('WORKSPACEBUNDLEPATH')}/Validation/reports/junit/test-reports/TEST-libout.xml",
                      f"/Workspace{os.getenv('WORKSPACEBUNDLEPATH')}/files/Libraries/python/dabdemo/dabdemo/"])

# Fail the cell execution if there are any test failures.
assert retcode == 0, "The pytest invocation failed. See the log for details."

Etapa 1.3: Adicionar um notebook que chame o arquivo wheel do Python

Mais tarde, a CLI do Databricks executa outro trabalho de notebook. Esse notebook cria um objeto DataFrame, passa-o para a função with_status da biblioteca de pacotes wheel do Python, imprime o resultado e relata os resultados da execução do trabalho. Crie na raiz de seu repositório um arquivo de notebook denominado dabdemo_notebook.py com o seguinte conteúdo:

# Databricks notebook source

# COMMAND ----------

# Restart Python after installing the Python wheel.
dbutils.library.restartPython()

# COMMAND ----------

from dabdemo.addcol import with_status

df = (spark.createDataFrame(
  schema = ["first_name", "last_name", "email"],
  data = [
    ("paula", "white", "paula.white@example.com"),
    ("john", "baer", "john.baer@example.com")
  ]
))

new_df = with_status(df)

display(new_df)

# Expected output:
#
# +------------+-----------+-------------------------+---------+
# │ first_name │ last_name │ email                   │ status  │
# +============+===========+=========================+=========+
# │ paula      │ white     │ paula.white@example.com │ checked │
# +------------+-----------+-------------------------+---------+
# │ john       │ baer      │ john.baer@example.com   │ checked │
# +------------+-----------+-------------------------+---------+

Etapa 1.4: Criar a configuração do pacote

O exemplo deste artigo usa os Pacotes de Ativos do Databricks para definir as configurações e os comportamentos para criação, implantação e execução do arquivo wheel do Python, os dois notebooks e o arquivo de código Python. Os Pacotes de Ativos do Databricks, conhecidos simplesmente como pacotes, possibilitam expressar dados completos, análises e projetos de ML como uma coleção de arquivos de origem. Confira O que são Pacotes de Ativos do Databricks?.

Para configurar o pacote para o exemplo deste artigo, crie na raiz do seu repositório um arquivo denominado databricks.yml. Neste arquivo de exemplo databricks.yml, substitua os seguintes espaços reservados:

Substitua <bundle-name> por um nome programático exclusivo para o pacote. Por exemplo, azure-devops-demo.
Substitua <job-prefix-name> por alguma cadeia de caracteres para ajudar a identificar exclusivamente os trabalhos criados no seu workspace do Azure Databricks neste exemplo. Por exemplo, azure-devops-demo.
Substitua <spark-version-id> pelo ID de versão do Databricks Runtime para seus clusters de trabalho, por exemplo 13.3.x-scala2.12.
Substitua <cluster-node-type-id> pela ID do tipo de nó do cluster para seus clusters de trabalho, por exemplo, Standard_DS3_v2.
Observe que dev no mapeamento targets especifica o host e os comportamentos de implantação relacionados. Em implementações no mundo real, você pode dar a esse destino um nome diferente em seus próprios pacotes.

Aqui está o conteúdo do arquivo databricks.yml deste exemplo:

# Filename: databricks.yml
bundle:
  name: <bundle-name>

variables:
  job_prefix:
    description: A unifying prefix for this bundle's job and task names.
    default: <job-prefix-name>
  spark_version:
    description: The cluster's Spark version ID.
    default: <spark-version-id>
  node_type_id:
    description: The cluster's node type ID.
    default: <cluster-node-type-id>

artifacts:
  dabdemo-wheel:
    type: whl
    path: ./Libraries/python/dabdemo

resources:
  jobs:
    run-unit-tests:
      name: ${var.job_prefix}-run-unit-tests
      tasks:
        - task_key: ${var.job_prefix}-run-unit-tests-task
          new_cluster:
            spark_version: ${var.spark_version}
            node_type_id: ${var.node_type_id}
            num_workers: 1
            spark_env_vars:
              WORKSPACEBUNDLEPATH: ${workspace.root_path}
          notebook_task:
            notebook_path: ./run_unit_tests.py
            source: WORKSPACE
          libraries:
            - pypi:
                package: pytest
    run-dabdemo-notebook:
      name: ${var.job_prefix}-run-dabdemo-notebook
      tasks:
        - task_key: ${var.job_prefix}-run-dabdemo-notebook-task
          new_cluster:
            spark_version: ${var.spark_version}
            node_type_id: ${var.node_type_id}
            num_workers: 1
            spark_env_vars:
              WORKSPACEBUNDLEPATH: ${workspace.root_path}
          notebook_task:
            notebook_path: ./dabdemo_notebook.py
            source: WORKSPACE
          libraries:
            - whl: "/Workspace${workspace.root_path}/files/Libraries/python/dabdemo/dist/dabdemo-0.0.1-py3-none-any.whl"

targets:
  dev:
    mode: development

Para obter mais informações sobre a sintaxe do arquivo databricks.yml, confira Configurações do Pacote de Ativos do Databricks.

Etapa 2: definir o pipeline de build

O Azure DevOps fornece uma interface de usuário hospedada na nuvem para definir as fases no seu pipeline de CI/CD utilizando YAML. Para obter mais informações sobre o Azure DevOps e os pipelines, consulte a documentação do Azure DevOps.

Nesta etapa, você deve usar a marcação YAML para definir o pipeline de build, que cria um artefato de implantação. Para implantar o código em um workspace do Azure Databricks, especifique o artefato de compilação desse pipeline como entrada em um pipeline de lançamento. Você definirá esse pipeline de lançamento posteriormente.

Para executar pipelines de build, o Azure DevOps fornece agentes de execução sob demanda hospedados na nuvem que dão suporte a implantações no Kubernetes, VMs, Azure Functions, Aplicativos Web do Azure e muitos outros destinos. Neste exemplo, você deve usar um agente sob demanda para automatizar a criação do artefato de implantação.

Defina o pipeline de build de exemplo deste artigo da seguinte maneira:

Entre no Azure DevOps e clique no link Entrar para abrir seu projeto do Azure DevOps.

Observação

Se o Portal do Microsoft Azure for exibido em vez do seu projeto do Azure DevOps, clique em Mais serviços > Organizações do Azure DevOps > Minhas organizações do Azure DevOps e, em seguida, abra seu projeto do Azure DevOps.
Clique em Pipelines na barra lateral e clique em Pipelines no menu Pipelines.
Clique no botão Novo Pipeline e siga as instruções na tela. (Se você já tiver pipelines, clique em Criar Pipeline.) Ao final dessas instruções, o editor de pipeline será aberto. Aqui você define o script do pipeline de build no arquivo azure-pipelines.yml que aparece. Se o editor do pipeline não estiver visível no final das instruções, selecione o nome do pipeline de build e clique em Editar.

Você pode usar o seletor do GIT branch para personalizar o processo de build de cada branch no seu repositório Git. É uma prática recomendada de CI/CD não fazer o trabalho de produção diretamente na ramificação main do seu repositório. Este exemplo pressupõe a existência de uma ramificação denominada release no repositório que deverá ser utilizada em vez de main.

O script do pipeline de build azure-pipelines.yml é armazenado por padrão na raiz do repositório Git remoto que você associa ao pipeline.

Substitua o conteúdo inicial do arquivo azure-pipelines.yml do pipeline pela definição a seguir e clique em Salvar.

# Specify the trigger event to start the build pipeline.
# In this case, new code merged into the release branch initiates a new build.
trigger:
- release

# Specify the operating system for the agent that runs on the Azure virtual
# machine for the build pipeline (known as the build agent). The virtual
# machine image in this example uses the Ubuntu 22.04 virtual machine
# image in the Azure Pipeline agent pool. See
# https://video2.skills-academy.com/azure/devops/pipelines/agents/hosted#software
pool:
  vmImage: ubuntu-22.04

# Download the files from the designated branch in the remote Git repository
# onto the build agent.
steps:
- checkout: self
  persistCredentials: true
  clean: true

# Generate the deployment artifact. To do this, the build agent gathers
# all the new or updated code to be given to the release pipeline,
# including the sample Python code, the Python notebooks,
# the Python wheel library component files, and the related Databricks asset
# bundle settings.
# Use git diff to flag files that were added in the most recent Git merge.
# Then add the files to be used by the release pipeline.
# The implementation in your pipeline will likely be different.
# The objective here is to add all files intended for the current release.
- script: |
    git diff --name-only --diff-filter=AMR HEAD^1 HEAD | xargs -I '{}' cp --parents -r '{}' $(Build.BinariesDirectory)
    mkdir -p $(Build.BinariesDirectory)/Libraries/python/dabdemo/dabdemo
    cp $(Build.Repository.LocalPath)/Libraries/python/dabdemo/dabdemo/*.* $(Build.BinariesDirectory)/Libraries/python/dabdemo/dabdemo
    cp $(Build.Repository.LocalPath)/Libraries/python/dabdemo/setup.py $(Build.BinariesDirectory)/Libraries/python/dabdemo
    cp $(Build.Repository.LocalPath)/*.* $(Build.BinariesDirectory)
  displayName: 'Get Changes'

# Create the deployment artifact and then publish it to the
# artifact repository.
- task: ArchiveFiles@2
  inputs:
    rootFolderOrFile: '$(Build.BinariesDirectory)'
    includeRootFolder: false
    archiveType: 'zip'
    archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
    replaceExistingArchive: true

- task: PublishBuildArtifacts@1
  inputs:
    ArtifactName: 'DatabricksBuild'

Etapa 3: definir o pipeline de lançamento

O pipeline de lançamento implanta os artefatos de compilação do pipeline de build em um ambiente do Azure Databricks. Separar o pipeline de lançamento nesta etapa do pipeline de build nas etapas anteriores permite que você crie uma build sem implantá-la ou implante artefatos de várias builds simultaneamente.

No projeto do Azure DevOps, no menu Pipelines na barra lateral, clique em Lançamentos.
Clique em Novo > Novo pipeline de lançamento. (Se você já tiver pipelines, clique em Criar pipeline.)
Na lateral da tela, há uma lista de modelos em destaque de padrões comuns de implantação. Para este exemplo de pipeline de lançamento, clique em .
Na caixa Artefatos na lateral da tela, clique em . No painel Adicionar um artefato, em Origem (pipeline de build), selecione o pipeline de build criado anteriormente. Clique em Adicionar.
Você pode configurar como o pipeline é disparado clicando em para exibir as opções do gatilho na lateral da tela. Se você quiser que um lançamento seja iniciado automaticamente com base na disponibilidade do artefato de compilação ou após um fluxo de trabalho de solicitação de pull, habilite o gatilho apropriado. Por enquanto, neste exemplo, na última etapa deste artigo, você dispara manualmente o pipeline de build e, em seguida, o pipeline de lançamento.
Clique em Salvar> OK.

Etapa 3.1: definir as variáveis de ambiente para o pipeline de lançamento

O pipeline de lançamento deste exemplo depende das variáveis de ambiente a seguir, que você pode adicionar clicando em Adicionar na seção Variáveis de pipeline da guia Variáveis, com um Escopo de Fase 1:

BUNDLE_TARGET, que deve corresponder ao nome target no seu arquivo databricks.yml. No exemplo deste artigo, será dev.
DATABRICKS_HOST, que representa a URL por workspace do workspace do Azure Databricks, começando com https://, por exemplo https://adb-<workspace-id>.<random-number>.azuredatabricks.net. Não inclua o / à direita após .net.
DATABRICKS_CLIENT_ID, que representa a ID do aplicativo para a entidade de serviço do Microsoft Entra ID.
DATABRICKS_CLIENT_SECRET, que repesenta o segredo do OAuth do Azure Databricks para a entidade de serviço do Microsoft Entra ID.

Etapa 3.2: configurar o agente de versão para o pipeline de lançamento

Clique no link 1 trabalho, 0 tarefa no objeto Estágio 1.
Na guia Tarefas, clique em Trabalho do agente.
Na seção Seleção do agente, para Pool de agentes, selecione Azure Pipelines.
Para Especificação do Agente, selecione o mesmo agente que você especificou anteriormente para o agente de build, neste exemplo ubuntu-22.04.
Clique em Salvar> OK.

Etapa 3.3: definir a versão do Python para o agente de versão

Clique no sinal de adição na seção Trabalho do agente, indicada pela seta vermelha na figura a seguir. Uma lista pesquisável de tarefas disponíveis será exibida. Há também uma guia Marketplace para plug-ins de terceiros que podem ser usados para complementar as tarefas padrão do Azure DevOps. Você adicionará várias tarefas ao agente de versão durante as próximas etapas.
A primeira tarefa adicionada é Usar a versão do Python, localizada na guia Ferramenta. Se você não encontrar essa tarefa, use a caixa Pesquisar para procurá-la. Ao encontrar a caixa, selecione-a e clique no botão Adicionar próximo à tarefa Usar versão do Python.
Assim como no pipeline de build, você deseja garantir que a versão do Python seja compatível com os scripts chamados nas tarefas subsequentes. Nesse caso, clique na tarefa Usar Python 3.x próxima ao Trabalho do agente e, em seguida, defina a Especificação de versão como 3.10. Defina também o Nome de exibição como Use Python 3.10. Esse pipeline pressupõe que você esteja usando o Databricks Runtime 13.3 LTS nos clusters, que têm o Python 3.10.12 instalado.
Clique em Salvar> OK.

Etapa 3.4: desempacotar o artefato de compilação do pipeline de build

Em seguida, faça com que o agente de versão extraia o arquivo wheel do Python, os arquivos de configurações de versão relacionados, os notebooks e o arquivo de código Python do arquivo zip usando a tarefa Extrair Arquivos: clique no sinal de adição na seção Trabalho do Agente, selecione a tarefa Extrair arquivos na guia Utilitário e clique em Adicionar.
Clique na tarefa Extrair arquivos próxima ao Trabalho do agente, defina Padrões de arquivo morto como **/*.zip e defina a pasta de destino como a variável do sistema $(Release.PrimaryArtifactSourceAlias)/Databricks. Defina também o Nome de exibição como Extract build pipeline artifact.

Observação

$(Release.PrimaryArtifactSourceAlias) representa um alias gerado pelo Azure DevOps para identificar o local de origem do artefato primário no agente de versão, por exemplo _<your-github-alias>.<your-github-repo-name>. O pipeline de lançamento define esse valor como a variável de ambiente RELEASE_PRIMARYARTIFACTSOURCEALIAS na fase Inicializar trabalho para o agente de versão. Confira Variáveis de lançamento e artefatos clássicos.
Defina o Nome de exibição como Extract build pipeline artifact.
Clique em Salvar> OK.

Etapa 3.5: definir a variável de ambiente BUNDLE_ROOT

Para que o exemplo deste artigo funcione conforme o esperado, é necessário definir uma variável de ambiente denominada BUNDLE_ROOT no pipeline de lançamento. Os Pacotes de Ativos do Databricks usam essa variável de ambiente para determinar a localização do arquivo databricks.yml. Para definir essa variável de ambiente:

Use a tarefa Variáveis de Ambiente: clique novamente no sinal de mais na seção Trabalho do Agente, selecione a tarefa Variáveis de Ambiente na guia Utilitário e clique em Adicionar.

Observação

Se a tarefa Variáveis de Ambiente não estiver visível na guia Utilitário, insira Environment Variables na caixa de Pesquisa e siga as instruções na tela para adicionar a tarefa à guia Utilitário. Isso pode exigir que você saia do Azure DevOps e volte ao local em que parou.
Para Variáveis de ambiente (separadas por vírgula), insira a seguinte definição: BUNDLE_ROOT=$(Agent.ReleaseDirectory)/$(Release.PrimaryArtifactSourceAlias)/Databricks.

Observação

$(Agent.ReleaseDirectory) representa um alias gerado pelo Azure DevOps para identificar o local do diretório de versão no agente de versão, por exemplo, /home/vsts/work/r1/a. O pipeline de lançamento define esse valor como a variável de ambiente AGENT_RELEASEDIRECTORY na fase Inicializar trabalho para o agente de versão. Confira Variáveis de lançamento e artefatos clássicos. Para obter informações sobre $(Release.PrimaryArtifactSourceAlias), consulte a anotação na etapa anterior.
Defina o Nome de exibição como Set BUNDLE_ROOT environment variable.
Clique em Salvar> OK.

Etapa 3.6. Instalar a CLI do Databricks e as ferramentas de criação do wheel do Python

Em seguida, instale a da CLI do Databricks e as ferramentas de criação do wheel do Python no agente de versão. O agente de versão chamará a CLI do Databricks e as ferramentas de criação do wheel do Python nas próximas tarefas. Para fazer isso, use a tarefa Bash: clique no sinal de adição novamente na seção Trabalho do agente, selecione a tarefa Bash na guia Utilitário e clique em Adicionar.
Clique na tarefa Script bash próxima ao Trabalho do agente.
Em Tipo, selecione Embutido.
Substitua o conteúdo do Script pelo seguinte comando, que instala a CLI do Databricks e as ferramentas de criação do wheel do Python:
```
curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
pip install wheel
```
Defina o Nome de exibição como Install Databricks CLI and Python wheel build tools.
Clique em Salvar> OK.

Etapa 3.7: Validar o Pacote de Ativos do Databricks

Nesta etapa, você deve verificar se o arquivo databricks.yml está sintaticamente correto.

Usar a tarefa Bash: clique novamente no sinal de mais na seção Trabalho do agente, selecione a tarefa Bash na guia Utilitário e clique em Adicionar.
Clique na tarefa Script bash próxima ao Trabalho do agente.
Em Tipo, selecione Embutido.
Substitua o conteúdo de Script pelo seguinte comando, que utiliza a CLI do Databricks para verificar se o arquivo databricks.yml está sintaticamente correto:
```
databricks bundle validate -t $(BUNDLE_TARGET)
```
Defina o Nome de exibição como Validate bundle.
Clique em Salvar> OK.

Etapa 3.8: implantar o pacote

Nesta etapa, você vai criar o arquivo wheel do Python e implantar o arquivo wheel do Python criado, os dois notebooks Python e o arquivo Python do pipeline de lançamento no seu workspace do Azure Databricks.

Usar a tarefa Bash: clique novamente no sinal de mais na seção Trabalho do agente, selecione a tarefa Bash na guia Utilitário e clique em Adicionar.
Clique na tarefa Script bash próxima ao Trabalho do agente.
Em Tipo, selecione Embutido.
Substitua o conteúdo do Script pelo seguinte comando, que usa a CLI do Databricks para criar o arquivo wheel do Python e implantar os arquivos de exemplo deste artigo do pipeline de lançamento no seu workspace do Azure Databricks:
```
databricks bundle deploy -t $(BUNDLE_TARGET)
```
Defina o Nome de exibição como Deploy bundle.
Clique em Salvar> OK.

Etapa 3.9: executar o notebook de teste de unidade do pacote wheel do Python

Nesta etapa, você executa um trabalho que executa o notebook de teste de unidade em seu workspace do Azure Databricks. Esse notebook executa testes de unidade em relação à logica da biblioteca de pacotes wheel do Python.

Usar a tarefa Bash: clique novamente no sinal de mais na seção Trabalho do agente, selecione a tarefa Bash na guia Utilitário e clique em Adicionar.
Clique na tarefa Script bash próxima ao Trabalho do agente.
Em Tipo, selecione Embutido.
Substitua o conteúdo do Script pelo seguinte comando, que usa a CLI do Databricks para executar o trabalho no seu workspace do Azure Databricks:
```
databricks bundle run -t $(BUNDLE_TARGET) run-unit-tests
```
Defina o Nome de exibição como Run unit tests.
Clique em Salvar> OK.

Etapa 3.10: executar o notebook que chama o pacote wheel do Python

Nesta etapa, você executará um trabalho que executa outro notebook em seu workspace do Azure Databricks. Esse notebook chama a biblioteca de pacotes wheel do Python.

Usar a tarefa Bash: clique novamente no sinal de mais na seção Trabalho do agente, selecione a tarefa Bash na guia Utilitário e clique em Adicionar.
Clique na tarefa Script bash próxima ao Trabalho do agente.
Em Tipo, selecione Embutido.
Substitua o conteúdo do Script pelo seguinte comando, que usa a CLI do Databricks para executar o trabalho no seu workspace do Azure Databricks:
```
databricks bundle run -t $(BUNDLE_TARGET) run-dabdemo-notebook
```
Defina o Nome de exibição como Run notebook.
Clique em Salvar> OK.

Agora você concluiu a configuração do pipeline de lançamento. Ele deve ter a seguinte aparência:

Configuração do pipeline de lançamento concluída do Azure DevOps

Etapa 4: executar os pipelines de lançamento e build

Nesta etapa, você executará os pipelines manualmente. Para saber como executar os pipelines automaticamente, consulte Especificar eventos que disparam pipelines e Gatilhos de versão.

Para executar manualmente o pipeline de build:

No menu Pipelines na barra lateral, clique em Pipelines.
Clique no nome do seu pipeline de build e, em seguida, clique em Executa pipeline.
Para Branch/tag, selecione o nome do branch no repositório Git que contém todo o código-fonte que você adicionou. Este exemplo pressupõe que isso esteja na ramificação release.
Clique em Executar. A página de execução do pipeline de build é exibida.
Para exibir o progresso do pipeline de build e os logs relacionados, clique no ícone de rotação próximo ao Trabalho.
Após o ícone Trabalho se transformar em uma marca de verificação verde, prossiga para executar o pipeline de lançamento.

Para executar o pipeline de lançamento manualmente:

Após o pipeline de build ter sido executado com êxito, no menu Pipelines da barra lateral, clique em Versões.
Clique no nome do pipeline de lançamento e clique em Criar lançamento.
Clique em Criar.
Para ver o progresso do pipeline de lançamento, na lista de versões, clique no nome da versão mais recente.
Na caixa Fases, clique em Fase 1 e clique em Logs.

Compartilhar via