dbx de Databricks Labs

Artículo
03/13/2024

Importante

Esta documentación se ha retirado y es posible que no se actualice.

Databricks recomienda usar las agrupaciones de recursos de Databricks en lugar de dbx de Databricks Labs. Consulte Qué son las agrupaciones de recursos de Databricks y Migración de dbx a agrupaciones.

Nota:

Este artículo trata sobre dbx de Databricks Labs, que se proporciona tal cual y no es apoyado por Databricks a través de los canales de soporte técnico del cliente. Las preguntas y solicitudes de funciones pueden comunicarse a través de la página de incidencias del repositorio databrickslabs/dbx en GitHub.

dbx de Databricks Labs es una herramienta de código abierto diseñada para ampliar la interfaz de la línea de comandos de Databricks heredada (CLI de Databricks) y proporcionar funcionalidad para un ciclo de vida de desarrollo rápido, una integración continua, e integración continua y entrega continua (CI/CD) en la plataforma de Azure Databricks.

dbx simplifica los procesos de implementación e inicio de los trabajos en varios entornos. También ayuda a empaquetar el proyecto y a entregarlo al entorno de Azure Databricks con tratamiento de versiones. Diseñado con un enfoque en la CLI, está creado para usarse activamente dentro de canalizaciones de CI/CD y como parte de las herramientas locales (como los IDE locales, incluidos Visual Studio Code y PyCharm).

El flujo de trabajo de desarrollo típico con dbx es:

Cree un repositorio remoto con un proveedor de Git que Databricks admita, si no dispone ya de uno.
Clone el repositorio remoto en el área de trabajo de Azure Databricks.
Cree o mueva un cuaderno de Azure Databricks al repositorio clonado en el área de trabajo de Azure Databricks. Use este cuaderno para empezar a crear prototipos del código que quiere que ejecuten los clústeres de Azure Databricks.
Para mejorar y modularizar el código del cuaderno mediante la adición de clases auxiliares y funciones independientes, archivos de configuración y pruebas, cambie al uso de una máquina de desarrollo local con dbx, su IDE preferido y Git instalado.
Clone el repositorio remoto en la máquina de desarrollo local.
Mueva el código del cuaderno a uno o varios archivos de código locales.
Al codificar localmente, inserte el trabajo desde el repositorio local en el repositorio remoto. Además, sincronice el repositorio remoto con el área de trabajo de Azure Databricks.

Sugerencia

Como alternativa, puede usar la sincronización de dbx para sincronizar automáticamente en tiempo real los cambios de archivos locales con los archivos correspondientes en el área de trabajo.
Siga usando el cuaderno en el área de trabajo de Azure Databricks para crear prototipos rápidos y siga moviendo el código validado del cuaderno a la máquina local. Siga usando el IDE local para tareas como la modularización de código, la finalización de código, el linting, las pruebas unitarias y la depuración paso a paso del código y los objetos que no requieren una conexión dinámica a Azure Databricks.
Use dbx para ejecutar por lotes el código local en los clústeres de destino, según sea necesario. (Esto es similar a ejecutar el script spark-submit del directorio bin de Spark para iniciar aplicaciones en un clúster de Spark).
Cuando esté listo para producción, use una plataforma de CI/CD como Acciones de GitHub, Azure DevOps o GitLab para automatizar la ejecución del código del repositorio remoto en los clústeres.

Requisitos

Para usar dbx, se debe tener instalado lo siguiente en el equipo de desarrollo local, independientemente de si el código usa Python, Scala o Java:

Python versión 3.8 o superior.

Si el código usa Python, se debería usar una versión de Python que coincida con la instalada en los clústeres de destino. Para obtener la versión de Python instalada en un clúster existente, puede usar el terminal web del clúster para ejecutar el comando python --version. Consulte también la sección "Entorno del sistema" de Versiones y compatibilidad de las notas de la versión de Databricks Runtime para obtener la versión de Databricks Runtime de los clústeres de destino.
pip.
Si el código usa Python, un método para crear entornos virtuales de Python para asegurarse de que se usa las versiones correctas de Python y las dependencias de paquetes en los proyectos de dbx. En este artículo, se trata pipenv.
dbx versión 0.8.0 o superior. Puede instalar este paquete desde el índice de paquetes de Python (PyPI) ejecutando pip install dbx.

Para confirmar si dbx está instalado, ejecute el comando siguiente:
```
dbx --version
```
Si se devuelve el número de versión, dbx está instalado.

Si el número de versión es inferior a 0.8.0, actualice dbx con la ejecución del siguiente comando y vuelva a comprobar el número de versión:
```
pip install dbx --upgrade
dbx --version

# Or ...
python -m pip install dbx --upgrade
dbx --version
```
La CLI de Databricks, versión 0.18 o anterior, configurada con autenticación. La CLI de Databricks heredada (versión 0.17 de la CLI de Databricks) se instala automáticamente al instalar dbx. Esta autenticación se puede configurar en la máquina de desarrollo local en una o ambas de las siguientes ubicaciones:
- Dentro de las variables de entorno DATABRICKS_HOST y DATABRICKS_TOKEN (a partir de la versión 0.8.0 de la CLI de Databricks heredada).
- En un perfil de configuración de Azure Databricks dentro del archivo .databrickscfg.
dbx busca las credenciales de autenticación en estas dos ubicaciones, respectivamente. dbx usa solo el primer conjunto de credenciales coincidentes que encuentra.

Nota:

