Ansluta till Databricks med hjälp av en SSH-tunnel

Viktigt!

Den här funktionen finns i Beta.

Kostnad och pris för funktioner i Beta kan ändras.

Azure Databricks SSH (Secure Shell)-tunneln kopplar Visual Studio Code, Cursor eller din terminal till Azure Databricks-arbetsytan och Azure Databricks serverlös beräkning, AI Runtime eller klassisk beräkning. Använd den för att redigera arbetsytfiler och köra eller felsöka Python-skript och anteckningsböcker, med din Python-miljö och kodexekvering på fjärrberäkningen. Koppla direkt till serverless compute, eller skapa en återanvändbar SSH-anslutning till ett dedikerat klassiskt kluster.

Kravspecifikation

Starta SSH-anslutningen från din lokala maskin. Tunneln kan inte startas från en annan fjärrmiljö eller en Docker-container.

För att ansluta till serverless eller klassisk compute måste du ha:

  • Databricks CLI version 1.5.0 eller senare installerad på din lokala dator och autentisering har konfigurerats. Kontrollera den installerade versionen med databricks --version. Se Installera eller uppdatera Databricks CLI.
  • Något av följande:
    • Visual Studio Code version 1.110.0 (Universal) eller högre samt Remote - SSH-tillägget (1.0.46+) måste vara installerade.
    • Cursor version 2.6.11 (Universal) eller högre.

För att ansluta till serverless compute måste port forwarding till serverless compute vara aktiverat. Se Hantera portvidarebefordran till serverlös databehandling.

Om du vill ansluta till serverlös GPU-beräkning måste FUNKTIONEN AI Runtime vara aktiverad. Se AI Runtime.

Ytterligare krav för Classic Compute

Så här ansluter du till klassisk beräkning (dedikerad, enskild användare):

Välj en SSH-anslutning

Använd anslutningsmetoden för din compute-typ:

Compute Anslutningsmetod Installationskrav
Serverlös beräkning databricks ssh connect Ingen separat SSH-installationssteg.
Lägg till --ide vscode eller --ide cursor för att starta en IDE.
AI-körtid databricks ssh connect --accelerator <accelerator> Ingen separat SSH-installationssteg.
Lägg till --ide vscode eller --ide cursor för att starta en IDE.
För stödda acceleratorer, se --accelerator.
Klassisk dedikerad beräkning för en användare Kör databricks ssh setup --name <connection-name> i terminalen.
Starta sedan SSH-sessionen från IDE:n eller kör ssh <connection-name>.		 Välj ett dedikerat, enanvändarkluster som uppfyller de klassiska beräkningskraven.
Delade kluster stöds inte.

För en jämförelse med Databricks Connect och andra utvecklingsalternativ, se Anslut från din IDE.

Ansluta till serverlös beräkning

När kraven ovan uppfylls, kör databricks ssh connect från din terminal eller IDE.

Värdet --ide anger vilken redigerare som ska startas, oavsett vilken redigerare eller terminal du kör kommandot från.

Visual Studio Code

databricks ssh connect --ide vscode

CLI:n öppnar ett Visual Studio Code-fönster som är anslutet till fjärrberäkningsresursen.

Cursor

databricks ssh connect --ide cursor

CLI:n öppnar ett Cursor-fönster som är anslutet till fjärrberäkningsmiljön.

Terminal

databricks ssh connect

CLI startar en interaktiv SSH-session.

För kommandoalternativ, inklusive namngivna anslutningar och autentiseringsprofiler, se databricks ssh connect.

Efter att du har anslutit dig, öppna ditt arbetsytprojekt och välj Python-miljön. Om anslutningen misslyckas, se Felsök SSH-tunnelanslutningar.

Koppla upp till serverlös GPU-beräkning med AI Runtime

Med AI Runtime aktiverad, lägg till --accelerator för att använda GPU-beräkning:

databricks ssh connect --accelerator GPU_1xA10

databricks ssh connect ger dig en interaktiv session på en enda nod. För långvariga träningsjobb eller distribuerad träning över flera noder skickar du arbetsbelastningen med databricks air i stället. Se Använd Databricks CLI med AI Runtime.

Ansluta till klassisk beräkning

För en återanvändbar anslutning till ett klassiskt dedikerat kluster, skapa ett SSH-värdnamn och välj sedan den SSH-värden i din IDE eller anslut från en terminal.

