dbx do Databricks Labs

Importante

Esta documentação foi desativada e pode não estar atualizada.

Databricks recomenda que você use Pacotes de Automação Declarativa em vez do dbx, fornecido pelo Databricks Labs. Veja o que são Pacotes de Automação Declarativa? e Migre do dbx para os pacotes.

Observação

Este artigo aborda o dbx do Databricks Labs, que é fornecido no estado em que se encontra e não tem suporte do Databricks por meio de canais de suporte técnico ao cliente. As dúvidas e solicitações de recursos podem ser comunicadas por meio da página Problemas do repositório databrickslabs/dbx no GitHub.

O dbx do Databricks Labs é uma ferramenta de código aberto projetada para estender a interface da linha de comando herdada do Databricks (CLI do Databricks) e fornecer funcionalidades para o ciclo de vida de desenvolvimento rápido, integração contínua e entrega/implantação contínua (CI/CD) na plataforma Azure Databricks.

dbx simplifica os processos de lançamento e implantação de tarefas em vários ambientes. Ele também ajuda a empacotar seu projeto e entregá-lo ao seu ambiente do Azure Databricks com controle de versão. Projetado com prioridade para a interface de linha de comando (CLI-first), ele é desenvolvido para ser utilizado ativamente tanto dentro de pipelines de CI/CD quanto como parte de ferramentas locais (tais como IDEs locais, incluindo Visual Studio Code e PyCharm).

O fluxo de trabalho de desenvolvimento típico com dbx:

Crie um repositório remoto com um provedor Git compatível com o Databricks, se você ainda não tiver um repositório remoto disponível.
Clone seu repositório remoto no espaço de trabalho do Azure Databricks.
Crie ou mova um notebook do Azure Databricks para o repositório clonado em seu workspace do Azure Databricks. Use este notebook para começar a prototipação do código que você deseja que os clusters do Azure Databricks executem.
Para aprimorar e modularizar o código do notebook adicionando classes auxiliares e funções, arquivos de configuração e testes separados, alterne para usar um computador de desenvolvimento local com dbx, o IDE preferencial e o Git instalados.
Clone o repositório remoto em seu computador de desenvolvimento local.
Mova o código do notebook para um ou mais arquivos de código locais.
Conforme você codifica localmente, efetue push do trabalho do repositório local para o repositório remoto. Além disso, sincronize seu repositório remoto com seu workspace do Azure Databricks.

Dica

Como alternativa, você pode usar dbx sync para sincronizar automaticamente as alterações de arquivos locais com os arquivos correspondentes em seu workspace, em tempo real.
Continue usando o notebook no workspace do Azure Databricks para prototipagem rápida e continue movendo o código validado do notebook para o computador local. Continue usando seu IDE local para tarefas como modularização de código, autocompletação de código, análise estática de código, testes de unidade, e depuração passo a passo de código e objetos que não exigem uma conexão ativa com o Azure Databricks.
Use dbx para executar em lotes o código local nos clusters de destino, conforme desejado. (Isso é semelhante à execução do script spark-submit no diretório do bin Spark para iniciar aplicativos em um cluster Spark.)
Quando estiver pronto para produção, use uma plataforma de CI/CD, como GitHub Actions, Azure DevOps ou GitLab , para automatizar a execução do código do repositório remoto em seus clusters.

Requisitos

Para usar dbx, você precisa ter o seguinte instalado em seu computador de desenvolvimento local, independentemente de seu código usar Python, Scala ou Java:

Python versão 3.8 ou superior.

Se o seu código usa Python, você deve usar uma versão do Python que corresponda à que está instalada em seus clusters de destino. Para obter a versão do Python instalada em um cluster existente, você pode usar o terminal Web do cluster para executar o python --version comando. Consulte também a seção "Ambiente do sistema" nas notas sobre versões e compatibilidade do Databricks Runtime para a versão do Databricks Runtime dos seus clusters de destino.
pip.
Se seu código usar Python, há um método para criar ambientes virtuais do Python, garantindo que você esteja utilizando as versões corretas do Python e das dependências dos pacotes em seus projetos de dbx. Este artigo aborda pipenv.
dbx versão 0.8.0 ou superior. Você pode instalar esse pacote no PyPI (Índice de Pacotes do Python) executando pip install dbx.

Para verificar se o dbx está instalado, execute o seguinte comando:
```
dbx --version
```
Se o número da versão for retornado, dbx será instalado.

Se o número da versão for inferior a 0.8.0, atualize o dbx executando o seguinte comando e verifique o número da versão novamente:
```
pip install dbx --upgrade
dbx --version

# Or ...
python -m pip install dbx --upgrade
dbx --version
```
A CLI do Databricks versão 0.18 ou inferior, configurada com autenticação. A versão 0.17 herdada do Databricks CLI é instalada automaticamente quando você instala o dbx. Essa autenticação pode ser configurada em seu computador de desenvolvimento local em um ou ambos os seguintes locais:
- Nas variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN (começando com a versão 0.8.0 da CLI herdada do Databricks).
- Em um perfil de configuração do Azure Databricks no arquivo .databrickscfg.
dbx procura credenciais de autenticação nesses dois locais, respectivamente. dbx usa apenas o primeiro conjunto de credenciais correspondentes que ele encontra.

Observação

dbx não tem suporte para o uso de um arquivo .netrc para autenticação, começando com a versão 0.17.2 da CLI herdada do Databricks. Para verificar a versão legada da CLI do Databricks instalada, execute o comando databricks --version.
git para enviar por push e sincronizar alterações de código locais e remotas.

Continue com as instruções para uma das seguintes IDEs:

Código do Visual Studio
PyCharm
Ideia do IntelliJ
Eclipse

Observação

O Databricks validou o uso dos IDEs anteriores com dbx; no entanto, dbx deve funcionar com qualquer IDE. Você também pode usar Sem IDE (apenas terminal).

O dbx é otimizado para trabalhar com arquivos de código Python de arquivo único e arquivos JAR do Scala e do Java compilados. O dbx não funciona com arquivos de código R de arquivo único ou pacotes de código R compilados. Isso ocorre porque dbx funciona com a API de Trabalhos 2.0 e 2.1, e essas APIs não podem executar arquivos de código R de arquivo único nem pacotes de código R compilados como trabalhos.

Visual Studio Code

