Databricks Connect para Databricks Runtime 12.2 LTS e abaixo

O Databricks Connect permite conectar IDEs populares, como Visual Studio Code e PyCharm, servidores do notebook e outros aplicativos personalizados a clusters do Azure Databricks.

Este artigo explica como funciona o Databricks Connect, descreve as etapas necessárias para você começar a usar o Databricks Connect, explica como solucionar problemas que possam surgir durante o uso do Databricks Connect e as diferenças entre a execução no Databricks Connect e a execução em um notebook do Azure Databricks.

Visão geral

O Databricks Connect é uma biblioteca de clientes do Databricks Runtime. Ele permite que você escreva trabalhos usando as APIs do Spark e execute-os remotamente em um cluster do Azure Databricks em vez de na sessão local do Spark.

Por exemplo, quando você executa o comando DataFrame spark.read.format(...).load(...).groupBy(...).agg(...).show() usando o Databricks Connect, a representação lógica do comando é enviada ao servidor do Spark em execução no Azure Databricks para execução no cluster remoto.

Com o Databricks Connect, você pode:

• Execute trabalhos do Spark em grande escala a partir de qualquer aplicativo Python, R, Scala ou Java. Em qualquer lugar que você possa import pyspark, require(SparkR) ou import org.apache.spark, agora você pode executar trabalhos do Spark diretamente do seu aplicativo, sem precisar instalar plug-ins do IDE ou usar scripts de envio do Spark.
• Executar o código em etapas e depurá-lo no IDE, mesmo quando trabalhar com um cluster remoto.
• Iterar rapidamente ao desenvolver bibliotecas. Você não precisa reiniciar o cluster depois de alterar as dependências da biblioteca Python ou Java no Databricks Connect, pois cada sessão do cliente é isolada uma da outra no cluster.
• Desligar clusters ociosos sem perder o trabalho. Como o aplicativo cliente é separado do cluster, ele não é afetado por reinicializações nem por atualizações do cluster, o que normalmente fará com que você perca todas as variáveis, os RDDs e os objetos de DataFrame definidos em um notebook.

Requisitos

Esta seção lista os requisitos para o Databricks Connect.

• Só há suporte para as seguintes versões do Databricks Runtime:

  • Databricks Runtime 12.2 LTS ML, Databricks Runtime 12.2 LTS
  • Databricks Runtime 11.3 LTS ML, Databricks Runtime 11.3 LTS
  • Databricks Runtime 10.4 LTS ML, Databricks Runtime 10.4 LTS
  • Databricks Runtime 9.1 LTS ML, Databricks Runtime 9.1 LTS
  • Databricks Runtime 7.3 LTS

• Você deve instalar o Python 3 em seu computador de desenvolvimento e a versão secundária da instalação do Python do cliente deve ser a mesma que a versão secundária do Python do cluster do Azure Databricks. A tabela mostra a versão do Python instalada com cada Databricks Runtime.

  Versão do Databricks Runtime	Versão do Python
  12.2 LTS ML, 12.2 LTS	3.9
  11.3 LTS ML, 11.3 LTS	3.9
  10.4 LTS ML, 10.4 LTS	3.8
  9.1 LTS ML, 9.1 LTS	3.8
  7.3 LTS	3.7

  O Databricks recomenda que você tenha um ambiente virtual Python ativado para cada versão do Python que você usa com o Databricks Connect. Os ambientes virtuais Python ajudam a garantir o uso das versões corretas do Python e do Databricks Connect em conjunto. Isso pode ajudar a reduzir o tempo gasto resolvendo problemas técnicos relacionados.

  Por exemplo, se você estiver usando o venv em seu computador de desenvolvimento e seu cluster estiver executando o Python 3.9, você deverá criar um venv ambiente com essa versão. O comando de exemplo a seguir gera os scripts para ativar um ambiente venv com Python 3.9 e, em seguida, esse comando coloca esses scripts dentro de uma pasta oculta chamada .venv dentro do diretório de trabalho atual:

  # Linux and macOS
  python3.9 -m venv ./.venv
  
  # Windows
  python3.9 -m venv .\.venv
  

  Para usar esses scripts para ativar esse ambiente venv, confira Como os venvs funcionam.

  Como outro exemplo, se você estiver usando o Conda em seu computador de desenvolvimento e seu cluster estiver executando o Python 3.9, você deverá criar um ambiente Conda com essa versão, por exemplo:

  conda create --name dbconnect python=3.9
  

  Para ativar o ambiente Conda com esse nome de ambiente, execute conda activate dbconnect.

• A versão principal e secundária do pacote do Databricks Connect deve sempre corresponder à versão do Databricks Runtime. O Databricks recomenda que você sempre use o pacote mais recente do Databricks Connect que corresponda à sua versão do Databricks Runtime. Por exemplo, quando você usa um cluster Databricks Runtime 12.2 LTS, você também deve usar o pacote databricks-connect==12.2.*.

  Observação

  Confira as notas sobre a versão do Databricks Connect para ver uma lista das versões e das atualizações de manutenção disponíveis do Databricks Connect.

• JRE (Java Runtime Environment) 8. O cliente foi testado com o OpenJDK 8 JRE. Ele não dá suporte ao Java 11.

Configurar o cliente

Conclua as etapas a seguir para configurar o cliente local do Databricks Connect.

Etapa 1: instalar o cliente do Databricks Connect

1. Com o ambiente virtual ativado, desinstale o PySpark, se ele já estiver instalado, executando o comando uninstall. Isso é necessário porque o pacote databricks-connect está em conflito com o PySpark. Para obter detalhes, confira Instalações conflitantes do PySpark. Para verificar se o PySpark já está instalado, execute o comando show.

   # Is PySpark already installed?
   pip3 show pyspark
   
   # Uninstall PySpark
   pip3 uninstall pyspark
   

