Changefeed Examples

On this page

Warning:

CockroachDB v21.2 is no longer supported. For more details, see the Release Support Policy.

This page provides step-by-step examples for using Core and Enterprise changefeeds. Creating Enterprise changefeeds is available on CockroachDB Dedicated or on clusters with an Enterprise license. Core changefeeds are available in all products.

For a summary of Core and Enterprise changefeed features, see What is Change Data Capture?

Enterprise changefeeds can connect to the following sinks:

Kafka
Cloud Storage (Amazon S3, Google Cloud Storage, Azure Storage)
Webhook

See the Changefeed Sinks page for more detail on forming sink URIs and specifics on configuration.

Use the following filters to show usage examples for either Enterprise or Core changefeeds:

Create a changefeed connected to Kafka

Note:

CREATE CHANGEFEED is an Enterprise-only feature. For the Core version, see the CHANGEFEED FOR example.

In this example, you'll set up a changefeed for a single-node cluster that is connected to a Kafka sink. The changefeed will watch two tables.

If you do not already have one, request a trial Enterprise license.
Use the cockroach start-single-node command to start a single-node cluster:
```
$ cockroach start-single-node --insecure --listen-addr=localhost --background
```
Download and extract the Confluent Open Source platform (which includes Kafka).
Move into the extracted confluent-<version> directory and start Confluent:
```
$ ./bin/confluent local services start
```
Only zookeeper and kafka are needed. To troubleshoot Confluent, see their docs and the Quick Start Guide.
Create two Kafka topics:
```
$ ./bin/kafka-topics \
--create \
--zookeeper localhost:2181 \
--replication-factor 1 \
--partitions 1 \
--topic office_dogs
```
```
$ ./bin/kafka-topics \
--create \
--zookeeper localhost:2181 \
--replication-factor 1 \
--partitions 1 \
--topic employees
```
Note:

You are expected to create any Kafka topics with the necessary number of replications and partitions. Topics can be created manually or Kafka brokers can be configured to automatically create topics with a default partition count and replication factor.
As the root user, open the built-in SQL client:
```
$ cockroach sql --insecure
```
Set your organization name and Enterprise license key that you received via email:
```
> SET CLUSTER SETTING cluster.organization = '<organization name>';
```
```
> SET CLUSTER SETTING enterprise.license = '<secret>';
```
Enable the kv.rangefeed.enabled cluster setting:
```
> SET CLUSTER SETTING kv.rangefeed.enabled = true;
```
Create a database called cdc_demo:
```
> CREATE DATABASE cdc_demo;
```
Set the database as the default:
```
> SET DATABASE = cdc_demo;
```

Create a table and add data:

> CREATE TABLE office_dogs (
     id INT PRIMARY KEY,
     name STRING);

> INSERT INTO office_dogs VALUES
   (1, 'Petee'),
   (2, 'Carl');

> UPDATE office_dogs SET name = 'Petee H' WHERE id = 1;

Create another table and add data:

> CREATE TABLE employees (
     dog_id INT REFERENCES office_dogs (id),
     employee_name STRING);

> INSERT INTO employees VALUES
   (1, 'Lauren'),
   (2, 'Spencer');

Start the changefeed:
```
> CREATE CHANGEFEED FOR TABLE office_dogs, employees INTO 'kafka://localhost:9092';
```
```
        job_id       
+--------------------+
  360645287206223873
(1 row)
```
This will start up the changefeed in the background and return the job_id. The changefeed writes to Kafka.
In a new terminal, move into the extracted confluent-<version> directory and start watching the Kafka topics:
```
$ ./bin/kafka-console-consumer \
--bootstrap-server=localhost:9092 \
--from-beginning \
--whitelist 'office_dogs|employees'
```
```
{"after": {"id": 1, "name": "Petee H"}}
{"after": {"id": 2, "name": "Carl"}}
{"after": {"id": 1, "name": "Lauren", "rowid": 528514320239329281}}
{"after": {"id": 2, "name": "Spencer", "rowid": 528514320239362049}}
```
The initial scan displays the state of the tables as of when the changefeed started (therefore, the initial value of "Petee" is omitted).