Conclua as instruções a seguir para começar a usar o Visual Studio Code e o Python com dbx.

Em seu computador de desenvolvimento local, você deve ter o seguinte instalado, além dos requisitos em geral:

Visual Studio Code.
A extensão do Python para Visual Studio Code. Para obter mais informações, consulte o Marketplace de extensão no site Visual Studio Code.

Para obter mais informações, consulte Introdução ao Python no VS Code na documentação do Visual Studio Code.

Siga estas etapas para começar a configurar a estrutura do projeto dbx:

No terminal, crie uma pasta em branco. Essas instruções utilizam uma pasta chamada dbx-demo. Você pode dar à pasta raiz do projeto dbx qualquer nome desejado. Se você usar um nome diferente, substitua o nome ao longo dessas etapas. Depois de criar a pasta, mude para ela e inicie o Visual Studio Code dessa pasta.

Para Linux e macOS:
```
mkdir dbx-demo
cd dbx-demo
code .
```
Dica

Se command not found: code for exibido após a execução code ., consulte Inicialização da linha de comando no site da Microsoft.

Para Windows:
```
md dbx-demo
cd dbx-demo
code .
```
No Visual Studio Code, crie um ambiente virtual do Python para este projeto:
1. Na barra de menus, clique em Exibir > Terminal.
2. Na raiz da dbx-demo pasta, execute o pipenv comando com a seguinte opção, onde <version> está a versão de destino do Python que você já instalou localmente (e, idealmente, uma versão que corresponde à versão do Python dos clusters de destino), por exemplo 3.8.14.
```
pipenv --python <version>
```
  Anote o valor Virtualenv location na saída do comando pipenv, pois você precisará dele na próxima etapa.
Selecione o interpretador do Python de destino e ative o ambiente virtual do Python:
1. Na barra de menus, clique em Exibição > Paleta de Comandos, digite Python: Select e clique em Python: selecionar Interpretador.
2. Selecione o interpretador do Python dentro do caminho para o ambiente virtual do Python que você acabou de criar. (Esse caminho é listado como o valor Virtualenv location na saída do comando pipenv.)
3. Na barra de menus, clique em Exibição > Paleta de Comandos, digite Terminal: Create e clique em Terminal: criar terminal.
Para obter mais informações, consulte Como usar ambientes do Python no VS Code na documentação do Visual Studio Code.
Continue com Criar um projeto dbx.

PyCharm

Conclua as instruções a seguir para começar a usar o PyCharm e o Python com dbx.

Em seu computador de desenvolvimento local, você deve ter o PyCharm instalado, além dos requisitos em geral.

Siga estas etapas para começar a configurar a estrutura do projeto dbx:

No PyCharm, na barra de menus, clique em Arquivo > Projeto novo.
Na caixa de diálogo Criar Projeto, escolha um local para o novo projeto.
Expandir o interpretador do Python: novo ambiente pipenv.
Selecione Novo ambiente usando, se ele ainda não estiver selecionado, e, em seguida, selecione Pipenv na lista suspensa.
Para o interpretador base, selecione o local que contém o interpretador do Python para a versão de destino do Python que você já instalou localmente (e, idealmente, uma versão que corresponda à versão do Python dos clusters de destino).
Para o executável do Pipenv, selecione o local que contém sua instalação local do pipenv, se isso ainda não for detectado automaticamente.
Se você desejar criar um projeto dbx mínimo e usar o main.py arquivo com esse projeto dbx mínimo, selecione a caixa Criar um script de boas-vindas do main.py. Caso contrário, desmarque essa caixa.
Clique em Criar.
Na janela ferramenta Projeto , clique com o botão direito do mouse na pasta raiz do projeto e clique em Abrir no > Terminal.
Continue com Criar um projeto dbx.

Ideia do IntelliJ

Conclua as instruções a seguir para começar a usar o IntelliJ IDEA e o Scala com dbx. Essas instruções criam um projeto mínimo em Scala baseado em sbt que você pode utilizar para iniciar um projeto de dbx.

Em seu computador de desenvolvimento local, você deve ter o seguinte instalado, além dos requisitos em geral:

IntelliJ IDEA.
O plug-in Scala para IntelliJ IDEA. Para obter mais informações, consulte Descubra o IntelliJ IDEA para Scala na documentação do IntelliJ IDEA.
JRE (Java Runtime Environment) 8. Embora qualquer edição do JRE 8 deva funcionar, o Databricks até agora só validou o uso de dbx e do IntelliJ IDEA com o OpenJDK 8 JRE. O Databricks ainda não validou o uso de dbx com o IntelliJ IDEA e o Java 11. Para obter mais informações, consulte JDK (Java Development Kit) na documentação do IntelliJ IDEA.

Siga estas etapas para começar a configurar a estrutura do projeto dbx:

Etapa 1: criar um projeto Scala baseado em sbt

No IntelliJ IDEA, dependendo da exibição, clique em Projetos > Novo Projeto ou Arquivo > Novo > Projeto.
Na caixa de diálogo Novo Projeto, clique em Scala, sbt e Avançar.
Digite um nome de projeto e um local para o projeto.
Para JDK, selecione a instalação do OpenJDK 8 JRE.
Para sbt, escolha a versão mais alta disponível de sbt listada.
Para Scala, o ideal é escolher a versão do Scala que corresponde à versão do Scala dos clusters de destino. Consulte a seção "Ambiente do sistema" nas notas de versão e compatibilidade do Databricks Runtime para a versão do Databricks Runtime nos seus clusters de destino.
Ao lado do Scala, selecione a caixa Fontes se ela ainda não estiver selecionada.
Adicione um prefixo de pacote ao Prefixo de Pacote. Estas etapas usam o prefixo de pacote com.example.demo. Se você especificar um prefixo de pacote diferente, substitua o prefixo de pacote ao longo destas etapas.
Clique em Concluir.

Etapa 2: adicionar um objeto ao pacote

Você pode adicionar todos os objetos necessários ao pacote. Este pacote contém apenas um objeto chamado SampleApp.

Na janela de ferramentas Projeto (Exibição > Janelas de Ferramentas > Projeto), clique com o botão direito do mouse na pasta nome do projeto> src > main > scala e clique em Nova > Classe Scala.
Escolha Objeto e digite o nome do objeto e pressione Enter. Por exemplo, digite SampleApp. Se você inserir um nome de objeto diferente aqui, substitua o nome ao longo destas etapas.