dbx no admite el uso de un archivo .netrc para la autenticación, empezando por la versión 0.17.2 de la CLI de Databricks heredada. Para comprobar la versión de la CLI heredada de Databricks instalada, ejecute el comando databricks --version.
Git para insertar y sincronizar los cambios de código local y remoto.

Continúe con las instrucciones correspondientes a uno de los siguientes IDE:

Visual Studio Code
PyCharm
IntelliJ IDEA
Eclipse

Nota:

Databricks ha validado el uso de los IDE anteriores con dbx; sin embargo, dbx debe funcionar con cualquier IDE. También se puede no usar Ningún IDE (solo terminal).

dbx está optimizado para trabajar con archivos de código de Python de un solo archivo y archivos JAR de Scala y Java compilados. dbx no funciona con archivos de código de R de archivo único ni con paquetes de código de R compilados. Esto se debe a que dbx funciona con Jobs API 2.0 y 2.1 y estas API no pueden ejecutar archivos de código de R de archivo único ni paquetes de código de R compilados como trabajos.

Visual Studio Code

Complete las siguientes instrucciones para empezar a usar Visual Studio Code y Python con dbx.

En la máquina de desarrollo local, debe tener instalado lo siguiente además de los requisitos generales:

Visual Studio Code.
La extensión de Python para Visual Studio Code. Para más información, consulte Marketplace de extensiones en el sitio web de Visual Studio Code.

Para más información, consulte Introducción a Python en VS Code en la documentación de Visual Studio Code.

Siga estos pasos para empezar a configurar la estructura del proyecto de dbx:

Desde el terminal, cree una carpeta en blanco. Estas instrucciones usan una carpeta denominada dbx-demo. Puede asignar el nombre que desee a la carpeta raíz del proyecto de dbx. Si se usa un nombre diferente, reemplace el nombre en estos pasos. Después de crear la carpeta, cambie a dicha carpeta y, a continuación, inicie Visual Studio Code desde esa carpeta.

Para Linux y macOS:
```
mkdir dbx-demo
cd dbx-demo
code .
```
Sugerencia

Si se muestra el mensaje command not found: code después de ejecutar code ., consulte Inicio desde la línea de comandos en el sitio web de Microsoft.

Para Windows:
```
md dbx-demo
cd dbx-demo
code .
```
En Visual Studio Code, cree un entorno virtual de Python para este proyecto:
1. En la barra de menús, haga clic en View > Terminal.
2. Desde la raíz de la carpeta dbx-demo, ejecute el comando pipenv con la siguiente opción, donde <version> es la versión de destino de Python que ya ha instalado localmente (e, idealmente, una versión que coincida con la versión de Python de los clústeres de destino), por ejemplo, 3.8.14.
```
pipenv --python <version>
```
  Anote el valor de Virtualenv location en la salida del comando pipenv, ya que lo necesitará en el paso siguiente.
Seleccione el intérprete de Python de destino y, a continuación, active el entorno virtual de Python:
1. En la barra de menús, haga clic en View > Command Palette, escriba Python: Select y, a continuación, haga clic en Python: Select Interpreter.
2. Seleccione el intérprete de Python de la ruta de acceso al entorno virtual de Python que acaba de crear. (Esta ruta de acceso aparece como el valor de Virtualenv location en la salida del comando pipenv).
3. En la barra de menús, haga clic en View > Command Palette, escriba Terminal: Create y, a continuación, haga clic en Terminal: Create New Terminal.
Para más información, consulte Uso de entornos de Python en VS Code en la documentación de Visual Studio Code.
Continúe con Creación de un proyecto de dbx.

PyCharm

Complete las siguientes instrucciones para empezar a usar PyCharm y Python con dbx.

En la máquina de desarrollo local, debe tener instalado PyCharm además de los requisitos generales.

Siga estos pasos para empezar a configurar la estructura del proyecto de dbx:

En PyCharm, en la barra de menús, haga clic en File > New Project.
En el cuadro de diálogo Create Project, elija una ubicación para el nuevo proyecto.
Expanda Python interpreter: New Pipenv environment.
Seleccione New environment using, si aún no está seleccionado y, a continuación, seleccione Pipenv en la lista desplegable.
En Base interpreter, seleccione la ubicación que contiene el intérprete de Python para la versión de destino de Python que ya ha instalado localmente (e, idealmente, una versión que coincida con la versión de Python de los clústeres de destino).
En Pipenv executable, seleccione la ubicación que contiene la instalación local de pipenv, si aún no se ha detectado automáticamente.
Si desea crear un proyecto de dbx mínimo y desea usar el archivo main.py con ese proyecto de dbx mínimo, seleccione el cuadro Create a main.py welcome script. En caso contrario, desactive este cuadro.
Haga clic en Crear.
En la ventana de herramientas Project, haga clic con el botón derecho en la carpeta raíz del proyecto y, a continuación, haga clic en Open in > Terminal.
Continúe con Creación de un proyecto de dbx.

IntelliJ IDEA

Complete las siguientes instrucciones para empezar a usar IntelliJ IDEA y Scala con dbx. Estas instrucciones crean un proyecto de Scala basado en sbt mínimo que se puede usar para iniciar un proyecto de dbx.

En la máquina de desarrollo local, debe tener instalado lo siguiente además de los requisitos generales:

