Run PostgreSQL on Kubernetes: A Practical Guide with Benchmarks and Best Practices

Remember when running databases in Kubernetes felt like a gamble? When unpredictable storage performance and complex state management made stability a constant battle? Thankfully, those days are largely behind us. With better tools, smarter operators, and field-tested strategies, you can now confidently deploy PostgreSQL on Kubernetes, especially when you need scale, automation, and platform consistency. Kubernetes has evolved beyond just hosting stateless services; it’s becoming the control plane for everything, including your critical databases.

In this post, you’ll discover why running PostgreSQL on Kubernetes isn’t just feasible but often the smart choice for teams handling growing infrastructure, consolidating environments, or planning for long-term scale. We’ll explore real business benefits, technical advantages, potential pitfalls to watch for, and which storage options perform best (with benchmark data to back it up). You’ll also learn how to get started using Percona Operator for PostgreSQL with our step-by-step implementation guide.

Why forward-thinking organizations are running PostgreSQL on Kubernetes

For teams managing PostgreSQL across multiple environments, Kubernetes offers a practical solution to bring consistency and automation to your database operations. It’s not about following a trend, though; it’s about solving real infrastructure challenges with tools that help you move faster, stay flexible, and reduce manual work.

Whether you’re running PostgreSQL in the cloud, on-premises, or in a hybrid infrastructure, Kubernetes provides tangible advantages for your technical and operational teams. 

Building a more scalable, consistent infrastructure

Your PostgreSQL deployment isn’t static anymore. You might be deploying clusters across regions, replicating data for failover, or integrating with microservices in dynamic environments. Kubernetes is built for exactly this kind of complexity. With the right setup, you can standardize how PostgreSQL is deployed, managed, and scaled across clouds, teams, and development stages. 

You get:

• Repeatable, declarative deployments: Use Kubernetes Operators to define and manage your database state.
• Integrated resiliency: Leverage built-in health checks, automated failover mechanisms, and self-healing capabilities.
• Streamlined DevOps: Natively integrate database provisioning and updates into CI/CD pipelines and GitOps workflows.
• Centralized control: Manage hybrid or multi-cloud database environments from a single control plane.

Think of it as infrastructure-as-code for your database, removing the guesswork from scaling or recovering PostgreSQL.

Meeting enterprise demands at speed

PostgreSQL on Kubernetes can meet stringent high availability (HA) and disaster recovery (DR) requirements, often more efficiently than traditional VM setups or manual configurations. A well-architected Kubernetes deployment allows you to:

• Spin up new clusters with HA enabled by default
• Automate failover and recovery without babysitting it
• Push updates without interrupting service
• Roll out configuration changes across environments in a controlled way

This flexibility is particularly valuable when you’re managing multiple instances, regions, or tenants.

Optimizing infrastructure utilization and budgets

Kubernetes helps teams right-size their resources. You can scale PostgreSQL vertically or horizontally based on usage, and adjust resources like memory, CPU, and storage dynamically. This opens up smarter infrastructure options:

• Lower costs: Consolidate instances onto shared hardware and fine-tune resource allocation to avoid over-provisioning.
• Improve efficiency: Leverage Kubernetes’ intelligent scheduling and auto-scaling capabilities for better resource utilization.
• Simplify stacks: Run databases alongside applications on the same cluster without significantly increasing operational complexity.

Instead of overspending on oversized VMs or getting locked into inflexible managed services, you retain full control.

Addressing common challenges (the right way)

To be clear, running PostgreSQL on Kubernetes isn’t without challenges. There are valid concerns about storage reliability, state management, operator complexity, and disaster recovery. However, these are solvable problems, not roadblocks.

Here’s what typically holds teams back:

