Continuous Data end-of-life notice

Action required: The Continuous Data UI, API, and CLI are scheduled for end of life. Review the latest migration guidance and start planning your transition to Data Control Tower.

On new engine installations of 2026.5.0.0 and later, the Admin UI opens directly to the Performance Dashboard, and the Manage, Resources, and System menus are unavailable. Engines upgraded from an earlier version keep full Admin UI access. This restriction cannot be changed by customers; contact Delphix Support if you need it lifted temporarily.

Learn more about the Continuous Data end-of-life announcement.

Overview

OCI WORM offline replication uses an Oracle Cloud Infrastructure (OCI) Object Storage bucket with a WORM retention policy as the transfer medium between source and target Delphix engines. The source writes replication serialization points to the bucket. The target reads and applies them without connecting directly to the source.

OCI offline replication also works with a bucket without a retention rule. Configure a WORM retention rule in OCI when you need to prevent changes to or deletion of replication data during the retention period.

This storage option extends offline replication alongside the existing NFS workflow. The NFS workflow is unchanged. For its procedures and concepts, see Offline replication (air gap).

Prerequisites

  • Use separate source and target Delphix Engines running 2026.6.0.0 or later. You cannot create the corresponding send and receive profiles on the same engine.

  • Configure an OCI Object Storage bucket accessible to both engines. For immutable replication data, configure its WORM retention rule in OCI before sending data. The Delphix Engine detects retention rules when a job runs and does not configure or store a retention setting.

  • Configure API key pair or instance-principal access for each engine. Grant the identities used by the profiles permission to read, write, and list bucket objects, manage multipart uploads, and read retention rules. For instance principals, grant access through an OCI dynamic group and IAM policy. For API keys, grant access through the OCI user's group and IAM policy. Source and target profiles can use different identities or authentication methods against the same bucket.

  • For API signing-key setup, see Oracle API signing-key documentation. For instance-principal setup, see OCI object storage setup. Use that topic's identity setup instructions only: its bucket-protection restrictions concern engine backing storage, not the offline replication bucket.

  • Synchronize both engines' clocks using NTP. OCI can reject signed requests if the clock has drifted.

Profile fields

  • Bucket name: The name of the OCI Object Storage bucket.

  • Authentication method: Instance principal or API key pair. Instance principal uses the engine's own OCI instance identity and requires the engine to be an OCI compute instance enrolled in a dynamic group. If no method is specified through the API, instance principal is used.

If you choose API key pair authentication, also provide the following fields:

  • Region: The OCI region where the bucket is located.

  • Tenancy OCID: The Oracle Cloud Identifier of your OCI tenancy.

  • User OCID: The Oracle Cloud Identifier of the OCI user that owns the API signing key.

  • Fingerprint: The fingerprint of the API signing key.

  • Private key: The private key of the API signing key pair.

  • Passphrase (optional): The passphrase for the private key, if one is set.

Upload the public signing key to the OCI user and use the matching PEM-encoded RSA private key in the profile. The OCI Console provides the tenancy OCID, user OCID, and fingerprint after the public key is uploaded. The passphrase is needed only if the private key is encrypted.

Full send policy

Offline replication to an OCI WORM bucket supports both incremental and full sends. An optional full send policy controls when a full serialization point is sent instead of an incremental one. Set the policy by number of runs (intervalRuns), elapsed time (intervalDuration), or both.

For a bucket with finite retention rules, intervalDuration must be shorter than the longest finite retention period. The engine validates this when you commit the profile and rejects an invalid interval. An intervalRuns-only policy is not checked against retention. If you change the bucket's retention later, recheck the full-send interval yourself.

Keep a recent full serialization point and the subsequent incremental points needed by your targets. Expiration of a retention period allows objects to be deleted; it does not itself mean that they have been deleted. Coordinate bucket cleanup with replication schedules so required points remain available.

The send profile's runtime.lastFullSendTimestamp and runtime.runsSinceLastFullSend report the last full send and the number of runs since it.

Configure an OCI WORM profile

The following CLI procedures create a send profile on the source and a receive profile on the target. Replace the example bucket name, object reference, tag, and credentials with your values. The Engine API examples provide an alternative for API-based workflows.

