Databricks Connect for Databricks Runtime 12.2 LTS e inferior

2025-01-23

Nota

O Databricks Connect recomenda que você use o Databricks Connect for Databricks Runtime 13.0 e superior .

O Databricks não planeja nenhum novo trabalho de recurso para o Databricks Connect for Databricks Runtime 12.2 LTS e inferior.

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

Este artigo explica como o Databricks Connect funciona, orienta você pelas etapas para começar a usar o Databricks Connect, explica como solucionar problemas que podem surgir ao usar o Databricks Connect e as diferenças entre executar usando o Databricks Connect versus executar em um bloco de anotações do Azure Databricks.

Descrição geral

Databricks Connect é uma biblioteca de cliente para o Databricks Runtime. Ele permite que você escreva trabalhos usando 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 spark.read.format(...).load(...).groupBy(...).agg(...).show() DataFrame usando o Databricks Connect, a representação lógica do comando é enviada para o servidor Spark em execução no Azure Databricks para execução no cluster remoto.

Com o Databricks Connect, você pode:

Execute trabalhos Spark em grande escala a partir de qualquer aplicação Python, R, Scala ou Java. Em qualquer lugar que você puder import pyspark, require(SparkR) ou import org.apache.spark, agora você pode executar trabalhos do Spark diretamente do seu aplicativo, sem a necessidade de instalar nenhum plug-in IDE ou usar scripts de envio do Spark.
Percorra e depure o código em seu IDE, mesmo quando estiver trabalhando com um cluster remoto.
Itere rapidamente ao desenvolver bibliotecas. Não é necessário reiniciar o cluster depois de alterar as dependências da biblioteca Python ou Java no Databricks Connect, porque cada sessão de cliente é isolada uma da outra no cluster.
Desligue clusters ociosos sem perder trabalho. Como o aplicativo cliente é dissociado do cluster, ele não é afetado por reinicializações ou atualizações do cluster, o que normalmente faria com que você perdesse todas as variáveis, RDDs e objetos DataFrame definidos em um bloco de anotações.

Nota

Para desenvolvimento Python com consultas SQL, o Databricks recomenda que você use o Databricks SQL Connector for Python em vez do Databricks Connect. o Databricks SQL Connector for Python é mais fácil de configurar do que o Databricks Connect. Além disso, o Databricks Connect analisa e planeja trabalhos executados em sua máquina local, enquanto os trabalhos são executados em recursos de computação remotos. Isso pode tornar especialmente difícil depurar erros de tempo de execução. O Databricks SQL Connector for Python envia consultas SQL diretamente para recursos de computação remotos e busca resultados.

Requerimentos

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

Somente as seguintes versões do Databricks Runtime são suportadas:
- 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 Tempo de execução 7.3 LTS
Você deve instalar o Python 3 em sua máquina 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 a seguir mostra a versão do Python instalada com cada Databricks Runtime.

Versão do Databricks Runtime Versão de 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 que você esteja usando as versões corretas do Python e do Databricks Connect juntos. Isso pode ajudar a reduzir o tempo gasto na resolução de problemas técnicos relacionados.

Por exemplo, se você estiver usando venv em sua máquina de desenvolvimento e seu cluster estiver executando o Python 3.9, deverá criar um venv ambiente com essa versão. O comando de exemplo a seguir gera os scripts para ativar um venv ambiente com o Python 3.9 e, em seguida, coloca esses scripts dentro de uma pasta oculta nomeada .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 venv ambiente, consulte Como os venvs funcionam.

Como outro exemplo, se você estiver usando Conda em sua máquina de desenvolvimento e seu cluster estiver executando Python 3.9, você deve 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 de pacote principal e secundária do Databricks Connect tem de corresponder sempre à sua 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 databricks-connect==12.2.* pacote.

Nota

Consulte as notas de versão do Databricks Connect para obter uma lista das versões e atualizações de manutenção disponíveis do Databricks Connect.
Java Runtime Environment (JRE) 8. O cliente foi testado com o OpenJDK 8 JRE. O cliente não suporta Java 11.

Versão do Databricks Runtime	Versão de 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

Nota

No Windows, se vir um erro indicando que o Databricks Connect não consegue encontrar winutils.exe, consulte Não é possível localizar winutils.exe no Windows.