2. Com o ambiente virtual ainda ativado, instale o cliente do Databricks Connect executando o comando install. Use a opção --upgrade para atualizar qualquer instalação do cliente existente para a versão especificada.

   pip3 install --upgrade "databricks-connect==12.2.*"  # Or X.Y.* to match your cluster version.
   

   Observação

   O Databricks recomenda que você acrescente a notação "dot-asterisk" a ser especificada databricks-connect==X.Y.* em vez de databricks-connect=X.Y, para garantir que o pacote mais recente esteja instalado.

Etapa 2: configurar as propriedades da conexão

1. Colete as propriedades de configuração a seguir.

   • A URL do Azure Databricks por espaço de trabalho. Isso também é o mesmo que https:// seguido pelo valor Nome do host do servidor para seu cluster; consulte Obter detalhes de conexão para um recurso de computação do Azure Databricks.

   • Um token de acesso pessoal do Azure Databricks ou um token do Microsoft Entra ID (antigo Azure Active Directory).

     • Para a passagem de credencial do Azure Data Lake Storage (ADLS), você deve usar um token do Microsoft Entra ID. A passagem de credenciais do Microsoft Entra ID é compatível apenas com clusters Standard que executam o Databricks Runtime 7.3 LTS e superior e não é compatível com a autenticação da entidade de serviço.
     • Para obter mais informações sobre autenticação com tokens do Microsoft Entra ID, consulte Autenticação por meio de tokens do Microsoft Entra ID.

   • A ID da sua computação clássica. Você pode obter o identificador de computação clássico a partir da URL. Aqui está o 1108-201635-xxxxxxxx ID. Consulte também a URL e a ID do recurso de computação.

     

   • A ID de organização exclusiva do seu workspace. Consulte Obter identificadores para objetos do espaço de trabalho .

   • A porta à qual o Databricks Connect se conecta no cluster. A porta padrão é 15001. Se o cluster estiver configurado para usar outra porta, como 8787, que foi fornecida nas instruções anteriores para o Azure Databricks, use o número da porta configurado.