Konfigurera SSH-anslutningen

Anmärkning

Det krävs bara att du konfigurerar SSH-anslutningen om du ansluter till den klassiska beräkningen.

Kör databricks ssh setup på din lokala dator. Ersätt <connection-name> med ett namn för denna koppling, såsom my-connection:

databricks ssh setup --name <connection-name>

CLI:n uppmanar dig att välja ett kluster och lägger till en värdpost i din SSH-konfiguration. Du kan också välja ett kluster direkt. Ersätt <cluster-id> med ID:t för ditt dedikerade kluster:

databricks ssh setup --name <connection-name> --cluster <cluster-id>

För att konfigurera hur länge SSH-tunneln väntar efter att den senaste klienten kopplat bort, lägg till --shutdown-delay i setup-kommandot. Standardvärdet är 10 minuter. Till exempel, för att sätta en 30-minuters fördröjning för anslutningar genom denna SSH-värdpost:

databricks ssh setup --name <connection-name> --cluster <cluster-id> --shutdown-delay 30m

Anmärkning

För IntelliJ-användare rekommenderar Databricks att du lägger --auto-start-cluster=false till i installationskommandot och startar klustret manuellt innan du ansluter. Det beror på att JetBrains IDE:er startar alla konfigurerade kluster vid lansering, vilket kan resultera i oväntade databehandlingskostnader.

Ansluta med hjälp av Visual Studio Code eller Cursor

  1. Installera Remote SSH-tillägget för Visual Studio Code. Markören innehåller ett SSH-fjärrtillägg som standard.

  2. I huvudmenyn för IDE klickar du på Visa>kommandopalett. Välj Fjärr-SSH: Inställningar. Du kan också välja Inställningar: Öppna användarinställningar (JSON) för att ändra settings.json direkt.

  3. Under Remote.SSH: Standardtillägg (eller remote.SSH.defaultExtensions i settings.json) lägger du till ms-Python.Python och ms-toolsai.jupyter.

    Om du ändrar settings.json:

    "remote.SSH.defaultExtensions": [
    "ms-Python.Python",
    "ms-toolsai.jupyter"
]

    Anmärkning

    Du kan också öka värdet för Remote.SSH: Connect Timeout (eller remote.SSH.connectTimeout i settings.json) för att ytterligare minska risken för timeout-fel. Standardtimeouten är 360.

  4. I kommandopaletten väljer du Fjärr-SSH: Anslut till värd.

  5. I den nedrullningsbara menyn väljer du den anslutning som du konfigurerade i det första steget. IDE fortsätter att ansluta i ett nytt fönster.

Ansluta med IntelliJ-IDE:er

  1. Följ Fjärrservertutorial för att komma igång.
  2. På den nya anslutningsskärmen anger du:
    • Användarnamn: root
    • Värd: <connection-name>

Koppla till klassisk compute från en terminal

Använd anslutningsnamnet du konfigurerade med databricks ssh setup:

ssh <connection-name>

För en direktanslutning utan en återanvändbar SSH-värdpost kan du också använda CLI. Byt ut <cluster-id> med ditt dedikerade kluster-ID:

databricks ssh connect --cluster <cluster-id>

Se databricks ssh connect.

Öppna arbetsyteprojekt via SSH

Som standard öppnas kommandot databricks ssh connect i en temporär katalog. Om du vill komma åt arbetsytefiler går du till arbetsytekatalogen från IDE eller terminalen:

  • I Visual Studio Code eller markören går du till kommandopaletten (Cmd/Ctrl+Skift+P) väljer Öppna mapp och navigerar till /Workspace/Users/<your-username>.
  • Ändra katalogen från ett terminalfönster: cd /Workspace/Users/<your-username>.

Anmärkning

Filer i /Workspace, /Volumesoch /dbfs sparas mellan klusteromstarter. Filer i /home, /rootoch andra lokala sökvägar är tillfälliga och förlorade vid omstart.

Kör Python och notebooks i SSH-sessionen

Välj Python-miljön som tillhandahålls av din SSH-session innan du kör koden. För klassisk beräkning inkluderar denna miljö de inbyggda Databricks Runtime-biblioteken och beräkningsomfångsbiblioteken.

  1. Öppna kommandopaletten (Cmd/Ctrl+Skift+P) och välj Python: Välj tolk.

  2. Välj den pythonEnv-xxx virtuella miljön i listan. Om du konfigurerar Python beroenden med hjälp av --base-environment flaggan väljer du det längre namnet på den virtuella miljön i listan med alternativ. Om den virtuella miljön inte visas:

    1. Kör echo $DATABRICKS_VIRTUAL_ENV från en terminal i IDE.

      Exempel på utdata: /local_disk0/.ephemeral_nfs/envs/pythonEnv-xxx/bin/python

    2. Klistra in de fullständiga utdata som tolksökväg i Python: Välj tolkprompt.

  3. Öppna en ny terminal och den virtuella miljön ska aktiveras automatiskt.

  4. Om du vill köra en Jupyter-notebook-fil kontrollerar du att den virtuella miljön har valts som kernel. Klicka på Välj kernel längst upp till höger i anteckningsboken.

Kör och felsöka Python filer och .ipynb notebook-filer med standardtilläggen Python och Jupyter.

Om du vill använda Spark i en Python fil på serverlös beräkning initierar du en session explicit:

from databricks.connect import DatabricksSession
spark = DatabricksSession.builder.serverless().profile("DEFAULT").getOrCreate()

Hantera beroenden för SSH-sessioner

Välj beroendehantering för din beräkningstyp:

  • För serverless compute, använd en arbetsplatsbasmiljö med en stödd version av serverless miljö.
  • För klassisk beräkning, använd cluster libraries för beroenden som kvarstår vid omstarter.
  • För beroenden som är begränsade till en projektsession, använd en setup notebook.

För icke-Python-paket, se Icke-Python-beroenden.

Basmiljöer för arbetsytor (rekommenderas för serverlös och AI-körning)

Anmärkning

Den här funktionen kräver att basmiljön för serverlös arbetsyta i förhandsversionen av Jobb är aktiverad. Se Hantera förhandsversioner av Azure Databricks.

Använd en basmiljö för arbetsytan med serverlös miljöversion 4 eller senare för att förkonfigurera Python beroenden. SSH-tunneln stöder inte --base-environment med serverless-miljöversion 5 eller senare. Skapa en basmiljö med hjälp av användargränssnittet för arbetsytan eller Databricks CLI-kommandot databricks environments create-workspace-base-environment.

Ange miljön med hjälp av --base-environment alternativet när du ansluter:

databricks ssh connect --base-environment my-workspace-env

Alternativet --base-environment accepterar ett visningsnamn, en workspace YAML-path eller ett resurs-ID. Du kan inte kombinera det med --cluster. Se databricks ssh connect.

Klusterbibliotek (rekommenderas för klassisk beräkning)

Installera beroenden med hjälp av arbetsytans användargränssnitt under Beräkningsbibliotek>. Dessa bevaras mellan klusteromstarter och är tillgängliga i pythonEnv-xxx. Se Klusterbibliotek.

Beroenden som inte är Python

Om du vill bevara icke-Python beroenden använder du ett init-skript som installerar paketen när beräkningen startar. Du kan också lagra paketen i en Unity Catalog-volym och referera till dem från init-skriptet. Se Vad är init-skript?.

Installation av projektanpassad anteckningsbok

För beroenden med projektomfattning kör du en notebook-fil som innehåller %pip install kommandon i början av varje session:

# Install from pyproject.toml
%pip install .

# Install from a requirements file
%pip install -r requirements.txt

# Install a wheel from Volumes or Workspace
%pip install /Volumes/catalog/schema/volume/your_library.whl

%pip kommandon inkluderar Databricks-specifika skyddsräcken och sprider beroenden till Spark-körnoder. Detta möjliggör användardefinierade funktioner (UDF: er) med anpassade beroenden.

Fler exempel finns i Hantera bibliotek med %pip kommandon.

Du behöver inte köra installationsnotebooken igen om du ansluter innan SSH-tunneln stängs av. Som standard stängs tunneln av 10 minuter efter att den senaste klienten kopplat bort. För att ändra denna fördröjning, använd --shutdown-delay med kommandot för din anslutningsmetod:

  • För en återanvändbar klassisk beräkningsanslutning, ställ in tidsgränsen med databricks ssh setup. Den genererade SSH-värdposten tillämpar fördröjningen när du ansluter från din IDE eller kör ssh <connection-name>.
  • För en direkt CLI-anslutning, ställ in fördröjningen med databricks ssh connect.

Anmärkning

Flera SSH-sessioner i samma kluster delar en virtuell miljö.

Använd Git i en SSH-session

Viktigt!

Den här funktionen finns som allmänt tillgänglig förhandsversion. Arbetsyteadministratörer kan styra åtkomsten till Git CLI-stöd för Git-mappar från sidan Förhandsversioner . Se Hantera förhandsversioner av Azure Databricks.

Du kan använda Git CLI i SSH-tunneln med nyskapta Git-mappar och de Git-autentiseringsuppgifter du har konfigurerat i Azure Databricks-arbetsytan. Se Använda Git CLI-kommandon.

Om CLI ber om inloggningsuppgifter istället för att hämta dem automatiskt, måste du koppla din Git-leverantör till Azure Databricks. Se Ansluta din Git-provider till Databricks.

Håll fristående processer igång

Som standard, när SSH-tunneln stängs ner, stoppar den alla processer som sessionen startade, inklusive processer som du kopplat från sessionen med tmux, setsid, eller nohup. Innan den stoppar dem loggar tunneln en varning med deras process-ID:n i utdata från tunnelns jobbkörning. databricks ssh connect skriver ut jobbkörnings-ID:t när databricks ssh connect startar tunneln.

För att hålla fristående arbete igång efter att du kopplar från, använd flaggan --keep-detached-processes. Sätt flaggan på anslutningen som startar tunneln innan du påbörjar det arbete du vill behålla. Se Anslutningar till en befintlig tunnel.

  • Serverless eller klassisk beräkning: Skicka flaggan till databricks ssh connect.
  • Klassisk beräkning med en konfigurerad SSH-värd: Ange flaggan för databricks ssh setup. Den genererade SSH-värdposten gäller varje gång du ansluter. Serverlösa anslutningar kräver ingen installation, så detta alternativ gäller endast för klassisk databehandling.

Följande exempel håller fristående processer igång på serverlös datorkapacitet:

databricks ssh connect --keep-detached-processes

Följande exempel håller fristående processer igång på ett dedikerat kluster:

databricks ssh connect --cluster 0123-456789-abcdefgh --keep-detached-processes

När du använder denna flagga och den sista klienten kopplar ifrån sig fungerar tunneln enligt följande:

  • Efter perioden --shutdown-delay kontrollerar tunneln om det finns frånkopplade processer. Medan någon av dem är igång fortsätter tunneln att gå istället för att stängas ner.
  • Fristående processer behåller sin tillgång till /Workspace och /Volumes.
  • Efter att den sista fristående processen avslutas stängs tunneln av och dess jobbkörning avslutas.

Medan tunneln fortsätter att köras kan du återansluta till samma compute-resurs och återansluta till frånkopplat arbete, till exempel med tmux attach. Vid serverless compute, återanslut med samma anslutningsnamn. Om du utelämnar --name, härleder CLI:n anslutningsnamnet från din arbetsyta och flaggorna --accelerator och --base-environment, så om du ändrar någon av flaggorna startas en separat anslutning.

Anslutningar till en befintlig tunnel

Tunnelns driftläge är fast när den startar, och senare anslutningar hanterar det enligt följande:

  • Om du ansluter med flaggan till en tunnel som startade utan den, startar CLI:n en ny tunnel. Processer som du frikopplade i den befintliga tunneln behålls inte, och de stannar ändå när tunneln stängs ner. På ett dedikerat kluster stoppar den nya tunneln omedelbart den befintliga, vilket avslutar dess öppna sessioner och stoppar dess fristående processer.
  • Om du ansluter utan flaggan till en tunnel som startades med den, återanvänder CLI:n den tunneln, och tunneln fortsätter att köras medan frikopplade processer kvarstår. Detta gäller även anslutningar från andra SSH-värdposter eller IDE-sessioner till samma beräkningsresurs.

Kostnader och maximal livslängd