Substitua o conteúdo do arquivo SampleApp.scala pelo seguinte código:

package com.example.demo

object SampleApp {
  def main(args: Array[String]) {
  }
}

Etapa 3: compilar o projeto

Adicione todas as configurações de compilação e dependências necessárias ao projeto. Esta etapa pressupõe que você esteja criando um projeto que foi configurado nas etapas anteriores e depende apenas das bibliotecas a seguir.

Substitua o conteúdo do arquivo do build.sbt projeto pelo seguinte conteúdo:

ThisBuild / version := "0.1.0-SNAPSHOT"

ThisBuild / scalaVersion := "2.12.14"

val sparkVersion = "3.2.1"

lazy val root = (project in file("."))
  .settings(
    name := "dbx-demo",
    idePackagePrefix := Some("com.example.demo"),
    libraryDependencies += "org.apache.spark" %% "spark-core" % sparkVersion withSources(),
    libraryDependencies += "org.apache.spark" %% "spark-sql" % sparkVersion withSources(),
    libraryDependencies += "org.apache.spark" %% "spark-hive" % sparkVersion withSources()
  )

No arquivo anterior, substitua:

2.12.14 com a versão do Scala que você escolheu anteriormente para este projeto.
3.2.1 com a versão do Spark que você escolheu anteriormente para este projeto.
dbx-demo com o nome do seu projeto.
com.example.demo com o nome do seu prefixo do pacote.

Na barra de menus, clique em Visualizar > Janelas de Ferramentas > sbt.
Na janela de ferramentas sbt, clique com o botão direito do mouse no nome do projeto e clique em Recarregar Projeto sbt. Aguarde até sbt concluir o download das dependências do projeto de um repositório de artefatos da Internet. Por padrão, são utilizados Coursier ou Ivy, dependendo da sua versão de sbt. Você pode ver o progresso do download na barra de status. Se você adicionar ou alterar mais dependências a este projeto, precisará repetir essa etapa de recarregamento do projeto para cada conjunto de dependências que adicionar ou alterar.
Na barra de menus, clique em IntelliJ IDEA > Preferências.
Na caixa de diálogo Preferências, clique em Build, Execução, Implantação > Ferramentas de Build > sbt.
Em JVM, para JRE, selecione a instalação do OpenJDK 8 JRE.
Em projetos sbt, selecione o nome do projeto.
Em shell do sbt, selecione builds.
Clique em OK.
Na barra de menus, clique em Compilar > Compilar Projeto. Os resultados do build são exibidos na janela de ferramentas sbt shell (Exibir > Janelas de Ferramentas > sbt shell).

Etapa 4: adicionar código ao projeto

Adicione todo o código necessário ao seu projeto. Esta etapa pressupõe que você só deseja adicionar código ao arquivo SampleApp.scala no pacote example.

No arquivo do projeto src>main>scala>SampleApp.scala, adicione o código que você deseja dbx executar em lote nos seus clusters alvo. Para testes básicos, use o exemplo de código Scala na seção Exemplo de código.

Etapa 5: executar o projeto

Na barra de menus, clique em Executar > Editar Configurações.
Na caixa de diálogo Configurações de Execução/Depuração, clique no ícone + (Adicionar Nova Configuração) ou Adicionar nova ou Adicionar nova configuração de execução.
Na lista suspensa, clique em sbt Task.
Em Nome, insira um nome para a configuração, por exemplo, Executar o programa.
Em Tarefas, insira ~run.
Selecione Utilizar shell sbt.
Clique em OK.
Na barra de menus, clique em Executar > "Executar o programa". Os resultados da execução aparecem na janela da ferramenta sbt shell.

Etapa 6: compilar o projeto como JAR

Você pode adicionar todas as configurações de build JAR ao projeto desejado. Esta etapa pressupõe que você só deseja criar um JAR baseado no projeto que foi configurado nas etapas anteriores.

Na barra de menus, clique em Arquivo > Estrutura do Projeto.
Na caixa de diálogo Estrutura do Projeto, clique em Configurações do Projeto > Artefatos.
Clique no ícone + (Adicionar).
Na lista suspensa, selecione JAR > a partir de módulos com dependências.
Na caixa de diálogo Criar JAR a partir de Módulos, em Módulo, selecione o nome do projeto.
Em Classe Principal, clique no ícone de pasta.
Na caixa de diálogo Selecionar Classe Principal, na guia Pesquisar por Nome, selecione SampleApp e clique em OK.
Para arquivos JAR de bibliotecas, selecione copiar para o diretório de saída e vincular por meio de manifesto.
Clique em OK para fechar a caixa de diálogo Criar JAR a partir de Módulos.
Clique em OK para fechar a caixa de diálogo Estrutura do Projeto.
Na barra de menus, clique em Compilar > Compilar Artefatos.
No menu de contexto exibido, selecione nome do projeto:jar > Compilar. Aguarde enquanto o sbt compila o seu JAR. Os resultados do build são exibidos na janela da ferramenta Saída de Build (Exibir > Janela de Ferramentas > Build).

O JAR é criado para a pasta do projeto out>artifacts><project-name>_jar. O nome do JAR é <project-name>.jar.

Etapa 7: exibir o terminal no IDE

Com a estrutura do projeto dbx agora em vigor, você está pronto para criar seu projeto dbx.

Exiba o terminal IntelliJ IDEA clicando em Exibição > Ferramenta Windows > Terminal na barra de menus e, em seguida, continue com Criar um projeto dbx.

Eclipse

Conclua as instruções a seguir para começar a usar Eclipse e Java com dbx. Essas instruções criam um projeto Java baseado em Maven mínimo que você pode usar para iniciar um projeto de dbx.

Em seu computador de desenvolvimento local, você deve ter o seguinte instalado, além dos requisitos em geral:

Uma versão do Eclipse. Estas instruções usam a edição para Desenvolvedores Java do IDE do Eclipse.
Uma edição do JRE (Java Runtime Environment) ou do Java Development Kit (JDK) 11, dependendo do sistema operacional do computador local. Embora qualquer edição do JRE ou do JDK 11 funcione, o Databricks até agora validou apenas o uso de dbx e do IDE do Eclipse para Desenvolvedores Java com o Eclipse 2022-03 R, que inclui o AdoptOpenJDK 11.

