Zerobus Ingest

Build clients that ingest data directly into Databricks Delta tables via the Zerobus gRPC API.

Status: Generally Available. Charges are billed against the Jobs Serverless SKU. Check the Zerobus overview for the current status of specific features (some, such as Streaming-table targets and Arrow Flight, may be in Beta).

Documentation:

What Is Zerobus Ingest?

Zerobus Ingest is a serverless connector that enables direct, record-by-record data ingestion into Delta tables via gRPC. It eliminates the need for message bus infrastructure (Kafka, Kinesis, Event Hub) for lakehouse-bound data. The service validates schemas, materializes data to target tables, and sends durability acknowledgments back to the client.

Core pattern: SDK init -> create stream -> ingest records -> handle ACKs -> flush -> close

Quick Decision: What Are You Building?

Scenario	Language	Serialization	Reference
Quick prototype / test harness	Python	JSON	references/2-python-client.md
Production Python producer	Python	Protobuf	references/2-python-client.md + references/4-protobuf-schema.md
JVM microservice	Java	Protobuf	references/3-multilanguage-clients.md
Go service	Go	JSON or Protobuf	references/3-multilanguage-clients.md
Node.js / TypeScript app	TypeScript	JSON	references/3-multilanguage-clients.md
High-performance system service	Rust	JSON or Protobuf	references/3-multilanguage-clients.md
Schema generation from UC table	Any	Protobuf	references/4-protobuf-schema.md
Retry / reconnection logic	Any	Any	references/5-operations-and-limits.md

If not specified, default to python.

Common Libraries

These libraries are essential for Zerobus data ingestion and are typically NOT pre-installed on Databricks:

databricks-zerobus-ingest-sdk: Zerobus SDK for high-performance streaming ingestion
databricks-sdk: Databricks workspace client for authentication and metadata
grpcio-tools: only needed to compile a
```
.proto
```
for Protobuf serialization

Install them through the job/cluster library configuration (see Installing Libraries below) rather than pip-installing at runtime — the SDK cannot pip-install on serverless compute.

grpcio-tools and protobuf compatibility

grpcio-tools

must match the runtime's

protobuf

version. If proto compilation fails with a version error, pin a compatible build (for older

protobuf

5.26/5.29 runtimes,

grpcio-tools==1.62.0

works); otherwise use the latest release.

Prerequisites

You must never execute the skill without confirming the below objects are valid:

A Unity Catalog managed Delta table to ingest into
A service principal id and secret with
```
MODIFY
```
and
```
SELECT
```
on the target table
The Zerobus server endpoint for your workspace region
The Zerobus Ingest SDK installed for your target language

See references/1-setup-and-authentication.md for complete setup instructions.

Minimal Python Example (JSON)

python

from zerobus.sdk.sync import ZerobusSdk
from zerobus.sdk.shared import RecordType, StreamConfigurationOptions, TableProperties

sdk = ZerobusSdk(server_endpoint, workspace_url)
options = StreamConfigurationOptions(record_type=RecordType.JSON)
table_props = TableProperties(table_name)

stream = sdk.create_stream(client_id, client_secret, table_props, options)
try:
    # Pass a dict for JSON streams; the SDK serializes it.
    record = {"device_name": "sensor-1", "temp": 22, "humidity": 55}
    offset = stream.ingest_record_offset(record)
    stream.wait_for_offset(offset)  # Block until durably written
finally:
    stream.close()

Detailed guides

Topic	File	When to Read
Setup & Auth	references/1-setup-and-authentication.md	Endpoint formats, service principals, SDK install
Python Client	references/2-python-client.md	Sync/async Python, JSON and Protobuf flows, reusable client class
Multi-Language	references/3-multilanguage-clients.md	Java, Go, TypeScript, Rust SDK examples
Protobuf Schema	references/4-protobuf-schema.md	Generate .proto from UC table, compile, type mappings
Operations & Limits	references/5-operations-and-limits.md	ACK handling, retries, reconnection, throughput limits, constraints

You must always follow all the steps in the Workflow

Workflow

Display the plan of your execution
Determine the type of client and serialization (JSON for prototypes/simple schemas; Protobuf for production/type safety)
Get schema: for Protobuf, generate the
```
.proto
```
per references/4-protobuf-schema.md; for JSON, ensure record keys match the target table columns
Write Python code to a local file following the instructions in the relevant guide (e.g.,
```
scripts/zerobus_ingest.py
```
)

Upload to workspace:

databricks workspace import-dir ./scripts /Workspace/Users/<user>/scripts

Execute on Databricks using a job or notebook
If execution fails: Edit the local file, re-upload, and re-execute

Important

