Demo Deploying voting app on Kubernetes

In this tutorial you’ll deploy the Example Voting App onto a Kubernetes cluster. We’ll create Pod manifests for each service, then add Services so the components can communicate and the UIs can be accessed from your browser. Prerequisites:

A running Kubernetes cluster (minikube, kind, or a cloud cluster)
kubectl configured to talk to your cluster
A directory containing the YAML manifests you’ll create

Start by creating a working folder and the individual YAML files described below.

1. Pod manifests

Pod manifests share the same top-level structure: apiVersion, kind, metadata (including name and labels), and spec (which defines containers). Create one YAML file per component:

voting-app-pod.yaml — voting UI
result-app-pod.yaml — results UI
redis-pod.yaml — Redis data store
db-pod.yaml — Postgres database
worker-pod.yaml — background worker

Below are the Pod manifests to create. Save each into its respective filename. voting UI (voting-app-pod.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: vote
  labels:
    app: vote
spec:
  containers:
  - name: vote
    image: dockersamples/examplevotingapp_vote
    ports:
    - containerPort: 80
      name: http

results UI (result-app-pod.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: result
  labels:
    app: result
spec:
  containers:
  - name: result
    image: dockersamples/examplevotingapp_result
    ports:
    - containerPort: 80
      name: http

Redis (redis-pod.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: redis
  labels:
    app: redis
spec:
  containers:
  - name: redis
    image: redis:alpine
    ports:
    - containerPort: 6379
      name: redis

Postgres (db-pod.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: db
  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

For Postgres, POSTGRES_USER and POSTGRES_PASSWORD initialize the default database user. In production, supply secrets using Kubernetes Secrets rather than plain env values.

Worker (worker-pod.yaml) — the worker only needs to run and communicate internally, so no ports are required:

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

Quick manifest summary

File	Component	Port / Notes
`voting-app-pod.yaml`	Voting UI	`containerPort: 80`
`result-app-pod.yaml`	Results UI	`containerPort: 80`
`redis-pod.yaml`	Redis	`containerPort: 6379`
`db-pod.yaml`	Postgres	`containerPort: 5432`; set `POSTGRES_USER`/`POSTGRES_PASSWORD`
`worker-pod.yaml`	Worker	No public ports

2. Service manifests

To enable network communication between components and to expose UIs, create Services for Redis, Postgres (db), vote, and result.

Use ClusterIP for internal services (Redis and Postgres).
Use NodePort for the vote and result UIs so you can open them in a browser for this demo.

Redis Service (redis-service.yaml):

apiVersion: v1
kind: Service
metadata:
  name: redis
  labels:
    app: redis
spec:
  type: ClusterIP
  ports:
  - name: redis
    port: 6379
    targetPort: 6379
  selector:
    app: redis

Postgres Service (db-service.yaml):

apiVersion: v1
kind: Service
metadata:
  name: db
  labels:
    app: db
spec:
  type: ClusterIP
  ports:
  - name: postgres
    port: 5432
    targetPort: 5432
  selector:
    app: db

Vote UI Service (vote-service.yaml) — NodePort exposes the UI externally on node port 31000, mapping the Service port 8080 to container port 80:

apiVersion: v1
kind: Service
metadata:
  name: vote
  labels:
    app: vote
spec:
  type: NodePort
  ports:
  - name: vote-service
    port: 8080
    targetPort: 80
    nodePort: 31000
  selector:
    app: vote

Result UI Service (result-service.yaml) — exposed on node port 31001 mapping Service port 8081 to container port 80:

apiVersion: v1
kind: Service
metadata:
  name: result
  labels:
    app: result
spec:
  type: NodePort
  ports:
  - name: result-service
    port: 8081
    targetPort: 80
    nodePort: 31001
  selector:
    app: result

Service summary

Service file	Type	Cluster Port	NodePort (external)
`redis-service.yaml`	ClusterIP	6379	n/a
`db-service.yaml`	ClusterIP	5432	n/a
`vote-service.yaml`	NodePort	8080	`31000`
`result-service.yaml`	NodePort	8081	`31001`

NodePort exposes ports on each cluster node and is suitable for demos. For production, consider using Ingress, a LoadBalancer Service, or a cloud LB rather than NodePort.

3. Apply manifests to the cluster

From the directory containing all YAML files, apply them in one command:

kubectl apply -f .

You should see resource creation messages similar to:

pod/db created
service/db created
pod/redis created
service/redis created
pod/result created
service/result created
service/vote created
pod/vote created
pod/worker created

4. Verify Pods and Services

Check that Pods are running:

kubectl get pods

Expected output (example):

NAME     READY   STATUS    RESTARTS   AGE
db       1/1     Running   0          2m20s
redis    1/1     Running   0          2m20s
result   1/1     Running   0          2m20s
vote     1/1     Running   0          2m20s
worker   1/1     Running   0          2m20s

List Services to confirm types and port mappings:

kubectl get svc

Example output:

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)              AGE
db           ClusterIP   10.96.162.14    <none>        5432/TCP             2m42s
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP              69m
redis        ClusterIP   10.96.38.124    <none>        6379/TCP             2m42s
result       NodePort    10.96.215.46    <none>        8081:31001/TCP       2m42s
vote         NodePort    10.96.175.115   <none>        8080:31000/TCP       2m42s

The NodePort mapping is shown as <service-port>:<nodePort>/TCP, for example 8080:31000/TCP.

5. Access the UIs

Find a node IP to access NodePort services:

kubectl get nodes -o wide

Use the node’s INTERNAL-IP and the nodePort to open the UIs in your browser. For example, if the node’s IP is 192.168.97.2:

Vote UI: http://192.168.97.2:31000
Result UI: http://192.168.97.2:31001

Open the Vote UI, cast a vote (for example, select Cats), then open the Result UI to confirm the service mesh and database updates. You should see the updated poll results (example below).

A simple blue screen showing a small centered poll results box that reads "CATS 100.0%" and "DOGS 0.0%." A browser window frame is visible around the screen and "1 vote" is shown in the bottom-right.

Conclusion

You have completed an end-to-end deployment of the Example Voting App on Kubernetes:

Pods for each component (vote, result, redis, db, worker)
ClusterIP Services for internal-only components (Redis, Postgres)
NodePort Services to expose vote and result UIs for demonstration

For production deployments, replace Pod manifests with Deployments (for replica management), move secrets into Secret objects, and use Ingress or LoadBalancer Services to expose public endpoints.

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

1. Pod manifests

Quick manifest summary

2. Service manifests

Service summary

3. Apply manifests to the cluster

4. Verify Pods and Services

5. Access the UIs

Conclusion

Links and references

Watch Video

​1. Pod manifests

​Quick manifest summary

​2. Service manifests

​Service summary

​3. Apply manifests to the cluster

​4. Verify Pods and Services

​5. Access the UIs

​Conclusion

​Links and references

Watch Video

1. Pod manifests

Quick manifest summary

2. Service manifests

Service summary

3. Apply manifests to the cluster

4. Verify Pods and Services

5. Access the UIs

Conclusion

Links and references