Configurar o cliente

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

Nota

Antes de começar a configurar o cliente Databricks Connect local, você deve atender aos requisitos para o Databricks Connect.

Etapa 1: Instalar o cliente Databricks Connect

Com seu ambiente virtual ativado, desinstale o PySpark, se ele já estiver instalado, executando o uninstall comando. Isso é necessário porque o pacote entra em conflito com o databricks-connect PySpark. Para obter detalhes, consulte Instalações conflitantes do PySpark. Para verificar se o PySpark já está instalado, execute o show comando.
```
# Is PySpark already installed?
pip3 show pyspark

# Uninstall PySpark
pip3 uninstall pyspark
```
Com seu ambiente virtual ainda ativado, instale o cliente Databricks Connect executando o install comando. Use a --upgrade opção para atualizar qualquer instalação de cliente existente para a versão especificada.
```
pip3 install --upgrade "databricks-connect==12.2.*"  # Or X.Y.* to match your cluster version.
```
Nota

O Databricks recomenda que você anexe a notação "ponto-asterisco" para especificar databricks-connect==X.Y.* em vez de databricks-connect=X.Y, para garantir que o pacote mais recente esteja instalado.

Etapa 2: Configurar propriedades de conexão

Colete as seguintes propriedades de configuração.
- A URL do Azure Databricks por espaço de trabalho. Isto é igual a seguido pelo valor Nome do servidor para o seu cluster; consulte Obter detalhes de conexão para um recurso de computação do Azure Databricks.
- Seu token de acesso pessoal do Azure Databricks ou token do Microsoft Entra ID (anteriormente Azure Ative Directory).
  - Para passagem de credenciais do Azure Data Lake Storage (ADLS), você deve usar um token de ID do Microsoft Entra. A passagem de credenciais do Microsoft Entra ID é suportada apenas em 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 de ID do Microsoft Entra, consulte Autenticação usando tokens de ID do Microsoft Entra.
- A ID do cluster. Você pode obter o ID do cluster a partir da URL. Aqui, o ID do cluster é 1108-201635-xxxxxxxx. Consulte também URL e ID do cluster.
- O ID de organização exclusivo para seu espaço de trabalho. Consulte Obter identificadores para objetos de 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 uma porta diferente, como 8787 a que foi dada nas instruções anteriores para o Azure Databricks, use o número da porta configurada.

Configure a conexão da seguinte maneira.

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

Interface de Linha de Comandos (CLI)

Execute o databricks-connect.

databricks-connect configure

A licença exibe:

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

Aceite os valores de configuração de licença e fornecimento. Para Databricks Host e Databricks Token, insira a URL do espaço de trabalho 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 informando que o token do Microsoft Entra ID é muito longo, poderá deixar o campo Databricks Token vazio e inserir manualmente o token no .

Configurações 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 SQL, use sql("set config=value"). Por exemplo: sql("set spark.databricks.service.clusterId=0304-201045-abcdefgh").

Parâmetro	Chave de configuração SQL	Nome da variável de ambiente
Anfitrião Databricks	spark.databricks.service.address	DATABRICKS_ADDRESS
Databricks Token	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

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

Se nenhum erro relacionado à conexão for mostrado (WARN as mensagens estão bem), então você se conectou com êxito.

Usar o Databricks Connect

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

JupyterLab

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Para instalar o JupyterLab, com seu ambiente virtual Python ativado, execute o seguinte comando no seu terminal ou prompt de comando:
```
pip3 install jupyterlab
```
Para iniciar o JupyterLab no seu navegador da web, execute o seguinte comando a partir do seu ambiente virtual Python ativado:
```
jupyter lab
```
Se o JupyterLab não aparecer no seu navegador da Web, copie o URL que começa com localhost ou 127.0.0.1 do seu ambiente virtual e insira-o na barra de endereço do seu navegador da Web.
Crie um novo notebook: no JupyterLab, clique em Arquivo > Novo > Notebook no menu principal, selecione Python 3 (ipykernel) e clique em Selecionar.
Na primeira célula do bloco de notas, introduza o código de exemplo ou o seu próprio código. Se você usar seu próprio código, no mínimo você deve instanciar uma instância de , como mostrado no SparkSession.builder.getOrCreate() de exemplo.
Para executar o bloco de anotações, clique em Executar > Executar Todas as Células.
Para depurar o bloco de anotações, clique no ícone de bug (Ativar Depurador) ao lado de Python 3 (ipykernel) na barra de ferramentas do bloco de anotações. Defina um ou mais pontos de interrupção e, em seguida, clique em Executar > Executar Todas as Células.
Para encerrar o JupyterLab, clique em > Ficheiros. Se o processo JupyterLab ainda estiver em execução no seu terminal ou prompt de comando, pare esse processo pressionando Ctrl + c e entrando y para confirmar.

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

