DevOps · DOP-02

Observability with Prometheus and Grafana

Observability with Prometheus and Grafana is a hands-on course in building monitoring from scratch, from installing Prometheus and collecting metrics with exporters to writing PromQL, designing Grafana dashboards and setting alerts with Alertmanager, then extending to logs with Loki and traces. It suits DevOps engineers, SREs, system administrators and teams running Docker or Kubernetes.

Updated
From 9,450 THB / person 10,500 −10% excl. VAT 7% · group rates available
PDFDownload the course outline
  • Duration18 hours · 3 days
  • FormatOnsite / live online
  • Next roundOn request
  • CertificateIncluded

Course overview

When a system fails or slows down, the first question is how you find out and how fast. Many organizations still learn about problems from customer calls rather than from their own monitoring. Prometheus and Grafana are the open-source standard that DevOps and SRE teams worldwide use to collect metrics, visualize them on dashboards and alert before users are affected. This course builds an observability stack

from scratch: installing Prometheus, collecting metrics from servers, containers, databases and applications through exporters, writing PromQL to query and compute values, designing readable Grafana dashboards, configuring alert rules that do not create noise with Alertmanager, and finally long-term storage plus an introduction to logs and traces. Every topic is hands-on in a lab environment. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)

What you’ll gain

  • Understand observability concepts and the difference between metrics, logs and traces
  • Install and configure Prometheus and understand its pull-based architecture
  • Collect metrics from servers, containers and databases using exporters
  • Configure service discovery so new targets are monitored automatically
  • Write PromQL to query, compute rates and aggregate metric data
  • Design Grafana dashboards that are readable and useful to the team
  • Instrument your own application and monitor it using the four golden signals
  • Write alert rules and manage notifications effectively with Alertmanager
  • Plan long-term storage and extend into log and trace collection

Who this course is for

  • DevOps engineers and site reliability engineers responsible for system stability
  • System administrators and infrastructure teams who need monitoring that actually works
  • Developers who want to understand application behavior and performance in production
  • Teams running Docker and Kubernetes who need container monitoring
  • Technical leads who need to establish alerting and availability metrics

Prerequisites

  • Basic Linux command line skills (the Linux Administration course is recommended first)
  • Basic networking concepts such as ports, HTTP and DNS
  • Prior Docker experience helps but is not required
  • Programming is not required, but you should be able to read YAML configuration

Curriculum

Course Details

A 3-day course, 6 hours per day (18 hours in total), delivered as lectures with hands-on labs for every topic. Intermediate level. Learners take home a lab guide, Prometheus and Alertmanager configuration files, sample Grafana dashboards and a set of commonly used PromQL queries. All tools are open source and can be deployed in the organization at no licensing cost.

Day 1 Prometheus Fundamentals and Metric Collection

Section 1: Observability and Monitoring Concepts

  • The difference between monitoring and observability and why organizations need both
  • The three pillars: metrics, logs and traces, and choosing the right one for each problem
  • Key indicators: the four golden signals and SLI, SLO and error budget concepts
  • How Prometheus, Grafana and Alertmanager fit together

Section 2: Installing and Configuring Prometheus

  • The pull-based architecture and the Prometheus time series database
  • Installing Prometheus with Docker Compose and the structure of prometheus.yml
  • Metrics, labels and time series concepts and good metric naming
  • Lab: install Prometheus and monitor itself as the first target

Section 3: Collecting Metrics with Exporters

  • Collecting server metrics with Node Exporter (CPU, memory, disk, network)
  • Monitoring containers with cAdvisor and collecting database and web server metrics
  • Metric types: counter, gauge, histogram and summary, and when to use each
  • Lab: install several exporters and verify Prometheus is collecting everything

Section 4: Service Discovery and Target Management

  • Static target configuration and its limits as the system grows
  • Service discovery from files, DNS and cloud providers, and using it with Kubernetes
  • Using relabeling to organize labels and filter targets
  • Lab: configure service discovery so new targets are monitored automatically
Day 2 PromQL and Grafana Dashboards

Section 5: PromQL Fundamentals

  • Selecting data with selectors and filtering with label matchers
  • Common functions: rate, increase, sum, avg, max and using by and without
  • Calculating percentiles from histograms and spotting anomalies
  • Lab: write PromQL to answer real questions such as error rate and resource usage

