Conectar-se ao Databricks usando um túnel SSH

Importante

Esse recurso está em Beta.

O custo e o preço dos recursos no Beta estão sujeitos a alterações.

O túnel Azure Databricks SSH (Secure Shell) conecta Visual Studio Code, Cursor ou seu terminal ao workspace Azure Databricks e ao Azure Databricks serverless compute, AI Runtime ou computação clássica. Use-o para editar arquivos do workspace e executar ou depurar scripts e notebooks Python, com seu ambiente Python e a execução do código ocorrendo no ambiente computacional remoto. Conecte-se diretamente à computação serverless ou configure uma conexão SSH reutilizável para um cluster clássico dedicado.

Requirements

Inicie a conexão SSH a partir da sua máquina local. O túnel não pode ser lançado a partir de outro ambiente remoto ou de um contêiner Docker.

Para se conectar à computação serverless ou clássica, você deve ter:

  • CLI do Databricks versão 1.5.0 ou superior instalada em seu computador local e autenticação configurada. Verifique sua versão instalada com databricks --version. Consulte Instalar ou atualizar a CLI do Databricks.
  • Qualquer um dos seguintes:
    • Visual Studio Code versão 1.110.0 (Universal) ou superior e a extensão Remote - SSH (1.0.46+) instalada.
    • Cursor versão 2.6.11 (Universal) ou superior.

Para se conectar à computação serverless, o encaminhamento de portas para computação serverless deve ser habilitado. Veja Gerenciar encaminhamento de portas para computação serverless.

Para se conectar à computação de GPU sem servidor, o recurso AI Runtime deve estar habilitado. Consulte AI Runtime.

Requisitos adicionais para computação clássica

Para se conectar à computação clássica (dedicada, de usuário único):

Escolha uma conexão SSH

Utilize o método de conexão para o seu tipo de computação:

Computação Método de conexão Requisito de configuração
Computação sem servidor databricks ssh connect Sem etapa separada de configuração de SSH.
Adicione --ide vscode ou --ide cursor para iniciar uma IDE.
Runtime de IA databricks ssh connect --accelerator <accelerator> Sem etapa separada de configuração de SSH.
Adicione --ide vscode ou --ide cursor para iniciar uma IDE.
Para aceleradores suportados, veja --accelerator.
Computação clássica dedicada e de usuário único Execute databricks ssh setup --name <connection-name> em seu terminal.
Depois, inicie a sessão SSH pelo IDE ou execute ssh <connection-name>.		 Selecione um cluster dedicado de usuário único que atenda aos requisitos clássicos de computação.
Não há suporte para clusters compartilhados.

Para uma comparação com Databricks Connect e outras opções de desenvolvimento, veja Conectar-se do seu IDE.

Conectar-se à computação sem servidor

Ao atender aos requisitos acima, execute databricks ssh connect no seu terminal ou IDE.

O valor --ide seleciona o editor a ser iniciado, independentemente de qual editor ou terminal você utilize para executar o comando.

Visual Studio Code

databricks ssh connect --ide vscode

A CLI abre uma janela do Visual Studio Code conectada ao ambiente de computação remoto.

Cursor

databricks ssh connect --ide cursor

A CLI abre uma janela do Cursor conectada ao ambiente de computação remoto.

Terminal

databricks ssh connect

O CLI inicia uma sessão interativa de SSH.

Para opções de comando, incluindo conexões nomeadas e perfis de autenticação, veja databricks ssh connect.

Depois de conectar, abra seu projeto de espaço de trabalho e selecione o ambiente Python. Se a conexão falhar, veja Solucionar problemas com conexões de túnel SSH.

Conecte-se à computação de GPU serverless com AI Runtime

Com o tempo de execução de IA ativado, adicione --accelerator para usar computação por GPU:

databricks ssh connect --accelerator GPU_1xA10

databricks ssh connect oferece uma sessão interativa em um único nó. Para tarefas de treinamento de longa duração ou treinamento distribuído em vários nós, envie a carga de trabalho com databricks air. Veja Usar a CLI do Databricks com o AI Runtime.