Caderno Jupyter clássico

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

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

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

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)

Código do Visual Studio

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Verifique se a extensão Python está instalada.
Abra a Paleta de Comandos (Command+Shift+P no macOS e Ctrl+Shift+P no Windows/Linux).
Selecione um interpretador Python. Vá para Configurações>preferências > de código e escolha configurações python.
Execute o databricks-connect get-jar-dir.
Adicione o diretório retornado do comando ao JSON Configurações do Usuário em python.venvPath. Isso deve ser adicionado à configuração do Python.
Desative o linter. Clique no botão ... no lado direito e edite as configurações do json. As configurações modificadas são as seguintes:
Se estiver executando com um ambiente virtual, que é a maneira recomendada de desenvolver para Python no VS Code, na Paleta de Comandos, digite select python interpreter e aponte para o 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

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Clusters Python 3

Ao criar um projeto PyCharm, selecione Intérprete Existente. No menu suspenso, selecione o ambiente Conda que criaste (ver Requisitos).
Vá para Executar > editar configurações.
Adicionar PYSPARK_PYTHON=python3 como uma variável de ambiente.

SparkR e RStudio Desktop

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Faça o download e descompacte a distribuição de código aberto do Spark em sua máquina de desenvolvimento. Escolha a mesma versão do cluster do Azure Databricks (Hadoop 2.7).
Execute o databricks-connect get-jar-dir. Este comando retorna um caminho como /usr/local/lib/python3.5/dist-packages/pyspark/jars. Copie o caminho do arquivo de um diretório acima do caminho do arquivo do diretório JAR, por exemplo, /usr/local/lib/python3.5/dist-packages/pyspark, que é o SPARK_HOME diretório.

Configure o caminho lib do Spark e a página inicial do Spark adicionando-os à parte superior do script R. Defina <spark-lib-path> para o diretório onde você descompactou o pacote Spark de código aberto na etapa 1. Defina <spark-home-path> para o diretório 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>")

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

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

Importante

Esta funcionalidade está em Pré-visualização Pública.

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

Nesta secçã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

No RStudio Desktop, instale o sparklyr 1.2 ou superior a partir do CRAN ou instale a versão master mais recente do GitHub.

# Install from CRAN
install.packages("sparklyr")

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

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

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

Feche a conexão.
```
spark_disconnect(sc)
```

Recursos

Para obter mais informações, consulte o README do GitHub do sparklyr.

Para exemplos de código, consulte sparklyr.

limitações do sparklyr e do RStudio Desktop

Os seguintes recursos não são suportados:

APIs de streaming sparklyr
APIs de ML do sparklyr
APIs da vassoura
csv_file modo de serialização
enviar faísca

IntelliJ (Scala ou Java)

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Execute o databricks-connect get-jar-dir.
Aponte as dependências para o diretório retornado do comando. Vá para Ficheiro > Estrutura do Projeto > Módulos > Dependências > sinal '+' > JARs ou Diretórios.

Para evitar conflitos, é altamente recomendável remover quaisquer outras instalações do Spark do seu classpath. Se isso não for possível, certifique-se de que os JARs adicionados estejam na frente do classpath. Em particular, eles devem estar à frente de qualquer outra versão instalada do Spark (caso contrário, você usará uma dessas outras versões do Spark e será executado localmente ou lançará um ClassDefNotFoundError).
Verifique a configuração da opção breakout no IntelliJ. O padrão é Todos os e causará tempos limite de rede se você definir pontos de interrupção para depuração. Defina-o como Thread para evitar parar os threads de rede em segundo plano.

