10 Cloud-Native Database Tools Used in DevOps
10 cloud-native database tools for DevOps: CockroachDB, YugabyteDB, TiDB, Vitess, Aurora, MongoDB Atlas, CloudNativePG, Liquibase, Flyway, Atlas.
Cloud-native database tools fall into two groups. Some are databases built to run across many nodes or as a managed service (CockroachDB, YugabyteDB, TiDB, Vitess, Amazon Aurora, MongoDB Atlas, CloudNativePG). The others manage schema change as code (Liquibase, Flyway, Atlas), so database updates move through the same CI/CD pipeline as application code.
This guide covers ten of them from a DevOps point of view: how each one is deployed, how it fits a pipeline, what its license allows, and where it is the wrong choice. If you are still building the basics, start with our What is DevOps guide and come back to the data layer afterwards.
Key takeaways
- Distributed SQL databases (CockroachDB, YugabyteDB, TiDB) replicate data with the Raft consensus protocol, so losing one node does not stop writes.
- Vitess does not replace MySQL. It shards and routes traffic to many ordinary MySQL instances.
- Managed services such as Aurora and MongoDB Atlas move patching, backups and failover to the provider, but you still own schema changes, indexes and cost.
- CloudNativePG runs PostgreSQL on Kubernetes through an operator and a
Clustercustom resource. - Liquibase, Flyway and Atlas turn schema changes into versioned files that a pipeline can validate and apply.
- Licenses changed recently: CockroachDB moved to a single Enterprise license with a free tier in late 2024, and Liquibase Community 5.0 moved to the Functional Source License in September 2025.
What "cloud-native" means for a database
For stateless services, cloud-native usually means containers, declarative config and automated recovery. A database keeps state, so the bar is different. In practice a database counts as cloud-native for DevOps work when it meets most of these conditions:
- It survives the loss of a node or an availability zone without manual failover.
- You can add capacity by adding nodes, not only by buying a bigger server.
- It can be created and changed through an API, a Kubernetes operator or an infrastructure as code provider.
- Backups, upgrades and scaling can run from automation instead of runbooks typed by hand.
- Schema changes can be stored in Git, reviewed and applied by a pipeline.
The first four points are about the database engine or service. The last point is about tooling around it, which is why schema migration tools belong on this list.
The 10 tools at a glance
| Tool | Type | Compatible with | How DevOps teams run it | License model |
|---|---|---|---|---|
| CockroachDB | Distributed SQL | PostgreSQL wire protocol | Self-hosted (Kubernetes operator or VMs) or CockroachDB Cloud | CockroachDB Software License (Enterprise, with a free tier) |
| YugabyteDB | Distributed SQL | PostgreSQL (YSQL) and a Cassandra-style API (YCQL) | Self-hosted with Helm, or managed YugabyteDB Aeon | Open source core (Apache 2.0) |
| TiDB | Distributed SQL (HTAP) | MySQL protocol | TiDB Operator on Kubernetes, TiUP on VMs, or TiDB Cloud | Apache 2.0 |
| Vitess | Sharding layer for MySQL | MySQL | Vitess Operator on Kubernetes, or hosted through PlanetScale | Apache 2.0, CNCF graduated |
| Amazon Aurora | Managed relational database | MySQL and PostgreSQL | AWS console, CloudFormation, Terraform, CDK | Commercial AWS service |
| MongoDB Atlas | Managed document database | MongoDB API | Atlas CLI, Atlas Kubernetes Operator, Terraform provider | Commercial service (server is SSPL) |
| CloudNativePG | Kubernetes operator for PostgreSQL | PostgreSQL | Cluster custom resource, GitOps | Apache 2.0 |
| Liquibase | Schema change management | Most SQL databases and some NoSQL | CLI, Maven/Gradle, Docker image in CI | Community 5.x under FSL-1.1-ALv2; Liquibase Secure is commercial |
| Flyway | Schema migration | Most SQL databases | CLI, Maven/Gradle, Docker image in CI | Open source edition plus commercial Redgate editions |
| Atlas | Schema as code | PostgreSQL, MySQL, SQLite, SQL Server and others | CLI, GitHub Actions, Kubernetes operator, Terraform provider | Open core with a commercial cloud |
Distributed SQL databases
1. CockroachDB
CockroachDB splits data into ranges and replicates each range with Raft, by default three copies. Any node can accept a query, and the cluster rebalances data when nodes join or leave. It speaks the PostgreSQL wire protocol, so most PostgreSQL drivers and many ORMs work, although not every PostgreSQL feature or extension is supported. Check the compatibility notes before you port an application.
Features that matter for operations include online schema changes, multi-region table localities (you can pin rows to a region for latency or data residency), changefeeds that stream row changes to Kafka or cloud storage, and built-in backup to object storage.
Licensing: Cockroach Labs retired the free Core edition with version 24.3 in November 2024. Self-hosted users now run under one Enterprise license. An Enterprise Free tier covers individuals, students, academic researchers and businesses under 10 million US dollars in annual revenue, renewed yearly, and it requires telemetry. Larger companies need a paid license after a trial. Confirm the current terms on the Cockroach Labs license page before you commit.
Good fit: transactional systems that must stay writable through a zone or region failure. Poor fit: small single-region apps where a managed PostgreSQL instance is cheaper and simpler.
2. YugabyteDB
YugabyteDB separates a query layer from a distributed storage layer called DocDB, which also uses Raft. Its YSQL API reuses the PostgreSQL query layer, so it supports more PostgreSQL features than most distributed databases, including many extensions. YCQL is a separate API modeled on Cassandra Query Language for wide-column workloads.
For Kubernetes, Yugabyte publishes Helm charts, and the managed service is called YugabyteDB Aeon. Tablets (YugabyteDB's shards) split automatically as they grow. Plan for the extra latency of distributed transactions: a query that touches rows on several nodes costs more than the same query on a single PostgreSQL server.
Good fit: teams with PostgreSQL skills who need horizontal scale and multi-zone resilience.
3. TiDB
TiDB is a MySQL-compatible database from PingCAP. Its architecture has three parts: stateless TiDB servers that parse SQL, TiKV for row storage (TiKV is a CNCF graduated project), and PD (Placement Driver) that stores metadata and schedules data placement. An optional columnar engine, TiFlash, keeps a replica of data in column format so analytical queries can run without a separate data warehouse. This mix is often called HTAP (hybrid transactional and analytical processing).
DevOps teams deploy it with TiDB Operator on Kubernetes or with the TiUP tool on virtual machines. Because each layer scales on its own, you can add SQL servers for more connections and TiKV nodes for more storage.
Good fit: MySQL applications that have outgrown one primary server, or teams that want reporting on live data.
4. Vitess
Vitess began at YouTube to scale MySQL and is now a CNCF graduated project. It keeps MySQL as the storage engine and adds a routing layer. Applications connect to vtgate, which looks like a MySQL server and sends each query to the right shard. Each MySQL instance runs next to a vttablet process that manages it. Vitess can reshard online, so a table can be split across more shards while traffic continues.
The Vitess Operator, maintained by PlanetScale, runs Vitess on Kubernetes. PlanetScale's hosted database is built on Vitess, so it is the usual managed option. Expect to choose sharding keys carefully: queries that cross shards are possible but slower, and some MySQL features behave differently behind vtgate.
Good fit: very large MySQL estates that need to shard without rewriting the application.
Managed cloud databases
5. Amazon Aurora
Aurora is AWS's MySQL- and PostgreSQL-compatible relational database. Its storage layer is shared by the writer and up to 15 read replicas in a cluster and keeps six copies of data across three Availability Zones. Failover to a replica is automatic. Aurora Serverless v2 scales capacity in fine-grained units for spiky workloads, and Aurora Global Database replicates a cluster to other Regions for disaster recovery.
For DevOps work, Aurora is usually defined in CloudFormation, CDK or Terraform. A small Terraform example:
resource "aws_rds_cluster" "app" {
cluster_identifier = "app-aurora"
engine = "aurora-postgresql"
master_username = "app_admin"
manage_master_user_password = true
backup_retention_period = 7
storage_encrypted = true
deletion_protection = true
}
resource "aws_rds_cluster_instance" "app" {
count = 2
identifier = "app-aurora-${count.index}"
cluster_identifier = aws_rds_cluster.app.id
instance_class = "db.r6g.large"
engine = aws_rds_cluster.app.engine
}
manage_master_user_password stores the password in AWS Secrets Manager instead of in Terraform state. deletion_protection stops an accidental terraform destroy from removing the database.
Good fit: teams already on AWS that want relational storage without running replication themselves. Watch: I/O and cross-Region transfer charges; compare the Aurora Standard and Aurora I/O-Optimized storage configurations for I/O-heavy workloads.
6. MongoDB Atlas
Atlas is MongoDB's managed service and runs on AWS, Azure and Google Cloud. A cluster is a replica set (or a sharded cluster for larger data), with automated backups, point-in-time restore and built-in metrics. Atlas also includes Atlas Search and Atlas Vector Search on the same data.
Automation options are good. The Atlas CLI scripts clusters and users, the official Terraform provider (mongodb/mongodbatlas) manages projects, clusters and network peering, and the Atlas Kubernetes Operator lets you declare Atlas resources as Kubernetes custom resources so GitOps tools can manage them.
Good fit: applications with flexible document schemas. Watch: a schemaless database still needs schema discipline. Use JSON Schema validation on collections and keep index definitions in code.
Running PostgreSQL on Kubernetes
7. CloudNativePG
CloudNativePG is an operator that manages the full life cycle of PostgreSQL clusters on Kubernetes: primary election, streaming replicas, automated failover, rolling updates, backups to object storage and point-in-time recovery. It does not use a separate failover tool such as Patroni. The operator itself watches instances and talks to the Kubernetes API.
A minimal three-instance cluster looks like this:
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
name: app-db
spec:
instances: 3
storage:
size: 20Gi
storageClass: fast-ssd
monitoring:
enablePodMonitor: true
The operator creates one primary and two replicas, plus Kubernetes Services for read-write and read-only traffic. Because the whole database is a YAML object, it fits GitOps: Argo CD or Flux can apply changes, and pull requests show exactly what changed. Storage still decides your durability, so read our guide to Kubernetes storage options before picking a StorageClass, and pair the cluster with a tested backup plan from our Kubernetes backup tools list.
Good fit: platform teams that already run Kubernetes well and want PostgreSQL close to their apps. Poor fit: teams new to Kubernetes, who will find a managed PostgreSQL service safer.
Database as code: schema migration tools
A database engine does not solve the most common source of deployment failures on the data side: schema changes made by hand. The next three tools put changes in version control so a pipeline can check and apply them. For zero-downtime release patterns built on top of these tools, see our guide to blue/green database migration.
8. Liquibase
Liquibase tracks changes as changesets in a changelog file, written in SQL, XML, YAML or JSON. It records applied changesets in a DATABASECHANGELOG table and uses a lock table so two deployments cannot run at once. Many change types can generate rollback statements automatically, and you can write custom rollbacks.
databaseChangeLog:
- changeSet:
id: 2027-01-add-orders
author: platform-team
changes:
- createTable:
tableName: orders
columns:
- column:
name: id
type: bigint
constraints:
primaryKey: true
- column:
name: status
type: varchar(20)
Typical pipeline commands are liquibase status to list pending changes, liquibase update-sql to print the SQL for review, and liquibase update to apply it.
Licensing: starting with version 5.0 (September 2025), Liquibase Community is released under the Functional Source License (FSL-1.1-ALv2). Each release converts to Apache 2.0 two years after it ships. Liquibase states that FSL does not meet the Open Source Initiative definition of open source. Liquibase Secure is the commercial edition. Check whether your organization's legal policy allows FSL software before you upgrade from 4.x.
9. Flyway
Flyway, from Redgate, uses plain SQL files with a naming convention. Versioned migrations look like V3__add_orders_table.sql and run once in order. Repeatable migrations start with R__ and run again whenever their checksum changes, which suits views and stored procedures. Applied versions are recorded in the flyway_schema_history table.
# Show applied and pending migrations
flyway info
# Fail the build if applied files were edited after release
flyway validate
# Apply pending migrations
flyway migrate
Pass the connection URL and credentials through environment variables or a secrets manager in CI, never in the repository. Since Flyway 9, the destructive clean command is disabled by default, which protects production databases from an accidental wipe.
Liquibase or Flyway? Flyway is simpler when your team writes SQL and moves forward only. Liquibase suits teams that want database-neutral changesets, preconditions and generated rollbacks.
10. Atlas
Atlas, from Ariga, takes a declarative approach similar to Terraform. You describe the desired schema in HCL, SQL or an ORM model, and Atlas computes the migration needed to get there. It can also work in a versioned mode and generate migration files with atlas migrate diff.
Its most useful pipeline feature is linting. atlas migrate lint flags risky changes such as dropping a column, adding a non-nullable column without a default, or creating an index that locks a table. Atlas publishes GitHub Actions, a Kubernetes operator and a Terraform provider, so schema changes can follow the same review flow as infrastructure.
How database tools fit a CI/CD pipeline
- Commit: the developer adds a migration file next to the application change.
- Lint: the pipeline runs
atlas migrate lintor a review ofliquibase update-sqloutput to catch destructive statements. - Test: a disposable database (a container started by the CI job, or a CloudNativePG cluster in a test namespace) applies every migration from zero, then the integration tests run.
- Validate:
flyway validateor a Liquibase checksum check confirms nobody edited a migration that already ran in production. - Deploy: migrations run as a separate pipeline step or a Kubernetes Job before the new application version rolls out.
- Observe: watch query latency, replication lag and lock waits after the change.
Write migrations so the old and new application versions both work during the rollout. The usual pattern is expand and contract: add the new column first, deploy code that writes to both, backfill, switch reads, and only then drop the old column in a later release. Our list of pipeline automation tools by stage shows where this step sits next to build and test stages.
How to choose
| If you need... | Start with |
|---|---|
| PostgreSQL behavior with horizontal scale | YugabyteDB or CockroachDB (check license terms) |
| To scale an existing MySQL application | TiDB or Vitess |
| Relational storage on AWS with little operations work | Amazon Aurora |
| Flexible documents on any major cloud | MongoDB Atlas |
| PostgreSQL inside your Kubernetes platform | CloudNativePG |
| SQL-first, forward-only migrations | Flyway |
| Database-neutral changesets with rollback | Liquibase |
| Declarative schema with migration linting | Atlas |
Two questions settle most decisions. First, do you really need more than one writable node? Many applications run well for years on a single managed PostgreSQL or MySQL primary with replicas. Second, who will be on call for the database? A distributed database on Kubernetes needs people who understand both.
Common mistakes
- Running a stateful database on Kubernetes without tested restores. A backup you have never restored is a guess.
- Editing a migration file after it has run in production, which breaks checksums and leaves environments out of step.
- Storing database passwords in Terraform variables or Helm values in Git. Use a secrets manager; our guide to Kubernetes secrets tools covers the options.
- Choosing a distributed database for scale you do not have, then paying for cross-node latency on every transaction.
- Ignoring license changes when upgrading. Read the release notes for license terms, not only for features.
Learn the skills behind these tools
Running databases this way draws on Kubernetes operators, storage, CI/CD and infrastructure as code. Our DevOps training in Pune covers pipelines and IaC, and the CKA training covers StatefulSets, PersistentVolumes and operators. Both run in our Kharadi classroom and live online across India.
Frequently asked questions
What is a cloud-native database?
It is a database built to run on cloud or Kubernetes infrastructure: it survives node or zone loss without manual failover, scales by adding nodes or capacity units, and can be created, changed and backed up through APIs or operators instead of manual steps.
Is CockroachDB still open source?
No. Since version 24.3 in November 2024, self-hosted CockroachDB runs under one Enterprise license. A free tier covers individuals, students, researchers and businesses under 10 million US dollars in annual revenue, renewed yearly, with telemetry required.
What is the difference between Vitess and TiDB?
Vitess keeps ordinary MySQL instances and adds a routing and sharding layer in front of them. TiDB is its own distributed database that speaks the MySQL protocol and stores data in TiKV, with optional columnar replicas for analytics.
Should I run databases on Kubernetes?
You can, with an operator such as CloudNativePG, if your team already runs Kubernetes well and tests restores. Teams new to Kubernetes are usually safer with a managed database service.
Is Liquibase still free?
Liquibase Community remains free to use, but from version 5.0 (September 2025) it is licensed under the Functional Source License, which converts each release to Apache 2.0 after two years. Check that your legal policy allows it.
Flyway or Liquibase: which should I pick?
Pick Flyway if your team writes plain SQL and only moves forward. Pick Liquibase if you want changesets that work across database engines, preconditions and generated rollback statements.
How do I run schema migrations without downtime?
Use the expand and contract pattern: add new structures first, deploy code that works with both old and new schemas, backfill data, switch reads, and remove old structures in a later release.
Official references
- Cockroach Labs: Enterprise license update
- YugabyteDB documentation
- TiDB architecture (PingCAP docs)
- Vitess documentation
- What is Amazon Aurora? (AWS docs)
- MongoDB Atlas documentation
- CloudNativePG documentation
- Liquibase: Community license change to FSL
- Flyway documentation (Redgate)
- Atlas documentation
What's Your Reaction?
Like
0
Dislike
0
Love
0
Funny
0
Angry
0
Sad
0
Wow
0