Tänk på följande:

  • Medan tunneln fortsätter att köra, fortsätter beräkningsresursen att köras och medför kostnader. Ett klassiskt kluster avslutas inte automatiskt. En inaktiv tmux sessionen räknas som en pågående frånkopplad process, så stäng den när du inte längre behöver den.
  • Jobbkörningen stoppas fortfarande när den når den maximala livslängd som satts av --server-timeout, även om frikopplade processer körs. Denna livslängd räknas från det att jobbet startar, inte från det att den senaste klienten kopplas bort. Efter att jobbkörningen har upphört förlorar frikopplade processer sin åtkomst till /Workspace och /Volumes. På serverless-bearbetning stannar de frikopplade processerna. På klassisk compute kan de fortsätta köras utan åtkomst tills klustret avslutas. För att behålla utdata från långvariga fristående jobb, spara det med Azure Databricks SDK eller REST API i stället för att skriva till sökvägarna /Workspace eller /Volumes. Se Arbeta med filer i Unity Catalog-volymer.
  • För arbete som körs under längre tid, använd jobb eller bundles istället.

SSH-tunnelbegränsningar

SSH-tunneln som tillhandahålls av Databricks har följande begränsningar:

  • Delade kluster stöds inte.
  • Filer som redigeras utanför /Workspace, /Volumesoch /dbfs går förlorade vid omstart av kluster.
  • Högst 10 SSH-anslutningar tillåts per kluster.
  • Inaktiva sessioner kan kopplas ned efter 1 timme.
  • SSH-tunneln kan inte startas från andra fjärrmiljöer eller Docker-containrar.
  • Du kan stöta på prestanda- eller anslutningsproblem när tre eller fler Jupyter-notebook-filer är öppna samtidigt.

Notebook-beteende i SSH-sessioner

Det finns vissa skillnader i notebook-filer när du använder SSH-tunneln:

  • Python-filer definierar inte några Databricks-globaler (som spark eller dbutils). Du måste importera dem explicit med from databricks.sdk.runtime import spark.
  • För ipynb-anteckningsböcker är dessa funktioner tillgängliga:
    • Databricks globals: display, displayHTML, dbutils, table, sql, udf, getArgument, , sc, , sqlContextspark
    • %sql magiskt kommando för att köra SQL-celler

Så här arbetar du med "notebooks" i Python-källkod:

  • Sök jupyter.interactiveWindow.cellMarker.codeRegex efter och ställ in den på:

    ^# COMMAND ----------|^# Databricks notebook source|^(#\\s*%%|#\\s*\\<codecell\\>|#\\s*In\\[\\d*?\\]|#\\s*In\\[ \\])

  • Sök jupyter.interactiveWindow.cellMarker.default efter och ställ in den på:

    # COMMAND ----------

Felsök SSH-tunnelanslutningar

Börja med det symptom som matchar felet:

Symtom Första kontrollen
SSH-anslutningen misslyckas eller tidsgränsen överskrids. Kontrollera HTTPS- och WebSocket-åtkomst till arbetsområdet. För klassisk beräkning, kontrollera även klustertillståndet och IDE:ns timeout. Se SSH-anslutningen misslyckas eller tidsgränsen överskrids.
CLI rapporterar att den inte kan hitta code. Installera Visual Studio Code-shellkommandot i din lokala PATH. Se code kommandot hittades inte.
CLI-autentisering misslyckas. Kontrollera CLI-profilen och, för klassisk compute, klusterbehörigheter. Se CLI-autentiseringsfel.
CLI rapporterar invalid_grant med Refresh token is invalid. Logga in igen på arbetsytan med samma CLI-profil, försök sedan att ansluta igen. Se Refresh token är ogiltig.
Python-kod eller notebookar slutar fungera efter anslutning. Kontrollera den valda tolken eller notebookkärnan. Se Python-kod eller notebooks som misslyckas i SSH-sessionen.
Filer försvinner efter en omstart av klustret. Kontrollera om filerna lagrades på en temporär lokal sökväg. Se Filer försvinner eller miljön återställs efter klustrets omstart.