PyDev com Eclipse

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Abra o Eclipse.
Criar um projeto: clique em Arquivo Novo Projeto PyDev Projeto PyDev> e, em seguida, clique em >.>>
Especifique um nome de projeto.
Para Conteúdo do projeto, especifique o caminho para seu ambiente virtual Python.
Clique em Configurar um intérprete antes de continuar.
Clique em Configuração manual.
Clique em New > Browse for python/pypy exe.
Navegue até e selecione o caminho completo para o interpretador Python referenciado no ambiente virtual e depois clique em Abrir.
Na caixa de diálogo Selecionar intérprete, clique em OK.
Na caixa de diálogo Seleção necessária, clique em OK.
Na caixa de diálogo Preferências, clique em Aplicar e Fechar.
Na caixa de diálogo Projeto PyDev, clique em Concluir.
Clique em Abrir perspetiva.
Adicione ao projeto um arquivo de código Python (.py) que contenha o código de exemplo ou seu próprio código. Se você usar seu próprio código, no mínimo você deve instanciar uma instância de , como mostrado no SparkSession.builder.getOrCreate() de exemplo.
Com o arquivo de código Python aberto, defina quaisquer pontos de interrupção onde você deseja que seu código pause durante a execução.
Clique em Executar > , Executar ou Executar > Depuração.

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

Eclipse

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Execute o databricks-connect get-jar-dir.
Aponte a configuração de JARs externos para o diretório retornado do comando. Vá para o menu > Projeto Propriedades > Java Build Path > Libraries > Adicionar Jars Externos.

Para evitar conflitos, é altamente recomendável remover quaisquer outras instalações do Spark do seu classpath. Se isso não for possível, certifique-se de que os JARs adicionados estejam na frente do classpath. Em particular, eles devem estar à frente de qualquer outra versão instalada do Spark (caso contrário, você usará uma dessas outras versões do Spark e será executado localmente ou lançará um ClassDefNotFoundError).

SBT

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

