Databricks Connect för Databricks Runtime 12.2 LTS och nedan

2025-01-23

Kommentar

Databricks Connect rekommenderar att du använder Databricks Connect för Databricks Runtime 13.0 och senare i stället.

Databricks planerar inget nytt funktionsarbete för Databricks Connect för Databricks Runtime 12.2 LTS och nedan.

Med Databricks Connect kan du ansluta populära IDE:er som Visual Studio Code och PyCharm, notebook-servrar och andra anpassade program till Azure Databricks-kluster.

Den här artikeln förklarar hur Databricks Connect fungerar, vägleder dig genom stegen för att komma igång med Databricks Connect, förklarar hur du felsöker problem som kan uppstå när du använder Databricks Connect och skillnader mellan att köra med Databricks Connect jämfört med att köras i en Azure Databricks-notebook-fil.

Översikt

Databricks Connect är ett klientbibliotek för Databricks Runtime. Du kan skriva jobb med Spark-API:er och fjärrköra dem på ett Azure Databricks-kluster i stället för i den lokala Spark-sessionen.

När du till exempel kör DataFrame-kommandot spark.read.format(...).load(...).groupBy(...).agg(...).show() med Databricks Connect skickas den logiska representationen av kommandot till Spark-servern som körs i Azure Databricks för körning på fjärrklustret.

Med Databricks Connect kan du:

Kör storskaliga Spark-jobb från alla Python-, R-, Scala- eller Java-program. Var du än kan import pyspark, require(SparkR) eller import org.apache.spark, kan du nu köra Spark-jobb direkt från ditt program, utan att behöva installera några IDE-plugin-program eller använda Spark-inlämningsskript.
Stega igenom och felsöka kod i din IDE även när du arbetar med ett fjärrkluster.
Iterera snabbt när du utvecklar bibliotek. Du behöver inte starta om klustret när du har ändrat Beroenden för Python- eller Java-bibliotek i Databricks Connect, eftersom varje klientsession är isolerad från varandra i klustret.
Stäng av inaktiva kluster utan att förlora arbetet. Eftersom klientprogrammet är frikopplat från klustret påverkas det inte av klusteromstarter eller uppgraderingar, vilket normalt gör att du förlorar alla variabler, RDD:er och DataFrame-objekt som definierats i en notebook-fil.

Kommentar

För Python-utveckling med SQL-frågor rekommenderar Databricks att du använder Databricks SQL Connector för Python i stället för Databricks Connect. Databricks SQL Connector för Python är enklare att konfigurera än Databricks Connect. Dessutom körs Databricks Connect-parsningar och planer på din lokala dator, medan jobb körs på fjärrberäkningsresurser. Detta kan göra det särskilt svårt att felsöka körningsfel. Databricks SQL Connector för Python skickar SQL-frågor direkt till fjärrberäkningsresurser och hämtar resultat.

Krav

I det här avsnittet visas kraven för Databricks Connect.

Endast följande Databricks Runtime-versioner stöds:
- 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
Du måste installera Python 3 på utvecklingsdatorn och den lägre versionen av python-klientens installation måste vara samma som den lägre Python-versionen av Azure Databricks-klustret. I följande tabell visas Python-versionen som är installerad med varje Databricks Runtime.

Databricks Runtime-version Python-version

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

Databricks rekommenderar starkt att du har en virtuell Python-miljö aktiverad för varje Python-version som du använder med Databricks Connect. Virtuella Python-miljöer hjälper dig att se till att du använder rätt versioner av Python och Databricks Connect tillsammans. Detta kan bidra till att minska den tid som ägnas åt att lösa relaterade tekniska problem.

Om du till exempel använder venv på utvecklingsdatorn och klustret kör Python 3.9 måste du skapa en venv miljö med den versionen. Följande exempelkommando genererar skripten för att aktivera en venv miljö med Python 3.9, och det här kommandot placerar sedan dessa skript i en dold mapp med namnet .venv i den aktuella arbetskatalogen:
```
# Linux and macOS
python3.9 -m venv ./.venv

# Windows
python3.9 -m venv .\.venv
```
Information om hur du använder dessa skript för att aktivera den här venv miljön finns i Så här fungerar venvs.

