Modernize organization application deployment by leveraging Kubernetes and AWS services

Use case to deploy app Containers along with postgres container in EKS cluster connected with RDS using CI/CD pipeline and terraform. Extended the solution by adding AWS ALB and Ingress Controller to access the application internally and externally

Situation: The organization aims to modernize its application deployment by leveraging Kubernetes and AWS services. They have chosen Amazon EKS for orchestration, RDS for database management, and GitLab as their CI tool.

Task: Deploy an application along with a PostgreSQL database in an EKS cluster, connected to an RDS instance, using an AWS CI/CD pipeline. Infrastructure should be defined as code using Terraform.

Actions:

1. Setting up Terraform Infrastructure:Create Terraform scripts to define EKS cluster, RDS instance, and necessary networking components.
2. Integrating with GitLab:Connect GitLab to AWS for seamless integration. Configure GitLab CI/CD pipeline to trigger on code commits.
3. EKS Cluster Deployment:Use Terraform to create and configure the EKS cluster with required worker nodes. Ensure proper networking and security configurations.
4. Database Configuration:Define RDS instance parameters in Terraform for PostgreSQL.Set up necessary security groups and networking to allow communication between EKS and RDS.
5. Application Deployment:Containerize the application and push it to a container registry. Define Kubernetes manifests in Terraform for deploying the application pods.
6. CI/CD Pipeline:Configure GitLab CI to trigger Terraform scripts on code changes. Implement stages in the pipeline for plan and apply Terraform steps.
7. Testing and Validation:Integrate automated testing into the CI/CD pipeline to ensure the stability of the application.
8. Secrets Management:Implement AWS Secrets Manager or similar for securely managing sensitive information like database credentials.

Results: The organization now has a fully automated CI/CD pipeline, orchestrated by GitLab, that deploys and updates the EKS cluster, PostgreSQL database, and the application. This approach ensures consistency, reliability, and scalability in their cloud-native environment.

Learnings:

• The organization gained proficiency in managing Kubernetes clusters using EKS.
• Enhanced collaboration and version control through GitLab CI/CD.
• Improved security by leveraging AWS managed services and infrastructure as code.

Extended the solution by adding AWS ALB and Ingress Controller to access the application internally and externally

Let's expand the use case to include an Application Load Balancer (ALB) and Ingress Controller for external access. We'll use Terraform to define the infrastructure and Kubernetes manifests for application deployment.

Terraform Code:

• EKS Cluster Setup (eks.tf):

• RDS Database Setup (rds.tf):

• Application Load Balancer (alb.tf):

Kubernetes Manifests:

• Deployment (deployment.yaml):

• Service (service.yaml):

• Ingress (ingress.yaml):

Steps:

1. Apply Terraform scripts to create EKS cluster, RDS instance, and ALB.
2. Deploy Kubernetes manifests using kubectl apply -f deployment.yaml -f service.yaml -f ingress.yaml.
3. Monitor the deployment using kubectl get pods, kubectl get services, and kubectl get ingress.
4. Access the application internally via the EKS cluster's NodePort or the ALB for external access.

This enhanced use case provides an end-to-end solution, including ALB and Ingress, for accessing the application both internally and externally. Adjust parameters and settings according to your specific requirements.

Best Regards,

Ramandeep Chandna

Subscribe to my Newsletter | Follow Me | Book 1:1 Mentorship Connect | Subscribe to my YouTube Channel