[GitHub] [ignite] Silberfuchs1 commented on a change in pull request #9874: IGNITE-16246 CDC extensions documentation

[GitBox <gi...@apache.org>]

Silberfuchs1 commented on a change in pull request #9874:
URL: https://github.com/apache/ignite/pull/9874#discussion_r822568792



##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.

Review comment:
       CDC is an experimental feature. API or design architecture might be changed.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.

Review comment:
       two way --> two ways
   to setup --> to set up

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.

Review comment:
       [Ignite2IgniteCdcStreamer] streams changes to destination cluster using client node.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.

Review comment:
       You don't need "which" here. 

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024

Review comment:
       sent --> send
   
   or
   
   Maximum number of events to be sent  to destination cluster in a single batch

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.

Review comment:
       This streamer starts client node which connects to destination cluster. After connection is established, all changes captured by CDC will be replicated to destination cluster.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.

Review comment:
       that will read ... and then write them...

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`

Review comment:
       that is primary --> that are primary

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`

Review comment:
       request (if not a verb)

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:

Review comment:
       You need an ordered list here. It a sequence of actions (till line 110).

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.

Review comment:
       'kafka-to-ignite.sh' will read ... and then apply them to the destination cluster.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`

Review comment:
       nodes that is primary for partition --> nodes that are primary for partition?

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`

Review comment:
       requests --> request

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16

Review comment:
       fashion --> manner

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.

Review comment:
       new (from update request)
   
   existing (stored in the cluster)

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.

Review comment:
       At the same time

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.
+
+For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+Default link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/conflictresolve/CacheVersionConflictResolverImpl.java[implementation] available in cdc-ext.
+
+==== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `clusterId` | Local cluster id. Can be any value from 1 to 31. | null
+| `caches` | Set of cache names to handle with this plugin instance. | null
+| `conflictResolveField` | Value field to resolve conflict with. Optional. Field values must implements `java.lang.Comparable`. | null

Review comment:
       must implement

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.
+
+For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+Default link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/conflictresolve/CacheVersionConflictResolverImpl.java[implementation] available in cdc-ext.
+
+==== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `clusterId` | Local cluster id. Can be any value from 1 to 31. | null
+| `caches` | Set of cache names to handle with this plugin instance. | null
+| `conflictResolveField` | Value field to resolve conflict with. Optional. Field values must implements `java.lang.Comparable`. | null
+|===
+
+==== Conflict resolve algorithm
+
+Replicated changes contains some additional data. Specifically, entry version from source cluster supplied with the changed data.
+Default conflict resolve algorithm based on entry version and `conflictResolveField`.
+Conflict resolution field should contain user provided monotonically increasing value such as query id or timestamp.
+
+. Changes from the "local" cluster always win.
+. If both old and new entry from the same cluster version comparsion used to determine order.
+. If `conflictResolveField` provided then field values comparsion used to determine order.

Review comment:
       is provided
   
   comparsion --> comparison

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.
+
+For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+Default link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/conflictresolve/CacheVersionConflictResolverImpl.java[implementation] available in cdc-ext.
+
+==== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `clusterId` | Local cluster id. Can be any value from 1 to 31. | null
+| `caches` | Set of cache names to handle with this plugin instance. | null
+| `conflictResolveField` | Value field to resolve conflict with. Optional. Field values must implements `java.lang.Comparable`. | null
+|===
+
+==== Conflict resolve algorithm
+
+Replicated changes contains some additional data. Specifically, entry version from source cluster supplied with the changed data.

Review comment:
       changes contain
   
   

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.

Review comment:
       selects

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.

Review comment:
       will capture --> that will capture

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.

Review comment:
       to Kafka

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`

Review comment:
       When streamer reaches this number, it waits for Kafka acknowledgement, and then commits CDC offset.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.

Review comment:
       not corellates --> does not correlate

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1

Review comment:
       Kafka

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.

Review comment:
       Make a NOTE, or an ATTENTION here (line 111).

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`

Review comment:
       Kafka

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:

Review comment:
       following beans which be loaded --> following beans that will be loaded

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.

