In this section, we will explore how to manage and orchestrate multiple containers using Docker Compose. This is essential for building complex applications that require multiple services to work together seamlessly.

1. Microservices Architecture: Understanding how to break down an application into smaller, manageable services.
2. Service Definition: How to define multiple services in a docker-compose.yml file.
3. Networking: How Docker Compose handles networking between containers.
4. Dependencies: Managing dependencies between services.

Before diving into multi-container applications, ensure you have a basic understanding of:

• Docker basics
• Docker Compose fundamentals
• Defining services in Docker Compose

In Docker Compose, you can define multiple services in a single docker-compose.yml file. Each service represents a container that will be part of your application.

• version: Specifies the version of the Docker Compose file format.
• services: Defines the different services (containers) that make up your application.
  • web: A service using the nginx image, exposing port 80.
  • app: A custom application service built from the ./app directory, exposing port 5000.
  • db: A PostgreSQL database service with environment variables for configuration.

Docker Compose automatically creates a network for your services, allowing them to communicate with each other using their service names as hostnames.

For example, the app service can connect to the db service using the hostname db.

The depends_on key specifies the order in which services should be started. In the example, the web service depends on the app service, ensuring that the app service starts before the web service.

1. Objective: Create a multi-container application with a web server, an application server, and a database.

2. Steps:

   • Create a directory structure:

     my-multi-container-app/
     ├── docker-compose.yml
     ├── app/
     │   ├── Dockerfile
     │   └── app.py
     

   • Define the docker-compose.yml file as shown in the example above.
   • Create a simple Flask application in app/app.py:

     from flask import Flask
     import os
     
     app = Flask(__name__)
     
     @app.route('/')
     def hello():
         return "Hello, World!"
     
     if __name__ == '__main__':
         app.run(host='0.0.0.0', port=5000)
     

   • Create a Dockerfile in the app directory:

     FROM python:3.8-slim
     WORKDIR /app
     COPY app.py /app
     RUN pip install flask
     CMD ["python", "app.py"]
     

   • Run docker-compose up in the my-multi-container-app directory.

3. Expected Outcome:

   • The web server should be accessible at http://localhost.
   • The application server should return "Hello, World!" when accessed.
   • The database should be running and accessible to the application server.

• Service Names: Ensure service names are unique and correctly referenced in the docker-compose.yml file.
• Port Conflicts: Avoid port conflicts by ensuring that the host ports are not already in use.
• Environment Variables: Use environment variables to configure services dynamically.

In this section, you learned how to define and manage multiple services using Docker Compose. This is a crucial skill for building and orchestrating complex applications that consist of multiple interdependent services. In the next section, we will dive deeper into Docker Compose commands to manage these multi-container applications effectively.