IntelliJ IDEA.
El complemento de Scala para IntelliJ IDEA. Para obtener más información, vea Discover IntelliJ IDEA for Scala (Descubrir IntelliJ IDEA para Scala) en la documentación de IntelliJ IDEA.
Java Runtime Environment (JRE) 8. Aunque cualquier edición de JRE 8 debería funcionar, Databricks solo ha validado hasta ahora el uso de dbx e IntelliJ IDEA con OpenJDK 8 JRE. Databricks aún no ha validado el uso de dbx con IntelliJ IDEA y Java 11. Para obtener más información, vea Java Development Kit (JDK) (kit de desarrollo de Java) en la documentación de IntelliJ IDEA.

Siga estos pasos para empezar a configurar la estructura del proyecto de dbx:

Paso 1: Creación de un proyecto de Scala basado en sbt

En IntelliJ IDEA, en función de la vista, haga clic en Proyectos > Nuevo proyecto o Archivo > Nuevo > Proyecto.
En el cuadro de diálogo Nuevo proyecto, haga clic en Scala, después en sbt y a continuación, haga clic en Siguiente.
Introduzca el nombre del proyecto y elija una ubicación para guardar el proyecto.
Para JDK, seleccione la instalación de OpenJDK 8 JRE.
Para sbt, elija la versión más alta disponible de sbt que se muestra.
Para Scala, idealmente, elija la versión de Scala que coincida con la versión de los clústeres de destino de Scala. Consulta la sección "Entorno del sistema" Versiones y compatibilidad de las notas de la versión de Databricks Runtime para la versión de Databricks Runtime de los clústeres de destino.
Junto a Scala, seleccione el cuadro Orígenes si aún no está seleccionado.
Agregue un prefijo de paquete al Prefijo de paquete. Estos pasos usa el prefijo de paquete com.example.demo. Si especifica un prefijo de paquete diferente, reemplace el prefijo del paquete en estos pasos.
Haga clic en Finalizar

Paso 2: Agregar un objeto al paquete

Puede agregar los objetos necesarios al paquete. Este paquete contiene un único objeto denominado SampleApp.

En la ventana de herramientas de Proyecto (Ver > Ventanas de herramientas >Proyecto), haga clic en nombre de proyecto> src >carpeta de >Scala principal y, a continuación, haga clic en Nueva > clase de Scala.
Elija Objeto y escriba el nombre del objeto y pulse Introducir. Por ejemplo, escriba SampleApp. Si introduce un nombre de objeto diferente aquí, asegúrese de reemplazar el nombre en estos pasos.

Reemplace el contenido del archivo SampleApp.scala por el código siguiente:

package com.example.demo

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

Paso 3: Compilar el proyecto

Agregue cualquier configuración de compilación de proyecto necesaria y dependencias al proyecto. En este paso se supone que va a compilar un proyecto que se configuró en los pasos anteriores y depende solo de las siguientes bibliotecas.

Reemplace el contenido del archivo del proyecto build.sbt por el código siguiente:

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()
  )

En el archivo anterior, reemplace:

2.12.14 con la versión de Scala que eligió anteriormente para este proyecto.
3.2.1 con la versión de Spark que eligió anteriormente para este proyecto.
dbx-demo con el nombre del proyecto.
com.example.demo con el nombre del prefijo del paquete.

En la barra de menús, haga clic en Ver > Ventanas de herramienta > sbt.
En la ventana de herramienta sbt, haga clic con el botón derecho en el nombre del proyecto y haga clic en Recargar proyecto sbt. Espere hasta que sbt termine de descargar las dependencias del proyecto desde un almacén de artefactos de Internet, como Coursier o Ivy de forma predeterminada, en función de la versión de sbt. Puede ver el progreso de la descarga en la barra de estado. Si agrega o cambia más dependencias a este proyecto, debe repetir este paso de recarga del proyecto para cada conjunto de dependencias que agregue o cambie.
En la barra de menús, haga clic en Preferencias de IntelliJ > IDEA.
En el cuadro de diálogo Preferencias, haga clic en Compilación, Ejecución, Implementación > Herramientas de compilación > sbt.
En JVM, para JRE, seleccione la instalación de OpenJDK 8 JRE.
En proyectos de sbt, seleccione el nombre del proyecto.
En shell de sbt, seleccione compilaciones.
Haga clic en Aceptar.
En la barra de menú, haga clic en Compilación > Compilar proyecto. Los resultados de la compilación aparecen en la ventana de la herramienta de shell de sbt (Ver > Ventanas de herramienta > shell de sbt).

Paso 4: Incorporación de código al proyecto

Añada el código necesario al proyecto. En este paso se supone que solo quiere agregar código al archivo SampleApp.scala del paquete example.

En el archivo del proyecto de src>main>scala>SampleApp.scala, agregue el código que desea dbx ejecutar por lotes en los clústeres de destino. Para realizar pruebas básicas, use el código de Scala de ejemplo en la sección Ejemplo de código.

Paso 5: Ejecución del proyecto

En la barra de menú, haga clic en Ejecutar > Editar configuraciones.
En el cuadro de diálogo Ejecutar o depurar configuraciones, haga clic en el icono +(Agregar nueva configuración) o Agregar nueva o Agregar nueva configuración de ejecución.
En la lista desplegable, haga clic en Tarea sbt.
En Nombre, escriba un nombre para la configuración, por ejemplo, Ejecutar el programa.
En Tareas, escriba ~run.
Seleccione Usar shell de sbt.
Haga clic en Aceptar.
En la barra de menús, haga clic en Ejecutar > Ejecutar «Ejecutar el programa». Los resultados de la ejecución aparecen en la ventana de herramientas del shell de sbt.