Conectar-se à computação clássica

Para uma conexão reutilizável com um cluster dedicado clássico, configure um nome de host SSH e selecione esse host no seu IDE ou conecte-se a partir de um terminal.

Configurar a conexão SSH

Observação

A configuração da conexão SSH só será necessária se você estiver se conectando à computação clássica.

Execute databricks ssh setup na sua máquina local. Substitua <connection-name> por um nome para essa conexão, como my-connection:

databricks ssh setup --name <connection-name>

A CLI pede que você selecione um cluster e adiciona uma entrada de host à sua configuração SSH. Você também pode selecionar um cluster diretamente. Substitua <cluster-id> pelo ID do seu cluster dedicado:

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

Para configurar quanto tempo o túnel SSH espera após o último cliente se desconectar, adicione --shutdown-delay ao comando de configuração. O padrão é 10 minutos. Por exemplo, para definir um atraso de 30 minutos para conexões através dessa entrada SSH do host:

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

Observação

Para usuários do IntelliJ, o Databricks recomenda adicionar --auto-start-cluster=false ao comando de instalação e iniciar o cluster manualmente antes de se conectar. Isso ocorre porque os IDEs do JetBrains iniciam todos os clusters configurados na inicialização, o que pode resultar em encargos de computação inesperados.

Conectar usando o Visual Studio Code ou o Cursor

  1. Para o Visual Studio Code, instale a extensão SSH Remota. O cursor inclui uma extensão SSH remota por padrão.

  2. No menu principal do IDE, clique em Exibir>Paleta de Comandos. Selecione Remote-SSH: Configurações. Como alternativa, selecione Preferências: Abrir Configurações do Usuário (JSON) para modificar settings.json diretamente.

  3. Em Remote.SSH: extensões padrão (ou remote.SSH.defaultExtensions in settings.json), adicione ms-Python.Python e ms-toolsai.jupyter.

    Se você estiver modificando settings.json:

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

    Observação

    Opcionalmente, aumente o valor de Remote.SSH: Connect Timeout (ou remote.SSH.connectTimeout em settings.json) para minimizar ainda mais a possibilidade de erros de tempo limite. O tempo limite padrão é 360.

  4. Na paleta de comandos, selecione Remote-SSH: Conectar-se ao host.

  5. No menu suspenso, selecione a conexão que você configurou na primeira etapa. O IDE continua a se conectar em uma nova janela.

Conectar usando IDEs do IntelliJ

  1. Siga o tutorial do servidor remoto para ser configurado.
  2. Na nova tela de conexão, insira:
    • Nome de utilizador: root
    • Host: <connection-name>

Conecte-se ao Classic Compute a partir de um terminal

Use o nome de conexão que você configurou com databricks ssh setup:

ssh <connection-name>

Para uma conexão direta sem entrada de host SSH reutilizável, você também pode usar a CLI. Substitua <cluster-id> pelo seu ID dedicado de cluster:

databricks ssh connect --cluster <cluster-id>

Consulte databricks ssh connect.

Abrir projetos do espaço de trabalho via SSH

Por padrão, o databricks ssh connect comando é aberto para um diretório efêmero. Para acessar arquivos de workspace, navegue até o diretório do workspace do IDE ou terminal:

  • Em Visual Studio Code ou Cursor, na Paleta de Comandos (Cmd/Ctrl+Shift+P), selecione Abrir Pasta e navegue até /Workspace/Users/<your-username>.
  • Em uma janela de terminal, altere o diretório: cd /Workspace/Users/<your-username>.

Observação

Arquivos em /Workspace, /Volumes e /dbfs persistem entre reinicializações de cluster. Os arquivos em /home, /roote outros caminhos locais são efêmeros e perdidos na reinicialização.

Execute Python e notebooks na sessão SSH

