Set up a MongoDB change streams source

Connect to the server with mongosh and run:

rs.status().members.map(m => m.name + " " + m.stateStr)

If the answer is an error, the server is standalone. Start mongod with the --replSet option (or set replication.replSetName in the configuration file), then initiate a one-node set:

rs.initiate({ _id: "rs0", members: [{ _id: 0, host: "<host>:27017" }] })

Sign in as an administrator and create a custom role. This is the role of the reference page: it reads and writes any database and may run collMod:

db.getSiblingDB("admin").runCommand({ createRole: "GluesyncUserRole",
  privileges: [
    { resource: { db: "", collection: "" }, actions: [ "collMod" ] }
  ],
  roles: [ { role: "readWriteAnyDatabase", db: "admin" } ]
})

For a source that only reads, a narrower role is enough. In our test this role let Gluesync browse the collections, run the snapshot, enable the images and follow the change stream. We did not test with fewer actions. Replace shop with your database:

db.getSiblingDB("admin").runCommand({ createRole: "GluesyncSourceRole",
  privileges: [
    { resource: { db: "shop", collection: "" },
      actions: [ "find", "changeStream", "collMod", "listCollections",
                 "listIndexes", "collStats", "dbStats" ] }
  ],
  roles: []
})

Create the user in the admin database, with the role you chose:

db.getSiblingDB("admin").createUser({
  user: "gluesync", pwd: "<a strong password>",
  roles: [ { role: "GluesyncSourceRole", db: "admin" } ]
})

In mongosh, create the collection:

db = db.getSiblingDB("shop");
db.orders.insertMany([
  { _id: 1, customer: "Acme Spa", status: "new", amount: 1500.50, quantity: 3,
    paid: true, created_at: new Date("2026-11-01T10:00:00Z"),
    tags: ["a", "b"], address: { city: "Milan", zip: "20100" } },
  { _id: 2, customer: "Globex", status: "paid", amount: 99.99, quantity: 1,
    paid: false, created_at: new Date("2026-11-01T11:15:00Z") }
]);

On the PostgreSQL database, create the table:

CREATE TABLE public.orders (
  _id integer PRIMARY KEY, customer varchar(100), status varchar(20),
  amount double precision, quantity integer, paid boolean,
  created_at timestamp(3), tags text[], address jsonb);

Open Data pipelines;

Select the + button (Create pipeline), or Create your first pipeline on a new installation. The Agents setup wizard opens on 1. Setup source;

In Search, type mongo and select the MongoDB CDC agent tile under NoSQL. The form that opens is titled MongoDB;

Enter Host name / Address, Port (27017), Database name (the database that holds the collections, shop here), Username and Password;

Under Advanced connection properties, select Add property, pick Auth Database in Key and enter admin in Value. The other keys are Connection Timeout Seconds, Read Timeout Seconds, Use Dns Seed List (for an Atlas SRV address), Replica Set and Direct connection;

Optional: turn on Disable auth for a server without access control. Under Security, Upload 'trust store' file, Upload 'key store' file and Upload 'certificate store' file take the TLS files, each with Upload files or Use a path;

Select Test and continue, then Next;

On 2. Setup target(s), search for postgres, select the PostgreSQL CDC agent tile, enter the connection of your PostgreSQL database, and select Test and continue and Next;

On 3. Ready, enter a Pipeline name and select Finish.

In the pipeline, select Entities. The Add entities page opens;

In the Object browser, expand the database shop and tick orders. The Field mapping dialog opens;

Set Target Schema to public and Target Table to orders. Gluesync reads the table and links every field that has a column of the same name. The _id field is marked as the key, because it is the primary key of the table;

Untick the row address on the source side. The dialog unticks its column on the target side too. See Data type notes for why;

Select Confirm, then Confirm and continue. The entity shop.orders is in the Hold group.

In the row of the entity, select the start icon (Start). The dialog Sync changes (CDC) opens;

In Start from, keep Full copy (marked Recommended for the first start) and keep Keep and merge under Data already in the target;

Select Start entity.

Read the target table:

SELECT _id, customer, status, amount, created_at, tags FROM public.orders ORDER BY _id;

Change the source. These commands insert, update and delete a document:

db = db.getSiblingDB("shop");
db.orders.insertOne({ _id: 3, customer: "Initech", status: "new", amount: Double(10.10),
  quantity: 2, paid: false, created_at: new Date(), tags: ["x"] });
db.orders.updateOne({ _id: 2 }, { $set: { status: "shipped", amount: 120.75 } });
db.orders.deleteOne({ _id: 1 });

Read the table again.

In the row of the entity, select the pause icon (Pause), then Pause entity;

In mongosh, change the source while the entity is stopped:

db = db.getSiblingDB("shop");
db.orders.insertOne({ _id: 6, customer: "Oscorp", status: "new", amount: Double(7),
  quantity: 1, paid: true, created_at: new Date() });
db.orders.updateOne({ _id: 3 }, { $set: { status: "shipped" } });
db.orders.deleteOne({ _id: 2 });

Select the start icon. In Start from, Where it stopped is now available and selected (Continue from the last checkpoint. Nothing is lost.). Select Start entity.