Paso 6: Compilar el proyecto como un archivo JAR

Puede agregar cualquier configuración de compilación jar al proyecto que desee. En este paso se supone que solo desea compilar un archivo JAR basado en el proyecto que se configuró en los pasos anteriores.

En la barra de menús, haga clic en Archivo > Estructura de proyecto.
En el cuadro de diálogo Estructura de proyecto, haga clic en Configuración del proyecto >Artefactos.
Haga clic en el icono de + (Agregar).
En la lista desplegable, seleccione JAR> Desde módulos con dependencias.
En el cuadro de diálogo Crear JAR a partir de módulos, en Módulo, seleccione el nombre del proyecto.
En Clase principal, haga clic en el icono de carpeta.
En el cuadro de diálogo Seleccionar clase principal , en la pestaña Buscar por nombre , seleccione SampleApp y, a continuación, haga clic en Aceptar.
En Archivos JAR de las bibliotecas, seleccione Copiar en el directorio de salida y vincule a través del manifiesto.
Haga clic en Aceptar para cerrar el cuadro de diálogo Crear JAR desde módulos.
Haga clic en Aceptar para cerrar el cuadro de diálogo Estructura del proyecto.
En la barra de menú, haga clic en Compilación > Compilar proyecto.
En el menú contextual que aparece, seleccione project-name:jar > Compilación. Espere mientras sbt compila el archivo JAR. Los resultados de la compilación aparecen en la ventana de herramientas de Salida de compilación (Ver > Ventanas de herramientas > Compilación).

El archivo JAR se compila en la carpeta del proyecto out>artifacts><project-name>_jar. El nombre del archivo JAR es <project-name>.jar.

Paso 7: Mostrar el terminal en el IDE

Con la estructura del proyecto dbx ahora en su lugar, está listo para crear el proyecto dbx.

Para mostrar el terminal IntelliJ IDEA, haga clic en Ver > Ventanas de herramientas > Terminal en la barra de menú y, a continuación, continúe con Crear un proyecto dbx.

Eclipse

Complete las siguientes instrucciones para empezar a usar Eclipse y Java con dbx. Estas instrucciones crean un proyecto de Java basado en Maven mínimo que se puede usar para iniciar un proyecto de dbx.

En la máquina de desarrollo local, debe tener instalado lo siguiente además de los requisitos generales:

Una versión de Eclipse. Estas instrucciones usan la edición IDE de Eclipse para desarrolladores de Java del IDE de Eclipse.
Edición de Java Runtime Environment (JRE) o Java Development Kit (JDK) 11, según el sistema operativo de la máquina local. Aunque cualquier edición de JRE o JDK 11 debería funcionar, Databricks solo ha validado el uso de dbx y el IDE de Eclipse para desarrolladores de Java con Eclipse 2022-03 R, que incluye AdoptOpenJDK 11.

Siga estos pasos para empezar a configurar la estructura del proyecto de dbx:

Paso 1: Creación de un proyecto de Java basado en Maven

En Eclipse, haga clic en Archivo > Nuevo > Proyecto.
En el cuadro de diálogo Nuevo proyecto, expanda Maven, seleccioneProyecto de Maven y haga clic en Siguiente.
En el cuadro de diálogo Nuevo proyecto de Maven, seleccione Crear un proyecto simple (omitir selección de arquetipo) y haga clic en Siguiente.
En Id. de grupo, escriba un identificador de grupo que se ajuste a las reglas de nombre de paquete de Java. Estos pasos usa el nombre de paquete de com.example.demo. Si escribe un identificador de grupo diferente, sustituya por estos pasos.
En Id. de artefacto, escriba un nombre para el archivo JAR sin el número de versión. En estos pasos se usa el nombre JAR de dbx-demo. Si escribe otro nombre para el archivo JAR, sustituya por estos pasos.
Haga clic en Finalizar

Paso 2: Agregar una clase al paquete

Puede agregar cualquier clase al paquete que desee. Este paquete contendrá una sola clase denominada SampleApp.

En la vista Explorador de proyecto (Ventana > Mostrar vista > Explorador de proyecto), seleccione el icono de proyecto nombre de proyecto y, a continuación, haga clic en Archivo > Nueva > clase.
En el cuadro de diálogo Nueva clase Java, en Paquete, escriba com.example.demo.
En Nombre, escriba SampleApp.
En Modificadores, seleccione público.
Deje Superclase en blanco.
Para Qué código auxiliar de método desea crear, seleccione vacío estático Main(string[] args).
Haga clic en Finalizar

Paso 3: Agregar dependencias al proyecto

En la vista Explorador de proyecto, haga doble clic en nombre de proyecto> pom.xml.

Agregue las siguientes dependencias como un elemento secundario del elemento <project> y, a continuación, guarde el archivo:

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

Sustituya:

2.12 con la versión de los clústeres de destino de Scala.
3.2.1 con la versión de los clústeres de destino de Spark.

Consulta la sección "Entorno del sistema" Versiones y compatibilidad de las notas de la versión de Databricks Runtime para la versión de Databricks Runtime de los clústeres de destino.

Paso 4: Compilar el proyecto

En el archivo del proyecto pom.xml, agregue las siguientes propiedades del compilador de Maven como elemento secundario del elemento <project> y guarde el archivo:

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

