Integração e entrega contínuas no Databricks usando Azure DevOps

nota

Este artigo aborda Azure DevOps, que é desenvolvido por terceiros. Para entrar em contato com o provedor, consulte Suporte do serviçoAzure DevOps.

Este artigo orienta você na configuração da automação Azure DevOps para seu código e artefatos que funcionam com Databricks. Especificamente, você configurará um fluxo de trabalho de integração e entrega contínua (CI/CD) para se conectar a um repositório Git , executará um Job usando o pipeline Azure para construir e testar uma Python wheel (*.whl) e o implantará para uso no Databricks Notebook.

Fluxo de trabalho de desenvolvimento deCI/CD

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

1. Crie um repositório ou use um repositório existente com seu provedor Git de terceiros.
2. Conecte sua máquina de desenvolvimento local ao mesmo repositório de terceiros. Para obter instruções, consulte a documentação do seu provedor Git terceirizado.
3. Puxe quaisquer artefatos atualizados existentes (como Notebook, arquivos de código e scripts de compilação) para sua máquina de desenvolvimento local a partir do repositório de terceiros.
4. Conforme necessário, crie, atualize e teste artefatos em sua máquina de desenvolvimento local. Em seguida, envie quaisquer artefatos novos e alterados da sua máquina de desenvolvimento local para o repositório de terceiros. Para obter instruções, consulte a documentação do seu provedor Git terceirizado.
5. Repita os passos 3 e 4 conforme necessário.
6. Use Azure DevOps periodicamente como uma abordagem integrada para extrair artefatos automaticamente do seu repositório de terceiros, criar, testar e executar código no seu workspace Databricks e relatar resultados de testes e execução. Embora você possa executar Azure DevOps manualmente, em implementações do mundo real, você instruiria seu provedor Git terceirizado a executar Azure DevOps sempre que um evento específico acontecesse, como uma solicitação de pull de repositório.

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

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

Sobre o exemplo

O exemplo deste artigo utiliza dois pipelines para coletar, implantar e executar exemplos de código Python e Python Notebook que estão armazenados em um repositório Git remoto.

O primeiro pipeline, conhecido como pipeline de construção , prepara artefatos de construção para o segundo pipeline, conhecido como pipeline de lançamento . Separar o pipeline de construção do pipeline de lançamento permite que você crie um artefato de construção sem implantá-lo ou implantar simultaneamente artefatos de várias construções. Para construir o pipeline de construção e liberação:

1. Crie uma máquina virtual do Azure para o pipeline de compilação.
2. Copie os arquivos do seu repositório Git para a máquina virtual.
3. Crie um arquivo tar compactado com gzip que contenha o código Python , Python Notebook e os arquivos de configuração de compilação, implantação e execução relacionados.
4. Copie o arquivo tar compactado com gzip como um arquivo zip em um local que possa ser acessado pelo pipeline de lançamento.
5. Crie outra máquina virtual do Azure para o pipeline de lançamento.
6. Obtenha o arquivo zip do local do pipeline de compilação e, em seguida, descompacte o arquivo zip para obter o código Python , Python Notebook e os arquivos de configuração de compilação, implantação e execução relacionados.
7. implantou o código Python , Python Notebook e os arquivos de configurações de construção, implantação e execução relacionados ao seu workspace remoto Databricks .
8. Crie os arquivos de código do componente da biblioteca Python wheel em um arquivo Python wheel.
9. execute testes unitários no código do componente para verificar a lógica no arquivo Python wheel .
10. execução do Python Notebook, um dos quais chama a funcionalidade do arquivo Python wheel .

Sobre o Databricks CLI

O exemplo deste artigo demonstra como usar o Databricks CLI em um modo não interativo dentro de um pipeline. O exemplo de pipeline deste artigo implanta código, constrói uma biblioteca e executa Notebook em seu workspace Databricks .

Se você estiver usando o Databricks CLI em seu pipeline sem implementar o código de exemplo, a biblioteca e o Notebook destes artigos, siga estes passos:

1. Prepare seu workspace Databricks para usar a autenticação OAuth máquina a máquina (M2M) para autenticar uma entidade de serviço. Antes de começar, confirme se você tem uma entidade de serviço Microsoft Entra ID com um segredo OAuth do Databricks. Consulte Autorizar o acesso da entidade de serviço ao Databricks com OAuth.

2. Instale o Databricks CLI no seu pipeline. Para fazer isso, adicione uma tarefa Bash Script ao seu pipeline que execute o seguinte script:

   Bash

   curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh

   Para adicionar uma tarefa de script Bash ao seu pipeline, consulte o passo 3.6. Instale o CLI Databricks e as ferramentas de construção Python wheel.