Siga estas etapas para começar a configurar a estrutura do projeto dbx:

Etapa 1: criar um projeto Java baseado em Maven

No Eclipse, clique em Arquivo > Novo > Projeto.
Na caixa de diálogo Novo Projeto, expanda Maven, selecione Projeto Maven e clique em Avançar.
Na caixa de diálogo Novo Maven Project, selecione Criar um projeto simples (ignorar seleção de arquétipo) e clique em Avançar.
Para a ID do Grupo, insira uma ID de grupo que esteja em conformidade com as regras de nome do pacote do Java. Estas etapas usam o nome de pacote com.example.demo. Se você inserir uma ID de grupo diferente, substitua-a ao longo destas etapas.
Para a ID do Artefato, insira um nome para o arquivo JAR sem o número de versão. Estas etapas usam o nome JAR dbx-demo. Se você inserir um nome diferente para o arquivo JAR, substitua-o ao longo destas etapas.
Clique em Concluir.

Etapa 2: adicionar uma classe ao pacote

Você pode adicionar qualquer classe ao pacote desejado. Este pacote conterá apenas uma classe chamada SampleApp.

Na exibição Gerenciador de Projetos (Janela > Mostrar Exibição >Gerenciador de Projetos), selecione o ícone do projeto nome do projeto e clique em Arquivo > Novo > Classe.
Na caixa de diálogo Nova Classe Java, em Pacote, insira com.example.demo.
Para Nome, insira SampleApp.
Em modificadores, selecione público.
Deixe a Superclasse em branco.
Em Quais stubs de método você deseja criar, selecione public static void Main(String[] args).
Clique em Concluir.

Etapa 3: adicionar dependências ao projeto

Na exibição Gerenciador de Projetos, clique duas vezes no nome do projeto> pom.xml.

Adicione as seguintes dependências como um elemento filho do elemento <project> e salve o arquivo:

<dependencies>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-sql_2.12</artifactId>
    <version>3.2.1</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_2.12</artifactId>
    <version>3.2.1</version>
  </dependency>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-hive_2.12</artifactId>
    <version>3.2.1</version>
    <scope>provided</scope>
  </dependency>
</dependencies>

Substitua:

2.12 com a versão dos clusters de destino do Scala.
3.2.1 com a versão do Spark dos clusters de destino.

Consulte a seção "Ambiente do sistema" nas notas de lançamento, versões e compatibilidade do Databricks Runtime para obter a versão do Databricks Runtime para seus clusters de destino.

Etapa 4: compilar o projeto

No arquivo do pom.xml projeto, adicione as seguintes propriedades do compilador Maven como um elemento filho do <project> elemento e salve o arquivo:

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.6</maven.compiler.source>
  <maven.compiler.target>1.6</maven.compiler.target>
</properties>

Na exibição Gerenciador de Projetos, clique com o botão direito do mouse no ícone do projeto nome do projeto e clique em Executar Como > Executar Configurações.
Na caixa de diálogo Executar Configurações, clique em Build do Maven.
Clique no ícone Nova configuração de inicialização.
Insira um nome para essa configuração de inicialização, por exemplo, compilação limpa.
Para o diretório Base, clique em Workspace, escolha o diretório do projeto e clique em OK.
Para metas, digite clean compile.
Clique em Executar. A saída da execução é exibida na visualização Console (Janela > Mostrar Visualização > Console).

Etapa 5: adicionar código ao projeto

Você pode adicionar qualquer código ao projeto desejado. Esta etapa pressupõe que você só deseja adicionar código a um arquivo chamado SampleApp.java para um pacote chamado com.example.demo.

No arquivo do src/main/java>com.example.demo>SampleApp.java projeto, adicione o código que você deseja dbx executar em lote em seus clusters de destino. (Se você não tiver nenhum código à mão, poderá usar o código Java no exemplo de código, listado no final deste artigo.)

Etapa 6: executar o projeto

Na exibição Gerenciador de Projetos, clique com o botão direito do mouse no ícone do projeto nome do projeto e clique em Executar Como > Executar Configurações.
Na caixa de diálogo Configurações de Execução, expanda Aplicativo Java e clique em Aplicativo.
Clique em Executar. A saída da execução é exibida no modo de exibição Console .

Etapa 7: compilar o projeto como JAR

Na exibição Gerenciador de Projetos, clique com o botão direito do mouse no ícone do projeto nome do projeto e clique em Executar Como > Executar Configurações.
Na caixa de diálogo Executar Configurações, clique em Build do Maven.
Clique no ícone Nova configuração de inicialização.
Insira um nome para essa configuração de inicialização, por exemplo, pacote limpo.
Para o diretório Base, clique em Workspace, escolha o diretório do projeto e clique em OK.
Para metas, digite clean package.
Clique em Executar. A saída da execução é exibida no modo de exibição Console .

O JAR é compilado na pasta <project-name>>target. O nome do JAR é <project-name>-0.0.1-SNAPSHOT.jar.

Observação

Se o JAR não aparecer na pasta target na janela Gerenciador de Projetos no início, você poderá tentar exibi-lo clicando com o botão direito do mouse no ícone do projeto nome do projeto e depois clicando em Atualizar.

Etapa 8: exibir o terminal no IDE

Com a estrutura do projeto dbx agora em vigor, você está pronto para criar seu projeto dbx. Para começar, defina Gerenciador de Projetos para mostrar os arquivos ocultos (arquivos começando com um ponto (./)) gerados pelo dbx, da seguinte maneira:

Na exibição Explorador de Projetos, clique no ícone de reticências (Menu Exibição) e, em seguida, clique em Filtros e Personalização.
Na caixa de diálogo Filtros e Personalização, na guia Filtros pré-definidos, desmarque a caixa .* recursos.
Clique em OK.

Em seguida, exiba o terminal do Eclipse da seguinte maneira:

Clique em Janela > Mostrar Visão > Terminal na barra de menus.
Se o prompt de comando do terminal não aparecer na visualização Terminal, clique no ícone Abrir um Terminal.
Use o cd comando para alternar para o diretório raiz do projeto.
Continue com Criar um projeto dbx.

Sem IDE (somente terminal)

Conclua as instruções a seguir para começar a usar um terminal e o Python com dbx.

