diff --git a/docs/getting_started.md b/docs/getting_started.md index cfc77b50b..babb242c9 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -118,7 +118,7 @@ For more about the expression language, see the To graph expressions, navigate to http://localhost:9090/graph and use the "Graph" tab. -For example, enter the following expression to graph the per-second rate of chunks +For example, enter the following expression to graph the per-second rate of chunks being created in the self-scraped Prometheus: ``` @@ -132,36 +132,26 @@ Experiment with the graph range parameters and other settings. Let us make this more interesting and start some example targets for Prometheus to scrape. -The Go client library includes an example which exports fictional RPC latencies -for three services with different latency distributions. - -Ensure you have the [Go compiler installed](https://golang.org/doc/install) and -have a [working Go build environment](https://golang.org/doc/code.html) (with -correct `GOPATH`) set up. - -Download the Go client library for Prometheus and run three of these example -processes: +The Node Exporter is used as an example target, for more information on using it +[see these instructions.](https://prometheus.io/docs/guides/node-exporter/) ```bash -# Fetch the client library code and compile example. -git clone https://github.com/prometheus/client_golang.git -cd client_golang/examples/random -go get -d -go build +tar -xzvf node_exporter-*.*.tar.gz +cd node_exporter-*.* # Start 3 example targets in separate terminals: -./random -listen-address=:8080 -./random -listen-address=:8081 -./random -listen-address=:8082 +./node_exporter --web.listen-address 127.0.0.1:8080 +./node_exporter --web.listen-address 127.0.0.1:8081 +./node_exporter --web.listen-address 127.0.0.1:8082 ``` You should now have example targets listening on http://localhost:8080/metrics, http://localhost:8081/metrics, and http://localhost:8082/metrics. -## Configuring Prometheus to monitor the sample targets +## Configure Prometheus to monitor the sample targets Now we will configure Prometheus to scrape these new targets. Let's group all -three endpoints into one job called `example-random`. However, imagine that the +three endpoints into one job called `node`. However, imagine that the first two endpoints are production targets, while the third one represents a canary instance. To model this in Prometheus, we can add several groups of endpoints to a single job, adding extra labels to each group of targets. In @@ -173,7 +163,7 @@ section in your `prometheus.yml` and restart your Prometheus instance: ```yaml scrape_configs: - - job_name: 'example-random' + - job_name: 'node' # Override the global default and scrape targets from this job every 5 seconds. scrape_interval: 5s @@ -189,8 +179,7 @@ scrape_configs: ``` Go to the expression browser and verify that Prometheus now has information -about time series that these example endpoints expose, such as the -`rpc_durations_seconds` metric. +about time series that these example endpoints expose, such as `node_cpu_seconds_total`. ## Configure rules for aggregating scraped data into new time series @@ -198,27 +187,26 @@ Though not a problem in our example, queries that aggregate over thousands of time series can get slow when computed ad-hoc. To make this more efficient, Prometheus allows you to prerecord expressions into completely new persisted time series via configured recording rules. Let's say we are interested in -recording the per-second rate of example RPCs -(`rpc_durations_seconds_count`) averaged over all instances (but -preserving the `job` and `service` dimensions) as measured over a window of 5 -minutes. We could write this as: +recording the per-second rate of cpu time (`node_cpu_seconds_total`) averaged +over all cpus per instance (but preserving the `job`, `instance` and `mode` +dimensions) as measured over a window of 5 minutes. We could write this as: ``` -avg(rate(rpc_durations_seconds_count[5m])) by (job, service) +avg by (job, instance, mode) (rate(node_cpu_seconds_total[5m])) ``` Try graphing this expression. To record the time series resulting from this expression into a new metric -called `job_service:rpc_durations_seconds_count:avg_rate5m`, create a file +called `job_instance_mode:node_cpu_seconds:avg_rate5m`, create a file with the following recording rule and save it as `prometheus.rules.yml`: ``` groups: -- name: example +- name: cpu-node rules: - - record: job_service:rpc_durations_seconds_count:avg_rate5m - expr: avg(rate(rpc_durations_seconds_count[5m])) by (job, service) + - record: job_instance_mode:node_cpu_seconds:avg_rate5m + expr: avg by (job, instance, mode) (rate(node_cpu_seconds_total[5m])) ``` To make Prometheus pick up this new rule, add a `rule_files` statement in your `prometheus.yml`. The config should now @@ -245,7 +233,7 @@ scrape_configs: static_configs: - targets: ['localhost:9090'] - - job_name: 'example-random' + - job_name: 'node' # Override the global default and scrape targets from this job every 5 seconds. scrape_interval: 5s @@ -261,5 +249,5 @@ scrape_configs: ``` Restart Prometheus with the new configuration and verify that a new time series -with the metric name `job_service:rpc_durations_seconds_count:avg_rate5m` +with the metric name `job_instance_mode:node_cpu_seconds:avg_rate5m` is now available by querying it through the expression browser or graphing it.