SSH-anslutningen misslyckas eller överskrider tidsgränsen

  • För klassisk compute, kontrollera att klustret körs i arbetsytans gränssnitt.
  • Kontrollera att ditt nätverk, VPN och brandvägg tillåter HTTPS- och WebSocket-trafik till din arbetsplatsdomän. SSH-tunneln använder inte port 22. Den tunnlar all trafik över samma HTTPS-endpoint som andra Databricks CLI-kommandon. Se Konfigurera brandväggsregler för domännamn.
  • Om en proxy eller brandvägg inspekterar TLS-trafik, kontrollera att den tillåter WebSocket-uppgraderingsförfrågan. En mellanhand som blockerar eller tar bort uppgraderingen gör att anslutningen misslyckas eller går ut i timeout. Be din nätverksadministratör att tillåta WebSocket-uppgraderingar till din workspace-domän, eller att kringgå TLS-inspektion för den domänen.
  • Om du ansluter via en företags HTTP-proxy, ställ in miljövariabeln HTTPS_PROXY eller NO_PROXY att kringgå proxyn för din arbetsplatsdomän. SSH-tunneln använder samma proxykonfiguration som andra Databricks CLI-kommandon. Se konfiguration av proxyservrar.
  • Kontrollera att din lokala maskin har HTTPS-åtkomst till github.com och release-assets.githubusercontent.com.
  • Öka SSH-tidsgränsen. Se Ansluta med Visual Studio Code eller Cursor.
  • För felmatchningar av nycklar, ta bort ~/.databricks/ssh-tunnel-keys och kör databricks ssh setup om.
  • Om felen "fjärrvärdsidentifiering har ändrats" kontrollera ~/.ssh/known_hosts-filen och ta bort poster som är relaterade till klustret.
  • SSH-sessioner kan släppas efter 1 timme och högst 10 SSH-anslutningar kan göras till ett enda kluster. Se SSH-tunnelbegränsningar.

code Kommandot hittades inte

Om du ser Error: exec: "code": executable file not found in $PATHöppnar du kommandopaletten (Cmd/Ctrl+Skift+P), väljer Kommandot Shell: Installera kommandot "code" i PATH och startar om IDE-sessionen eller terminalsessionen.

CLI-autentiseringsfel

  • Logga in på din arbetsyta med databricks auth login.
  • För klassisk beräkning, bekräfta att du har CAN ATTACH TO-behörighet på klustret, eller CAN RESTART-behörighet om klustret inte körs.

Uppdateringstoken är ogiltig

Om databricks ssh connect misslyckas med error getting token, invalid_grant och Refresh token is invalid, har auktorisationsservern avvisat CLI:ns sparade OAuth-refresh-token. Logga in igen för att få en ny session:

  1. Ange konfigurationsprofilen för arbetsytan du vill ansluta till:

    databricks auth profiles --skip-validate

  2. Logga in igen med profilen. Ersätt <workspace-url> med arbetsområdets URL, utan /oidc/v1/token sökvägen, och <profile-name> med det matchande profilnamnet:

    databricks auth login --host <workspace-url> --profile <profile-name>

    Slutför inloggningsflödet i webbläsaren.

  3. Försök ansluta igen med samma profil:

    databricks ssh connect --ide vscode --profile <profile-name>

    Använd --ide cursor för Cursor, eller utelämna --ide för en terminalsession.

Om felet kvarstår, kontrollera att det misslyckade kommandot riktar sig mot samma arbetsyta och profil som du just loggade in på. Se OAuth användar-till-maskin (U2M) autentisering.

Python-kod eller notebooks fungerar inte i SSH-sessionen

Filer försvinner eller miljön återställs efter klusteromstart

  • Filer i /Workspace, /Volumes och /dbfs monteringar bevaras mellan klusteromstarter. Filer i /home, /rootoch andra lokala sökvägar är tillfälliga och förlorade vid omstart.
  • Använd klusterbibliotekshantering för beständiga beroenden. Automatisera ominstallationer med init-skript om det behövs. Se Vad är init-skript?.

SSH-installationen misslyckas på Windows (WSL)

Kör databricks ssh setup direkt på Windows, inte inom WSL. Den Windows Visual Studio Code instansen kan inte hitta SSH-konfigurationer som skapats på WSL-sidan.

Vanliga frågor

Kräver serverless compute SSH-konfiguration?

No. När du har installerat och autentiserat Databricks CLI, använd databricks ssh connect för serverless compute. Kommandot databricks ssh setup konfigurerar återanvändbara SSH-värdposter för Classic Dedicated Compute.

Kräver Databricks SSH-tunnel port 22?

No. SSH-tunneln transporterar trafik över HTTPS till din workspace-domän och kräver WebSocket-stöd. Ditt nätverk, VPN, brandvägg och proxy måste tillåta den trafiken. Se SSH-anslutningen misslyckas eller tidsgränsen överskrids.

Hur skiljer sig SSH-tunneln från Databricks Connect?