Selecione o ambiente Python fornecido pela sua sessão SSH antes de executar o código. Para computação clássica, esse ambiente inclui as bibliotecas embutidas do Databricks Runtime e bibliotecas com escopo de computação.

  1. Abra a Paleta de Comandos (Cmd/Ctrl+Shift+P) e selecione Python: Selecionar Interpretador.

  2. Selecione o ambiente virtual pythonEnv-xxx da lista. Se você configurar as dependências do Python usando a flag --base-environment, selecione o nome mais longo do ambiente virtual na lista de opções. Se o ambiente virtual não aparecer:

    1. Execute echo $DATABRICKS_VIRTUAL_ENV em um terminal dentro do IDE.

      Exemplo de saída: /local_disk0/.ephemeral_nfs/envs/pythonEnv-xxx/bin/python

    2. Cole o resultado completo como caminho do interpretador no prompt Python: Selecionar Interpretador.

  3. Abra um novo terminal e o ambiente virtual deve ser ativado automaticamente.

  4. Para executar um jupyter notebook, verifique se o ambiente virtual está selecionado como o kernel. Clique em Selecionar Kernel no canto superior direito do bloco de anotações.

Execute e depure arquivos Python e notebooks .ipynb usando as extensões padrão do Python e do Jupyter.

Para usar o Spark em um arquivo Python na computação sem servidor, inicialize uma sessão explicitamente:

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

Gerenciar dependências para sessões SSH

Escolha o gerenciamento de dependências para o seu tipo de computação:

Para pacotes não Python, veja Dependências não Python.

Ambientes base do espaço de trabalho (recomendados para ambientes sem servidor e tempo de execução de IA)

Observação

Esse recurso requer que a prévia Suporte ao ambiente base de workspace sem servidor em Jobs esteja habilitada. Consulte Gerenciar visualizações do Azure Databricks.

Use um ambiente base de workspace com a versão 4 ou inferior do ambiente serverless para pré-configurar dependências do Python. O túnel SSH não suporta --base-environment com ambiente serverless versão 5 ou superior. Crie um ambiente base usando a interface do usuário do workspace ou o comando databricks environments create-workspace-base-environment da CLI do Databricks.

Especifique o ambiente usando a opção --base-environment ao se conectar:

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

A opção --base-environment aceita um nome de exibição, um caminho YAML de workspace ou um ID de recurso. Você não pode combiná-lo com --cluster. Consulte databricks ssh connect.

Bibliotecas de cluster (recomendadas para computação clássica)

Instale as dependências usando a interface do workspace em Computação > Bibliotecas. Elas persistem entre reinicializações de cluster e estão disponíveis em pythonEnv-xxx. Consulte bibliotecas de cluster.

Dependências que não são do Python

Para persistir dependências não Python, use um script de inicialização que instale os pacotes quando a computação for iniciada. Opcionalmente, armazene os pacotes em um volume do Catálogo do Unity e faça referência a eles a partir do script de inicialização. Consulte O que são scripts de inicialização?.

Configuração de notebook específica do projeto

Para dependências com escopo de projeto, é necessário executar um notebook que contém os comandos %pip install no início de cada sessão.

# 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

Os comandos %pip incluem proteções específicas do Databricks e propagam dependências para os nós executores do Spark. Isso permite UDFs (funções definidas pelo usuário) com dependências personalizadas.

Para obter mais exemplos, consulte Gerenciar bibliotecas com %pip comandos.

Você não precisa rodar novamente o notebook de configuração se reconectar antes do túnel SSH desligar. Por padrão, o túnel desliga 10 minutos após o último cliente se desconectar. Para alterar esse atraso, use --shutdown-delay com o comando para o seu método de conexão:

  • Para uma conexão reutilizável com um recurso de computação clássico, defina o atraso usando databricks ssh setup. A entrada de host SSH gerada aplica o atraso quando você se conecta a partir do seu IDE ou executa ssh <connection-name>.
  • Para uma conexão CLI direta, defina o atraso com databricks ssh connect.

Observação

Várias sessões SSH no mesmo cluster compartilham um ambiente virtual.

Use o Git em uma sessão SSH

Importante

