Scenario

A growing e-commerce company, ShopEase, is preparing to modernize how it runs backend services. Before fully adopting microservices at scale, the engineering team wants to standardize how applications are packaged, deployed, and run across environments.

Today, a backend service is:

• Run locally during development
• Manually packaged and started
• Difficult to move consistently across machines
• Not managed by any orchestration platform

As the team prepares for future growth, they need a reliable, repeatable deployment model that works the same way on every machine and can later scale as traffic increases.

To achieve this, the team decides to move the service to Kubernetes, using Amazon Elastic Kubernetes Service (EKS) to manage containers, deployments, and networking.

Your Role as the DevOps Engineer

Your role is to take a backend application and deploy it in a cloud-native way using Kubernetes.

You are responsible for:

• Packaging the application as a Docker container
• Storing the image in a container registry
• Running the application on a managed Kubernetes cluster
• Exposing the service so it can be accessed externally
• Understanding how Kubernetes manages Pods and traffic

This mirrors how DevOps engineers introduce Kubernetes into real teams — starting with one service and building confidence in the platform.

Our Solution

You will deploy a containerized backend service on Amazon EKS and let Kubernetes manage it.

The solution includes:

• A Dockerized application stored in Amazon ECR
• An Amazon EKS cluster with EC2 worker nodes
• A Kubernetes Deployment to run and manage Pods
• A Kubernetes Service (NodePort) to expose the application
• Health endpoints to verify application status

The focus of this project is on Kubernetes fundamentals, not production optimizations. Advanced features like HTTPS, Ingress, and autoscaling are intentionally deferred to later projects.

About the Project

In this hands-on project, you will deploy a real backend service on Kubernetes and understand how applications actually run inside an EKS cluster.

You will learn:

• How application code becomes a Docker image
• How Kubernetes pulls images from a registry
• How Deployments create and manage Pods
• How Services route traffic to Pods
• How AWS networking and security groups interact with Kubernetes

The application includes API endpoints, health checks, and a simple UI to observe runtime behavior.

By the end, Kubernetes will feel practical and logical, not abstract or “magical.”

Steps To Be Performed 👩‍💻

We’ll complete the project in the following stages:

1. Understand Kubernetes and Amazon EKS concepts
2. Containerize the application using Docker
3. Push the Docker image to Amazon ECR
4. Create an Amazon EKS cluster
5. Deploy the application using a Kubernetes Deployment
6. Expose the application using a Kubernetes Service (NodePort)

Each step focuses on what is happening and why, not just running commands.

Services Used 🛠

• Docker - Containerize the application
• Amazon ECR - Store Docker images
• Amazon EKS - Managed Kubernetes cluster
• Amazon EC2 - Worker nodes for the cluster
• Amazon VPC - Networking for EKS
• AWS IAM - Permissions and access control
• Kubernetes (kubectl) - Deploy and manage workloads

Estimated Time & Cost ⚙️

• Estimated Time: 3 - 4 hours
• Cost: $0 -$3 (covered by AWS Free Tier/credits when cleaned up)

➡️ Architectural Diagram

Here is the architecture diagram of this project:

➡️ Final Result

At the end of this project, you’ll have:

• A containerized application running on Amazon EKS.
• Hands-on experience with Kubernetes Deployments and Services.
• A clear understanding of how traffic reaches Pods.