3. Configure seu pipeline para permitir que o Databricks CLI instalado autentique sua entidade de serviço com seu workspace. Para fazer isso, consulte a etapa 3.1: Definir variável de ambiente para o pipelinede lançamento.

4. Adicione mais tarefas do Bash Script ao seu pipeline conforme necessário para executar seu comando CLI Databricks . Veja o comando CLI Databricks.

Antes de começar

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

• Um projeto existente do Azure DevOps . Se você ainda não tiver um projeto, crie um projeto no Azure DevOps.
• Um repositório existente com um provedor Git compatível com o Azure DevOps. Você adicionará o código de exemplo Python , o Python Notebook de exemplo e os arquivos de configurações de versão relacionados a este repositório. Se você ainda não tiver um repositório, crie um seguindo as instruções do seu provedor Git. Em seguida, conecte seu projeto do Azure DevOps a este repositório, caso ainda não tenha feito isso. Para obter instruções, siga os links em Repositórios de fontes suportados.
• O exemplo deste artigo usa a autenticação OAuth máquina a máquina (M2M) para autenticar uma entidade de serviço Microsoft Entr ID em um workspace Databricks . Você deve ter uma entidade de serviço Microsoft Entra ID com um segredo OAuth do Databricks para essa entidade de serviço. Consulte Autorizar o acesso da entidade de serviço ao Databricks com OAuth.

o passo 1: Adicione os arquivos do exemplo ao seu repositório

Neste passo, no repositório com seu provedor Git de terceiros, você adiciona todos os arquivos de exemplo deste artigo que seu pipeline Azure DevOps construiu, implantou e executou em seu workspace remoto Databricks .

o passo 1.1: Adicionar os arquivos do componente Python wheel

No exemplo deste artigo, seu pipeline Azure DevOps cria e testa um arquivo Python wheel . Um Databricks Notebook então chama a funcionalidade do arquivo Python wheel criado.

Para definir a lógica e os testes unitários para o arquivo Python wheel que o Notebook executa, na raiz do seu 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 biblioteca que é posteriormente incorporada em um arquivo Python wheel e então instalada em clusters Databricks . É uma função simples que adiciona uma nova coluna, preenchida por um literal, a um Apache Spark DataFrame:

Python

# 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 DataFrame contendo os valores esperados. Se os valores corresponderem, o teste será aprovado:

Python

# 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 o Databricks CLI empacote corretamente este código de biblioteca em um arquivo Python wheel , crie dois arquivos chamados __init__.py e __main__.py na mesma pasta dos dois arquivos anteriores. Crie também um arquivo chamado 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> pelo seu nome:

Python

# 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:

Python

# 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 construir a biblioteca em um arquivo Python wheel . Substitua <my-url>, <my-author-name>@<my-organization> e <my-package-description> por valores válidos:

Python

# 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"]
)

o passo 1.2: Adicionar um notebook de teste de unidade para o arquivo Python wheel

Posteriormente, a CLI Databricks executa um trabalho de notebook. Este trabalho executa um Python Notebook com o nome de arquivo run_unit_tests.py. Esta execução do Notebook pytest contra a lógica da biblioteca Python wheel .

Para executar os testes unitários do exemplo deste artigo, adicione na raiz do seu repositório um arquivo Notebook chamado run_unit_tests.py com o seguinte conteúdo:

Python

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

o passo 1.3: Adicionar um Notebook que chama o arquivo Python wheel

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

Python

# 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 │
# +------------+-----------+-------------------------+---------+

o passo 1.4: Criar a configuração do pacote

O exemplo deste artigo usa Databricks ativo Bundles para definir as configurações e comportamentos para construir, implantar e executar o arquivo Python wheel , os dois Notebooks e o arquivo de código Python . Databricks ativos Bundles, conhecidos simplesmente como bundles , possibilitam expressar análises de dados completas e projetos ML como uma coleção de arquivos de origem. Veja o que são Databricks ativo Bundles?.

Para configurar o pacote para o exemplo deste artigo, crie na raiz do seu repositório um arquivo chamado 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 algumas strings para ajudar a identificar exclusivamente o Job criado no seu workspace Databricks para este exemplo. Por exemplo, azure-devops-demo.
• Substitua <spark-version-id> pelo ID da versão Databricks Runtime para seus clusters de Job, por exemplo 13.3.x-scala2.12.
• Substitua <cluster-node-type-id> pelo ID do tipo de nó cluster para seus clusters de trabalho, por exemplo i3.xlarge.
• Observe que dev no mapeamento targets especifica o host e os comportamentos de implantação relacionados. Em implementações do mundo real, você pode dar a esse alvo um nome diferente em seus próprios pacotes.

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