• Stateful persistence: Requires robust Persistent Volume configuration, reliable backup strategies, and clear recovery plans.
• Storage performance variability: Performance heavily depends on the underlying storage class, configuration, and workload type.
• DIY complexity: Rolling your own Kubernetes setup often lacks essential components like mature HA, monitoring, or backup integrations.
• Potential lock-in: Some commercial solutions may introduce proprietary extensions or feature limitations behind paywalls.

PostgreSQL on Kubernetes performance: What the benchmark shows

One question we often hear is, “Can Kubernetes storage really keep up with my PostgreSQL workloads?” For database work, performance and reliability aren’t optional features, so we decided to test it.

Percona’s study, Benchmarking PostgreSQL Storage Performance on Kubernetes, compared how different storage solutions handle PostgreSQL workloads when deployed using the Percona Operator for PostgreSQL. The goal was simple: identify how storage choices impact I/O performance and transaction throughput in real-world conditions.

What we tested

The benchmarks ran on AWS EKS (v1.29.4) using i4i instances with local NVMe storage. We evaluated a mix of open source and commercial storage options:

• OpenEBS
• Rook
• Lightbits
• Portworx
• AWS EBS

To simulate actual PostgreSQL activity, we used two testing tools:

• FIO, to measure raw I/O performance (IOPS, bandwidth, latency)
• pgbench, to simulate database workloads and capture TPS (transactions per second)

To reflect how you might run PostgreSQL in different environments, we tested under two memory scenarios:

• Low memory allocation, where PostgreSQL relied heavily on disk I/O
• High memory allocation, where larger shared buffers allowed more operations in memory

Key takeaways

Each storage solution showed distinct strengths:

• OpenEBS stood out in disk-heavy (low-memory) scenarios, delivering top TPS for random I/O workloads. Ideal if your database frequently reads/writes small chunks from disk.
• Portworx showed strong performance with sequential operations and larger datasets, making it suitable for streaming or bulk-processing workloads.
• AWS EBS delivered reliable, predictable results across the board. It’s a solid general-purpose option, especially in environments where consistency matters most.
• Lightbits delivered well-rounded performance, handling both sequential and random I/O steadily, though not always topping the charts in specific categories.
• Rook struggled at higher concurrency levels, where performance degraded more noticeably. It may be better suited for smaller deployments or less intensive workloads.

Perhaps most importantly, we found that the choice of storage backend significantly impacted performance, especially when PostgreSQL was memory-constrained and relied heavily on disk I/O. Throughput and latency varied considerably. With ample memory, the performance differences narrowed, highlighting the trade-offs between infrastructure cost and raw speed.

 

Get the full report with detailed test results and analysis

 

What this means for your PostgreSQL deployment

Storage is arguably the most critical factor influencing PostgreSQL performance on Kubernetes. Your choice directly impacts speed, stability, and cost under load.

This benchmark confirms that PostgreSQL can absolutely thrive on Kubernetes when paired with the right architecture and storage solution. And it reinforces the value of using a tested, production-ready operator like Percona Operator for PostgreSQL to manage the full stack.

How to run PostgreSQL on Kubernetes (Step-by-step guide)

Running PostgreSQL on Kubernetes becomes straightforward when you have the right tools. The process is repeatable, reliable, and production-ready with Percona Operator for PostgreSQL, which handles the heavy lifting of deploying, scaling, and managing your database.

This guide walks through a basic deployment using the Percona Operator for PostgreSQL. While simple, this foundation can be extended for staging and production use. Note: This example uses version 2.3.1. Check the Percona Operator documentation to use the latest stable version.

Install Percona Operator for PostgreSQL

1. Start by creating a dedicated Kubernetes namespace for the Operator. This helps isolate your PostgreSQL workloads and keeps things organized. In this example, we’ll use a namespace called postgres-operator:

2. Deploy the Percona Operator for PostgreSQL into the postgres-operator namespace. In this example, we’re using version 2.3.1 and applying it server-side to ensure everything is configured cleanly:

At this point, the Operator pod should be running. List the pods in your namespace to confirm that it’s in a running state.

