Docker Compose Day 18: Complete Guide

Hey there, tech explorers! 👋 Ready to dive deep into the world of containers? If you’ve been playing around with Docker and are looking to take things to the next level, you’re in the right place! In today’s blog, we’ll be exploring Docker Compose and YAML 📝—two game-changing tools that can turn your container management from meh to magnificent! 💥

So, fasten your seatbelt, grab a cup of coffee ☕, and let’s dive into it.

📋 Prerequisites 📋

Before we dive in, make sure you have the following in place:

🐧 Linux-based system (Ubuntu, CentOS, etc.) or Windows/Mac with Docker Desktop installed.
🐳 Docker and Docker Compose are installed and running on your system.

Install Docker:
```
  sudo apt-get update
  sudo apt-get install docker.io -y
```
Install Docker Compose:
```
  sudo apt-get install docker-compose -y
```
Docker Compose Installed: Check with
```
  docker-compose --version
```
👨‍💻 Basic understanding of terminal commands.
🌐 Internet connection to pull images from Docker Hub.

What is Docker Compose? 🐳🤔

Imagine you want to run a web app that needs three things:

A frontend to display stuff,
A backend to handle logic, and
A database to store data.

Now, setting up each service manually and linking them can be a pain, right? That’s where Docker Compose comes in to save the day! 🎉

✨ One file, one command, and BAM! 💥 Your entire environment is up and running in seconds! 🚀

In simple terms:

Docker Compose is a tool that allows you to define and manage multiple containers in one single file called docker-compose.yml.
It automates everything, from building images to linking containers and managing their networks. 🎩✨

What is YAML? 📄🤔

YAML is like the secret language 🤫 Docker Compose speaks!

YAML (Yet Another Markup Language or "YAML Ain't Markup Language") is a human-friendly data format that's easy to read and write. No more confusing syntax or complicated code—just simple, clean configurations. 🧼

YAML Syntax Basics:

Indentation Matters: Use spaces, not tabs.
Key-Value Pairs: Define data with simple key: value pairs.
Lists: Use hyphens (-) for lists.

Why YAML?

📝 Readable: Easy to read and write.
🎯 Structured: Organizes data hierarchically.
✅ Widely Used: Popular in DevOps for defining configurations like Docker Compose, Kubernetes manifests, and Ansible playbooks.

Think of YAML as a way to describe what you want Docker to do:

Which containers to start 🛠️
How they should communicate 📡
What environment variables to use 🌐

Here’s what YAML looks like in action:

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example

In this example:

web and db are services.
We specify images (like Nginx and MySQL).
We expose ports and set environment variables.

Easy, right? 😎

Let’s Get Hands-On! 💪

Task 1: Mastering Docker Compose

Now that you know what Docker Compose and YAML are, let’s get hands-on! 💪 Here’s how to set up your environment using a docker-compose.yml file.

🧑‍🍳 Step 1: Create a docker-compose.yml File

Open your favorite code editor (VS Code, Nano, or even Notepad).
Create a file named docker-compose.yml.
Add the following content to define two services: a web server and a database.

sudversion: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"  # Expose port 8080 on your machine to access the web service
    environment:
      ENV: production
    volumes:
      - .:/app
  db:
    image: mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: mypassword123  # Set environment variables

⚙️ Step 2: Run the Services

Open your terminal and navigate to the folder containing docker-compose.yml. Run:

docker-compose up -d

This command spins up both the web and database services. 🎉

🔍Step 3: Check the running containers

docker ps

🌐 Step 4: Check Everything is Running

Visit http://localhost:8080 in your browser. You should see the Nginx welcome page. If everything works, congrats! 🎊 You just ran multiple containers with one command!

⏹️ Step 5: Stop the services

docker-compose down

Using Environment Variables 🌱

You can manage environment variables in Docker Compose like this:

Option 1: Directly in the docker-compose.yml file (as shown above).

Option 2: Use a .env file for better manageability:

  ENV=production
  MYSQL_ROOT_PASSWORD=mypassword123

Example:

Store sensitive data in a .env file:

  NODE_ENV=production
  PORT=3000

Update your docker-compose.yml to use it:

  environment:
    - NODE_ENV=${NODE_ENV}
    - PORT=${PORT}

Task 2: Running Docker Containers 🐋

Let’s take it a step further and work with individual Docker commands.

🐋 Step 1: Pull a Docker Image

Grab a pre-built image from Docker Hub:

sudo docker pull nginx:latest

👨‍💻 Step 2: Run the Container as a Non-Root User

To run Docker commands without using sudo (admin rights), follow these steps:

Add your user to the docker group:
```
 sudo usermod -aG docker $USER
```
Reboot your machine for changes to take effect:
```
 sudo reboot
```
After the reboot, check if you can run Docker without sudo:
```
 docker ps
```
If you can run the command without sudo, you’re all set! 🎉

🔍 Step 3: Inspect the Container

Run a container:

docker run -d -p 8080:80 --name mynginx nginx:latest

Now inspect its details:

docker inspect mynginx

This will display all the juicy details like exposed ports, IP address, and running processes. 🕵️‍♂️

📜 Step 4: View Logs

Want to see what’s happening inside the container? Run:

docker logs mynginx

🛑 Step 5: Stop and Start the Container

Stop the container:

docker stop mynginx

Start it again:

docker start mynginx

🗑️ Step 6: Remove the Container

Once you're done, clean up by removing the container:

docker rm mynginx

Wrapping It Up with a Fun Twist! 🎉

And that’s a wrap, folks! 🎬 You've just unlocked another level in your Docker journey. 🚀 Let’s take a quick recap of what we covered:

Docker Compose helps you manage multi-container apps with ease.
YAML is the language you use to configure services in Docker Compose.
You can pull, inspect, log, stop, start, and remove Docker containers like a pro. 🚀
Bonus: Running Docker commands without sudo makes life much easier. 😉

With Docker Compose and YAML under your belt, you’re now ready to compose containerized symphonies! 🎵 Whether it’s running a simple web app 🕸️ or building complex microservices architecture 🏗️, you're in control. Keep experimenting, breaking things 🔧, and building them back stronger! 💥

🚀 “The best way to predict the future is to create it.” – Abraham Lincoln (and probably every DevOps engineer ever 😉)

Happy Docking! ⚓ See you in the next adventure! 🚢

Day 18 Docker Compose Task: Step-by-Step Instructions

Table of contents