Managing PostgreSQL on Kubernetes with Percona Everest’s REST API

I’ve been working with Kubernetes and databases for the past few months, and I’m enjoying learning and exploring more about Percona Everest’s features. Percona Everest is a free, open source tool that makes it easier for teams to manage databases in the cloud.

In a Cloud Native world, everything is programmable, including databases. Percona Everest provides a REST API that lets you manage databases like any other Kubernetes resource, using code, automation, and complete control. To explore this more deeply, I created a friendly and straightforward Python demo app to show how to integrate Everest’s APIs with internal tools.

In this article, we’ll explore how to use APIs to interact with databases in a Kubernetes environment using Percona Everest. I’ve built a simple Python demo, everest-api-demo, that shows how to create, manage, and delete database clusters without using the UI or CLI.

We will cover:

• A quick high-level explanation of APIs
• How to create a PostgreSQL database using the Percona Everest API
• How to list existing database clusters using Python and curl
• How to fetch your database credentials through the API 
• How to delete the database cluster when you are done

Note: Percona Everest also supports MySQL and MongoDB, but we’ll save those for another blog post.

Why APIs?

When I started, I wondered if I had to do everything through the UI. There had to be a better way.

An API (Application Programming Interface) lets two systems talk to each other. You send a request (like “create a database”), and the system responds with data or performs an action.

For example, travel sites don’t own the aeroplanes; they use APIs to get real-time info from different airlines. Percona Everest works similarly: instead of clicking through a UI, you can use its API to automate database operations.

For databases, this means no more manual clicking or editing YAML files. With Percona Everest, you can provision PostgreSQL, MySQL, or MongoDB clusters using simple HTTP requests.

Exploring the Percona Everest API cocumentation

One of the best things about working with the Percona Everest is its excellent, beginner-friendly documentation, which includes APIs. You can explore it here: Percona Everest API Reference.

For every API call, in this picture, the Percona Everest docs show you:

• The HTTP method to use (GET, POST, PUT, or DELETE)
• The full endpoint URL
• Required parameters like namespace and name
• The request format (also called payload or body for POST/PUT)
• Expected responses (such as 200 OK, 404 Not Found, or 500 Server Error)
• curl examples you can copy and try

Using Postman to test API calls

To try Percona Everest’s APIs without writing code, use Postman, a visual tool for sending and inspecting API requests.

Tip: If you’re running Percona Everest locally (e.g., localhost:8080), use the Postman Desktop Agent to allow web-based Postman to send requests through your local machine.

Requirements before using the API

1. We need Percona Everest running on a Kubernetes cluster. For testing, I deployed it to a Google Kubernetes Engine (GKE) cluster, and for temporary local access, I used kubectl port-forward to reach its UI at localhost:8080. Follow the docs to install it with Helm or everestctl

1. You’ll also need a Bearer Token to authenticate your requests.. I grabbed my token from the browser DevTools:

   • Open the Percona Everest UI
   • Log in to Percona Everest  with your credentials
   • Open the Network tab
   • Look at any request → Headers → copy the Authorization: Bearer token

3. When writing scripts that interact with APIs, it’s a good practice to avoid hardcoding values like API URLs, cluster names, or authentication tokens directly in the code. Instead, you can define them as variables at the top of your script or load them from environment variables or config files.

In our Python demo (everest-api-demo), we use variables like these to make the code reusable:

Creating a PostgreSQL cluster with the Percona Everest API

Let’s create a PostgreSQL cluster using the API. Here’s what the setup includes:

• PostgreSQL version: 17.4
• Cluster name: demo-pg-cluster
• Replicas: 1 (single instance)
• Storage: 25 Gi with standard-rwo storage class
• Resources: 1 CPU and 2 GB of memory for the database
• Proxy: PgBouncer with one replica, internal exposure, and minimal resources

In our everest-api-demo, all of this is handled inside the create_cluster() function:

The create_cluster() function prepares all the required database configuration (like PostgreSQL version, storage, resources, and proxy settings) inside a payload dictionary. It then makes a POST request to the Percona Everest API using Python’s requests library to create the cluster.

If the request is successful, the function logs a confirmation message and shows the full payload that was sent; this helps you verify that everything went as expected.

The line response.raise_for_status() ensures the script stops and throws an error if the API returns a failure status (like 400 or 500). This is useful for debugging and makes the script more robust.

To create your PostgreSQL cluster, you simply run:

Sample output:

Equivalent curl command

The same could be done using the following curl:

Listing all database clusters via the API

Once our database is created, the next step is to check what’s running in our cluster. Let’s list all available clusters. The Percona Everest API also provides an endpoint to list all database clusters in a specific namespace. 

You can list all clusters in your namespace using this function:

This function:

• Sends a GET request to the Percona Everest API
• Parses the response to extract cluster details
• Logs the name, engine type, and status of each cluster

To list your active clusters, just run:

And here’s what the output looks like:

This is especially useful when you want to verify the state of your environments, or if you’re managing multiple clusters and want to see what’s deployed quickly.

Getting the PostgreSQL credentials via API

Now that our cluster is running, how do we connect to it? Let’s use the API to retrieve credentials programmatically.

Run the script:

Sample output:

 Using curl instead:

You can then use it directly with a psql command to connect from your Kubernetes cluster:

This is a great way to quickly test your cluster connection without exposing anything externally.

Deleting our PostgreSQL cluster

Once you’re done with your PostgreSQL cluster, you can delete the cluster using the Percona Everest API.

Run the script:

Sample output:

 Using curl instead:

This simple step completes the lifecycle of our database cluster,  from creation and connection to deletion,  all through API calls.

Final thoughts

Feel free to explore the Percona Everest documentation to learn more about what’s possible. You can also check out and use this demo project: everest-api-demo, fork it, modify it, and share improvements!

Do you have questions or feedback? We’d love to hear from you in the Percona Community Forum. Let us know how Percona Everest works for you and how you use it in your projects!

 

Learn more about Percona Everest