Note:

This example only prints the value. To print both the key and value of each message in the changefeed (e.g., to observe what happens with DELETEs), use the --property print.key=true flag.
Back in the SQL client, insert more data:
```
> INSERT INTO office_dogs VALUES (3, 'Ernie');
```
Back in the terminal where you're watching the Kafka topics, the following output has appeared:
```
{"after": {"id": 3, "name": "Ernie"}}
```
When you are done, exit the SQL shell (\q).

To stop cockroach:

Get the process ID of the node:

ps -ef | grep cockroach | grep -v grep

  501 21766     1   0  6:21PM ttys001    0:00.89 cockroach start-single-node --insecure --listen-addr=localhost

Gracefully shut down the node, specifying its process ID:

kill -TERM 21766

initiating graceful shutdown of server
server drained and shutdown completed

To stop Kafka, move into the extracted confluent-<version> directory and stop Confluent:
```
$ ./bin/confluent local services stop
```

Create a changefeed connected to Kafka using Avro

Note:

CREATE CHANGEFEED is an Enterprise-only feature. For the Core version, see the CHANGEFEED FOR example.

In this example, you'll set up a changefeed for a single-node cluster that is connected to a Kafka sink and emits Avro records. The changefeed will watch two tables.

If you do not already have one, request a trial Enterprise license.
Use the cockroach start-single-node command to start a single-node cluster:
```
$ cockroach start-single-node --insecure --listen-addr=localhost --background
```
Download and extract the Confluent Open Source platform (which includes Kafka).
Move into the extracted confluent-<version> directory and start Confluent:
```
$ ./bin/confluent local services start
```
Only zookeeper, kafka, and schema-registry are needed. To troubleshoot Confluent, see their docs and the Quick Start Guide.
Create two Kafka topics:
```
$ ./bin/kafka-topics \
--create \
--zookeeper localhost:2181 \
--replication-factor 1 \
--partitions 1 \
--topic office_dogs
```
```
$ ./bin/kafka-topics \
--create \
--zookeeper localhost:2181 \
--replication-factor 1 \
--partitions 1 \
--topic employees
```
Note:

You are expected to create any Kafka topics with the necessary number of replications and partitions. Topics can be created manually or Kafka brokers can be configured to automatically create topics with a default partition count and replication factor.
As the root user, open the built-in SQL client:
```
$ cockroach sql --insecure
```
Set your organization name and Enterprise license key that you received via email:
```
> SET CLUSTER SETTING cluster.organization = '<organization name>';
```
```
> SET CLUSTER SETTING enterprise.license = '<secret>';
```
Enable the kv.rangefeed.enabled cluster setting:
```
> SET CLUSTER SETTING kv.rangefeed.enabled = true;
```
Create a database called cdc_demo:
```
> CREATE DATABASE cdc_demo;
```
Set the database as the default:
```
> SET DATABASE = cdc_demo;
```

Create a table and add data:

> CREATE TABLE office_dogs (
     id INT PRIMARY KEY,
     name STRING);

> INSERT INTO office_dogs VALUES
   (1, 'Petee'),
   (2, 'Carl');

> UPDATE office_dogs SET name = 'Petee H' WHERE id = 1;

Create another table and add data:

> CREATE TABLE employees (
     dog_id INT REFERENCES office_dogs (id),
     employee_name STRING);

> INSERT INTO employees VALUES
   (1, 'Lauren'),
   (2, 'Spencer');

Start the changefeed:
```
> CREATE CHANGEFEED FOR TABLE office_dogs, employees INTO 'kafka://localhost:9092' WITH format = avro, confluent_schema_registry = 'http://localhost:8081';
```
To connect to Confluent Cloud, use the following URL structure: 'https://{API_KEY_ID}:{API_SECRET_URL_ENCODED}@{CONFLUENT_REGISTRY_URL}:443'. See the Confluent Cloud Schema Registry Tutorial for further detail.
```
        job_id       
+--------------------+
  360645287206223873
(1 row)
```
This will start up the changefeed in the background and return the job_id. The changefeed writes to Kafka.

