{
  "schema_version": 2,
  "id": "integrate/redis-data-integration/data-pipelines/deploy",
  "title": "Deploy a pipeline",
  "url": "https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/deploy/",
  "summary": "Learn how to deploy an RDI pipeline",
  "aliases": [
    "/integrate/redis-data-integration/ingest/data-pipelines/data-type-handling/"
  ],
  "tags": [
    "docs",
    "integrate",
    "rs",
    "rdi"
  ],
  "last_updated": "2026-10-13T08:44:20+03:00",
  "page_type": "content",
  "content_hash": "b3d34307f75430cdb808bc44707846884b0436de696041f6fdf8e99909e329e3",
  "sections": [
    {
      "id": "overview",
      "title": "Overview",
      "role": "overview",
      "text": "The sections below explain how to deploy a pipeline after you have created the required\n[configuration](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines)."
    },
    {
      "id": "set-secrets",
      "title": "Set secrets",
      "role": "content",
      "text": "Before you deploy your pipeline, you must set the authentication secrets for the source\nand target databases. Every secret belongs to one database: a source, identified by its\nname in `config.yaml`, or the target. You name that database with the `--db` option of the\n[`redis-di set-secret`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-set-secret)\ncommand.\n\nThe table below lists the available secret keys. The username and password are required,\nwhile the other keys are only relevant for TLS/mTLS connections.\n\n| Secret key | Description |\n| :-- | :-- |\n| `USERNAME` | Username for the database |\n| `PASSWORD` | Password for the database |\n| `CACERT` | (For TLS only) CA certificate |\n| `CERT` | (For mTLS only) Client certificate |\n| `KEY` | (For mTLS only) Private key |\n| `KEY_PASSWORD` | (For mTLS only) Private key password |\n\nYou can reference a secret in `config.yaml` using an environment variable that is derived from\nthe secret key and the database name. The variable name consists of the database name in\nuppercase (with each dash replaced by an underscore), followed by `_DB_`, followed by the key.\nFor example, if you set `PASSWORD` with `--db mysql` the corresponding environment variable\nis `MYSQL_DB_PASSWORD`, which the source references as\n`${MYSQL_DB_PASSWORD}`. If you set `PASSWORD` with `--db target`, the environment variable is `TARGET_DB_PASSWORD`. The sample\n[config.yaml file](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/pipeline-config#example)\nshows these references in use, and\n[Multiple sources in one pipeline](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/multiple-sources)\ncovers the source naming rules.\n\n> [!NOTE]\n> The scope-prefixed keys `SOURCE_DB_*` and `TARGET_DB_*` are also accepted, and can be\n> used without specifying `--db`. RDI accepts a `SOURCE_DB_*` key only for a pipeline with exactly\n> one source. Prefer the per-database keys with `--db`, which work for any pipeline. See\n> [Existing names are kept after an upgrade](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/multiple-sources#existing-names-are-kept-after-an-upgrade) for more information.\n\n> [!NOTE]\n> When creating secrets for TLS or mTLS, ensure that all certificates and keys are in `PEM` format. The only exception to this is that for PostgreSQL, the source's private key secret must be in `DER` format. If you have a key in `PEM` format, you must convert it to `DER` before creating the secret using the command:\n\n[code example]\n\nThis command assumes that the private key is not encrypted. See the [`openssl` documentation](https://docs.openssl.org/master/) to learn how to convert an encrypted private key."
    },
    {
      "id": "set-secrets-with-the-cli",
      "title": "Set secrets with the CLI",
      "role": "content",
      "text": "Use [`redis-di set-secret`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-set-secret)\nto set secrets for any installation type (VM, Kubernetes, or Redis Cloud).\n\nThe command lines for a source named `mysql` are shown below. If your pipeline has multiple sources, you should run the command once for each source, using the appropriate database name.\n\n[code example]\n\nThe corresponding command lines for target secrets are:\n\n[code example]\n\nBy default, `set-secret` waits for the pipeline to apply the change before returning. When you set\nseveral secrets at once, set all but the last one with `--wait=false` to avoid a timeout while the\npipeline is only partially updated. See [Wait for changes to complete](#wait) below for details."
    },
    {
      "id": "manage-secrets-with-the-cli",
      "title": "Manage secrets with the CLI",
      "role": "content",
      "text": "Along with `set-secret`, the CLI has commands to list, inspect, and delete secrets. Because the API\nnever returns secret values, these commands show only the secret keys and whether they are set, not\nthe stored values.\n\n[code example]\n\nSee the reference pages for\n[`list-secrets`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-list-secrets),\n[`get-secret`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-get-secret),\n[`describe-secret`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-describe-secret),\nand [`delete-secret`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-delete-secret)\nfor the full list of options."
    },
    {
      "id": "set-secrets-for-k8shelm-deployment-using-kubectl-command",
      "title": "Set secrets for K8s/Helm deployment using Kubectl command",
      "role": "content",
      "text": "> [!NOTE]\n> It is strongly recommended to manage secrets with the `redis-di` CLI rather than with\n> `kubectl` directly. The CLI applies the correct labels automatically, validates the secret keys, and\n> works the same way across all installation types.\n\nFor a Kubernetes/Helm deployment, you can also use [`kubectl create secret generic`](https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/kubectl_create_secret_generic/)\nto set secrets instead of the CLI. The general pattern of the commands is:\n\n[code example]\n\nWhere `<DB>` is `<source>-db` for the secrets of a source, or `target-db` for target secrets.\nThe examples below use a source named `mysql`, so its secret is `mysql-db`.\n\nIf you use TLS or mTLS for either the source or target databases, you also need to create the\n`<source>-db-ssl` and/or `target-db-ssl` K8s secrets that contain the certificates used\nto establish secure connections. The general pattern of the commands is:\n\n[code example]\n\nThe specific command lines for source secrets are as follows:\n\n[code example]\n\nThe corresponding command lines for target secrets are:\n\n[code example]\n\nNote that the certificate paths contained in the `CACERT`, `CERT`, and `KEY` secrets are internal to RDI, so you *must* use the values shown in the example above. Each source has its own certificate directory, named after the source (for example, `/etc/certificates/mysql_db/` for a source named `mysql`). You should only change the certificate paths when you create the `<source>-db-ssl` and `target-db-ssl` secrets.\n\nYou must also label any secrets that you create directly with `kubectl` so that the RDI operator\ndiscovers them as pipeline secrets. Give each secret the following labels, where the\n`app.kubernetes.io/instance` label corresponds to the pipeline name (the name is just\n`default` for the default pipeline):\n\n| Label | Value |\n| :-- | :-- |\n| `app.kubernetes.io/name` | `pipeline` |\n| `app.kubernetes.io/instance` | `default` |\n| `product` | `rdi` |\n\nApply the labels to each secret with [`kubectl label`](https://kubernetes.io/docs/reference/kubectl/generated/kubectl_label/):\n\n[code example]"
    },
    {
      "id": "deploy-a-pipeline",
      "title": "Deploy a pipeline",
      "role": "content",
      "text": "When you have created your configuration, including the [jobs](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/transform-examples), you are\nready to deploy. Use the\n[`redis-di deploy`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-deploy)\ncommand to deploy a pipeline:\n\n[code example]\n\nRDI first validates the configuration and then deploys it if it is correct. You can control the\nvalidation and what happens after deployment with the following options:\n\n- `--dry-run`: Validate the configuration without deploying it. Off by default.\n- `--validate-tables`: Validate the configuration against the source and target databases, for\n  example that the tables it references exist. On by default; pass `--validate-tables=false` to skip\n  this check, which is useful when the databases are not reachable at deploy time.\n- `--validate-cdc`: Additionally validate that the source database is correctly configured for\n  [change data capture (CDC)](https://redis.io/docs/latest/integrate/redis-data-integration/architecture#overview).\n  Off by default; enable it with `--validate-cdc`.\n- `--start`: Start the pipeline as soon as it is deployed. On by default; pass `--start=false` to\n  deploy the pipeline without starting it, then start it later with\n  [`redis-di start`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-start).\n\nSee the [`redis-di deploy`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-deploy)\nreference page for the full list of options.\n\nYou can also use [Redis Insight](https://redis.io/docs/latest/develop/tools/insight/rdi-connector)\nto configure and deploy pipelines for both VM and K8s installations."
    },
    {
      "id": "display-the-pipeline-status",
      "title": "Display the pipeline status",
      "role": "content",
      "text": "Once a pipeline is deployed, use the\n[`redis-di describe`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-describe)\ncommand (also available as `redis-di status`) to display its status. This combines the pipeline\nconfiguration with its runtime status, showing its overall state, its sources and targets, its jobs\nand components, and its per-stream statistics and performance metrics.\n\n[code example]\n\nTo watch the status update live, pair the command with `watch`:\n\n[code example]\n\nFor a shorter overview, [`redis-di list`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-list)\nprints a one-line summary of the pipeline, and\n[`redis-di get`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-get)\ndoes the same for a single pipeline. See the\n[`redis-di describe`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-describe)\nreference page for details."
    },
    {
      "id": "start-and-stop-a-pipeline",
      "title": "Start and stop a pipeline",
      "role": "content",
      "text": "Use [`redis-di stop`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-stop)\nto pause a running pipeline and\n[`redis-di start`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-start)\nto resume it. Stopping a pipeline halts data processing without deleting the pipeline or its\nconfiguration. A Debezium source restarts according to its\n[snapshot mode](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/pipeline-config#choose-a-snapshot-mode)\nand the availability of its saved source position.\n\n[code example]\n\nTo act on a single source instead of the whole pipeline, add `--source`:\n\n[code example]\n\nNote that a source can only run if its parent pipeline is running. See\n[Multiple sources in one pipeline](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/multiple-sources) for more information."
    },
    {
      "id": "reset-a-pipeline",
      "title": "Reset a pipeline",
      "role": "content",
      "text": "Use [`redis-di reset`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-reset)\nto clear the pipeline's saved source positions. With the default `initial` snapshot\nmode, a Debezium collector reloads selected source data and then resumes change data capture\n(CDC). Reset does not change the configured\n[snapshot mode](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/pipeline-config#choose-a-snapshot-mode).\nModes that skip existing rows do not reload them after a reset, and `initial_only` mode\ndoes not capture subsequent changes.\n\nReset does not flush the target Redis database. A new snapshot can overwrite target\nrecords, but [missed deletes can leave stale records](https://redis.io/docs/latest/integrate/redis-data-integration/data-pipelines/pipeline-config#missed-deletes).\n\n[code example]\n\nAdd `--source` to reset a single source. The other sources keep their data, but the whole\npipeline stops while the reset runs and starts again afterwards:\n\n[code example]"
    },
    {
      "id": "clear-a-pipeline",
      "title": "Clear a pipeline",
      "role": "content",
      "text": "To stop a pipeline and discard its configuration, deploy an empty configuration with the\n`--empty` option of\n[`redis-di deploy`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-deploy):\n\n[code example]\n\nRDI removes the pipeline's data plane components and deletes its data from the RDI database,\nincluding the change data streams, offsets, schema history, dead-letter queue entries,\nstatistics, deduplication state, and record counters of every source. The pipeline itself\nremains, with an empty configuration, so you can deploy a new configuration to it at any time.\n\nThe pipeline secrets are not affected, so remove them yourself with\n[`redis-di delete-secret`](https://redis.io/docs/latest/integrate/redis-data-integration/reference/cli/redis-di-delete-secret)\nif you no longer need them. The records the pipeline wrote to the target database are not\ndeleted either.\n\n> [!NOTE]\n> Clearing a pipeline discards the source aliases of any source that predates RDI's\n> support for multiple sources, so if you deploy such a source again under the same name you\n> must set its secrets again, and also change its secret references and job `server_name` values. See\n> [Redeploying a configuration after clearing a pipeline](https://redis.io/docs/latest/integrate/redis-data-integration/installation/upgrade#redeploying-a-configuration-after-clearing-a-pipeline)\n> for a before and after example."
    },
    {
      "id": "wait",
      "title": "Wait for changes to complete",
      "role": "content",
      "text": "The commands that change a pipeline's state, namely `deploy`, `start`, `stop`, `reset`,\n`set-secret`, and `delete-secret`, do not return as soon as the API accepts the request. By default,\nthey wait for the pipeline to finish transitioning to the expected state, polling its status until it\nsucceeds, reaches an error, or the `--timeout` (2 minutes by default) elapses. This is usually what\nyou want: the command reflects the real outcome, so a script can rely on the change having taken\neffect and can fail fast if it did not.\n\nIn some cases, though, a pipeline needs *several* changes before it can transition to a healthy state,\nand waiting after each individual change would time out. The clearest example is rotating both the\nusername and the password of a database: if you set only the username with the default `--wait=true`,\nthe pipeline tries to reconnect with the new username and the old password, fails, and the command\ntimes out after two minutes with the pipeline in a broken state.\n\nTo avoid this, set all the related secrets, or at least all of them except the last, with\n`--wait=false`, so the pipeline applies them together and only the final command waits for it to\nbecome healthy:\n\n[code example]\n\nThe same applies to any set of changes that are only valid together."
    }
  ],
  "examples": [
    {
      "id": "set-secrets-ex0",
      "language": "bash",
      "code": "openssl pkcs8 -topk8 -inform PEM -outform DER \\\n    -in /path/to/myclient.pem \\\n    -out /path/to/myclient.pk8 -nocrypt",
      "section_id": "set-secrets"
    },
    {
      "id": "set-secrets-with-the-cli-ex0",
      "language": "bash",
      "code": "# For username and password\nredis-di set-secret USERNAME --db mysql yourUsername\nredis-di set-secret PASSWORD --db mysql yourPassword\n\n# With source TLS, in addition to the above\nredis-di set-secret CACERT --db mysql /path/to/myca.crt\n\n# With source mTLS, in addition to the above\nredis-di set-secret CERT --db mysql /path/to/myclient.crt\nredis-di set-secret KEY --db mysql /path/to/myclient.key\n# Use this only if the private key is password-protected\nredis-di set-secret KEY_PASSWORD --db mysql yourKeyPassword",
      "section_id": "set-secrets-with-the-cli"
    },
    {
      "id": "set-secrets-with-the-cli-ex1",
      "language": "bash",
      "code": "# For username and password\nredis-di set-secret USERNAME --db target yourUsername\nredis-di set-secret PASSWORD --db target yourPassword\n\n# With target TLS, in addition to the above\nredis-di set-secret CACERT --db target /path/to/myca.crt\n\n# With target mTLS, in addition to the above\nredis-di set-secret CERT --db target /path/to/myclient.crt\nredis-di set-secret KEY --db target /path/to/myclient.key\n# Use this only if the private key is password-protected\nredis-di set-secret KEY_PASSWORD --db target yourKeyPassword",
      "section_id": "set-secrets-with-the-cli"
    },
    {
      "id": "manage-secrets-with-the-cli-ex0",
      "language": "bash",
      "code": "# List all the secrets of a pipeline, with the database each one belongs to\nredis-di list-secrets\n\n# List only the secrets of one database\nredis-di list-secrets --db mysql\n\n# Show a single secret and whether it is set\nredis-di describe-secret PASSWORD --db mysql\n\n# Delete a secret (prompts for confirmation unless you add --force)\nredis-di delete-secret CACERT --db mysql",
      "section_id": "manage-secrets-with-the-cli"
    },
    {
      "id": "set-secrets-for-k8shelm-deployment-using-kubectl-command-ex0",
      "language": "bash",
      "code": "kubectl create secret generic <DB> \\\n--namespace=rdi \\\n--from-literal=<SECRET-NAME>=<SECRET-VALUE>",
      "section_id": "set-secrets-for-k8shelm-deployment-using-kubectl-command"
    },
    {
      "id": "set-secrets-for-k8shelm-deployment-using-kubectl-command-ex1",
      "language": "bash",
      "code": "kubectl create secret generic <DB>-ssl \\\n--namespace=rdi \\\n--from-file=<FILE-NAME>=<FILE-PATH>",
      "section_id": "set-secrets-for-k8shelm-deployment-using-kubectl-command"
    },
    {
      "id": "set-secrets-for-k8shelm-deployment-using-kubectl-command-ex2",
      "language": "bash",
      "code": "# Without source TLS\n# Create or update mysql-db secret\nkubectl create secret generic mysql-db --namespace=rdi \\\n--from-literal=MYSQL_DB_USERNAME=yourUsername \\\n--from-literal=MYSQL_DB_PASSWORD=yourPassword \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n\n# With source TLS\n# Create or update mysql-db secret\nkubectl create secret generic mysql-db --namespace=rdi \\\n--from-literal=MYSQL_DB_USERNAME=yourUsername \\\n--from-literal=MYSQL_DB_PASSWORD=yourPassword \\\n--from-literal=MYSQL_DB_CACERT=/etc/certificates/mysql_db/ca.crt \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n# Create or update mysql-db-ssl secret\nkubectl create secret generic mysql-db-ssl --namespace=rdi \\\n--from-file=ca.crt=/path/to/myca.crt \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n\n# With source mTLS\n# Create or update mysql-db secret. Include the MYSQL_DB_KEY_PASSWORD line\n# only if the private key is password-protected.\nkubectl create secret generic mysql-db --namespace=rdi \\\n--from-literal=MYSQL_DB_USERNAME=yourUsername \\\n--from-literal=MYSQL_DB_PASSWORD=yourPassword \\\n--from-literal=MYSQL_DB_CACERT=/etc/certificates/mysql_db/ca.crt \\\n--from-literal=MYSQL_DB_CERT=/etc/certificates/mysql_db/client.crt \\\n--from-literal=MYSQL_DB_KEY=/etc/certificates/mysql_db/client.key \\\n--from-literal=MYSQL_DB_KEY_PASSWORD=yourKeyPassword \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n# Create or update mysql-db-ssl secret\nkubectl create secret generic mysql-db-ssl --namespace=rdi \\\n--from-file=ca.crt=/path/to/myca.crt \\\n--from-file=client.crt=/path/to/myclient.crt \\\n--from-file=client.key=/path/to/myclient.key \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -",
      "section_id": "set-secrets-for-k8shelm-deployment-using-kubectl-command"
    },
    {
      "id": "set-secrets-for-k8shelm-deployment-using-kubectl-command-ex3",
      "language": "bash",
      "code": "# Without target TLS\n# Create or update target-db secret\nkubectl create secret generic target-db --namespace=rdi \\\n--from-literal=TARGET_DB_USERNAME=yourUsername \\\n--from-literal=TARGET_DB_PASSWORD=yourPassword \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n\n# With target TLS\n# Create or update target-db secret\nkubectl create secret generic target-db --namespace=rdi \\\n--from-literal=TARGET_DB_USERNAME=yourUsername \\\n--from-literal=TARGET_DB_PASSWORD=yourPassword \\\n--from-literal=TARGET_DB_CACERT=/etc/certificates/target_db/ca.crt \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n# Create or update target-db-ssl secret\nkubectl create secret generic target-db-ssl --namespace=rdi \\\n--from-file=ca.crt=/path/to/myca.crt \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n\n# With target mTLS\n# Create or update target-db secret. Include the TARGET_DB_KEY_PASSWORD line\n# only if the private key is password-protected.\nkubectl create secret generic target-db --namespace=rdi \\\n--from-literal=TARGET_DB_USERNAME=yourUsername \\\n--from-literal=TARGET_DB_PASSWORD=yourPassword \\\n--from-literal=TARGET_DB_CACERT=/etc/certificates/target_db/ca.crt \\\n--from-literal=TARGET_DB_CERT=/etc/certificates/target_db/client.crt \\\n--from-literal=TARGET_DB_KEY=/etc/certificates/target_db/client.key \\\n--from-literal=TARGET_DB_KEY_PASSWORD=yourKeyPassword \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -\n# Create or update target-db-ssl secret\nkubectl create secret generic target-db-ssl --namespace=rdi \\\n--from-file=ca.crt=/path/to/myca.crt \\\n--from-file=client.crt=/path/to/myclient.crt \\\n--from-file=client.key=/path/to/myclient.key \\\n--save-config --dry-run=client -o yaml | kubectl apply -f -",
      "section_id": "set-secrets-for-k8shelm-deployment-using-kubectl-command"
    },
    {
      "id": "set-secrets-for-k8shelm-deployment-using-kubectl-command-ex4",
      "language": "bash",
      "code": "kubectl label secret mysql-db --namespace=rdi --overwrite \\\n  app.kubernetes.io/name=pipeline \\\n  app.kubernetes.io/instance=default \\\n  product=rdi\nkubectl label secret target-db --namespace=rdi --overwrite \\\n  app.kubernetes.io/name=pipeline \\\n  app.kubernetes.io/instance=default \\\n  product=rdi\n\n# With source TLS or mTLS\nkubectl label secret mysql-db-ssl --namespace=rdi --overwrite \\\n  app.kubernetes.io/name=pipeline \\\n  app.kubernetes.io/instance=default \\\n  product=rdi\n\n# With target TLS or mTLS\nkubectl label secret target-db-ssl --namespace=rdi --overwrite \\\n  app.kubernetes.io/name=pipeline \\\n  app.kubernetes.io/instance=default \\\n  product=rdi",
      "section_id": "set-secrets-for-k8shelm-deployment-using-kubectl-command"
    },
    {
      "id": "deploy-a-pipeline-ex0",
      "language": "bash",
      "code": "redis-di deploy --dir <path to pipeline folder>",
      "section_id": "deploy-a-pipeline"
    },
    {
      "id": "display-the-pipeline-status-ex0",
      "language": "bash",
      "code": "redis-di describe",
      "section_id": "display-the-pipeline-status"
    },
    {
      "id": "display-the-pipeline-status-ex1",
      "language": "bash",
      "code": "watch -n 1 redis-di describe",
      "section_id": "display-the-pipeline-status"
    },
    {
      "id": "start-and-stop-a-pipeline-ex0",
      "language": "bash",
      "code": "redis-di stop\nredis-di start",
      "section_id": "start-and-stop-a-pipeline"
    },
    {
      "id": "start-and-stop-a-pipeline-ex1",
      "language": "bash",
      "code": "redis-di stop --source mysql\nredis-di start --source mysql",
      "section_id": "start-and-stop-a-pipeline"
    },
    {
      "id": "reset-a-pipeline-ex0",
      "language": "bash",
      "code": "redis-di reset",
      "section_id": "reset-a-pipeline"
    },
    {
      "id": "reset-a-pipeline-ex1",
      "language": "bash",
      "code": "redis-di reset --source mysql",
      "section_id": "reset-a-pipeline"
    },
    {
      "id": "clear-a-pipeline-ex0",
      "language": "bash",
      "code": "redis-di deploy --empty",
      "section_id": "clear-a-pipeline"
    },
    {
      "id": "wait-ex0",
      "language": "bash",
      "code": "redis-di set-secret USERNAME --db mysql newUsername --wait=false\nredis-di set-secret PASSWORD --db mysql newPassword",
      "section_id": "wait"
    }
  ]
}