Section 6: Grafana and Building Dashboards

  • Installing Grafana and connecting Prometheus as a data source
  • Panel types and choosing the right visualization for each kind of data
  • Using variables to build dashboards that can switch server or service
  • Lab: build a dashboard monitoring your own servers and containers

Section 7: Designing Dashboards That Work

  • Design principles so a dashboard immediately shows whether the system is healthy
  • Tailoring dashboards by audience: executives, operations teams and developers
  • Importing community dashboards and adapting them to the organization
  • Lab: refine a dashboard so it communicates system status on a single screen

Section 8: Application Monitoring

  • Instrumenting an application with a client library and exposing a metrics endpoint
  • Measuring the four golden signals: latency, traffic, errors and saturation
  • External monitoring with Blackbox Exporter to simulate the user perspective
  • Lab: add metrics to a sample application and build a dashboard to track it
Day 3 Alerting, Storage and Capstone

Section 9: Writing Alerting Rules

  • Writing alerting rules in PromQL and using the for duration to avoid noisy alerts
  • Setting severity levels and including the context the team needs to fix the problem
  • Symptom-based alerting: alert on what users feel, not on every internal metric
  • Lab: write alert rules for the servers and services you are monitoring

Section 10: Alertmanager and Notifications

  • Installing and configuring Alertmanager and connecting it to Prometheus
  • Grouping, silencing and inhibition to reduce alert noise
  • Sending notifications to email, LINE, Slack or your organization channels
  • Lab: send alerts to a real channel and test an outage scenario

Section 11: Long-term Storage and Performance

  • Setting retention periods and estimating the storage required
  • Long-term storage approaches and federation as the system scales
  • Performance tuning: scrape interval, label count and high cardinality problems
  • Backing up and maintaining the monitoring stack itself

Section 12: Logs, Traces and Capstone

  • Collecting logs with Loki and viewing logs alongside metrics in Grafana
  • Distributed tracing concepts and OpenTelemetry for following requests across services
  • Capstone: build a complete observability setup for one service from metrics to alerts
  • Workshop: present your dashboards and alert rules and receive feedback

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

For organisations — in-house / private

  • Tailor the content to your team’s tools and projects
  • Your dates, at your office or live online
  • Quotation with tax ID for procurement
Corporate training quote

Instructors

Frequently asked questions

What is the difference between monitoring and observability?

Monitoring watches metrics you already know matter and alerts when they cross a threshold, such as high CPU or a nearly full disk, answering whether something is wrong. Observability is the ability to understand what is happening inside a system from the data it emits, metrics, logs and traces, so you can work out why something is wrong, even for problems nobody anticipated. Organisations need both.

What does the rate function do in PromQL?

Counter metrics, such as total HTTP requests, only ever increase, so their raw values say little. The rate function calculates the average per-second increase over a time window, for example rate(http_requests_total[5m]), and handles counter resets when a service restarts. It is usually combined with sum by to group results by service or status code, for instance to find the error rate per second.

What are the steps to monitor servers with Prometheus and Grafana?

Start by installing Prometheus, for example with Docker Compose, and Node Exporter on the servers you want to watch. Add them as targets in prometheus.yml so Prometheus scrapes their metrics. Install Grafana, add Prometheus as a data source and build dashboards with PromQL or import community dashboards. Finally, write alerting rules and configure Alertmanager to notify your team. This course practises every step on lab machines.

Who is the Observability with Prometheus and Grafana course for, and what should I know beforehand?

It suits DevOps engineers and SREs responsible for system stability, administrators and infrastructure teams who need practical monitoring, developers who want to understand how their applications behave in production, and teams running Docker or Kubernetes. You should know basic Linux commands, understand ports, HTTP and DNS, and be able to read YAML. Some Docker experience makes the labs smoother.

What will I be able to do after the Observability with Prometheus and Grafana course?

You will be able to install Prometheus and collect metrics with exporters, set up service discovery, write PromQL to answer real questions such as error rates and resource use, build Grafana dashboards that show system health at a glance, instrument applications around the four golden signals, write alerting rules with Alertmanager, and extend to logs with Loki and traces. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.

Can the Observability with Prometheus and Grafana course be run in-house for our team?

Yes. It can be run in-house for your team, with examples adapted to your own work, such as designing dashboards and alerting rules for the services your team actually runs. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.