En la vista Explorador de proyecto, haga clic derecho en el icono del proyecto nombre del proyecto y, a continuación, haga clic en Ejecutar como > Configuraciones de ejecución.
En el cuadro de diálogo Ejecutar configuraciones, haga clic en Compilación de Maven.
Haga clic en el icono Nueva configuración de inicio.
Escriba un nombre para esta configuración de inicio, por ejemplo, compilación limpia.
En Directorio base, haga clic en Área de trabajo, elija el directorio del proyecto y haga clic en Aceptar.
En Objetivos, escriba clean compile.
Haga clic en Ejecutar. La salida de la ejecución aparece en la vista Consola (Ventana > Mostrar vista > Consola).

Paso 5: Incorporar el código al proyecto

Puede agregar cualquier código al proyecto que desee. En este paso se supone que solo desea agregar código a un archivo denominado SampleApp.java para un paquete denominado com.example.demo.

En el archivo del proyecto de src/main/java>com.example.demo>SampleApp.java, agregue el código que desea dbx ejecutar por lotes en los clústeres de destino. (Si no tiene ningún código a mano, puede usar el código de Java del ejemplo de código, que aparece hacia el final de este artículo).

Paso 6: Ejecutar el proyecto

En la vista Explorador de proyecto, haga clic derecho en el icono del proyecto nombre del proyecto y, a continuación, haga clic en Ejecutar como > Configuraciones de ejecución.
En el cuadro de diálogo Ejecutar configuraciones, expanda Aplicación Java y, a continuación, haga clic en Aplicación.
Haga clic en Ejecutar. La salida de la ejecución aparece en la vista Consola.

Paso 7: Compilar el proyecto como un archivo JAR

En la vista Explorador de proyecto, haga clic derecho en el icono del proyecto nombre del proyecto y, a continuación, haga clic en Ejecutar como > Configuraciones de ejecución.
En el cuadro de diálogo Ejecutar configuraciones, haga clic en Compilación de Maven.
Haga clic en el icono Nueva configuración de inicio.
Escriba un nombre para esta configuración de inicio, por ejemplo, paquete limpio.
En Directorio base, haga clic en Área de trabajo, elija el directorio del proyecto y haga clic en Aceptar.
En Objetivos, escriba clean package.
Haga clic en Ejecutar. La salida de la ejecución aparece en la vista Consola.

El archivo JAR se compila en la carpeta <project-name>>target. El nombre del archivo JAR es <project-name>-0.0.1-SNAPSHOT.jar.

Nota:

Si el archivo JAR no aparece en la carpeta target de la ventana del Explorador de proyecto al principio, puede intentar mostrarlo haciendo clic con el botón derecho en el icono del proyecto nombre del proyecto y, a continuación, haga clic en Actualizar.

Paso 8: Mostrar el terminal en el IDE

Con la estructura del proyecto dbx ahora en su lugar, está listo para crear el proyecto dbx. Para empezar, establezca vista de Explorador de proyecto para mostrar los archivos ocultos (archivos a partir de un punto (./)) que dbx genera, como se indica a continuación:

En la vista de Explorador de proyecto, haga clic en el icono de filtro de elipses (Menú de vista) y, a continuación, haga clic en Filtros y personalización.
En el cuadro de diálogo Filtros y personalización, en la pestaña Filtros predefinidos, desactive el cuadro . resources*.
Haga clic en Aceptar.

A continuación, muestre el terminal de Eclipse de la siguiente manera:

Haga clic en Ventana > Mostrar vista > Terminal en la barra de menú.
En el símbolo del sistema del terminal no aparece, en la vista Terminal, haga clic en el icono Abrir un terminal.
Use el comando cd para cambiar al directorio raíz del proyecto.
Continúe con Creación de un proyecto de dbx.

Sin IDE (solo terminal)

Complete las siguientes instrucciones para empezar a usar un terminal y Python con dbx.

Siga estos pasos para usar un terminar para empezar a configurar la estructura del proyecto dbx:

Desde el terminal, cree una carpeta en blanco. Estas instrucciones usan una carpeta llamada dbx-demo (pero puede asignar a la carpeta raíz del proyecto de dbx cualquier nombre que desee). Después de crear la carpeta, cambie a dicha carpeta.

Para Linux y macOS:
```
mkdir dbx-demo
cd dbx-demo
```
Para Windows:
```
md dbx-demo
cd dbx-demo
```
Cree un entorno virtual de Python para este proyecto mediante la ejecución del comando pipenv, con la siguiente opción, desde la raíz de la carpeta dbx-demo, donde <version> es la versión de destino de Python que ya ha instalado localmente, por ejemplo, 3.8.14.
```
pipenv --python <version>
```
Active el entorno virtual de Python mediante la ejecución de pipenv shell.
```
pipenv shell
```
Continúe con Creación de un proyecto de dbx.

Creación de un proyecto de dbx

Con la estructura del proyecto dbx en activo desde una de las secciones anteriores, ya está listo para crear uno de los siguientes tipos de proyectos:

Creación de un proyecto dbx mínimo para Python
Creación de un proyecto dbx mínimo para Scala o Java
Creación de un proyecto con plantilla de dbx con compatibilidad con CI/CD

Creación de un proyecto de dbx mínimo para Python

El siguiente proyecto dbx mínimo es el enfoque más sencillo y rápido para empezar a trabajar con Python y dbx. Muestra la ejecución por lotes de un archivo de código de Python en un clúster multiuso de Azure Databricks existente en el área de trabajo de Azure Databricks.

Nota:

