Creating a multi-container application can be daunting, but Docker Compose and C# can make it much more straightforward. This article will walk us through the steps to create a multi-container application with Docker Compose and C#. Prerequisites Basic knowledge of OOPS concepts. Any programming language knowledge. Basic knowledge of docker So, to begin with, C#: Introduction to C# C# has been around for quite some period, and it continues to develop, obtaining more enhanced features. medium.com Learning Objectives How to create a multi-container application with Docker Compose and C#. Getting Started Step 1: Install Docker and Docker Compose Before we begin, make sure that Docker and Docker Compose are installed on your machine. Docker is a platform for developing, shipping, and running applications using containerization, while Docker Compose is a tool for defining and running multi-container Docker applications. You can download Docker and Docker Compose from their respective websites. Step 2: Create a New Project Directory Once Docker and Docker Compose are installed, please create a new directory for your project and navigate to it using your terminal. For this example, we will call our project "my-csharp-app". mkdir my-csharp-app
cd my-csharp-app Step 3: Create a Frontend Dockerfile Next, we will create a Dockerfile for our frontend container. This container will serve as a basic HTML page that calls our backend API. Create a new file called "Dockerfile.frontend" in your project directory and add the following code: FROM nginx:alpine
COPY ./nginx.conf /etc/nginx/conf.d/default.conf
COPY ./wwwroot /usr/share/nginx/html This Dockerfile uses the official nginx: alpine image as its base and copies our custom nginx configuration file and HTML files to the appropriate directories. Step 4: Create a Backend Dockerfile Next, we will create a Dockerfile for our backend container. This container will serve a simple C# API that returns a list of users in JSON format. Create a new file called "Dockerfile.backend" in your project directory and add the following code: FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /app
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o out

FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build /app/out .
ENTRYPOINT ["dotnet", "MyCSharpApp.dll"] This Dockerfile uses the official dotnet SDK as its base and copies our application code to the appropriate directory. It then restores dependencies, builds the application, and publishes it to an output directory. Finally, it copies the output to the appropriate directory in the final container and sets the entry point to start the application. Step 5: Create a Docker Compose File Now that we have our Dockerfiles, we can create a Docker Compose file to define our multi-container application. Create a new file called "docker-compose.yml" in your project directory and add the following code: version: "3"
services:
  frontend:
    build:
      context: .
      dockerfile: Dockerfile.frontend
    ports:
      - "8080:80"
    depends_on:
      - backend
  backend:
    build:
      context: .
      dockerfile: Dockerfile.backend
    ports:
      - "5000:5000" This Docker Compose file defines two services: "frontend" and "backend". The "frontend" service uses the Dockerfile.frontend file we created earlier to build its image. It exposes port 8080 on the host machine, which is mapped to port 80 in the container. It also depends on the "backend" service, meaning it will not start until the "backend" service is running. The "backend" service uses the Dockerfile.backend file we created earlier to build its image. It exposes port 5000 on both the host and container and has no dependencies on other services. Step 6: Add Configuration Files We need to add some configuration files that our containers will use to communicate. Create a new directory called "config" in your project directory, and create two files inside it: "appsettings.json" and "nginx.conf". In the "appsettings.json" file, add the following code: {
  "BackendBaseUrl": "http://backend:5000"
} This configuration file defines a variable called "BackendBaseUrl" used by our frontend container to make API calls to our backend container. In the "nginx.conf" file, add the following code: server {
    listen       80;
    server_name  localhost;
    location / {
        proxy_pass         http://frontend:80;
        proxy_redirect     off;
        proxy_set_header   Host $host;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Host $server_name;
    }
} This configuration file defines the NGINX reverse proxy settings, allowing our frontend container to communicate with our backend container. Step 7: Write the Application Code Now that we have our containers and configuration files, we can write the application code that will run inside them. Create a new directory called "src" in your project directory, and create two files inside it: "Program.cs" and "UserController.cs". In the "Program.cs" file, add the following code: using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace MyCSharpApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }
        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }
} This code sets up the entry point for our backend container and configures it to use a "Startup" class that we will define in the next step. In the "UserController.cs" file, add the following code: using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;

namespace MyCSharpApp.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class UserController : ControllerBase
    {
        private static readonly List<string> Users = new List<string> { "Alice", "Bob", "Charlie" };
        [HttpGet]
        public ActionResult<IEnumerable<string>> Get()
        {
            return Ok(Users);
        }
    }
} This code defines a simple controller that returns a list of users when an HTTP GET request is made to the "/user" route. Step 8: Write the Startup Class Create a new file called "Startup.cs" in your project directory, and add the following code: using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace MyCSharpApp
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        public IConfiguration Configuration { get; }
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
        }
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.UseRouting();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
} This code sets up the middleware for our backend container and adds support for controllers. Step 9: Build and Run the Application Now that we have written our application code, we can build and run our containers using Docker Compose. In your terminal, navigate to your project directory and run the following command: docker-compose up This command will build and start the containers defined in our "docker-compose.yml" file. Once the containers are running, you should be able to access the application by navigating to " " in your web browser. http://localhost You should see a page that displays a list of users, which is being served by our backend container and demonstrated by our frontend container. Step 10: Stop the Application After testing your application, you can stop all the running containers by pressing "Ctrl-C" in your terminal. This will stop and remove all the containers but will not delete any data or configuration files you created. Conclusion This article demonstrates how to create a multi-container application using Docker Compose and C#. By breaking our application into smaller, more modular containers, we can improve the scalability and maintainability of our application and make it easier to develop and deploy. Docker Compose provides a powerful toolset for managing complex container-based applications, and C# offers a robust and flexible platform for building web applications. By combining these two technologies, we can create modern, cloud-native applications that are efficient, reliable, and easy to manage. Follow Me On , , , , , C# Publication LinkedIn Instagram Twitter Dev.to BuyMeACoffee Also published here

How Lazy Loading Works in EF 8 Preview Release

How to Run a Microsoft .NET Docker Image in C#

Linktree

Buy Me a Coffee

Newsletter

Too Long; Didn't Read

Make resilience your competitive advantage

How to Create Multi-Container Applications With Docker Compose and C#

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Can We Train AI to Become More Human-Like?

111 Stories To Learn About Csharp

130 Stories To Learn About Dotnet

C# 8.0 Indices and Ranges

3 Insanely Easy Changes You Can Make To Clean Up Your Code

Can We Train AI to Become More Human-Like?

111 Stories To Learn About Csharp

130 Stories To Learn About Dotnet

C# 8.0 Indices and Ranges

3 Insanely Easy Changes You Can Make To Clean Up Your Code

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps