Migrating to Kubernetes : Our Monolith to Microservices Journey

Migrating from EC2 based Monolith to Kubernetes is a significant step toward modernising any infrastructure and taking advantage of container orchestration benefits. By following a well-defined migration plan and addressing the considerations we've discussed why we chose Kubernetes and making the transition smoother and more rewarding for us.

In recent years, Kubernetes has emerged as the de facto standard for container orchestration and management. Its ability to automate the deployment, scaling, and management of containerized applications has made it a popular choice for organizations looking to modernize their infrastructure. In this blog post, we look through the process of migrating from EC2 to Kubernetes and explore the benefits of making this transition.

Why Migrate to Kubernetes?

Before diving into the migration process, let's briefly discuss why you might want to migrate from EC2 to Kubernetes:

1. Scalability: Kubernetes provides seamless horizontal scaling, allowing you to scale your applications based on demand. This means you can easily handle traffic spikes and reduce infrastructure costs during periods of lower demand.
2. Resource Efficiency: Kubernetes optimizes resource utilization, ensuring that you make the most out of your infrastructure. It schedules containers efficiently, reducing wasted resources.
3. Fault Tolerance: Kubernetes offers built-in fault tolerance with automatic recovery mechanisms, reducing downtime and ensuring high availability for your applications.
4. Portability: Kubernetes abstracts away the underlying infrastructure, making it easier to move applications between different cloud providers or on-premises environments.
5. Advanced Orchestration: Kubernetes supports advanced deployment strategies, such as canary deployments, blue-green deployments, and rolling updates, making application updates safer and more controlled

Changes in System Design: Adopting Microservices

Assessment and Planning:

• Start by assessing your existing EC2-based applications. Document their architecture, dependencies, and resource requirements.
• Identify the components that can be containerized and migrated to Kubernetes.

Containerization:

• Containerize your applications using containerization technologies like Docker. This step involves creating Docker images for your application components.

Kubernetes Cluster Setup:

• Choose a Kubernetes distribution that suits your needs. Popular options include Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS), or self-managed clusters using tools like kops or kubeadm.
• Configure your Kubernetes cluster with appropriate node pools, networking, and security settings.

Strangler Microservices Pattern

We used the strangler microservices pattern where we created the same functionality in a new microservice from our Django based monolith and using cloudfront origins and path based routing feature of Kubernetes we shifted traffic from our monolith to microservice in a slow and steady manner.

We use cloudfront to provide edge caching, requests are processed by our react based custom framework on frontend which performs server side rendering and lots of optimizations discussed here : Performance Optimization

With new architecture in place we needed a way break our monolithic Django application to micro-frontends, we explored lots of ways to perform this and finally settled on multiple origins from our CDN servers, this allowed flexibility in chosing to serve users from new or older system and we could easily test out same routes by comparing new and old architectures, this gave us lots of freedom to experiment not only with technologies and framework but allowed us to improve upon developer experiences in deployment and monitoring.

With above setup in place we started standardising on lots of processes and frameworks which allowed developers to develop and ship new features faster, following considerations helped us in our migration:

Deployment:

After testing lots of deployment tools and CI/CD pipelines for eg: Github Actions, Jenkins and CodeDeploy, we settled on CodeBuild and CodeDeploy as these were managed services from AWS, our deployment strategy changed to using Tag based deployment with multistage builds and build caching

We used ArgoCD which helped in reconciliation and streamlined our deployment process, we started using GitOps and Slack based notifications for all deployment activities

Deployment of new microservices was stratght-forward:

• Define Kubernetes deployment manifests (YAML files) that describe how your applications should run.
• Deploy your containerized applications to the Kubernetes cluster using Helm and ArgoCD

Service Discovery and Load Balancing:

• Utilize Kubernetes' built-in service discovery and load balancing features to route traffic to your application pods.

Monitoring and Logging:

• We implemented Cloudwatch, Newrelic and Kubernetes-native monitoring. For  logging solutions we started using Sentry and Loki

Testing and Validation:

• Conducting thorough testing to ensure that your applications work correctly in the Kubernetes environment was a crucial feature, we implemented CI/CD pipelines for automated testing and deployment and created multiple staging environments for testing along with Beta and Production environment

Scaling and Optimization:

• Leveraging Kubernetes' scaling capabilities to adjust resources based on actual usage and optimize cluster for cost-efficiency. Using Bin-packed containers allowed us to reduce number of nodes which were runing the monolith, but the drawback is that initialially we have to run both the systems in parallel

Benefits and Considerations

Migrating to Kubernetes offers numerous advantages, including improved scalability, resource efficiency, and fault tolerance. However, it's essential to consider the following:

• Learning Curve: Kubernetes has a learning curve, so invest time in training your team to maximize its benefits.
• Costs: While Kubernetes can optimize resource usage, it may also introduce additional complexity and management overhead. We had to consider the cost implications.
• Monitoring and Security: Kubernetes requires robust monitoring and security practices to ensure the health and security of your applications.
• Backup and Disaster Recovery: Backup and disaster recovery strategies specific to our Kubernetes workloads had to be thought out from ground up

With these changes we started our migration process in late 2022 and so far we have broken our monolith into 50+ backend and frontend microservices, while maintaining monolithic system in parallel, we also started using Devtron in production which helped in deploying and delivering new systems faster.