Compatibility requirements for ZDM Proxy

True zero downtime migration with ZDM Proxy is possible only if your clusters, data model, and application logic meet the compatibility requirements described on this page.

You might need to adjust your data model or application logic to ensure compatibility between the origin and target clusters during the migration and ongoing compatibility with the target cluster after the migration.

If you cannot meet these requirements, particularly the cluster and schema compatibility requirements, see Compare DataStax migration tools for alternative migration tools and strategies.

Supported Cassandra Native Protocol versions

ZDM Proxy supports protocol versions v3, v4, DSE_V1, and DSE_V2.

ZDM Proxy technically doesn’t support v5. If v5 is requested, the proxy handles protocol negotiation so that the client application properly downgrades the protocol version to v4. This means that you can use ZDM Proxy with any client application that uses a driver version supporting protocol version v5, as long as the application doesn’t use v5-specific functionality.

Thrift isn’t supported by ZDM Proxy

If you are using an earlier driver or cluster version that only supports Thrift, you must change your client application to use CQL, and, if needed, upgrade your cluster before starting the migration process.

Supported data store providers, versions, and migration paths

You can use ZDM Proxy to support migrations between Astra, DataStax Enterprise (DSE), Hyper-Converged Database (HCD), open-source Apache Cassandra®, and and other Cassandra-based databases. Supported migration paths include cross-platform migrations and same-platform upgrades.

DataStax tests ZDM Proxy compatibility with Astra, DSE, HCD, and open-source Cassandra. Support for other Cassandra-based databases is possible if the origin and target clusters share a common protocol version. However, DataStax doesn’t test all data store providers, and DataStax doesn’t guarantee full support for any specific data store aside from the platforms and versions listed here.

Compatible origin clusters

Migrate from one of the following:

  • Astra DB Serverless or Astra Managed Clusters (Astra DB Classic).

  • Hyper-Converged Database (HCD).

  • DataStax Enterprise (DSE) version 4.7.1 and later.

  • Apache Cassandra® version 2.1.6 and later.

    ZDM Proxy requires that the origin and target clusters share a common protocol version. Therefore, Cassandra 2.0 migrations are only possible when migrating to 2.1 or 2.2 because Cassandra 2.0 supports only v2.

  • Other Cassandra-based databases that are based on a compatible Cassandra version, such as ScyllaDB and Yugabyte.

Compatible target clusters

Migrate to one of the following:

You can use ZDM for major version upgrades to your current database platform, such as upgrades from DSE 5.0 to DSE 6.9. Using ZDM reduces the risk of data loss or corruption due to breaking changes between versions, provides a seamless rollback option, and streamlines the upgrade process, eliminating the need for interim upgrades and progressive manual reconfiguration.

Schema and keyspace alignment

To successfully migrate with ZDM Proxy, the origin and target clusters must have matching schemas, including keyspace names, table names, column names, and data types. A CQL statement produced by your client application must be able to succeed without modification on both clusters because ZDM Proxy routes the exact same CQL statements to both clusters.

Even without ZDM Proxy, matching schemas are required for most CQL-based data migration tools, such as Astra DB Sideloader and Cassandra Data Migrator. If it is impossible to match the schemas, your migration cannot use ZDM Proxy. See Compare DataStax migration tools for alternative migration tools and strategies, such as extract, transform, and load (ETL) processes.

ZDM Proxy doesn’t modify or transform CQL statements with the exception of optional replacement for now().

A CQL statement that your client application sends to ZDM Proxy must be able to succeed on both clusters. This means that any keyspace that your client application uses must exist on both the origin and target clusters with the same keyspace name, table names, column names, and compatible data types. However, the keyspaces can have different replication strategies and durable write settings.

At the column level, the schema doesn’t need to be a one-to-one match as long as the CQL statements can be executed successfully on both clusters. For example, if a table has 10 columns, and your client application uses only five of those columns, then you can recreate the table on the target cluster with only the five required columns. However, the data from the other columns won’t be migrated to the target cluster if those columns don’t exist on the target cluster. Before you decide to omit a column from the target cluster, make sure that it is acceptable to permanently lose that data after the migration.

