Docker Microservices Demo with Cross-Language Containers

From Local Development to Docker - A Cross-Language Technical Roadmap

By the end of this guide, you'll understand how to:

• Build a microservices application using multiple programming languages
• Run C# (.NET), Python (Flask), and Node.js (Express) services independently
• Convert applications into Docker images
• Use a Docker network so containers can communicate by service name
• Understand how containers isolate file systems, networking, and runtime environments
• Use docker build, docker run, and docker network commands
• Build a basic frontend that communicates with backend services

Prerequisites

Foundational Knowledge

• Basic understanding of C#, Python, and JavaScript/Node.js
• Familiarity with command line/terminal
• Basic understanding of APIs and HTTP requests

Software Required

• Docker Desktop installed and running
• .NET 8 SDK (Optional)
• Python 3.12+ (Optional)
• Node.js 22+ (Optional)
• Google Chrome or any browser
• Text editor (VS Code recommended)

Hardware Requirements

• Windows/Linux/Mac system
• Minimum 8 GB RAM recommended
• Internet connection for downloading Docker images and packages

Introduction: What Are Containers in Docker?

Containers run in isolated environments on a host machine (local or remote). Docker containers have their own:

• File system
• Networking
• Processes
• Runtime environment

This allows developers to build applications that behave consistently across systems.

You can create private Docker networks where containers communicate securely using container names instead of IP addresses.

The Story Behind This Project

To understand Docker networking practically, I created three separate applications using different technologies:

1. C# for the authentication service
2. Python for the notification service
3. Node.js for the frontend dashboard

Instead of running everything on localhost manually, Docker containers make them work together cleanly.

What Is Microservices Architecture?

Microservices is an architectural style where an application is split into small independent services.

Instead of one large monolithic application:

• Each service handles one responsibility
• Services can be built in different languages
• Services can scale independently
• Teams can develop services separately

In this project:

• Auth handles login/payment response
• Notification handles alerts
• Frontend shows all data in browser

Project Structure

micro-demo/
├── auth-service/          # C# ASP.NET Core Service
│   ├── auth-service.csproj
│   ├── Program.cs
│   └── Dockerfile
├── notification-service/  # Python Flask Service
│   ├── app.py
│   ├── requirements.txt
│   └── Dockerfile
└── frontend/              # Node.js Frontend
    ├── server.js
    ├── package.json
    └── Dockerfile

Download Project Files: GitHub Repository

Step 1: Build the C# Auth Service

Program.cs

using auth_service.payment_services;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var payment = new PaymentService();

app.MapGet("/", () => "auth-service running");

app.MapGet("/login", () =>
{
    return Results.Ok(new
    {
        token = "jwt-demo-token"
    });
});

app.MapGet("/pay", async () =>
{
    return Results.Ok(await payment.ProcessPayment());
});

app.Run("http://0.0.0.0:8080");

payment-service/payment.cs

using System.Net.Http;

namespace auth_service.payment_services;

public class PaymentService
{
    private readonly HttpClient http = new HttpClient();

    public async Task<object> ProcessPayment()
    {
        string notify = "";
        try
        {
            notify = await http.GetStringAsync("http://notification-service:5000/notify");
        }
        catch
        {
            notify = "notification failed";
        }

        return new
        {
            service = "payment-service",
            payment = "success",
            notification = notify
        };
    }
}

auth-service.csproj

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
</Project>

Dockerfile

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app .
EXPOSE 8080
ENTRYPOINT ["dotnet", "auth-service.dll"]

Build Image

docker build -t auth-service:Demo .

Step 2: Build Python Notification Service

app.py

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "notification-service running"

@app.route("/notify")
def notify():
    return "Email + SMS sent"

app.run(host="0.0.0.0", port=5000)

requirements.txt

Flask

Dockerfile

FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
EXPOSE 5000
CMD ["python", "app.py"]

Build Image

docker build -t notification-service:Demo .

Step 3: Build Node.js Frontend

server.js

const express = require("express");
const axios = require("axios");
const app = express();

app.get("/", async (req, res) => {
  let csData = {};
  let pythonData = "";

  try {
    const csResponse = await axios.get("http://auth-service:8080/pay");
    csData = csResponse.data;
  } catch (err) {
    csData = { error: "C# service unreachable" };
  }

  try {
    const pyResponse = await axios.get("http://notification-service:5000/notify");
    pythonData = pyResponse.data;
  } catch (err) {
    pythonData = "Python service unreachable";
  }

  res.send(`
    <html>
      <head>
        <title>Microservices Frontend</title>
      </head>
      <body>
        <h1>Frontend Dashboard</h1>
        <pre>${JSON.stringify(csData, null, 2)}</pre>
        <pre>${pythonData}</pre>
      </body>
    </html>
  `);
});

app.listen(3000, () => {
  console.log("Frontend running at Docker");
});

package.json

{
  "dependencies": {
    "axios": "^1.15.2",
    "express": "^5.2.1"
  }
}

Dockerfile

FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Build Docker Image

docker build -t frontend-nodejs:Demo .

Step 4: Create Docker Network

docker network create network-microservice

This creates a private bridge network where containers can find each other by container name.

Step 5: Run All Containers

Run Auth Service

docker run -d --name auth-service --network network-microservice -p 5001:8080 auth-service:Demo

Run Notification Service

docker run -d --name notification-service --network network-microservice -p 5002:5000 notification-service:Demo

Run Frontend

docker run -d --name frontend-nodejs --network network-microservice -p 5003:3000 frontend-nodejs:Demo

Step 6: Verify Network

docker network inspect network-microservice

Output:

"Containers": {
  "2c2361e10770...": {
    "Name": "auth-service",
    "IPv4Address": "172.19.0.2/16"
  },
  "cdd769411ae9...": {
    "Name": "frontend-nodejs",
    "IPv4Address": "172.19.0.4/16"
  },
  "cf3f827dfe15...": {
    "Name": "notification-service",
    "IPv4Address": "172.19.0.3/16"
  }
}

If all three containers appear in the output, your services are connected successfully!

Step 7: Open in Browser

Navigate to: http://localhost:5003/

You'll see the frontend dashboard showing:

• C# Service Data: Payment service response with notification
• Python Flask Data: Email + SMS sent confirmation

Key Technical Concepts Learned

Why Container Names Work

Inside the Docker network:

• http://auth-service:8080
• http://notification-service:5000

Docker automatically resolves names to container IP addresses.

Why This Is Powerful

You built:

• Cross-language architecture
• Independent deployments
• Internal service communication
• Real microservices behavior

Common Problems & Fixes

Docker Not Running

Start Docker Desktop first.

Port Already Used

Change -p host:container

Example:

-p 6003:3000

Container Cannot Reach Another Container

Ensure both are on same network:

docker network inspect network-microservice

Final Thoughts

This project demonstrates that Docker is not just for packaging apps—it becomes an operating environment where multiple services can behave like a distributed system on one machine.

You used:

• C#
• Python
• Node.js
• Networking
• APIs
• Containers

That is real backend engineering practice.

Questions? Comments? Drop them below!

If you found this helpful, give it a and share with your dev community!