Introduction

PostgreSQL is one of the most powerful open-source relational database management systems that supports SQL compliance and advanced features. As applications scale, managing PostgreSQL effectively is critical—and this is where Docker and Kubernetes shine. Docker allows us to package PostgreSQL as a lightweight container, while Kubernetes orchestrates these containers to ensure we have a reliable and scalable deployment.

In this guide, we’ll navigate through the essential steps of using PostgreSQL with Docker and Kubernetes, ensuring that you have a strong understanding of the fundamentals along the way.

Prerequisites

Before we dive into the setup, ensure you have the following installed:

• Docker: Download and install Docker Desktop.
• Kubernetes: Use Minikube or k3s for running Kubernetes on your local machine.
• kubectl: Kubernetes command-line tool. Follow the instructions here to install it.

Step 1: Running PostgreSQL with Docker

First, let’s run PostgreSQL in a Docker container. You can use the official PostgreSQL Docker image to make this process straightforward.

Pull the PostgreSQL Image

Open your terminal and execute:

docker pull postgres:latest

Run PostgreSQL Container

Now we can run a PostgreSQL container:

docker run --name my-postgres -e POSTGRES_PASSWORD=mysecretpassword -d -p 5432:5432 postgres

• --name my-postgres: Names the container for easy reference.
• -e POSTGRES_PASSWORD=mysecretpassword: Sets the PostgreSQL user password.
• -d: Runs the container in detached mode.
• -p 5432:5432: Maps port 5432 on your host to port 5432 in the container.

You can check if the container is running with:

docker ps

Connect to PostgreSQL

To connect to PostgreSQL running in Docker, you can use any PostgreSQL client or the psql CLI:

docker exec -it my-postgres psql -U postgres

You can now create databases, tables, and perform any PostgreSQL operations as needed.

Step 2: Deploying PostgreSQL on Kubernetes

Now that we have a PostgreSQL container running, let’s deploy it on Kubernetes using a Deployment and a Service for easier access.

Create a Persistent Volume

First, we need a Persistent Volume to store our database data. Create a YAML file postgres-pv.yaml:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgres-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /data/postgres

Apply the Persistent Volume:

kubectl apply -f postgres-pv.yaml

Create a Persistent Volume Claim

Next, create a Persistent Volume Claim postgres-pvc.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Apply the Persistent Volume Claim:

kubectl apply -f postgres-pvc.yaml

Create the PostgreSQL Deployment

Now, create a postgres-deployment.yaml to define your PostgreSQL Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:latest
        env:
        - name: POSTGRES_PASSWORD
          value: mysecretpassword
        ports:
        - containerPort: 5432
        volumeMounts:
        - mountPath: /var/lib/postgresql/data
          name: postgres-storage
      volumes:
      - name: postgres-storage
        persistentVolumeClaim:
          claimName: postgres-pvc

Apply the Deployment:

kubectl apply -f postgres-deployment.yaml

Create a Service

To access PostgreSQL from outside of the Kubernetes cluster, you will need to expose it via a Service. Create postgres-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: postgres
spec:
  type: NodePort
  ports:
    - port: 5432
      targetPort: 5432
      nodePort: 30002
  selector:
    app: postgres

Apply the Service:

kubectl apply -f postgres-service.yaml

Connect to PostgreSQL

You can now connect to your PostgreSQL instance using:

psql -h localhost -p 30002 -U postgres

If you’re running Minikube, use the Minikube IP:

minikube ip

And then connect with the Minikube IP instead of localhost.

Monitoring and Scaling PostgreSQL

With PostgreSQL running in a Kubernetes environment, you can easily scale your deployment or monitor its performance using tools like Prometheus and Grafana. For database backups, you can also schedule periodic snapshots using Kubernetes CronJobs.

This setup provides a solid base to run PostgreSQL with Docker and Kubernetes, ensuring that your database is resilient, portable, and scalable. As you continue to explore PostgreSQL, you can delve into more advanced features like replication and high-availability configurations to further enhance your deployments.