Deploying a Python Web Server to Production with Kubernetes

February 21, 2024

Deploying a Python web server into production using Kubernetes can seem daunting at first, but by breaking down the process into manageable steps, it becomes much more approachable. In this blog post, we'll walk through the steps to deploy a Flask web server, from setting up dependencies to deploying on AWS Elastic Kubernetes Service (EKS).

2024 02 21

Step 1: Create a requirements.txt for Dependencies

Start by creating a requirements.txt file to list all the dependencies needed for your Python web server. For a Flask application, this might look something like:


Install the dependencies using pip:

pip install -r requirements.txt

Step 2: Refactor Source Code and Configuration

Move all configurations to a separate config file or use Kubernetes ConfigMaps for managing environment-specific settings. This approach helps in maintaining different configurations for development, staging, and production environments.

Step 3: Refactor Data Logic

Separate data logic from the application code, and use Kubernetes Persistent Volumes (PV) and Persistent Volume Claims (PVC) for data storage. This setup ensures that your data persists even if the pod is restarted or moved to a different node.

Step 4: Identify the Command to Start the Flask Web Server

Determine the command to start your Flask web server. Typically, it would be something like:

flask run --host=

Step 5: Create a Dockerfile and Build the Image

Create a Dockerfile to containerize your Flask application. Choose a lightweight base image such as Alpine Linux, Ubuntu, or Distroless for security and performance:

FROM python:3.9-alpine
COPY . /app
RUN pip install -r requirements.txt
CMD ["flask", "run", "--host="]

Build the Docker image and tag it:

docker build -t my-flask-app:latest .

Step 6: Upload the Image to a Registry

Push the Docker image to a container registry such as Docker Hub or Amazon Elastic Container Registry (ECR):

docker push my-flask-app:latest

Ensure you have authentication set up for pulling the image from the registry in your Kubernetes cluster.

Step 7: Create Kubernetes Resource Files

Create the necessary Kubernetes resource files, including:

  • Deployment.yaml: Defines the desired state of your application, including the Docker image to use and the number of replicas.
  • Service.yaml: Exposes your application to the network, allowing traffic to reach the pods.
  • Ingress.yaml: Manages external access to your services, typically through an HTTP or HTTPS route.
  • Ingress Controller: Handles the routing of external traffic to the appropriate internal services.

Step 8: Run the Pods in Minikube

Before deploying to a production environment, test your setup locally using Minikube. Start Minikube and apply your Kubernetes configurations:

minikube start
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml

Step 9: Deploy to AWS EKS

Once you've tested your application locally, deploy it to AWS EKS for production use. Set up your EKS cluster and apply your Kubernetes configurations:

aws eks --region region-name update-kubeconfig --name cluster-name
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml

Step 10: Configure DNS with Route 53

Finally, map a subdomain in AWS Route 53 to your application's ingress to make it accessible via a user-friendly URL.

By following these steps, you can successfully deploy a Python web server to production using Kubernetes and AWS EKS. This setup provides scalability, reliability, and ease of management for your application.

Profile picture

Victor Leung, who blog about business, technology and personal development. Happy to connect on LinkedIn