End-to-End Containerised Deployment: AWS EC2 Docker Docker Hub Kubernetes

MOHAMMED AMANKHAN — Thu, 13 Aug 2026 21:26:58 +0000

🚀 My First End-to-End Containerised Deployment: AWS EC2 → Docker → Docker Hub → Kubernetes

I recently completed a hands-on DevOps project where I8 deployed a simple web application through the complete container workflow — from writing the application to running it inside a Kubernetes Pod.

This project helped me understand how Docker and Kubernetes fit together in a real deployment workflow.

🛠️ What I Built

The deployment flow looked like this:

HTML Application → Dockerfile → Docker Image → Docker Hub → Kubernetes Pod → NodePort Service → Web Browser

🔹 Technologies Used

☁️ AWS EC2
🐳 Docker
📦 Docker Hub
☸️ Kubernetes
🌐 Kubernetes NodePort
💻 HTML
🐧 Linux

1️⃣ Created a Simple Web Application

I started with a basic "index.html" file containing the web application's content.

The goal wasn't to build a complex application.

Instead, I wanted to focus on understanding the deployment and containerisation process.

2️⃣ Provisioned an AWS EC2 Instance

I created an Amazon EC2 instance to provide the Linux environment for the project.

After connecting to the instance through SSH, I prepared the environment required for Docker and Kubernetes.

3️⃣ Created a Dockerfile

Next, I created a "Dockerfile" to package the web application into a Docker image.

A simple example:

FROM nginx:latest

COPY index.html /usr/share/nginx/html/index.html

EXPOSE 80

Here:

"FROM" specifies the base image.
"COPY" places my HTML file inside the Nginx web server directory.
"EXPOSE" documents the port used by the application.

4️⃣ Built the Docker Image

Once the Dockerfile was ready, I built the image using:

docker build -t my-web-app .

This converted the application and its required environment into a reusable Docker image.

I could then verify the image using:

docker images

5️⃣ Tested the Container Locally

Before moving to Kubernetes, I tested the Docker container:

docker run -d -p 8080:80 my-web-app

This mapped:

EC2 Port 8080 → Container Port 80

I then accessed the application through the EC2 instance's public IP and port.

6️⃣ Pushed the Image to Docker Hub

After confirming that the container worked correctly, I pushed the image to Docker Hub.

First, I tagged the image:

docker tag my-web-app /my-web-app:latest

Then logged in:

docker login

And pushed the image:

docker push /my-web-app:latest

This gave me a central container image that Kubernetes could pull and deploy.

7️⃣ Deployed the Application on Kubernetes

Next, I created a Kubernetes Pod configuration.

Example:

apiVersion: v1
kind: Pod

metadata:
name: my-web-app

spec:
containers:
- name: my-web-app
image: /my-web-app:latest
ports:
- containerPort: 80

I applied it using:

kubectl apply -f pod.yaml

Then checked the Pod:

kubectl get pods

8️⃣ Exposed the Pod Using a NodePort Service

A Pod alone isn't the most convenient way to expose an application externally.

So I created a Kubernetes Service using NodePort.

apiVersion: v1
kind: Service

metadata:
name: my-web-app-service

spec:
type: NodePort

selector:
app: my-web-app

ports:
- port: 80
targetPort: 80
nodePort: 30080

I then applied it:

kubectl apply -f service.yaml

And verified it with:

kubectl get services

9️⃣ Accessed the Application

Once the NodePort Service was running, I accessed the application through the EC2 instance's public IP and NodePort.

For example:

http://:30080

This allowed me to access the web application from my browser.

🔄 Complete Deployment Flow

    Web Application
          │
          ▼
      index.html
          │
          ▼
      Dockerfile
          │
          ▼
   Docker Image
          │
          ▼
     Docker Hub
          │
          ▼
  Kubernetes Pod
          │
          ▼
 NodePort Service
          │
          ▼
      EC2 Network
          │
          ▼
     Web Browser

🧠 What I Learned

This project helped me understand several important DevOps concepts practically:

🐳 Containerisation

Instead of running the application directly on the server, Docker packages the application into a portable container image.

📦 Container Registries

Docker Hub provides a place to store and distribute container images.

☸️ Kubernetes Pods

A Pod provides the basic execution environment for containers in Kubernetes.

🌐 Kubernetes Services

Services provide a stable way to expose applications running inside Kubernetes.

🔌 NodePort

NodePort allows a service to be accessed through a port on the Kubernetes node.

🔄 Container Lifecycle

I also got a better understanding of the flow:

Build → Package → Push → Pull → Deploy → Expose → Access

🚧 What's Next?

This is only the beginning of my Kubernetes learning journey.

My next steps are to move from manually managing a Pod to using Kubernetes resources designed for real deployments:

Deployments
ReplicaSets
Rolling Updates
ConfigMaps
Secrets
Ingress
Persistent Volumes
Kubernetes Networking
Horizontal Pod Autoscaling
CI/CD with GitHub Actions
AWS EKS

The goal is to gradually move from a simple single-container deployment towards a more production-oriented architecture.

💡 Final Takeaway

This may be a small project, but it gave me something more valuable than just theory — hands-on understanding of how an application moves from source code to a running container and finally into Kubernetes.

I'm continuing to learn by building, breaking, troubleshooting, and rebuilding.

One project at a time. 🚀

devops #docker #kubernetes #aws

DEV Community: MOHAMMED AMANKHAN

End-to-End Containerised Deployment: AWS EC2 Docker Docker Hub Kubernetes

devops #docker #kubernetes #aws