Deploying a multi-container environment with Docker Compose

Do you have many software parts to run at the same time: a database, your main app (API), and monitoring tools? That can often be a headache!

Docker Compose is the simplest solution. It’s like a “master switch” that lets you turn on or off your whole system (database, API, monitoring tools, and more) with just a couple of commands.

This guide shows you how to build a complete system with:

• Backend API: built with Go/Gin
• PostgreSQL: the database
• Prometheus: Gathers data/Monitoring
• Grafana: visualization
• cAdvisor: monitors the server’s health

Prerequisites

Before you begin, make sure you have the following installed:

• Docker Install Docker
• Docker Compose – Install Docker Compose
• Git (optional, for version control)

The main pieces (services)

Everything is defined in the docker-compose.yml file. Here’s what we have:

How the pieces talk to each other

The important part is how the services communicate:

• API (backend) talks to the DB (db):
  • The API needs to know the database’s name. Instead of using localhost, it uses the Docker service name, which is just db (super simple!).
  • The password and database name (DB_PASSWORD, DB_NAME) are set using environment variables.
• Grafana talks to prometheus: Grafana needs data to draw charts, so it depends on prometheus.

Keeping your data safe

You don’t want to lose data every time you turn off Docker, right?

• Database: We use a volume called postgres_data. The data is saved outside the container, keeping it completely safe.
• Grafana: Also uses a volume to save the dashboards you create.

Setting up the monitoring tools

We set up a three-step “monitoring” system:

Prometheus - collecting the data

Prometheus needs to know where to “scrape” (fetch) data from.

• We use the prometheus/prometheus.yml file to tell it: “Go get data from the backend:8000 service every 15 seconds.”

cAdvisor - monitoring server health

• cAdvisor is a tool that tracks the “health” of Docker and your computer (CPU, RAM usage).
• It’s specially configured to be able to “see” the system information.

Grafana - viewing the charts

• You access it at http://localhost:3000.
• Log in with username: admin and password: admin.
• Here, you connect Grafana to Prometheus. Then, you use that data to build charts that track API performance, DB speed, or RAM/CPU usage.

Setup docker compose

We’ll use a docker-compose.yml file to define all the containers, networks, and volumes in our environment.

1
services:
2
  book-api:
3
    container_name: backend
4
    build:
5
      context: .
6
      dockerfile: Dockerfile
7
    ports:
8
      - "5000:5000"
9
    restart: 'on-failure'
10
    environment:
11
      POSTGRES_HOST: db
12
      POSTGRES_DB: DB_NAME
13
      POSTGRES_PORT: 5432
14
      POSTGRES_USER: postgres
15
      POSTGRES_PASSWORD: DB_PASSWORD
16
      GATEWAY_HOST: BASE_URL
17
    depends_on:
18
      - db
19
  ccadvisor:
20
    image: gcr.io/cadvisor/cadvisor:latest
21
    container_name: book-api-cadvisor
22
    restart: always
23
    volumes:
24
      - /etc/localtime:/etc/localtime:ro
25
      - /etc/timezone:/etc/timezone:ro
26
      - /:/rootfs:ro
27
      - /var/run:/var/run:rw
28
      - /sys:/sys:ro
29
      - /var/lib/docker:/var/lib/docker:ro
30
      - /var/run/docker.sock:/var/run/docker.sock:rw
31
    devices:
32
      - /dev/kmsg:/dev/kmsg
33
    depends_on:
34
      - book-api
35
  prometheus:
36
    image: prom/prometheus:latest
37
    container_name: book-api-prometheus
38
    restart: always
39
    volumes:
40
      - /etc/localtime:/etc/localtime:ro
41
      - /etc/timezone:/etc/timezone:ro
42
      - ./prometheus:/etc/prometheus
43
    command:
44
      - '--config.file=/etc/prometheus/prometheus.yml'
45
    ports:
46
      - '9090:9090'
47
  grafana:
48
    image: grafana/grafana:latest
49
    container_name: book-api-grafana
50
    restart: always
51
    volumes:
52
      - /etc/localtime:/etc/localtime:ro
53
      - /etc/timezone:/etc/timezone:ro
54
      - ./grafana/grafana.ini:/etc/grafana/grafana.ini
55
      - ./grafana/provisioning:/etc/grafana/provisioning
56
      - ./grafana/data:/var/lib/grafana
57
    user: "1000"
58
    depends_on:
59
      - prometheus
60
    ports:
61
      - "3000:3000"
62
  db:
63
    image: postgres:15
64
    container_name: postgres_container
65
    restart: always
66
    environment:
67
      POSTGRES_DB: DB_NAME
68
      POSTGRES_USER: postgres
69
      POSTGRES_PASSWORD: DB_PASSWORD
70
    ports:
71
      - "5433:5432"
72
    volumes:
73
      - postgres_data:/var/lib/postgresql/data
74

75
volumes:
76
  postgres_data:

Run and manage

This is the easiest part, with only 2 main commands!

Start the whole system

Run this command. Docker will automatically download what’s needed, build your API, and run all the services at once:

docker-compose up -d

Access the services

Once everything is running, you can visit the services:

Stop and clean up

When you want to turn off the whole system (e.g., at the end of the workday), use this command:

docker-compose down

Customizing configuration files

Prometheus configuration

You can add more scrape targets to monitor additional services.

1
- job_name: 'cadvisor'
2
  static_configs:
3
    - targets: ['cadvisor:8080']

Grafana dashboards

Add your custom dashboards in grafana/provisioning/dashboards/. Grafana automatically loads these on startup.

Conclusion

With docker compose, you can run your entire stack — API, database, and monitoring tools — using a single command. It simplifies setup, saves time, and keeps your environment consistent across development and production.