Docker Monitoring and Visualization with Grafana & Prometheus

Monitoring containers is an important part of running reliable Docker-based applications. Simply knowing that a container is running is not enough—we also need to understand how much CPU, memory, disk, and other system resources it is consuming.

In this guide, we will build a simple Docker monitoring stack using Prometheus, cAdvisor, Node Exporter, and Grafana.

By the end, you will have a monitoring setup where:

cAdvisor collects Docker container metrics. Node Exporter collects host-system metrics. Prometheus collects and stores those metrics. Grafana turns the collected metrics into dashboards and visualizations.

Architecture

The monitoring setup can be understood as:

┌─────────────────┐
                │   Docker Host   │
                │                 │
                │  Containers     │
                └────────┬────────┘
                         │
              ┌──────────┴──────────┐
              │                     │
       ┌──────▼──────┐       ┌──────▼────────┐
       │   cAdvisor  │       │ Node Exporter │
       │ Container   │       │ Host Metrics  │
       │ Metrics     │       │               │
       └──────┬──────┘       └──────┬────────┘
              │                     │
              └──────────┬──────────┘
                         │
                  ┌──────▼──────┐
                  │ Prometheus  │
                  │   Metrics   │
                  │   Storage   │
                  └──────┬──────┘
                         │
                  ┌──────▼──────┐
                  │   Grafana   │
                  │ Dashboards  │
                  └─────────────┘

Prerequisites

Before starting, make sure Docker and Docker Compose are installed on your system.

You should be comfortable with basic Docker commands and YAML configuration files.

1. Create the Docker Compose Configuration

Create a docker-compose.yml file:

nano docker-compose.yml

Add the following configuration:

version: "3"

services:

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - 9090:9090
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
      - "--web.console.libraries=/usr/share/prometheus/console_libraries"
      - "--web.console.templates=/usr/share/prometheus/consoles"

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    ports:
      - 8080:8080
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - 9100:9100
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - "--path.procfs=/host/proc"
      - "--path.sysfs=/host/sys"
      - '--collector.filesystem.ignored-mount-points="^/(sys|proc|dev|host|etc)($$|/)"'

volumes:
  prometheus_data:

What are these services doing?

Prometheus

Prometheus is responsible for collecting and storing metrics. In this setup, it listens on port 9090.

The configuration file is mounted into the container:

- ./prometheus.yml:/etc/prometheus/prometheus.yml

A persistent volume is also used so that Prometheus data can survive container restarts.

cAdvisor

cAdvisor provides container-level metrics. It can monitor Docker containers and expose information about their resource usage.

It is exposed on:

http://localhost:8080

Node Exporter

Node Exporter exposes metrics about the underlying host system.

It runs on port:

9100

The configuration mounts /proc, /sys, and the host filesystem into the container so that Node Exporter can access the required host information.

2. Configure Prometheus

Create the Prometheus configuration:

nano prometheus.yml

Add:

global:
  scrape_interval: 15s

scrape_configs:

  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "cadvisor"
    static_configs:
      - targets: ["cadvisor:8080"]

  - job_name: "node-exporter"
    static_configs:
      - targets: ["node-exporter:9100"]

The scrape_interval determines how frequently Prometheus collects metrics. Here, Prometheus attempts to scrape the configured targets every 15 seconds.

The important part is the target configuration:

targets: ["cadvisor:8080"]

and:

targets: ["node-exporter:9100"]

Because these services are running within the same Docker Compose network, their service names can be used for communication.

3. Start the Monitoring Stack

Start the services using Docker Compose:

docker-compose up -d

You can check whether the containers are running with:

docker ps

You should see containers for:

prometheus
cadvisor
node-exporter

At this point, the basic monitoring stack is running.

4. Add Grafana

Now we need Grafana to visualize the metrics collected by Prometheus.

Add the following service to docker-compose.yml:

grafana:
  image: grafana/grafana:latest
  container_name: grafana
  ports:
    - 3000:3000
  volumes:
    - grafana_data:/var/lib/grafana
  environment:
    - GF_SECURITY_ADMIN_PASSWORD=admin

Also add the Grafana volume:

volumes:
  grafana_data: {}
  prometheus_data: {}

Your monitoring stack now contains four major components:

Prometheus
cAdvisor
Node Exporter
Grafana

