🏠 JumpToTech Homework — Docker ECR EKS Service Ingress ALB

Scenario

You joined a company as a Junior DevOps Engineer.

A developer gives you a simple web application. Your task is to containerize it and deploy it to AWS EKS so customers can access it from the internet.

Final architecture:

Developer Code
      ↓
Dockerfile
      ↓
Docker Image
      ↓
Amazon ECR
      ↓
EKS Cluster
      ↓
Node Group
      ↓
Deployment
      ↓
ReplicaSet
      ↓
3 Pods
      ↓
Service
      ↓
Ingress
      ↓
AWS Load Balancer Controller
      ↓
ALB
      ↓
Internet / Browser

---

PART 1 — Create the project

Create:

mkdir jumptotech-homework
cd jumptotech-homework

Your final directory should contain:

jumptotech-homework/
│
├── index.html
├── Dockerfile
├── deployment.yaml
├── service.yaml
└── ingress.yaml

Create an index.html that displays:

JumpToTech DevOps
Docker → ECR → EKS
My Kubernetes Application is Running!

Design is up to you.

---

PART 2 — Docker

Create a Dockerfile.

Requirements:

• Use nginx:alpine
• Copy index.html into Nginx
• Application listens on port 80

Build the image:

docker build -t jumptotech-homework:v1 .

Verify:

docker images

Run it locally:

docker run -d \
--name homework-test \
-p 8080:80 \
jumptotech-homework:v1

Check:

docker ps

Open:

http://localhost:8080

You must see your application.

---

PART 3 — Docker troubleshooting

Run:

docker logs homework-test

Enter the container:

docker exec -it homework-test sh

Inside:

pwd
ls
cat /usr/share/nginx/html/index.html

Exit:

exit

Then:

docker inspect homework-test

Find:

• Image
• Ports
• Network
• IP address

Stop and remove:

docker stop homework-test
docker rm homework-test

---

PART 4 — Create Amazon ECR repository

Create your own ECR repository.

Name:

jumptotech-homework

Verify it exists:

aws ecr describe-repositories \
--region us-east-1

Find your AWS account ID:

aws sts get-caller-identity

Your ECR URI will look like:

ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/jumptotech-homework

---

PART 5 — Login to ECR

Authenticate Docker:

aws ecr get-login-password --region us-east-1 | \
docker login \
--username AWS \
--password-stdin \
ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com

You should get:

Login Succeeded

---

PART 6 — Build for EKS

⚠️ Students with Apple Silicon Macs must pay attention to architecture.

Check your EKS node architecture later with:

kubectl get nodes \
-o custom-columns="NODE:.metadata.name,ARCH:.status.nodeInfo.architecture"

For standard AMD64 worker nodes, build:

docker buildx build \
--platform linux/amd64 \
-t ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/jumptotech-homework:v1 \
--push .

Verify the image:

docker buildx imagetools inspect \
ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/jumptotech-homework:v1

Find:

linux/amd64

---

PART 7 — Connect to EKS

Find your cluster:

aws eks list-clusters --region us-east-1

Connect:

aws eks update-kubeconfig \
--region us-east-1 \
--name YOUR_CLUSTER_NAME

Test:

kubectl get nodes

All worker nodes should show:

Ready

---

PART 8 — Understand the Node Group

Run:

aws eks list-nodegroups \
--cluster-name YOUR_CLUSTER_NAME \
--region us-east-1

Then:

kubectl get nodes -o wide

Answer in your homework:

What is a Node Group?

What is a Node?

What runs on the Node?

Does a Deployment run directly on a Node?

---

PART 9 — Create Deployment

Create:

deployment.yaml

Requirements:

Deployment name:
homework-deployment

Replicas:
3

Pod label:
app=homework

Container name:
homework-container

Container port:
80

Image:
your ECR image :v1

Do not copy an old Deployment blindly. Write the YAML yourself.

Apply:

kubectl apply -f deployment.yaml

---

PART 10 — Verify Kubernetes