Install the SDK through the job/cluster library configuration, not by pip-installing at runtime in a notebook.
Serverless limitation: The Zerobus SDK cannot pip-install on serverless compute. Use classic compute clusters, or use the Zerobus REST API (Beta) for notebook-based ingestion without the SDK.
Explicit table grants: Service principals need explicit
```
MODIFY
```
and
```
SELECT
```
grants on the target table. Schema-level inherited permissions may not be sufficient for the
```
authorization_details
```
OAuth flow.

Execution Workflow

Step 1: Upload code to workspace

Get your workspace username for the

<user>

path segment, then upload:

bash

USER=$(databricks current-user me --output json | jq -r .userName)
databricks workspace import-dir ./scripts "/Workspace/Users/$USER/scripts"

Step 2: Create and run a job

bash

databricks jobs create --json '{
  "name": "zerobus-ingest",
  "tasks": [{
    "task_key": "ingest",
    "spark_python_task": {
      "python_file": "/Workspace/Users/<user>/scripts/zerobus_ingest.py"
    },
    "new_cluster": {
      "spark_version": "16.1.x-scala2.12",
      "node_type_id": "i3.xlarge",
      "num_workers": 0
    }
  }]
}'

databricks jobs run-now JOB_ID

If execution fails:

Read the error from the job run output
Edit the local Python file to fix the issue

Re-upload:

databricks workspace import-dir ./scripts /Workspace/Users/<user>/scripts

Re-run:
```
databricks jobs run-now JOB_ID
```

Installing Libraries

Databricks provides Spark, pandas, numpy, and common data libraries by default, but the Zerobus SDK is never pre-installed — always add

databricks-zerobus-ingest-sdk

to the job/cluster library config. Only add other libraries if you hit an import error.

Add to the job configuration:

json

"libraries": [
  {"pypi": {"package": "databricks-zerobus-ingest-sdk>=1.0.0"}}
]

Or use init scripts in the cluster configuration.

Timestamp Format

A Delta

TIMESTAMP

column maps to a Protobuf

int64

of epoch microseconds (see the type mappings in references/4-protobuf-schema.md) — supply an integer, not a string:

python

from datetime import datetime, timezone

event_time = int(datetime.now(timezone.utc).timestamp() * 1_000_000)  # epoch microseconds

Key Concepts

gRPC + Protobuf: Zerobus uses gRPC as its transport protocol. Any application that can communicate via gRPC and construct Protobuf messages can produce to Zerobus.
JSON or Protobuf serialization: JSON for quick starts; Protobuf for type safety, forward compatibility, and performance.
At-least-once delivery: The connector provides at-least-once guarantees. Design consumers to handle duplicates.
Durability ACKs: Ingestion is acknowledged when records are durably written. Use
```
ingest_record_offset()
```
+
```
wait_for_offset(offset)
```
for offset-based tracking, an
```
AckCallback
```
for asynchronous confirmation, or
```
flush()
```
to ensure all buffered records are durably written.
No table management: Zerobus does not create or alter tables. You must pre-create your target table and manage schema evolution yourself.
Single-AZ durability: The service runs in a single availability zone. Plan for potential zone outages.

Common Issues

Issue	Solution
Connection refused	Verify server endpoint format matches your cloud (AWS vs Azure). Check firewall allowlists.
Authentication failed	Confirm service principal client_id/secret. Verify GRANT statements on the target table.
Schema mismatch	Ensure record fields match the target table schema exactly. Regenerate .proto if table changed.
Stream closed unexpectedly	Implement retry with exponential backoff and stream reinitialization. See references/5-operations-and-limits.md.
Throughput limits hit	Max 100 MB/s and 15,000 rows/s per stream. Open multiple streams or contact Databricks.
Region not supported	Check supported regions in references/5-operations-and-limits.md.
Table not found	Ensure table is a managed Delta table in a supported region with correct three-part name.
SDK install fails on serverless	The Zerobus SDK cannot be pip-installed on serverless compute. Use classic compute clusters or the REST API (Beta) from notebooks.
Error 4024 / authorization_details	Service principal lacks explicit table-level grants. Grant `MODIFY` and `SELECT` directly on the target table — schema-level inherited grants may be insufficient.

Related Skills

databricks-python-sdk - General SDK patterns and WorkspaceClient for table/schema management
databricks-pipelines - Downstream pipeline processing of ingested data
databricks-unity-catalog - Managing catalogs, schemas, and tables that Zerobus writes to
databricks-synthetic-data-gen - Generate test data to feed into Zerobus producers
databricks-core - CLI install, profile selection, authentication

databricks-zerobus-ingest

NPX Install

Tags

SKILL.md Content