Welcome to the first lesson of the Multi-Container Orchestration with Docker Compose course. In this lesson, you'll be introduced to Docker Compose, a powerful tool used to define and manage multi-container Docker applications. Docker Compose is essential because it streamlines the process of running multiple interrelated Docker containers, such as web servers and databases, as a single cohesive application. This simplifies both development and production workflows by allowing you to define all services and configurations needed in a single file. As you have already learned about managing individual containers and networks, this lesson will build on that foundation by showing you how to orchestrate multiple containers using Docker Compose.

Docker Compose is a tool that makes it easy to manage a group of containers that work together as a single application. Each container, which might run a web server, a database, or another part of your application, is called a "service" in Docker Compose. Think of it as an orchestra where each musician (or container) plays an instrument (or service), and Docker Compose is the conductor that ensures all musicians play together in harmony to create beautiful music. This coordination of multiple services working together is what allows your application to function effectively.

Here’s why it’s important:

• Simplified Management: It allows you to manage various services like web servers, databases, or caches as a single application, coordinating them to work seamlessly together.

• Single Configuration File: By using a YAML file, Docker Compose lets you specify all the containers and their configurations in one place, eliminating manual setup.

• Efficient Orchestration: You can start, stop, and manage all parts of your application with a few simple commands, saving time and reducing errors.

• Development and Production Ready: Whether you’re developing locally or deploying to production, Docker Compose streamlines the workflow, ensuring consistency and reliability across environments.

This foundational understanding of Docker Compose will help you as we dive into its core component: the docker-compose.yml file.

A docker-compose.yml file is the core of setting up multi-container applications with Docker Compose. It uses a straightforward YAML syntax to describe all the services your application relies on, how they should be built, and how they interact with each other.

Here is a generic structure of a docker-compose.yml file:

YAML
Copy to clipboard
1version: '3'  # Specify the Docker Compose file format version
2
3services:  # Define the application services (containers) to be run
4  my_container:  # Define a service with a name
5    image: your_image_name  # Specify the image to use
6    ports:  # Optionally expose and map ports
7      - "80:8080" # host_port:container_port
8    environment:  # Optionally set environment variables
9      VARIABLE_NAME: value
10
11  # Add more services as needed...

Key Elements of the Structure:

• version: This specifies the syntax version being employed, ensuring compatibility with different Compose features. Version 3 is commonly used for its balance of features and simplicity.
• services: This section defines each container that makes up the application, grouping related components.
• my_container: Each service listed under services needs a unique identifier, which is used to reference and manage the service.
• image: Under each service, this specifies the Docker image to be used, determining what the service will run.
• ports: This optional element maps container ports to host ports, facilitating communication and access.
• environment: Also optional, this sets environment variables within the container, allowing customization and configuration at runtime.

The clear and concise structure of a docker-compose.yml makes it easy to manage complex applications with simple text files. If you want to learn more about this file, you can check the official Docker Compose File documentation.

Let's walk through creating a simple docker-compose.yml file that includes a web server and a database.

YAML
Copy to clipboard
1version: '3'  # Specify the Docker Compose file format version
2
3services:
4  web:  # Define a service named 'web'
5    image: nginx  # Use the official Nginx image
6    ports:
7      - "8080:80"  # Host 8080 -> Container 80
8
9  db:  # Define a service named 'db'
10    image: mysql  # Use the official MySQL image
11    environment:
12      MYSQL_ROOT_PASSWORD: abcd1234  # Define the MySQL root password inside the container

In this file, we define two services: web and db. The web service uses the official Nginx image and maps port 80 inside the container to port 8080 on the host machine, allowing web traffic to be served. The db service uses the official MySQL image, and we define an environment variable MYSQL_ROOT_PASSWORD to set the root password for the MySQL database.

With your docker-compose.yml file ready, you can start your application's services with a simple command. Navigate to the directory containing the file and run:

Bash
Copy to clipboard
1# Start all services defined in the docker-compose.yml file
2docker compose up

This command will initialize and start all defined services. If successful, you should see output messages similar to the following, indicating that the web server and database have started:

Plain text
Copy to clipboard
1[+] Running 19/2
2 ✔ web 7 layers [⣿⣿⣿⣿⣿⣿⣿]      0B/0B      Pulled                                                           8.0s 
3 ✔ db 10 layers [⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿]      0B/0B      Pulled                                                       21.1s 
4[+] Running 3/3
5 ✔ Network filesystem_default  Created                                                                      0.2s 
6 ✔ Container filesystem-web-1  Created                                                                      0.1s 
7 ✔ Container filesystem-db-1   Created                                                                      0.1s 
8Attaching to db-1, web-1
9db-1   | 2024-11-05 09:39:42+00:00 [Note] [Entrypoint]: Entrypoint script for MySQL Server 9.1.0-1.el9 started.
10web-1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
11...

This output confirms that the images for each service have been pulled, the containers have been created, and the services are now running. By default, docker compose up runs in attached mode, so you will continue to see the logs for each service as they execute. For more detailed information about this command, you can refer to the official Docker Compose Up documentation.

After starting your services with Docker Compose, you can verify which services are currently running using the following commands:

Bash
Copy to clipboard
1# List all running services with their status
2docker compose ps
3
4# List all services, regardless of their status
5docker compose ps -a

These commands provide a list of services defined in your docker-compose.yml file, displaying their status and other relevant details.

Here’s an example of the output you might see:

Plain text
Copy to clipboard
1NAME               IMAGE     COMMAND                  SERVICE   CREATED         STATUS         PORTS
2filesystem-db-1    mysql     "docker-entrypoint.s…"   db        3 minutes ago   Up 3 minutes   3306/tcp, 33060/tcp
3filesystem-web-1   nginx     "/docker-entrypoint.…"   web       3 minutes ago   Up 3 minutes   0.0.0.0:8080->80/tcp, :::8080->80/tcp

In the output, the SERVICE column directly refers to the service names specified in your Compose file, while the NAME column lists the container names, such as filesystem-db-1 and filesystem-web-1. These names are automatically generated by Docker Compose and consist of three parts:

1. Project Name: Derived from the parent directory, such as filesystem.
2. Service Name: Corresponding to the service names in your docker-compose.yml file, like db and web.
3. Numeric Suffix: Used to differentiate instances of the same service.

If you're curious to learn more about the docker compose ps command, feel free to check out the official Docker Compose ps documentation.

If you compare the Docker Compose output with what you see from docker ps, you'll notice a similar structure, which focuses on the running containers.

Here’s an example:

Plain text
Copy to clipboard
1CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
2bc94cd0b7f13   mysql     "docker-entrypoint.s…"   5 minutes ago   Up 4 minutes   3306/tcp, 33060/tcp                     filesystem-db-1
3bdd0a2843740   nginx     "/docker-entrypoint.…"   5 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp, :::8080->80/tcp   filesystem-web-1

The NAMES column uses the same naming convention as Docker Compose, maintaining consistency and allowing you to easily link each container to its respective service. This uniform naming approach simplifies the management and monitoring of containers in a multi-container application setup, providing clarity and organization.

In this lesson, you were introduced to Docker Compose and learned how to write a basic docker-compose.yml file. You explored the fundamental structure of compose files and ran key Docker Compose commands to bring up your services. This lays the groundwork for much more complex applications that we will explore in later lessons. As you move forward to the practice exercises, you'll have the opportunity to apply these concepts by creating and managing your own multi-container Docker applications. Keep this knowledge in mind as you experiment, and remember that Docker Compose is your ally in simplifying container management.