Create the send profile through the CLI

  1. Log in to the source engine CLI. Start a send profile with the OCI bucket and the group or dataset to replicate:

    source> cd replication/spec
    source replication spec> create
    source replication spec create *> set name=oci-send
    source replication spec create *> set dataTraffic.type=ReplicationOfflineTraffic
    source replication spec create *> set dataTraffic.offlineStorage.type=OciOfflineStorage
    source replication spec create *> set dataTraffic.offlineStorage.bucketName=<bucket-name>
    source replication spec create *> set objectSpecification.objects=<group-or-dataset-reference>
  2. Configure authentication. For instance principal, leave dataTraffic.offlineStorage.auth unset to use the source engine's OCI identity. For API key pair authentication, set these fields before committing:

    source replication spec create *> set dataTraffic.offlineStorage.auth.type=OciApiKeyAuth
    source replication spec create *> set dataTraffic.offlineStorage.auth.region=<oci-region>
    source replication spec create *> set dataTraffic.offlineStorage.auth.tenancyOcid=<tenancy-ocid>
    source replication spec create *> set dataTraffic.offlineStorage.auth.userOcid=<user-ocid>
    source replication spec create *> set dataTraffic.offlineStorage.auth.fingerprint=<key-fingerprint>
    source replication spec create *> set dataTraffic.offlineStorage.auth.privateKey="-----BEGIN RSA PRIVATE KEY-----
    <key body>
    -----END RSA PRIVATE KEY-----
    > "

    Paste the complete PEM private key between the quotes, including its BEGIN and END lines. If the key is encrypted, also set dataTraffic.offlineStorage.auth.passphrase.

  3. Commit the profile, then record its generated tag for the receive profile:

    source replication spec create *> commit
    source replication spec> select oci-send
    source replication spec 'oci-send'> ls

    The engine validates required API key fields and the RSA PEM key at commit. A successful commit does not prove that the credentials have all required bucket permissions. Some settings, including retention-interval validation, also require bucket access at commit. Other OCI authentication or access errors appear when the profile runs.

Create the receive profile through the CLI

  1. Log in to the target engine CLI. Use the same bucket and the source profile's tag. On the receive profile, offlineStorage is directly on the profile, not under dataTraffic:

    target> cd replication/receive
    target replication receive> create
    target replication receive create *> set name=oci-receive
    target replication receive create *> set tag=<source-spec-tag>
    target replication receive create *> set offlineStorage.type=OciOfflineStorage
    target replication receive create *> set offlineStorage.bucketName=<bucket-name>
  2. For instance principal, leave offlineStorage.auth unset to use the target engine's OCI identity. For API key pair authentication, set the target-side credentials:

    target replication receive create *> set offlineStorage.auth.type=OciApiKeyAuth
    target replication receive create *> set offlineStorage.auth.region=<oci-region>
    target replication receive create *> set offlineStorage.auth.tenancyOcid=<tenancy-ocid>
    target replication receive create *> set offlineStorage.auth.userOcid=<user-ocid>
    target replication receive create *> set offlineStorage.auth.fingerprint=<key-fingerprint>
    target replication receive create *> set offlineStorage.auth.privateKey="-----BEGIN RSA PRIVATE KEY-----
    <key body>
    -----END RSA PRIVATE KEY-----
    > "

    If the key is encrypted, also set offlineStorage.auth.passphrase. The target can use the same key as the source or a different key with access to the bucket.

  3. Commit the profile and confirm its bucket and tag:

    target replication receive create *> commit
    target replication receive> select oci-receive
    target replication receive 'oci-receive'> ls

    The receive tag cannot be changed after profile creation. On a target engine, use only one receive profile for a given source tag.

Data Control Tower

For the DCT send and receive procedures, authentication fields, and execution options, see Configure OCI offline replication in DCT. The CLI and Engine API procedures in this topic operate directly on the engines; the DCT workflow manages the corresponding profiles through replication policies.

In the DCT Create Replication Policy wizard, use Offline - Send or Offline - Receive as the Traffic Mode. On Replication Target, choose OCI Object Store and enter the bucket and authentication settings. A receive policy also needs the target engine and the Source replication tag from the send policy's Overview tab.

For a send policy, the Parameters step includes Full Send Interval (runs) and Full Send Interval Duration. These configure the same policy described above; using the Engine API is an alternative, not a requirement.

Configure the full send policy through the CLI

On the source engine, update the send profile. This example sets both a five-run interval and a one-day interval; you can set either or both:

source replication spec 'oci-send'> update
source replication spec 'oci-send' update *> set dataTraffic.fullSendPolicy.type=FullSendPolicy
source replication spec 'oci-send' update *> set dataTraffic.fullSendPolicy.intervalRuns=5
source replication spec 'oci-send' update *> set dataTraffic.fullSendPolicy.intervalDuration=P1D
source replication spec 'oci-send' update *> commit