Esse recurso está em Visualização Pública. Os administradores do workspace podem controlar o acesso ao suporte da CLI do Git para pastas Git na página Visualizações . Consulte Gerenciar visualizações do Azure Databricks.

Você pode usar a CLI do Git no túnel SSH com pastas Git recém-criadas e as credenciais Git que você configurou no workspace do Azure Databricks. Consulte Usar comandos da CLI do Git.

Se a CLI pedir credenciais em vez de detectá-las automaticamente, você deve conectar seu provedor Git ao Azure Databricks. Consulte Conectar seu provedor Git ao Databricks.

Manter processos desanexados em execução

Por padrão, quando o túnel SSH desliga, ele para todos os processos que a sessão iniciou, incluindo os que você desanexou da sessão com tmux, setsid, ou nohup. Antes de pará-los, o túnel registra um aviso com seus IDs de processo na saída da execução do trabalho do túnel. databricks ssh connect imprime o ID da execução do trabalho ao iniciar o túnel.

Para manter o trabalho desanexado rodando depois de desconectar, use a flag --keep-detached-processes. Defina a flag na conexão que inicia o túnel antes de iniciar o trabalho que deseja manter. Consulte Conexões a um túnel existente.

  • Computação serverless ou clássica: Passe a bandeira para databricks ssh connect.
  • Computação clássica com um host SSH configurado: Passe a flag para databricks ssh setup. A entrada de host SSH gerada é aplicada toda vez que você se conecta. Conexões serverless não exigem configuração, então essa opção se aplica apenas à computação clássica.

O seguinte exemplo mantém processos desanexados em execução em computação sem servidor:

databricks ssh connect --keep-detached-processes

O exemplo a seguir mantém processos desacoplados rodando em um cluster dedicado:

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

Quando você usa essa flag e o último cliente se desconecta, o túnel se comporta da seguinte forma:

  • Após esse --shutdown-delay período, o túnel verifica processos desvinculados. Enquanto algum deles estiver em execução, o túnel continua funcionando em vez de desligar.
  • Processos desanexados mantêm seu acesso a /Workspace e /Volumes.
  • Após a saída do último processo desanexado, o túnel se fecha e a execução do job termina.

Enquanto o túnel permanece em execução, você pode se reconectar ao mesmo serviço de computação e se reconectar ao trabalho desanexado, por exemplo, com tmux attach. Em computação serverless, reconecte com o mesmo nome de conexão. Se você omitir --name, a CLI deriva o nome da conexão do seu workspace e dos sinalizadores --accelerator e --base-environment, então mudar qualquer um dos sinalizadores inicia uma conexão separada.

Conexões com um túnel existente

O modo do túnel é fixo quando é iniciado, e conexões posteriores o tratam da seguinte forma:

  • Se você se conectar com a flag a um túnel que começou sem ela, a CLI inicia um novo túnel. Processos que você desvinculou no túnel existente não são mantidos, e ainda assim param quando o túnel desliga. Em um cluster dedicado, o novo túnel para imediatamente o existente, encerrando suas sessões abertas e encerrando seus processos desanexados.
  • Se você se conectar sem a flag a um túnel que começou com ela, a CLI reutiliza esse túnel, e o túnel continua rodando enquanto os processos em segundo plano permanecem. Isso também se aplica a conexões de outras entradas de host SSH ou sessões de IDE para a mesma instância de computação.

Custos e vida útil máxima

Tenha o seguinte em mente:

  • Enquanto o túnel permanece em execução, o serviço de computação continua em execução e incorre em custos. Um cluster clássico não termina automaticamente. Uma sessão ociosa tmux conta como um processo desanexado em execução, então feche-a quando não precisar mais.
  • A execução do trabalho ainda para quando atinge o tempo máximo de vida definido por --server-timeout, mesmo que processos destacados estejam em execução. Esse tempo de vida conta a partir do início da execução do trabalho, não a partir do momento em que o último cliente se desconecta. Após a execução do trabalho ser interrompida, os processos desanexados perdem o acesso a /Workspace e /Volumes. Na computação serverless, os processos desvinculados param. No comput clássico, eles podem continuar rodando sem esse acesso até o cluster terminar. Para manter a saída de trabalhos desanexados de longa duração, salve-a com o SDK do Azure Databricks ou a API REST em vez de gravar nos caminhos /Workspace ou /Volumes. Consulte Trabalho com arquivos nos volumes do Unity Catalog.
  • Para trabalhos de longa duração, use jobs ou bundles em vez disso.