Om du till exempel använder Conda på utvecklingsdatorn och klustret kör Python 3.9 måste du skapa en Conda-miljö med den versionen, till exempel:
```
conda create --name dbconnect python=3.9
```
Om du vill aktivera Conda-miljön med det här miljönamnet kör du conda activate dbconnect.
Den högre och lägre Databricks Connect-paketversionen måste alltid matcha din Databricks Runtime-version. Databricks rekommenderar att du alltid använder det senaste paketet med Databricks Connect som matchar din Databricks Runtime-version. När du till exempel använder ett Databricks Runtime 12.2 LTS-kluster måste du också använda databricks-connect==12.2.* paketet.

Kommentar

Se utgivningsanteckningarna för Databricks Connect för en lista över tillgängliga Databricks Connect-versioner och underhållsuppdateringar.
Java Runtime Environment (JRE) 8. Klienten har testats med OpenJDK 8 JRE. Klienten stöder inte Java 11.

Databricks Runtime-version	Python-version
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

Kommentar

Om du ser ett fel på Windows där Databricks Connect inte kan hitta winutils.exe, se Kan inte hitta winutils.exe på Windows.

Konfigurera klienten

Utför följande steg för att konfigurera den lokala klienten för Databricks Connect.

Kommentar

Innan du börjar konfigurera den lokala Databricks Connect-klienten måste du uppfylla kraven för Databricks Connect.

Steg 1: Installera Databricks Connect-klienten

När den virtuella miljön är aktiverad avinstallerar du PySpark, om den redan är installerad, genom att uninstall köra kommandot . Detta krävs eftersom paketet står i databricks-connect konflikt med PySpark. Mer information finns i PySpark-installationer i konflikt. Kör kommandot för att kontrollera om PySpark redan är installerat show .
```
# Is PySpark already installed?
pip3 show pyspark

# Uninstall PySpark
pip3 uninstall pyspark
```
När den virtuella miljön fortfarande är aktiverad installerar du Databricks Connect-klienten genom att install köra kommandot . Använd alternativet --upgrade för att uppgradera en befintlig klientinstallation till den angivna versionen.
```
pip3 install --upgrade "databricks-connect==12.2.*"  # Or X.Y.* to match your cluster version.
```
Kommentar

Databricks rekommenderar att du lägger till notationen "dot-asterisk" för att ange databricks-connect==X.Y.* i stället för databricks-connect=X.Y, för att se till att det senaste paketet är installerat.

Steg 2: Konfigurera anslutningsegenskaper

Samla in följande konfigurationsegenskaper.
- URL:en för Azure Databricks per arbetsyta. Detta är också samma som https:// följt av värdet Server Hostname för klustret. se Hämta anslutningsinformation för en Azure Databricks-beräkningsresurs.
- Din personliga Åtkomsttoken för Azure Databricks eller Microsoft Entra-ID (tidigare Azure Active Directory).
  - För genomströmning av autentiseringsuppgifter för Azure Data Lake Storage (ADLS) måste du använda en Microsoft Entra-ID-token. Genomströmning av Microsoft Entra-ID-autentiseringsuppgifter stöds endast i Standard-kluster som kör Databricks Runtime 7.3 LTS och senare och är inte kompatibelt med autentisering med tjänstens huvudnamn.
  - Mer information om autentisering med Microsoft Entra ID-token finns i Autentisering med Microsoft Entra ID-token.
- ID:t för klustret. Du kan hämta kluster-ID:t från URL:en. Här är 1108-201635-xxxxxxxxkluster-ID:t . Se även Kluster-URL och ID.
- Det unika organisations-ID:t för din arbetsyta. Se Hämta identifierare för arbetsyteobjekt.
- Porten som Databricks Connect ansluter till i klustret. Standardporten är 15001. Om klustret är konfigurerat för att använda en annan port, till exempel 8787 som angavs i tidigare instruktioner för Azure Databricks, använder du det konfigurerade portnumret.

Konfigurera anslutningen på följande sätt.

Du kan använda cli-, SQL-konfigurationer eller miljövariabler. Prioriteten för konfigurationsmetoder från högsta till lägsta är: SQL-konfigurationsnycklar, CLI och miljövariabler.

Kommandoradsgränssnitt (CLI)

Kör databricks-connect.

databricks-connect configure

Licensen visar:

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