Use an interval shorter than the bucket's finite retention period. The engine contacts the bucket to validate intervalDuration when you commit.

Configure the full send policy through the Engine API

Engine API paths below are relative to https://<engine-address>/resources/json/delphix. Establish an authenticated API session as described in Create authenticated sessions, using API version 1.11.52 or later.

  1. On the source engine, read the profile with GET /replication/spec/{specRef}, using its replication spec reference.

  2. In the spec's dataTraffic object, add fullSendPolicy. Set intervalRuns to a positive integer for a run-based policy, or intervalDuration to an ISO 8601 duration for a time-based policy. For example, this policy requests a full serialization point every seven runs:

    "fullSendPolicy": {
        "type": "FullSendPolicy",
        "intervalRuns": 7
    }

    For a time-based policy, replace "intervalRuns": 7 with, for example, "intervalDuration": "P7D" for seven days. Choose a duration shorter than the bucket's longest finite retention period. You can also set both fields.

  3. Update the spec with POST /replication/spec/{specRef}. Submit a ReplicationSpec payload containing the updated dataTraffic object with type ReplicationOfflineTraffic. Preserve the bucket and authentication mode. On an existing API-key profile, omit unchanged credential fields to keep their stored values. Do not send redacted values from a read response as credentials.

  4. Read the spec again and confirm that dataTraffic.fullSendPolicy contains the intended values.

Send replication data

Scheduled and on-demand sends follow the replication spec in the same way as NFS-based offline replication. After the initial full send, each run sends an incremental serialization point unless the full send policy requires a full one.

To run a normal send through the CLI:

source replication spec 'oci-send'> execute
source replication spec 'oci-send' execute *> commit

Wait for the send job to complete successfully before running the target's receive profile. To force a full send for one execution:

source replication spec 'oci-send'> execute
source replication spec 'oci-send' execute *> set sendMode=FULL
source replication spec 'oci-send' execute *> commit

Omit sendMode to use the configured policy. FULL forces a full serialization point for that run. FORCE_INCREMENTAL discards an in-progress full send and forces an incremental send.

In DCT, open the send policy's Actions menu to access the send dialog, then choose Use configured policy, Full Send, or Incremental Send. The DCT API also supports POST /replication-profiles/{id}/force-full-send. Through the Engine API, use POST /replication/spec/{specRef}/execute with the payload {"type":"ReplicationSpecExecuteParameters","sendMode":"FULL"}. Monitor the job and confirm that it completes successfully.

Receive and restore data

Run a receive through the CLI

After the source send completes, execute the receive profile created above:

target replication receive 'oci-receive'> execute
target replication receive 'oci-receive' execute *> commit

The first successful receive creates the replica dataset on the target. Monitor the job until it completes successfully. To identify the last received serialization point:

target replication receive 'oci-receive'> getLastReceivedInfo
target replication receive 'oci-receive' getLastReceivedInfo *> commit

Configure and run a receive through the Engine API

As an alternative to the CLI, configure the target through the Engine API. Paths are relative to https://<engine-address>/resources/json/delphix on the engine receiving the request. Establish an authenticated API session on each engine using API version 1.11.52 or later.

  1. On the source engine, read the send spec with GET /replication/spec/{specRef} and record its tag. Confirm that a send to the OCI bucket has completed successfully.

  2. On the target engine, create a receive spec with POST /replication/receive. Set tag to the source spec's tag. Set offlineStorage to an OciOfflineStorage object with the same bucketName and authentication for the target engine. For API key pair authentication, use the following payload, replacing the placeholder values with your target-side credentials:

    {
        "type": "OfflineReplicationReceiveSpec",
        "name": "oci-offline-receive",
        "tag": "<source-spec-tag>",
        "offlineStorage": {
            "type": "OciOfflineStorage",
            "bucketName": "<bucket-name>",
            "auth": {
                "type": "OciApiKeyAuth",
                "region": "<oci-region>",
                "tenancyOcid": "<tenancy-ocid>",
                "userOcid": "<target-user-ocid>",
                "fingerprint": "<key-fingerprint>",
                "privateKey": "<PEM-encoded-private-key>"
            }
        }
    }

    Add passphrase to auth if the private key is encrypted. Encode line breaks in the PEM key as \n in JSON. For instance-principal authentication, replace the auth object with {"type":"OciInstancePrincipalAuth"}. Grant the target identity the bucket permissions listed in Prerequisites.

  3. Record the receive spec reference returned by the create request. Run POST /replication/receive/{receiveSpecRef}/execute on the target engine.

  4. Monitor the receive job until it completes successfully. Then call GET /replication/receive/{receiveSpecRef}/getLastReceivedInfo and check lastSendTimestamp and lastOfflineSerializationPointId to identify the serialization point received. Repeat the receive operation for subsequent serialization points.

