Hop options

Every key of a hop and of its sides: its type, the engines that read it, and what it does.

Every key a hop may say, from the one registry the configuration is checked against before anything runs: an unknown key is refused with the closest known one, a wrong type or a contradiction with where it is.

A hop's keys

The keys of a hop itself, beside its two sides.

KeyWritten asRead onWhat it is
goaltextevery enginewhat the hop is for - copy, cutover, verify, two-way, keep-in-sync, rehearse, upgrade, subset, consolidate, split, reshard or archive
enginetextevery enginethe engine both sides run, or hetero - read from the addresses when they are addresses
sourcetext or a mappingevery enginewhere the data is: an address or the long form
targettext or a mappingevery enginewhere it goes: an address or the long form
databasesa listevery enginethe source databases to move, all of them when left out
excludea list or a mappingevery enginedatabases, schemas or tables left alone - dotted names and patterns, or databases each with all, its tables or its schemas
objectsa mappingevery enginethe kinds of object beside the tables carried: views, routines, triggers, events, sequences, dictionaries, roles - each all (the default), none, or a list of names; one not carried is out of scope as an excluded table is
includea list or a mappingevery enginethe only databases, schemas or tables taken - moved, followed, checked and repaired - the rest left alone as if excluded; exclude wins where both name one. Written as exclude is
servicetextevery enginethe playbook migkit advise shows
big_rowsa whole numberevery engineread by nothing
slicea whole numberevery enginethe rows one compared range of a large table holds - a number migkit otherwise decides; leave it out unless its own choice failed you
workersa whole numberevery enginethe most workers migkit's own sizing may reach - a ceiling: migkit works the number out itself and never goes past this
optionsa mappingevery enginethe hop's options
db_mapa mappingevery enginesource database name -> target database name
mappinga mappingevery enginerenames, column rules, row filters, the changes carried per table (ops: insert, update, delete), and the percentage a table's aggregates may drift by when read a second way - keys under it: tables, columns, where, tolerance, ops, names

A hop's options

The keys under a hop's options:.

