How to Run a Multi-Container .NET App Using Docker-Compose

Introduction

Docker Compose is a tool that simplifies the management of multi-container Docker applications. It allows you to define and manage a set of related services that together form your application in a single YAML file, typically named docker-compose.yml. Instead of running individual docker run commands for each container, Docker Compose enables you to define all the containers, networks, and volumes your application needs in one place.

The YAML file shows how to configure the containers, including specifying the base images, environment variables, ports, and dependencies between services.For instance, if you’re building a web application that requires a web server, a database, and a caching service, you can define each of these components as a separate service in the Compose file. Docker Compose will then handle starting, stopping, and scaling these containers, ensuring they work together as a cohesive unit.

One of the key features of Docker Compose is its ability to create isolated environments for your application. Each service runs in its own container but can easily communicate with other services through a common network defined in the Compose file. This makes it easier to set up complex applications, test them in a consistent environment, and deploy them to different stages of development and production.

Docker Compose is particularly useful for development, as it allows you to spin up an entire stack with a single command (docker-compose up). This can save time and reduce the complexity of managing dependencies and configurations, especially when working with microservices or distributed systems.

Implementation

version: '3.4'

services:
  order:
    image: ${DOCKER_REGISTRY-}order
    build:
      context: .
      dockerfile: Order/Dockerfile
    networks: 
      - eshop
    ports:
      - 5101:5101
    depends_on:
      - db
  product:
    image: ${DOCKER_REGISTRY-}product
    build:
      context: .
      dockerfile: Product/Dockerfile
    networks: 
      - eshop
    ports:
       - 5102:5102
    depends_on:
      - db
  customer:
    image: ${DOCKER_REGISTRY-}customer
    build:
      context: .
      dockerfile: Customer/Dockerfile
    networks: 
      - eshop
    ports:
       - 5103:5103
    depends_on:
      - db
  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: "postgres"
      POSTGRES_PASSWORD: "password"
      POSTGRES_DB: "mydatabase"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    network:
      - eshop
volumes:
  postgres_data:
networks:
  eshop:
    driver: bridge

Explaination:

Here, we have three .NET Web API services that uses Postgres DB. Each service will have its own Dockerfile. We have defined three services for the APIs and one service for the DB.

Each service has a name i.e. order, customer, product, db.

• image: specifies the Docker image to be used for the service
• build: used to specify how to build the Docker image for this service. This is typically used when you want to build the image from a Dockerfile.
• context: specifies the directory to be used as the build context. The ‘.’ indicates that the current directory (where the docker-compose.yml file is located) should be used
• network: used to specify the Docker networks that the service should connect to.
• port: used to map the host machine’s ports to the container’s ports.
• depends_on: specifies dependencies between services. This ensures that the service only starts after the system starts its dependencies.
• environment: allows you to define environment variables that will be available inside the container. We typically use these variables to configure the containerized application.
• volume: used to manage data persistence in Docker containers. It allows you to mount host directories or named volumes into the container’s file system.

Benefits

1. Simplified Configuration: Define and manage all your application services, networks, and volumes in a single YAML file.
2. Scalability: Easily scale services by adjusting the docker-compose.yml file, for example, by specifying replicas.
3. Isolation: Each service runs in its own container, ensuring that dependencies are isolated and do not conflict.
4. Consistent Environments: Developers and operations teams can use the same Docker Compose file, ensuring consistency across development, staging, and production environments.
5. Quick Setup and Teardown: With docker-compose up and docker-compose down, you can quickly spin up and tear down your entire application stack, making it ideal for testing and continuous integration pipelines.

Conclusion

Here we learned about what docker-compose is, how we can use docker-compose to deploy multiple .NET applications and some commonly used docker-compose keywords along with its benefits.