Demo Example Voting Application

This guide walks through the example voting application: its architecture, each service’s role and source layout, and how to build and run the full stack locally with Docker. The demo uses a small Flask front end, a Node.js real-time dashboard, a .NET worker, Redis as a queue, and Postgres as durable storage. Repository overview

The stack has five components: vote (Flask), result (Node.js + Socket.IO), worker (C#/.NET), redis (queue), and postgres (database).
App code for the three services is included in the repo under vote/, result/, and worker/. Redis and Postgres are pulled from public images.

Architecture diagram

Components — quick tour

Component	Language / Image	Role
`vote`	Python (Flask)	Web UI to cast votes; pushes JSON messages to Redis and sets a cookie per voter
`worker`	C# / .NET	Background processor: reads Redis votes, aggregates or transforms, then writes results to Postgres
`result`	Node.js + Socket.IO	Real-time dashboard: reads aggregated results from Postgres and pushes updates to connected clients
`redis`	`redis:alpine`	Short-lived queue (list named `votes`) used to buffer incoming votes
`db` (Postgres)	`postgres:15-alpine`	Durable store for aggregated results (uses a named volume for persistence)

vote (Flask)

A lightweight Flask app presents two options (e.g., Cats vs Dogs).
On submit, it generates a voter_id, pushes a JSON payload into Redis (list votes), and sets a cookie for the client.
The app listens on port 80 and is served by Gunicorn in the production image.

Key parts of the Flask application (simplified):

# app.py (excerpt)
import json
from flask import Flask, make_response, render_template
import redis

redis_client = redis.Redis(host='redis', port=6379, db=0)
app = Flask(__name__)

@app.route('/vote', methods=['POST'])
def vote():
    voter_id = "some-unique-id"  # generated per user
    vote = "cats"  # from form data
    data = json.dumps({'voter_id': voter_id, 'vote': vote})
    redis_client.rpush('votes', data)

    resp = make_response(render_template(
        'index.html',
        option_a='Cats',
        option_b='Dogs',
        hostname='vote',
        vote=vote,
    ))
    resp.set_cookie('voter_id', voter_id)
    return resp

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80, debug=True, threaded=True)

Multi-stage Dockerfile pattern (vote)

The example Dockerfile uses multi-stage builds to install dependencies in a base image, provide a development stage with file-watching, and produce a small runnable final image served by Gunicorn.

# Dockerfile (vote)
# base defines a base stage that uses the official python runtime base image
FROM python:3.11-slim AS base