`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

Nota

Antes de começar a usar o Databricks Connect, você deve atender aos requisitos e configurar o cliente para o Databricks Connect.

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

Com seu ambiente virtual ativado, certifique-se de que o comando databricks-connect test foi executado com êxito em Configurar o cliente.
Com seu ambiente virtual ativado, inicie o shell do Spark. Para Python, execute o pyspark comando. Para Scala, execute o spark-shell comando.
```
# For Python:
pyspark
```
```
# For Scala:
spark-shell
```

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>

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

Use a variável interna spark para representar o SparkSession 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

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

Exemplos de código

Este exemplo de código simples consulta a tabela especificada e, em seguida, mostra as primeiras 5 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:

Cria um DataFrame na memória.
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 tabela diferente, ajuste as chamadas para spark.sql, temps.write.saveAsTableou ambos.
Salva o conteúdo do DataFrame na tabela.
Executa uma SELECT consulta no conteúdo da tabela.
Mostra o resultado da consulta.
Exclui a tabela.

Píton

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

linguagem de programação Scala

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, sua classe principal ou arquivo Python terá outros JARs e arquivos de dependência. Você pode adicionar esses JARs e arquivos de dependência chamando sparkContext.addJar("path-to-the-jar") ou sparkContext.addPyFile("path-to-the-file"). Você também pode adicionar arquivos Egg e arquivos zip com a addPyFile() interface. Sempre que você executa o código no IDE, os JARs e arquivos de dependência são instalados no cluster.

Píton

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 + Java UDFs

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

linguagem de programação Scala

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

Utilitários do Access Databricks

Esta seção descreve como usar o Databricks Connect para acessar o Databricks Utilities.

Você pode usar os utilitários dbutils.fs e dbutils.secrets do módulo de referência Databricks Utilities (dbutils). Os comandos suportados são dbutils.fs.cp, , , dbutils.fs.head, dbutils.fs.ls, dbutils.fs.mkdirsdbutils.fs.mv, dbutils.fs.put, dbutils.fs.rm, dbutils.secrets.get, , . dbutils.secrets.getBytesdbutils.secrets.listdbutils.secrets.listScopes Consulte Utilitário do sistema de arquivos (dbutils.fs) ou executar dbutils.fs.help() e Utilitário de segredos (dbutils.secrets) ou executar dbutils.secrets.help().

Píton

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 DBUtils de uma maneira 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"]

linguagem de programação Scala

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

Copiando arquivos entre sistemas de arquivos locais e remotos

Você pode usar dbutils.fs para copiar arquivos entre seu cliente e sistemas de arquivos remotos. 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 ficheiro que pode ser transferido dessa forma é de 250 MB.

Ativar `dbutils.secrets.get`

Devido a restrições de segurança, a capacidade de chamar dbutils.secrets.get é desativada por padrão. Entre em contato com o suporte do Azure Databricks para habilitar esse recurso para seu espaço de trabalho.

Definir configurações do Hadoop

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

Resoluçã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 com o Databricks Connect e como resolvê-los.

Nesta secção:

Erro de correspondência de versão do Python
O servidor não está ativado
Instalações PySpark em conflito
Conflitantes 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
O nome do arquivo, nome do diretório ou sintaxe do rótulo do volume está incorreto no Windows

Erro de correspondência 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 versus 3.9.15 é OK, 3.9 versus 3.8 não é).

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

O servidor não está ativado

Verifique se o cluster tem o servidor Spark habilitado com spark.databricks.service.server.enabled trueo . Você deve ver as seguintes linhas no log do driver, se 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 entra em conflito com o databricks-connect PySpark. Ter ambos instalados causará erros ao inicializar o contexto do Spark em 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 em seu ambiente Python, certifique-se de que ele seja desinstalado antes de instalar o databricks-connect. Depois de desinstalar o PySpark, certifique-se de reinstalar totalmente o pacote 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.

Conflitantes `SPARK_HOME`

Se você já usou o Spark em sua máquina, seu IDE pode ser configurado para usar uma dessas outras versões do Spark em vez do Databricks Connect Spark. Isso pode se manifestar de várias maneiras, incluindo erros de "fluxo corrompido" ou "classe não encontrada". Você pode ver qual versão do Spark está sendo usada verificando o valor da variável de SPARK_HOME ambiente:

Píton

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

linguagem de programação Scala

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 da do cliente, você deve desdefinir a variável SPARK_HOME e tentar novamente.

Verifique as configurações da variável de ambiente do IDE, o arquivo .bashrc, .zshrcou .bash_profile e em qualquer outro lugar que as variáveis de ambiente possam ser definidas. Você provavelmente terá que sair e reiniciar seu IDE para limpar o estado antigo, e você pode até precisar criar um novo projeto se o problema persistir.

Você não deve precisar atribuir um novo valor a SPARK_HOME; removê-lo deve ser suficiente.

Entrada conflitante ou ausente `PATH` para binários

É possível que seu PATH esteja configurado para que comandos como spark-shell estarão executando algum outro binário instalado anteriormente em vez daquele fornecido com o Databricks Connect. Isso pode causar databricks-connect test falhas. Certifique-se de que os binários do Databricks Connect tenham precedência ou remova os instalados anteriormente.

Se não consegues executar comandos como spark-shell, pode ser que o teu PATH não tenha sido configurado automaticamente por pip3 install e precise adicionar manualmente o diretório de instalação bin ao teu PATH. É possível usar o Databricks Connect com IDEs mesmo que isso não esteja configurado. No entanto, o databricks-connect test comando não funcionará.

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

Se você vir erros de "fluxo corrompido" durante a execução databricks-connect test, isso pode ser devido a configurações de serialização de cluster incompatíveis. Por exemplo, definir a spark.io.compression.codec configuração pode causar esse problema. Para resolver esse problema, considere remover essas configurações das configurações de cluster ou definir a configuração no cliente Databricks Connect.

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

Se você estiver usando o Databricks Connect no Windows e veja:

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.

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

Se você estiver usando o Windows e o Databricks Connect e veja:

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

O Java ou o Databricks Connect foram instalados em um diretório com um espaço no caminho. Você pode contornar isso instalando em um caminho de diretório sem espaços ou configurando seu caminho usando o formulário de nome curto.

Autenticação usando tokens de ID do Microsoft Entra

Nota

As informações a seguir se aplicam somente às versões 7.3.5 a 12.2.x do Databricks Connect.

O Databricks Connect for Databricks Runtime 13.3 LTS e superior atualmente não suporta tokens de ID do Microsoft Entra.

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

Para as versões 7.3.5 a 12.2.x do Databricks Connect, você pode fornecer o token de ID do Microsoft Entra 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.

Píton

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

linguagem de programação Scala

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

Depois de atualizar o token, o aplicativo pode continuar a usar o mesmo SparkSession e quaisquer objetos e estados 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 a vida útil do token de ID do Microsoft Entra para persistir durante a execução do seu aplicativo. Para fazer isso, anexe um TokenLifetimePolicy com um tempo de vida adequadamente longo ao aplicativo de autorização Microsoft Entra ID que você usou para adquirir o token de acesso.

Nota

A passagem de ID do Microsoft Entra usa dois tokens: o token de acesso de ID do Microsoft Entra que foi descrito anteriormente que você configura nas versões 7.3.5 a 12.2.x do Databricks Connect e o token de passagem ADLS para o recurso específico que o Databricks gera enquanto o Databricks processa a solicitação. Não é possível estender o tempo de vida dos tokens de passagem ADLS usando as políticas de tempo de vida do token do Microsoft Entra ID. Se você enviar um comando para o cluster que leva mais de uma hora, ele falhará se o comando acessar um recurso ADLS após a marca de uma hora.

Limitações

Catálogo Unity.

Streaming estruturado.
Execução de código arbitrário que não faz parte de um trabalho do Spark no cluster remoto.
APIs nativas Scala, Python e R para operações de tabela Delta (por exemplo, DeltaTable.forPath) não são suportadas. No entanto, a API SQL (spark.sql(...)) com operações Delta Lake e a API Spark (por exemplo, spark.read.load) em tabelas Delta são suportadas.
Copie para.
Usando funções SQL, Python ou Scala UDFs que fazem parte do catálogo do servidor. No entanto, UDFs Scala e Python introduzidos localmente funcionam.
Apache Zeppelin 0.7.x e inferior.
Ligar-se a clusters com controlo de acesso à tabela .
Ligar-se a clusters com o isolamento de processo ativado (em outras palavras, onde spark.databricks.pyspark.enableProcessIsolation está configurado para true).
Comando Delta CLONE SQL.
Visões temporárias globais.
Koalas e pyspark.pandas.
CREATE TABLE table AS SELECT ... Os comandos SQL nem sempre funcionam. Em vez disso, use spark.sql("SELECT ...").write.saveAsTable("table").

A passagem de credenciais do Microsoft Entra ID é suportada apenas em clusters padrão que executam o Databricks Runtime 7.3 LTS e superior e não é compatível com a autenticação da entidade de serviço.
A seguinte referência aos utilitários do Databricks (dbutils):

Partilhar via

Databricks Connect for Databricks Runtime 12.2 LTS e inferior

Descrição geral

Requerimentos

Configurar o cliente

Etapa 1: Instalar o cliente Databricks Connect

Etapa 2: Configurar propriedades de conexão

Usar o Databricks Connect

Nesta secção:

JupyterLab

Caderno Jupyter clássico

Código do Visual Studio

PyCharm

Clusters Python 3

SparkR e RStudio Desktop

sparklyr e RStudio Desktop

Nesta secção:

Requisitos

Instalar, configurar e usar o sparklyr

Recursos

limitações do sparklyr e do RStudio Desktop

IntelliJ (Scala ou Java)

PyDev com Eclipse

Eclipse

SBT

build.sbt

Shell do Spark

Exemplos de código

Píton

linguagem de programação Scala

Java

Trabalhar com dependências

Píton

linguagem de programação Scala

Utilitários do Access Databricks

Píton

linguagem de programação Scala

Copiando arquivos entre sistemas de arquivos locais e remotos

Ativar dbutils.secrets.get

Definir configurações do Hadoop

Resolução de Problemas

Nesta secção:

Erro de correspondência de versão do Python

O servidor não está ativado

Instalações conflitantes do PySpark

Conflitantes SPARK_HOME

Píton

linguagem de programação Scala

Java

Resolução

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

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

Autenticação usando tokens de ID do Microsoft Entra

Píton

linguagem de programação Scala

Limitações

Comentários

Recursos adicionais

`build.sbt`

Ativar `dbutils.secrets.get`

Conflitantes `SPARK_HOME`

Entrada conflitante ou ausente `PATH` para binários

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