3. Now it’s time to deploy Percona Distribution for PostgreSQL by applying the cr.yaml custom resource file.

Check the operator and replica set the Pods’ status.

The Operator may take a few moments to finish initializing.  The creation process is over when reporting the ready status:

The Operator is now installed and deployed. Next, you can connect to your PostgreSQL cluster and start using the database as you normally would.

Connect to the PostgreSQL cluster

The Secrets object we target is named cluster1-pguser-cluster1. We will retrieve the pgBouncer URI from your secret, decode it, and pass it as the PGBOUNCER_URI environment variable. 

The following example shows how to pass the pgBouncer URI from the default Secret object cluster1-pguser-cluster1:

Now let’s create a Pod that runs a container with Percona Distribution for PostgreSQL and connects to the database. The following command does it, naming the Pod pg-client and connecting you to the cluster1 database:

It might take a moment to create the Pod and establish the database connection. Once it’s ready, you’ll see output similar to this:

You’re now connected to your PostgreSQL cluster and ready to start creating tables and inserting data!

Percona’s approach to PostgreSQL on Kubernetes

Running PostgreSQL on Kubernetes is one thing. Running it well, with security, scalability, observability, and expert support, is what sets Percona apart.

We don’t just package a few tools together. Our open source approach gives you a production-ready PostgreSQL stack with all the features you’d expect in an enterprise solution without hidden licensing costs, feature restrictions, or vendor lock-in.

Enterprise features, no strings attached

With Percona Operator for PostgreSQL, you get everything you need right out of the box:

• High availability through Patroni and HAProxy, using architectures built and tested by PostgreSQL experts
• Complete backup and disaster recovery via pgBackRest, with both full and incremental backup options
• Efficient connection pooling with PgBouncer to maintain performance under heavy loads
• Advanced security using pgAudit, set_user, role management, and support for Transparent Data Encryption (TDE is currently in release candidate status, with general availability expected in Q3 2025.)
• Comprehensive monitoring with PMM and pg_stat_monitor, tools specifically built for PostgreSQL that provide deep, actionable insights

There’s no proprietary wrapper or enterprise-only tier. Everything we build is fully open source.

Unified management with Percona Everest

For organizations managing multiple database types (PostgreSQL, MySQL, MongoDB) on Kubernetes, Percona Everest provides a unified, self-service platform. It simplifies provisioning, scaling, backups, and monitoring across your diverse database fleet, offering an open source alternative to proprietary DBaaS platforms.

Expertise on your terms

Sometimes you want to run everything yourself. Sometimes you want a partner. Percona gives you options without locking you into one path.

We offer:

• 24/7/365 support: Mission-critical support with guaranteed SLAs from PostgreSQL experts.
• Managed Services: Let Percona handle the day-to-day operations, monitoring, and maintenance of your databases.
• Consulting and health checks: Strategic guidance on architecture, performance tuning, migration, and scaling.
• Training and onboarding: Empower your teams with the skills needed to run PostgreSQL effectively on Kubernetes.

And because we support MySQL, MongoDB, and PostgreSQL, we help you remain database-agnostic even as your infrastructure grows.

Doing more with Percona for PostgreSQL on Kubernetes

PostgreSQL and Kubernetes make a powerful combination, but only when you have the right architecture, storage, and operational support. When done well, this approach gives you a consistent, scalable way to run PostgreSQL anywhere, without relying on proprietary tools or sacrificing performance.

That’s exactly what we deliver.

With Percona for PostgreSQL, you get everything needed to run PostgreSQL in production, from high availability and security to backups, monitoring, and enterprise-grade extensions. Our Operator for PostgreSQL is included as part of the solution, giving you a fully open source, thoroughly tested deployment framework backed by PostgreSQL experts.

No lock-in. No compromise. Just a proven way to run PostgreSQL securely and reliably, wherever you need it.

 

Explore our PostgreSQL on Kubernetes solution