Fontes de dados do Spark
A API de fonte de dados Spark permite ler e gravar em bancos de dados externos diretamente do Databricks. Utilize-o somente quando precisar da flexibilidade total do mecanismo Spark, quiser executar consultas nativas na origem ou exigir acesso de gravação a sistemas externos. Em geral, o Databricks recomenda acesso somente leitura e governado com pushdown automático de consultas Spark ou SQL. Consulte O que é federação de consultas?.
A API da fonte de dados Spark apresenta comportamentos específicos para conectividade, execução de consultas e detecção de esquema.
- A carga de trabalho principal e quaisquer transformações Spark subsequentes são executadas no cluster Spark do Databricks.
- Ao usar a opção
query, a instrução SQL especificada é executada inteiramente na fonte de dados externa. Spark busca os resultados sem realizar o envio automático de transformação na string de consulta. - A conexão requer um conector Databricks, um driver JDBC fornecido pelo usuário ou uma fonte de dados personalizada do PySpark.
- O Spark lê automaticamente o esquema da tabela de banco de dados externa e mapeia seus tipos para tipos Spark SQL.
Use a bundled connector
O Databricks Runtime inclui conectores otimizados para fontes de dados comuns. Consulte Conectores Agrupados Compatíveis para a lista completa.
Os conectores agrupados usam host e port como opções separadas em vez de uma string de URL JDBC completa.
Consultar dados usando uma consulta de passagem
Usar a opção query garante que a lógica de filtro e join seja executada no banco de dados de origem antes que os dados cheguem ao Spark. Para acesso de leitura controlado com pushdown automático de consultas e delegação de permissões do Unity Catalog por meio de visualizações, considere usar consultas remotas .
df = (spark.read
.format("sqlserver")
.option("host", "<your-sql-server-instance>.database.windows.net")
.option("user", dbutils.secrets.get(scope="<scope>", key="<user>"))
.option("password", dbutils.secrets.get(scope="<scope>", key="<password>"))
.option("database", "<database-name>")
.option("query", "SELECT id, name FROM users WHERE active = 1")
.load())
Gravar dados
Especifique um modo de escrita com .mode() para controlar como os dados são gravados. Use append para adicionar linhas a uma tabela existente ou overwrite para substituir seu conteúdo.
(df.write
.format("sqlserver")
.mode("overwrite")
.option("host", "<your-sql-server-instance>.database.windows.net")
.option("user", dbutils.secrets.get(scope="<scope>", key="<user>"))
.option("password", dbutils.secrets.get(scope="<scope>", key="<password>"))
.option("database", "<database-name>")
.option("dbtable", "<table-name>")
.save())
Use uma conexão JDBC do Unity Catalog
Se um conector específico da fonte não estiver agrupado, ou se desejar usar uma versão específica do driver JDBC, use uma conexão JDBC do Unity Catalog. Isso permite centralizar o gerenciamento de credenciais e usar seu próprio driver JDBC.
Uma conexão JDBC do Unity Catalog oferece várias vantagens em relação ao uso direto de um conector empacotado ou de um driver JDBC bruto. Com uma conexão JDBC do Unity Catalog, é possível:
- Traga seu próprio JAR de driver JDBC para qualquer banco de dados que suporte JDBC.
- Create the connection once and reuse it across serverless, standard, and dedicated compute.
- Utilize acesso regulado à fonte de dados usando um objeto de conexão do Unity Catalog.
- Ocultar credenciais de conexão do usuário que consulta.
- Ler e gravar em bancos de dados externos por meio da API de fonte de dados do Spark.
Para usar uma conexão JDBC do Unity Catalog, especifique databricks.connection nas opções do Spark:
df = (spark.read
.format("jdbc")
.option("databricks.connection", "<connection-name>")
.option("query", "SELECT * FROM external_table")
.load())
Para obter instruções de configuração, consulte conexão JDBC.
Use um conector personalizado em compute dedicado
Em compute dedicado (clássico), você pode instalar conectores de fonte de dados Spark de terceiros ou drivers JDBC que não vêm empacotados com o Databricks Runtime.
Use esta abordagem quando:
- Você precisa de um conector Spark de terceiros para sistemas como MongoDB, Cassandra, Couchbase ou Elasticsearch.
- É necessário ter uma versão específica do driver que não está incluída no runtime.
- Deseja instalar um driver JDBC diretamente no cluster sem configurar uma conexão do Unity Catalog.
Instalar um conector ou driver
Instale a biblioteca em seu cluster por meio de Compute > seu cluster > Bibliotecas > Instalar novo . É possível utilizar coordenadas Maven diretamente sem baixar ou carregar quaisquer JARs. Reinicie o cluster para que a biblioteca entre em vigor.
Ler dados
Depois que o conector for instalado, use o nome do formato do conector e suas opções de conexão necessárias para ler dados.
df = (spark.read
.format("mongodb")
.option("connection.uri", "mongodb://<hostname>:27017")
.option("database", "<database-name>")
.option("collection", "<collection-name>")
.load())
Gravar dados
Use o mesmo nome de formato e as mesmas opções de conexão para gravar os dados de volta na origem.
(df.write
.format("mongodb")
.mode("overwrite")
.option("connection.uri", "mongodb://<hostname>:27017")
.option("database", "<database-name>")
.option("collection", "<collection-name>")
.save())
Considerações
Tenha o seguinte em mente ao usar conectores personalizados em compute dedicado.
- O driver ou conector está disponível apenas no cluster onde está instalado.
- Custom third-party Spark JARs are not supported on Databricks SQL, serverless, or standard access mode compute. For those compute types, use bundled connectors or JDBC Unity Catalog connections.
PySpark fontes de dados personalizadas
A API de Fonte de Dados Python permite criar conectores de dados personalizados inteiramente em Python, sem JARs ou bibliotecas baseadas em JVM. Use isso quando você precisar se conectar a REST APIs, a aplicativos SaaS ou a qualquer sistema sem uma interface JDBC, ou quando desejar gerar dados sintéticos programaticamente. A API suporta leituras e gravações, tanto em lotes quanto em transmissão.
PySpark fontes de dados personalizadas requerem Databricks Runtime 15.4 LTS ou acima.
Para configuração, exemplos e referência da API, consulte fontes de dados personalizadas do PySpark.
Comparar estratégias de integração
A tabela a seguir compara a API Spark fonte de dados com o Lakehouse Federation e o Lakeflow Connect para ajudar você a escolher a abordagem certa para o seu caso de uso.
Recurso | API da fonte de dados do Spark | Federação lakehouse | LakeFlow Connect |
|---|---|---|---|
Caso de uso principal | ETL complexo, lógica Spark personalizada, consultas de passagem | Consultas ad-hoc, relatórios de BI | Ingestão automatizada em grande escala |
Movimentação de dados | Carregado na memória do Spark (efêmero) | Carregado na memória do Spark (efêmero) | Copiado para o Delta Lake (persistente) |
Execução de query | Empilhamento manual usando a opção nativa | Pushdown automático de filtros, joins e agregações de Spark e SQL | Não aplicável (replicação de tabela completa) |
Governança | Conexão do Unity Catalog (JDBC) ou Secret Scopes | Unity Catalog (catálogo federado) | Unity Catalog (pipeline gerenciado) |
Melhor para | Usuários avançados que necessitam de flexibilidade total do Spark | Minimizando a movimentação de dados enquanto preserva a governança | Pipelines de CDC de produção e de ingestão |
Conectores em pacote suportados
As seguintes fontes de dados estão incluídas no Databricks Runtime e podem ser chamadas diretamente por meio do Spark. As leituras e gravações são compatíveis com o compute dedicado e padrão.
Gravações em compute serverless são suportadas para PostgreSQL, SQL Server, MySQL, Snowflake e Redshift. Consulte opções de gravação serverless para conectores empacotados para opções de conector suportadas.
Origem de dados |
|
|---|---|
PostgreSQL |
|
SQL Server |
|
MySQL e MariaDB |
|
Snowflake |
|
Amazon Redshift |
|
Google BigQuery |
|
Azure Synapse |
|
HTTP |
|
Migrar cargas de trabalho do BigQuery JDBC para o Databricks Runtime 20
Starting with Databricks Runtime 20, Databricks Runtime no longer includes the bundled BigQuery JDBC driver. Databricks Runtime 19 and earlier continue to include the driver. This change affects classic compute workloads that use Spark JDBC with a jdbc:bigquery: URL.
To find affected workloads, search their code and configuration for a jdbc:bigquery: URL. This JDBC path is separate from the bundled Google BigQuery connector, which uses .format("bigquery") and remains available. Without an installed BigQuery JDBC driver, affected workloads fail with a driver-not-found error.
Antes de mover uma carga de trabalho afetada para o Databricks Runtime 20 ou posterior, escolha uma das seguintes opções:
- Para cargas de trabalho somente leitura, use o Lakehouse Federation para consultar o BigQuery por meio de um catálogo externo.
- Substitua as leituras e gravações do Spark JDBC pelo conector empacotado do Google BigQuery. Consulte Usar um conector empacotado e Conectores empacotados compatíveis.
- Use uma conexão JDBC do Unity Catalog com seu próprio driver JDBC do BigQuery.
- Em compute clássico dedicado, instale seu próprio driver JDBC do BigQuery.
- Mantenha a carga de trabalho no Databricks Runtime 19 ou anterior até concluir uma dessas alterações.
For informação about the drivers available from Google, see BigQuery ODBC and JDBC drivers.
Limitações
As seguintes limitações se aplicam ao usar a API da fonte de dados do Spark no Databricks.
- As opções do Spark para fontes de dados agrupadas são limitadas a
query,dbtable, e a um pequeno conjunto de opções específicas do conector. - JARs Spark personalizados de terceiros só podem ser instalados em compute dedicado. Para serverless ou compute padrão, use conectores integrados ou conexões JDBC do Unity Catalog.
- PySpark fontes de dados personalizadas requerem Databricks Runtime 15.4 LTS ou acima.