(Para crear un proyecto para Python con plantilla de dbx que muestre la ejecución por lotes de código en clústeres multiuso y clústeres de trabajos, implementaciones de artefactos de código remoto y configuración de la plataforma de CI/CD, vaya directamente a Creación de un proyecto para Python con plantilla de dbx con compatibilidad con CI/CD).

Para completar este procedimiento, debe tener un clúster multiuso existente en el área de trabajo. (Consulte Ver proceso o Referencia de configuración de proceso). Idealmente (pero no necesario), la versión de Python en el entorno virtual de Python debe coincidir con la versión instalada en este clúster. Para identificar la versión de Python del clúster, use el terminal web del clúster para ejecutar el comando python --version.

python --version

En el terminal, desde la carpeta raíz del proyecto de dbx, ejecute el comando dbx configure con la opción siguiente. Este comando crea una carpeta .dbx oculta dentro de la carpeta raíz del proyecto de dbx. Esta carpeta .dbx contiene los archivos lock.json y project.json.
```
dbx configure --profile DEFAULT --environment default
```
Nota:

El archivo project.json define un entorno denominado default junto con una referencia al perfil DEFAULT dentro del archivo .databrickscfg. Si desea que dbx use otro perfil, reemplace --profile DEFAULT por --profile seguido del nombre del perfil de destino en el comando dbx configure.

Por ejemplo, si tiene un perfil denominado DEV en el archivo .databrickscfg y desea que dbx lo use en lugar del perfil DEFAULT, el archivo project.json podría tener este aspecto en su lugar, en cuyo caso también reemplazaría --environment default por --environment dev en el comando dbx configure:
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}
```
Si quiere que dbx use las variables de entorno DATABRICKS_HOST y DATABRICKS_TOKEN en lugar de un perfil del archivo .databrickscfg, omita la opción --profile entera del comando dbx configure.
Cree una carpeta denominada conf dentro de la carpeta raíz del proyecto dbx.

Para Linux y macOS:
```
mkdir conf
```
Para Windows:
```
md conf
```
Agregue un archivo llamado deployment.yaml al directorio conf, con el siguiente contenido de archivo:
```
build:
  no_build: true
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        spark_python_task:
          python_file: "file://dbx-demo-job.py"
```
Nota:

El archivo deployment.yaml contiene la palabra default en minúsculas, que es una referencia al perfil DEFAULT en mayúsculas del archivo .databrickscfg. Si desea que dbx use otro perfil, reemplace default por el nombre del perfil de destino.

Por ejemplo, si tiene un perfil denominado DEV en el archivo .databrickscfg y quiere que dbx lo use en lugar del perfil DEFAULT, el archivo deployment.yaml tendría este aspecto en su lugar:
```
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"
```
Si quiere que dbx use las variables de entorno DATABRICKS_HOST y DATABRICKS_TOKEN en lugar de un perfil del archivo .databrickscfg, deje default en el archivo deployment.yaml tal como está. dbx usará esta referencia de manera predeterminada.
Sugerencia

Para agregar pares clave-valor de configuración de Spark a un trabajo, use el campo spark_conf, por ejemplo:
```
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 agregar permisos a un trabajo, use el campo access_control_list, por ejemplo:
```
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"
        # ...
```
Tenga en cuenta que el campo access_control_list debe ser exhaustivo, por lo que el propietario del trabajo debe agregarse a la lista, igual que los demás permisos de usuario y grupo.
Agregue el código para que se ejecute en el clúster a un archivo denominado dbx-demo-job.py y agregue el archivo a la carpeta raíz del proyecto dbx. (Si no tiene ningún código a mano, puede usar el código de Python del ejemplo de código, que aparece hacia el final de este artículo).

Nota:

No es necesario llamar dbx-demo-job.py a este archivo. Si elige un nombre de archivo diferente, asegúrese de actualizar el campo python_file del archivo conf/deployment.yaml para que coincida.
Ejecute el comando dbx execute con las siguientes opciones. En este comando, reemplace <existing-cluster-id> por el identificador del clúster de destino del área de trabajo. (Para obtener el identificador, consulte Dirección URL e identificador del clúster).
```
dbx execute --cluster-id=<existing-cluster-id> dbx-demo-job --no-package
```
Para ver los resultados de la ejecución localmente, consulte la salida del terminal. Para ver los resultados de la ejecución en el clúster, vaya al panel Standard output de la pestaña Driver logs del clúster. (Consulte Registro de trabajo y controlador de proceso).
Continúe con los pasos siguientes.

Creación de un proyecto de dbx mínimo para Scala o Java

El siguiente proyecto de dbx mínimo es el enfoque más sencillo y rápido para empezar a trabajar con dbx y Scala o Java. Muestra la implementación de un único archivo JAR de Scala o Java en el área de trabajo de Azure Databricks y, a continuación, la ejecución de ese archivo JAR implementado en un clúster de trabajos de Azure Databricks en el área de trabajo de Azure Databricks.

Nota:

Azure Databricks limita cómo puede ejecutar código de Scala y Java en clústeres:

No puede ejecutar un único archivo Scala o Java como un trabajo en un clúster, ya que puede con un único archivo de Python. Para ejecutar código de Scala o Java, primero debe compilarlo en un archivo JAR.
Puede ejecutar un archivo JAR como un trabajo en un clúster multiusos existente. Sin embargo, no puede volver a instalar ninguna actualización de ese archivo JAR en el mismo clúster multiusos. En este caso, debe usar un clúster de trabajos en su lugar. En esta sección se usa el enfoque del clúster de trabajos.
En primer lugar, debe implementar el archivo JAR en el área de trabajo de Azure Databricks para poder ejecutar ese archivo JAR implementado en cualquier clúster o clúster de trabajos multiusos de esa área de trabajo.