Limitações do túnel SSH

O túnel SSH fornecido pelo Databricks tem as seguintes limitações:

  • Não há suporte para clusters compartilhados.
  • Arquivos editados fora de /Workspace, /Volumes e /dbfs são perdidos na reinicialização do cluster.
  • No máximo 10 conexões SSH são permitidas por cluster.
  • As sessões inativas podem ser encerradas após 1 hora.
  • O túnel SSH não pode ser iniciado de outros ambientes remotos ou contêineres do Docker.
  • Você pode encontrar problemas de desempenho ou conexão quando três ou mais notebooks Jupyter estiverem abertos simultaneamente.

Comportamento do Notebook em sessões SSH

Há algumas diferenças nos notebooks ao usar o túnel SSH:

  • Os arquivos Python não definem nenhum global do Databricks (como spark ou dbutils). Você deve importá-los explicitamente com from databricks.sdk.runtime import spark.
  • Para notebooks ipynb, esses recursos estão disponíveis:
    • Globais do Databricks: display, displayHTML, dbutils, table, sql, udf, getArgument, sc, sqlContext, spark
    • %sql comando mágico para executar células SQL

Para trabalhar com "notebooks" de origem do Python:

  • Pesquise por jupyter.interactiveWindow.cellMarker.codeRegex e defina como:

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

  • Pesquise por jupyter.interactiveWindow.cellMarker.default e defina como:

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

Solucionar problemas nas conexões de túnel SSH

Comece pelo sintoma que corresponde à falha:

Sintoma Primeira verificação
A conexão SSH falha ou expira por tempo limite. Verifique o HTTPS do workspace e o acesso ao WebSocket. Para computação clássica, também verifique o estado do cluster e o tempo limite do IDE. Veja A conexão SSH falha ou expira.
O CLI informa que não consegue encontrar code. Instale o comando shell do Visual Studio Code em seu ambiente local PATH. Consulte code comando não encontrado.
A autenticação da CLI falha. Verifique o perfil CLI e, para computação clássica, as permissões do cluster. Veja erros de autenticação de CLI.
O CLI reporta invalid_grant com Refresh token is invalid. Faça login novamente no workspace usando o mesmo perfil de CLI e tente a conexão novamente. Veja O token de atualização é inválido.
O código ou os notebooks em Python falham após a conexão. Verifique o interpretador ou kernel do notebook selecionado. Consulte Códigos ou notebooks em Python falham na sessão SSH.
Arquivos desaparecem após uma reinicialização do cluster. Verifique se os arquivos foram armazenados em um caminho local efêmero. Veja Arquivos desaparecem ou ambiente é redefinido após reiniciar o cluster.

