Add stats APIs

_config.yml

@@ -45,6 +45,9 @@ collections:
   im-plugin:
     permalink: /:collection/:path/
     output: true
+  replication-plugin:
+    permalink: /:collection/:path/
+    output: true
   monitoring-plugins:
     permalink: /:collection/:path/
     output: true
@@ -81,6 +84,9 @@ just_the_docs:
     im-plugin:
       name: Index management plugin
       nav_fold: true
+    replication-plugin:
+      name: Replication plugin
+      nav_fold: true
     monitoring-plugins:
       name: Monitoring plugins
       nav_fold: true

_monitoring-plugins/ad/index.md

@@ -17,21 +17,24 @@ Anomaly detection  automatically detects anomalies in your OpenSearch data in ne
 
 You can pair the anomaly detection plugin with the [alerting plugin]({{site.url}}{{site.baseurl}}/monitoring-plugins/alerting/) to notify you as soon as an anomaly is detected.
 
+To use the anomaly detection plugin, your computer needs to have more than one CPU core.
+{: .note }
+
 ## Get started with Anomaly Detection
 
 To get started, choose **Anomaly Detection** in OpenSearch Dashboards.
-To first test with sample streaming data, you can try out one of the preconfigured detectors with one of the sample datasets.
+To first test with sample streaming data, choose **Sample Detectors** and try out one of the preconfigured detectors.
 
-### Step 1: Define a detector
+### Step 1: Create a detector
 
-A detector is an individual anomaly detection task. You can define multiple detectors, and all the detectors can run simultaneously, with each analyzing data from different sources.
+A detector is an individual anomaly detection task. You can create multiple detectors, and all the detectors can run simultaneously, with each analyzing data from different sources.
 
-1. Choose **Create detector**.
+1. Choose **Create Detector**.
 1. Enter a name and brief description. Make sure the name is unique and descriptive enough to help you to identify the purpose of the detector.
 1. For **Data source**, choose the index you want to use as the data source. You can optionally use index patterns to choose multiple indices.
-1. (Optional) For **Data filter**, filter the index you chose as the data source. From the **Data filter** menu, choose **Add data filter**, and then design your filter query by selecting **Field**, **Operator**, and **Value**, or choose **Use query DSL** and add your own JSON filter query.
 1. Select the **Timestamp field** in your index.
-1. For **Operation settings**, define the **Detector interval**, which is the time interval at which the detector collects data.
+1. (Optional) For **Data filter**, filter the index you chose as the data source. From the **Filter type** menu, choose  **Visual filter**, and then design your filter query by selecting **Fields**, **Operator**, and **Value**, or choose **Custom Expression** and add your own JSON filter query.
+1. For **Detector operation settings**, define the **Detector interval**, which is the time interval at which the detector collects data.
 - The detector aggregates the data in this interval, then feeds the aggregated result into the anomaly detection model.
 The shorter you set this interval, the fewer data points the detector aggregates.
 The anomaly detection model uses a shingling process, a technique that uses consecutive data points to create a sample for the model. This process needs a certain number of aggregated data points from contiguous intervals.
@@ -41,49 +44,42 @@ Set the window delay to shift the detector interval to account for this delay.
 - For example, say the detector interval is 10 minutes and data is ingested into your cluster with a general delay of 1 minute.
 Assume the detector runs at 2:00. The detector attempts to get the last 10 minutes of data from 1:50 to 2:00, but because of the 1-minute delay, it only gets 9 minutes of data and misses the data from 1:59 to 2:00.
 Setting the window delay to 1 minute shifts the interval window to 1:49 - 1:59, so the detector accounts for all 10 minutes of the detector interval time.
-1. Choose **Next**.
+1. Choose **Create**.
 
-After you define the detector, the next step is to configure the model.
+After you create the detector, the next step is to add features to it.
 
-### Step 2: Configure the model
-
-#### Add features to your detector
+### Step 2: Add features to your detector
 
 A feature is the field in your index that you want to check for anomalies. A detector can discover anomalies across one or more features. You must choose an aggregation method for each feature: `average()`, `count()`, `sum()`, `min()`, or `max()`. The aggregation method determines what constitutes an anomaly.
 
 For example, if you choose `min()`, the detector focuses on finding anomalies based on the minimum values of your feature. If you choose `average()`, the detector finds anomalies based on the average values of your feature.
 
