Containerizing .NET Microservices with Docker: Product and Order Services

3 min readJul 31, 2024

Containerization has revolutionized the way we develop, deploy, and manage applications, especially in a microservices architecture. By packaging applications and their dependencies into isolated containers, Docker ensures consistency across various environments, simplifies deployment, and enables easy scaling.

In this blog, we’ll walk through the process of containerizing two .NET microservices — Product and Order services — demonstrating the process of creating Dockerfiles, building images, and running containers. This setup provides a solid foundation for deploying and managing microservices in a production environment.

Embark on a journey of continuous learning and exploration with DotNet-FullStack-Dev. Uncover more by visiting our https://dotnet-fullstack-dev.blogspot.com reach out for further information.

Why Containerize .NET Microservices?

Containerizing microservices offers several benefits:

Isolation: Each service runs in its own container, avoiding conflicts between dependencies.
Consistency: Containers encapsulate the application and its environment, ensuring consistency from development to production.
Scalability: Containers can be easily scaled up or down based on demand.
Portability: Containers can run on any platform that supports Docker.

Setting Up the Environment

Before we begin, make sure you have the following installed:

Docker
.NET SDK (6.0 or later)
Docker Hub account (optional, for pushing images)

Assume we have two microservices:

Product Service: Manages product data.
Order Service: Manages customer orders.

Creating Dockerfiles

A Dockerfile is a script that contains instructions on how to build a Docker image for your application. Let’s create Dockerfiles for the Product and Order services.

Dockerfile for Product Service:

# Use the official .NET image as a build stage
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /app

# Copy the csproj and restore as distinct layers
COPY *.csproj ./
RUN dotnet restore

# Copy everything else and build
COPY . ./
RUN dotnet publish -c Release -o /out

# Use the official .NET runtime image for a smaller final image
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY --from=build /out .
ENTRYPOINT ["dotnet", "ProductService.dll"]

Dockerfile for Order Service:

# Use the official .NET image as a build stage
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /app

# Copy the csproj and restore as distinct layers
COPY *.csproj ./
RUN dotnet restore

# Copy everything else and build
COPY . ./
RUN dotnet publish -c Release -o /out

# Use the official .NET runtime image for a smaller final image
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY --from=build /out .
ENTRYPOINT ["dotnet", "OrderService.dll"]

Building Docker Images

Once the Dockerfiles are created, you can build the Docker images for both services. Navigate to the directory containing each Dockerfile and run:

Building the Product Service Image:

docker build -t product-service .

Building the Order Service Image:

docker build -t order-service .

These commands will create Docker images named product-service and order-service respectively.

Running Containers Locally

After building the images, you can run the containers locally to test the microservices.

Running the Product Service Container:

docker run -d -p 8000:80 --name product-service product-service

Running the Order Service Container:

docker run -d -p 8001:80 --name order-service order-service

-d: Run the container in detached mode.
-p: Map a port on the host to a port in the container.
--name: Name the running container.

Now, the Product service is accessible at http://localhost:8000 and the Order service at http://localhost:8001.

Networking Between Containers

In a microservices architecture, services often need to communicate with each other. Docker provides a way to create networks that containers can join, enabling them to discover and communicate with each other.

To create a network and connect both containers:

docker network create microservices-network
docker network connect microservices-network product-service
docker network connect microservices-network order-service

This setup allows the Product and Order services to communicate over the network microservices-network.

Pushing Images to Docker Hub (Optional)

If you want to deploy these services to a production environment, you can push the images to Docker Hub or any other container registry.

Tag and Push Product Service Image:

docker tag product-service your-dockerhub-username/product-service
docker push your-dockerhub-username/product-service

Tag and Push Order Service Image:

docker tag order-service your-dockerhub-username/order-service
docker push your-dockerhub-username/order-service

Conclusion

Containerizing .NET microservices with Docker offers a robust solution for developing, deploying, and scaling applications. By encapsulating each service in its own container, you can ensure consistent environments across different stages of development and deployment. Docker’s flexibility and portability make it an ideal choice for microservices architecture.