Review comment:
       You need an empty line between 109 and 110, 110 and 111 to split the sentences.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1

Review comment:
       Kafka

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024

Review comment:
       Maximum number of events to be sent to destination cluster in a single batch.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.

Review comment:
       It is expected...
   
   failure resistance --> fault-tolerance

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.
+
+For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.

Review comment:
       link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined for each cache replicated between clusters.

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.
+
+For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+Default link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/conflictresolve/CacheVersionConflictResolverImpl.java[implementation] available in cdc-ext.
+
+==== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `clusterId` | Local cluster id. Can be any value from 1 to 31. | null
+| `caches` | Set of cache names to handle with this plugin instance. | null
+| `conflictResolveField` | Value field to resolve conflict with. Optional. Field values must implements `java.lang.Comparable`. | null
+|===
+
+==== Conflict resolve algorithm
+
+Replicated changes contains some additional data. Specifically, entry version from source cluster supplied with the changed data.
+Default conflict resolve algorithm based on entry version and `conflictResolveField`.
+Conflict resolution field should contain user provided monotonically increasing value such as query id or timestamp.
+
+. Changes from the "local" cluster always win.
+. If both old and new entry from the same cluster version comparsion used to determine order.

Review comment:
       comparsion --> comparison

##########
File path: docs/_docs/persistence/change-data-capture.adoc
##########
@@ -129,4 +129,9 @@ IMPORTANT: `ignite-cdc.sh` implements the fail-fast approach. It just fails in c
  3. Load the saved state.
  4. Start the consumer.
  5. Infinitely wait for the newly available segment and process it.
- 6. Stop the consumer in case of a failure or a received stop signal.
\ No newline at end of file
+ 6. Stop the consumer in case of a failure or a received stop signal.
+
+== cdc-ext
+
+Ignite extensions project has link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[cdc-ext] module which provides two way to setup cross cluster replication based on CDC.

Review comment:
       two ways to set up