KeyWritten asRead onWhat it is
accept_changesa lista pair across two enginestable.column patterns whose values may arrive as the target keeps them
accessa mappingevery enginewho sees and does what on this hop in the web view and the API - viewer, operator, approver, admin - added to the file's own access - keys under it: viewer, operator, approver, admin
account_hosttextMySQLthe host part of a MySQL account made on the target for a user the source names without one (the default is any host, %)
accountstrue or falseevery enginefalse: the move does not carry users, roles or grants - the target's are made apart from it - so their checks are skipped and said as not compared, and no repair grants them (as objects: {roles: false})
app_rolesa listevery enginethe application's roles protect_target holds
application_sqltext or a lista pair across two engineswhere the application's code is on this machine: the SQL written in it is found, carried into the target's SQL and proved on the sandbox, and never changed
approvalsa mappingevery enginethe steps that wait for an approval - keys under it: steps, signers, count, expires
at_resta mappingevery enginewho may read the files holding values (recipients), and the directory on an encrypted or memory-backed volume where the files a program writes lie (scratch) - keys under it: recipients, scratch
bastiona mapping or textevery enginebastion jump host configuration for SSH/SSM port forwarding
tunnela mapping or textevery enginealias for bastion configuration
archivea mappingevery enginegoal archive: remove - the archived rows removed from the source once proved (with the source's answer, source_changes: {archived_rows: yes}), restore - the removed rows put back from the archive, batch - rows a batch - keys under it: remove, restore, batch
charsettext or a mappingevery enginethe character set, and the collation, the target's text is converted to - a name, or {to, collation, repair: double-encoded | none}; converted by MySQL's own conversion after the copy, held to elsewhere - keys under it: to, collation, repair
consolidatea mappingevery enginegoal consolidate: column - the column each source's rows are held under, value or values - this source's, keys - how keys two sources hold are kept apart (refuse, tenant, offset, remap or prefix), offsets - each value's under offset, with - the other hops writing the same target - keys under it: column, value, values, keys, offsets, with
index_advicetrue or falseevery engineindexes the translated workload needs, made on the target hypothetically and advised only where its own planner's estimate falls by half
nodesa mappingevery enginewhat only the operator knows of a many-node topology, read where migkit decides it: spaces - {source: {table: {range: [lo, hi], stride: [offset, step], values: [...]}}} the keys each source writes, conflict - the rule for a key two sources write (apply_remote, keep_local or last_update_wins), route - how a fan-out places a row (by table, range or hash, with tables or bounds), marks - {node: true} where the node tells migkit's writes apart - keys under it: spaces, conflict, route, marks
splita mappingevery enginegoal split: with - the other parts of the same source, shared - tables every part takes whole, rest - refuse or stays (the rows no part takes stay on the source) - keys under it: with, shared, rest
resharda mappingevery enginegoal reshard: with - the other hops of the group (their sources and targets the group's), by - auto, hash, range, list, lookup or target (the one target cluster's own distribution), key - {table: shard key columns}, shared - tables every target takes whole, ranges - {target hop: upper bound or null}, values - {target hop: [values]}, lookup - {value: target hop}, default - the target hop of a value not named - keys under it: with, by, key, shared, ranges, values, lookup, default
stream_laga numberAmazon Keyspacesseconds a Keyspaces change position is held behind the clock, for writes the service has not yet made readable
target_settingstext or a mapping or true or falseMySQLthe answer, given ahead, to a setting on the target a run needs raised: yes (migkit sets it for the run and puts the old value back, also after a killed run) or no - for every setting or by its name (max_allowed_packet: yes)
table_enginetext or a mappingMySQL, a pair across two enginesthe storage engine the target's tables are made in - a name, or {to, accept: [group numbering, remote rows], foreign_keys: {child.column: parent.column}} - keys under it: to, accept, foreign_keys
cdc_confidence_secondsa numberCassandraseconds the follow of a change log stays behind the source's clock
checksumtextPostgreSQLtext or jsonb row rendering
checksum_workersa whole numberPostgreSQLtables checksummed at once - a number migkit otherwise decides; leave it out unless its own choice failed you
closuretextevery enginewhat assess says of a table the hop takes that needs one it leaves out - a foreign key's parent, a view's, a routine's or a trigger's table, a sequence's owner, a partition: warn (each named, with the tables to take) or accept (said as accepted)
cloudtextevery enginethe cloud the servers run in - aws, gcp or azure - where their addresses and the servers do not say; the machine and the target's class are named in it
code_dirtexta pair across two engineswhere the operator's own versions of routines are kept, one <name>.sql each
builtin_suitestext or a lista pair across two engineswhere the engines' own test suites are on this machine: each case calling a function the source's code calls is run on both sandboxes, and the ones answered apart become the translator's rules
code_reference_daysa whole number or true or falsea pair across two enginesdays after the cutover the source's answers stay the reference the target's routines are held to (true: 30)
code_modela mappinga pair across two enginesthe model a routine no converter proves is asked of - keys under it: provider, url, model
code_model_roundsa whole numbera pair across two enginesrounds the model gets on one routine - a number migkit otherwise decides; leave it out unless its own choice failed you
compare_withtextevery engineanother tool's own check of this move - a Tencent or Alibaba DTS data check's report, AWS DMS's table statistics - held table by table against migkit's answers in the evidence
create_streamstrue or falseKinesis Data Streamscreate a missing stream
cutovera mapping or true or falseevery enginethe cutover as one timed path that freezes the source and undoes itself (migkit.cutover) - keys under it: budget, start_below, freeze, pooler, flip, flip_undo, keys, jobs, no_return, restore_points
ddltext or a mappingevery enginewhat a DDL on the source does to a running tail: stop it, park only the table it touched, or apply what can be carried at its place in the log - one word, or a mapping of default, tables or patterns to a word each, and skip: the kinds left out (truncate, drop, create)
deadlinetext or a numberevery enginewhen the move must be done by - a duration (6h, 90m, 2d) or a moment (2026-10-01T02:00): the plan names the cheapest machine for migkit that meets it
editiona mappingSQL Server, Oracle Database, MySQL, MongoDBwhat a change of edition may leave behind on the target - accept: [the features whose loss the hop accepts, as assess names them: encryption at rest, auditing, change data capture] - keys under it: accept
deeptrue or falseRediscompare every key's value, not a sample
exact_batchestrue or falseevery enginea one-way tail numbers its batches on the target, so a stop resumes after the last committed - false turns off one of the ways migkit may choose; left out, migkit chooses
follow_untiltextevery enginestopped or caught_up: how long a follow runs
exclude_schematextPostgreSQLschemas left out of the schema dump
export_buckettextDynamoDB, Firestore (native mode), Firestore in Datastore mode, Amazon Neptune, Amazon Timestreams3://bucket/prefix the source's own export of a table is written under, for a copy that reads the table off it
fence_timeouta whole numberevery engineseconds a fenced re-check waits
fk_scan_secondsa whole numberPostgreSQLthe budget of the orphaned-row scan
float_tolerancea numberPostgreSQL, Cassandra, CockroachDB, Aurora DSQLhow far two floats may differ
formattextKafka, Kinesis Data Streams, Google Pub/Subthe change stream's message format
keep_prooftrue or falseevery enginethe tail keeps every table's digest leaves up as it applies, so a check reads only what changed
keytext or a listAny other SQL enginethe key column(s) of a listed table
limitsa mappingevery enginewhat the move may take at most, kept to as hard limits by its plan (LIMITS): source_load (the share of the source's reads, 0.3 or 30%), money (in the currency transfer_price_per_gb is in), bytes_billed (a warehouse's), outage (the cutover's write outage, seconds), replica_lag (seconds the source's replica may fall behind), target_memory and target_connections - keys under it: source_load, money, bytes_billed, outage, replica_lag, target_memory, target_connections
lob_scan_secondsa whole numberMySQLthe budget of the large-value scan
masktext or a list or true or falseevery enginevalues reports show as salted hashes
mask_on_writea mappingevery engine[db.][schema.]table.column (names or patterns) -> null, constant <text>, hash or truncate <n>: written so into the target by every way that carries the table, and proved as written
transforma mappingevery engine[db.][schema.]table.column -> an expression of the column's value in the analytic SQL (lower(email)), run over each batch as it passes and over the source by the check; on_target: true lets the target rewrite it after the copy where that is cheaper
mask_keytextevery enginethe key a hash in mask_on_write is taken with - a reference to a secret (env:, file:, vault:, ...); the same value gives the same digest on every run
max_message_bytesa whole numberKafka, Kinesis Data Streams, Google Pub/Subthe largest message a stream takes
newer_winstextevery enginethe column that keeps the newer row
noise_prefixtextevery enginethe beginnings of the names of tables another tool keeps for itself, left out of everything (Hop.excluded), comma-separated
notifytext or a list or a mappingevery enginewho is told what the migration is doing - an address, a list of them, or {to, events, lag, detail}: the events told (verdict, drift, lag, cutover, approval, failure, fallback, done), the seconds a change tail may be behind, and whether an error's words are sent and not only its kind - keys under it: to, events, lag, detail
egresstext or a list or a mapping or true or falseevery enginewhat may leave the machine for this hop - none, or the kinds that may (notify, traces, assist, evidence, anchor), or {allow, to}: the kinds and the hosts they may go to - keys under it: allow, to
anchora mappingevery enginethe audit record's signed checkpoints, kept in a bucket whose Object Lock holds them unchangeable so a record rewritten later shows - the bucket, a prefix, a retention {mode: GOVERNANCE or COMPLIANCE, days}, and required: true to stop a writing command that cannot anchor (credentials are the machine's own, never here) - keys under it: bucket, prefix, region, endpoint_url, retention, required, allowed_signers
evidencea mappingevery enginethe evidence export: {sign: a private SSH key} it is signed with - keys under it: sign
offset_headertrue or falseKafkaeach message the copy carries keeps its source partition and offset in a header, so a group's position is placed on the target exactly
offsetstextKafkahow a copied topic's offsets are kept: auto gives a partition whose source offsets have no gap the very same offsets on the target, map also writes every other partition's source-to-target offsets into the target in the same transaction as the messages they describe, off copies as before - false turns off one of the ways migkit may choose; left out, migkit chooses
offsets_pad_limita whole numberKafkathe most records migkit may produce and then delete to make a partition's first offset the source's; a partition that needs more is copied without identical offsets - a ceiling: migkit works the number out itself and never goes past this
on_conflicttextevery enginesource-wins or keep-target
origin_tabletextevery enginekeep or drop: the table of migkit's batches on a one-way target (migkit_origin), taken away when the stream is torn down for good - at a --drop, and at the cutover's point of no return - once no tail of the hop runs
partition_bytextKafka, Kinesis Data Streams, Google Pub/Subthe column a stream partitions by
performancetextevery enginegate: a slower target fails the check
physicala mappingPostgreSQL, MySQL, SQL Serverthe target may be seeded from a copy of the source's pages, SQL Server's own backup restored, or a cloud's own copy (physical, backupseed, cloudseed), and how - keys under it: data, run, stop, start, restart, source, source_plugin, cloud, source_id, target_id, region, target_region, target_role_arn, kms_key, instance_class, way, subnet_group, security_groups, subscription, resource_group, location, project, address, upgrade, backup, restore_from, profile, role, product, zone, vpc, subnet, spec, storage
proof_sandboxtext or a mappinga pair across two enginesthe two scratch servers stored code, the constraints, the collations and the sized types are run and compared on, or docker for migkit to start them - keys under it: source, target, docker
productiontext or a listevery enginehost patterns of production servers: a target matching one is written only when the hop names it (production_target)
production_targettext or a listevery enginethe production server this hop writes to on purpose, by a name it answers to
protect_targettrue or falseevery enginethe application may not write the target while migkit moves into it: its rights taken where the engine grants rights, its access policy changed where the hop answers yes (target_access), its writes named before the cutover where nothing holds a writer
regiontextevery enginethe region the machine and the target's class are priced in, where the addresses do not say
rehearsestext or a mappingevery enginegoal rehearse: the hop this one rehearses, whose plan is forecast from what this one measures - its name, or {hop, databases: {this hop's database: that hop's}} - keys under it: hop, databases
repair_windowa whole numberevery engineseconds a writer is paused for a repair
replica_server_idsa listMySQLserver IDs of replicas known to the source MySQL server
replication_factora whole numberKafkaa created topic's replicas
reversetextevery engineat_cutover: a stream back starts at cutover
rulesa mappingevery enginequestions both sides must answer alike
samplea whole numberRedis, Kafkahow many keys or messages are compared
sap_licencetextOracle Database, SQL Server, Db2 (Linux, UNIX, Windows), Db2 for i, Db2 for z/OS, SAP ASE, hana, a pair across two engines, SAP application data (ODP)the licence of a database that holds an SAP system: full-use (bought apart from SAP, so a direct read is the customer's) or runtime (bought through SAP, which allows no direct read)
schedulea mappingevery enginewhen the hop runs by itself - keys under it: cron, timezone, run, args, catchup, pause_after_failures, max_duration, retry_window
schema_authoritytextevery enginewhich schema reading decides: schema-aware (the default) or every-reading
server_ida whole numberMySQLthe replica id the binlog reader uses
server_to_servertrue or false or a mappingPostgreSQLthe target may pull the rows from the source itself, with the objects that needs made on the servers for the copy and dropped after: true, or {source: host:port} where the target reaches the source at another address - keys under it: source
settlea numberevery engineseconds a re-check waits for a stream to settle - left out, none before a re-check of what a stream may still carry, and 2 between the proof's generations
share_tablestrue or false or textevery enginemachines share one move's tables: true, each table to one machine; ranges, a large table's ranges as well, every write held to the number of the claim that took it
shipa mappingevery enginethe seed may go on media where the link is too narrow (ship): the carrier (disk, snowball, databox, transfer_appliance), where it is written (path, or endpoint with bucket or container, prefix, region, profile, ca_bundle, credential), its model or capacity, where the far end reads it (load_from, load_endpoint, load_region, load_profile, load_credential), how long it takes to reach the far end as the operator states it (shipping), and who must have signed its manifest (signers) - keys under it: carrier, path, endpoint, bucket, container, prefix, region, profile, ca_bundle, model, capacity, load_from, load_endpoint, load_region, load_profile, shipping, signers, gather, credential, load_credential
slottext or a listPostgreSQLthe slot a pipeline migkit did not set up reads, which the fence waits for
standbytrue or falseevery enginethe same move run on two or more machines: one moves it, the others take it over from the last position committed once it stops renewing its lease, the target refusing the one that lost it
source_changestext or a mapping or true or falseevery enginethe answer, given ahead, to a change on the source a faster way needs: yes (migkit makes it and takes it off again), no or dba - for every change, or by its name (clone_plugin: yes)
seed_snapshottextevery enginethe manifest of the source volume's snapshot a block seed is carried from (written by blockseed.manifest): with seed_snapshot_parent only the blocks changed between the two travel
seed_snapshot_parenttextevery enginethe manifest of the snapshot of the same volume the target already holds
shardsa whole numberKinesis Data Streamsa created stream's shards
snapshot_limita numberPostgreSQLhow old a snapshot may get
source_enginetexta pair across two engines, SAP application data (ODP)the source's engine of a hetero hop
spool_limita whole numberevery enginebytes a parked table's changes may take on this machine before the table is copied again instead - a number migkit otherwise decides; leave it out unless its own choice failed you
statea mappingevery enginewhere run state is kept, and a directory every machine of the hop sees (shared) - keys under it: backend, bucket, prefix, region, endpoint_url, mirror, shared
subseta mappingevery enginegoal subset: the rows a copy for testing starts from - start: {table: a condition, a share like 10% or a number of rows} - whether the rows that refer to them come too (children), and the most rows it may hold (most) - keys under it: start, children, most
tablesa listAny other SQL enginethe tables of a generic hop
target_accesstext or true or falseDynamoDB, BigQuerythe answer, given ahead, to the change of the target's access policy protect_target offers where the engine's writes are allowed outside the data (a table's own policy, a dataset's access): yes - migkit makes it and gives it back at cutover - or no
target_enginetexta pair across two engines, SAP application data (ODP), MySQLthe target's engine of a hetero hop
target_has_replicastrue or falseMySQLfalse: the target has no replicas and no restore replays its binlog, so a load may leave the binlog off
target_rowstextevery enginerefuse, replace or keep: what a copy does with the rows a table on the target already holds
tombstonestrue or falseKafkacarry deletes' empty messages
topictextKafka, Kinesis Data Streams, Google Pub/Subthe stream name template
topologytextevery engineone_way or two_way
transfer_price_per_gba numberevery enginewhat a carried gigabyte costs
two_readingstrue or false or a mappingevery enginea second, independent reading of every table, row by row where it has a key (a table that differs is read twice whatever this says): true, or rows, sample and case_insensitive - keys under it: rows, sample, case_insensitive
two_waya mapping or true or falseevery enginemigkit's own tails both ways, a row both sides changed settled column by column: the rule of a column nothing names (on_conflict), each table's rules by column (tables), and what settles a row one side deleted - keys under it: on_conflict, column, source_rank, target_rank, delta, tables, delete_vs_update, delete_missing
types_from_datatrue or falsea pair across two enginesa column whose declaration leaves its domain open (a bare decimal, a text of no length) is built sized from the data it holds, each narrowing recorded and proved
verify_batchestrue or falseevery enginecompare a bulk copy with the source
versionsa mappingAmazon Redshift, Snowflake, BigQuery{table: the column whose value orders a row's versions}, for a warehouse fed from more than one place: rows arrive in any order, and a late row never overwrites a newer one
wal_archivetextPostgreSQLthe directory the write-ahead log is archived to, read after the live one
wal_dirtextPostgreSQLwhere the PostgreSQL write-ahead log is read from on this machine, when the data directory is not
workload_replaytrue or falseevery enginethe source's record of what the application ran, every statement on it translated, run on both sandboxes and compared by its answers and the rows it writes, and timed on both sides, weighted by how often each ran

A side's keys

A side written in the long form rather than as an address.

KeyWritten asRead onWhat it is
hosttextevery enginethe server's name or address
porta whole numberevery enginethe server's port
usertextevery enginethe user migkit signs in as
passworda reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name)every enginea reference to the password - env:, file:, vault:, keyring:, aws-sm:, gcp-sm:, azure-kv:
optionsa mappingevery enginethe endpoint's options, the same as writing them beside host

A side's options

The keys of a side's own options, under it or under its options: - most may also be written in its address.

KeyWritten asRead onWhat it is
api_keya reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name)Qdranta reference to the key the service is signed in with - env:, file:, vault:, keyring:
authtextPostgreSQL, MySQL, Aurora DSQL, Amazon Keyspaces, Amazon Neptune, SQL Serverpassword, or the cloud's own sign-in: aws_iam (rds-iam) for a token the cloud signs, cloudsql_iam for the cloud's access token, azure_managed_identity for the managed identity's token
authSourcetextMongoDBthe database the user is defined in
change_streamtextGoogle Cloud Spannerthe change stream the tail reads, where not one that watches every table in scope
changesa mappingTiDB, CockroachDB, Aurora DSQL, Couchbasewhere the source publishes its changes, where a client cannot read its log: a Kafka topic (servers, topic or topics, format, and how to sign in), a Kinesis stream (stream, region, cdc_stream, order_window), or a changefeed streamed to migkit (via: changefeed) - keys under it: via, servers, hosts, topic, topics, format, security_protocol, sasl_mechanism, user, ssl_cafile, stream, region, endpoint_url, cdc_stream, order_window, password
change_feedtextCosmos DB for NoSQLlatest: follow by the latest-version change feed, which carries no delete - where the account has no all-versions-and-deletes feed
collection_groupsa list or textFirestore (native mode)the collection groups read, each with every collection of its name
data_boosttrue or falseGoogle Cloud Spannertrue: reads go through Spanner's independent compute, away from the application's
decodingtextGaussDB (openGauss)the logical decoding slot or plugin the changes are read through
dialecttextGoogle Cloud Spannerthe SQL dialect of the Spanner database
emulatortextGoogle Cloud Spanner, Google Cloud Bigtable, Firestore (native mode), Firestore in Datastore mode, Google Pub/Subthe address of a local emulator the service is reached through instead of the cloud
graph_apitextAmazon Neptunethe query language the graph is read in: gremlin or opencypher
instancetextGoogle Cloud Spanner, Google Cloud Bigtablethe Spanner or Bigtable instance
key_propertytextNeo4jthe property that holds a node's key
labelsa listNeo4jthe node labels read
namespacetextFirestore (native mode), Firestore in Datastore modethe namespace of the documents
prioritytextCosmos DB for NoSQL, Google Cloud Spannerlow: reads yield to the application where the account runs priority-based execution
networktextCouchbaseexternal: reach the cluster's nodes at their alternate addresses
mgmt_porta whole numberCouchbasethe cluster manager's port, where not 8091 (18091 with TLS)
aws_regiontextPostgreSQL, MySQL, Kafkathe region an aws_iam token is signed for
aws_role_arntextPostgreSQL, MySQL, Kafkathe role an aws_iam token is signed as
rdf_defaulttextAmazon Neptunethe graph a triple with none is put in
retentiona mappingAmazon Timestreamhow long Timestream keeps what is written: memory_hours and magnetic_days - keys under it: memory_hours, magnetic_days
setsa list or a mappingPolarDB-X, TDSQL (distributed)the sets of a distributed cluster to read, each its own server
shardkeytext or a mapping or a listPolarDB-X, TDSQL (distributed)the columns each table is spread by, or none for a table that is not sharded: a name, or {table: columns | none}
sparqltextAmazon Neptunethe query that reads the RDF side
sparql_updatetextAmazon Neptunethe update that writes the RDF side
sslmodetextPostgreSQL, Amazon Redshift, TeradataTLS: disable ... verify-full
sslrootcerttextPostgreSQL, Amazon Redshift, Teradatathe authority's certificate file
logmechtextTeradatahow a Teradata side signs in, where not by its own password (LDAP, KRB5)
clienttextSAP application data (ODP)the SAP client the services are read in
languagetextSAP application data (ODP)the SAP logon language
service_pathtextSAP application data (ODP)where the SAP system publishes its OData services, where not /sap/opu/odata/sap
kindtextSaaS applications, read by a connector programhow a program source is spoken to - the kind of connector program it runs, its address's scheme
programtextSaaS applications, read by a connector programwhat a program source runs: a tap's command, a connector's image or command, a dlt source's module:function, a Salesforce org's sign-in host
configtextSaaS applications, read by a connector programthe file of a program's own settings, credentials included
streamstext or a listSaaS applications, read by a connector programthe streams (or objects) of a program source to read, all of them when left out
installtextSaaS applications, read by a connector programwhat installs a program source's program where it is not on this machine: a pip requirement, installed into an environment of its own
containertrue or falseSaaS applications, read by a connector programrun a connector as the container its image is, or as a program on this machine
api_versiontextSaaS applications, read by a connector programthe Salesforce API version the objects are read through
pubsub_endpointtextSaaS applications, read by a connector programwhere Salesforce's change events are read from (host:port)
pubsub_tlstrue or falseSaaS applications, read by a connector programTLS to the change events' endpoint: off only for a local stand-in
sslcerttextPostgreSQL, Amazon Redshifta client certificate file
sslkeytextPostgreSQL, Amazon Redshifta client key file
sslcrltextPostgreSQL, Amazon Redshifta revocation list file
ssltrue or falseMySQLTLS, nothing checked
ssl_catextMySQLthe authority's certificate file
ssl_certtextMySQLa client certificate file
ssl_keytextMySQLa client key file
ssl_verify_identitytrue or falseMySQLcheck the name on the certificate
hoststext or a listMongoDB, Kafkamore than one server
timeouta numberNeo4j, Qdrantseconds a request may take before it is given up
tunnel_bytextevery enginethe mechanism establishing the tunnel
typesa listNeo4jthe relationship types read
uri_optionstextMongoDBthe driver's own options
pathtextSQLite, DuckDB, Parquet files, Files described by COBOL copybooks, Delta tablesthe file or directory
tablesa mappingFiles described by COBOL copybookseach table of a directory of files described by COBOL copybooks: its file, copybook, record, recfm, lrecl, codepage, key, segment, redefines, odo, bytes and unreadable
codepagetextFiles described by COBOL copybooksthe EBCDIC code page the files' text is in (cp037, cp838, cp1047 ...)
recfmtextFiles described by COBOL copybooksthe files' record format: F, FB, V, VB or ZOSMF
unreadabletextFiles described by COBOL copybooksstop (the default) or null: a value that is not one stops the read, or lands as NULL and is listed
odotextFiles described by COBOL copybooksactual (the default) or max: whether a table OCCURS DEPENDING ON its count takes the room of its count or of its most
urltextAny other SQL engine, OpenSearch, Parquet files, Delta tables, Snowflake, Couchbase, Cosmos DB for NoSQLthe whole connection address (Snowflake's account URL a streaming channel signs in at, a Cosmos DB account's endpoint, a Couchbase connection string)
securetrue or falseClickHouseTLS
address_from_targettextClickHousehost:port the target reaches the source at, where it knows it by another name
servicetextOracle Databasethe service to connect to
service_nametextOracle Databasethe service to connect to
mine_servicetextOracle Databasethe container's root service, where the redo is mined from there (a database before 21c)
mine_usertextOracle Databasethe user the redo is mined as, where not the side's own
mine_passworda reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name)Oracle Databasethat user's password reference
mine_standbytextOracle Databasea physical standby of the source the redo is mined on instead (host:port/service)
mine_off_sourcetrue or falseOracle Databasethe source mines nothing: its redo is mined on the standby or the mining database named
mine_instancetextOracle Databasea database migkit mines the source's shipped archived redo on (host:port/service)
mine_instance_usertextOracle Databasethe user that database is mined as, where not the side's own
mine_instance_passworda reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name)Oracle Databasethat user's password reference
archive_fromtextOracle Databasewhere the source's archived redo is read (a directory or an object store)
archive_totextOracle Databasewhere the mining database reads the shipped archived redo
archive_seen_astextOracle Databasethat place's path as the mining database sees it, where not the same
redo_readertextOracle Databasewhere a redo-file reader run beside the redo listens (host:port)
redo_reader_dsntextOracle Databasehow that reader reaches the database, where not as migkit does
redo_reader_mba whole numberOracle Databasethe memory that reader may take, in MB - a number migkit otherwise decides; leave it out unless its own choice failed you
databasetextDb2 (Linux, UNIX, Windows), Db2 for i, Db2 for z/OS, Amazon Redshift, Snowflake, BigQuerythe database to connect to (a z/OS subsystem's location name, an IBM i system's relational database)
accounttextSnowflakethe account identifier
warehousetextSnowflake, Iceberg tablesthe warehouse queries run in (Snowflake), where new tables' files go (Iceberg)
roletextSnowflakethe role queries run as
authenticatortextSnowflakehow the side signs in, where not by password
private_key_filetextSnowflakea key pair's private key file, which a streaming channel signs in with
private_key_passphrasea reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name)Snowflakethe private key's passphrase
locationtextBigQuerythe datasets' region
credentials_filetextBigQuery, Google Pub/Suba service account's key file
anonymoustrue or falseBigQuerysign in as nobody, which only an emulator takes
api_endpointtextBigQuerythe API's address, a private one or an emulator's
write_endpointtextBigQuerythe Storage Write API's host:port
stagetextAmazon Redshift, CockroachDBan S3 prefix the cluster reads staged files from
iam_roletextAmazon Redshift, Amazon Neptunethe role the cluster reads the stage as
stage_regiontextAmazon Redshiftthe stage bucket's region
stage_endpoint_urltextAmazon Redshiftthe stage's S3-compatible endpoint
iamtrue or falseAmazon Redshiftsign in by IAM rather than a password
cluster_identifiertextAmazon Redshiftthe provisioned cluster an IAM sign-in is for
serverless_work_grouptextAmazon Redshiftthe Serverless workgroup an IAM sign-in is for
profiletextAmazon Redshiftthe AWS profile an IAM sign-in uses
db_usertextAmazon Redshiftthe database user an IAM sign-in becomes
catalogtextIceberg tablesthe Iceberg catalog: sqlite:///... or another SQL database's URL, or a REST catalog's http(s) address
catalog_nametextIceberg tablesthe name the catalog keeps its tables under
catalog_propertiesa mappingIceberg tablesanything else the catalog takes
projecttextGoogle Pub/Sub, Google Cloud Bigtable, Firestore (native mode), Firestore in Datastore mode, Google Cloud Spannerthe project
regiontextDynamoDB, Kinesis Data Streams, Parquet files, Amazon Redshift, Delta tables, Aurora DSQL, Amazon Keyspaces, Amazon Neptune, Amazon Timestreamthe region
endpoint_urltextDynamoDB, Kinesis Data Streams, Parquet files, Delta tables, Amazon Keyspaces, Amazon Timestreaman endpoint of its own (a local one, a compatible store)
table_prefixtextDynamoDBthe table names' template
index_prefixtextOpenSearchthe index names' template
tlstrue or falseOpenSearch, Db2 for i, Couchbase, Cosmos DB for NoSQL, SAP application data (ODP), Oracle Database, Amazon Neptune, MongoDB, Redis, CassandraTLS, the certificate checked against the system's authorities (https on OpenSearch, Cosmos DB and SAP)
tls_ca_filetextDb2 for i, Couchbase, SAP application data (ODP), Oracle Database, MongoDB, Redis, Cassandrathe authorities' certificates file
tls_cert_filetextMongoDB, Redis, Cassandraa client certificate file
tls_key_filetextRedis, Cassandraa client key file
tls_crl_filetextMongoDBa revocation list file
tls_insecuretrue or falseDb2 for i, Couchbase, Cosmos DB for NoSQL, SAP application data (ODP), Oracle Database, MongoDB, Redis, CassandraTLS with nothing checked (an emulator's own certificate)
encrypttext or true or falseSQL Serverrequire, request or off
redis_producttextRediscommunity, cloud or software: the Redis product the target is, where its name cannot say
rdb_filetextRedisa backup file of the source's keyspace, read in its place so the server is left alone
aof_filetextRedisthe source's append-only file, read in its place
aof_timestampa whole numberRedisthe moment, in seconds since the epoch, the append-only file is read up to
snapshota mappingOpenSearcha snapshot of the source an index may be copied from: its name, its repository on the source, and where its files are - keys under it: name, repository, local_dir, s3_uri, s3_region
verifytrue or falseOpenSearchcheck the certificate
odbc_drivertextSAP ASEthe ODBC driver's file
replicationtext or a mappingCassandraa created keyspace's replication
security_protocoltextKafkaPLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
sasl_mechanismtextKafkahow SASL signs in
ssl_cafiletextKafkathe authority's certificate file
schema_registrytextKafkathe schema registry's address
schema_registry_usertextKafkathe schema registry's user
schema_registry_passworda reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name)Kafkathe schema registry's password
manageda mappingevery enginethe managed service this side is and how its provider's API reaches it: service (its name in the managed-service catalogue, where neither its address nor its server says), id (its instance at the provider, where its address does not find it), region, profile (the provider CLI's profile its credentials come from), role (one assumed), and what else the provider asks for - keys under it: service, id, region, profile, role, project, subscription, resource_group, compartment, project_id, zone, cluster, vpc, subnet, spec, storage
tunneltext or a mappingevery enginereach the server through a tunnel
tunnel_totextevery enginewhat carries the connection, for the report
bastiona mapping or textevery enginebastion jump host configuration for SSH/SSM port forwarding
admintext or a listNeo4jthe neo4j-admin command or path
azure_client_idtextevery enginethe managed identity client ID on Azure
dump_dirtextNeo4ja directory for neo4j database dumps
log_standbytextSQL Servera SQL Server log standby directory or secondary database name
recall_ka whole numberQdrantthe k nearest neighbours evaluated for vector recall
stop_databasetrue or falseNeo4jwhether neo4j-admin may stop a database for dump
transactionstrue or falseDynamoDBwhether DynamoDB uses TransactWriteItems or writes without
_original_hosttextevery engineinternal recording of original endpoint host before bastion tunnel rebinding
_original_porta whole numberevery engineinternal recording of original endpoint port before bastion tunnel rebinding

6 more keys turn one named way of migkit's on or off; migkit doctor says what each does on a hop that sets one.