In a new terminal, move into the extracted confluent-<version> directory and start watching the Kafka topics:

$ ./bin/kafka-avro-console-consumer \
--bootstrap-server=localhost:9092 \
--from-beginning \
--whitelist 'office_dogs|employees'

{"after":{"office_dogs":{"id":{"long":1},"name":{"string":"Petee H"}}}}
{"after":{"office_dogs":{"id":{"long":2},"name":{"string":"Carl"}}}}
{"after":{"employees":{"dog_id":{"long":1},"employee_name":{"string":"Lauren"},"rowid":{"long":528537452042682369}}}}
{"after":{"employees":{"dog_id":{"long":2},"employee_name":{"string":"Spencer"},"rowid":{"long":528537452042747905}}}}

The initial scan displays the state of the table as of when the changefeed started (therefore, the initial value of "Petee" is omitted).

Note:

This example only prints the value. To print both the key and value of each message in the changefeed (e.g., to observe what happens with DELETEs), use the --property print.key=true flag.

Back in the SQL client, insert more data:
```
> INSERT INTO office_dogs VALUES (3, 'Ernie');
```
Back in the terminal where you're watching the Kafka topics, the following output has appeared:
```
{"after":{"office_dogs":{"id":{"long":3},"name":{"string":"Ernie"}}}}
```
When you are done, exit the SQL shell (\q).

To stop cockroach:

Get the process ID of the node:

ps -ef | grep cockroach | grep -v grep

  501 21766     1   0  6:21PM ttys001    0:00.89 cockroach start-single-node --insecure --listen-addr=localhost

Gracefully shut down the node, specifying its process ID:

kill -TERM 21766

initiating graceful shutdown of server
server drained and shutdown completed

To stop Kafka, move into the extracted confluent-<version> directory and stop Confluent:
```
$ ./bin/confluent local services stop
```

Create a changefeed connected to a cloud storage sink

Note:

CREATE CHANGEFEED is an Enterprise-only feature. For the Core version, see the CHANGEFEED FOR example above.

In this example, you'll set up a changefeed for a single-node cluster that is connected to an AWS S3 sink. The changefeed watches two tables. Note that you can set up changefeeds for any of these cloud storage providers.

If you do not already have one, request a trial Enterprise license.
Use the cockroach start-single-node command to start a single-node cluster:
```
$ cockroach start-single-node --insecure --listen-addr=localhost --background
```
As the root user, open the built-in SQL client:
```
$ cockroach sql --insecure
```
Set your organization name and Enterprise license key that you received via email:
```
> SET CLUSTER SETTING cluster.organization = '<organization name>';
```
```
> SET CLUSTER SETTING enterprise.license = '<secret>';
```
Enable the kv.rangefeed.enabled cluster setting:
```
> SET CLUSTER SETTING kv.rangefeed.enabled = true;
```
Create a database called cdc_demo:
```
> CREATE DATABASE cdc_demo;
```
Set the database as the default:
```
> SET DATABASE = cdc_demo;
```

Create a table and add data:

> CREATE TABLE office_dogs (
     id INT PRIMARY KEY,
     name STRING);

> INSERT INTO office_dogs VALUES
   (1, 'Petee'),
   (2, 'Carl');

> UPDATE office_dogs SET name = 'Petee H' WHERE id = 1;

Create another table and add data:

> CREATE TABLE employees (
     dog_id INT REFERENCES office_dogs (id),
     employee_name STRING);

> INSERT INTO employees VALUES
   (1, 'Lauren'),
   (2, 'Spencer');

Start the changefeed:

> CREATE CHANGEFEED FOR TABLE office_dogs, employees INTO 's3://example-bucket-name/test?AWS_ACCESS_KEY_ID=enter_key-here&AWS_SECRET_ACCESS_KEY=enter_key_here' with updated, resolved='10s';

        job_id       
+--------------------+
  360645287206223873
(1 row)

This will start up the changefeed in the background and return the job_id. The changefeed writes to AWS.

Monitor your changefeed on the DB Console. For more information, see Changefeeds Dashboard.
When you are done, exit the SQL shell (\q).

To stop cockroach:

Get the process ID of the node:

ps -ef | grep cockroach | grep -v grep

  501 21766     1   0  6:21PM ttys001    0:00.89 cockroach start-single-node --insecure --listen-addr=localhost

Gracefully shut down the node, specifying its process ID:

kill -TERM 21766

initiating graceful shutdown of server
server drained and shutdown completed

Create a changefeed connected to a webhook sink

Note:

CREATE CHANGEFEED is an enterprise-only feature. For the Core version, see the CHANGEFEED FOR example above.

Note:

This feature is experimental.This feature is subject to change. To share feedback and/or issues, contact Support.

New in v21.2: In this example, you'll set up a changefeed for a single-node cluster that is connected to a local HTTP server via a webhook. For this example, you'll use an example HTTP server to test out the webhook sink.

If you do not already have one, request a trial Enterprise license.
Use the cockroach start-single-node command to start a single-node cluster:
```
$ cockroach start-single-node --insecure --listen-addr=localhost --background
```
In this example, you'll run CockroachDB's Movr application workload to set up some data for your changefeed.

First create the schema for the workload:
```
 cockroach workload init movr "postgresql://root@127.0.0.1:26257?sslmode=disable"
```
Then run the workload:
```
 cockroach workload run movr --duration=1m "postgresql://root@127.0.0.1:26257?sslmode=disable"
```
As the root user, open the built-in SQL client:
```
$ cockroach sql --insecure
```
Set your organization name and Enterprise license key that you received via email:
```
> SET CLUSTER SETTING cluster.organization = '<organization name>';
```
```
> SET CLUSTER SETTING enterprise.license = '<secret>';
```
Enable the kv.rangefeed.enabled cluster setting:
```
> SET CLUSTER SETTING kv.rangefeed.enabled = true;
```
In a separate terminal window, set up your HTTP server. Clone the test repository:
```
git clone https://github.com/cockroachlabs/cdc-webhook-sink-test-server.git
```
```
cd cdc-webhook-sink-test-server/go-https-server
```
Next make the script executable and then run the server (passing a specific port if preferred, otherwise it will default to :3000):
```
chmod +x ./server.sh
```
```
./server.sh <port>
```

Back in your SQL shell, run the following statement to create a changefeed that emits to your webhook sink:

CREATE CHANGEFEED FOR TABLE movr.vehicles INTO 'webhook-https://localhost:3000?insecure_tls_skip_verify=true' WITH updated;

You set up a changefeed on the vehicles table, which emits changefeed messages to the local HTTP server.

See the options table for more information on the options available for creating your changefeed to a webhook sink.

      job_id
----------------------
687842491801632769
(1 row)

In the terminal where your HTTP server is running, you'll receive output similar to:

2021/08/24 14:00:21 {"payload":[{"after":{"city":"rome","creation_time":"2019-01-02T03:04:05","current_location":"39141 Travis Curve Suite 87","ext":{"brand":"Schwinn","color":"red"},"id":"d7b18299-c0c4-4304-9ef7-05ae46fd5ee1","owner_id":"5d0c85b5-8866-47cf-a6bc-d032f198e48f","status":"in_use","type":"bike"},"key":["rome","d7b18299-c0c4-4304-9ef7-05ae46fd5ee1"],"topic":"vehicles","updated":"1629813621680097993.0000000000"}],"length":1}
2021/08/24 14:00:22 {"payload":[{"after":{"city":"san francisco","creation_time":"2019-01-02T03:04:05","current_location":"84888 Wallace Wall","ext":{"color":"black"},"id":"020cf7f4-6324-48a0-9f74-6c9010fb1ab4","owner_id":"b74ea421-fcaf-4d80-9dcc-d222d49bdc17","status":"available","type":"scooter"},"key":["san francisco","020cf7f4-6324-48a0-9f74-6c9010fb1ab4"],"topic":"vehicles","updated":"1629813621680097993.0000000000"}],"length":1}
2021/08/24 14:00:22 {"payload":[{"after":{"city":"san francisco","creation_time":"2019-01-02T03:04:05","current_location":"3893 Dunn Fall Apt. 11","ext":{"color":"black"},"id":"21b2ec54-81ad-4af7-a76d-6087b9c7f0f8","owner_id":"8924c3af-ea6e-4e7e-b2c8-2e318f973393","status":"lost","type":"scooter"},"key":["san francisco","21b2ec54-81ad-4af7-a76d-6087b9c7f0f8"],"topic":"vehicles","updated":"1629813621680097993.0000000000"}],"length":1}

For more detail on emitted changefeed messages, see responses.

Core changefeeds stream row-level changes to a client until the underlying SQL connection is closed.

Note:

Only Core changefeeds are available on CockroachDB Serverless. To create a changefeed into a configurable sink, like cloud storage or Kafka, use CockroachDB Dedicated, which has this feature enabled by default.

Create a Core changefeed

In this example, you'll set up a core changefeed for a single-node cluster.

In a terminal window, start cockroach:

$ cockroach start-single-node \
--insecure \
--listen-addr=localhost \
--background

As the root user, open the built-in SQL client:
```
$ cockroach sql \
--url="postgresql://root@127.0.0.1:26257?sslmode=disable" \
--format=csv
```
Note:

Because core changefeeds return results differently than other SQL statements, they require a dedicated database connection with specific settings around result buffering. In normal operation, CockroachDB improves performance by buffering results server-side before returning them to a client; however, result buffering is automatically turned off for core changefeeds. Core changefeeds also have different cancellation behavior than other queries: they can only be canceled by closing the underlying connection or issuing a CANCEL QUERY statement on a separate connection. Combined, these attributes of changefeeds mean that applications should explicitly create dedicated connections to consume changefeed data, instead of using a connection pool as most client drivers do by default.

Note:

To determine how wide the columns need to be, the default table display format in cockroach sql buffers the results it receives from the server before printing them to the console. When consuming core changefeed data using cockroach sql, it's important to use a display format like csv that does not buffer its results. To set the display format, use the --format=csv flag when starting the built-in SQL client, or set the \set display_format=csv option once the SQL client is open.
Enable the kv.rangefeed.enabled cluster setting:
```
> SET CLUSTER SETTING kv.rangefeed.enabled = true;
```
Create table foo:
```
> CREATE TABLE foo (a INT PRIMARY KEY);
```
Insert a row into the table:
```
> INSERT INTO foo VALUES (0);
```

Start the core changefeed:

> EXPERIMENTAL CHANGEFEED FOR foo;

table,key,value
foo,[0],"{""after"": {""a"": 0}}"

In a new terminal, add another row:
```
$ cockroach sql --insecure -e "INSERT INTO foo VALUES (1)"
```
Back in the terminal where the core changefeed is streaming, the following output has appeared:
```
foo,[1],"{""after"": {""a"": 1}}"
```
Note that records may take a couple of seconds to display in the core changefeed.
To stop streaming the changefeed, enter CTRL+C into the terminal where the changefeed is running.

To stop cockroach:

Get the process ID of the node:

ps -ef | grep cockroach | grep -v grep

  501 21766     1   0  6:21PM ttys001    0:00.89 cockroach start-single-node --insecure --listen-addr=localhost

Gracefully shut down the node, specifying its process ID:

kill -TERM 21766

initiating graceful shutdown of server
server drained and shutdown completed

Create a Core changefeed using Avro