A conexão SSH falha ou atinge o tempo limite

  • Para computação clássica, verifique se o cluster está rodando na interface do workspace.
  • Verifique se sua rede, VPN e firewall permitem tráfego HTTPS e WebSocket para o domínio do seu workspace. O túnel SSH não usa a porta 22. Ele encaminha todo o tráfego por meio do mesmo endpoint HTTPS usado por outros comandos da Databricks CLI. Consulte Configurar regras de firewall de nome de domínio.
  • Se um proxy ou firewall inspecionar o tráfego TLS, verifique se ele permite a solicitação de atualização do WebSocket. Um intermediário que bloqueia ou remove a atualização faz a conexão falhar ou expirar. Peça ao administrador de rede para permitir atualizações do WebSocket no domínio de workspace ou para aplicar bypass na inspeção TLS desse domínio.
  • Se você se conectar por meio de um proxy HTTP corporativo, defina a variável de ambiente HTTPS_PROXY ou NO_PROXY para ignorar o proxy no domínio do seu espaço de trabalho. O túnel SSH usa a mesma configuração de proxy que outros comandos CLI do Databricks. Veja configuração do servidor proxy.
  • Verifique se sua máquina local tem acesso HTTPS a github.com e release-assets.githubusercontent.com.
  • Aumente o tempo limite do SSH. Consulte Conectar usando o Visual Studio Code ou o Cursor.
  • Para erros de incompatibilidade de chave, exclua ~/.databricks/ssh-tunnel-keys e execute novamente databricks ssh setup.
  • Para erros de "identificação do host remoto mudou", verifique o arquivo ~/.ssh/known_hosts e remova as entradas relacionadas ao seu cluster.
  • As sessões SSH podem ser suspensas após 1 hora e não mais do que 10 conexões SSH podem ser feitas em um único cluster. Veja limitações do túnel SSH.

code comando não encontrado

Se você vir Error: exec: "code": executable file not found in $PATH, abra a Paleta de Comandos (Cmd/Ctrl+Shift+P), selecione Comando shell: instale o comando 'code' no PATH e reinicie o IDE ou a sessão de terminal.

Erros de autenticação da CLI

  • Faça login no seu workspace usando databricks auth login.
  • Para computação clássica, confirme se você tem permissão CAN ATTACH TO no cluster, ou CAN RESTART se o cluster não estiver em execução.

Token de atualização é inválido

Se databricks ssh connect falhar com error getting token, invalid_grant, e Refresh token is invalid, o servidor de autorização rejeitou o token de atualização OAuth salvo da CLI. Faça login novamente para obter uma nova sessão:

  1. Identifique o perfil de configuração do espaço de trabalho ao qual você deseja se conectar:

    databricks auth profiles --skip-validate

  2. Faça login novamente usando esse perfil. Substitua <workspace-url> pela URL do workspace, sem o caminho /oidc/v1/token, e <profile-name> pelo nome de perfil correspondente:

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

    Conclua o fluxo de autenticação no navegador.

  3. Tente novamente a conexão com o mesmo perfil:

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

    Use --ide cursor para o Cursor, ou omita --ide para uma sessão de terminal.

Se o erro persistir, verifique se o comando que falhou tem como alvo o mesmo workspace e perfil nos quais você acabou de fazer login. Veja autenticação OAuth de usuário para máquina (U2M).

Código Python ou notebooks falham na sessão SSH

Arquivos desaparecem ou o ambiente é resetado após reinicialização do cluster

  • Os arquivos em montagens /Workspace, /Volumes, e /dbfs persistem entre reinicializações do cluster. Os arquivos em /home, /roote outros caminhos locais são efêmeros e perdidos na reinicialização.
  • Use o gerenciamento de biblioteca de cluster para dependências persistentes. Automatize reinstalações usando scripts de inicialização, se necessário. Consulte O que são scripts de inicialização?.

Falha na instalação do SSH no Windows (WSL)

Execute databricks ssh setup diretamente no Windows, não no WSL. A instância de Windows Visual Studio Code não consegue localizar as configurações de SSH criadas no lado do WSL.

perguntas frequentes

Computação serverless requer configuração de SSH?

No. Após instalar e autenticar a CLI do Databricks, use databricks ssh connect para computação serverless. O databricks ssh setup comando configura entradas reutilizáveis de SSH para computação dedicada clássica.

O túnel SSH do Databricks requer a porta 22?

No. O túnel SSH transporta tráfego via HTTPS para o domínio do seu workspace e requer suporte ao WebSocket. Sua rede, VPN, firewall e proxy devem permitir esse tráfego. Veja A conexão SSH falha ou expira.

Como o túnel SSH é diferente do Databricks Connect?

O Databricks Connect permite escrever código usando APIs do Spark e executá-las remotamente na computação do Databricks em vez de na sessão do Spark local. A extensão Databricks Visual Studio Code usa o Databricks Connect para fornecer depuração integrada do código do usuário no Databricks.

