Pular para o conteúdo principal
Última atualização em

dbx da Databricks Labs

importante

Essa documentação foi descontinuada e pode não estar atualizada.

Databricks recomenda que o senhor use Databricks ativo Bundles em vez de dbx da Databricks Labs. Consulte O que são Databricks ativo Bundles? e Migrar de dbx para bundles.

nota

Este artigo cobre dbx do Databricks Labs, que é fornecido no estado em que se encontra e não é suportado pelo Databricks por meio do canal do cliente do suporte técnico. Perguntas e solicitações de recurso podem ser comunicadas por meio da página Issues do repositório databrickslabs/dbx em GitHub.

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

dbx simplifica os processos de lançamento e implementação de trabalhos em vários ambientes. Isso também ajuda a empacotar o projeto e entregá-lo ao ambiente Databricks de forma versionada. Projetado em CLIprimeiro, ele foi desenvolvido para ser usado ativamente dentro do pipeline CI/CD e como parte de ferramentas locais (como IDEs, incluindo Visual Studio Code e PyCharm).

O fluxo de trabalho de desenvolvimento típico do site dbx é o seguinte:

  1. Crie um repositório remoto com um provedor Git compatível com a Databricks, se o senhor ainda não tiver um repositório remoto disponível.

  2. Clone o repositório remoto em seu Databricks workspace.

  3. Crie ou mova um Notebook Databricks para o repositório clonado em seu Databricks workspace. Use este Notebook para começar a criar um protótipo do código que o senhor deseja que o Databricks clustering execute.

  4. Para aprimorar e modularizar o código do Notebook adicionando classes e funções auxiliares separadas, arquivos de configuração e testes, passe a usar uma máquina de desenvolvimento local com dbx, seu IDE preferido, e Git instalado.

  5. Clone seu repositório remoto em sua máquina de desenvolvimento local.

  6. Mova seu código do Notebook para um ou mais arquivos de código locais.

  7. Ao codificar localmente, envie seu trabalho do repositório local para o repositório remoto. Além disso, sincronize o repositório remoto com o Databricks workspace.

dica