# Add curl for healthcheck
RUN apt-get update && \
    apt-get install -y --no-install-recommends curl && \
    rm -rf /var/lib/apt/lists/*

# Set the application directory
WORKDIR /usr/local/app

# Install our requirements.txt
COPY requirements.txt ./requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# dev defines a stage for development, where it'll watch for filesystem changes
FROM base AS dev
RUN pip install watchdog
ENV FLASK_ENV=development
CMD ["python", "app.py"]

# final defines the stage that will bundle the application for production
FROM base AS final
COPY . .
EXPOSE 80
CMD ["gunicorn", "app:app", "-b", "0.0.0.0:80", "--workers", "3"]

worker (C#)

The worker polls Redis votes, processes each vote (e.g., de-duplicates or aggregates), and stores results in Postgres.
It connects to Redis at host redis and Postgres at host db using credentials in the demo.

Relevant C# snippet (simplified):

// Program.cs (excerpt)
using System;
using System.Threading;
using Npgsql;
using StackExchange.Redis;
using Newtonsoft.Json;

namespace Worker
{
    public class Program
    {
        public static int Main(string[] args)
        {
            var pgsql = OpenDbConnection("Server=db;Username=postgres;Password=postgres;");
            var redisConn = OpenRedisConnection("redis");
            var redis = redisConn.GetDatabase();

            var keepAliveCommand = pgsql.CreateCommand();
            keepAliveCommand.CommandText = "SELECT 1";

            var definition = new { vote = "", voter_id = "" };
            while (true)
            {
                // Poll for work, e.g., poll Redis "votes" list and process to Postgres
                Thread.Sleep(100);
            }
        }
    }
}

Example multi-stage Dockerfile for the worker (.NET):

# Dockerfile (worker)
# build compiles the program for the builder's local platform
FROM --platform=${BUILDPLATFORM} mcr.microsoft.com/dotnet/sdk:7.0 AS build
ARG TARGETPLATFORM
ARG TARGETARCH
ARG BUILDPLATFORM
RUN echo "I am running on $BUILDPLATFORM, building for $TARGETPLATFORM"

WORKDIR /source
COPY *.csproj .
RUN dotnet restore

COPY . .
RUN dotnet publish -c Release -o /app

# app image
FROM mcr.microsoft.com/dotnet/runtime:7.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "Worker.dll"]

result (Node.js)

The result service is a Node.js/Socket.IO server that reads aggregated state from Postgres and pushes updates to connected browsers in real time.
It uses a Postgres connection string pointing to host db with user postgres and password postgres (demo configuration).

Key server snippet:

// server.js (excerpt)
const http = require('http');
const socketio = require('socket.io');
const { Pool } = require('pg');
const async = require('async');

const app = require('express')();
const server = http.Server(app);
const io = socketio(server);

const port = process.env.PORT || 80;

io.on('connection', function (socket) {
  socket.emit('message', { text: 'Welcome!' });
  socket.on('subscribe', function (data) {
    socket.join(data.channel);
  });
});

var pool = new Pool({
  connectionString: 'postgres://postgres:postgres@db/postgres'
});

// retry connecting to DB until available
async.retry(
  { times: 1000, interval: 1000 },
  function(callback) {
    pool.connect(function(err, client, done) {
      if (err) {
        console.error("Waiting for db");
      }
      callback(err, client);
    });
  }
);

Example Dockerfile for the result app (Node):

# Dockerfile (result)
FROM node:18-slim

# add curl for healthcheck and tini
RUN apt-get update && \
    apt-get install -y --no-install-recommends curl tini && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /usr/local/app

# have nodemon available for local dev use (file watching)
RUN npm install -g nodemon

COPY package*.json ./

RUN npm ci && \
    npm cache clean --force && \
    mv /usr/local/app/node_modules /node_modules

COPY . .

ENV PORT=80
EXPOSE 80

CMD ["tini", "--", "node", "server.js"]

Important note about credentials

This demo embeds Postgres credentials and connection strings directly in source code for simplicity. For production, always inject secrets via environment variables, a secrets manager, or your orchestration platform (e.g., Docker secrets, Kubernetes Secrets, HashiCorp Vault).

Build and run locally with Docker (step-by-step)

From the repository root you can either build each service image manually or use docker compose up if the repository includes a Compose file.

Build images (if not using Compose):

docker build -t vote ./vote
docker build -t result ./result
docker build -t worker ./worker

Create a user-defined bridge network so containers can reach each other by name:

docker network create voting-app

Start Redis and Postgres (Postgres uses a named volume for persistence):

docker run -d --name redis --network voting-app redis:alpine

docker run -d --name db --network voting-app \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=postgres \
  -v db-data:/var/lib/postgresql/data \
  postgres:15-alpine

Run the application containers and attach them to the voting-app network:

# vote app (host port 8080 -> container 80)
docker run -d --name vote --network voting-app -p 8080:80 vote

# result app (host port 8081 -> container 80)
docker run -d --name result --network voting-app -p 8081:80 result

# worker app (background service, no host port required)
docker run -d --name worker --network voting-app worker

Verify containers are running:

docker ps

Ports and endpoints

Service	Host port	Container port	URL
vote	`8080`	`80`	http://localhost:8080
result	`8081`	`80`	http://localhost:8081

What to expect

Use the Vote UI to cast votes. The Flask app enqueues messages in Redis.
The worker polls Redis, processes votes, and writes aggregated results to Postgres.
The Result UI reads from Postgres and broadcasts updates to clients in real time via Socket.IO.

Cleanup (optional)

Stop and remove containers, the network, and the volume:

docker rm -f vote result worker redis db
docker network rm voting-app
docker volume rm -f db-data

That covers the local build-and-run workflow for the example voting application. For production deployment, move secrets out of source, use proper healthchecks and readiness probes, and consider orchestration with Docker Compose, Kubernetes, or another platform.

Introduction

Docker Commands

Docker Images

Docker Compose

Docker Engine, Storage

Docker Networking

Docker Registry

Docker on Mac & Windows

Container Orchestration - Docker Swarm & Kubernetes

Conclusion

Docker Run Commands

Demo Example Voting Application

Watch Video