Most production-ready, full-fledged applications require a secure and consistent database to store large amounts of data. Therefore, choosing the correct database solution is crucial for your application’s overall health and performance. However, microservices and distributed environments further complicate the choice. In this article, we’ll examine PostgreSQL and Apache Cassandra databases to learn how they compare in a Kubernetes environment.

What is PostgreSQL?

PostgreSQL is an open-source relational database. It started as the University of California, Berkley’s POSTGRES project in 1986 and remains active even now.

The database features reliability, data integrity, performance, fault tolerance, security, extensibility, and internationalization. It runs on most operating systems and has several powerful add-ons, such as the PostGIS geospatial database extender. Finally, it is fully compliant with atomicity, consistency, isolation, and durability (ACID) standards. 

What is Apache Cassandra?

Cassandra is an open-source, NoSQL, distributed database. It is written in Java and built for horizontal scaling, flexibility, elasticity, extreme fault tolerance, reliability, and speed in distributed environments. Initially, Facebook created it as an internal tool. Then it became part of the Apache Incubator project. 

Cassandra is favored for its lightweight and robust non-relational structure.

Differences between Cassandra and PostgreSQL:

PostgreSQL Cassandra
Developed by PostgreSQL Global Development Group in 1989. Developed by Apache Software foundation and released in July 2008.
PostgreSQL is written in C languages. Cassandra is written in Java languages.
It has user defined functions for Server-side scripts. It does not supports Server-side scripting.
It is widely used by open source RDBMS. It is wide column store based on ideas of BigTable and DynamoDB.
The primary database model for PostgreSQL is Relational DBMS. The primary database model for Cassandra is Wide column store.
It has Document store as Secondary database models. It has no Secondary database models.
Server operating systems for PostgreSQL are FreeBSD, HP-UX, Linux, NetBSD, OpenBSD, OS X, Solaris, Unix and Windows. Server operating systems for Cassandra are BSD, Linux, OS X and Windows.
It supports XML format. It does not support XML format.
It supports Secondary indexing. It supports Secondary indexing but in a restricted way, i.e., only equality queries, not always the best performing solution.
It supports Master-master replication method. It supports selectable replication factor method.
In PostgreSQL, partitioning can be done by range, list and hash. In Cassandra, partitioning can be done Sharding.
PostgreSQL provides the concept of Referential Integrity and have Foreign keys. Cassandra does not provides the concept of Referential Integrity. Hence, no Foreign Keys.
It does not offers an API for user-defined Map/Reduce method. It offers an API for user-defined Map/Reduce methods.

What to Consider While Running a Database on Kubernetes

Kubernetes has become the de facto container orchestrator for cloud-native microservices and distributed applications. This open-source orchestration tool manages containerized workloads and services.

However, running databases on Kubernetes clusters is not as straightforward as running applications. Before running a database on a Kubernetes cluster, consider a few different factors.

First, Kubernetes is a stateless environment, whereas databases are stateful applications — that is — they preserve data. The database you choose should handle storage using Kubernetes methods like StatefulSets and PersistentVolumes.

Additionally, the database you select should feature inbuilt sharding, failover election, and replication capabilities — or at least the ability to perform these tasks.

Furthermore, Operators are not to be overlooked. They are application-specific controllers that automate administrative tasks.

Finally, databases that handle transient data and caching are better suited to the Kubernetes cluster. So, the database of your choice should be robust and resilient to ever-changing data and environments.

Using Cassandra in Kubernetes

Cassandra and Kubernetes work well together in a tech stack for several reasons:

  • Availability: Cassandra is a NoSQL database and a distributed database. Therefore, its architecture fits well with Kubernetes. Its replication techniques and distributed storage make Cassandra resilient and highly available.
  • Scalability: Cassandra allows vertical and horizontal scaling since it depends on nodes with minimal downtime. As a result, Kubernetes can handle scaling Cassandra nodes.
  • Elasticity: Cassandra can add or remove nodes as required without severe repercussions. Again, Kubernetes can assume this function. Cassandra’s elasticity also ensures that it optimally uses nodes and has almost no idle resources during non-peak times.
  • Self-Healing Capability: Kubernetes can restart failed containerized applications, including Cassandra nodes. Cassandra’s replication strategies also ensure better recovery of failed nodes without data loss.

Cassandra and Kubernetes work well together in compute, network, and storage capabilities due to their similar architectures. Nodes make both systems inherently resilient in a distributed environment. However, Cassandra and Kubernetes don’t mesh together well in certain instances.

Challenges of Using Cassandra in Kubernetes

The first challenge of using Cassandra in Kubernetes is their differing compute and storage capabilities. Kubernetes separates compute and storage functions, ensuring the stored data is not lost even if a node fails. However, Cassandra groups these services as a single unit.

Cassandra handles faster reads and writes by writing some of the data in the RAM and some in the persistent store. Therefore, if the Cassandra node fails, the data in the RAM is lost. Retrieving the data requires manual intervention.

The second challenge is identifying nodes. Cassandra identifies its nodes using IP addresses that are different each time. So, every time a node is deleted or added to the Cassandra cluster, the entire node-creation process repeats.

Backups also present a challenge when using Cassandra in Kubernetes. Kubernetes uses CronJobs and similar methods to handle backups. However, due to Cassandra’s inherent replication strategy, part of the data is stored in RAM and the rest is stored on disk.

So, every time a backup occurs, it must flush the data stored in RAM out to the storage. This action stalls the Cassandra node and makes it temporarily unresponsive during the flush.