2. Configure a conexão da seguinte maneira.

   Você pode usar a CLI, as configurações do SQL ou as variáveis de ambiente. A precedência dos métodos de configuração do mais alto para o mais baixo é: chaves de configuração do SQL, CLI e variáveis de ambiente.

   • CLI

     1. Execute databricks-connect.

        databricks-connect configure
        

        A licença é exibida:

        Copyright (2018) Databricks, Inc.
        
        This library (the "Software") may not be used except in connection with the
        Licensee's use of the Databricks Platform Services pursuant to an Agreement
          ...
        

     2. Aceite os valores de configuração de licença e de fornecimento. Em Host do Databricks e Token do Databricks, insira a URL do workspace e o token de acesso pessoal que você anotou na Etapa 1.

        Do you accept the above agreement? [y/N] y
        Set new config values (leave input empty to accept default):
        Databricks Host [no current value, must start with https://]: <databricks-url>
        Databricks Token [no current value]: <databricks-token>
        Cluster ID (e.g., 0921-001415-jelly628) [no current value]: <cluster-id>
        Org ID (Azure-only, see ?o=orgId in URL) [0]: <org-id>
        Port [15001]: <port>
        

        Se você receber uma mensagem indicando que o token do Microsoft Entra ID é muito longo, mantenha o campo Token do Databricks vazio e insira o token manualmente em ~/.databricks-connect.

   • Configurações do SQL ou variáveis de ambiente. A tabela a seguir mostra as chaves de configuração do SQL e as variáveis de ambiente que correspondem às propriedades de configuração que você anotou na Etapa 1. Para definir uma chave de configuração do SQL, use sql("set config=value"). Por exemplo: sql("set spark.databricks.service.clusterId=0304-201045-abcdefgh").

     Parâmetro	Chave de configuração do SQL	Nome de variável de ambiente
     Host do Databricks	spark.databricks.service.address	DATABRICKS_ADDRESS
     Token do Databricks	spark.databricks.service.token	DATABRICKS_API_TOKEN
     ID do cluster	spark.databricks.service.clusterId	DATABRICKS_CLUSTER_ID
     ID da organização	spark.databricks.service.orgId	DATABRICKS_ORG_ID
     Porta	spark.databricks.service.port	DATABRICKS_PORT

3. Com seu ambiente virtual ainda ativado, teste a conectividade com o Azure Databricks da seguinte maneira.

   databricks-connect test
   

   Se o cluster configurado não estiver em execução, o teste iniciará o cluster, que permanecerá em execução até o tempo de encerramento automático configurado. O resultado deve ser semelhante ao seguinte:

   * PySpark is installed at /.../.../pyspark
   * Checking java version
   java version "1.8..."
   Java(TM) SE Runtime Environment (build 1.8...)
   Java HotSpot(TM) 64-Bit Server VM (build 25..., mixed mode)
   * Testing scala command
   ../../.. ..:..:.. WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
   Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
   Setting default log level to "WARN".
   To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
   ../../.. ..:..:.. WARN MetricsSystem: Using default name SparkStatusTracker for source because neither spark.metrics.namespace nor spark.app.id is set.
   ../../.. ..:..:.. WARN SparkServiceRPCClient: Now tracking server state for 5ab..., invalidating prev state
   ../../.. ..:..:.. WARN SparkServiceRPCClient: Syncing 129 files (176036 bytes) took 3003 ms
   Welcome to
         ____              __
        / __/__  ___ _____/ /__
       _\ \/ _ \/ _ `/ __/  '_/
      /___/ .__/\_,_/_/ /_/\_\   version 2...
         /_/
   
   Using Scala version 2.... (Java HotSpot(TM) 64-Bit Server VM, Java 1.8...)
   Type in expressions to have them evaluated.
   Type :help for more information.
   
   scala> spark.range(100).reduce(_ + _)
   Spark context Web UI available at https://...
   Spark context available as 'sc' (master = local[*], app id = local-...).
   Spark session available as 'spark'.
   View job details at <databricks-url>/?o=0#/setting/clusters/<cluster-id>/sparkUi
   View job details at <databricks-url>?o=0#/setting/clusters/<cluster-id>/sparkUi
   res0: Long = 4950
   
   scala> :quit
   
   * Testing python command
   ../../.. ..:..:.. WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
   Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
   Setting default log level to "WARN".
   To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
   ../../.. ..:..:.. WARN MetricsSystem: Using default name SparkStatusTracker for source because neither spark.metrics.namespace nor spark.app.id is set.
   ../../.. ..:..:.. WARN SparkServiceRPCClient: Now tracking server state for 5ab.., invalidating prev state
   View job details at <databricks-url>/?o=0#/setting/clusters/<cluster-id>/sparkUi
   

4. Se nenhum erro relacionado à conexão for mostrado (WARN mensagens estiverem corretas), você se conectou com êxito.

Usar o Databricks Connect

A seção descreve como configurar seu servidor IDE ou notebook preferencial para usar o cliente do Databricks Connect.

Nesta seção:

• JupyterLab
• Jupyter Notebook clássico
• PyCharm
• SparkR e RStudio Desktop
• sparklyr e RStudio Desktop
• IntelliJ (Scala ou Java)
• PyDev com Eclipse
• Eclipse
• SBT
• Shell do Spark

JupyterLab

Para usar o Databricks Connect com o JupyterLab e Python, siga estas instruções.

1. Para instalar o JupyterLab, com o ambiente virtual Python ativado, execute o seguinte comando no terminal ou no Prompt de Comando:

   pip3 install jupyterlab
   

2. Para iniciar o JupyterLab no navegador da Web, execute o seguinte comando no ambiente virtual Python ativado:

   jupyter lab
   

   Se o JupyterLab não aparecer no navegador da Web, copie a URL que começa com localhost ou 127.0.0.1 do seu ambiente virtual e insira-a na barra de endereços do navegador da Web.

3. Crie um novo notebook: no JupyterLab, clique em Arquivo > Novo > Notebook no menu principal, selecione Python 3 (ipykernel) e clique em Selecionar.

4. Na primeira célula do notebook, insira o código de exemplo ou seu próprio código. Se você usar o próprio código, no mínimo deverá criar uma instância do SparkSession.builder.getOrCreate(), conforme mostrado no código de exemplo.

5. Para executar o notebook, clique em Executar > Executar Todas as Células.

6. Para depurar o notebook, clique no ícone bug (Habilitar Depurador) ao lado do Python 3 (ipykernel) na barra de ferramentas do notebook. Defina um ou mais pontos de interrupção e clique em Executar > Executar Todas as Células.

7. Para desligar o JupyterLab, clique em Arquivo > Desligado. Se o processo do JupyterLab ainda estiver em execução no seu terminal ou prompt de comando, interrompa esse processo pressionando Ctrl + c e, em seguida, inserindo y para confirmar.

Para obter instruções de depuração mais específicas, confira Depurador.

Jupyter Notebook Clássico

O script de configuração do Databricks Connect adiciona automaticamente o pacote à configuração do projeto. Para começar a trabalhar em um kernel do Python, execute:

from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()

Para habilitar a abreviação %sql para executar e visualizar consultas SQL, use o seguinte snippet:

from IPython.core.magic import line_magic, line_cell_magic, Magics, magics_class

@magics_class
class DatabricksConnectMagics(Magics):

   @line_cell_magic
   def sql(self, line, cell=None):
       if cell and line:
           raise ValueError("Line must be empty for cell magic", line)
       try:
           from autovizwidget.widget.utils import display_dataframe
       except ImportError:
           print("Please run `pip install autovizwidget` to enable the visualization widget.")
           display_dataframe = lambda x: x
       return display_dataframe(self.get_spark().sql(cell or line).toPandas())

   def get_spark(self):
       user_ns = get_ipython().user_ns
       if "spark" in user_ns:
           return user_ns["spark"]
       else:
           from pyspark.sql import SparkSession
           user_ns["spark"] = SparkSession.builder.getOrCreate()
           return user_ns["spark"]

ip = get_ipython()
ip.register_magics(DatabricksConnectMagics)

Visual Studio Code

Para usar o Databricks Connect com o Visual Studio Code, faça o seguinte:

1. Verifique se a extensão do Python está instalada.

2. Abra a paleta de comandos (Comando+SHIFT+P no macOS e CTRL+SHIFT+P no Windows/no Linux).

3. Selecione um interpretador do Python. Acesse Código > Preferências > Configurações e escolha Configurações do Python.

4. Execute databricks-connect get-jar-dir.

5. Adicione o diretório retornado do comando ao JSON de Configurações de Usuário em python.venvPath. Isso deve ser adicionado à Configuração do Python.

6. Desabilite o linter. Clique em … no lado direito e edite as configurações de JSON. As configurações modificadas são as seguintes:

   

7. Se você estiver a executando com um ambiente virtual, que é a maneira recomendada de desenvolvimento para Python no VS Code, na paleta de comandos, digite select python interpreter e aponte para seu ambiente que corresponde à versão do Python do cluster.

   

   Por exemplo, se o cluster for Python 3.9, seu ambiente de desenvolvimento deverá ser Python 3.9.

   

PyCharm

O script de configuração do Databricks Connect adiciona automaticamente o pacote à configuração do projeto.

Clusters do Python 3

1. Ao criar um projeto do PyCharm, selecione Interpretador Existente. No menu suspenso, selecione o ambiente do Conda que você criou (confira Requisitos).

   

2. Acesse Executar > Editar configurações.

3. Adicione PYSPARK_PYTHON=python3 como uma variável de ambiente.

   

SparkR e RStudio Desktop

Para usar o Databricks Connect com o SparkR e o RStudio Desktop, faça o seguinte:

1. Baixe e descompacte a distribuição código aberto do Spark em sua máquina de desenvolvimento. Escolha a mesma versão que no cluster do Azure Databricks (Hadoop 2.7).

2. Execute databricks-connect get-jar-dir. Esse comando retorna um caminho como /usr/local/lib/python3.5/dist-packages/pyspark/jars. Copie o caminho de arquivo de um diretório acima, o caminho do arquivo de diretório JAR, por exemplo, /usr/local/lib/python3.5/dist-packages/pyspark, que é o diretório SPARK_HOME.

3. Configure o caminho de biblioteca do Spark e a página inicial do Spark adicionando-os ao início do script R. Defina <spark-lib-path> como o diretório em que você desempacotou o pacote do Spark de código aberto na etapa 1. Defina <spark-home-path> como o diretório do Databricks Connect da etapa 2.

   # Point to the OSS package path, e.g., /path/to/.../spark-2.4.0-bin-hadoop2.7
   library(SparkR, lib.loc = .libPaths(c(file.path('<spark-lib-path>', 'R', 'lib'), .libPaths())))
   
   # Point to the Databricks Connect PySpark installation, e.g., /path/to/.../pyspark
   Sys.setenv(SPARK_HOME = "<spark-home-path>")
   

4. Inicie uma sessão do Spark e comece a executar comandos do SparkR.

   sparkR.session()
   
   df <- as.DataFrame(faithful)
   head(df)
   
   df1 <- dapply(df, function(x) { x }, schema(df))
   collect(df1)
   

sparklyr e RStudio Desktop

Você pode copiar o código dependente do sparklyr que desenvolveu localmente usando o Databricks Connect e executá-lo em um notebook do Azure Databricks ou no RStudio Server hospedado no seu workspace do Azure Databricks, com poucas ou nenhuma alteração no código.

Nesta seção:

• Requisitos
• Instalar, configurar e usar o sparklyr
• Recursos
• Limitações do sparklyr e do RStudio Desktop

Requisitos

• sparklyr 1.2 ou superior.
• Databricks Runtime 7.3 LTS ou superior com a versão correspondente do Databricks Connect.

Instalar, configurar e usar o sparklyr

1. No RStudio Desktop, instale o sparklyr 1.2 ou superior do CRAN ou instale a última versão mestre do GitHub.

   # Install from CRAN
   install.packages("sparklyr")
   
   # Or install the latest master version from GitHub
   install.packages("devtools")
   devtools::install_github("sparklyr/sparklyr")
   

2. Ative o ambiente Python com a versão correta do Databricks Connect instalada e execute o seguinte comando no terminal para obter o <spark-home-path>:

   databricks-connect get-spark-home
   

3. Inicie uma sessão do Spark e comece a executar comandos do sparklyr.

   library(sparklyr)
   sc <- spark_connect(method = "databricks", spark_home = "<spark-home-path>")
   
   iris_tbl <- copy_to(sc, iris, overwrite = TRUE)
   
   library(dplyr)
   src_tbls(sc)
   
   iris_tbl %>% count
   

4. Feche a conexão.

   spark_disconnect(sc)
   

Recursos

Para obter mais informações, confira o LEIAME do sparklyr no GitHub.

Para ver exemplos de código, confira sparklyr.

Limitações do sparklyr e do RStudio Desktop

Não há suporte para os seguintes recursos:

• APIs de streaming do sparklyr
• APIs de ML do sparklyr
• APIs do broom
• Modo de serialização do csv_file
• Spark-submit

IntelliJ (Scala ou Java)

Para usar o Databricks Connect com o IntelliJ (Scala ou Java), faça o seguinte:

1. Execute databricks-connect get-jar-dir.

2. Aponte as dependências para o diretório retornado do comando. Vá para Arquivo > Estrutura do Projeto > Módulos > Dependências > Sinal de '+' > JARs ou Diretórios.

   

   Para evitar conflitos, recomendamos expressamente remover qualquer outra instalação do Spark do caminho de classe. Se isso não for possível, verifique se os JARs que você adicionar estão à frente do caminho de classe. Em particular, eles precisam estar à frente de qualquer outra versão instalada do Spark (caso contrário, você usará uma dessas outras versões do Spark e a executará localmente ou vai gerar uma ClassDefNotFoundError).

3. Verifique a configuração da opção de sessão de grupo no IntelliJ. O padrão é Todos e causará tempos limite de rede se você definir pontos de interrupção para depuração. Defina-o como Thread para evitar interromper os threads de rede em segundo plano.

   

PyDev com Eclipse

Para usar o Databricks Connect e o PyDev com o Eclipse, siga estas instruções.

1. Inicie o Eclipse.
2. Criar um projeto: clique em Arquivo > Novo > Projeto > PyDev > Projeto PyDev e clique em Avançar.
3. Especifique um Nome do projeto.
4. Para Conteúdo do projeto, especifique o caminho para o ambiente virtual Python.
5. Clique em Configure um interpretador antes de continuar.
6. Clique em Configuração manual.
7. Clique em Novo > Procurar python/pypy exe.
8. Procure e selecione o caminho completo para o interpretador do Python referenciado no ambiente virtual e, em seguida, clique em Abrir.
9. Na caixa de diálogo Selecionar interpretador, clique em OK.
10. Na caixa de diálogo Seleção necessária, clique em OK.
11. Na caixa de diálogo Preferências, clique em Aplicar e Fechar.
12. Na caixa de diálogo Projeto PyDev, clique em Concluir.
13. Clique em Abrir Perspectiva.
14. Adicione ao projeto um arquivo de código Python (.py) que contém o código de exemplo ou seu próprio código. Se você usar o próprio código, no mínimo deverá criar uma instância do SparkSession.builder.getOrCreate(), conforme mostrado no código de exemplo.
15. Com o arquivo de código Python aberto, defina os pontos de interrupção em que você deseja que seu código pause durante a execução.
16. Clique em Executar > Executar ou Executar > Depurar.

Para obter instruções de execução e depuração mais específicas, confira Executando um programa.

Eclipse

Para usar o Databricks Connect e o Eclipse, faça o seguinte:

1. Execute databricks-connect get-jar-dir.

2. Aponte a configuração de JARs externos para o diretório retornado do comando. Acesse menu Projeto > Propriedades > Caminho de Build do Java > Bibliotecas > Adicionar JARs Externos.

   

   Para evitar conflitos, recomendamos expressamente remover qualquer outra instalação do Spark do caminho de classe. Se isso não for possível, verifique se os JARs que você adicionar estão à frente do caminho de classe. Em particular, eles precisam estar à frente de qualquer outra versão instalada do Spark (caso contrário, você usará uma dessas outras versões do Spark e a executará localmente ou vai gerar uma ClassDefNotFoundError).

   

SBT

Para usar o Databricks Connect com o SBT, você deve configurar seu arquivo build.sbt para vincular aos JARs do Databricks Connect em vez da dependência usual da biblioteca do Spark. Faça isso com a diretiva unmanagedBase no seguinte exemplo de arquivo de build, que pressupõe um aplicativo Scala que tenha um objeto principal com.example.Test:

build.sbt

name := "hello-world"
version := "1.0"
scalaVersion := "2.11.6"
// this should be set to the path returned by ``databricks-connect get-jar-dir``
unmanagedBase := new java.io.File("/usr/local/lib/python2.7/dist-packages/pyspark/jars")
mainClass := Some("com.example.Test")

Shell do Spark

Para usar o Databricks Connect com o shell do Spark e Python ou Scala, siga estas instruções.

1. Com o ambiente virtual ativado, certifique-se de que o comando databricks-connect test foi executado com êxito em Configurar o cliente.

2. Com seu ambiente virtual ativado, inicie o shell do Spark. Para Python, execute o comando pyspark. Para Scala, execute o comando spark-shell.

   # For Python:
   pyspark
   

   # For Scala:
   spark-shell
   

3. O shell do Spark aparece, por exemplo, para Python:

   Python 3... (v3...)
   [Clang 6... (clang-6...)] on darwin
   Type "help", "copyright", "credits" or "license" for more information.
   Setting default log level to "WARN".
   To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
   ../../.. ..:..:.. WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
   Welcome to
          ____              __
        / __/__  ___ _____/ /__
       _\ \/ _ \/ _ `/ __/  '_/
      /__ / .__/\_,_/_/ /_/\_\   version 3....
         /_/
   
   Using Python version 3... (v3...)
   Spark context Web UI available at http://...:...
   Spark context available as 'sc' (master = local[*], app id = local-...).
   SparkSession available as 'spark'.
   >>>
   

   Para Scala:

   Setting default log level to "WARN".
   To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
   ../../.. ..:..:.. WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
   Spark context Web UI available at http://...
   Spark context available as 'sc' (master = local[*], app id = local-...).
   Spark session available as 'spark'.
   Welcome to
         ____              __
        / __/__  ___ _____/ /__
       _\ \/ _ \/ _ `/ __/  '_/
      /___/ .__/\_,_/_/ /_/\_\   version 3...
         /_/
   
   Using Scala version 2... (OpenJDK 64-Bit Server VM, Java 1.8...)
   Type in expressions to have them evaluated.
   Type :help for more information.
   
   scala>
   

4. Consulte Análise interativa com o shell do Spark para obter informações sobre como usar o shell do Spark com Python ou Scala para executar comandos no cluster.

   Use a variável interna spark para representar o SparkSession no cluster em execução, por exemplo, para Python:

   >>> df = spark.read.table("samples.nyctaxi.trips")
   >>> df.show(5)
   +--------------------+---------------------+-------------+-----------+----------+-----------+
   |tpep_pickup_datetime|tpep_dropoff_datetime|trip_distance|fare_amount|pickup_zip|dropoff_zip|
   +--------------------+---------------------+-------------+-----------+----------+-----------+
   | 2016-02-14 16:52:13|  2016-02-14 17:16:04|         4.94|       19.0|     10282|      10171|
   | 2016-02-04 18:44:19|  2016-02-04 18:46:00|         0.28|        3.5|     10110|      10110|
   | 2016-02-17 17:13:57|  2016-02-17 17:17:55|          0.7|        5.0|     10103|      10023|
   | 2016-02-18 10:36:07|  2016-02-18 10:41:45|          0.8|        6.0|     10022|      10017|
   | 2016-02-22 14:14:41|  2016-02-22 14:31:52|         4.51|       17.0|     10110|      10282|
   +--------------------+---------------------+-------------+-----------+----------+-----------+
   only showing top 5 rows
   

   Para Scala:

   >>> val df = spark.read.table("samples.nyctaxi.trips")
   >>> df.show(5)
   +--------------------+---------------------+-------------+-----------+----------+-----------+
   |tpep_pickup_datetime|tpep_dropoff_datetime|trip_distance|fare_amount|pickup_zip|dropoff_zip|
   +--------------------+---------------------+-------------+-----------+----------+-----------+
   | 2016-02-14 16:52:13|  2016-02-14 17:16:04|         4.94|       19.0|     10282|      10171|
   | 2016-02-04 18:44:19|  2016-02-04 18:46:00|         0.28|        3.5|     10110|      10110|
   | 2016-02-17 17:13:57|  2016-02-17 17:17:55|          0.7|        5.0|     10103|      10023|
   | 2016-02-18 10:36:07|  2016-02-18 10:41:45|          0.8|        6.0|     10022|      10017|
   | 2016-02-22 14:14:41|  2016-02-22 14:31:52|         4.51|       17.0|     10110|      10282|
   +--------------------+---------------------+-------------+-----------+----------+-----------+
   only showing top 5 rows
   

5. Para parar o shell do Spark, pressione Ctrl + d ou Ctrl + z ou execute o comando quit() ou exit() para Python ou :q ou :quit para Scala.

Exemplos de código

Este exemplo de código simples consulta a tabela especificada e mostra as cinco primeiras linhas da tabela especificada. Para usar uma tabela diferente, ajuste a chamada para spark.read.table.

from pyspark.sql.session import SparkSession

spark = SparkSession.builder.getOrCreate()

df = spark.read.table("samples.nyctaxi.trips")
df.show(5)

Este exemplo de código mais longo faz o seguinte:

1. Cria um DataFrame na memória.
2. Cria uma tabela com o nome zzz_demo_temps_table dentro do esquema default. Se a tabela com esse nome já existir, a tabela será excluída primeiro. Para usar um esquema ou uma tabela diferente, ajuste as chamadas para spark.sql, temps.write.saveAsTable ou ambos.
3. Salva o conteúdo do DataFrame na tabela.
4. Executa uma SELECT consulta no conteúdo da tabela.
5. Mostra o resultado da consulta.
6. Exclui a tabela.

Python

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

spark = SparkSession.builder.appName('temps-demo').getOrCreate()

# Create a Spark 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 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 zzz_demo_temps_table')
temps.write.saveAsTable('zzz_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.
df_temps = spark.sql("SELECT * FROM zzz_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 zzz_demo_temps_table')

Scala (linguagem de programação)

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

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

      // Create a Spark DataFrame consisting of high and low temperatures
      // by airport code and date.
      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 zzz_demo_temps_table")
      temps.write.saveAsTable("zzz_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 zzz_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 zzz_demo_temps_table")
  }
}

Java

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 App {
    public static void main(String[] args) throws Exception {
        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 zzz_demo_temps_table");
        temps.write().saveAsTable("zzz_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 zzz_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 zzz_demo_temps_table");
    }
}

Trabalhar com dependências

Normalmente, a classe principal ou o arquivo Python terá outros JARs e arquivos de dependência. Você pode adicionar esses JARs de dependência e arquivos chamando sparkContext.addJar("path-to-the-jar") ou sparkContext.addPyFile("path-to-the-file"). Adicione também arquivos Egg e arquivos zip com a interface addPyFile(). Sempre que você executar o código no IDE, os JARs de dependência e os arquivos serão instalados no cluster.

Python

from lib import Foo
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

sc = spark.sparkContext
#sc.setLogLevel("INFO")

print("Testing simple count")
print(spark.range(100).count())

print("Testing addPyFile isolation")
sc.addPyFile("lib.py")
print(sc.parallelize(range(10)).map(lambda i: Foo(2)).collect())

class Foo(object):
  def __init__(self, x):
    self.x = x

Python e UDFs do Java

from pyspark.sql import SparkSession
from pyspark.sql.column import _to_java_column, _to_seq, Column

## In this example, udf.jar contains compiled Java / Scala UDFs:
#package com.example
#
#import org.apache.spark.sql._
#import org.apache.spark.sql.expressions._
#import org.apache.spark.sql.functions.udf
#
#object Test {
#  val plusOne: UserDefinedFunction = udf((i: Long) => i + 1)
#}

spark = SparkSession.builder \
  .config("spark.jars", "/path/to/udf.jar") \
  .getOrCreate()
sc = spark.sparkContext

def plus_one_udf(col):
  f = sc._jvm.com.example.Test.plusOne()
  return Column(f.apply(_to_seq(sc, [col], _to_java_column)))

sc._jsc.addJar("/path/to/udf.jar")
spark.range(100).withColumn("plusOne", plus_one_udf("id")).show()

Scala (linguagem de programação)

package com.example

import org.apache.spark.sql.SparkSession

case class Foo(x: String)

object Test {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder()
      ...
      .getOrCreate();
    spark.sparkContext.setLogLevel("INFO")

    println("Running simple show query...")
    spark.read.format("parquet").load("/tmp/x").show()

    println("Running simple UDF query...")
    spark.sparkContext.addJar("./target/scala-2.11/hello-world_2.11-1.0.jar")
    spark.udf.register("f", (x: Int) => x + 1)
    spark.range(10).selectExpr("f(id)").show()

    println("Running custom objects query...")
    val objs = spark.sparkContext.parallelize(Seq(Foo("bye"), Foo("hi"))).collect()
    println(objs.toSeq)
  }
}

Acessar Utilitários do Databricks

Esta seção descreve como usar o Databricks Connect para acessar os Utilitários do Databricks.

Você pode usar os utilitários dbutils.fs e dbutils.secrets do módulo de Utilitários do Databricks (dbutils) referência. Os comandos compatíveis são dbutils.fs.cp, dbutils.fs.head, dbutils.fs.ls, dbutils.fs.mkdirs, dbutils.fs.mv, dbutils.fs.put, dbutils.fs.rm, dbutils.secrets.get, dbutils.secrets.getBytes, dbutils.secrets.list e dbutils.secrets.listScopes. Confira Utilitário do sistema de arquivos (dbutils.fs) ou execute dbutils.fs.help() e Utilitário de segredos (dbutils.secrets) ou execute dbutils.secrets.help().

Python

from pyspark.sql import SparkSession
from pyspark.dbutils import DBUtils

spark = SparkSession.builder.getOrCreate()

dbutils = DBUtils(spark)
print(dbutils.fs.ls("dbfs:/"))
print(dbutils.secrets.listScopes())

Ao usar o Databricks Runtime 7.3 LTS ou superior, para acessar o módulo do DBUtils de uma forma que funcione localmente e em clusters do Azure Databricks, use o seguinte get_dbutils():

def get_dbutils(spark):
  from pyspark.dbutils import DBUtils
  return DBUtils(spark)

Caso contrário, use o seguinte get_dbutils():

def get_dbutils(spark):
  if spark.conf.get("spark.databricks.service.client.enabled") == "true":
    from pyspark.dbutils import DBUtils
    return DBUtils(spark)
  else:
    import IPython
    return IPython.get_ipython().user_ns["dbutils"]

Scala (linguagem de programação)

val dbutils = com.databricks.service.DBUtils
println(dbutils.fs.ls("dbfs:/"))
println(dbutils.secrets.listScopes())

Como copiar arquivos entre sistemas de arquivos locais e remotos

Use dbutils.fs para copiar arquivos entre o cliente e os sistemas de arquivos remotos. O esquema file:/ refere-se ao sistema de arquivos local no cliente.

from pyspark.dbutils import DBUtils
dbutils = DBUtils(spark)

dbutils.fs.cp('file:/home/user/data.csv', 'dbfs:/uploads')
dbutils.fs.cp('dbfs:/output/results.csv', 'file:/home/user/downloads/')

O tamanho máximo do arquivo que pode ser transferido dessa maneira é de 250 MB.

Habilitar dbutils.secrets.get

Devido a restrições de segurança, a capacidade de chamada a dbutils.secrets.get está desabilitada por padrão. Entre em contato com o suporte do Azure Databricks para habilitar esse recurso no seu workspace.

Definir configurações do Hadoop

No cliente, você pode definir configurações do Hadoop usando a API spark.conf.set, que se aplica às operações de SQL e do DataFrame. As configurações do Hadoop definidas no sparkContext precisam ser feitas na configuração do cluster ou por meio de um notebook. Isso porque as configurações definidas em sparkContext não estão vinculadas às sessões de usuário, mas se aplicam a todo o cluster.

Solução de problemas

Execute databricks-connect test para verificar se há problemas de conectividade. Esta seção descreve alguns problemas comuns que você pode encontrar no Databricks Connect e como resolvê-los.

Nesta seção:

• Incompatibilidade de versão do Python
• Servidor não habilitado
• Instalações conflitantes do PySpark
• Conflitante SPARK_HOME
• Entrada conflitante ou ausente PATH para binários
• Configurações de serialização conflitantes no cluster
• Não é possível encontrar winutils.exe no Windows
• A sintaxe do nome do arquivo, nome do diretório ou rótulo do volume está incorreta no Windows

Incompatibilidade de versão do Python

Verifique se a versão do Python que você está usando localmente tem, pelo menos, a mesma versão secundária que a versão no cluster (por exemplo, 3.9.16 em relação a 3.9.15 é adequado, mas 3.9 em relação a 3.8 não).

Se você tiver várias versões do Python instaladas localmente, verifique se o Databricks Connect está usando a correta definindo a variável de ambiente PYSPARK_PYTHON (por exemplo, PYSPARK_PYTHON=python3).

Servidor não habilitado

Verifique se o cluster tem o servidor do Spark habilitado com spark.databricks.service.server.enabled true. Você verá as seguintes linhas no log do driver se ele for:

../../.. ..:..:.. INFO SparkConfUtils$: Set spark config:
spark.databricks.service.server.enabled -> true
...
../../.. ..:..:.. INFO SparkContext: Loading Spark Service RPC Server
../../.. ..:..:.. INFO SparkServiceRPCServer:
Starting Spark Service RPC Server
../../.. ..:..:.. INFO Server: jetty-9...
../../.. ..:..:.. INFO AbstractConnector: Started ServerConnector@6a6c7f42
{HTTP/1.1,[http/1.1]}{0.0.0.0:15001}
../../.. ..:..:.. INFO Server: Started @5879ms

Instalações conflitantes do PySpark

O pacote databricks-connect entra em conflito com o PySpark. Ter os dois instalados causará erros ao inicializar o contexto do Spark no Python. Isso pode se manifestar de várias maneiras, incluindo erros de “fluxo corrompido” ou “classe não encontrada”. Se você tiver o PySpark instalado no ambiente do Python, verifique se ele foi desinstalado antes de instalar o databricks-connect. Depois de desinstalar o PySpark, lembre-se de reinstalar totalmente o pacote do Databricks Connect:

pip3 uninstall pyspark
pip3 uninstall databricks-connect
pip3 install --upgrade "databricks-connect==12.2.*"  # or X.Y.* to match your specific cluster version.

SPARK_HOME conflitante

Se você já tiver usado o Spark no computador, o IDE poderá ser configurado para usar uma dessas outras versões do Spark em vez do Databricks Connect para Spark. Isso pode se manifestar de várias maneiras, incluindo erros de “fluxo corrompido” ou “classe não encontrada”. Você poderá ver a versão do Spark que está sendo usada verificando o valor da variável de ambiente SPARK_HOME:

Python

import os
print(os.environ['SPARK_HOME'])

Scala (linguagem de programação)

println(sys.env.get("SPARK_HOME"))

Java

System.out.println(System.getenv("SPARK_HOME"));

Resolução

Se SPARK_HOME estiver definido como uma versão do Spark diferente daquela do cliente, remova a definição da variável SPARK_HOME e tente novamente.

Verifique as configurações da variável de ambiente do IDE, o arquivo .bashrc, .zshrc ou .bash_profile e qualquer outro lugar em que as variáveis de ambiente possam estar definidas. Provavelmente, você precisará sair do IDE e reiniciá-lo para limpar o estado antigo e talvez até precise criar um projeto caso o problema persista.

Você não precisa definir SPARK_HOME como um novo valor. A remoção da definição deve ser suficiente.

Entrada PATH conflitante ou ausente para binários

É possível que o PATH esteja configurado, ou seja, comandos como spark-shell executarão algum outro binário instalado anteriormente em vez do fornecido com o Databricks Connect. Isso poderá causar uma falha no databricks-connect test. Você deve verificar se os binários do Databricks Connect têm precedência ou remover os instalados anteriormente.

Se você não puder executar comandos como spark-shell, também é possível que seu PATH não tenha sido configurado pip3 install automaticamente e você precisará adicionar o dir de instalação bin ao seu PATH manualmente. É possível usar o Databricks Connect com IDEs mesmo que isso não esteja configurado. No entanto, o comando databricks-connect test não funcionará.

Configurações de serialização conflitantes no cluster

Se você receber erros de “fluxo corrompido” ao executar o databricks-connect test, isso poderá ser devido a configurações de serialização de cluster incompatíveis. Por exemplo, definir a configuração spark.io.compression.codec pode causar esse problema. Para resolvê-lo, considere a possibilidade de remover essas configurações das configurações do cluster ou de definir a configuração no cliente do Databricks Connect.

Não é possível encontrar winutils.exe no Windows

Se estiver usando o Databricks Connect no Windows e receber:

ERROR Shell: Failed to locate the winutils binary in the hadoop binary path
java.io.IOException: Could not locate executable null\bin\winutils.exe in the Hadoop binaries.

Siga as instruções para configurar o caminho do Hadoop no Windows.

A sintaxe do nome do arquivo, do nome do diretório ou do rótulo do volume está incorreta no Windows

Se estiver usando o Databricks Connect no Windows e receber:

The filename, directory name, or volume label syntax is incorrect.

O Java ou o Databricks Connect foi instalado em um diretório com um espaço no caminho. Resolva isso instalando em um caminho de diretório sem espaços ou configurando o caminho usando o formato de nome curto.

Autenticação usando o tokens do Microsoft Entra ID

Ao usar o Databricks Connect versões 7.3.5 a 12.2.x, você pode autenticar usando um token do Microsoft Entra ID em vez de um token de acesso pessoal. Os tokens do Microsoft Entra ID têm um tempo de vida limitado. Quando o token do do Microsoft Entra ID expira, o Databricks Connect falha com um erro Invalid Token.

Para as versões 7.3.5 a 12.2.x do Databricks Connect, você pode fornecer o token do Microsoft Entra ID em seu aplicativo Databricks Connect em execução. Seu aplicativo precisa obter o novo token de acesso e defini-lo como a chave de configuração do SQL spark.databricks.service.token.

Python

spark.conf.set("spark.databricks.service.token", new_aad_token)

Scala (linguagem de programação)

spark.conf.set("spark.databricks.service.token", newAADToken)

Depois de atualizar o token, o aplicativo pode continuar usando o mesmo SparkSession e todos os objetos e o estado criados no contexto da sessão. Para evitar erros intermitentes, o Databricks recomenda que você forneça um novo token antes que o token antigo expire.

Você pode estender o tempo de vida do token do Microsoft Entra ID para que ele seja persistente durante a execução do aplicativo. Para fazer isso, anexe uma TokenLifetimePolicy com um tempo de vida apropriado ao aplicativo de autorização do Microsoft Entra ID que você usou para adquirir o token de acesso.

Limitações

• Catálogo do Unity.

• Streaming Estruturado.
• Execução de código arbitrário que não faz parte de um trabalho do Spark no cluster remoto.
• Não há suporte para APIs nativas do Scala, do Python e do R em operações de tabela Delta (por exemplo, DeltaTable.forPath). No entanto, há suporte para a API do SQL (spark.sql(...)) operações do Delta Lake e a API do Spark (por exemplo, spark.read.load) em tabelas Delta.
• Cópia.
• Utilizando funções SQL ou UDFs em Python ou Scala que fazem parte do catálogo do servidor. No entanto, as UDFs do Scala e do Python foram introduzidas localmente.
• Apache Zeppelin 0.7.x e inferior.
• Conexão aos clusters com o controle de acesso à tabela.
• Conexão aos clusters com o isolamento de processo habilitado (em outras palavras, quando spark.databricks.pyspark.enableProcessIsolation é definido como true).
• Comando SQL CLONE delta.
• Exibições temporárias globais.
• Coalas e pyspark.pandas.
• CREATE TABLE table AS SELECT ... Os comandos SQL nem sempre funcionam. Em vez disso, use spark.sql("SELECT ...").write.saveAsTable("table").

• Só há suporte para a passagem de credenciais do Microsoft Entra ID em clusters standard que executam o Databricks Runtime 7.3 LTS e superior, e ela não é compatível com a autenticação da entidade de serviço.
• A seguinte referência de Utilitários do Databricks (dbutils):
  • biblioteca
  • fluxo de trabalho do notebook
  • Widgets