En el terminal, desde la carpeta raíz del proyecto, ejecute el comando dbx configure con la opción siguiente. Este comando crea una carpeta .dbx oculta dentro de la carpeta raíz del proyecto. Esta carpeta .dbx contiene los archivos lock.json y project.json.
```
dbx configure --profile DEFAULT --environment default
```
Nota:

El archivo project.json define un entorno denominado default junto con una referencia al perfil DEFAULT dentro del archivo .databrickscfg. Si desea que dbx use otro perfil, reemplace --profile DEFAULT por --profile seguido del nombre del perfil de destino en el comando dbx configure.

Por ejemplo, si tiene un perfil denominado DEV en el archivo .databrickscfg y desea que dbx lo use en lugar del perfil DEFAULT, el archivo project.json podría tener este aspecto en su lugar, en cuyo caso también reemplazaría --environment default por --environment dev en el comando dbx configure:
```
{
  "environments": {
    "default": {
      "profile": "DEFAULT",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<current-folder-name>",
        "artifact_location": "dbfs:/dbx/<current-folder-name>"
      }
    },
    "dev": {
      "profile": "DEV",
      "storage_type": "mlflow",
      "properties": {
        "workspace_directory": "/Shared/dbx/projects/<some-other-folder-name>",
        "artifact_location": "dbfs:/dbx/<some-other-folder-name>"
      }
    }
  }
}
```
Si quiere que dbx use las variables de entorno DATABRICKS_HOST y DATABRICKS_TOKEN en lugar de un perfil del archivo .databrickscfg, omita la opción --profile entera del comando dbx configure.
Cree una carpeta denominada conf dentro de la carpeta raíz del proyecto.

Para Linux y macOS:
```
mkdir conf
```
Para Windows:
```
md conf
```
Agregue un archivo llamado deployment.yaml al directorio conf, con el siguiente contenido de archivo mínimo:
```
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"
```
Sustituya:
- Valor de spark_version con la versión de runtime adecuada para el clúster de trabajos de destino.
- El valor de node_type_id con los Tipos de nodos de trabajo y de controlador apropiados para el clúster de trabajos de destino.
- El valor de instance_pool_id con el identificador de un grupo de instancias existente en el área de trabajo, para permitir la ejecución más rápida de trabajos. Si no tiene un grupo de instancias existente disponible o no desea usar un grupo de instancias, quite esta línea por completo.
- El valor de jar con la ruta de acceso del proyecto al archivo JAR. Para IntelliJ IDEA con Scala, podría ser file://out/artifacts/dbx_demo_jar/dbx-demo.jar. Para el IDE de Eclipse con Java, podría ser file://target/dbx-demo-0.0.1-SNAPSHOT.jar.
- El valor de main_class_name con el nombre de la clase principal en el archivo JAR, por ejemplo com.example.demo.SampleApp.
Nota:

El archivo deployment.yaml contiene la palabra default, que es una referencia al entorno default del archivo .dbx/project.json, que a su vez es una referencia al perfil DEFAULT dentro del archivo .databrickscfg. Si desea que dbx use un perfil diferente, reemplace default en este archivo deployment.yaml por la referencia correspondiente en el archivo .dbx/project.json, que a su vez hace referencia al perfil correspondiente dentro del archivo .databrickscfg.

Por ejemplo, si tiene un perfil denominado DEV en el archivo .databrickscfg y quiere que dbx lo use en lugar del perfil DEFAULT, el archivo deployment.yaml tendría este aspecto en su lugar:
```
environments:
  default:
    workflows:
      - name: "dbx-demo-job"
        # ...
  dev:
    workflows:
      - name: "<some-other-job-name>"
        # ...
```
Si quiere que dbx use las variables de entorno DATABRICKS_HOST y DATABRICKS_TOKEN en lugar de un perfil del archivo .databrickscfg, deje default en el archivo deployment.yaml tal como está. dbx usará la configuración del entorno default (excepto para el valor profile) en el archivo .dbx/project.json de forma predeterminada.
Sugerencia

Para agregar pares clave-valor de configuración de Spark a un trabajo, use el campo spark_conf, por ejemplo:
```
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 agregar permisos a un trabajo, use el campo access_control_list, por ejemplo:
```
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"
        # ...