Acceptera konfigurationsvärdena för licens och leverans. För Databricks-värd - och Databricks-token anger du arbetsytans URL och den personliga åtkomsttoken som du antecknade i steg 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>

Om du får ett meddelande om att Microsoft Entra-ID-token är för lång kan du lämna Databricks-token fältet tomt och manuellt ange token i ~/.databricks-connect.

SQL-konfigurationer eller miljövariabler. I följande tabell visas SQL-konfigurationsnycklarna och miljövariablerna som motsvarar de konfigurationsegenskaper som du antecknade i steg 1. Om du vill ange en SQL-konfigurationsnyckel använder du sql("set config=value"). Exempel: sql("set spark.databricks.service.clusterId=0304-201045-abcdefgh").

Parameter	SQL-konfigurationsnyckel	Miljöns variabelnamn
Databricks-värd	spark.databricks.service.address	DATABRICKS_ADDRESS
Databricks-token	spark.databricks.service.token	DATABRICKS_API_TOKEN
Kluster-ID	spark.databricks.service.clusterId	DATABRICKS_CLUSTER_ID
Org-ID	spark.databricks.service.orgId	DATABRICKS_ORG_ID
Hamn	spark.databricks tjänsteport	DATABRICKS_PORT

När den virtuella miljön fortfarande är aktiverad testar du anslutningen till Azure Databricks på följande sätt.

databricks-connect test

Om klustret som du konfigurerade inte körs startar testet klustret som fortsätter att köras till dess konfigurerade autotermineringstid. Utdata bör se ut ungefär så här:

* 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

Om inga anslutningsrelaterade fel visas (WARN meddelanden är okej) har du anslutit.

Använda Databricks Connect

I avsnittet beskrivs hur du konfigurerar önskad IDE- eller notebook-server för att använda klienten för Databricks Connect.

JupyterLab

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Följ dessa instruktioner om du vill använda Databricks Connect med JupyterLab och Python.

Om du vill installera JupyterLab, med din virtuella Python-miljö aktiverad, kör du följande kommando från terminalen eller kommandotolken:
```
pip3 install jupyterlab
```
Starta JupyterLab i webbläsaren genom att köra följande kommando från den aktiverade virtuella Python-miljön:
```
jupyter lab
```
Om JupyterLab inte visas i webbläsaren kopierar du url:en som börjar med localhost eller 127.0.0.1 från den virtuella miljön och anger den i webbläsarens adressfält.
Skapa en ny notebook-fil: i JupyterLab klickar du på File > New > Notebook på huvudmenyn, väljer Python 3 (ipykernel) och klickar på Välj.
I anteckningsbokens första cell anger du antingen exempelkoden eller din egen kod. Om du använder din egen kod måste du minst instansiera en instans av SparkSession.builder.getOrCreate(), som du ser i exempelkoden.
Om du vill köra anteckningsboken klickar du på Kör > kör alla celler.
Om du vill felsöka anteckningsboken klickar du på buggikonen (Aktivera felsökningsprogram) bredvid Python 3 (ipykernel) i anteckningsbokens verktygsfält. Ange en eller flera brytpunkter och klicka sedan på Kör > Kör alla celler.
Om du vill stänga av JupyterLab klickar du på > fil. Om JupyterLab-processen fortfarande körs i terminalen eller kommandotolken stoppar du den här processen genom att trycka på Ctrl + c och sedan ange y för att bekräfta.

Mer specifika felsökningsinstruktioner finns i Felsökningsprogram.

Klassisk Jupyter Notebook

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Konfigurationsskriptet för Databricks Connect lägger automatiskt till paketet i projektkonfigurationen. Kom igång i en Python-kernel genom att köra:

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

Om du vill aktivera förkortningen %sql för att köra och visualisera SQL-frågor använder du följande kodfragment:

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

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Gör följande för att använda Databricks Connect med Visual Studio Code:

Kontrollera att Python-tillägget är installerat.
Öppna kommandopaletten (Kommando+Skift+P på macOS och Ctrl+Skift+P i Windows/Linux).
Välj en Python-tolk. Gå till Inställningar för >> och välj python-inställningar.
Kör databricks-connect get-jar-dir.
Lägg till katalogen som returneras från kommandot till JSON för användarinställningar under python.venvPath. Detta bör läggas till i Python-konfigurationen.
Inaktivera lintern. Klicka på ... till höger och redigera json-inställningar. De ändrade inställningarna är följande:
Om du kör med en virtuell miljö, vilket är det rekommenderade sättet att utveckla för Python i VS Code, i kommandopalettens typ select python interpreter och peka på din miljö som matchar python-klustrets version.