YAML

# 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 , consulte ConfiguraçãoDatabricks ativo Bundle.

o passo 2: Definir o pipelinede construção

Azure DevOps fornece uma interface de usuário hospedada cloudpara definir os estágios do seu pipeline CI/CD usando YAML. Para obter mais informações sobre Azure DevOps e o pipeline, consulte a documentaçãoAzure DevOps.

Neste passo, você usa a marcação YAML para definir o pipeline de construção, que cria um artefato de implantação. Para implantar o código em um workspace Databricks , você especifica o artefato de construção deste pipeline como entrada em um pipeline de lançamento. Você define esse pipeline de lançamento mais tarde.

Para executar o pipeline de construção, Azure DevOps fornece agentes de execução sob demanda hospedados na cloudque dão suporte a implantações no Kubernetes, VMs, Azure Functions, Azure Web Apps e muitos outros destinos. Neste exemplo, você usa um agente sob demanda para automatizar a criação do artefato de implantação.

Defina pipeline de construção de exemplo deste artigo da seguinte forma:

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

nota

Se o Portal Azure for exibido em vez do seu projeto Azure DevOps , clique em Mais serviços > Organizações Azure DevOps > Minhas organizações Azure DevOps e abra seu projeto Azure DevOps .

2. Clique em pipeline na barra lateral e depois clique em pipeline no menu pipeline .

   

3. Clique no botão Novo pipeline e siga as instruções na tela. (Se você já tiver um pipeline, clique em Criar pipeline .) Ao final dessas instruções, o editor de pipeline é aberto. Aqui você define seu script de pipeline de construção no arquivo azure-pipelines.yml que aparece. Se o editor de pipeline não estiver visível no final das instruções, selecione o nome do pipeline de compilação e clique em Editar .

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

   

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

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

   YAML

   # 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://learn.microsoft.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'

o passo 3: Definir o pipelinede lançamento

O pipeline de lançamento transferiu os artefatos de compilação do pipeline de compilação para um ambiente Databricks . Separar o pipeline de lançamento neste passo do pipeline de construção nos passos anteriores permite que você crie uma construção sem aprimorá-la ou aprimore artefatos de várias construções simultaneamente.

1. No seu projeto Azure DevOps , no menu do pipeline na barra lateral, clique em Versões .

   

2. Clique em Novo > Novo pipeline de lançamento . (Se você já tiver um pipeline, clique em Novo pipeline .)

3. Na lateral da tela há uma lista de padrões em destaque para padrões de implantação comuns. Para este exemplo de pipeline de liberação, clique em .

   

4. Na caixa Artefatos na lateral da tela, clique em . No painel Adicionar um artefato , para Origem (pipeline de construção) , selecione o pipeline de construção que você criou anteriormente. Em seguida, clique em Adicionar .

   

5. Você pode configurar como o pipeline é acionado clicando em para exibir opções de disparo na lateral da tela. Se você quiser que uma versão seja iniciada 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, no último passo deste artigo você aciona manualmente o pipeline de construção e depois o pipeline de lançamento.

   

6. Clique em Salvar > OK .

o passo 3.1: Definir variável de ambiente para o pipelinede lançamento

pipeline de lançamento deste exemplo depende da seguinte variável de ambiente, que você pode adicionar clicando em Adicionar na seção de variáveis do pipeline na tab Variáveis , com um Escopo de Estágio 1 :

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

o passo 3.2: Configurar o agente de liberação para o pipelinede liberação

1. Clique no link 1 Job, 0 tarefa dentro do objeto Stage 1 .

   

2. Na tab tarefa , clique em Trabalho do Agente .

3. Na seção Seleção de agente , para poolde agentes , selecione PipelineAzure .

4. Para Especificação do Agente , selecione o mesmo agente que você especificou para o agente de compilação anteriormente, neste exemplo ubuntu-22.04 .

   

5. Clique em Salvar > OK .

o passo 3.3: Definir a versão Python para o agente de lançamento

1. Clique no sinal de mais na seção Tarefa do agente , indicado pela seta vermelha na figura a seguir. Uma lista pesquisável de tarefas disponíveis aparece. Há também uma tab de mercado para plug-ins de terceiros que podem ser usados para complementar a tarefa padrão Azure DevOps . Você adicionará várias tarefas ao agente de liberação durante os próximos passos.

   