In some cases, you can change the primary key on the target cluster. For example, if your compound primary key is PRIMARY KEY (A, B), and you always provide parameters for the A and B columns in your CQL statements, then you could change the key to PRIMARY KEY (B, A) when creating the schema on the target because your CQL statements will still run successfully.

Lightweight Transactions and other non-idempotent operations

Non-idempotent CQL operations don’t produce the exact same result each time the request is executed. Whether the request is executed and the actual value written to the database depend on the column’s current value or other conditions at the time of the request. Examples of non-idempotent operations include the following:

By design, a ZDM migration involves two separate clusters, and it is possible for the clusters to have differences due to non-idempotent operations.

If you use non-idempotent operations, DataStax recommends adding a reconciliation phase to your migration before and after Phase 4. This allows you an additional opportunity to resolve any data inconsistencies that are produced by non-idempotent operations. The Cassandra Data Migrator is ideal for detecting and reconciling these types of inconsistencies.

However, if your application workloads can tolerate inconsistencies produced by LWTs and non-idempotent operations, you might not need to perform any additional validation or reconciliation steps. This depends entirely on your application business logic and requirements. It is your responsibility to determine whether your workloads can tolerate these inconsistencies and to what extent.

Lightweight Transactions and the applied flag

ZDM Proxy handles LWTs in the same way as other write requests: It sends the request to both clusters concurrently, and then it waits for both to respond. ZDM Proxy returns a success status to the client only if both clusters send successful acknowledgements; otherwise, it returns a failure status.

However, clusters can consider an LWT to be successful with or without data modification, because LWTs modify data only if a specific condition is met, and they don’t fail if the condition isn’t met. With ZDM Proxy, this means both clusters can return successful acknowledgements with different outcomes on each cluster. This is because the evaluation of an LWT’s condition is based on the state of the data on the cluster at the time of the request. For example, if the condition is met on the origin cluster but not on the target cluster, then the data is modified on the origin cluster only.

If your application logic includes LWTs, you must reconcile any inconsistences caused by LWTs, and understand how the applied flag is handled by ZDM Proxy:

Repeatedly validate and reconcile data to catch all inconsistencies

During the ZDM process, the clusters aren’t fully synchronized until the data has been completely replicated and thoroughly validated at the end of Phase 2. Up to that point, LWTs can produce inconsistent data that you must reconcile at the end of Phase 2. Furthermore, because ZDM Proxy is designed to continuously route writes to both clusters, you might need to validate and reconcile the data multiple times to catch additional inconsistencies that occurred while you were reconciling previous inconsistencies.

Don’t rely on the applied flag

A cluster’s response to an LWT includes an applied flag. If applied is True, then the LWT’s condition was met and the data was actually modified. If applied is False, then the condition wasn’t met and the data wasn’t modified.

Outside of a migration scenario, this flag is passed to the client application from the one cluster that the client is connected to. However, with ZDM Proxy, the responses from both clusters are passed to ZDM Proxy, which then passes only one response back to the client application. This is intentional because ZDM Proxy is designed to be transparent to the client application: The client application believes it is interacting with a single cluster.

Specifically, ZDM Proxy returns the response, including the applied flag, from the primary cluster. For the majority of the migration process, the origin cluster is the primary cluster. Near the end of the migration (Phase 4), the target cluster becomes the primary cluster.

If your application logic depends on the applied flag, be aware that, during the migration, your application receives the applied flag from the primary cluster only. It cannot access the applied flag from the secondary cluster. If needed, modify your application logic in anticipation of this behavior. Or, plan to thoroughly reconcile inconsistencies that occur due to LWTs before the final phases of the migration (Phase 4 and Phase 5) where the target cluster becomes the primary cluster and your applications stop using the origin cluster.

Server-side non-deterministic functions in the primary key

Statements with UUID and timeuuid functions, like now() and uuid(), create data inconsistencies between the origin and target clusters because the values are computed at the cluster level.

If these functions are used for regular non-primary key columns, you must determine if it is acceptable to have different values in the two clusters depending on your application business logic. However, if these functions are used in any primary key column, then your data migration phase will fail because of data inconsistencies between the two clusters. Effectively, the clusters will never be truly in sync from a programmatic perspective.

ZDM Proxy has an option to replace now() with a timeUUID calculated at the proxy level to ensure that these records write the same value to both clusters.