Om klustret till exempel är Python 3.9 bör utvecklingsmiljön vara Python 3.9.

PyCharm

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Konfigurationsskriptet för Databricks Connect lägger automatiskt till paketet i projektkonfigurationen.

Python 3-kluster

När du skapar ett PyCharm-projekt väljer du befintlig tolk. I den nedrullningsbara menyn väljer du den Conda-miljö som du skapade (se Krav).
Gå till Kör > redigera konfigurationer.
Lägg till PYSPARK_PYTHON=python3 som en miljövariabel.

SparkR och RStudio Desktop

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Om du vill använda Databricks Connect med SparkR och RStudio Desktop gör du följande:

Ladda ned och packa upp öppen källkod Spark-distributionen på utvecklingsdatorn. Välj samma version som i ditt Azure Databricks-kluster (Hadoop 2.7).
Kör databricks-connect get-jar-dir. Det här kommandot returnerar en sökväg som /usr/local/lib/python3.5/dist-packages/pyspark/jars. Kopiera filsökvägen för en katalog ovanför JAR-katalogfilens sökväg, /usr/local/lib/python3.5/dist-packages/pysparktill exempel , som är SPARK_HOME katalogen.

Konfigurera Spark lib-sökvägen och Spark Home genom att lägga till dem överst i R-skriptet. Ange <spark-lib-path> till katalogen där du packade upp Spark-paketet med öppen källkod i steg 1. Ange <spark-home-path> till katalogen Databricks Connect från steg 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>")

Starta en Spark-session och börja köra SparkR-kommandon.

sparkR.session()

df <- as.DataFrame(faithful)
head(df)

df1 <- dapply(df, function(x) { x }, schema(df))
collect(df1)

sparklyr och RStudio Desktop

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Viktigt!

Den här funktionen finns som allmänt tillgänglig förhandsversion.

Du kan kopiera sparklyrberoende kod som du har utvecklat lokalt med Databricks Connect och köra den i en Azure Databricks-notebook-fil eller värdbaserad RStudio Server på din Azure Databricks-arbetsyta med minimala eller inga kodändringar.

I detta avsnitt:

Krav
Installera, konfigurera och använda sparklyr
Resurser
begränsningar för sparklyr och RStudio Desktop

Krav

sparklyr 1.2 eller senare.
Databricks Runtime 7.3 LTS eller senare med matchande version av Databricks Connect.

Installera, konfigurera och använda sparklyr

I RStudio Desktop installerar du sparklyr 1.2 eller senare från CRAN eller installerar den senaste huvudversionen från GitHub.

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

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

Aktivera Python-miljön med rätt version av Databricks Connect installerad och kör följande kommando i terminalen för att hämta <spark-home-path>:
```
databricks-connect get-spark-home
```

Starta en Spark-session och börja köra sparklyr-kommandon.

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

Stäng anslutningen.
```
spark_disconnect(sc)
```

Resurser

Mer information finns i Sparklyr GitHub README.

Kodexempel finns i sparklyr.

begränsningar för sparklyr och RStudio Desktop

Följande funktioner stöds inte:

sparklyr-strömnings-API:er
sparklyr ML-API:er
broom-API:er
csv_file serialiseringsläge
spark submit

IntelliJ (Scala eller Java)

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Om du vill använda Databricks Connect med IntelliJ (Scala eller Java) gör du följande:

Kör databricks-connect get-jar-dir.
Peka beroendena till katalogen som returneras från kommandot. Gå till Fil > Projektstruktur > Moduler > Beroenden > plustecken > JAR-filer eller kataloger.

För att undvika konflikter rekommenderar vi starkt att du tar bort andra Spark-installationer från din klassökväg. Om detta inte är möjligt kontrollerar du att de JAR:er som du lägger till finns längst fram i klassökvägen. I synnerhet måste de ligga före någon annan installerad version av Spark (annars använder du antingen någon av de andra Spark-versionerna och kör lokalt eller genererar en ClassDefNotFoundError).
Kontrollera inställningen för breakout-alternativet i IntelliJ. Standardvärdet är Alla och orsakar nätverkstimeouter om du anger brytpunkter för felsökning. Ställ in den på Tråd för att undvika att stoppa bakgrundens nätverkstrådar.