Siga estas etapas para usar um terminal e começar a configurar a estrutura do projeto dbx:

No terminal, crie uma pasta em branco. Essas instruções usam uma pasta chamada dbx-demo (mas você pode dar à pasta raiz do projeto dbx qualquer nome desejado). Após criar a pasta, mude para ela.

Para Linux e macOS:
```
mkdir dbx-demo
cd dbx-demo
```
Para Windows:
```
md dbx-demo
cd dbx-demo
```
Crie um ambiente virtual do Python para este projeto executando o comando pipenv, com a opção a seguir, na raiz da pasta dbx-demo, onde <version> é a versão de destino do Python que você já instalou localmente, por exemplo 3.8.14.
```
pipenv --python <version>
```
Ativar seu ambiente virtual do Python executando pipenv shell.
```
pipenv shell
```
Continue com Criar um projeto dbx.

Criar um projeto dbx

Com a estrutura do projeto dbx em vigor conforme uma das seções anteriores, agora você está pronto para criar um dos seguintes tipos de projeto:

Criar um projeto dbx mínimo para Python
Criar um projeto dbx mínimo para Scala ou Java
Criar um projeto com modelo dbx para Python com suporte a CI/CD

Criar um projeto dbx mínimo para Python

O projeto dbx mínimo a seguir é a abordagem mais simples e rápida para começar a usar o Python e o dbx. Ele demonstra a execução em lote de um arquivo de código Python em um cluster existente do Azure Databricks para todas as finalidades no workspace do Azure Databricks.

Observação

Para criar um projeto de modelo dbx para Python que demonstra a execução em lote de código em clusters e clusters de trabalho para todas as finalidades, implantações de artefatos de código remoto e instalação da plataforma CI/CD, avance para Criar um projeto de modelo dbx para Python com suporte a CI/CD.

Para concluir esse procedimento, você deve ter um cluster de todas as finalidades existente em seu workspace. (Consulte Exibir computação ou Referência de configuração de computação.) Idealmente (mas não necessário), a versão do Python em seu ambiente virtual do Python deve corresponder à versão instalada neste cluster. Para identificar a versão do Python no cluster, use o terminal Web do cluster para executar o comando python --version.

python --version

No terminal, na pasta raiz do projeto dbx , execute o dbx configure comando com a opção a seguir. Esse comando cria uma pasta oculta .dbx dentro da pasta raiz do projeto dbx . Esta pasta .dbx contém arquivos lock.json e project.json.
```
dbx configure --profile DEFAULT --environment default
```
Observação

O arquivo project.json define um ambiente chamado default juntamente com uma referência ao perfil DEFAULT em seu arquivo .databrickscfg. Se você quiser dbx usar um perfil diferente, substitua --profile DEFAULT pelo --profile seguido pelo nome do perfil de destino no dbx configure comando.

Por exemplo, se você tiver um perfil chamado DEV no seu arquivo .databrickscfg e quiser que o dbx o use em vez do perfil DEFAULT, seu arquivo project.json poderá ter a seguinte aparência e, nesse caso, você também substituirá --environment default por --environment dev no comando dbx configure:
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}
```
Se você deseja que dbx use as variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN em vez de um perfil em seu arquivo .databrickscfg, deixe de fora a opção --profile do comando dbx configure.
Crie uma pasta nomeada conf dentro da pasta raiz do projeto dbx .

Para Linux e macOS:
```
mkdir conf
```
Para Windows:
```
md conf
```
Adicione um arquivo nomeado como deployment.yaml ao conf diretório, com o seguinte conteúdo do arquivo:
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_python_task:
          python_file: 'file://dbx-demo-job.py'
```
Observação

A palavra em letras minúsculas default contida no arquivo deployment.yaml é uma referência ao perfil em letras maiúsculas DEFAULT dentro do seu arquivo .databrickscfg. Se você quiser dbx usar um perfil diferente, substitua default pelo nome do seu perfil de destino.

Por exemplo, se você tiver um perfil chamado DEV em seu arquivo .databrickscfg e quiser que dbx o use em vez do perfil DEFAULT, seu arquivo deployment.yaml poderá ter a seguinte aparência:
```
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_python_task:
          python_file: 'file://dbx-demo-job.py'
  dev:
    workflows:
      - name: '<some-other-job-name>'
        spark_python_task:
          python_file: 'file://<some-other-filename>.py'
```
Se você quiser que dbx use as variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN em vez de um perfil no arquivo .databrickscfg, deixe default no deployment.yaml como está. dbx usará essa referência por padrão.
Dica

Para adicionar pares chave-valor de configuração do Spark a um trabalho, use o campo spark_conf, por exemplo:
```
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: '-verbose:gc -XX:+PrintGCDetails'
        # ...
```
Para adicionar permissões a um trabalho, use o access_control_list campo, por exemplo:
```
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        access_control_list:
          - user_name: 'someone@example.com'
            permission_level: 'IS_OWNER'
          - group_name: 'some-group'
            permission_level: 'CAN_VIEW'
        # ...
```
Observe que o campo access_control_list deve ser exaustivo; portanto, o proprietário da tarefa deve ser adicionado à lista, juntamente com outras permissões de usuário e grupo.
Adicione o código a ser executado no cluster a um arquivo nomeado dbx-demo-job.py e adicione o arquivo à pasta raiz do projeto dbx. (Se você não tiver nenhum código à mão, poderá usar o código Python no Exemplo de código, listado no final deste artigo.)

Observação

Você não tem que nomear esse dbx-demo-job.py arquivo. Se você escolher um nome de arquivo diferente, atualize o campo python_file no arquivo conf/deployment.yaml para corresponder.
Execute o comando de comando dbx execute com as seguintes opções. Neste comando, substitua <existing-cluster-id> pela ID do computador clássico no seu workspace. (Para obter a ID, consulte a URL e a ID do recurso de computação.)
```
dbx execute --cluster-id=<existing-cluster-id> dbx-demo-job --no-package
```
Para exibir os resultados da execução localmente, consulte a saída do terminal. Para exibir os resultados da execução em seu cluster, vá para o painel Standard output na guia Logs de Driver do cluster. (Confira Driver de computação e logs de trabalho.)
Continue com os Próximos passos.

Criar um projeto dbx mínimo para Scala ou Java