O túnel SSH permite acessar o workspace a partir da sua IDE e transfere todo o seu ambiente de desenvolvimento para a máquina de computação. Python, o kernel e a execução do código rodam no Azure Databricks com acesso aos recursos de computação.

Como meu código e dados são protegidos?

O tráfego SSH é criptografado de ponta a ponta, e o código roda no recurso de computação do Azure Databricks ao qual você se conecta. A autenticação usa a CLI Databricks e o perfil do seu workspace configurado. Consulte Quais métodos de autenticação são suportados?.

Quais IDEs têm suporte?

Visual Studio Code e Cursor têm suporte oficial. Qualquer IDE com funcionalidades SSH é compatível, mas apenas o VS Code e o Cursor são testados.

Todos os recursos do notebook do Databricks estão disponíveis no IDE?

Alguns recursos, como display(), dbutilse %sql estão disponíveis com limitações ou configuração manual. Veja o comportamento do Notebook nas sessões SSH.

Meu cluster será iniciado automaticamente quando eu me conectar usando o túnel SSH?

Sim, mas se levar mais tempo para iniciar o cluster do que o tempo limite de conexão, a tentativa de conexão falhará. Para evitar isso, aumente o valor de Remote.SSH: Timeout de Conexão na Command Palette (ou remote.SSH.connectTimeout em settings.json), reduzindo ainda mais a chance de erros de timeout.

Como saber se meu cluster está em execução?

Navegue até Computação na interface do usuário do workspace Databricks e verifique o status do cluster. O cluster deve mostrar Executando para que a conexão SSH funcione.

Como faço para desconectar minha sessão SSH/IDE?

Você pode desconectar uma sessão fechando a janela IDE, usando a opção Desconectar em seu IDE, fechando seu terminal SSH ou executando o exit comando no terminal.

Como faço para parar o cluster e evitar custos quando não estou trabalhando?

Para parar imediatamente, encerre o cluster na interface do usuário do espaço de trabalho. Navegue até Computação na interface do usuário do Databricks, localize o cluster e clique em Encerrar Cluster ou Parar Cluster.

Defina uma política de encerramento automático curta em seu cluster a partir da interface do usuário do workspace. Depois que você desconecta, o túnel SSH espera o shutdown-delay período (padrão: 10 minutos), então o timeout de inatividade do cluster se aplica. Se você usar --keep-detached-processes, o cluster não termina automaticamente enquanto processos desanexados estão rodando. Isso também se aplica a conexões sem a flag que reutilizam um túnel iniciado com ela. Consulte Conexões a um túnel existente.

Como devo lidar com dependências persistentes?

As dependências instaladas durante uma sessão são perdidas após a reinicialização do cluster. Use o armazenamento persistente (/Workspace/Users/<your-username>) para requisitos e scripts de instalação. Use bibliotecas de cluster ou scripts de inicialização para automação.

Quais métodos de autenticação têm suporte?

A autenticação usa a CLI do Databricks e o arquivo de perfis ~/.databrickscfg. As chaves SSH são manipuladas pelo túnel SSH.

Posso me conectar a bancos de dados ou serviços externos do cluster?

Sim, desde que sua rede de cluster permita conexões de saída e você tenha as bibliotecas necessárias.

Posso usar extensões adicionais do IDE?

A maioria das extensões funciona quando instaladas em sua sessão SSH remota, dependendo do IDE e do cluster. Por padrão, o Visual Studio Code não instala extensões locais em hosts remotos. Você pode instalá-las manualmente abrindo o painel de extensões e habilitando suas extensões locais no host remoto. Você também pode configurar o Visual Studio Code para sempre instalar determinadas extensões remotamente. Consulte Conectar-se ao Databricks.

Sim, no entanto, os administradores do workspace devem adicionar as URLs dos marketplaces de extensões do Visual Studio Code e do Cursor à lista de permissões. Seu computador local também deve ter a capacidade de acessar a Internet.

  • Última atualização em