PyDev med Eclipse

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Följ dessa instruktioner om du vill använda Databricks Connect och PyDev med Eclipse.

Starta Eclipse.
Skapa ett projekt: klicka på Arkiv Nytt projekt PyDev > PyDev-projekt och klicka sedan på >.>>
Ange ett projektnamn.
För Project-innehåll anger du sökvägen till din virtuella Python-miljö.
Klicka på Konfigurera en tolk innan du fortsätter.
Klicka på Manuell konfiguration.
Klicka på Ny > bläddra efter python/pypy exe.
Bläddra till och välj den fullständiga sökvägen till Python-tolken som refereras till från den virtuella miljön och klicka sedan på Öppna.
I dialogrutan Välj tolk klickar du på OK.
Klicka på OK i dialogrutan Markering som behövs.
I dialogrutan Inställningar klickar du på Tillämpa och stäng.
I dialogrutan PyDev-projekt klickar du på Slutför.
Klicka på Öppna perspektiv.
Lägg till en Python-kodfil (.py) i projektet som innehåller antingen exempelkoden eller din egen kod. Om du använder din egen kod måste du minst instansiera en instans av SparkSession.builder.getOrCreate(), som du ser i exempelkoden.
När Python-kodfilen är öppen anger du eventuella brytpunkter där du vill att koden ska pausas när den körs.
Klicka på Kör > körning eller Kör > felsökning.

Mer specifika instruktioner för körning och felsökning finns i Köra ett program.

Förmörkelse

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Gör följande för att använda Databricks Connect och Eclipse:

Kör databricks-connect get-jar-dir.
Peka den externa JARs-konfigurationen till katalogen som returneras från kommandot. Gå till Project-menyn > Egenskaper > Java Build Path > Libraries > Lägg till externa jars.

För att undvika konflikter rekommenderar vi starkt att du tar bort andra Spark-installationer från din klassökväg. Om detta inte är möjligt kontrollerar du att de JAR:er som du lägger till finns längst fram i klassökvägen. I synnerhet måste de ligga före någon annan installerad version av Spark (annars använder du antingen någon av de andra Spark-versionerna och kör lokalt eller genererar en ClassDefNotFoundError).

SBT

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Om du vill använda Databricks Connect med SBT måste du konfigurera build.sbt filen så att den länkar mot Databricks Connect-JAR:erna i stället för det vanliga Spark-biblioteksberoendet. Du gör detta med unmanagedBase direktivet i följande exempelversionsfil, som förutsätter en Scala-app som har ett com.example.Test huvudobjekt:

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

Spark-gränssnitt

Kommentar

Innan du börjar använda Databricks Connect måste du uppfylla kraven och konfigurera klienten för Databricks Connect.

Följ dessa instruktioner om du vill använda Databricks Connect med Spark-gränssnittet och Python eller Scala.

När den virtuella miljön är aktiverad kontrollerar du att kommandot databricks-connect test har körts i Konfigurera klienten.
Starta Spark-gränssnittet när den virtuella miljön är aktiverad. Kör kommandot för pyspark Python. Kör kommandot för Scala spark-shell .
```
# For Python:
pyspark
```
```
# For Scala:
spark-shell
```

Spark-gränssnittet visas, till exempel för 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'.
>>>

För 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>

Mer information om hur du använder Spark-gränssnittet med Python eller Scala för att köra kommandon i klustret finns i Interaktiv analys med Spark Shell.

Använd den inbyggda spark variabeln för att representera SparkSession på ditt kluster som körs, till exempel för 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

För 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

Om du vill stoppa Spark-gränssnittet trycker Ctrl + d du på eller Ctrl + z, eller kör kommandot quit() eller exit() för Python eller :q för :quit Scala.

Kodexempel

Det här enkla kodexemplet frågar den angivna tabellen och visar sedan den angivna tabellens första 5 rader. Om du vill använda en annan tabell justerar du anropet till spark.read.table.

from pyspark.sql.session import SparkSession

spark = SparkSession.builder.getOrCreate()

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

Det här längre kodexemplet gör följande:

Skapar en minnesintern DataFrame.
Skapar en tabell med namnet zzz_demo_temps_table i default-schemat. Om tabellen med det här namnet redan finns tas tabellen bort först. Om du vill använda ett annat schema eller en annan tabell justerar du anropen till spark.sql, temps.write.saveAsTableeller båda.
Sparar dataramens innehåll i tabellen.
Kör en SELECT fråga i tabellens innehåll.
Visar frågans resultat.
Tar bort tabellen.

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

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

Arbeta med beroenden

Vanligtvis har din huvudklass eller Python-fil andra beroende-JAR:er och -filer. Du kan lägga till sådana beroende-JAR:er och filer genom att anropa sparkContext.addJar("path-to-the-jar") eller sparkContext.addPyFile("path-to-the-file"). Du kan också lägga till Egg-filer och zip-filer med addPyFile() gränssnittet. Varje gång du kör koden i din IDE installeras beroende-JAR:er och -filer i klustret.

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 + Java UDF:er

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

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

Komma åt Databricks-verktyg

I det här avsnittet beskrivs hur du använder Databricks Connect för att få åtkomst till Databricks Utilities.

Du kan använda dbutils.fs och dbutils.secrets verktyg för referensmodulen Databricks Utilities (dbutils). Kommandon som stöds är 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, dbutils.secrets.listScopes. Se Filsystemverktyget (dbutils.fs) eller kör dbutils.fs.help() och Verktyget Hemligheter (dbutils.secrets) eller kör 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())

När du använder Databricks Runtime 7.3 LTS eller senare för att få åtkomst till DBUtils-modulen på ett sätt som fungerar både lokalt och i Azure Databricks-kluster använder du följande get_dbutils():

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

Annars använder du följande 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

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

Kopiera filer mellan lokala filsystem och fjärrfilsystem

Du kan använda dbutils.fs för att kopiera filer mellan klienten och fjärrfilsystemen. Schemat file:/ refererar till det lokala filsystemet på klienten.

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

Den maximala filstorleken som kan överföras på det sättet är 250 MB.

Aktivera `dbutils.secrets.get`

På grund av säkerhetsbegränsningar är anropsförmågan dbutils.secrets.get inaktiverad som standard. Kontakta Azure Databricks-supporten för att aktivera den här funktionen för din arbetsyta.

Ange Hadoop-konfigurationer

På klienten kan du ange Hadoop-konfigurationer med hjälp av spark.conf.set-API:et, som gäller för SQL- och DataFrame-åtgärder. Hadoop-konfigurationer som angetts på sparkContext måste anges i klusterkonfiguration eller med hjälp av en notebook. Det beror på att konfigurationer som anges på sparkContext inte är knutna till användarsessioner utan gäller för hela klustret.

Felsökning

Kör databricks-connect test för att söka efter anslutningsproblem. I det här avsnittet beskrivs några vanliga problem som kan uppstå med Databricks Connect och hur du löser dem.

I detta avsnitt:

Python-versionen stämmer inte
Servern är inte aktiverad
PySpark-installationer i konflikt
Motstridig SPARK_HOME
Motstridiga eller saknade PATH poster för binärfiler
Motstridiga serialiseringsinställningar i klustret
Det går inte att hitta winutils.exe i Windows
Syntaxen för filnamn, katalognamn eller volymetikett är felaktig i Windows

Python-versionen stämmer inte

Kontrollera att den Python-version som du använder lokalt har minst samma delversion som versionen i klustret (till exempel 3.9.16 jämfört med 3.9.15 är OK, 3.9 jämfört med 3.8 inte).

Om du har flera Python-versioner installerade lokalt kontrollerar du att Databricks Connect använder rätt genom att ange PYSPARK_PYTHON miljövariabeln (till exempel PYSPARK_PYTHON=python3).

Servern är inte aktiverad

Kontrollera att Spark-servern är aktiverad i klustret med spark.databricks.service.server.enabled true. Du bör se följande rader i drivrutinsloggen om det är:

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

PySpark-installationer i konflikt

Paketet databricks-connect står i konflikt med PySpark. Om båda har installerats uppstår fel när Spark-kontexten initieras i Python. Detta kan manifesteras på flera sätt, till exempel "strömma skadade" eller "klassen hittades inte"-fel. Om du har PySpark installerat i Python-miljön kontrollerar du att det avinstalleras innan du installerar databricks-connect. När du har avinstallerat PySpark måste du installera om Databricks Connect-paketet helt:

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

