75 Kubernetes Deployment and Runtime Validation

In this lab, you will deploy your containerized application to Kubernetes and validate that it behaves correctly under real orchestration conditions.

You will move from single-container execution to cluster-managed execution.

Context and goals

So far, you have:

• Built a Node.js application
• Containerized it with Docker
• Orchestrated services with Docker Compose
• Automated validation using CI

In this lab, you will:

• Deploy your application to Kubernetes
• Expose it via a Service
• Validate runtime behavior
• Simulate failures
• Explore scaling and resilience

This lab is intentionally deep. Core sections are required. At least one extension lane item is required for grading.

Verify your environment

Your goal is to end up with a working Kubernetes cluster and kubectl access.

For this lab, you must use k3s on the course Ubuntu Server VM.

If you are working on a personal machine, consult the official documentation for your chosen Kubernetes distribution, but the lab instructions assume k3s on Ubuntu Server.

At the end of setup, this must work:

1
kubectl get nodes

You must see at least one node in Ready state.

Install k3s on the course VM (recommended)

1
# Update packages
2
sudo apt update
3

4
# Install k3s (single-node cluster) and make kubeconfig readable
5
curl -sfL https://get.k3s.io | \
6
  INSTALL_K3S_EXEC="server --write-kubeconfig-mode 644" sh -
7

8
# Put kubeconfig in the default location for kubectl
9
mkdir -p "$HOME/.kube"
10
cp /etc/rancher/k3s/k3s.yaml "$HOME/.kube/config"
11

12
# Ensure kubectl uses your local kubeconfig
13
export KUBECONFIG="$HOME/.kube/config"
14

15
# Persist for future sessions
16
echo 'export KUBECONFIG="$HOME/.kube/config"' >> ~/.bashrc
17

18
# Verify cluster access
19
kubectl get nodes
20
kubectl get pods -A

1
sudo systemctl restart k3s

Tools checklist

1
kubectl version --client
2
docker version

Create a dedicated namespace

Create a namespace for this lab:

1
kubectl create namespace quote-lab

Set it as default for your session:

1
kubectl config set-context --current --namespace=quote-lab

Verify:

1
kubectl get pods

Build and tag your image for Kubernetes

Build your Docker image locally:

1
docker build -t quote-app:local -f docker/Dockerfile .

1
docker save quote-app:local | sudo k3s ctr images import -

1
sudo k3s ctr images list | grep quote-app

1
kubectl get pods
2
kubectl delete pod <pod-name>
3
kubectl get pods -w

1
kubectl create deployment nginx-test --image=nginx
2
kubectl expose deployment nginx-test --port=80 --type=ClusterIP
3
kubectl get pods

If using another environment, adjust accordingly.

Create a Deployment

Create a file named deployment.yaml with the following content:

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  name: quote-app
5
spec:
6
  replicas: 1
7
  selector:
8
    matchLabels:
9
      app: quote-app
10
  template:
11
    metadata:
12
      labels:
13
        app: quote-app
14
    spec:
15
      containers:
16
        - name: quote-app
17
          image: quote-app:local
18
          ports:
19
            - containerPort: 3000
20
          readinessProbe:
21
            httpGet:
22
              path: /health
23
              port: 3000
24
            initialDelaySeconds: 3
25
            periodSeconds: 5

Apply it:

1
kubectl apply -f deployment.yaml

Observe:

1
kubectl get pods
2
kubectl describe pod <pod-name>

Expose the application with a Service

Create service.yaml:

1
apiVersion: v1
2
kind: Service
3
metadata:
4
  name: quote-app
5
spec:
6
  selector:
7
    app: quote-app
8
  ports:
9
    - port: 80
10
      targetPort: 3000
11
  type: ClusterIP

Apply it:

1
kubectl apply -f service.yaml

Verify:

1
kubectl get svc

Access the application

Use port-forwarding:

1
kubectl port-forward svc/quote-app 8080:80

Open:

1
http://localhost:8080

Verify that:

• The app loads
• The health endpoint responds
• Basic routes function correctly

Validate readiness behavior

Delete the running pod:

1
kubectl delete pod <pod-name>

Observe:

1
kubectl get pods -w

Confirm:

• A new pod is created automatically
• The Service continues routing traffic
• Downtime is minimal

Scale the Deployment

Scale to multiple replicas:

1
kubectl scale deployment quote-app --replicas=3

Observe:

1
kubectl get pods

Confirm:

• Three pods are running
• All are Ready

Discuss:

• What does scaling change?
• What does it not change?

Introduce a controlled failure

This step is required for grading.

Modify your deployment to intentionally break readiness.

Examples:

• Change readinessProbe path to a non-existent endpoint
• Use the wrong container port
• Set an invalid image tag

Apply the change and observe:

1
kubectl apply -f deployment.yaml
2
kubectl get pods
3
kubectl describe pod <pod-name>

Confirm:

• Pods fail readiness
• Traffic is not routed
• Kubernetes reports the failure

Restore the correct configuration.

Inspect logs and events

Inspect application logs:

1
kubectl logs <pod-name>

Inspect cluster events:

1
kubectl get events

Observe how Kubernetes surfaces runtime issues.

Extension lanes

At least one extension item is required for grading. You may complete more for additional distinction.

Reflect on orchestration

Answer the following verbally during review:

• What does Kubernetes automate?
• What remains your responsibility?
• What signals determine application health?
• How does this differ from Docker Compose?

Wrap-up

You have:

• Deployed an application to Kubernetes
• Exposed it with a Service
• Validated runtime behavior
• Simulated failures
• Explored scaling and resilience

This completes the practical orchestration portion of the course.

In larger systems, this foundation expands to:

• Ingress controllers
• Service meshes
• Observability stacks
• GitOps workflows
• Infrastructure automation

You now understand the core control loop that powers modern cloud-native systems.