```
Tenga en cuenta que el campo access_control_list debe ser exhaustivo, por lo que el propietario del trabajo debe agregarse a la lista, igual que los demás permisos de usuario y grupo.
Ejecute el comando dbx deploy. dbx implementa el archivo JAR en la ubicación de la ruta de acceso del .dbx/project.jsonarchivoartifact_location para el entorno coincidente. dbx también implementa los archivos del proyecto como parte de un experimento de MLflow, en la ubicación que aparece en la ruta de acceso del .dbx/project.jsonarchivoworkspace_directory para el entorno coincidente.
```
dbx deploy --no-package
```
Ejecute el comando dbx launch con las siguientes opciones. Este comando ejecuta el trabajo con el nombre coincidente en conf/deployment.yaml. Para buscar el archivo JAR implementado que se va a ejecutar como parte del trabajo, dbx hace referencia a la ubicación en la ruta de acceso del .dbx/project.jsonarchivoartifact_location para el entorno coincidente. Para determinar qué archivo JAR específico se va a ejecutar, dbx hace referencia al experimento de MLflow en la ubicación que aparece en la ruta de acceso del .dbx/project.jsonarchivoworkspace_directory para el entorno coincidente.
```
dbx launch dbx-demo-job
```
Para ver los resultados de la ejecución del trabajo en el clúster de trabajos, consulte Ver trabajos.
Para ver el experimento al que hace referencia el trabajo, consulte Organización de ejecuciones de entrenamiento con experimentos de MLflow.
Continúe con los pasos siguientes.

Creación de un proyecto con plantilla de dbx para Python con compatibilidad con CI/CD

El siguiente proyecto para Python con plantilla de dbx muestra la compatibilidad con la ejecución por lotes de código de Python en clústeres multiuso y clústeres de trabajos de Azure Databricks en las áreas de trabajo de Azure Databricks, implementaciones de artefactos de código remoto y configuración de la plataforma de CI/CD. (Para crear un proyecto de dbx mínimo para Python que solo muestre la ejecución por lotes de un único archivo de código de Python en un clúster multiuso existente, vuelva a Creación de un proyecto de dbx mínimo para Python).

Desde el terminal, en la carpeta raíz del proyecto de dbx, ejecute el comando dbx init.
```
dbx init
```
En project_name, escriba un nombre para el proyecto o pulse Entrar para aceptar el nombre de proyecto predeterminado.
En el campo version, escriba un número de versión inicial para el proyecto o pulse Entrar para aceptar la versión predeterminada del proyecto.
En el campo cloud, seleccione el número que corresponde a la versión de la nube de Azure Databricks que desea que use el proyecto o pulse Entrar para aceptar el valor predeterminado.
En el campo cicd_tool, seleccione el número que corresponde a la herramienta de CI/CD admitida que desea que use el proyecto o pulse Entrar para aceptar el valor predeterminado.
Para project_slug, escriba un prefijo que quiera usar para los recursos del proyecto o pulse Entrar para aceptar el valor predeterminado.
Para workspace_directory, escriba la ruta de acceso local al directorio del área de trabajo del proyecto o pulse Entrar para aceptar el valor predeterminado.
Para artifact_location, escriba la ruta de acceso del área de trabajo de Azure Databricks en la que se escribirán los artefactos del proyecto o pulse Entrar para aceptar el valor predeterminado.
Para el campo profile, escriba el nombre del perfil de autenticación de la CLI que desea que use el proyecto o pulse Entrar para aceptar el valor predeterminado.

Sugerencia

Para omitir los pasos anteriores, ejecute dbx init con parámetros de plantilla codificados de forma rígida, por ejemplo:

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

dbx calcula los parámetros project_slug, workspace_directory y artifact_location automáticamente. Estos tres parámetros son opcionales y solo son útiles para casos de uso más avanzados.

Consulte el comando init en la referencia de la CLI en la documentación de dbx.

Consulte también Próximos pasos.

Ejemplo de código

Si no tiene ningún código disponible para ejecutar por lotes con dbx, puede experimentar haciendo que dbx ejecute por lotes el código siguiente. Este código crea una pequeña tabla en el área de trabajo, consulta la tabla y, a continuación, elimina la tabla.

Sugerencia

Si desea dejar la tabla en el área de trabajo en lugar de eliminarla, comente la última línea de código de este ejemplo antes de ejecutarlo por lotes con 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

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");
  }
}

Pasos siguientes

Amplíe el archivo conf/deployment.yaml para admitir varios tipos de definiciones de clústeres multiuso y de trabajos.
Declare trabajos multitarea en el archivo conf/deployment.yaml.
Haga referencia a las propiedades nombradas en su archivo conf/deployment.yaml.
Ejecute por lotes el código como nuevos trabajos en clústeres con el comando dbx execute.

Recursos adicionales

Implemente por lotes artefactos de código en el almacenamiento del área de trabajo de Azure Databricks con el comando dbx deploy.
Ejecute por lotes trabajos existentes en clústeres con el comando dbx launch.
Use dbx para realizar la implementación e inicio del flujo de trabajo basado en recursos.
Programar implementaciones de flujo de trabajo.
Obtenga más información sobre dbx y CI/CD.
Documentación de dbx
Repositorio databrickslabs/dbx en GitHub
Limitaciones de dbx

Compartir a través de

dbx de Databricks Labs

Requisitos

Visual Studio Code

PyCharm

IntelliJ IDEA

Paso 1: Creación de un proyecto de Scala basado en sbt

Paso 2: Agregar un objeto al paquete

Paso 3: Compilar el proyecto

Paso 4: Incorporación de código al proyecto

Paso 5: Ejecución del proyecto

Paso 6: Compilar el proyecto como un archivo JAR

Paso 7: Mostrar el terminal en el IDE

Eclipse

Paso 1: Creación de un proyecto de Java basado en Maven

Paso 2: Agregar una clase al paquete

Paso 3: Agregar dependencias al proyecto

Paso 4: Compilar el proyecto

Paso 5: Incorporar el código al proyecto

Paso 6: Ejecutar el proyecto

Paso 7: Compilar el proyecto como un archivo JAR

Paso 8: Mostrar el terminal en el IDE

Sin IDE (solo terminal)

Creación de un proyecto de dbx

Creación de un proyecto de dbx mínimo para Python

Creación de un proyecto de dbx mínimo para Scala o Java

Creación de un proyecto con plantilla de dbx para Python con compatibilidad con CI/CD

Ejemplo de código

Python

Scala

Java

Pasos siguientes

Recursos adicionales

Recursos adicionales