The purpose of this assessment was to deepen my understanding of Kubernetes by deploying the Twoge application. The task involved containerizing the application, deploying it on a local Kubernetes cluster (Minikube), and then migrating the deployment to AWS Elastic Kubernetes Service (EKS). Additionally, the assessment aimed to familiarize me with managing containerized applications, configuring database connections, and implementing lifecycle management through probes.
- Dockerizing Twoge:
- I began by writing a Dockerfile for the Twoge application, ensuring it included all necessary dependencies and configurations for the Python Flask environment.
- Built the Docker image and tested it using Docker Compose to ensure it worked as expected.
- YML Configuration:
- Created deployment and service YML files to deploy Twoge on Minikube.
- Created deployment and service YML files to deploy a Postgres database.
- Configured the app service to expose the application within the Minikube cluster.
- ConfigMap and Secrets:
- Defined ConfigMap and Secrets to securely manage and inject database configurations into the application.
- Deployed the database on Kubernetes, ensuring proper connectivity and security.
- Namespace Creation:
- Created a dedicated namespace for the Twoge application to organize and isolate resources within the cluster.
- Lifecycle Management:
- Implemented a startup probe to monitor the application's startup process and ensure it was running smoothly.
- As a bonus, I also implemented a readiness probe to manage application readiness more effectively.
- Migration to EKS:
- Migrated the Twoge deployment from Minikube to AWS EKS.
- Updated the service type to
LoadBalancerto enable public access on EKS.
- Storage Configuration:
- Created a Persistent Volume Claim (PVC) using a storage class to ensure data persistence for the application.
- GitHub Actions Setup:
- Set up a CI/CD pipeline using GitHub Actions for automating Docker image building and deployment to EKS.
- Ensured that the pipeline utilized the appropriate namespace and Docker Hub credentials.
Before starting, ensure you have the following tools installed:
-
Docker: To build and push Docker images.
- Installation instructions can be found here.
-
Minikube: For local Kubernetes deployment.
- Installation instructions can be found here.
-
kubectl: The Kubernetes command-line tool.
- Installation instructions can be found here.
-
AWS CLI: To manage AWS services and interact with EKS.
- Installation instructions can be found here.
To securely manage your AWS credentials and Docker Hub credentials, create the following GitHub secrets in your repository:
-
AWS Credentials:
AWS_ACCESS_KEY_ID: Your AWS Access Key ID.AWS_SECRET_ACCESS_KEY: Your AWS Secret Access Key.AWS_REGION: Your AWS region (e.g.,us-west-2).
-
Docker Hub Credentials:
DOCKER_USERNAME: Your Docker Hub username.DOCKER_PASSWORD: Your Docker Hub password.
To add secrets in GitHub:
- Navigate to your repository on GitHub.
- Go to
Settings>Secrets>Actions. - Click
New repository secretand add the required secrets.
Fork the repository and clone it to your local machine:
git clone <your-forked-repo-url>
cd twogeBuild the Docker image for the Twoge application:
docker build --platform linux/amd64,linux/arm64 -t twoge-kube:latest . - Start Minikube:
minikube start- Create a secret.yml file:
echo "apiVersion: v1
kind: Secret
metadata:
name: twoge-secret
namespace: tristan
type: Opaque
data:
postgres-username: dXNlcjE= # user1 base64 encoded
postgres-password: cGFzc3dvcmQ= # password base64 encoded" > k8s/secrets.yml- Apply the YML files for deployment and service:
kubectl apply -f namespace.yml kubectl apply -f flask-deployment.yml kubectl apply -f flask-service.yml kubectl apply -f configmap.yml kubectl apply -f secrets.yml kubectl apply -f postgres-deployment.yml kubectl apply -f postgres-service.yml
- This can also be ran with the following:
kubectl apply -f namespace.yml kubectl apply -f . - Once the pods are running you can start the app with:
minikube service flask-service
- Update Your Kubernetes Configuration
- Update your kubeconfig file to point to the EKS cluster:
aws eks update-kubeconfig --name <your-eks-cluster-name> --region <your-aws-region>
- Update Kubernetes Files
- In the
flask-service.ymlfile, change the service type fromNodePort(used in Minikube) toLoadBalancerfor EKS to allow external access. - In the
storageclass.ymlfile, comment out the code needed for minikube and uncomment out the code needed for EKS.
- Apply the YAML Files to EKS
- Use
kubectlto apply your configurations to the EKS cluster:kubectl apply -f k8s/namespace.yml kubectl apply -f k8s/ -n <namespace>
- Verify Deployment
- Check the status of your pods and services on EKS:
kubectl get pods -n <namespace> kubectl get services -n <namespace>
- Or:
kubectl get all -n <namespace>
- Update Kubernetes Context
- Update your kubectl Context to use Minikube:
kubectl config use-context minikube
- Verify the Current Context
- Check to see if it switched correctly
kubectl config current-context
- Update Kubernetes Files
- In the flask-service.yml file, change the service type from 'LoadBalancer' back to 'NodePort'.
- In the storageclass.yml file, comment out the code needed for EKS and uncomment out the code needed for Minikube.
- Apply the YAML to Minikube
- Reapply configurations to Minikube:
kubectl apply -f k8s/namespace.yml kubectl apply -f k8s/ -n <namespace>
- Verify Deployment
- Check the status of your pods and services on Minikube:
kubectl get pods -n <namespace> kubectl get services -n <namespace>
- Or:
kubectl get all -n <namespace>
- Try making a small change to the flask-deployment.yml and pushing it up to github. For example, change the number replicas.
- After pushing up the change, go to the actions tab in your repo and verify the jobs finsihed successfuly.
- You should now also see the number of flask-deployment pods changed and you should have a new docker image on dockerhub.