Motstridig `SPARK_HOME`

Om du tidigare har använt Spark på datorn kan din IDE vara konfigurerad att använda någon av dessa andra versioner av Spark i stället för Databricks Connect Spark. Detta kan manifesteras på flera sätt, till exempel "strömma skadade" eller "klassen hittades inte"-fel. Du kan se vilken version av Spark som används genom att kontrollera värdet för SPARK_HOME miljövariabeln:

python

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

Scala

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

Java

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

Åtgärd

Om SPARK_HOME har angetts till en annan version av Spark än den i klienten bör du ta bort variabeln SPARK_HOME och försöka igen.

Kontrollera inställningarna för din IDE-miljövariabel, din .bashrc, .zshrceller .bash_profile fil och var som helst annars kan miljövariabler anges. Du måste förmodligen avsluta och starta om din IDE för att rensa det gamla tillståndet, och du kan till och med behöva skapa ett nytt projekt om problemet kvarstår.

Du bör inte behöva ange SPARK_HOME till ett nytt värde; att återställa det borde vara tillräckligt.

Motstridiga eller saknade `PATH` poster för binärfiler

Det är möjligt att din PATH är konfigurerad så att kommandon som spark-shell kommer att köra någon annan tidigare installerad binär fil i stället för den som tillhandahålls med Databricks Connect. Detta kan orsaka databricks-connect test fel. Du bör se till att databricks Connect-binärfilerna har företräde eller ta bort de tidigare installerade binärfilerna.

Om du inte kan köra kommandon som spark-shell, är det också möjligt att din PATH inte har konfigurerats automatiskt av pip3 install och du måste lägga till installationsdir bin till din PATH manuellt. Det är möjligt att använda Databricks Connect med IDE:er även om det inte är inställt. Kommandot fungerar dock databricks-connect test inte.

Motstridiga serialiseringsinställningar i klustret

Om du ser "strömma skadade" fel när du kör databricks-connect testkan detta bero på inkompatibla kluster serialiseringskonfigurationer. Om du till exempel ställer in konfigurationen spark.io.compression.codec kan det här problemet orsakas. Lös problemet genom att ta bort dessa konfigurationer från klusterinställningarna eller ange konfigurationen i Databricks Connect-klienten.

Det går inte att hitta `winutils.exe` i Windows

Om du använder Databricks Connect i Windows och ser:

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.

Följ anvisningarna för att konfigurera Hadoop-sökvägen i Windows.

Syntaxen för filnamn, katalognamn eller volymetikett är felaktig i Windows

Om du använder Windows och Databricks Connect och se:

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

Antingen Java eller Databricks Connect installerades i en katalog med ett utrymme i sökvägen. Du kan kringgå detta genom att antingen installera i en katalogsökväg utan blanksteg eller konfigurera sökvägen med hjälp av det korta namnformuläret.

Autentisering med Hjälp av Microsoft Entra-ID-token

Kommentar

Följande information gäller endast för Databricks Connect-versionerna 7.3.5 till och med 12.2.x.

Databricks Connect för Databricks Runtime 13.3 LTS och senare stöder för närvarande inte Microsoft Entra ID-token.

När du använder Databricks Connect-versionerna 7.3.5 till 12.2.x kan du autentisera med hjälp av en Microsoft Entra ID-token i stället för en personlig åtkomsttoken. Microsoft Entra-ID-token har en begränsad livslängd. När Microsoft Entra-ID-token upphör att gälla misslyckas Databricks Connect med ett Invalid Token fel.

För Databricks Connect-versionerna 7.3.5 till 12.2.x kan du ange Microsoft Entra ID-token i ditt Databricks Connect-program som körs. Ditt program måste hämta den nya åtkomsttoken och ange den till spark.databricks.service.token SQL-konfigurationsnyckel.

python

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

Scala

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

När du har uppdaterat token kan programmet fortsätta att använda samma SparkSession och alla objekt och tillstånd som skapas i kontexten för sessionen. För att undvika tillfälliga fel rekommenderar Databricks att du anger en ny token innan den gamla token upphör att gälla.

