Master DevOps Monitoring with Prometheus

Set up a testing workspace to learn Prometheus hands-on with VirtualBox, Visual Studio Code, Ubuntu Server, and the Docker Engine, using SSH and a built-in terminal.

Install VirtualBox, create a Ubuntu 64-bit virtual machine named Prometheus, allocate 2 GB RAM and 10 GB disk, attach the ISO, enable bridged networking, and install OpenSSH server.

Install and configure Visual Studio Code on macOS, enabling SSH functionality and Remote Explorer. Connect to the Ubuntu VM via SSH, set up a terminal, and run apt-get update.

Install the Docker engine by running the official get.docker.com script, then add your user to the docker group and verify with docker ps.

Explore core monitoring principles, how Prometheus works, and its metrics, logs, push and pull methods, data model, and server architecture in the DevOps lifecycle.

Explore the DevOps lifecycle and the five stages of monitoring, from planning and coding through continuous integration, deployment, and continuous monitoring, with data collection, storage, alerting, visualization, analytics and reporting.

Explore four anti-patterns in DevOps monitoring, including cargo culting, tool obsession, and unnecessary toil, and emphasize Prometheus use via people, practices, service discovery, and monitoring beyond metrics.

Promote design patterns for monitoring, including continual improvement, composability over monolithic tools like Nagios, and user-centric metrics, and favor existing tools over in-house solutions.

Learn how metrics provide time-based aggregations to detect issues, then logs add context to the same events, using tools like Logstash, Graylog, and Fluentd.

Compare push and pull metrics collection in Prometheus, tracing agents that send data to a server versus targets exposing http endpoints for scraping, and the implications for scaling and availability.

Explore how Prometheus uses a dimensional data model with metric names and labels, using PromQL queries and aggregators like up and count to analyze http requests for status code 401.

Discover how the Prometheus server architecture connects data collection via pull-based scraping, exporters, push gateway, and service discovery, stores time series data locally, and visualizes with PromQL, Grafana, and Alertmanager.

Run the Prometheus server in your test environment, tour web interface, and learn node exporter metrics, Prometheus exposition, and how to run Prometheus as a systemd service or in Docker.

Run Prometheus in the terminal using three methods via SSH in Visual Studio Code on a virtual machine. Explore the expression browser, targets, and configuration to run queries like up.

Explore the Prometheus server package components, including console libraries, the time series database, and configuration checks, and learn to adjust retention, paths, and command line flags while verifying yaml.

Download, run, and expose linux kernel metrics from /proc and /sys with the Prometheus node exporter, view them on port 9100, and add a node exporter job to Prometheus.

Prometheus scrapes metrics from exporters every 15 seconds, revealing a metrics page with help text and type lines for summary, gauge, counter, and histogram, and enables bridges to other systems.

Install and configure Prometheus as a systemd service by creating a dedicated user, organizing data and config directories, moving binaries, and writing a systemd unit.

Set up the node exporter as a systemd service by creating its user, moving the binary, and configuring a three-section service file. Start the service and verify metrics are available.

Install Prometheus and the node exporter with Docker using Docker Compose to set up a multi-container monitoring environment. Configure volumes and configuration, then reload changes with curl to apply updates.

Learn to generate your own metrics, implement the four base metric types, explore instrumentation methods, understand metric name structure, recognize monitoring limits, and build a Docker web application.

Generate metrics for your web apps with the Prometheus Python client, expose a metrics endpoint, and learn how to count get requests using a Prometheus counter.

learn to add the counter metric to a Prometheus-instrumented Python app; import counter, create test_requests_total with a description, and increment it on each get request using .inc.

Explore the four metric types in Prometheus—counter, gauge, summary, and histogram—and learn how each tracks events, current state, latency, and quantiles.

Learn approaches to instrumentation across online, offline, and batch jobs, focusing on read, use, and Prometheus Gateway methods, and key metrics like request rate, latency, utilization, and batch run duration.

Learn how to apply Prometheus metric naming guidelines, including library.name.unit.suffix format, snake_case, lowercase starts, and base units, while avoiding reserved or conflicting names.

Explore limitations in monitoring metrics with Prometheus, including resource costs, cardinality, and how histograms with multiple labels impact cpu, memory, and observability decisions.

Add Prometheus instrumentation to a dockerized Flask app using WSGI and the Python client, exposing port 5000 and scraping metrics at /metrics.

Explore official and third-party exporters to extend Prometheus metrics collection, including node exporter, WMI, Docker engine, black box, MySQL exporters, and experiments with GitHub and gira exporters.

Discover how the node exporter collects Linux kernel metrics for Prometheus, highlighting its modular design, cpu idle and guest seconds queries, and memory metrics in the expression browser.

Explore node exporter metrics in depth, including file system details (files, size bytes, available vs free), disk input/output rates, network transmit and receive rates, and boot time and uname info.