##########
File path: docs/_docs/persistence/change-data-capture-extensions.adoc
##########
@@ -0,0 +1,188 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+= Change Data Capture Extension
+
+WARNING: CDC is an experimental feature whose API or design architecture might be changed.
+
+== Overview
+link:https://github.com/apache/ignite-extensions/tree/master/modules/cdc-ext[Change Data Capture Extension] module provides two way to setup cross cluster replication based on CDC.
+
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/IgniteToIgniteCdcStreamer.java[Ignite2IgniteCdcStreamer] - stream changes to destination cluster using client node.
+. link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/IgniteToKafkaCdcStreamer.java[Ignite2KafkaCdcStreamer] combined with link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/kafka/KafkaToIgniteCdcStreamer.java[KafkaToIgniteCdcStreamer] streams changes to destination cluster using link:https://kafka.apache.org[Apache Kafka] as a transport.
+
+NOTE: For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+
+
+== Ignite to Ignite CDC streamer
+This streamer starts client node which connects to destination cluster and then all changes captured by CDC replicated to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2ignite.svg[]
+
+== Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `destinationIgniteConfiguration` | Ignite configuration of client nodes that will connect to destination cluster to replicate changes. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+|===
+
+== Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+|===
+
+== CDC replication using Kafka
+
+This way to replicate changes between clusters requires setting up two applications:
+
+. `ignite-cdc.sh` with `org.apache.ignite.cdc.kafka.IgniteToKafkaCdcStreamer` will capture changes from source cluster and write it to Kafka topic.
+. `kafka-to-ignite.sh` will read changes from Kafka topic and write them to destination cluster.
+
+NOTE: Instances of `ignite-cdc.sh` with configured streamer should be started on each server node of source cluster to capture all changes.
+
+image:../../assets/images/integrations/CDC-ignite2kafka.svg[]
+
+=== IgniteToKafkaCdcStreamer Configuration
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `kafkaProperties` | Kafka producer properties. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaParts` | Number of Kafka topic partitions. | null
+| `onlyPrimary` | Flag to handle changes only on nodes that is primary for partition. | `false`
+| `maxBatchSize` | Maximum size of concurrently produced kafka records. When streamer reach this number it will wait kafka acknowledges and commit CDC offset.  | `1024`
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+|===
+
+=== IgniteToKafkaCdcStreamer Metrics
+
+|===
+|Name |Description
+| `EventsCount` | Count of messages applied to destination cluster.
+| `LastEventTime` | Timestamp of last applied event.
+| `BytesSent` | Number of bytes sent to the Kafka.
+|===
+
+=== `kafka-to-ignite.sh` application
+
+This application should be started near the destination cluster.
+It will read CDC events from Kafka topic and apply them to destination cluster.
+
+IMPORTANT: `kafka-to-ignite.sh` implements the fail-fast approach. It just fails in case of any error. The restart procedure should be configured with the OS tools.
+
+Count of instances of the application not corellates to the count of destination server nodes.
+It should be just enough to process source cluster load.
+Each instance of application will process configured subset of topic partitions to spread the load.
+`KafkaConsumer` for each partition will be created to ensure fair reads.
+
+==== Installation
+
+Build `cdc-ext` module with maven:
+```console
+  $~/src/ignite-extensions/> mvn clean package -DskipTests
+  $~/src/ignite-extensions/> ls modules/cdc-ext/target | grep zip
+ignite-cdc-ext.zip
+```
+
+Unpack `ignite-cdc-ext.zip` archive to `$IGNITE_HOME` folder.
+Now, you have additional binary `$IGNITE_HOME/bin/kafka-to-ignite.sh` and `$IGNITE_HOME/libs/optional/ignite-cdc-ext` module.
+Please, enable `ignite-cdc-ext` to be able to run `kafka-to-ignite.sh`.
+
+==== Configuration
+
+Application configuration should be done using POJO classes or Spring xml file like regular Ignite node configuration.
+Kafka to ignite configuration file should contain the following beans which be loaded during startup:
+
+. `IgniteConfiguration` bean: Configuration of the client node that will connect to the destination cluster.
+. `java.util.Properties` bean with the name `kafkaProperties`: Single Kafka consumer configuration.
+. `org.apache.ignite.cdc.kafka.KafkaToIgniteCdcStreamerConfiguration` bean: Options specific to `kafka-to-ignite.sh` application.
+
+[cols="20%,45%,35%",opts="header"]
+|===
+|Name |Description | Default value
+| `caches` | Set of cache names to replicate. | null
+| `topic` | Name of the Kafka topic. | null
+| `kafkaPartsFrom` | Lower kafka partitions number (inclusive). | -1
+| `kafkaPartsTo` | Lower kafka partitions number (exclusive). | -1
+| `kafkaRequestTimeout` | Kafka requests timeout in milliseconds.  | `3000`
+| `maxBatchSize` | Maximum number of events to sent in single batch to destination cluster. | 1024
+| `threadCount` | Count of threads to proceed consumers. Each thread poll records from dedicated partitions in round-robin fashion. | 16
+|===
+
+==== Logging
+
+`kakfa-to-ignite.sh` uses the same logging configuration as the Ignite node does. The only difference is that the log is written in the "kafka-ignite-streamer.log" file.
+
+== CacheVersionConflictResolver implementation
+
+It expected that CDC streamers will be configured with the `onlyPrimary=false` in most real-world deployments to ensure failure resistance.
+That means streamer will send the same change several times equal to `CacheConfiguration#backups` + 1.
+In the same time concurrent updates of the same key can be done in replicated clusters.
+`CacheVersionConflictResolver` used by Ignite node to select or merge new(from update request) and existing(stored in the cluster) entry versions.
+Selected entry version will be actually stored in the cluster.
+
+NOTE: Default implementation only select correct entry and never merge.
+
+For each cache which replicated between clusters link:https://github.com/apache/ignite/blob/master/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/version/CacheVersionConflictResolver.java[CacheVersionConflictResolver] should be defined.
+Default link:https://github.com/apache/ignite-extensions/blob/master/modules/cdc-ext/src/main/java/org/apache/ignite/cdc/conflictresolve/CacheVersionConflictResolverImpl.java[implementation] available in cdc-ext.

Review comment:
       is available




-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: notifications-unsubscribe@ignite.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org