Archive restore behavior

If the bucket uses OCI's Archive tier, the receive job restores archived objects automatically. While restoring, the job reports a WAITING_FOR_UNARCHIVE status with the number of pending and total objects, then continues to normal completion. Metadata and data can require separate restore requests, so the receive may wait more than once. Restore time depends on OCI; no separate unarchive request or operator action is required.

Receive policy and recovery

NEXT_IN_CHAIN, the default receive policy, applies the next serialization point in sequence. LATEST_FULL_PREFERRED selects the latest available full serialization point ahead of the target and skips intervening points. If no qualifying full point exists, it falls back to NEXT_IN_CHAIN. Subsequent receives apply the incremental points after the selected full point.

If a required serialization point has been deleted, the receive fails and identifies the missing point. Force a full send on the source, wait for it to complete, then receive with a one-time policy override:

target replication receive 'oci-receive'> execute
target replication receive 'oci-receive' execute *> set receivePolicy=LATEST_FULL_PREFERRED
target replication receive 'oci-receive' execute *> commit

To make the policy persistent, set receivePolicy in an update to the receive profile instead. Through the Engine API, use POST /replication/receive/{receiveSpecRef}/execute with {"type":"OfflineReplicationReceiveSpecExecuteParameters","receivePolicy":"LATEST_FULL_PREFERRED"} for a one-time override.

In DCT's receive dialog, Use configured policy uses the profile's receive policy, Next in Chain selects NEXT_IN_CHAIN, and Full Receive selects LATEST_FULL_PREFERRED.

Rotate an API signing key

Upload the replacement public key to the OCI user, then update each profile that uses that key. On the source profile, update dataTraffic.offlineStorage.auth.fingerprint and dataTraffic.offlineStorage.auth.privateKey. On a receive profile, use offlineStorage.auth.fingerprint and offlineStorage.auth.privateKey. Update the passphrase if required, then commit the profile.

The engine stores the private key and passphrase encrypted and does not display them. Omit unchanged fields when updating an existing API-key profile to retain their values. If the source and target use the same key, update both profiles before running them with the replacement key.

Cleanup

Both engines clean up their local send and receive caches after each job. Bucket cleanup is separate from this local cleanup.

cleanupOfflineData on a receive profile deletes received serialization points from offline storage after a successful receive. Its default is false. It is supported for NFS shares and OCI buckets without retention rules, but not for WORM buckets.

The engine rejects cleanupOfflineData=true at commit if the bucket has a retention rule. If a retention rule is added after the profile was created, the cleanup step fails at run time. Set cleanupOfflineData=false on the receive profile before running it against the protected bucket.

For WORM buckets, keep engine cleanup disabled and manage object deletion in OCI after protection expires. Do not delete serialization points still needed by any target. Retention expiry alone does not delete objects or reclaim space.

API reference

OCI WORM offline replication uses the standard replication spec API on the Delphix Engine.

  • On the source, set offlineStorage in the replication spec's ReplicationOfflineTraffic to an OciOfflineStorage object with bucketName and auth (OciInstancePrincipalAuth or OciApiKeyAuth). Optionally set fullSendPolicy.

  • On the target, set offlineStorage in the OfflineReplicationReceiveSpec to an OciOfflineStorage object with the same bucketName and target-side auth. Set tag to match the source spec.

  • Run sends with POST /replication/spec/{specRef}/execute and receives with POST /replication/receive/{receiveSpecRef}/execute. Both use the public execute operation.

For the full list of new and updated API objects, see the API changes section of the 2026.6 release notes.

In the DCT API, the ReplicationProfile resource includes offline_storage_type and oci_bucket_name fields, and POST /replication-profiles/{id}/force-full-send triggers an on-demand full send. For API specifications by DCT version, see the DCT API references.

Retention and limitations

  • Retention is enforced by the OCI bucket's WORM retention rule. Objects cannot be overwritten or deleted before the retention period expires. The Delphix Engine does not configure or store retention settings.

  • For finite retention rules, intervalDuration must be shorter than the longest finite retention period. This is checked when the profile is committed, not continuously after bucket-retention changes.

  • OCI WORM Object Storage is the supported immutable object-storage implementation for this release. Other cloud providers' immutable storage services are not supported.

Last updated
Nov 10, 2026