Docker Microservices Demo with Cross-Language Containers

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

Learning Objectives

By the end of this guide, a reader will 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

  • Runtime environments

• Use docker build, docker run, and docker network commands.

• Inspect Docker networking with docker network inspect.

• Build a basic frontend that communicates with backend services.

Prerequisites

Before following this guide, ensure you have the following:

Foundational Knowledge

• Basic understanding of:

  • C#

  • Python

  • 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. They run on a host machine, which may be 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 also 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, three separate applications were created 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 were used to 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

Note : If you want to test files you can download project files from Project Repo:https://github.com/sumeetpypi/Docker-microservices-demo.git

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

# 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)

Dockerfile

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

requirement.txt

Flask

Build Image

Docker build -t notification-service:Demo .

Step 3: Build Node.js Frontend

server.js

Step 3: Build Node.js Frontend

server.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”: {
“2c2361e10770241b0cba70d0e58eef0ddf129bd09cbf392862ba874d28e96417”: {

“Name”: “auth-service”,

“EndpointID”: “c353fa8307a3382bef6462bf9a2b2526a22d55a3d363c77323fea637bbb6ee33”,

“MacAddress”: “ce:b0:cd:64:1d:be”,

“IPv4Address”: “172.19.0.2/16”,

“IPv6Address”: “”

},

“cdd769411ae9cfd8da615a96bca145a821b2d987e4984dc458bc82634656203f”: {

“Name”: “frontend-nodejs”,

“EndpointID”: “c1fa8e8d66449bca7e8f93089a8bdfd071c29600ac17ef212a88e8d9937be719”,

“MacAddress”: “86:41:52:44:6d:fc”,

“IPv4Address”: “172.19.0.4/16”,

“IPv6Address”: “”

},

“cf3f827dfe1586a1d9aa0f531255f9392585a97613be0a2a906200ad16b623f7”: {

“Name”: “notification-service”,

“EndpointID”: “41c10dda03e65a283eb4dbc06905e6482e09288a124962fa7eac5af9953a5449”,

“MacAddress”: “ce:1d:45:12:4b:19”,

“IPv4Address”: “172.19.0.3/16”,

“IPv6Address”: “”

}

If all three containers appear in the output, as it shown in above example your services are connected successfully.

Step 7: Open in Browser

http://localhost:5003/

You will see the frontend dashboard showing:

• C# service response

Python notification response

Key Technical Concepts Learned

Why Container Names Work

Inside Docker network:

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

Docker automatically resolves names to container IP addresses.

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.