Run:

kubectl get deployments

Then:

kubectl get rs

Then:

kubectl get pods

Then:

kubectl get pods -o wide

All three Pods should eventually be:

1/1   Running

---

PART 11 — Prove ownership

Pick one Pod:

kubectl describe pod POD_NAME

Find:

Controlled By:

It should show a ReplicaSet.

Then:

kubectl describe rs REPLICASET_NAME

Find:

Controlled By:

You should be able to prove:

Deployment
     ↓
ReplicaSet
     ↓
Pod
     ↓
Container

Take a screenshot.

---

PART 12 — Troubleshoot your Pods

Check:

kubectl describe deployment homework-deployment

Then:

kubectl describe pod POD_NAME

Then:

kubectl logs POD_NAME

Students must know when each command is useful.

---

PART 13 — Create Service

Create:

service.yaml

Requirements:

Name:
homework-service

Type:
ClusterIP

Selector:
app=homework

Port:
80

TargetPort:
80

Apply:

kubectl apply -f service.yaml

Check:

kubectl get svc

Then:

kubectl describe svc homework-service

---

PART 14 — Prove Service found the Pods

Run:

kubectl get endpoints homework-service

You should have backend endpoints corresponding to your Pods.

Also:

kubectl get pods -o wide

Compare the Pod IP addresses.

Explain:

Service
selector app=homework
       ↓
+------+------+------+
|      |      |      |
↓      ↓      ↓
Pod 1  Pod 2  Pod 3

---

PART 15 — Intentionally break the Service 🔥

This is required.

Change:

selector:
  app: homework

to something incorrect:

selector:
  app: wrong

Apply:

kubectl apply -f service.yaml

Now:

kubectl get endpoints homework-service

Explain why the endpoints disappeared.

Then fix the selector and apply again.

This part must be demonstrated in your presentation.

---

PART 16 — Test without ALB

Before creating Ingress, prove that the application works.

Run:

kubectl port-forward \
service/homework-service \
8080:80

Keep the terminal open.

Open:

http://localhost:8080

You should see your application.

Traffic:

Browser
   ↓
localhost:8080
   ↓
kubectl port-forward
   ↓
Service
   ↓
Pod
   ↓
Container

If port 8080 is busy:

lsof -i :8080

Use another port, for example:

kubectl port-forward \
service/homework-service \
8081:80

---

PART 17 — Check AWS Load Balancer Controller

Now move toward production-style internet access.

Check:

kubectl get deployment \
-n kube-system \
aws-load-balancer-controller

Check:

kubectl get pods -n kube-system

And:

kubectl get ingressclass

You are looking for the ALB controller/IngressClass.

If the controller is not installed, document that finding rather than randomly installing commands from the internet. We will review controller installation and AWS permissions together if needed.

---

PART 18 — Create Ingress

If AWS Load Balancer Controller is correctly installed, create:

ingress.yaml

Requirements:

Ingress name:
homework-ingress

Ingress class:
alb

Scheme:
internet-facing

Target type:
ip

Path:
/

Backend:
homework-service

Backend port:
80

Apply:

kubectl apply -f ingress.yaml

Check:

kubectl get ingress

Then:

kubectl describe ingress homework-ingress

---

PART 19 — Find the ALB

Watch:

kubectl get ingress -w

When successfully provisioned, the ADDRESS field should eventually show an AWS load balancer hostname.

Then test that address in your browser.

Final runtime concept:

                 INTERNET
                     |
                     ↓
                   DNS
                     |
                     ↓
                 AWS ALB
                     |
             routing rules
                     |
                     ↓
             homework-service
                     |
          +----------+----------+
          ↓          ↓          ↓
        Pod 1      Pod 2      Pod 3
          ↓          ↓          ↓
      Container  Container  Container

---

PART 20 — Understand Ingress vs Controller

Every student must explain this.

Ingress

Rules / desired configuration

Example:

/      → frontend-service
/api   → api-service
/admin → admin-service