In this example, you'll set up a core changefeed for a single-node cluster that emits Avro records. CockroachDB's Avro binary encoding convention uses the Confluent Schema Registry to store Avro schemas.

Use the cockroach start-single-node command to start a single-node cluster:
```
$ cockroach start-single-node \
--insecure \
--listen-addr=localhost \
--background
```
Download and extract the Confluent Open Source platform.
Move into the extracted confluent-<version> directory and start Confluent:
```
$ ./bin/confluent local services start
```
Only zookeeper, kafka, and schema-registry are needed. To troubleshoot Confluent, see their docs and the Quick Start Guide.
As the root user, open the built-in SQL client:
```
$ cockroach sql --url="postgresql://root@127.0.0.1:26257?sslmode=disable" --format=csv
```
Note:

Because core changefeeds return results differently than other SQL statements, they require a dedicated database connection with specific settings around result buffering. In normal operation, CockroachDB improves performance by buffering results server-side before returning them to a client; however, result buffering is automatically turned off for core changefeeds. Core changefeeds also have different cancellation behavior than other queries: they can only be canceled by closing the underlying connection or issuing a CANCEL QUERY statement on a separate connection. Combined, these attributes of changefeeds mean that applications should explicitly create dedicated connections to consume changefeed data, instead of using a connection pool as most client drivers do by default.

Note:

To determine how wide the columns need to be, the default table display format in cockroach sql buffers the results it receives from the server before printing them to the console. When consuming core changefeed data using cockroach sql, it's important to use a display format like csv that does not buffer its results. To set the display format, use the --format=csv flag when starting the built-in SQL client, or set the \set display_format=csv option once the SQL client is open.
Enable the kv.rangefeed.enabled cluster setting:
```
> SET CLUSTER SETTING kv.rangefeed.enabled = true;
```
Create table bar:
```
> CREATE TABLE bar (a INT PRIMARY KEY);
```
Insert a row into the table:
```
> INSERT INTO bar VALUES (0);
```

Start the core changefeed:

> EXPERIMENTAL CHANGEFEED FOR bar WITH format = avro, confluent_schema_registry = 'http://localhost:8081';

table,key,value
bar,\000\000\000\000\001\002\000,\000\000\000\000\002\002\002\000

In a new terminal, add another row:
```
$ cockroach sql --insecure -e "INSERT INTO bar VALUES (1)"
```
Back in the terminal where the core changefeed is streaming, the output will appear:
```
bar,\000\000\000\000\001\002\002,\000\000\000\000\002\002\002\002
```
Note that records may take a couple of seconds to display in the core changefeed.
To stop streaming the changefeed, enter CTRL+C into the terminal where the changefeed is running.

To stop cockroach:

Get the process ID of the node:

ps -ef | grep cockroach | grep -v grep

  501 21766     1   0  6:21PM ttys001    0:00.89 cockroach start-single-node --insecure --listen-addr=localhost

Gracefully shut down the node, specifying its process ID:

kill -TERM 21766

initiating graceful shutdown of server
server drained and shutdown completed

To stop Confluent, move into the extracted confluent-<version> directory and stop Confluent:
```
$ ./bin/confluent local services stop
```
To terminate all Confluent processes, use:
```
$ ./bin/confluent local destroy
```

For further information on Core changefeeds, see EXPERIMENTAL CHANGEFEED FOR.

Cockroach
University

Docs Hub

Changefeed Examples

Create a changefeed connected to Kafka

Create a changefeed connected to Kafka using Avro

Create a changefeed connected to a cloud storage sink

Create a changefeed connected to a webhook sink

Create a Core changefeed

Create a Core changefeed using Avro

See also

Cockroach University

Docs Hub

Cockroach University

Docs Hub

Changefeed Examples

Create a changefeed connected to Kafka

Create a changefeed connected to Kafka using Avro

Create a changefeed connected to a cloud storage sink

Create a changefeed connected to a webhook sink

Create a Core changefeed

Create a Core changefeed using Avro

See also

Cockroach
University

Cockroach
University