Du kan förlänga livslängden för Microsoft Entra-ID-token så att den bevaras under körningen av ditt program. Det gör du genom att koppla en TokenLifetimePolicy med en lämplig lång livslängd till det Microsoft Entra ID-auktoriseringsprogram som du använde för att hämta åtkomsttoken.

Kommentar

Microsoft Entra ID-genomströmning använder två token: Microsoft Entra ID-åtkomsttoken som tidigare beskrevs som du konfigurerade i Databricks Connect-versionerna 7.3.5 till 12.2.x och ADLS-genomströmningstoken för den specifika resurs som Databricks genererar medan Databricks bearbetar begäran. Du kan inte förlänga livslängden för ADLS-genomströmningstoken med hjälp av Microsoft Entra ID-tokens livslängdsprinciper. Om du skickar ett kommando till klustret som tar längre tid än en timme misslyckas det om kommandot kommer åt en ADLS-resurs efter entimmesmarkeringen.

Begränsningar

Unity Catalog.

Strukturerad direktuppspelning.
Köra godtycklig kod som inte ingår i ett Spark-jobb i fjärrklustret.
Interna Scala-, Python- och R-API:er för Delta-tabellåtgärder (till exempel DeltaTable.forPath) stöds inte. SQL API (spark.sql(...)) med Delta Lake-åtgärder och Spark API (till exempel spark.read.load) i Delta-tabeller stöds dock båda.
Kopiera till.
Använda SQL-funktioner, Python eller Scala UDF:er som ingår i serverns katalog. Men lokalt introducerade Scala- och Python-UDF:er fungerar.
Apache Zeppelin 0.7.x och nedan.
Ansluta till kluster med tabellåtkomstkontroll.
Ansluta till kluster med processisolering aktiverat (med andra ord där spark.databricks.pyspark.enableProcessIsolation är inställt på true).
Delta CLONE SQL-kommando.
Globala tillfälliga vyer.
Koalas och pyspark.pandas.
CREATE TABLE table AS SELECT ... SQL-kommandon fungerar inte alltid. Använd spark.sql("SELECT ...").write.saveAsTable("table")i stället .

Genomströmning av Microsoft Entra-ID-autentiseringsuppgifter stöds endast på standardkluster som kör Databricks Runtime 7.3 LTS och senare och är inte kompatibelt med autentisering med tjänstens huvudnamn.
Följande Databricks Utilities-referens (dbutils):

Dela via

Databricks Connect för Databricks Runtime 12.2 LTS och nedan

Översikt

Krav

Konfigurera klienten

Steg 1: Installera Databricks Connect-klienten

Steg 2: Konfigurera anslutningsegenskaper

Använda Databricks Connect

I detta avsnitt:

JupyterLab

Klassisk Jupyter Notebook

Visual Studio-koden

PyCharm

Python 3-kluster

SparkR och RStudio Desktop

sparklyr och RStudio Desktop

I detta avsnitt:

Krav

Installera, konfigurera och använda sparklyr

Resurser

begränsningar för sparklyr och RStudio Desktop

IntelliJ (Scala eller Java)

PyDev med Eclipse

Förmörkelse

SBT

build.sbt

Spark-gränssnitt

Kodexempel

python

Scala

Java

Arbeta med beroenden

python

Scala

Komma åt Databricks-verktyg

python

Scala

Kopiera filer mellan lokala filsystem och fjärrfilsystem

Aktivera dbutils.secrets.get

Ange Hadoop-konfigurationer

Felsökning

I detta avsnitt:

Python-versionen stämmer inte

Servern är inte aktiverad

PySpark-installationer i konflikt

Motstridig SPARK_HOME

python

Scala

Java

Åtgärd

Motstridiga eller saknade PATH poster för binärfiler

Motstridiga serialiseringsinställningar i klustret

Det går inte att hitta winutils.exe i Windows

Syntaxen för filnamn, katalognamn eller volymetikett är felaktig i Windows

Autentisering med Hjälp av Microsoft Entra-ID-token

python

Scala

Begränsningar

Feedback

Ytterligare resurser

`build.sbt`

Aktivera `dbutils.secrets.get`

Motstridig `SPARK_HOME`

Motstridiga eller saknade `PATH` poster för binärfiler

Det går inte att hitta `winutils.exe` i Windows