AWS Load Balancer Controller

Watches Kubernetes resources
        ↓
Calls AWS APIs
        ↓
Creates/configures AWS resources
        ↓
ALB
Listeners
Rules
Target Groups

ALB

Receives actual HTTP/HTTPS requests
        ↓
Uses configured routing
        ↓
Sends traffic to appropriate backend

Do not say:

User → Controller → Pod

The Controller is not forwarding every customer request.

---

PART 21 — Troubleshooting challenge

If the website doesn't work, students must troubleshoot in this order:

kubectl get ingress

kubectl describe ingress homework-ingress

kubectl get svc

kubectl describe svc homework-service

kubectl get endpoints homework-service

kubectl get pods -o wide

kubectl describe pod POD_NAME

kubectl logs POD_NAME

And explain the logic:

Browser
   ↓
ALB available?
   ↓
Ingress configured?
   ↓
Service exists?
   ↓
Endpoints exist?
   ↓
Pods Ready?
   ↓
Correct targetPort?
   ↓
Container running?
   ↓
Application logs

---

PART 22 — Scaling challenge

Start with:

kubectl get pods

Scale from 3 Pods to 5:

kubectl scale deployment \
homework-deployment \
--replicas=5

Watch:

kubectl get pods -w

Then:

kubectl get endpoints homework-service

Answer:

Did you manually tell the Service about the two new Pods?

No.

Why?

Because:

Service selector
app=homework
      ↓
automatically matches
      ↓
new Pods with app=homework

---

PART 23 — Self-healing challenge 🔥

Find a Pod:

kubectl get pods

Delete one:

kubectl delete pod POD_NAME

Immediately:

kubectl get pods -w

Observe what Kubernetes does.

Explain:

Deployment wants 5
       ↓
One Pod deleted
       ↓
Only 4 remain
       ↓
ReplicaSet detects mismatch
       ↓
Creates replacement
       ↓
Back to 5

This is desired state + reconciliation/self-healing.

---

PART 24 — Final cleanup

AWS resources cost money, so cleanup is part of the homework.

Delete Ingress first:

kubectl delete -f ingress.yaml

Verify the associated ALB resources are being removed before deleting the rest.

Then:

kubectl delete -f service.yaml
kubectl delete -f deployment.yaml

Check:

kubectl get ingress
kubectl get svc
kubectl get pods

Do not delete a shared class EKS cluster or Node Group unless instructed.

---

🎤 Monday presentation

Each student gets 5 minutes.

They must show one architecture diagram:

Code
 ↓
Dockerfile
 ↓
Image
 ↓
ECR
 ↓
EKS
 ↓
Deployment
 ↓
ReplicaSet
 ↓
Pods
 ↓
Service
 ↓
Ingress
 ↓
ALB
 ↓
Customer

Then answer:

1. What is the difference between Image and Container?
2. Why do we push the image to ECR?
3. What is a Node Group?
4. What is a Deployment?
5. What creates/manages the Pods for a Deployment?
6. How can you find which ReplicaSet owns a Pod?
7. Why shouldn't customers connect directly to Pod IPs?
8. How does Service find its Pods?
9. What are port and targetPort?
10. What happens if the Service selector is wrong?
11. What is Ingress?
12. What is an Ingress Controller?
13. Who configures/creates the ALB in this architecture?
14. Who handles the actual HTTP request?
15. What happens when a Pod dies?
16. Why did some Apple Silicon users need --platform linux/amd64?
17. What does ImagePullBackOff mean?
18. What is the difference between kubectl get and kubectl describe?
19. What does kubectl logs tell you?
20. How would you troubleshoot if the website stopped working?

Homework is complete only when the student can explain the architecture

The goal is not just to make the browser open.

The student should be able to look at this:

ALB → Service → Pod

and explain how the application got there from source code, where the image is stored, where the Pod runs, how Service discovers its backends, how Ingress/Controller configure external routing, and how they would troubleshoot each layer if something failed.