O projeto dbx mínimo a seguir é a abordagem mais simples e rápida para começar a usar dbx e Scala ou Java. Ele demonstra a implantação de um único JAR do Scala ou Java no workspace do Azure Databricks e, em seguida, a execução desse JAR implantado em um cluster de trabalhos do Azure Databricks no workspace do Azure Databricks.

Observação

O Azure Databricks limita o modo como você pode executar o código Scala e Java em clusters:

Não é possível executar apenas um arquivo Scala ou Java como um trabalho em um cluster, como você pode fazer com um arquivo Python. Para executar o código Scala ou Java, primeiro você precisa compilá-lo em um JAR.
Você pode executar um JAR como um trabalho em um cluster multiuso. No entanto, você não pode reinstalar nenhuma atualização para esse JAR no mesmo cluster para todas as finalidades. Nesse caso, você deve usar um cluster de tarefas. Esta seção usa a abordagem de cluster de trabalho.
Primeiro, você deve implantar o JAR em seu workspace do Azure Databricks antes de executar esse JAR implantado em qualquer cluster de uso geral ou cluster de trabalhos nesse workspace.

No terminal, na pasta raiz do projeto, execute o dbx configure comando com a opção a seguir. Esse comando cria uma pasta oculta .dbx dentro da pasta raiz do projeto. Esta pasta .dbx contém arquivos lock.json e project.json.
```
dbx configure --profile DEFAULT --environment default
```
Observação

O arquivo project.json define um ambiente chamado default juntamente com uma referência ao perfil DEFAULT em seu arquivo .databrickscfg. Se você quiser dbx usar um perfil diferente, substitua --profile DEFAULT pelo --profile seguido pelo nome do perfil de destino no dbx configure comando.

Por exemplo, se você tiver um perfil chamado DEV no seu arquivo .databrickscfg e quiser que o dbx o use em vez do perfil DEFAULT, seu arquivo project.json poderá ter a seguinte aparência e, nesse caso, você também substituirá --environment default por --environment dev no comando dbx configure:
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Workspace/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}
```
Se você deseja que dbx use as variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN em vez de um perfil em seu arquivo .databrickscfg, deixe de fora a opção --profile do comando dbx configure.
Crie uma pasta nomeada conf dentro da pasta raiz do projeto.

Para Linux e macOS:
```
mkdir conf
```
Para Windows:
```
md conf
```
Adicione um arquivo chamado deployment.yaml ao diretório conf, com o seguinte conteúdo mínimo do arquivo:
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        new_cluster:
          spark_version: '10.4.x-scala2.12'
          node_type_id: 'Standard_DS3_v2'
          num_workers: 2
          instance_pool_id: 'my-instance-pool'
        libraries:
          - jar: 'file://out/artifacts/dbx_demo_jar/dbx-demo.jar'
        spark_jar_task:
          main_class_name: 'com.example.demo.SampleApp'
```
Substitua:
- O valor de spark_version com a versão de execução apropriada para seu cluster de tarefas alvo.
- O valor de node_type_id com o tipo de nó de Trabalho apropriado para o cluster de trabalhos de destino.
- O valor de instance_pool_id com a ID de um pool de instâncias existente em seu workspace, para habilitar a execução mais rápida de trabalhos. Se você não tiver um pool de instâncias existente disponível ou não quiser usar um pool de instâncias, remova essa linha inteira.
- O valor de jar com o caminho do projeto até o JAR. Para o IntelliJ IDEA com Scala, pode ser file://out/artifacts/dbx_demo_jar/dbx-demo.jar. Para o IDE do Eclipse com Java, pode ser file://target/dbx-demo-0.0.1-SNAPSHOT.jar.
- O valor de main_class_name com o nome da classe principal no JAR, por exemplo, com.example.demo.SampleApp.
Observação

O arquivo deployment.yaml contém a palavra default, que é uma referência ao ambiente default no arquivo .dbx/project.json, que por sua vez é uma referência ao perfil DEFAULT em seu arquivo .databrickscfg. Se você deseja que dbx use um perfil diferente, substitua default neste arquivo deployment.yaml pela referência correspondente no arquivo .dbx/project.json, que por sua vez faz referência ao perfil correspondente em seu arquivo .databrickscfg.

Por exemplo, se você tiver um perfil chamado DEV em seu arquivo .databrickscfg e quiser que dbx o use em vez do perfil DEFAULT, seu arquivo deployment.yaml poderá ter a seguinte aparência:
```
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        # ...
  dev:
    workflows:
      - name: '<some-other-job-name>'
        # ...
```
Se você quiser que dbx use as variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN em vez de um perfil no arquivo .databrickscfg, deixe default no deployment.yaml como está. dbx usará as configurações de ambiente default (exceto o valor profile) no arquivo .dbx/project.json por padrão.
Dica

Para adicionar pares chave-valor de configuração do Spark a um trabalho, use o campo spark_conf, por exemplo:
```
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        spark_conf:
          spark.speculation: true
          spark.streaming.ui.retainedBatches: 5
          spark.driver.extraJavaOptions: '-verbose:gc -XX:+PrintGCDetails'
        # ...
```
Para adicionar permissões a um trabalho, use o access_control_list campo, por exemplo:
```
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        access_control_list:
          - user_name: 'someone@example.com'
            permission_level: 'IS_OWNER'
          - group_name: 'some-group'
            permission_level: 'CAN_VIEW'
        # ...
```
Observe que o campo access_control_list deve ser exaustivo; portanto, o proprietário da tarefa deve ser adicionado à lista, juntamente com outras permissões de usuário e grupo.
Execute o comando dbx deploy. dbx implanta o JAR no local no .dbx/project.json caminho do artifact_location arquivo para o ambiente correspondente. dbx também implanta os arquivos do projeto como parte de um experimento do MLflow, no caminho listado no arquivo .dbx/project.json para o local correspondente no ambiente workspace_directory.
```
dbx deploy --no-package
```
Execute o comando dbx launch com as opções a seguir. Esse comando executa o trabalho com o nome correspondente em conf/deployment.yaml. Para localizar o JAR implantado para ser executado como parte do trabalho, dbx referencia a localização no caminho do arquivo .dbx/project.jsonartifact_location para o ambiente correspondente. Para determinar qual JAR específico deve ser executado, dbx referencia o experimento MLflow no caminho listado no arquivo .dbx/project.json para o ambiente correspondente.
```
dbx launch dbx-demo-job
```
Para exibir os resultados da execução do trabalho em seu cluster de trabalhos, consulte Exibir trabalhos e pipelines.
Para exibir o experimento referenciado pelo trabalho, consulte Organizar execuções de treinamento com experimentos do MLflow.
Continue com Próximas etapas.