2. A primeira tarefa que você adiciona é Usar versão Python , localizada na tab Ferramentas . Se você não conseguir encontrar esta tarefa, use a caixa de pesquisa para procurá-la. Quando encontrá-lo, selecione-o e clique no botão Adicionar ao lado da tarefa Usar versão do Python .

   

3. Assim como no pipeline de construção, você quer ter certeza de que a versão Python é compatível com os scripts chamados nas tarefas subsequentes. Nesse caso, clique na tarefa Usar Python 3.x ao lado de Trabalho do agente e defina a especificação da versão como 3.10. Defina também o Nome de exibição como Use Python 3.10. Este pipeline pressupõe que você esteja usando o Databricks Runtime 13.3 LTS nos clusters que têm o Python 3.10.12 instalado.

   

4. Clique em Salvar > OK .

o passo 3.4: Descompacte o artefato de construção do pipelinede construção

1. Em seguida, faça com que o agente de liberação extraia o arquivo Python wheel , os arquivos de configurações de liberação relacionados, o Notebook e o arquivo de código Python do arquivo zip usando a tarefa Extrair arquivos : clique no sinal de mais na seção Tarefa do agente , selecione a tarefa Extrair arquivos na tab Utilidades e clique em Adicionar .

2. Clique na tarefa Extrair arquivos ao lado de Trabalho do agente , defina Padrões de arquivo compactado 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.

nota

$(Release.PrimaryArtifactSourceAlias) representa um alias gerado pelo Azure DevOps para identificar o local de origem do artefato primário no agente de liberação, por exemplo _<your-github-alias>.<your-github-repo-name>. O pipeline de liberação define esse valor como a variável de ambiente RELEASE_PRIMARYARTIFACTSOURCEALIAS na fase Inicializar tarefa para o agente de liberação. Veja Variáveis de artefatos e versão clássica.

3. Defina o nome de exibição como Extract build pipeline artifact.

   

4. Clique em Salvar > OK .

o passo 3.5: Defina a variável de ambiente BUNDLE_ROOT

Para que o exemplo deste artigo funcione conforme o esperado, você deve definir uma variável de ambiente chamada BUNDLE_ROOT no pipeline de lançamento. Databricks ativo Bundles usa esta variável de ambiente para determinar onde o arquivo databricks.yml está localizado. Para definir esta variável de ambiente:

1. Use a variável de ambiente tarefa: clique novamente no sinal de mais na seção Agent Job , selecione a variável de ambiente tarefa na tab utilidades e clique em Add .

nota

Se a variável de ambiente tarefa não estiver visível na tab utilidades , digite Environment Variables na caixa Pesquisar e siga as instruções na tela para adicionar a tarefa à tab utilidades . Isso pode exigir que você saia do Azure DevOps e depois retorne ao local onde parou.

2. Para variável de ambiente (separada por vírgula) , insira a seguinte definição: BUNDLE_ROOT=$(Agent.ReleaseDirectory)/$(Release.PrimaryArtifactSourceAlias)/Databricks.

nota