Restart or recreate the services:

docker-compose up -d

Check the containers again:

docker ps

5. Open Grafana

Grafana is available at:

http://localhost:3000

Open the address in your browser.

The Grafana service in this setup uses:

Username: admin
Password: admin

For a real deployment, you should change the default credentials rather than using them in production.

6. Connect Prometheus to Grafana

Once you are inside Grafana, add Prometheus as a data source.

Navigate to:

Configuration → Data Sources

Create a new Prometheus data source.

For the Prometheus URL, use:

http://prometheus:9090

The important detail here is that Grafana is communicating with Prometheus through the Docker Compose network.

Using:

http://prometheus:9090

allows Grafana to reach the Prometheus container using its Compose service name.

After entering the URL, save and test the data source.

7. Import a Monitoring Dashboard

Instead of creating every visualization manually, Grafana allows dashboards to be imported using dashboard IDs.

In this setup, dashboard ID:

16310

can be imported into Grafana.

Go to:

Dashboards → Import

Enter:

16310

and proceed with the import.

Once the dashboard is connected to the Prometheus data source, Grafana can display the collected monitoring information.

8. Understanding the Monitoring Flow

At this point, it is useful to understand what happens when the system is running.

Suppose a Docker container starts consuming more CPU.

The flow is approximately:

Docker Container
       ↓
   cAdvisor
       ↓
   Prometheus
       ↓
     Grafana
       ↓
   Visualization

Similarly, host-level information is exposed by Node Exporter:

Docker Host
    ↓
Node Exporter
    ↓
Prometheus
    ↓
Grafana

Prometheus periodically scrapes the configured endpoints and stores the resulting time-series data.

Grafana then queries Prometheus and presents that data through dashboards.

9. Why Use Prometheus and Grafana Together?

Prometheus and Grafana solve different parts of the monitoring problem.

Prometheus

Prometheus focuses on:

Collecting metrics Scraping monitoring endpoints Storing time-series data Querying metrics

Grafana

Grafana focuses primarily on:

Visualization Dashboards Graphs Monitoring panels Presenting metrics in an easier-to-understand format

This separation makes the stack flexible. Prometheus handles the metric collection and storage while Grafana provides the visualization layer.

10. Why cAdvisor and Node Exporter?

These two exporters provide different perspectives.

cAdvisor focuses on containers and exposes container-related resource metrics.

Node Exporter focuses on the host machine and exposes system-level metrics.

Using both allows us to observe the relationship between the host and the containers running on it.

For example:

Host CPU / Memory
       │
       │
       ▼
Node Exporter
       │
       ▼
 Prometheus
       │
       ▼
  Grafana


Container CPU / Memory
       │
       │
       ▼
   cAdvisor
       │
       ▼
 Prometheus
       │
       ▼
  Grafana

11. Useful Commands

Here are some commands that are useful while working with this monitoring stack.

Check running containers:

docker ps

View logs from Prometheus:

docker logs prometheus

View cAdvisor logs:

docker logs cadvisor

View Node Exporter logs:

docker logs node-exporter

View Grafana logs:

docker logs grafana

Stop the stack:

docker-compose down

Start it again:

docker-compose up -d

12. Common Ports

The services in this setup use the following ports:

You can access the services locally using:

Prometheus → http://localhost:9090
cAdvisor → http://localhost:8080
Node Exporter → http://localhost:9100
Grafana → http://localhost:3000

Conclusion

In this project, we created a Docker-based monitoring stack using Prometheus, cAdvisor, Node Exporter, and Grafana.

The overall workflow is:

Docker Containers ──→ cAdvisor ──┐
                                 │
Docker Host ────────→ Node Exporter
                                 │
                                 ▼
                            Prometheus
                                 │
                                 ▼
                              Grafana
                                 │
                                 ▼
                           Dashboards

This setup provides a foundation for monitoring Docker environments and understanding how applications and infrastructure consume resources.

Once the basic stack is working, it can be extended with alerting, additional exporters, custom Prometheus queries, and more specialized Grafana dashboards.

The key takeaway is that monitoring becomes much more useful when raw metrics are transformed into something that can be observed and analyzed easily. Prometheus provides the metrics layer, while Grafana turns those metrics into a practical visualization interface.