Criar um projeto com modelo dbx para Python com suporte a CI/CD

O projeto de modelo dbx a seguir para Python demonstra suporte para a execução em lote de código Python em clusters em clusters para todas as finalidades e clusters de trabalhos do Azure Databricks em seus workspaces do Azure Databricks, implantações de artefatos de código remoto e configuração da plataforma CI/CD. (Para criar um projeto dbx mínimo para Python que demonstra apenas a execução de um arquivo de código Python em lote em um cluster existente para todas as finalidades, avance para Criar um projeto dbx mínimo para Python.)

No terminal, na pasta raiz do projeto dbx , execute o dbx init comando.
```
dbx init
```
Para project_name, insira um nome para seu projeto ou pressione ENTER para aceitar o nome de projeto padrão.
Para versões, insira um número de versão inicial para seu projeto ou pressione ENTER para aceitar a versão de projeto padrão.
Para nuvem, selecione o número que corresponde à versão de nuvem do Azure Databricks que você deseja que seu projeto use ou pressione ENTER para aceitar a padrão.
Para cicd_tool, selecione o número que corresponde à ferramenta CI/CD com suporte que você deseja que seu projeto use ou pressione ENTER para aceitar a padrão.
Para project_slug, insira um prefixo que você deseja usar para recursos em seu projeto ou pressione ENTER para aceitar o padrão.
Em workspace_directory, insira o caminho local para o diretório do workspace do seu projeto ou pressione ENTER para aceitar o padrão.
Para artifact_location, insira o caminho no workspace do Azure Databricks para onde os artefatos do projeto serão gravados ou pressione Enter para aceitar o padrão.
Para perfil, digite o nome do perfil de autenticação da CLI que você deseja que seu projeto use ou pressione Enter para aceitar o padrão.

Dica

Você pode ignorar as etapas anteriores executando dbx init com parâmetros de modelo embutidos em código, por exemplo:

dbx init --template="python_basic" \
-p "project_name=cicd-sample-project" \
-p "cloud=Azure" \
-p "cicd_tool=Azure DevOps" \
-p "profile=DEFAULT" \
--no-input

dbxcalcula os parâmetros project_slug, workspace_directory e artifact_location automaticamente. Esses três parâmetros são opcionais e são úteis somente em casos de uso mais avançados.

Consulte o comando init na Referência da CLI na documentação dbx.

Confira também as Próximas etapas.

Exemplo de código

Se você não tiver nenhum código prontamente disponível para execução em lote com dbx, é possível experimentar fazendo o lote dbx executar o código a seguir. Esse código cria uma tabela pequena em seu workspace, consulta a tabela e exclui a tabela.

Dica

Se desejar deixar a tabela em seu workspace em vez de excluí-la, comente a última linha de código neste exemplo antes de executá-lo em lote com dbx.

Python

# For testing and debugging of local objects, run
# "pip install pyspark=X.Y.Z", where "X.Y.Z"
# matches the version of PySpark
# on your target clusters.
from pyspark.sql import SparkSession

from pyspark.sql.types import *
from datetime import date

spark = SparkSession.builder.appName("dbx-demo").getOrCreate()

# Create a DataFrame consisting of high and low temperatures
# by airport code and date.
schema = StructType([
   StructField('AirportCode', StringType(), False),
   StructField('Date', DateType(), False),
   StructField('TempHighF', IntegerType(), False),
   StructField('TempLowF', IntegerType(), False)
])

data = [
   [ 'BLI', date(2021, 4, 3), 52, 43],
   [ 'BLI', date(2021, 4, 2), 50, 38],
   [ 'BLI', date(2021, 4, 1), 52, 41],
   [ 'PDX', date(2021, 4, 3), 64, 45],
   [ 'PDX', date(2021, 4, 2), 61, 41],
   [ 'PDX', date(2021, 4, 1), 66, 39],
   [ 'SEA', date(2021, 4, 3), 57, 43],
   [ 'SEA', date(2021, 4, 2), 54, 39],
   [ 'SEA', date(2021, 4, 1), 56, 41]
]

temps = spark.createDataFrame(data, schema)

# Create a table on the cluster and then fill
# the table with the DataFrame's contents.
# If the table already exists from a previous run,
# delete it first.
spark.sql('USE default')
spark.sql('DROP TABLE IF EXISTS demo_temps_table')
temps.write.saveAsTable('demo_temps_table')

# Query the table on the cluster, returning rows
# where the airport code is not BLI and the date is later
# than 2021-04-01. Group the results and order by high
# temperature in descending order.
df_temps = spark.sql("SELECT * FROM demo_temps_table " \
   "WHERE AirportCode != 'BLI' AND Date > '2021-04-01' " \
   "GROUP BY AirportCode, Date, TempHighF, TempLowF " \
   "ORDER BY TempHighF DESC")
df_temps.show()

# Results:
#
# +-----------+----------+---------+--------+
# |AirportCode|      Date|TempHighF|TempLowF|
# +-----------+----------+---------+--------+
# |        PDX|2021-04-03|       64|      45|
# |        PDX|2021-04-02|       61|      41|
# |        SEA|2021-04-03|       57|      43|
# |        SEA|2021-04-02|       54|      39|
# +-----------+----------+---------+--------+

# Clean up by deleting the table from the cluster.
spark.sql('DROP TABLE demo_temps_table')

Scala (linguagem de programação)

package com.example.demo

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.types._
import org.apache.spark.sql.Row
import java.sql.Date