Furthermore, the type of data stored is significant. Cassandra handles large data sets at blazing speeds. However, it is schema-free and not ACID-compliant. So, it’s not a wise choice for applications with sensitive data that must be consistent at all times.

Finally, there is a lack of documentation and support for using Cassandra. Apache does not have official Cassandra documentation related to Kubernetes installations, so users must instead rely on third-party solutions for troubleshooting.

PostgreSQL in Kubernetes

PostgreSQL and Kubernetes feature different architectures and running mechanisms that don’t mesh. However, Postgres has evolved and extended its core functionality to be more compatible with distributed environments. Operators help Postgres and Kubernetes work well together and enhance the capabilities of an already robust database system.

The advantages of using PostgreSQL with Kubernetes include:

  • Performance: Running Postgres in a Kubernetes environment enhances its performance. It can leverage the Kubernetes architecture to improve horizontal scaling in a distributed architecture. Kubernetes can create and deploy nodes when required, and Postgres’ data replication ensures up-to-date data.
  • Automatic Failover: Postgres inherently uses Write-Ahead Logging (WAL) to store all transaction log data in persistent storage. If a node fails, you can retrieve these transaction logs and restore the data. Kubernetes leverages this mechanism to enhance automatic failover while ensuring data consistency.
  • Scalability: Postgres can leverage Kubernetes’ ability to scale on demand. It takes little effort to set up a Postgres node due to Kubernetes’ replication and automatic failover capability. Kubernetes helps Postgres handle client requests efficiently and automatically without latency issues or the hassle of connection-pooling and similar mechanisms.
  • Stateful Workloads: Kubernetes has evolved to handle stateful workloads — those that preserve their state from one session to the next. Stateful workloads ensure that Postgres keeps its reliability, security, and consistency features in a distributed environment.
  • Documentation: PostgreSQL provides excellent and detailed documentation within manuals, tutorials, and books.

Postgres and Kubernetes can adapt to work well together. However, some specific considerations and prerequisites require administrative expertise. 

Challenges of Using PostgreSQL in Kubernetes

To maximize the benefit of using Postgres with Kubernetes, you should first consider storage. Postgres should have a data layer that dynamically allocates storage space to ensure data availability. Use a container-native storage capability to keep the data available if you need to restart or replicate nodes or pods.

Also, consider availability. Postgres ensures high fault tolerance and data availability using WAL. The Kubernetes architecture should ensure that the containers support local storage to provide Postgres with the benefits of this mechanism. The containers should also ensure high read-write performance to avoid latency issues.

Finally, consider pod specifications. Typically, a Kubernetes environment has two Postgres instances: the primary and the standby. The primary instance or pod is for all read and write operations. The standby is for disaster recovery if the primary fails. To ensure that this failover is correct and automatic, both types of instances or pods should have the exact specifications at all times.

When to Use Cassandra

Apache Cassandra was built for speed and is mainly a query-based database. It outshines most other database solutions for query-heavy operations. Cassandra scales well and has an efficient failover mechanism. So, any application should use Apache Cassandra if it requires frequent writes over large volumes of data in a distributed environment, cannot lose its data, and cannot afford database downtimes.

These properties make Apache Cassandra ideal for order-, health-, and food-tracking applications. Cassandra is also suitable for transaction-logging applications, time-series data analysis, and reporting applications.

However, Cassandra is not an ideal choice when an application must always maintain ACID properties or must update data frequently.

When to Use Postgres

PostgreSQL is an ACID-compliant relational database packed with many extensions. It provides high performance, transactional consistency, data security and safety, and reliability for large datasets. Postgres is an excellent choice for any application that requires ACID-compliance, heavy and frequent data updates (reads), and reliable and long-term data storage.

It is ideal for banking applications that require consistent data, supply-chain applications, and scientific data applications that generate terabytes of data.

Using Database as a Service

You must adjust Postgres and Cassandra workloads to fit well in a Kubernetes environment. These adjustments require a significant amount of expertise and continued maintenance to ensure the database works optimally.

One way to optimize all of the specifications is to use a managed service for deploying databases. A managed service is a low-ops choice because the service manages functions such as backups, scaling, and data security.

Just create your database and application while a managed database service like Portworx Data Services handles the rest. Portworx Data Services provides a complete solution for deploying and managing database-reliant applications in a distributed and microservices architecture like Kubernetes.


Neither PostgreSQL nor Apache Cassandra is entirely Kubernetes-compatible, but both options can work well with a few tweaks. The CNCF asserts that Postgres is mature enough to integrate into a Kubernetes environment, whereas Cassandra is not yet sufficiently usable. However, Cassandra is maturing at a rapid rate.

Both PostgreSQL and Cassandra possess unique benefits and drawbacks, and your choice ultimately depends on your use case. Then, services like Portworx Data Services can help optimize your database configuration and management.

Whether you choose PostgreSQL or Cassandra, you can always learn more about how Portworx makes your data services scalable, available, and secure on Kubernetes.

Subscribe for Updates

About Us
Portworx is the leader in cloud native storage for containers.


Bhavin Shah

Sr. Technical Marketing Manager | Cloud Native BU, Pure Storage
Explore Related Content:
  • databases
  • kubernetes
April 1, 2022 Architect’s Corner
Leveraging Databases in Multi-Cloud Kubernetes
Tim Darnell
Tim Darnell
March 25, 2022 Architect’s Corner
Choosing a Kubernetes Operator for Cassandra
Ryan Wallner
Ryan Wallner
March 18, 2022 Technical Insights
Choosing a Kubernetes Operator for PostgreSQL
Bhavin Shah
Bhavin Shah