Demo Deploying voting app on Kubernetes with Deployments

This guide shows how to migrate the voting application from standalone Pod manifests and NodePort Services to Kubernetes Deployments (which manage ReplicaSets and Pods for you). Moving from raw Pods to Deployments gives you:

Declarative scaling (replicas).
Self-healing (automatically recreates failed Pods).
Rolling updates (upgrade without downtime or manual Pod replacement).

Why migrate? Running individual Pods has these limitations:

No simple scaling (e.g., to increase from 1 to 5 instances).
No controller to watch and recreate failed Pods.
No built-in rolling upgrade mechanism — manual Pod replacement can cause downtime.

Comparison: Pod vs Deployment

Resource	Use Case	Key advantages
Pod	Single instance of a containerized workload	Simple, immediate, but no scaling/self-healing
Deployment	Managed replica set of Pods	Declarative scaling, self-healing, rolling updates

Prerequisite: This guide assumes you previously deployed the voting and result apps as Pods and exposed them with NodePort Services so they could be reached externally. kubectl cleanup

kubectl delete -f .
# Example output:
# pod "db" deleted
# service "db" deleted
# pod "redis" deleted
# service "redis" deleted
# pod "result" deleted
# service "result" deleted
# service "vote" deleted
# pod "vote" deleted
# pod "worker" deleted

Tip: To convert a Pod manifest to a Deployment, move the Pod spec into spec.template of the Deployment, and add replicas and a selector.matchLabels that matches template.metadata.labels.

Make sure spec.selector.matchLabels in the Deployment exactly matches spec.template.metadata.labels. If they differ, the Deployment will reject the manifest.

Service configuration Service manifests do not need to change when you move from Pods to Deployments — just ensure the Service selector matches the labels used by the Deployment templates. Example NodePort snippet used to expose the vote app (unchanged from the pod-based configuration):

spec:
  type: NodePort
  ports:
  - name: "vote-service"
    port: 8080
    targetPort: 80
    nodePort: 31000
  selector:
    app: vote

Original Pod manifest (for reference)

apiVersion: v1
kind: Pod
metadata:
  name: worker
  labels:
    app: worker
spec:
  containers:
  - name: worker
    image: dockersamples/examplevotingapp_worker

Create Deployments Below are concise, corrected Deployment manifests for each component. Each uses apiVersion: apps/v1, includes replicas, selector.matchLabels, and template (the embedded Pod spec). Place these manifests in your deployments directory and apply them with kubectl apply -f .. vote-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vote
  labels:
    app: vote
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vote
  template:
    metadata:
      labels:
        app: vote
    spec:
      containers:
      - name: vote
        image: dockersamples/examplevotingapp_vote
        ports:
        - containerPort: 80
          name: vote

result-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: result
  labels:
    app: result
spec:
  replicas: 1
  selector:
    matchLabels:
      app: result
  template:
    metadata:
      labels:
        app: result
    spec:
      containers:
      - name: result
        image: dockersamples/examplevotingapp_result
        ports:
        - containerPort: 80
          name: result

redis-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
  labels:
    app: redis
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: redis:alpine
        ports:
        - containerPort: 6379
          name: redis

db-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: db
  labels:
    app: db
spec:
  replicas: 1
  selector:
    matchLabels:
      app: db
  template:
    metadata:
      labels:
        app: db
    spec:
      containers:
      - name: postgres
        image: postgres:15-alpine
        env:
        - name: POSTGRES_USER
          value: postgres
        - name: POSTGRES_PASSWORD
          value: postgres
        ports:
        - containerPort: 5432
          name: postgres

worker-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: worker
  labels:
    app: worker
spec:
  replicas: 1
  selector:
    matchLabels:
      app: worker
  template:
    metadata:
      labels:
        app: worker
    spec:
      containers:
      - name: worker
        image: dockersamples/examplevotingapp_worker

Apply deployments and services

# from the deployments directory
kubectl apply -f .
# Example output:
# deployment.apps/db created
# service/db created
# deployment.apps/redis created
# service/redis created
# deployment.apps/result created
# service/result created
# deployment.apps/vote created
# service/vote created
# deployment.apps/worker created

Verify Services and Deployments

kubectl get svc
# Example output:
# NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)             AGE
# db           ClusterIP   10.96.128.199    <none>        5432/TCP            9s
# kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP             98m
# redis        ClusterIP   10.96.79.153     <none>        6379/TCP            9s
# result       NodePort    10.96.59.99      <none>        8081:31001/TCP      9s
kubectl get deployment
# Example output:
# NAME    READY   UP-TO-DATE   AVAILABLE   AGE
# db      1/1     1            1           18s
# redis   1/1     1            1           18s
# result  1/1     1            1           18s
# vote    1/1     1            1           18s
# worker  1/1     1            1           17s

To see everything at once:

kubectl get all
# Shows Pods, Services, Deployments, ReplicaSets in the current namespace

Scaling a Deployment To scale the vote Deployment to 5 replicas:

kubectl scale deployment vote --replicas=5
# Example output:
# deployment.apps/vote scaled

Verify the scale

kubectl get deployment vote
# Example output:
# NAME   READY   UP-TO-DATE   AVAILABLE   AGE
kubectl get pod
# Example output (multiple vote pods with different suffixes):
# NAME                          READY   STATUS    RESTARTS   AGE
# vote-7fb64db549-4bqnl         1/1     Running   0          23s
# vote-7fb64db549-9v2kh         1/1     Running   0          23s
# vote-7fb64db549-gbbv9         1/1     Running   0          23s
# vote-7fb64db549-nfw9f         1/1     Running   0          4m19s
# vote-7fb64db549-wv8dp         1/1     Running   0          23s
# (other component pods listed similarly)

When you refresh the application endpoint, each request may be served by a different Pod (you can see the Pod suffix in the app UI), demonstrating load distribution across replicas. Conclusion You’ve migrated from Pod manifests to Kubernetes Deployments, giving your application declarative scaling, automatic self-healing, and safe rolling updates. Links and references

Introduction

Kubernetes Overview

Kubernetes Concepts

YAML Introduction

Kubernetes Concepts - Pods, ReplicaSets, Deployments

Networking in Kubernetes

Services

Microservices Architecture

Kubernetes on the Cloud

Conclusion

Appendix

Demo Deploying voting app on Kubernetes with Deployments

Watch Video