object SampleApp {
  def main(args: Array[String]) {
    val spark = SparkSession.builder().master("local").getOrCreate()

    val schema = StructType(Array(
      StructField("AirportCode", StringType, false),
      StructField("Date", DateType, false),
      StructField("TempHighF", IntegerType, false),
      StructField("TempLowF", IntegerType, false)
    ))

    val data = List(
      Row("BLI", Date.valueOf("2021-04-03"), 52, 43),
      Row("BLI", Date.valueOf("2021-04-02"), 50, 38),
      Row("BLI", Date.valueOf("2021-04-01"), 52, 41),
      Row("PDX", Date.valueOf("2021-04-03"), 64, 45),
      Row("PDX", Date.valueOf("2021-04-02"), 61, 41),
      Row("PDX", Date.valueOf("2021-04-01"), 66, 39),
      Row("SEA", Date.valueOf("2021-04-03"), 57, 43),
      Row("SEA", Date.valueOf("2021-04-02"), 54, 39),
      Row("SEA", Date.valueOf("2021-04-01"), 56, 41)
    )

    val rdd = spark.sparkContext.makeRDD(data)
    val temps = spark.createDataFrame(rdd, schema)

    // Create a table on the Databricks cluster and then fill
    // the table with the DataFrame's contents.
    // If the table already exists from a previous run,
    // delete it first.
    spark.sql("USE default")
    spark.sql("DROP TABLE IF EXISTS demo_temps_table")
    temps.write.saveAsTable("demo_temps_table")

    // Query the table on the Databricks cluster, returning rows
    // where the airport code is not BLI and the date is later
    // than 2021-04-01. Group the results and order by high
    // temperature in descending order.
    val df_temps = spark.sql("SELECT * FROM demo_temps_table " +
      "WHERE AirportCode != 'BLI' AND Date > '2021-04-01' " +
      "GROUP BY AirportCode, Date, TempHighF, TempLowF " +
      "ORDER BY TempHighF DESC")
    df_temps.show()

    // Results:
    //
    // +-----------+----------+---------+--------+
    // |AirportCode|      Date|TempHighF|TempLowF|
    // +-----------+----------+---------+--------+
    // |        PDX|2021-04-03|       64|      45|
    // |        PDX|2021-04-02|       61|      41|
    // |        SEA|2021-04-03|       57|      43|
    // |        SEA|2021-04-02|       54|      39|
    // +-----------+----------+---------+--------+

    // Clean up by deleting the table from the Databricks cluster.
    spark.sql("DROP TABLE demo_temps_table")
  }
}

Java

package com.example.demo;

import java.util.ArrayList;
import java.util.List;
import java.sql.Date;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.*;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.Dataset;

public class SampleApp {
  public static void main(String[] args) {
    SparkSession spark = SparkSession
      .builder()
      .appName("Temps Demo")
      .config("spark.master", "local")
      .getOrCreate();

    // Create a Spark DataFrame consisting of high and low temperatures
    // by airport code and date.
    StructType schema = new StructType(new StructField[] {
      new StructField("AirportCode", DataTypes.StringType, false, Metadata.empty()),
      new StructField("Date", DataTypes.DateType, false, Metadata.empty()),
      new StructField("TempHighF", DataTypes.IntegerType, false, Metadata.empty()),
      new StructField("TempLowF", DataTypes.IntegerType, false, Metadata.empty()),
    });

    List<Row> dataList = new ArrayList<Row>();
    dataList.add(RowFactory.create("BLI", Date.valueOf("2021-04-03"), 52, 43));
    dataList.add(RowFactory.create("BLI", Date.valueOf("2021-04-02"), 50, 38));
    dataList.add(RowFactory.create("BLI", Date.valueOf("2021-04-01"), 52, 41));
    dataList.add(RowFactory.create("PDX", Date.valueOf("2021-04-03"), 64, 45));
    dataList.add(RowFactory.create("PDX", Date.valueOf("2021-04-02"), 61, 41));
    dataList.add(RowFactory.create("PDX", Date.valueOf("2021-04-01"), 66, 39));
    dataList.add(RowFactory.create("SEA", Date.valueOf("2021-04-03"), 57, 43));
    dataList.add(RowFactory.create("SEA", Date.valueOf("2021-04-02"), 54, 39));
    dataList.add(RowFactory.create("SEA", Date.valueOf("2021-04-01"), 56, 41));

    Dataset<Row> temps = spark.createDataFrame(dataList, schema);

    // Create a table on the Databricks cluster and then fill
    // the table with the DataFrame's contents.
    // If the table already exists from a previous run,
    // delete it first.
    spark.sql("USE default");
    spark.sql("DROP TABLE IF EXISTS demo_temps_table");
    temps.write().saveAsTable("demo_temps_table");

    // Query the table on the Databricks cluster, returning rows
    // where the airport code is not BLI and the date is later
    // than 2021-04-01. Group the results and order by high
    // temperature in descending order.
    Dataset<Row> df_temps = spark.sql("SELECT * FROM demo_temps_table " +
      "WHERE AirportCode != 'BLI' AND Date > '2021-04-01' " +
      "GROUP BY AirportCode, Date, TempHighF, TempLowF " +
      "ORDER BY TempHighF DESC");
    df_temps.show();

    // Results:
    //
    // +-----------+----------+---------+--------+
    // |AirportCode|      Date|TempHighF|TempLowF|
    // +-----------+----------+---------+--------+
    // |        PDX|2021-04-03|       64|      45|
    // |        PDX|2021-04-02|       61|      41|
    // |        SEA|2021-04-03|       57|      43|
    // |        SEA|2021-04-02|       54|      39|
    // +-----------+----------+---------+--------+

    // Clean up by deleting the table from the Databricks cluster.
    spark.sql("DROP TABLE demo_temps_table");
  }
}

Próximas etapas

Estenda o arquivo conf/deployment.yaml para dar suporte a vários tipos de definições de cluster de uso geral e de trabalho.
Declare trabalhos multitarefa em seu arquivo conf/deployment.yaml.
Faça referência às propriedades nomeadas no arquivo conf/deployment.yaml.
Execute o código em modo batch como novas tarefas em clusters com o comando dbx execute.

Recursos adicionais

Implantar artefatos de código em lote no armazenamento de workspace do Azure Databricks com o comando dbx deploy.
Executa em lote trabalhos existentes em clusters com o comando dbx launch.
Use o dbx para executar a implantação e a inicialização do fluxo de trabalho baseado em ativos.
Agendar implantações de fluxo de trabalho.
Saiba mais sobre dbx e CI/CD.
Documentação do dbx
Repositório databrickslabs/dbx no GitHub
Limitações do dbx

Comentários

Esta página foi útil?

Last updated on 2026-01-24