-A multi-feature model correlates anomalies across all its features. The [curse of dimensionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality) makes it less likely for multi-feature models to identify smaller anomalies as compared to a single-feature model. Adding more features might negatively impact the [precision and recall](https://en.wikipedia.org/wiki/Precision_and_recall) of a model. A higher proportion of noise in your data might further amplify this negative impact. Selecting the optimal feature set is usually an iterative process. By default, the maximum number of features for a detector is 5. You can adjust this limit with the `plugins.anomaly_detection.max_anomaly_features` setting.
+A multi-feature model correlates anomalies across all its features. The [curse of dimensionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality) makes it less likely for multi-feature models to identify smaller anomalies as compared to a single-feature model. Adding more features might negatively impact the [precision and recall](https://en.wikipedia.org/wiki/Precision_and_recall) of a model. A higher proportion of noise in your data might further amplify this negative impact. Selecting the optimal feature set is usually an iterative process. We recommend experimenting with a historical detector with different feature sets and checking the precision before moving on to real-time detectors. By default, the maximum number of features for a detector is 5. You can adjust this limit with the `plugins.anomaly_detection.max_anomaly_features` setting.
 {: .note }
 
-1. On the **Configure Model** page, enter the **Feature name** and check **Enable feature**.
-1. For **Find anomalies based on**, choose the method to find anomalies. For **Field Value**, choose the **aggregation method**. Or choose **Custom expression**, and add your own JSON aggregation query.
-1. Select a field.
+1. On the **Model configuration** page, enter the **Feature name**.
+1. For **Find anomalies based on**, choose the method to find anomalies. For **Field Value** menu, choose the **field** and the **aggregation method**. Or choose **Custom expression**, and add your own JSON aggregation query.
 
-#### (Optional) Set category fields for high cardinality
+#### (Optional) Set a category field for high cardinality
 
 You can categorize anomalies based on a keyword or IP field type.
 
 The category field categorizes or slices the source time series with a dimension like IP addresses, product IDs, country codes, and so on. This helps to see a granular view of anomalies within each entity of the category field to isolate and debug issues.
 
-To set a category field, choose **Enable a category field** and select a field. You can’t change the category fields after you create the detector.
+To set a category field, choose **Enable a category field** and select a field.
 
 Only a certain number of unique entities are supported in the category field. Use the following equation to calculate the recommended total number of entities supported in a cluster:
 
 ```
-(data nodes * heap size * anomaly detection maximum memory percentage) / (entity model size of a detector)
+(data nodes * heap size * anomaly detection maximum memory percentage) / (entity size of a detector)
 ```
 
-To get the entity model size of a detector, use the [profile detector API]({{site.url}}{{site.baseurl}}/monitoring-plugins/ad/api/#profile-detector). You can adjust the maximum memory percentage with the `plugins.anomaly_detection.model_max_size_percent` setting.
-
 This formula provides a good starting point, but make sure to test with a representative workload.
 {: .note }
 
-For example, for a cluster with three data nodes, each with 8 GB of JVM heap size, a maximum memory percentage of 10% (default), and the entity model size of the detector as 1MB: the total number of unique entities supported is (8.096 * 10^9 * 0.1 / 1 MB ) * 3 = 2429.
+For example, for a cluster with 3 data nodes, each with 8G of JVM heap size, a maximum memory percentage of 10% (default), and the entity size of the detector as 1MB: the total number of unique entities supported is (8.096 * 10^9 * 0.1 / 1M ) * 3 = 2429.
 
-If the actual total number of unique entities higher than this number that you calculate (in this case: 2429), the anomaly detector makes its best effort to model the extra entities. The detector prioritizes entities that occur more often and are more recent.
-
-#### (Advanced settings) Set a shingle size
+#### Set a shingle size
 
 Set the number of aggregation intervals from your data stream to consider in a detection window. It’s best to choose this value based on your actual data to see which one leads to the best results for your use case.
 
@@ -96,27 +92,12 @@ For sample previews, the anomaly detection plugin selects a small number of data
 
 Examine the sample preview and use it to fine-tune your feature configurations (for example, enable or disable features) to get more accurate results.
 
-1. Choose **Preview sample anomalies**.
-    - If you don't see any sample anomaly result, check the detector interval and make sure you have more than 400 data points for some entities during the preview date range.
-1. Choose **Next**.
+1. Choose **Save and start detector**.
+1. Choose between automatically starting the detector (recommended) or manually starting the detector at a later time.
 
-### Step 3: Set up detector jobs
+### Step 3: Observe the results
 
-To start a real-time detector to find anomalies in your data in near real-time, check **Start real-time detector automatically (recommended)**.
-
-Alternatively, if you want to perform historical analysis and find patterns in long historical data windows (weeks or months), check **Run historical analysis detection** and select a date range (at least 128 detection intervals).
-
-Analyzing historical data helps you get familiar with the anomaly detection plugin. You can also evaluate the performance of a detector with historical data to further fine-tune it.
-
-We recommend experimenting with historical analysis with different feature sets and checking the precision before moving on to real-time detectors.
-
-### Step 4: Review and create
-
-Review your model configuration and select **Create detector**.
-
-### Step 5: Observe the results
-
-Choose the **Real-time results** or **Historical analysis** tab. For real-time results, you need to wait for some time to see the anomaly results. If the detector interval is 10 minutes, the detector might take more than an hour to start, as it's waiting for sufficient data to generate anomalies.
+Choose the **Anomaly results** tab. You need to wait for some time to see the anomaly results. If the detector interval is 10 minutes, the detector might take more than an hour to start, as it's waiting for sufficient data to generate anomalies.
 
 A shorter interval means the model passes the shingle process more quickly and starts to generate the anomaly results sooner.
 Use the [profile detector]({{site.url}}{{site.baseurl}}/monitoring-plugins/ad/api#profile-detector) operation to make sure you have sufficient data points.
@@ -125,12 +106,12 @@ If you see the detector pending in "initialization" for longer than a day, aggre
 
 ![Anomaly detection results]({{site.url}}{{site.baseurl}}/images/ad.png)
 
-Analyze anomalies with the following visualizations:
+Analize anomalies with the following visualizations:
 
 - **Live anomalies** - displays live anomaly results for the last 60 intervals. For example, if the interval is 10, it shows results for the last 600 minutes. The chart refreshes every 30 seconds.
-- **Anomaly history** (for historical analysis) / **Anomaly overview** (for real-time results) - plots the anomaly grade with the corresponding measure of confidence.
-- **Anomaly occurrence** - shows the `Start time`, `End time`, `Data confidence`, and `Anomaly grade` for each detected anomaly.
+- **Anomaly history** - plots the anomaly grade with the corresponding measure of confidence.
 - **Feature breakdown** - plots the features based on the aggregation method. You can vary the date-time range of the detector.
+- **Anomaly occurrence** - shows the `Start time`, `End time`, `Data confidence`, and `Anomaly grade` for each detected anomaly.
 
 `Anomaly grade` is a number between 0 and 1 that indicates how anomalous a data point is. An anomaly grade of 0 represents “not an anomaly,” and a non-zero value represents the relative severity of the anomaly.
 
@@ -138,13 +119,12 @@ Analyze anomalies with the following visualizations:
 
 If you set the category field, you see an additional **Heat map** chart. The heat map correlates results for anomalous entities. This chart is empty until you select an anomalous entity. You also see the anomaly and feature line chart for the time period of the anomaly (`anomaly_grade` > 0).
 
-Choose and drag over the anomaly line chart to zoom in and see a more detailed view of an anomaly.
+Choose a filled rectangle to see a more detailed view of the anomaly.
 {: .note }
 
-
 ### Step 4: Set up alerts
 
-Under **Real-time results**, choose **Set up alerts** and configure a monitor to notify you when anomalies are detected. For steps to create a monitor and set up notifications based on your anomaly detector, see [Monitors]({{site.url}}{{site.baseurl}}/monitoring-plugins/alerting/monitors/).
+Choose **Set up alerts** and configure a monitor to notify you when anomalies are detected. For steps to create a monitor and set up notifications based on your anomaly detector, see [Monitors]({{site.url}}{{site.baseurl}}/monitoring-plugins/alerting/monitors/).
 
 If you stop or delete a detector, make sure to delete any monitors associated with it.
 
@@ -153,12 +133,33 @@ If you stop or delete a detector, make sure to delete any monitors associated wi
 To see all the configuration settings for a detector, choose the **Detector configuration** tab.
 
 1. To make any changes to the detector configuration, or fine tune the time interval to minimize any false positives, go to the **Detector configuration** section and choose **Edit**.
-- You need to stop real-time and historical analysis to change its configuration. Confirm that you want to stop the detector and proceed.
+- You need to stop the detector to change its configuration. Confirm that you want to stop the detector and proceed.
 1. To enable or disable features, in the **Features** section, choose **Edit** and adjust the feature settings as needed. After you make your changes, choose **Save and start detector**.
+- Choose between automatically starting the detector (recommended) or manually starting the detector at a later time.
 
-### Step 8: Manage your detectors
+### Step 6: Analyze historical data
 
-To start, stop, or delete a detector, go to the **Detectors** page.
+Analyzing historical data helps you get familiar with the anomaly detection plugin. You can also evaluate the performance of a detector with historical data to further fine-tune it.
 
-1. Choose the detector name.
-2. Choose **Actions** and select **Start real-time detectors**, **Stop real-time detectors**, or **Delete detectors**.
+To use a historical detector, you need to specify a date range that has data present in at least 1,000 detection intervals.
+{: .note }
+
+1. Choose **Historical detectors** and **Create historical detector**.
+1. Enter the **Name** of the detector and a brief **Description**.
+1. For **Data source**, choose the index to use as the data source. You can optionally use index patterns to choose multiple indices.
+1. For **Time range**, select a time range for historical analysis.
+1. For **Detector settings**, choose to use the settings of an existing detector. Or choose the **Timestamp field** in your index, add individual features to the detector, and set the detector interval.
+1. (Optional) Choose to run the historical detector automatically after creating it.
+1. Choose **Create**.
+   - You can stop the historical detector even before it completes.
+
+### Step 7: Manage your detectors
+
+To change or delete a detector, go to the **Detector details** page.
+
+1. To make changes to your detector, choose the detector name.
+1. Choose **Actions** and **Edit detector**.
+   - You need to stop the detector to change its configuration. Confirm that you want to stop the detector and proceed.
+1. Make your changes and choose **Save changes**.
+
+To delete your detector, choose **Actions** and **Delete detector**. In the pop-up box, type `delete` to confirm and choose **Delete**.

_monitoring-plugins/ad/settings.md

@@ -28,20 +28,15 @@ Setting | Default | Description
 `plugins.anomaly_detection.max_anomaly_detectors` | 1,000 | The maximum number of non-high cardinality detectors (no category field) users can create.
 `plugins.anomaly_detection.max_multi_entity_anomaly_detectors` | 10 | The maximum number of high cardinality detectors (with category field) in a cluster.
 `plugins.anomaly_detection.max_anomaly_features` | 5 | The maximum number of features for a detector.
-`plugins.anomaly_detection.ad_result_history_rollover_period` | 12h | How often the rollover condition is checked. If `true`, the anomaly detection plugin rolls over the result index to a new index.
-`plugins.anomaly_detection.ad_result_history_max_docs_per_shard` | 1,350,000,000 | The maximum number of documents in a single shard of the result index. The anomaly detection plugin only counts the refreshed documents in the primary shards.
-`plugins.anomaly_detection.max_entities_per_query` | 1,000,000 | The maximum unique values per detection interval for high cardinality detectors. By default, if the category field(s) have more than the configured unique values in a detector interval, the anomaly detection plugin orders them by the natural ordering of categorical values (for example, entity `ab` comes before `bc`) and then selects the top values.
-`plugins.anomaly_detection.max_entities_for_preview` | 5 | The maximum unique category field values displayed with the preview operation for high cardinality detectors. By default, if the category field(s) have more than the configured unique values in a detector interval, the anomaly detection plugin orders them by the natural ordering of categorical values (for example, entity `ab` comes before `bc`) and then selects the top values.
+`plugins.anomaly_detection.ad_result_history_rollover_period` | 12h | How often the rollover condition is checked. If `true`, the plugin rolls over the result index to a new index.
+`plugins.anomaly_detection.ad_result_history_max_docs` | 250000000 | The maximum number of documents in one result index. The plugin only counts refreshed documents in the primary shards.
+`plugins.anomaly_detection.ad_result_history_retention_period` | 30d | The maximum age of the result index.  If its age exceeds the threshold, the plugin deletes the rolled over result index. If the cluster has only one result index, the plugin keeps the index even if it's older than its configured retention period.
+`plugins.anomaly_detection.max_entities_per_query` | 1,000 | The maximum unique values per detection interval for high cardinality detectors. By default, if the category field has more than 1,000 unique values in a detector interval, the plugin selects the top 1,000 values and orders them by `doc_count`.
+`plugins.anomaly_detection.max_entities_for_preview` | 30 | The maximum unique category field values displayed with the preview operation for high cardinality detectors. If the category field has more than 30 unique values, the plugin selects the top 30 values and orders them by `doc_count`.
 `plugins.anomaly_detection.max_primary_shards` | 10 | The maximum number of primary shards an anomaly detection index can have.
-`plugins.anomaly_detection.filter_by_backend_roles` | False | When you enable the security plugin and set this to `true`, the anomaly detection plugin filters results based on the user's backend role(s).
-`plugins.anomaly_detection.max_batch_task_per_node` | 10 | Starting a historical analysis triggers a batch task. This setting is the number of batch tasks that you can run per data node. You can tune this setting from 1 to 1,000. If the data nodes can’t support all batch tasks and you’re not sure if the data nodes are capable of running more historical analysis, add more data nodes instead of changing this setting to a higher value. Increasing this value might bring more load on each data node.
-`plugins.anomaly_detection.max_old_ad_task_docs_per_detector` | 1 | You can run historical analysis for the same detector many times. For each run, the anomaly detection plugin creates a new task. This setting is the number of previous tasks the plugin keeps. Set this value to at least 1 to track its last run. You can keep a maximum of 1,000 old tasks to avoid overwhelming the cluster.
-`plugins.anomaly_detection.batch_task_piece_size` | 1,000 | The date range for a historical task is split into smaller pieces and the anomaly detection plugin runs the task piece by piece. Each piece contains 1,000 detection intervals by default. For example, if detector interval is 1 minute and one piece is 1,000 minutes, the feature data is queried every 1,000 minutes. You can change this setting from 1 to 10,000.
-`plugins.anomaly_detection.batch_task_piece_interval_seconds` | 5 | Add a time interval between two pieces of the same historical analysis task. This interval prevents the task from consuming too much of the available resources and starving other operations like search and bulk index. You can change this setting from 1 to 600 seconds.
-`plugins.anomaly_detection.max_top_entities_for_historical_analysis` | 1,000 | The maximum number of top entities that you run for a high cardinality detector historical analysis. The range is from 1 to 10,000.
-`plugins.anomaly_detection.max_running_entities_per_detector_for_historical_analysis` | 10 | The number of entity tasks that you can run in parallel for a single high cardinality detector. The task slots available on your cluster also impact how many entities run in parallel. If a cluster has 3 data nodes, each data node has 10 task slots by default. Say you already have two high cardinality detectors and each of them run 10 entities. If you start a single-entity detector that takes 1 task slot, the number of task slots available is 10 * 3 - 10 * 2 - 1 = 9. If you now start a new high cardinality detector, the detector can only run 9 entities in parallel and not 10. You can tune this value from 1 to 1,000 based on your cluster's capability. If you set a higher value, the anomaly detection plugin runs historical analysis faster but also consumes more resources.
-`plugins.anomaly_detection.max_cached_deleted_tasks` | 1,000 | You can rerun historical analysis for a single detector as many times as you like. The anomaly detection plugin only keeps a limited number of old tasks, by default 1 old task. If you run historical analysis three times for a detector, the oldest task is deleted. Because historical analysis generates a number of anomaly results in a short span of time, it's necessary to clean up anomaly results for a deleted task. With this field, you can configure how many deleted tasks you can cache at most. The plugin cleans up a task's results when it's deleted. If the plugin fails to do this cleanup, it adds the task's results into a cache and an hourly cron job performs the cleanup. You can use this setting to limit how many old tasks are put into cache to avoid a DDoS attack. After an hour, if still you find an old task result in the cache, use the [delete detector results API]({{site.url}}{{site.baseurl}}/monitoring-plugins/ad/api/#delete-detector-results) to delete the task result manually. You can tune this setting from 1 to 10,000.
-`plugins.anomaly_detection.delete_anomaly_result_when_delete_detector` | False | Whether the anomaly detection plugin deletes the anomaly result when you delete a detector. If you want to save some disk space, especially if you've high cardinality detectors generating a lot of results, set this field to true. Alternatively, you can use the [delete detector results API]({{site.url}}{{site.baseurl}}/monitoring-plugins/ad/api/#delete-detector-results) to manually delete the results.
-`plugins.anomaly_detection.dedicated_cache_size` | 10 | If the real-time analysis of a high cardinality detector starts successfully, the anomaly detection plugin guarantees keeping 10 (dynamically adjustable via this setting) entities' models in memory per node. If the number of entities exceeds this limit, the plugin puts the extra entities' models in a memory space shared by all detectors. The actual number of entities varies based on the memory that you've available and the frequencies of the entities. If you'd like the plugin to guarantee keeping more entities' models in memory and if you're cluster has sufficient memory, you can increase this setting value.
-`plugins.anomaly_detection.max_concurrent_preview` | 2 | The maximum number of concurrent previews. You can use this setting to limit resource usage.
-`plugins.anomaly_detection.model_max_size_percent` | 0.1 | The upper bound of the memory percentage for a model.
+`plugins.anomaly_detection.filter_by_backend_roles` | False | When you enable the security plugin and set this to `true`, the plugin filters results based on the user's backend role(s).
+`plugins.anomaly_detection.max_cache_miss_handling_per_second` | 100 | High cardinality detectors use a cache to store active models. In the event of a cache miss, the cache gets the models from the model checkpoint index. Use this setting to limit the rate of fetching models. Because the thread pool for a GET operation has a queue of 1,000, we recommend setting this value below 1,000.
+`plugins.anomaly_detection.max_batch_task_per_node` | 2 | Starting a historical detector triggers a batch task. This setting is the number of batch tasks that you can run per data node. You can tune this setting from 1 to 1000. If the data nodes can't support all batch tasks and you're not sure if the data nodes are capable of running more historical detectors, add more data nodes instead of changing this setting to a higher value.
+`plugins.anomaly_detection.max_old_ad_task_docs_per_detector` | 10 | You can run the same historical detector many times. For each run, the anomaly detection plugin creates a new task. This setting is the number of previous tasks the plugin keeps. Set this value to at least 1 to track its last run. You can keep a maximum of 1,000 old tasks to avoid overwhelming the cluster.
+`plugins.anomaly_detection.batch_task_piece_size` | 1000 | The date range for a historical task is split into smaller pieces and the anomaly detection plugin runs the task piece by piece. Each piece contains 1,000 detection intervals by default. For example, if detector interval is 1 minute and one piece is 1000 minutes, the feature data is queried every 1,000 minutes. You can change this setting from 1 to 10,000.
+`plugins.anomaly_detection.batch_task_piece_interval_seconds` | 5 | Add a time interval between historical detector tasks. This interval prevents the task from consuming too much of the available resources and starving other operations like search and bulk index. You can change this setting from 1 to 600 seconds.

_replication-plugin/api.md

@@ -0,0 +1,391 @@
+---
+layout: default
+title: API
+nav_order: 50
+---
+
+# Cross-cluster replication API
+
+Use these replication operations to programmatically manage cross-cluster replication.
+
+#### Table of contents
+- TOC
+{:toc}
+
+## Start replication
+Introduced 1.1
+{: .label .label-purple }
+
+Initiate replication of an index from the leader cluster to the follower cluster. Send this request to the follower cluster.
+
+
+#### Request
+
+```json
+PUT /_plugins/_replication/<follower-index>/_start
+{
+   "leader_alias":"<connection-alias-name>",
+   "leader_index":"<index-name>",
+   "use_roles":{
+      "leader_cluster_role":"<role-name>",
+      "follower_cluster_role":"<role-name>"
+   }
+}
+```
+
+Specify the following options:
+
+Options | Description | Type | Required
+:--- | :--- |:--- |:--- |
+`leader_alias` |  The name of the cross-cluster connection. You define this alias when you [set up a cross-cluster connection]({{site.url}}{{site.baseurl}}/replication-plugin/get-started/#set-up-a-cross-cluster-connection). | `string` | Yes
+`leader_index` |  The index on the leader cluster that you want to replicate. | `string` | Yes
+`use_roles` |  The roles to use for all subsequent backend replication tasks between the indices. Specify a `leader_cluster_role` and `follower_cluster_role`. See [Map the leader and follower cluster roles]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/#map-the-leader-and-follower-cluster-roles). | `string` | If security plugin is enabled
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```
+
+## Stop replication
+Introduced 1.1
+{: .label .label-purple }
+
+Terminates replication and converts the follower index to a standard index. Send this request to the follower cluster.
+
+#### Request
+
+```json
+POST /_plugins/_replication/<follower-index>/_stop
+{}
+```
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```
+
+## Pause replication
+Introduced 1.1
+{: .label .label-purple }
+
+Pauses replication of the leader index. Send this request to the follower cluster.
+
+#### Request
+
+```json
+POST /_plugins/_replication/<follower-index>/_pause 
+{}
+```
+
+You can't resume replication after it's been paused for more than 12 hours. You must [stop replication]({{site.url}}{{site.baseurl}}/replication-plugin/api/#stop-replication), delete the follower index, and restart replication of the leader.
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```
+
+## Resume replication
+Introduced 1.1
+{: .label .label-purple }
+
+Resumes replication of the leader index. Send this request to the follower cluster.
+
+#### Request
+
+```json
+POST /_plugins/_replication/<follower-index>/_resume
+{}
+```
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```
+
+## Get replication status
+Introduced 1.1
+{: .label .label-purple }
+
+Gets the status of index replication. Possible statuses are `SYNCING`, `BOOTSTRAPING`, `PAUSED`, and `REPLICATION NOT IN PROGRESS`. Use the syncing details to measure replication lag. Send this request to the follower cluster.
+
+#### Request
+
+```json
+GET /_plugins/_replication/<follower-index>/_status
+```
+
+#### Sample response
+
+```json
+{
+  "status" : "SYNCING",
+  "reason" : "User initiated",
+  "leader_alias" : "my-connection-name",
+  "leader_index" : "leader-01",
+  "follower_index" : "follower-01",
+  "syncing_details" : {
+    "leader_checkpoint" : 19,
+    "follower_checkpoint" : 19,
+    "seq_no" : 0
+  }
+}
+```
+To include shard replication details in the response, add the `&verbose=true` parameter.
+
+The leader and follower checkpoint values begin as negative integers and reflect the shard count (-1 for one shard, -5 for five shards, and so on). The values increment toward positive integers with each change that you make. For example, when you make a change on the leader index, the `leader_checkpoint` becomes `0`. The `follower_checkpoint` is initially still `-1` until the follower index pulls the change from the leader, at which point it increments to `0`. If the values are the same, it means the indices are fully synced.
+
+## Get leader cluster stats
+Introduced 1.1
+{: .label .label-purple }
+
+Gets information about replicated leader indices on a specified cluster. 
+
+#### Request
+
+```json
+GET /_plugins/_replication/leader_stats
+```
+
+#### Sample response
+
+```json
+{
+   "num_replicated_indices": 2,
+   "operations_read": 15,
+   "translog_size_bytes": 1355,
+   "operations_read_lucene": 0,
+   "operations_read_translog": 15,
+   "total_read_time_lucene_millis": 0,
+   "total_read_time_translog_millis": 659,
+   "bytes_read": 1000,
+   "index_stats":{
+      "leader-index-1":{
+         "operations_read": 7,
+         "translog_size_bytes": 639,
+         "operations_read_lucene": 0,
+         "operations_read_translog": 7,
+         "total_read_time_lucene_millis": 0,
+         "total_read_time_translog_millis": 353,
+         "bytes_read":466
+      },
+      "leader-index-2":{
+         "operations_read": 8,
+         "translog_size_bytes": 716,
+         "operations_read_lucene": 0,
+         "operations_read_translog": 8,
+         "total_read_time_lucene_millis": 0,
+         "total_read_time_translog_millis": 306,
+         "bytes_read": 534
+      }
+   }
+}
+```
+
+## Get follower cluster stats
+Introduced 1.1
+{: .label .label-purple }
+
+Gets information about follower (syncing) indices on a specified cluster. 
+
+#### Request
+
+```json
+GET /_plugins/_replication/follower_stats
+```
+
+#### Sample response
+
+```json
+{
+   "num_syncing_indices": 2,
+   "num_bootstrapping_indices": 0,
+   "num_paused_indices": 0,
+   "num_failed_indices": 0,
+   "num_shard_tasks": 2,
+   "num_index_tasks": 2,
+   "operations_written": 3,
+   "operations_read": 3,
+   "failed_read_requests": 0,
+   "throttled_read_requests": 0,
+   "failed_write_requests": 0,
+   "throttled_write_requests": 0,
+   "follower_checkpoint": 1,
+   "leader_checkpoint": 1,
+   "total_write_time_millis": 2290,
+   "index_stats":{
+      "follower-index-1":{
+         "operations_written": 2,
+         "operations_read": 2,
+         "failed_read_requests": 0,
+         "throttled_read_requests": 0,
+         "failed_write_requests": 0,
+         "throttled_write_requests": 0,
+         "follower_checkpoint": 1,
+         "leader_checkpoint": 1,
+         "total_write_time_millis": 1355
+      },
+      "follower-index-2":{
+         "operations_written": 1,
+         "operations_read": 1,
+         "failed_read_requests": 0,
+         "throttled_read_requests": 0,
+         "failed_write_requests": 0,
+         "throttled_write_requests": 0,
+         "follower_checkpoint": 0,
+         "leader_checkpoint": 0,
+         "total_write_time_millis": 935
+      }
+   }
+}
+```
+
+## Get auto-follow stats
+Introduced 1.1
+{: .label .label-purple }
+
+Gets information about auto-follow activity and any replication rules configured on the specified cluster.
+
+#### Request
+
+```json
+GET /_plugins/_replication/autofollow_stats
+```
+
+#### Sample response
+
+```json
+{
+   "num_success_start_replication": 2,
+   "num_failed_start_replication": 0,
+   "num_failed_leader_calls": 0,
+   "failed_indices":[
+      
+   ],
+   "autofollow_stats":[
+      {
+         "name":"my-replication-rule",
+         "pattern":"movies*",
+         "num_success_start_replication": 2,
+         "num_failed_start_replication": 0,
+         "num_failed_leader_calls": 0,
+         "failed_indices":[
+            
+         ]
+      }
+   ]
+}
+```
+
+## Update settings
+Introduced 1.1
+{: .label .label-purple }
+
+Updates settings on the follower index.
+
+#### Request
+
+```json
+PUT /_plugins/_replication/<follower-index>/_update
+{
+   "settings":{
+      "index.number_of_shards": 4,
+      "index.number_of_replicas": 2
+   }
+}
+```
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```
+
+## Create replication rule
+Introduced 1.1
+{: .label .label-purple }
+
+Automatically starts replication on indices matching a specified pattern. If a new index on the leader cluster matches the pattern, OpenSearch automatically creates a follower index and begins replication. You can also use this API to update existing replication rules.
+
+Send this request to the follower cluster.
+
+Make sure to note the names of all auto-follow patterns after you create them. The replication plugin currently does not include an API operation to retrieve a list of existing patterns.
+{: .tip }
+
+#### Request
+
+```json
+POST /_plugins/_replication/_autofollow
+{
+   "leader_alias" : "<connection-alias-name>",
+   "name": "<auto-follow-pattern-name>",
+   "pattern": "<pattern>",
+   "use_roles":{
+      "leader_cluster_role": "<role-name>",
+      "follower_cluster_role": "<role-name>"
+   }
+}
+```
+
+Specify the following options:
+
+Options | Description | Type | Required
+:--- | :--- |:--- |:--- |
+`leader_alias` |  The name of the cross-cluster connection. You define this alias when you [set up a cross-cluster connection]({{site.url}}{{site.baseurl}}/replication-plugin/get-started/#set-up-a-cross-cluster-connection). | `string` | Yes
+`name` |  A name for the auto-follow pattern. | `string` | Yes
+`pattern` |  An array of index patterns to match against indices in the specified leader cluster. Supports wildcard characters. For example, `leader-*`. | `string` | Yes
+`use_roles` |  The roles to use for all subsequent backend replication tasks between the indices. Specify a `leader_cluster_role` and `follower_cluster_role`. See [Map the leader and follower cluster roles]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/#map-the-leader-and-follower-cluster-roles). | `string` | If security plugin is enabled
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```
+
+## Delete replication rule
+Introduced 1.1
+{: .label .label-purple }
+
+Deletes the specified replication rule. This operation prevents any new indices from being replicated but does not stop existing replication that the rule has already initiated.
+
+Send this request to the follower cluster.
+
+#### Request
+
+```json
+DELETE /_plugins/_replication/_autofollow
+{
+   "leader_alias" : "<connection-alias-name>",
+   "name": "<auto-follow-pattern-name>",
+}
+```
+
+Specify the following options:
+
+Options | Description | Type | Required
+:--- | :--- |:--- |:--- |
+`leader_alias` |  The name of the cross-cluster connection. You define this alias when you [set up a cross-cluster connection]({{site.url}}{{site.baseurl}}/replication-plugin/get-started/#set-up-a-cross-cluster-connection). | `string` | Yes
+`name` |  The name of the pattern. | `string` | Yes
+
+#### Sample response
+
+```json
+{
+   "acknowledged": true
+}
+```

_replication-plugin/auto-follow.md

@@ -0,0 +1,104 @@
+---
+layout: default
+title: Auto-follow
+nav_order: 20
+has_children: false
+
+---
+
+# Auto-follow for cross-cluster replication
+
+Auto-follow lets you automatically replicate indices created on the leader cluster based on matching patterns. When you create an index on the leader cluster with a name that matches a specified pattern (for example, `index-01*`), a corresponding follower index is automatically created on the follower cluster. 
+
+You can configure multiple replication rules for a single cluster. The patterns currently only support wildcard matching. 
+
+## Prerequisites
+
+You need to [set up a cross-cluster connection]({{site.url}}{{site.baseurl}}/replication-plugin/get-started/#set-up-a-cross-cluster-connection) between two clusters before you can enable auto-follow. 
+
+## Permissions
+
+If the security plugin is enabled, non-admin users need to be mapped to the appropriate permissions in order to perform replication actions. For index and cluster-level permissions requirements, see [Cross-cluster replication permissions]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/).
+
+## Get started with auto-follow
+
+Replication rules are a collection of patterns that you create against a single remote cluster. When you create a replication rule, it automatically starts replicating any *new* indices that match the pattern, but does not replicate matching indices that were previously created. 
+
+Create a replication rule on the follower cluster:
+
+```bash
+curl -XPOST -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/_autofollow?pretty' -d '
+{
+   "leader_alias" : "my-connection-alias",
+   "name": "my-replication-rule",
+   "pattern": "movies*",
+   "use_roles":{
+      "leader_cluster_role": "all_access",
+      "follower_cluster_role": "all_access"
+   }
+}'
+```
+
+If the security plugin is disabled, you can leave out the `use_roles` parameter. If it's enabled, however, you need to specify the leader and follower cluster roles that OpenSearch uses to authenticate requests. This example uses `all_access` for simplicity, but we recommend creating a replication user on each cluster and [mapping it accordingly]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/#map-the-leader-and-follower-cluster-roles).
+{: .tip }
+
+To test the rule, create a matching index on the leader cluster:
+
+```bash
+curl -XPUT -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9201/movies-0001?pretty'
+```
+
+And confirm its replica shows up on the follower cluster:
+
+```bash
+curl -XGET -u 'admin:admin' -k 'https://localhost:9200/_cat/indices?v'
+```
+
+It might take several seconds for the index to appear.
+
+```bash
+health status index        uuid                     pri rep docs.count docs.deleted store.size pri.store.size
+yellow open   movies-0001  kHOxYYHxRMeszLjTD9rvSQ     1   1          0            0       208b           208b
+```
+
+## Retrieve replication rules
+
+To retrieve a list of existing replication rules configured on a cluster, send the following request:
+
+```bash
+curl -XGET -u 'admin:admin' -k 'https://localhost:9200/_plugins/_replication/autofollow_stats'
+
+{
+   "num_success_start_replication": 1,
+   "num_failed_start_replication": 0,
+   "num_failed_leader_calls": 0,
+   "failed_indices":[
+      
+   ],
+   "autofollow_stats":[
+      {
+         "name":"my-replication-rule",
+         "pattern":"movies*",
+         "num_success_start_replication": 1,
+         "num_failed_start_replication": 0,
+         "num_failed_leader_calls": 0,
+         "failed_indices":[
+            
+         ]
+      }
+   ]
+}
+```
+
+## Delete a replication rule
+
+When you delete a replication rule, OpenSearch stops replicating *new* indices that match the pattern, but existing indices that the rule previously created continue to replicate. If you need to stop existing replication activity, use the [stop replication API operation]({{site.url}}{{site.baseurl}}/replication-plugin/api/#stop-replication).
+
+```bash
+curl -XDELETE -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/_autofollow?pretty' -d '
+{
+   "leader_alias" : "my-conection-alias",
+   "name": "my-replication-rule"
+}'
+```
+

_replication-plugin/get-started.md

@@ -0,0 +1,273 @@
+---
+layout: default
+title: Get started
+nav_order: 10
+---
+
+# Get started with cross-cluster replication
+
+With cross-cluster replication, you index data to a leader index, and OpenSearch replicates that data to one or more read-only follower indices. All subsequent operations on the leader are replicated on the follower, such as creating, updating, or deleting documents.
+
+## Prerequisites
+
+Cross-cluster replication has the following prerequisites:
+- Both the leader and follower cluster must have the replication plugin installed.
+- If you've overridden `node.roles` in `opensearch.yml` on the remote cluster, make sure it also includes the `remote_cluster_client` role:
+
+   ```yaml
+   node.roles: [<other_roles>, remote_cluster_client]
+   ```
+
+## Permissions
+
+Make sure the security plugin is either enabled on both clusters or disabled on both clusters. If you disabled the security plugin, you can skip this section. However, we strongly recommend enabling the security plugin in production scenarios.
+
+If the security plugin is enabled, non-admin users need to be mapped to the appropriate permissions in order to perform replication actions. For index and cluster-level permissions requirements, see [Cross-cluster replication permissions]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/).
+
+In addition, add the following setting to `opensearch.yml` on the leader cluster so it allows connections from the follower cluster: 
+
+```yml
+plugins.security.nodes_dn_dynamic_config_enabled: true
+```
+
+## Example setup
+
+Save this sample file as `docker-compose.yml` and run `docker-compose up` to start two single-node clusters on the same network:
+
+```yml
+version: '3'
+services:
+  replication-node1:
+    image: opensearchproject/opensearch:{{site.opensearch_version}}
+    container_name: replication-node1
+    environment:
+      - cluster.name=leader-cluster
+      - discovery.type=single-node
+      - bootstrap.memory_lock=true
+      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m"
+    ulimits:
+      memlock:
+        soft: -1
+        hard: -1
+    volumes:
+      - opensearch-data2:/usr/share/opensearch/data
+    ports:
+      - 9201:9200
+      - 9700:9600 # required for Performance Analyzer
+    networks:
+      - opensearch-net
+  replication-node2:
+    image: opensearchproject/opensearch:{{site.opensearch_version}}
+    container_name: replication-node2
+    environment:
+      - cluster.name=follower-cluster
+      - discovery.type=single-node
+      - bootstrap.memory_lock=true
+      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m"
+    ulimits:
+      memlock:
+        soft: -1
+        hard: -1
+    volumes:
+      - opensearch-data1:/usr/share/opensearch/data
+    ports:
+      - 9200:9200
+      - 9600:9600 # required for Performance Analyzer
+    networks:
+      - opensearch-net
+
+volumes:
+  opensearch-data1:
+  opensearch-data2:
+
+networks:
+  opensearch-net:
+```
+
+After the clusters start, verify the names of each:
+
+```bash
+curl -XGET -u 'admin:admin' -k 'https://localhost:9201'
+{
+  "cluster_name" : "leader-cluster",
+  ...
+}
+
+curl -XGET -u 'admin:admin' -k 'https://localhost:9200'
+{
+  "cluster_name" : "follower-cluster",
+  ...
+}
+```
+
+For this example, use port 9201 (`replication-node1`) as the leader and port 9200 (`replication-node2`) as the follower cluster.
+
+To get the IP address for the leader cluster, first identify its container ID:
+
+```bash
+docker ps
+CONTAINER ID    IMAGE                                       PORTS                                                      NAMES
+3b8cdc698be5    opensearchproject/opensearch:{{site.opensearch_version}}   0.0.0.0:9200->9200/tcp, 0.0.0.0:9600->9600/tcp, 9300/tcp   replication-node2
+731f5e8b0f4b    opensearchproject/opensearch:{{site.opensearch_version}}   9300/tcp, 0.0.0.0:9201->9200/tcp, 0.0.0.0:9700->9600/tcp   replication-node1
+```
+
+Then get that container's IP address:
+
+```bash
+docker inspect --format='{% raw %}{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}{% endraw %}' 731f5e8b0f4b
+172.22.0.3
+```
+
+## Set up a cross-cluster connection
+
+Cross-cluster replication follows a "pull" model, so most changes occur on the follower cluster, not the leader cluster. 
+
+On the follower cluster, add the IP address (with port 9300) for each seed node. Because this is a single-node cluster, you only have one seed node. Provide a descriptive name for the connection, which you'll use in the request to start replication:
+
+```bash
+curl -XPUT -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_cluster/settings?pretty' -d '
+{
+  "persistent": {
+    "cluster": {
+      "remote": {
+        "my-connection-alias": {
+          "seeds": ["172.22.0.3:9300"]
+        }
+      }
+    }
+  }
+}'
+```
+
+## Start replication
+
+To get started, create an index called `leader-01` on the leader cluster:
+
+```bash
+curl -XPUT -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9201/leader-01?pretty'
+```
+
+Then start replication from the follower cluster. In the request body, provide the connection name and leader index that you want to replicate, along with the security roles you want to use:
+
+```bash
+curl -XPUT -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_start?pretty' -d '
+{
+   "leader_alias": "my-connection-alias",
+   "leader_index": "leader-01",
+   "use_roles":{
+      "leader_cluster_role": "all_access",
+      "follower_cluster_role": "all_access"
+   }
+}'
+```
+
+If the security plugin is disabled, omit the `use_roles` parameter. If it's enabled, however, you must specify the leader and follower cluster roles that OpenSearch will use to authenticate the request. This example uses `all_access` for simplicity, but we recommend creating a replication user on each cluster and [mapping it accordingly]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/#map-the-leader-and-follower-cluster-roles).
+{: .tip }
+
+This command creates an identical read-only index named `follower-01` on the local cluster that continuously stays updated with changes to the `leader-01` index on the remote cluster. Starting replication creates a follower index from scratch; you can't convert an existing index to a follower index. 
+
+## Confirm replication
+
+After replication starts, get the status:
+
+```bash
+curl -XGET -k -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_status?pretty'
+
+{
+  "status" : "SYNCING",
+  "reason" : "User initiated",
+  "leader_alias" : "my-connection-alias",
+  "leader_index" : "leader-01",
+  "follower_index" : "follower-01",
+  "syncing_details" : {
+    "leader_checkpoint" : -1,
+    "follower_checkpoint" : -1,
+    "seq_no" : 0
+  }
+}
+```
+
+Possible statuses are `SYNCING`, `BOOTSTRAPING`, `PAUSED`, and `REPLICATION NOT IN PROGRESS`. 
+
+The leader and follower checkpoint values begin as negative numbers and reflect the shard count (-1 for one shard, -5 for five shards, and so on). The values increment with each change and illustrate how many updates the follower is behind the leader. If the indices are fully synced, the values are the same.
+
+To confirm that replication is actually happening, add a document to the leader index:
+
+```bash
+curl -XPUT -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9201/leader-01/_doc/1?pretty' -d '{"The Shining": "Stephen King"}'
+```
+
+Then validate the replicated content on the follower index:
+
+```bash
+curl -XGET -k -u 'admin:admin' 'https://localhost:9200/follower-01/_search?pretty'
+
+{
+  ...
+  "hits": [{
+    "_index": "follower-01",
+    "_type": "_doc",
+    "_id": "1",
+    "_score": 1.0,
+    "_source": {
+      "The Shining": "Stephen King"
+    }
+  }]
+}
+```
+
+## Pause and resume replication
+
+You can temporarily pause replication of an index if you need to remediate issues or reduce load on the leader cluster:
+
+```bash
+curl -XPOST -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_pause?pretty' -d '{}'
+```
+
+To confirm replication is paused, get the status:
+
+```bash
+curl -XGET -k -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_status?pretty'
+
+{
+  "status" : "PAUSED",
+  "reason" : "User initiated",
+  "leader_alias" : "my-connection-alias",
+  "leader_index" : "leader-01",
+  "follower_index" : "follower-01"
+}
+```
+
+When you're done making changes, resume replication:
+
+```bash
+curl -XPOST -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_resume?pretty' -d '{}'
+```
+
+When replication resumes, the follower index picks up any changes that were made to the leader index while replication was paused.
+
+Note that you can't resume replication after it's been paused for more than 12 hours. You must [stop replication]({{site.url}}{{site.baseurl}}/replication-plugin/api/#stop-replication), delete the follower index, and restart replication of the leader.
+
+## Stop replication
+
+Terminate replication of a specified index from the follower cluster:
+
+```bash
+curl -XPOST -k -H 'Content-Type: application/json' -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_stop?pretty' -d '{}'
+```
+
+When you stop replication, the follower index un-follows the leader and becomes a standard index that you can write to. You can't restart replication after stopping it. 
+
+Get the status to confirm that the index is no longer being replicated:
+
+```bash
+curl -XGET -k -u 'admin:admin' 'https://localhost:9200/_plugins/_replication/follower-01/_status?pretty'
+
+{
+  "status" : "REPLICATION NOT IN PROGRESS"
+}
+```
+
+You can further confirm that replication is stopped by making modifications to the leader index and confirming they don't show up on the follower index.
+
+

_replication-plugin/index.md

@@ -0,0 +1,22 @@
+---
+layout: default
+title: Cross-cluster replication
+nav_order: 1
+has_children: false
+
+---
+
+# Cross-cluster replication
+
+The cross-cluster replication plugin lets you replicate indices, mappings, and metadata from one OpenSearch cluster to another. Cross-cluster replication has the following benefits:
+- By replicating your indices, you ensure that you can continue to handle search requests in the event of an outage.
+- Replicating data across geographically distant data centers minimizes the distance between the data and the application server, reducing expensive latencies.
+- You can replicate data from multiple smaller clusters to a centralized reporting cluster, which is useful when it's inefficient to query across a large network.
+
+Replication follows an active-passive model where the follower index (where the data is replicated) pulls data from the leader (remote) index.
+
+The replication plugin supports replication of indices using wildcard pattern matching and provides commands to pause, resume, and stop replication. Once replication starts on an index, it initiates persistent background tasks on all primary shards on the follower cluster, which continuously poll corresponding shards from the leader cluster for updates.
+
+You can use the replication plugin with the security plugin to encrypt cross-cluster traffic with node-to-node encryption and control access to replication activities.
+
+To start, see [Get started with cross-cluster replication]({{site.url}}{{site.baseurl}}/replication-plugin/get-started/).

_replication-plugin/permissions.md

@@ -0,0 +1,78 @@
+---
+layout: default
+title: Permissions
+nav_order: 30
+---
+
+# Cross-cluster replication permissions
+
+You can use the [security plugin]({{site.url}}{{site.baseurl}}/security-plugin/index/) with cross-cluster replication to limit users to certain actions. For example, you might want certain users to only perform replication activity on the leader or follower cluster.
+
+Because cross-cluster replication involves multiple clusters, it's possible that clusters might have different security configurations. The following configurations are supported:
+
+- Security plugin fully enabled on both clusters
+- Security plugin enabled only for TLS on both clusters (`plugins.security.ssl_only`)
+- Security plugin absent or disabled on both clusters (not recommended)
+
+Enable node-to-node encryption on both the leader and the follower cluster to ensure that replication traffic between the clusters is encrypted.
+
+## Basic permissions
+
+In order for non-admin users to perform replication activities, they must be mapped to the appropriate permissions.  
+
+The security plugin has two built-in roles that cover most replication use cases: `cross_cluster_replication_leader_full_access`, which provides replication permissions on the leader cluster, and `cross_cluster_replication_follower_full_access`, which provides replication permissions on the follower cluster. For descriptions of each, see [Predefined roles]({{site.url}}{{site.baseurl}}/security-plugin/access-control/users-roles#predefined-roles).
+
+If you don't want to use the default roles, you can combine individual replication [permissions]({{site.url}}{{site.baseurl}}/replication-plugin/permissions/#replication-permissions) to meet your needs. Most permissions correspond to specific REST API operations. For example, the `indices:admin/plugins/replication/index/pause` permission lets you pause replication.
+
+## Map the leader and follower cluster roles
+
+The [start replication]({{site.url}}{{site.baseurl}}/replication-plugin/api/#start-replication) and [create replication rule]({{site.url}}{{site.baseurl}}/replication-plugin/api/#create-replication-rule) operations are special cases. They involve background processes on the leader and follower clusters that must be associated with roles. When you perform one of these actions, you must explicitly pass the `leader_cluster_role` and
+`follower_cluster_role` in the request, which OpenSearch then uses in all backend replication tasks.
+
+To enable non-admins to start replication and create replication rules, create an identical user on each cluster (for example, `replication_user`) and map them to the `cross_cluster_replication_leader_full_access` role on the remote cluster and `cross_cluster_replication_follower_full_access` on the follower cluster. For instructions, see [Map users to roles]({{site.url}}{{site.baseurl}}/security-plugin/access-control/users-roles/#map-users-to-roles).
+
+Then add those roles to the request, and sign it with the appropriate credentials:
+
+```bash
+curl -XPUT -k -H 'Content-Type: application/json' -u 'replication_user:password' 'https://localhost:9200/_plugins/_replication/follower-01/_start?pretty' -d '
+{
+   "leader_alias": "leader-cluster",
+   "leader_index": "leader-01",
+   "use_roles":{
+      "leader_cluster_role": "cross_cluster_replication_leader_full_access",
+      "follower_cluster_role": "cross_cluster_replication_follower_full_access"
+   }
+}'
+```
+
+You can create your own, custom leader and follower cluster roles using individual permissions, but we recommend using the default roles, which are a good fit for most use cases.
+
+## Replication permissions
+
+The following sections list the available index and cluster-level permissions for cross-cluster replication.
+
+### Follower cluster
+
+The security plugin supports these permissions for the follower cluster:
+
+```
+indices:admin/plugins/replication/index/setup/validate
+indices:admin/plugins/replication/index/start
+indices:admin/plugins/replication/index/pause
+indices:admin/plugins/replication/index/resume
+indices:admin/plugins/replication/index/stop
+indices:admin/plugins/replication/index/update
+indices:admin/plugins/replication/index/status_check
+indices:data/write/plugins/replication/changes
+cluster:admin/plugins/replication/autofollow/update
+```
+
+### Leader cluster
+
+The security plugin supports these permissions for the leader cluster:
+
+```
+indices:admin/plugins/replication/validate
+indices:data/read/plugins/replication/file_chunk
+indices:data/read/plugins/replication/changes
+```

_replication-plugin/settings.md

@@ -0,0 +1,34 @@
+---
+layout: default
+title: Settings
+nav_order: 40
+---
+
+# Replication settings
+
+The replication plugin adds several settings to the standard OpenSearch cluster settings.
+The settings are dynamic, so you can change the default behavior of the plugin without restarting your cluster.
+You can mark settings as `persistent` or `transient`.
+
+For example, to update how often the follower cluster polls the leader cluster for updates:
+
+```json
+PUT _cluster/settings
+{
+  "persistent": {
+    "plugins.replication.follower.metadata_sync_interval": "30s"
+  }
+}
+```
+
+These settings manage the resources consumed by remote recoveries. We don’t recommend changing these settings; the defaults should work well for most use cases.
+
+Setting | Default | Description
+:--- | :--- | :---
+`plugins.replication.follower.index.recovery.chunk_size` | 10MB | The chunk size requested by the follower cluster during file transfer. Specify the chunk size as a value and unit, for example, 10MB, 5KB. See [Supported units]({{site.url}}{{site.baseurl}}/opensearch/units/).
+`plugins.replication.follower.index.recovery.max_concurrent_file_chunks` | 4 | The number of file chunk requests that can be sent in parallel for each recovery. 
+`plugins.replication.follower.index.ops_batch_size` | 5000 | The number of operations that can be fetched at a time during the syncing phase of replication.
+`plugins.replication.follower.concurrent_readers_per_shard` | 2 | The number of concurrent requests from the follower cluster per shard during the syncing phase of replication.
+`plugins.replication.autofollow.fetch_poll_interval` | 30s | How often auto-follow tasks poll the leader cluster for new matching indices.
+`plugins.replication.follower.metadata_sync_interval` | 60s | How often the follower cluster polls the leader cluster for updated index metadata.
+

_security-plugin/access-control/permissions.md

@@ -130,6 +130,7 @@ These permissions are for the cluster and can't be applied granularly. For examp
 - cluster:admin/opendistro/reports/instance/list
 - cluster:admin/opendistro/reports/instance/get
 - cluster:admin/opendistro/reports/menu/download
+- cluster:admin/plugins/replication/autofollow/update
 - cluster:admin/reindex/rethrottle
 - cluster:admin/repository/delete
 - cluster:admin/repository/get
@@ -196,6 +197,13 @@ These permissions apply to an index or index pattern. You might want a user to h
 - indices:admin/mappings/fields/get*
 - indices:admin/mappings/get
 - indices:admin/open
+- indices:admin/plugins/replication/index/setup/validate
+- indices:admin/plugins/replication/index/start
+- indices:admin/plugins/replication/index/pause
+- indices:admin/plugins/replication/index/resume
+- indices:admin/plugins/replication/index/stop
+- indices:admin/plugins/replication/index/update
+- indices:admin/plugins/replication/index/status_check
 - indices:admin/refresh
 - indices:admin/refresh*
 - indices:admin/resolve/index
@@ -221,6 +229,8 @@ These permissions apply to an index or index pattern. You might want a user to h
 - indices:data/read/msearch/template
 - indices:data/read/mtv (multi-term vectors)
 - indices:data/read/mtv*
+- indices:data/read/plugins/replication/file_chunk
+- indices:data/read/plugins/replication/changes
 - indices:data/read/scroll
 - indices:data/read/scroll/clear
 - indices:data/read/search
@@ -231,6 +241,7 @@ These permissions apply to an index or index pattern. You might want a user to h
 - indices:data/write/bulk*
 - indices:data/write/delete (delete documents)
 - indices:data/write/delete/byquery
+- indices:data/write/plugins/replication/changes
 - indices:data/write/index (add documents to existing indices)
 - indices:data/write/reindex
 - indices:data/write/update

_security-plugin/access-control/users-roles.md

@@ -109,6 +109,8 @@ Role | Description
 `anomaly_full_access` | Grants full permissions to all anomaly detection actions.
 `anomaly_read_access` | Grants permissions to view detectors, but not create, modify, or delete detectors.
 `all_access` | Grants full access to the cluster: all cluster-wide operations, write to all indices, write to all tenants.
+`cross_cluster_replication_follower_full_access` | Grants full access to perform cross-cluster replication actions on the follower cluster.
+`cross_cluster_replication_leader_full_access` | Grants full access to perform cross-cluster replication actions on the leader cluster.
 `kibana_read_only` | A special role that prevents users from making changes to visualizations, dashboards, and other OpenSearch Dashboards objects. See `opensearch_security.readonly_mode.roles` in `opensearch_dashboards.yml`. Pair with the `kibana_user` role.
 `kibana_user` | Grants permissions to use OpenSearch Dashboards: cluster-wide searches, index monitoring, and write to various OpenSearch Dashboards indices.
 `logstash` | Grants permissions for Logstash to interact with the cluster: cluster-wide searches, cluster monitoring, and write to the various Logstash indices.