Learn to export Windows metrics with the WMI exporter by installing the MSI, running it as a service, and configuring Prometheus to scrape on port 9182, with firewall considerations.

Learn to scrape Docker engine metrics with Prometheus by configuring a daemon.json, enabling metrics on port 9323, restarting the Docker daemon, and querying Docker engine metrics.

Learn to scrape container metrics with cAdvisor, Google's container advisor, a service discovery tool for docker containers; deploy via Docker Compose and view CPU, memory, network, and filesystem metrics.

Master Prometheus black box exporter for external monitoring with ICMP, TCP, HTTP, and DNS probes, and configure Docker Compose with a custom file to observe probe results.

Extend the black box exporter with tcp connect and dns probes. Update Prometheus with dns_google and tcp_connect targets and test them via the /probe path.

Learn to run the MySQL exporter with Prometheus by installing MySQL, creating the exporter user, configuring dot my.cnf, and exposing metrics on port 9104, noting Docker scraping issues.

Explore a third party Prometheus exporter for GitHub, run via Docker, expose metrics on port 9171, and configure with repos, user, and a GitHub token for reliable scrapes.

Learn to scrape Prometheus metrics from a Jira server by installing the Jira Prometheus plugin, exposing metrics, and configuring a Prometheus job to monitor Jira data.

Explore the Pushgateway in Prometheus monitoring, install and configure it with Docker, test push with a cron job, and enable the node exporter text file collector to push metrics.

Install and configure the push gateway with docker compose, enable honor labels for target and instrumentation labels, and push metrics to Prometheus via a cron job.

Configure the text file collector in node exporter to read .prom files from a directory, bind the temp folder in Docker, and push metrics to Prometheus via the push gateway.

Explore Prometheus service discovery and its methods. See practical examples with file service discovery configuration, Ansible-based discovery, and EC2 integration.

Learn how service discovery feeds Prometheus with target and discovered labels, using top-down and bottom-up approaches and file-based configurations (yaml or json) to manage static and dynamic targets.

Combine file service discovery with Ansible to install node exporter on virtual machines, update Prometheus configuration, and label targets.

Learn how to implement EC2 service discovery with Prometheus, including creating an IAM user, configuring the EC2 job, bootstrapping the node exporter, and using instance tags for discovered labels.

Master labeling for Prometheus monitoring by targeting source labels, replacing and external labels, and configuring black box exporter, while adding instrumentation and metrics to your web app.

Learn to target Prometheus targets by using relabel configs to drop or keep based on source labels like team, environment, and instance.

Master DevOps monitoring with Prometheus teaches how to use relabeling to transform and rename target labels, such as extracting instance ID, state, and environment from metadata during EC2 service discovery.

Learn how external labels give Prometheus server identity and enable high-availability across regions. Configure global external labels in the Prometheus config to set region and DC identifiers for each server.

Configure relabeling to route targets through the black box exporter, enabling Prometheus to probe web applications with http probes and properly map targets to instance labels.

Apply metrics relabelling in Prometheus to drop high cardinality metrics by regexing the name, while they remain scraped by the Jira plugin exporter and hidden in the expression browser.

Add labels to Prometheus metrics in a Flask web app by including request method and path, then rebuild the Docker image.

Master promql basics: perform aggregation and grouping with by and without, use the promql api, and apply operators count to rate, including min, max, topK, bottomK, binary and logical operators.

Aggregate metrics with PromQL by using equal, not equal, and regex matchers to filter by environment such as test and to select metrics like node exporter file system size bytes.

Learn to query the Prometheus API in the browser and with curl, retrieve metrics such as up, fetch json outputs with pretty print, and inspect runtime, build, configuration, and targets.

Learn to use Prometheus without and by groupers to compute total CPU usage per instance, excluding idle, then apply rates over five minutes and group Docker containers by name.

Learn how to use sum and count aggregators in Prometheus to compute total file system sizes, count Linux and Windows machines, and determine CPUs per instance by filtering labels.

Explore min and max operators to find group-level extremes, and use top K, bottom K, and count value operators with real-world examples like cpu idle time and gc duration.

Apply binary operators to compute memory metrics and percentages, convert bytes to gigabytes, and evaluate comparisons and booleans for alerts and ad hoc queries.

Master Prometheus label handling by using the ignoring and on clauses to compare and aggregate metrics with nonmatching labels, illustrated with docker and virtual machine cpu usage.

Explore promql logical operators or, unless, and how they filter samples and drive alerting rules. Use or to capture samples, unless to exclude matches, and to require both conditions.

Explore promql functions, starting with time function to compute uptime and convert it to hours and days. Learn minutes, day, month, year values, and sorting with rate, irate, and averages.

Explore rate, irate, avg, and avg_over_time in PromQL to analyze counters and aggregates. Learn to use 5-minute range vector, handle scrape variability, and improve alerts with average over time.

Derive memory change per second for gauge metrics, such as node exporter, and use predict linear to forecast memory usage from past day data, example jirah exporter next six hours.