Como alternativa, o senhor pode usar o dbx sync para sincronizar automaticamente as alterações de arquivos locais com os arquivos correspondentes no site workspace, em tempo real.

  1. Continue usando o Notebook em seu Databricks workspace para prototipagem rápida e continue movendo o código validado do Notebook para a máquina local. Continue usando seu IDE local para tarefas como modularização de código, autocompletar código, linting, teste de unidade e depuração passo a passo de código e objetos que não exigem uma conexão ativa com o site Databricks.

  2. Use dbx para lotes executar seu código local em seu clustering de destino, conforme desejado. (Isso é semelhante à execução do script spark-submit no diretório Spark's bin para iniciar aplicativos em um cluster Spark ).

  3. Quando o senhor estiver pronto para a produção, use uma plataforma CI/CD, como GitHub Actions, Azure DevOps, ou GitLab para automatizar a execução do código do repositório remoto em seu cluster.

Requisitos​

Para usar o dbx, é necessário ter os seguintes itens instalados no computador de desenvolvimento local, independentemente de o código usar Python, Scala ou Java:

  • Python versão 3.8 ou acima.

    Se o seu código usa Python, o senhor deve usar uma versão de Python que corresponda à que está instalada no clustering de destino. Para obter a versão do Python que está instalada em um cluster existente, o python --version senhor pode usar o terminal da Web do cluster para executar o comando. Consulte também a seção "System environment" (Ambiente do sistema) no site Databricks Runtime notas sobre versões e compatibilidade da versão Databricks Runtime para o seu clustering de destino.

  • pip.

  • Se o seu código usa Python, um método para criar ambientes virtuais Python para garantir que o senhor esteja usando as versões corretas de Python e as dependências do pacote em seus projetos dbx. Este artigo aborda o pipenv.

  • dbx versão 0.8.0 ou acima. O senhor pode instalar esse pacote a partir do Python pacote Index (PyPI) executando pip install dbx.

    Para confirmar que o site dbx está instalado, execute o seguinte comando:

    Bash
    dbx --version

    Se o número da versão for retornado, o dbx será instalado.

    Se o número da versão for abaixo de 0.8.0, atualize o site dbx executando o seguinte comando e, em seguida, verifique novamente o número da versão:

    Bash
    pip install dbx --upgrade
    dbx --version

    # Or ...
    python -m pip install dbx --upgrade
    dbx --version

  • O site Databricks CLI versão 0.18 ou abaixo, configurado com autenticação. A CLI legada da Databricks (Databricks CLI versão 0.17) é instalada automaticamente quando o senhor instala o site dbx. Essa autenticação pode ser configurada em sua máquina de desenvolvimento local em um ou em ambos os seguintes locais:

    • Dentro das variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN (começando com o legado Databricks CLI versão 0.8.0).
    • Em um perfil de configuração do Databricks em seu arquivo .databrickscfg.

    dbx procura credenciais de autenticação nesses dois locais, respectivamente. dbx usa somente o primeiro conjunto de credenciais correspondentes que encontra.

nota

dbx não suporta o uso de um .netrc para autenticação, começando com a versão 0.17.2 do Databricks CLI legado. Para verificar a versão instalada do legado Databricks CLI , execute o comando databricks --version.

  • git para enviar e sincronizar alterações de código locais e remotas.

Continue com as instruções para um dos seguintes IDEs:

nota

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

dbx é otimizado para trabalhar com arquivos de código Python de arquivo único e arquivos JAR Scala e Java compilados. dbx não funciona com arquivos de código R de arquivo único ou pacote de código R compilado. Isso ocorre porque dbx trabalha com os Jobs API 2.0 e 2.1, e esses APIs não podem executar arquivos de código R de arquivo único ou pacote de código R compilado como Job.

Código do Visual Studio​

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

Em sua máquina de desenvolvimento local, você deve ter o seguinte instalado, além dos requisitos gerais:

Siga estas passos para começar a configurar sua estrutura de projeto dbx :

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

    No Linux e macOS:

    Bash
    mkdir dbx-demo
    cd dbx-demo
    code .
dica

Se command not found: code for exibido depois que o senhor executar code ., consulte Launching from the comando line no site Microsoft.

No Windows:

PowerShell
md dbx-demo
cd dbx-demo
code .

  1. No Visual Studio Code, crie um ambiente virtual Python para esse projeto:

    1. Na barra de menus, clique em view > Terminal .

    2. Na raiz da pasta dbx-demo, execute o comando pipenv com a seguinte opção, em que <version> é a versão de destino de Python que o senhor já tem instalada localmente (e, idealmente, uma versão que corresponda à versão de Python do clustering de destino), por exemplo, 3.8.14.

      Bash
      pipenv --python <version>

      Anote o valor Virtualenv location na saída do comando pipenv , pois você precisará dele na próxima passo.

  2. Selecione o interpretador Python de destino e, em seguida, ative o ambiente virtual Python:

    1. Na barra de menus, clique em Exibir > Paleta de comandos , digite Python: Select e clique em Python: Select Interpreter.
    2. Selecione o interpretador Python no caminho para o ambiente virtual Python que o senhor acabou de criar. (Esse caminho é listado como o valor Virtualenv location na saída do comando pipenv ).
    3. Na barra de menus, clique em view > comando Palette , digite Terminal: Create e clique em Terminal: Create New Terminal .

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

  3. Continue com Criar um projeto dbx.

PyCharm​

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

Em sua máquina de desenvolvimento local, o senhor deve ter o PyCharm instalado, além dos requisitos gerais.

Siga estas passos para começar a configurar sua estrutura de projeto dbx :

  1. No PyCharm, na barra de menus, clique em File > New Project .
  2. Na caixa de diálogo Criar projeto , escolha um local para seu novo projeto.
  3. Expansão do interpretador Python: Novo ambiente Pipenv .
  4. Selecione Novo ambiente usando , se ainda não estiver selecionado, e selecione Pipenv na lista suspensa.
  5. Para o intérprete Base , selecione o local que contém o intérprete Python para a versão de destino de Python que o senhor já tem instalada localmente (e, idealmente, uma versão que corresponda à versão de Python do clustering de destino).
  6. Para o executável Pipenv , selecione o local que contém sua instalação local do pipenv, se ela ainda não tiver sido detectada automaticamente.
  7. Se você quiser criar um projeto dbx mínimo e quiser usar o arquivo main.py com esse projeto dbx mínimo, selecione a caixa de script de boas-vindas Criar um main.py . Caso contrário, desmarque essa caixa.
  8. Clique em Criar .
  9. Na janela da ferramenta Projeto , clique com o botão direito do mouse na pasta raiz do projeto e clique em Abrir no Terminal > .
  10. Continue com Criar um projeto dbx.

IntelliJ IDEA​

Siga as instruções a seguir para começar a usar o IntelliJ IDEA e o Scala com o site dbx. Estas instruções criam um projeto Scala mínimo baseado em sbt que o senhor pode usar para iniciar um projeto dbx.

Em sua máquina de desenvolvimento local, você deve ter o seguinte instalado, além dos requisitos gerais:

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

Siga estas passos para começar a configurar sua estrutura de projeto dbx :

Etapa 1: Criar um projeto Scala baseado em sbt​

  1. Em IntelliJ IDEA, dependendo do seu view, clique em Projects > New Project ou File > New > Project .
  2. Na caixa de diálogo New Project , clique em Scala , clique em sbt e, em seguida, clique em Next .
  3. Insira um nome de projeto e um local para o projeto.
  4. Para o JDK , selecione sua instalação do OpenJDK 8 JRE.
  5. Para sbt , escolha a versão mais alta disponível de sbt listada.
  6. Para Scala o ideal é escolher a versão do site Scala que corresponda à versão do site Scala do clustering de destino. Consulte a seção "System environment" (Ambiente do sistema) no site Databricks Runtime notas sobre versões e compatibilidade da versão Databricks Runtime para o seu clustering de destino.
  7. Ao lado de Scala , selecione a caixa Sources (Fontes ) se ela ainda não estiver selecionada.
  8. Adicione um prefixo de pacote a Package Prefix . Esses passos usam o prefixo do pacote com.example.demo. Se você especificar um prefixo de pacote diferente, substitua o prefixo do pacote ao longo dessas passos.
  9. Clique em Concluir .

Etapa 2: Adicionar um objeto ao pacote​

O senhor pode adicionar quaisquer objetos necessários ao seu pacote. Esse pacote contém um único objeto chamado SampleApp.

  1. Na janela da ferramenta Projeto (Exibir > Ferramenta Windows > Projeto ), clique com o botão direito do mouse na pasta project-name > src > main > Scala e clique em New > Scala Class .

  2. Escolha Objeto , digite o nome do objeto e pressione Enter. Por exemplo, digite SampleApp. Se você inserir um nome de objeto diferente aqui, certifique-se de substituir o nome ao longo dessas etapas.

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

    Scala
    package com.example.demo

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

Etapa 3: criar o projeto​

Adicione quaisquer configurações e dependências de construção de projeto necessárias ao seu projeto. Esta passo assume que você está construindo um projeto que foi configurado nas passos anteriores e depende apenas das seguintes bibliotecas.

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

    Scala
    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 o senhor escolheu anteriormente para este projeto.
    • 3.2.1 com a versão do Spark que o senhor escolheu anteriormente para este projeto.
    • dbx-demo com o nome do seu projeto.
    • com.example.demo com o nome do prefixo do seu pacote.

  2. Na barra de menus, clique em view > Tool Windows > sbt .

  3. Na janela da ferramenta sbt , clique com o botão direito do mouse no nome do seu projeto e clique em Recarregar projeto sbt. Aguarde até que o site sbt conclua o download das dependências do projeto em um repositório de artefatos da Internet, como o Coursier ou o Ivy by default, dependendo da sua versão do sbt. O senhor pode ver o progresso do download na barra de status. Se você adicionar ou alterar mais dependências a esse projeto, deverá repetir essa etapa de recarregamento do projeto para cada conjunto de dependências adicionado ou alterado.

  4. Na barra de menus, clique em IntelliJ IDEA > Preferences .

  5. Na caixa de diálogo Preferências , clique em Build, Execution, Deployment > Build Tools > sbt .

  6. Em JVM , para JRE , selecione sua instalação do OpenJDK 8 JRE.

  7. Em projetos sbt , selecione o nome do seu projeto.

  8. No shell do sbt , selecione builds .

  9. Clique em OK .

  10. Na barra de menu, clique em Build > Build Project . Os resultados da compilação aparecem na janela da ferramenta sbt shell (view > Tool Windows > sbt shell ).

Etapa 4: adicionar código ao projeto​

Adicione qualquer código necessário ao seu projeto. Esta passo pressupõe que você deseja apenas adicionar código ao arquivo SampleApp.scala no pacote example .

No arquivo src > main > scala > SampleApp.scala do projeto, adicione o código que o senhor deseja dbx para lotes execução em seu clustering de destino. Para testes básicos, use o código Scala de exemplo na seção Exemplo de código.

Etapa 5: execução do projeto​

  1. Na barra de menus, clique em execução > Edit Configurations .
  2. Na caixa de diálogo Configurações de execução/Debug , clique no ícone + (Adicionar nova configuração ), ou Adicionar nova , ou Adicionar nova configuração de execução .
  3. No menu suspenso, clique em sbt tarefa .
  4. Em Name , digite um nome para a configuração, por exemplo, executar o programa .
  5. Para tarefa , digite ~run.
  6. Selecione Use sbt shell .
  7. Clique em OK .
  8. Na barra de menus, clique em execução > execução 'executar o programa' . Os resultados da execução aparecem na janela da ferramenta sbt shell .

Etapa 6: Compilar o projeto como um JAR​

Você pode adicionar qualquer configuração de construção JAR que desejar ao seu projeto. Esta passo pressupõe que você deseja construir apenas um JAR baseado no projeto que foi configurado nas passos anteriores.

  1. Na barra de menu, clique em Arquivo > Estrutura do projeto .
  2. Na caixa de diálogo Estrutura do projeto , clique em Configurações do projeto > Artifacts .
  3. Clique no ícone + ( Adicionar ).
  4. Na lista suspensa, selecione JAR > De módulos com dependências .
  5. Na caixa de diálogo Create JAR from Modules , em Module , selecione o nome do seu projeto.
  6. Para Classe principal , clique no ícone da pasta.
  7. Na caixa de diálogo Select Main Class (Selecionar classe principal ), em Search by Name (Pesquisar por nome ) tab, selecione SampleApp e clique em OK .
  8. Para arquivosJAR da biblioteca , selecione copiar para o diretório de saída e vincular via manifesto .
  9. Clique em OK para fechar a caixa de diálogo Create JAR from Modules .
  10. Clique em OK para fechar a caixa de diálogo Estrutura do projeto .
  11. Na barra de menu, clique em Build > Build Artifacts .
  12. No menu de contexto exibido, selecione o nome do projeto > Construir . Aguarde enquanto o site sbt constrói o JAR. Os resultados da compilação aparecem na janela da ferramenta Build Output (consulte > Tool Windows > Build ).

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

Etapa 7: Exibir o terminal no IDE​

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

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

Eclipse​

Siga as instruções a seguir para começar a usar o Eclipse e o Java com o site dbx. Estas instruções criam um projeto mínimo Mavenbaseado em Java que o senhor pode usar para começar um dbx projeto.

Em sua máquina de desenvolvimento local, você deve ter o seguinte instalado, além dos requisitos gerais:

  • Uma versão do Eclipse. Estas instruções usam a edição do Eclipse IDE para desenvolvedores Java do Eclipse IDE.
  • Uma edição do Java Runtime Environment (JRE) ou do Java Development Kit (JDK) 11, dependendo do sistema operacional do seu computador local. Embora qualquer edição do JRE ou do JDK 11 deva funcionar, até o momento a Databricks só validou o uso do site dbx e do Eclipse IDE for Java Developers com o Eclipse 2022-03 R, que inclui o AdoptOpenJDK 11.

Siga estas passos para começar a configurar sua estrutura de projeto dbx :

Etapa 1: Criar um projeto Java baseado em Maven​

  1. No Eclipse, clique em File > New > Project .
  2. Na caixa de diálogo New Project , expanda Maven , selecione Maven Project e clique em Next .
  3. Na caixa de diálogo Novo projeto Maven , selecione Criar um projeto simples (ignorar a seleção de arquétipo) e clique em Avançar .
  4. Para Group Id , digite um ID de grupo que esteja em conformidade com as regras de nome de pacote do Java. Essas etapas usam o nome do pacote com.example.demo. Se você inserir uma ID de grupo diferente, substitua-a ao longo dessas etapas.
  5. Para Artifact Id , insira um nome para o arquivo JAR sem o número da versão. Essas passos usam o nome JAR de dbx-demo. Se você inserir um nome diferente para o arquivo JAR, substitua-o ao longo dessas passos.
  6. Clique em Concluir .

Etapa 2: Adicionar uma classe ao pacote​

O senhor pode adicionar as classes que quiser ao seu pacote. Esse pacote conterá uma única classe chamada SampleApp.

  1. No Project Explorer view (Window > Show view > Project Explorer ), selecione o ícone do projeto com o nome do projeto e clique em File > New > Class .
  2. Na caixa de diálogo New Java Class , para pacote , digite com.example.demo.
  3. Em Nome , digite SampleApp.
  4. Em Modificadores , selecione público .
  5. Deixe a Superclasse em branco.
  6. Para Quais stubs de método o senhor gostaria de criar , selecione public static void Main(strings[] args) .
  7. Clique em Concluir .

Etapa 3: adicionar dependências ao projeto​

  1. No Project Explorer view, clique duas vezes em project-name > pom.xml .

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

    XML
    <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>

    Substituir:

    • 2.12 com sua versão de "clustering" de destino de Scala.
    • 3.2.1 com sua versão de "clustering" de destino de Spark.

    Consulte a seção "System environment" (Ambiente do sistema) no site Databricks Runtime notas sobre versões e compatibilidade da versão Databricks Runtime para o seu clustering de destino.

Etapa 4: compilar o projeto​

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

    XML
    <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>

  2. No Project Explorer view, clique com o botão direito do mouse no ícone do projeto com o nome do projeto e, em seguida, clique em executar As > executar Configurations .

  3. Na caixa de diálogo Configurações de execução , clique em Maven Build .

  4. Clique no ícone Nova configuração de lançamento .

  5. Insira um nome para essa configuração de inicialização, por exemplo, compilação limpa .

  6. Para o diretório Base , clique em workspace , escolha o diretório do seu projeto e clique em OK .

  7. Em Metas , insira clean compile.

  8. Clique em executar . A saída da execução aparece no Console view (Janela > Show view > Console ).

Etapa 5: adicionar código ao projeto​

Você pode adicionar qualquer código que desejar ao seu projeto. Esta passo pressupõe que você deseja apenas adicionar código a um arquivo denominado SampleApp.java para um pacote denominado com.example.demo.

No arquivo src/main/java > com.example.demo > SampleApp.java do projeto, adicione o código que o senhor deseja que dbx lote a execução em seu clustering de destino. (Se o senhor 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: execução do projeto​

  1. No Project Explorer view, clique com o botão direito do mouse no ícone do projeto com o nome do projeto e, em seguida, clique em executar As > executar Configurations .
  2. Na caixa de diálogo Configurações de execução , expanda Java Application e clique em App .
  3. Clique em executar . A saída da execução aparece no Console view.

Etapa 7: Compilar o projeto como um JAR​

  1. No Project Explorer view, clique com o botão direito do mouse no ícone do projeto com o nome do projeto e, em seguida, clique em executar As > executar Configurations .
  2. Na caixa de diálogo Configurações de execução , clique em Maven Build .
  3. Clique no ícone Nova configuração de lançamento .
  4. Digite um nome para essa configuração de inicialização, por exemplo, clean pacote .
  5. Para o diretório Base , clique em workspace , escolha o diretório do seu projeto e clique em OK .
  6. Em Metas , insira clean package.
  7. Clique em executar . A saída da execução aparece no Console view.

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

nota

Se o site JAR não aparecer na pasta target na janela Project Explorer , o senhor pode tentar exibi-lo clicando com o botão direito do mouse no ícone do projeto com o nome do projeto e, em seguida, clicando em refresh .

Etapa 8: Exibir o terminal no IDE​

Com a estrutura do seu projeto dbx agora estabelecida, você está pronto para criar seu projeto dbx. Para começar, configure o Project Explorer view para mostrar os arquivos ocultos (arquivos que começam com um ponto (./)) que o dbx gera, da seguinte forma:

  1. No Project Explorer view, clique no ícone de filtro de elipses (Menu Exibir ) e, em seguida, clique em Filters and Customization (Filtros e personalização ).
  2. Na caixa de diálogo Filters and Customization (Filtros e personalização ), em Pre-set filters (Filtros predefinidos ) tab, desmarque a caixa de recurso .* .
  3. Clique em OK .

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

  1. Clique em Window > Show view > Terminal na barra de menus.
  2. Se o prompt de comando do terminal não for exibido, no Terminal view, clique no ícone Abrir um terminal .
  3. Use o comando cd para alternar para o diretório raiz do seu projeto.
  4. Continue com Criar um projeto dbx.

Sem IDE (somente terminal)​

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

Siga estas passos para usar um terminal para começar a configurar sua estrutura de projeto dbx :

  1. No seu terminal, crie uma pasta em branco. Essas instruções usam uma pasta chamada dbx-demo (mas você pode dar à pasta raiz do seu projeto dbx o nome que quiser). Depois de criar a pasta, mude para ela.

    No Linux e macOS:

    Bash
    mkdir dbx-demo
    cd dbx-demo

    No Windows:

    PowerShell
    md dbx-demo
    cd dbx-demo

  2. Crie um ambiente virtual Python para esse projeto executando o comando pipenv, com a seguinte opção, a partir da raiz da pasta dbx-demo, em que <version> é a versão de destino do Python que o senhor já tem instalada localmente, por exemplo, 3.8.14.

    Bash
    pipenv --python <version>

  3. Ative seu ambiente virtual Python executando pipenv shell.

    Bash
    pipenv shell

  4. Continue com Criar um projeto dbx.

Crie um projeto dbx​

Com sua estrutura de projeto dbx estabelecida em uma das seções anteriores, agora você está pronto para criar um dos seguintes tipos de projetos:

Criar um projeto dbx mínimo para Python​

O projeto mínimo dbx a seguir é a abordagem mais simples e rápida para começar a usar o Python e o dbx. Ele demonstra lotes de execução de um único Python arquivo de código em um Databricks cluster existente todo-propósito em seu Databricks workspace.

nota

Para criar um projeto modelo dbx para Python que demonstre lotes de execução de código em clusters todo-propósito e Job clustering, implementações remotas de artefatos de código e configuração da plataforma CI/CD, pule para Criar um projeto modelo dbx para Python com suporte a CI/CD.

Para concluir esse procedimento, o senhor deve ter um cluster todo-propósito existente em seu site workspace. (Consulte o site compute ou a referência de configuração de computação). Idealmente (mas não obrigatoriamente), a versão do Python em seu ambiente virtual Python deve corresponder à versão instalada nesse clustering. Para identificar a versão do Python no clustering, use o terminal da Web do clustering para executar o python --version comando.

Bash
python --version

  1. No terminal, na pasta raiz do projeto dbx, execute o comando dbx configure com a seguinte opção. Esse comando cria uma pasta oculta .dbx dentro da pasta raiz do projeto dbx. Essa pasta .dbx contém arquivos lock.json e project.json.

    Bash
    dbx configure --profile DEFAULT --environment default
nota

O arquivo project.json define um ambiente chamado default junto com uma referência ao perfil DEFAULT em seu arquivo .databrickscfg. Se quiser que o site dbx use um perfil diferente, substitua --profile DEFAULT por --profile seguido do nome do perfil de destino no comando dbx configure.

Por exemplo, se tiver um perfil chamado DEV no arquivo .databrickscfg e quiser que o dbx o utilize em vez do perfil DEFAULT, o arquivo project.json poderá ter a seguinte aparência e, nesse caso, o comando dbx configure também substituirá --environment default por --environment dev:

JSON
{
  "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 o senhor quiser que o site dbx use as variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN em vez de um perfil no arquivo .databrickscfg, deixe de fora a opção --profile do comando dbx configure.

  1. Crie uma pasta chamada conf dentro da pasta raiz do seu projeto dbx.

    No Linux e macOS:

    Bash
    mkdir conf

    No Windows:

    PowerShell
    md conf

  2. Adicione um arquivo chamado deployment.yaml file ao diretório conf, com o seguinte conteúdo de arquivo:

    YAML
    build:
      no_build: true
    environments:
      default:
        workflows:
          - name: 'dbx-demo-job'
            spark_python_task:
              python_file: 'file://dbx-demo-job.py'
nota

O arquivo deployment.yaml contém a palavra default em minúsculas, que é uma referência ao perfil DEFAULT em maiúsculas em seu arquivo .databrickscfg. Se você quiser que dbx use 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 pode ter a seguinte aparência:

YAML
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 o senhor quiser que o dbx use o DATABRICKS_HOST e o DATABRICKS_TOKEN variável de ambiente em vez de um perfil no arquivo .databrickscfg, deixe o default no deployment.yaml como está. dbx usará essa referência em default.

dica

Para adicionar Spark configuration par key-value a um Job, use o campo spark_conf, por exemplo:

YAML
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 campo access_control_list, por exemplo:

YAML
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 do trabalho deve ser adicionado à lista, bem como outras permissões de usuário e grupo.

  1. Adicione o código para execução no clustering a um arquivo chamado dbx-demo-job.py e adicione o arquivo à pasta raiz do seu projeto dbx. (Se o senhor não tiver nenhum código à mão, poderá usar o código Python no exemplo de código, listado no final deste artigo).
nota

Você não precisa nomear esse arquivo como dbx-demo-job.py. Se você escolher um nome de arquivo diferente, certifique-se de atualizar o campo python_file no arquivo conf/deployment.yaml para que ele corresponda.

  1. Execute o comando dbx execute comando com as seguintes opções. Neste comando, substitua <existing-cluster-id> pelo ID do clássico compute em seu workspace. (Para obter o ID, consulte computar o URL e o ID do recurso).

    Bash
    dbx execute --cluster-id=<existing-cluster-id> dbx-demo-job --no-package

  2. Para view os resultados da execução localmente, veja a saída do seu terminal. Para view os resultados da execução em seu cluster, acesse o painel de saída padrão no Driver logs tab para seu cluster. (Consulte o driver de computação e worker logs .)

  3. Continue com as próximas etapas.

Criar um projeto dbx mínimo para Scala ou Java​

O projeto mínimo dbx a seguir é a abordagem mais simples e rápida para começar a usar o dbx e o Scala ou Java. Isso demonstra que o senhor implantou um único Scala ou Java JAR em seu Databricks workspace e, em seguida, executou esse JAR implantado em um Databricks Job clustering em seu Databricks workspace.

nota

Databricks limita como o senhor pode executar o código Scala e Java no clustering:

  • O senhor não pode executar um único arquivo Scala ou Java como um trabalho em um clustering, como pode fazer com um único arquivo Python. Para executar o código Scala ou Java, o senhor deve primeiro compilá-lo em um JAR.
  • O senhor pode executar o JAR como um Job em um cluster todo-propósito existente. No entanto, o senhor não pode reinstalar nenhuma atualização do site JAR nos mesmos clusters todo-propósito. Nesse caso, o senhor deve usar um Job clustering. Esta seção usa a abordagem de agrupamento de trabalhos.
  • O senhor deve primeiro implantar o JAR no seu Databricks workspace antes de poder executar esse JAR implantado em qualquer cluster todo-propósito ou Job clustering nesse workspace.

  1. No terminal, a partir da pasta raiz do projeto, execute o comando dbx configure com a seguinte opção. Esse comando cria uma pasta oculta .dbx dentro da pasta raiz do projeto. Essa pasta .dbx contém arquivos lock.json e project.json.

    Bash
    dbx configure --profile DEFAULT --environment default
nota

O arquivo project.json define um ambiente chamado default junto com uma referência ao perfil DEFAULT em seu arquivo .databrickscfg. Se quiser que o site dbx use um perfil diferente, substitua --profile DEFAULT por --profile seguido do nome do perfil de destino no comando dbx configure.

Por exemplo, se tiver um perfil chamado DEV no arquivo .databrickscfg e quiser que o dbx o utilize em vez do perfil DEFAULT, o arquivo project.json poderá ter a seguinte aparência e, nesse caso, o comando dbx configure também substituirá --environment default por --environment dev:

JSON
{
  "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 o senhor quiser que o site dbx use as variáveis de ambiente DATABRICKS_HOST e DATABRICKS_TOKEN em vez de um perfil no arquivo .databrickscfg, deixe de fora a opção --profile do comando dbx configure.

  1. Crie uma pasta chamada conf na pasta raiz do seu projeto.

    No Linux e macOS:

    Bash
    mkdir conf

    No Windows:

    PowerShell
    md conf

  2. Adicione um arquivo chamado deployment.yaml file ao diretório conf, com o seguinte conteúdo mínimo de arquivo:

    YAML
    build:
      no_build: true
    environments:
      default:
        workflows:
          - name: 'dbx-demo-job'
            new_cluster:
              spark_version: '10.4.x-scala2.12'
              node_type_id: 'i3.xlarge'
              aws_attributes:
                first_on_demand: 1
                availability: 'SPOT'
              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'

    Substituir:

    • O valor de spark_version com a versão de tempo de execução apropriada para o Job clustering de destino.
    • O valor de node_type_id com o tipo de nó de trabalho apropriado para o clustering de trabalho de destino.
    • O valor de instance_pool_id com o ID de uma instância existente pool existente em seu site workspace, para permitir a execução mais rápida do trabalho. Se o senhor não tiver um pool de instâncias disponível ou não quiser usar um pool de instâncias, remova completamente essa linha.
    • O valor de jar com o caminho no projeto para o JAR. Para o IntelliJ IDEA com Scala, pode ser file://out/artifacts/dbx_demo_jar/dbx-demo.jar. Para o Eclipse IDE 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.
nota

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ê quiser que dbx use um perfil diferente, substitua default nesse 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 pode ter a seguinte aparência:

YAML
environments:
  default:
    workflows:
      - name: 'dbx-demo-job'
        # ...
  dev:
    workflows:
      - name: '<some-other-job-name>'
        # ...

Se o senhor quiser que o dbx use o DATABRICKS_HOST e o DATABRICKS_TOKEN variável de ambiente em vez de um perfil no arquivo .databrickscfg, deixe o default no deployment.yaml como está. dbx usará as configurações de ambiente default (exceto o valor profile) no arquivo .dbx/project.json por default.

dica

Para adicionar Spark configuration par key-value a um Job, use o campo spark_conf, por exemplo:

YAML
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 campo access_control_list, por exemplo:

YAML
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 do trabalho deve ser adicionado à lista, bem como outras permissões de usuário e grupo.

  1. execução do dbx deploy comando. dbx implantado o JAR no local do caminho artifact_location do arquivo .dbx/project.json para o ambiente correspondente. dbx também implantou os arquivos do projeto como parte de um experimentoMLflow, no local listado no caminho workspace_directory do arquivo .dbx/project.json para o ambiente correspondente.

    Bash
    dbx deploy --no-package

  2. Execute o comando dbx launch com as seguintes opções. Esse comando executa o trabalho com o nome correspondente em conf/deployment.yaml. Para localizar o JAR implantado para execução como parte do trabalho, o dbx faz referência ao local no caminho artifact_location do arquivo .dbx/project.json para o ambiente correspondente. Para determinar qual JAR específico deve ser executado, dbx faz referência ao experimento MLflow no local listado no caminho workspace_directory do arquivo .dbx/project.json para o ambiente correspondente.

    Bash
    dbx launch dbx-demo-job

  3. Para view os resultados da execução do trabalho em seu clustering de trabalho, consulte view Job and pipeline.

  4. Para view o experimento que o Job referenciou, consulte Organizar treinamento execução com MLflow experimentos.

  5. Continue com as próximas etapas.

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

O projeto modelo a seguir para dbx Python demonstra o suporte para lotes de execução do Python código em Databricks clusters todo-propósito e clustering de trabalho em seu Databricks espaço de trabalho, implantações de artefatos de código remoto e CI/CD configuração da plataforma. (Para criar um projeto dbx mínimo para Python que demonstre apenas a execução de lotes de um único arquivo de código Python em um cluster todo-propósito existente, volte para Criar um projeto dbx mínimo para Python).

  1. No terminal, na pasta raiz do projeto dbx, execute o comando dbx init.

    Bash
    dbx init

  2. Em project_name , digite um nome para o seu projeto ou pressione Enter para aceitar o nome do projeto default.

  3. Em version , digite um número de versão inicial para o projeto ou pressione Enter para aceitar a versão do projeto default.

  4. Para a nuvem , selecione o número que corresponde à versão da nuvem Databricks que o senhor deseja que o projeto use ou pressione Enter para aceitar o default.

  5. Para cicd_tool , selecione o número que corresponde à ferramenta CI/CD suportada que o senhor deseja que o projeto use ou pressione Enter para aceitar o default.

  6. Para project_slug , digite um prefixo que deseja usar para recurso em seu projeto ou pressione Enter para aceitar o default.

  7. Para workspace , digite o caminho local para o diretório workspace do seu projeto ou pressione Enter para aceitar o default.

  8. Para artifact_location , digite o caminho em Databricks workspace para onde os artefatos do projeto serão gravados ou pressione Enter para aceitar o default.

  9. Em profile , digite o nome do perfil de autenticação CLI que deseja que o projeto use ou pressione Enter para aceitar o default.

dica

Você pode pular as passos anteriores executando dbx init com parâmetros padrão embutidos em código, por exemplo:

Bash
dbx init --template="python_basic" \
-p "project_name=cicd-sample-project" \
-p "cloud=AWS" \
-p "cicd_tool=GitHub Actions" \
-p "profile=DEFAULT" \
--no-input

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

Consulte o comando init em CLI Reference na documentação dbx.

Veja também Próximas etapas.

Exemplo de código​

Se o senhor não tiver nenhum código prontamente disponível para lotes execução com dbx, poderá fazer uma experiência com dbx lotes execução o seguinte código. Esse código cria uma pequena tabela em seu site workspace, consulta a tabela e, em seguida, exclui a tabela.

dica

Se o senhor quiser deixar a tabela no site workspace em vez de excluí-la, comente a última linha de código deste exemplo antes de colocá-la 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')

Próximas etapas​

Recurso adicional​