$(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 liberação define esse valor como a variável de ambiente AGENT_RELEASEDIRECTORY na fase Inicializar tarefa para o agente de liberação. Veja Variáveis de artefatos e versão clássica. Para informações sobre $(Release.PrimaryArtifactSourceAlias), consulte a nota no passo anterior.

3. Defina o nome de exibição como Set BUNDLE_ROOT environment variable.

   

4. Clique em Salvar > OK .

o passo 3.6. Instale as ferramentas de construção CLI do Databricks e Python wheel

1. Em seguida, instale as ferramentas de construção CLI do Databricks e Python wheel no agente de lançamento. O agente de liberação chamará as ferramentas de construção CLI Databricks e Python wheel nas próximas tarefas. Para fazer isso, use a tarefa Bash : clique no sinal de mais novamente na seção Tarefa do Agente , selecione a tarefa Bash na tab Tarefas e clique em Adicionar .

2. Clique na tarefa Bash Script ao lado de Agent Job .

3. Para Tipo , selecione Em linha .

4. Substitua o conteúdo de Script pelo seguinte comando, que instala as ferramentas de construção CLI do Databricks e Python wheel:

   Bash

   curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
   pip install wheel

5. Defina o nome de exibição como Install Databricks CLI and Python wheel build tools.

   

6. Clique em Salvar > OK .

o passo 3.7: Validar o pacote ativo Databricks

Neste passo, você garante que o arquivo databricks.yml esteja sintaticamente correto.

1. Use a tarefa Bash : clique no sinal de mais novamente na seção Tarefa do agente , selecione a tarefa Bash na tab de tarefas e clique em Adicionar .

2. Clique na tarefa Bash Script ao lado de Agent Job .

3. Para Tipo , selecione Em linha .

4. Substitua o conteúdo de Script pelo seguinte comando, que usa a CLI do Databricks para verificar se o arquivo databricks.yml está sintaticamente correto:

   Bash

   databricks bundle validate -t $(BUNDLE_TARGET)

5. Defina o nome de exibição como Validate bundle.

6. Clique em Salvar > OK .

o passo 3.8: implementou o pacote

Neste passo, você cria o arquivo Python wheel e implanta o arquivo Python wheel criado, os dois Python Notebook e o arquivo Python do pipeline de lançamento para seu workspace Databricks .

1. Use a tarefa Bash : clique no sinal de mais novamente na seção Tarefa do agente , selecione a tarefa Bash na tab de tarefas e clique em Adicionar .

2. Clique na tarefa Bash Script ao lado de Agent Job .

3. Para Tipo , selecione Em linha .

4. Substitua o conteúdo de Script pelo comando a seguir, que usa o CLI Databricks para criar o arquivo Python wheel e implantar os arquivos de exemplo deste artigo do pipeline de lançamento para seu workspace Databricks :

   Bash

   databricks bundle deploy -t $(BUNDLE_TARGET)

5. Defina o nome de exibição como Deploy bundle.

6. Clique em Salvar > OK .

o passo 3.9: execução do Notebook de testes unitários para a Python wheel

Neste passo, você executa um Job que executa o teste unitário Notebook no seu workspace Databricks . Esta unidade de execução do Notebook testa a lógica da biblioteca Python wheel .

1. Use a tarefa Bash : clique no sinal de mais novamente na seção Tarefa do agente , selecione a tarefa Bash na tab de tarefas e clique em Adicionar .

2. Clique na tarefa Bash Script ao lado de Agent Job .

3. Para Tipo , selecione Em linha .

4. Substitua o conteúdo do Script pelo seguinte comando, que usa o Databricks CLI para executar o Job no seu workspace Databricks :

   Bash

   databricks bundle run -t $(BUNDLE_TARGET) run-unit-tests

5. Defina o nome de exibição como Run unit tests.

6. Clique em Salvar > OK .

o passo 3.10: execução do Notebook que chama a Python wheel

Neste passo, você executa um Job que executa outro Notebook em seu workspace Databricks . Este Notebook chama a Python wheel de biblioteca.

1. Use a tarefa Bash : clique no sinal de mais novamente na seção Tarefa do agente , selecione a tarefa Bash na tab de tarefas e clique em Adicionar .

2. Clique na tarefa Bash Script ao lado de Agent Job .

3. Para Tipo , selecione Em linha .

4. Substitua o conteúdo do Script pelo seguinte comando, que usa o Databricks CLI para executar o Job no seu workspace Databricks :

   Bash

   databricks bundle run -t $(BUNDLE_TARGET) run-dabdemo-notebook

5. Defina o nome de exibição como Run notebook.

6. Clique em Salvar > OK .

Agora você concluiu a configuração do seu pipeline de lançamento. Deve ficar assim:

o passo 4: execução do pipeline de build e release

Nesta etapa, você executa o pipeline manualmente. Para saber como executar o pipeline automaticamente, consulte Especificar eventos que acionam o pipeline e Liberar gatilhos.

Para executar o pipeline de build manualmente:

1. No menu do pipeline na barra lateral, clique em pipeline .
2. Clique no nome do seu pipeline de construção e depois clique em execução pipeline .
3. Para Branch/tag , selecione o nome da branch no seu repositório Git que contém todo o código-fonte que você adicionou. Este exemplo pressupõe que isso esteja no ramo release .
4. Clique em execução . A página de execução do pipeline de construção é exibida.
5. Para ver o progresso do pipeline de construção e view os logs relacionados, clique no ícone giratório ao lado de Job .
6. Depois que o ícone Job mudar para uma marca de seleção verde, prossiga para a execução do pipeline de lançamento.

Para executar o pipeline de lançamento manualmente:

1. Após a execução bem-sucedida do pipeline de construção, no menu do pipeline na barra lateral, clique em Releases .
2. Clique no nome do seu pipeline de lançamento e depois clique em Criar lançamento .
3. Clique em Criar .
4. Para ver o progresso do pipeline de lançamento, na lista de lançamentos, clique no nome do lançamento mais recente.
5. Na caixa Estágios , clique em Estágio 1 e clique em logs .