To enable this feature, set replace_cql_functions to true. For more information, see Change a mutable configuration variable.

The replace_cql_functions option only replaces the now() function.

This feature is disabled by default because it has a noticeable impact on performance. DataStax recommends that you test this feature extensively before using it in production.

If the performance impact is unacceptable for your application, or you are using functions other than now(), then you must change your client application to use values calculated locally at the client-level before the statement is sent to the database. Most drivers have utility methods that help you compute these values locally. For more information, see your driver’s documentation and Query timestamps in Cassandra drivers.

Driver retry policy and query idempotence

The ZDM process requires you to perform rolling restarts of your client applications during the migration. This is standard practice for client applications that are deployed over multiple instances, and it is a widely used approach to roll out releases and configuration changes.

Throughout the migration process, you must restart ZDM Proxy instances to apply configuration changes. Client applications handle this in the same way as typical rolling restarts of DSE or Cassandra clusters.

If your applications already tolerate rolling restarts of your origin cluster, then you shouldn’t expect any issues during rolling restarts of ZDM Proxy instances.

To ensure that your client application retries requests that fail due to connection errors caused by the rolling restart process, check your driver’s retry policies and whether your requests are marked as idempotent. Most drivers treat all statements as non-idempotent by default, and they don’t automatically retry them. This means that you must explicitly mark statements as idempotent to trigger retries after connection errors. For more information, see Query idempotence in Cassandra drivers and Cassandra driver retry policies.

Client compression

The binary protocol used by Astra, DSE, HCD, and open-source Cassandra supports optional compression of transport-level requests and responses that reduces network traffic at the cost of CPU overhead.

When establishing connections from client applications, ZDM Proxy responds with a list of compression algorithms supported by both clusters. The compression algorithm configured in your DataStax-compatible driver must match any item from the common list, or CQL request compression must be disabled completely. ZDM Proxy cannot decompress and recompress CQL requests using different compression algorithms.

This isn’t related to storage compression, which you can configure on specific tables with the compression table property. Storage/table compression doesn’t affect the client application or ZDM Proxy in any way.

Authenticator and authorizer configuration

A cluster’s authorizer doesn’t affect client applications or ZDM Proxy, which means that you can use any kind of authorizer configuration on your clusters, and they can use different authorizers.

In contrast, a cluster’s authenticator must be compatible with ZDM Proxy. ZDM Proxy supports the following cluster authenticator configurations:

  • No authenticator

  • PasswordAuthenticator

  • DseAuthenticator with internal or ldap scheme

ZDM Proxy doesn’t support DseAuthenticator with kerberos scheme.

The origin and target clusters can have different authentication configurations because ZDM Proxy treats them independently.

DSE advanced workloads

This section describes how ZDM Proxy handles certain DSE advanced workloads. For more DSE-specific migration considerations, see Migrate to DataStax Enterprise.

DSE Graph

ZDM Proxy handles all DSE Graph requests as write requests even if the traversals are read-only. There is no special handling for these requests, so you must consider the traversals that your client application sends and determine whether the traversals are idempotent. If the traversals are non-idempotent, then your must thoroughly validate and reconcile the data and the end of Phase 2 to ensure that the target cluster is truly consistent with the origin cluster. For more information, see Lightweight Transactions and other non-idempotent operations.

DataStax’s recommended tools for data migration and reconciliation are CQL-based, so they only support migrations where the origin cluster is a database that uses the new DSE Graph engine (DSE 6.8 and later). They cannot be used with the earlier Graph engine in DSE versions prior to 6.8.

DSE Search

Read-only DSE Search workloads can be moved directly from the origin to the target without ZDM Proxy being involved. If your client application uses Search and also issues writes, or if you need the read routing capabilities from ZDM Proxy, then you can connect your Search workloads to ZDM Proxy as long as you are using DataStax-compatible drivers to submit these queries. This approach means the queries are regular CQL SELECT statements, so ZDM Proxy handles them as regular read requests.

If you use the HTTP API then you can either modify your applications to use the CQL API instead, or you must move those applications directly from the origin to the target when the migration is complete, if that is acceptable for your use case.

Astra migrations