Med Databricks Connect kan du skriva kod med spark-API:er och köra dem via fjärranslutning på Databricks-beräkning i stället för i den lokala Spark-sessionen. Databricks Visual Studio Code-tillägget använder Databricks Connect för att tillhandahålla inbyggd felsökning av användarkod på Databricks.

SSH-tunneln låter dig komma åt workspace från din IDE och flyttar hela din utvecklingsmiljö på beräkningsresursen. Python, kärnan och kodexekveringen körs på Azure Databricks med tillgång till beräkningsresurserna.

Hur skyddas min kod och mina data?

SSH-trafik är krypterad end-to-end, och kod körs på den Azure Databricks-beräkningsresurs du ansluter till. Autentiseringen använder Databricks CLI och din konfigurerade arbetsytprofil. Se Vilka autentiseringsmetoder stöds?.

Vilka IDE:er stöds?

Visual Studio Code och Markören stöds officiellt. Alla IDE-funktioner med SSH är kompatibla, men endast VS Code och Cursor testas.

Är alla databricks notebook-funktioner tillgängliga från IDE?

Vissa funktioner som display(), dbutilsoch %sql är tillgängliga med begränsningar eller manuell konfiguration. Se Notebook-beteende i SSH-sessioner.

Startar mitt kluster automatiskt när jag ansluter med SSH-tunneln?

Ja, men om det tar längre tid att starta klustret än tidsgränsen för anslutningen misslyckas anslutningsförsöket. För att förhindra detta ökar du värdet för Remote.SSH: Connect Timeout från kommandopaletten (eller remote.SSH.connectTimeout i settings.json) för att ytterligare minska risken för timeout-fel.

Hur vet jag om mitt kluster körs?

Gå till Beräkning i databricks-arbetsytans användargränssnitt och kontrollera statusen för klustret. Klustret måste visa Kör för att SSH-anslutningen ska fungera.

Hur kopplar jag från min SSH/IDE-session?

Du kan koppla från en session genom att stänga IDE-fönstret med alternativet Koppla från i din IDE, stänga SSH-terminalen eller köra exit kommandot i terminalen.

Hur stoppar jag klustret och undviker avgifter när jag inte arbetar?

Avsluta klustret från arbetsytans användargränssnitt om du vill sluta omedelbart. Gå till Beräkning i användargränssnittet för Databricks-arbetsytan, leta reda på klustret och klicka på Avsluta eller Stoppa.

Ange en kort princip för automatisk avslutning i klustret från arbetsytans användargränssnitt. Efter att du kopplat bort väntar SSH-tunneln under perioden shutdown-delay (standard: 10 minuter), sedan gäller klustrets inaktivitetstimeout. Om du använder --keep-detached-processes, avslutas inte klustret automatiskt medan frikopplade processer körs. Detta gäller även anslutningar utan flaggan som återanvänder en tunnel som startats med flaggan. Se Anslutningar till en befintlig tunnel.

Hur ska jag hantera beständiga beroenden?

Beroenden som installeras under en session går förlorade efter omstart av klustret. Använd beständig lagring (/Workspace/Users/<your-username>) för krav och konfigurationsskript. Använd klusterbibliotek eller init-skript för automatisering.

Vilka autentiseringsmetoder stöds?

Autentiseringen använder Databricks CLI och profilfilen ~/.databrickscfg . SSH-nycklar hanteras av SSH-tunneln.

Kan jag ansluta till externa databaser eller tjänster från klustret?

Ja, så länge klustrets nätverk tillåter utgående anslutningar och du har de bibliotek som krävs.

Kan jag använda ytterligare IDE-tillägg?

De flesta tillägg fungerar när de installeras i din fjärranslutna SSH-session, beroende på din IDE och ditt kluster. Visual Studio Code installerar som standard inte lokala tillägg på fjärrvärdar. Du kan installera dem manuellt genom att öppna tilläggspanelen och aktivera dina lokala tillägg på fjärrvärden. Du kan också konfigurera Visual Studio Code för att alltid installera vissa tillägg via fjärranslutning. Se Ansluta till Databricks.

Ja, men arbetsyteadministratörer måste tillåtalist-URL:er för marknadsplatser för Visual Studio Code- och markörtillägg. Din lokala dator måste också ha möjlighet att komma åt Internet.

  • Uppdaterades senast