This section describes specific considerations for Astra migrations. If you need to make any changes to your data model or application logic for compatibility with Astra, do so before starting the migration. As mentioned previously, this is because ZDM Proxy requires that the same CQL statements can be executed successfully on both clusters, and the data migration tools require matching schemas.

Astra guardrails, limits, and CQL compatibility

As a managed database-as-a-service (DBaaS) offering, Astra implements guardrails and limits on its databases, and Astra doesn’t support all CQL functionality. Make sure your application workloads and CQL statements are compatible with these limitations.

In self-managed clusters, such as DSE and Cassandra, you can configure the database limits in cassandra.yml. Many of these limits aren’t configurable in Astra, and those that can be changed require intervention by DataStax Support.

Astra doesn’t support consistency level ONE

CL.ONE isn’t supported by Astra, and read and write requests sent through ZDM Proxy with CL.ONE to Astra DB databases always fail. ZDM Proxy doesn’t mute these failures because you need to be aware of them. You must adapt your client application to use a consistency level that is supported by both clusters to ensure that the migration is seamless and error-free.

Astra doesn’t support the Stargate APIs

The Stargate APIs (Document, REST, GraphQL, gRPC) are deprecated for Astra. If you are migrating to Astra from an origin cluster that uses any of these APIs, your client applications won’t work with Astra. Before you migrate, you must change your applications to use other programmatic access, such as Cassandra drivers or the Data API. For more information, see Migrate to the Data API from the Stargate APIs.

Read-only applications

In versions 2.1.0 and later, ZDM Proxy sends periodic heartbeats to keep idle cluster connections alive. The default interval is 30,000 milliseconds, and it can be configured with the heartbeat_interval_ms variable, or by directly setting the ZDM_HEARTBEAT_INTERVAL_MS environment variable if you aren’t using ZDM Proxy Automation.

In ZDM Proxy versions earlier than 2.1.0, read-only applications require special handling to avoid connection termination due to inactivity.

DataStax recommends that you use ZDM Proxy version 2.1.0 or later to benefit from the heartbeat feature. If you cannot use version 2.1.0 or later, see the alternatives described in Client application closed connection errors every 10 minutes when migrating to Astra DB.

Multi-datacenter clusters and other complex migrations

Complex migration scenarios, such as multi-datacenter migrations or many-to-one migrations, require additional planning to configure ZDM Proxy and migrate the data efficiently.

Multi-region migrations require additional planning and action depending on factors like the amount of data, number of regions, data consistency requirements, and orchestration of multi-region traffic.

Multi-region migrations can include one or more of the following scenarios:

  • Your origin cluster is deployed to multiple regions, with or without enforced consistency.

  • Your target database is, or will be, deployed to multiple regions.

  • You need to support multiple regions in a live migration scenario.

  • You are migrating to Astra DB, and you need to prepare to follow the eventual consistency model for multi-region databases.

For relatively small migrations to Astra DB with consistent data across all regions, you can migrate the primary region first, and then add additional regions after the initial migration is complete. This strategy allows Astra DB’s eventual consistency model to replicate the data from the primary region to the additional regions. However, this approach isn’t suitable for all migrations.

It is difficult to provide a one-size-fits-all solution for multi-region migrations due to the potential complexity and variability of these scenarios. For assistance planning a multi-region migration, contact your DataStax account representative or DataStax Support.

To configure ZDM Proxy for a multi-datacenter migration, see the ZDM Proxy infrastructure guidelines for multi-datacenter clusters.

For more guidance on migrations to Astra, see the Astra DB Sideloader preparations for specific migration scenarios.

Was this helpful?

Give Feedback

How can we improve the documentation?

© Copyright IBM Corporation 2025 | Privacy policy | Terms of use Manage Privacy Choices

Apache, Apache Cassandra, Cassandra, Apache Tomcat, Tomcat, Apache Lucene, Apache Solr, Apache Hadoop, Hadoop, Apache Pulsar, Pulsar, Apache Spark, Spark, Apache TinkerPop, TinkerPop, Apache Kafka and Kafka are either registered trademarks or trademarks of the Apache Software Foundation or its subsidiaries in Canada, the United States and/or other countries. Kubernetes is the registered trademark of the Linux Foundation.

General Inquiries: Contact IBM