|
Cluster Monitoring Operator
The OpenShift Container Platform Cluster Monitoring Operator (CMO) is the central component of the stack. It controls the deployed monitoring components and resources and ensures that they are always up to date.
Prometheus Operator
The Prometheus Operator (PO) creates, configures, and manages Prometheus and Alertmanager instances. It also automatically generates monitoring target configurations based on familiar Kubernetes label queries.
Prometheus
The Prometheus is the systems and service monitoring system, around which the monitoring stack is based.
Prometheus Adapter
The Prometheus Adapter exposes cluster resource metrics API for horizontal pod autoscaling. Resource metrics are CPU and memory utilization.
Alertmanager
The Alertmanager service handles alerts sent by Prometheus.
kube-state-metrics
The
kube-state-metrics
exporter agent converts Kubernetes objects to metrics that Prometheus can use.
openshift-state-metrics
The
openshift-state-metrics
exporter expands upon
kube-state-metrics
by adding metrics for OpenShift Container Platform-specific resources.
node-exporter
node-exporter
is an agent deployed on every node to collect metrics about it.
Grafana
The Grafana analytics platform provides dashboards for analyzing and visualizing the metrics. The Grafana instance that is provided with the monitoring stack, along with its dashboards, is read-only.
All the components of the monitoring stack are monitored by the stack and are automatically updated when OpenShift Container Platform is updated.
In addition to the components of the stack itself, the monitoring stack monitors:
CoreDNS
Elasticsearch (if Logging is installed)
Fluentd (if Logging is installed)
HAProxy
Image registry
Kubelets
Kubernetes apiserver
Kubernetes controller manager
Kubernetes scheduler
Metering (if Metering is installed)
OpenShift apiserver
OpenShift controller manager
Operator Lifecycle Manager (OLM)
Telemeter client
Each OpenShift Container Platform component is responsible for its monitoring configuration. For problems with a component’s monitoring, open a bug in Bugzilla against that component, not against the general monitoring component.
Other OpenShift Container Platform framework components might be exposing metrics as well. For details, see their respective documentation.
1.2. Configuring the monitoring stack
Prior to OpenShift Container Platform 4, the Prometheus Cluster Monitoring stack was configured through the Ansible inventory file. For that purpose, the stack exposed a subset of its available configuration options as Ansible variables. You configured the stack before you installed OpenShift Container Platform.
In OpenShift Container Platform 4, Ansible is not the primary technology to install OpenShift Container Platform anymore. The installation program provides only a very low number of configuration options before installation. Configuring most OpenShift framework components, including the Prometheus Cluster Monitoring stack, happens post-installation.
This section explains what configuration is supported, shows how to configure the monitoring stack, and demonstrates several common configuration scenarios.
Prerequisites
-
The monitoring stack imposes additional resource requirements. Consult the computing resources recommendations in
Scaling the Cluster Monitoring Operator
and verify that you have sufficient resources.
1.2.1. Maintenance and support
The supported way of configuring OpenShift Container Platform Monitoring is by configuring it using the options described in this document.
Do not use other configurations, as they are unsupported.
Configuration paradigms might change across Prometheus releases, and such cases can only be handled gracefully if all configuration possibilities are controlled. If you use configurations other than those described in this section, your changes will disappear because the cluster-monitoring-operator reconciles any differences. The operator reverses everything to the defined state by default and by design.
Explicitly unsupported cases include:
Creating additional
ServiceMonitor
objects in the
openshift-*
namespaces.
This extends the targets the cluster monitoring Prometheus instance scrapes, which can cause collisions and load differences that cannot be accounted for. These factors might make the Prometheus setup unstable.
Creating unexpected
ConfigMap
objects or
PrometheusRule
objects.
This causes the cluster monitoring Prometheus instance to include additional alerting and recording rules.
Modifying resources of the stack.
The Prometheus Monitoring Stack ensures its resources are always in the state it expects them to be. If they are modified, the stack will reset them.
Using resources of the stack for your purposes.
The resources created by the Prometheus Cluster Monitoring stack are not meant to be used by any other resources, as there are no guarantees about their backward compatibility.
Stopping the Cluster Monitoring Operator from reconciling the monitoring stack.
Adding new alerting rules.
Modifying the monitoring stack Grafana instance.
1.2.2. Creating cluster monitoring ConfigMap
To configure the Prometheus Cluster Monitoring stack, you must create the cluster monitoring ConfigMap.
Prerequisites
-
An installed
oc
CLI tool
Administrative privileges for the cluster
Procedure
-
Check whether the
cluster-monitoring-config
ConfigMap object exists:
$ oc -n openshift-monitoring get configmap cluster-monitoring-config
-
If it does not exist, create it:
$ oc -n openshift-monitoring create configmap cluster-monitoring-config
-
Start editing the
cluster-monitoring-config
ConfigMap:
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
-
Create the
data
section if it does not exist yet:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
1.2.3. Configuring the cluster monitoring stack
You can configure the Prometheus Cluster Monitoring stack using ConfigMaps. ConfigMaps configure the Cluster Monitoring Operator, which in turn configures components of the stack.
Prerequisites
-
Make sure you have the
cluster-monitoring-config
ConfigMap object with the
data/config.yaml
section.
Procedure
-
Start editing the
cluster-monitoring-config
ConfigMap:
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
-
Put your configuration under
data/config.yaml
as key-value pair
<component_name>: <component_configuration>
:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
<component>:
<configuration_for_the_component>
Substitute
<component>
and
<configuration_for_the_component>
accordingly.
For example, create this ConfigMap to configure a Persistent Volume Claim (PVC) for Prometheus:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
prometheusK8s:
volumeClaimTemplate: spec: storageClassName: fast volumeMode: filesystem resources: requests: storage: 40Gi
Here,
prometheusK8s
defines the Prometheus component and the following lines define its configuration.
Save the file to apply the changes. The pods affected by the new configuration are restarted automatically.
1.2.4. Configurable monitoring components
This table shows the monitoring components you can configure and the keys used to specify the components in the ConfigMap:
Table 1.2. Configurable monitoring components
|
Component
|
Key
|
|
Prometheus Operator
prometheusOperator
Prometheus
prometheusK8s
Alertmanager
alertmanagerMain
kube-state-metrics
kubeStateMetrics
openshift-state-metrics
openshiftStateMetrics
Grafana
grafana
Telemeter Client
telemeterClient
Prometheus Adapter
k8sPrometheusAdapter
From this list, only Prometheus and Alertmanager have extensive configuration options. All other components usually provide only the
nodeSelector
field for being deployed on a specified node.
1.2.5. Moving monitoring components to different nodes
You can move any of the monitoring stack components to specific nodes.
Prerequisites
-
Make sure you have the
cluster-monitoring-config
ConfigMap object with the
data/config.yaml
section.
Procedure
-
Start editing the
cluster-monitoring-config
ConfigMap:
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
-
Specify the
nodeSelector
constraint for the component under
data/config.yaml
:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
<component>:
nodeSelector:
<node_key>: <node_value>
<node_key>: <node_value>
Substitute <component> accordingly and substitute <node_key>: <node_value> with the map of key-value pairs that specifies the destination node. Often, only a single key-value pair is used.
The component can only run on a node that has each of the specified key-value pairs as labels. The node can have additional labels as well.
For example, to move components to the node that is labeled foo: bar, use:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
prometheusOperator: nodeSelector: foo: bar prometheusK8s: nodeSelector: foo: bar alertmanagerMain: nodeSelector: foo: bar kubeStateMetrics: nodeSelector: foo: bar grafana: nodeSelector: foo: bar telemeterClient: nodeSelector: foo: bar k8sPrometheusAdapter: nodeSelector: foo: bar
openshiftStateMetrics:
nodeSelector:
node-role.kubernetes.io/infra: ""
-
Save the file to apply the changes. The components affected by the new configuration are moved to new nodes automatically.
1.2.6. Assigning tolerations to monitoring components
You can assign tolerations to any of the monitoring stack components to enable moving them to tainted nodes.
Prerequisites
-
Make sure you have the
cluster-monitoring-config
ConfigMap object with the
data/config.yaml
section.
Procedure
-
Start editing the
cluster-monitoring-config
ConfigMap:
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
-
Specify
tolerations
for the component:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
<component>:
tolerations:
<toleration_specification>
Substitute
<component>
and
<toleration_specification>
accordingly.
For example, a
oc adm taint nodes node1 key1=value1:NoSchedule
taint prevents the scheduler from placing pods in the
foo: bar
node. To make the
alertmanagerMain
component ignore that taint and to place
alertmanagerMain
in
foo: bar
normally, use this toleration:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
alertmanagerMain:
nodeSelector:
foo: bar
tolerations: - key: "key1" operator: "Equal" value: "value1" effect: "NoSchedule"
-
Save the file to apply the changes. The new component placement configuration is applied automatically.
1.2.7. Configuring persistent storage
Running cluster monitoring with persistent storage means that your metrics are stored to a persistent volume (PV) and can survive a pod being restarted or recreated. This is ideal if you require your metrics or alerting data to be guarded from data loss. For production environments, it is highly recommended to configure persistent storage. Because of the high IO demands, it is advantageous to use local storage.
Prerequisites
-
Dedicate sufficient local persistent storage to ensure that the disk does not become full. How much storage you need depends on the number of pods. For information on system requirements for persistent storage, see
Prometheus database storage requirements
.
Make sure you have a persistent Volume (PV) ready to be claimed by the persistent volume claim (PVC), one PV for each replica. Because Prometheus has two replicas and Alertmanager has three replicas, you need five PVs to support the entire monitoring stack. The PVs should be available from the Local Storage Operator. This does not apply if you enable dynamically provisioned storage.
Use the block type of storage.
Configure local persistent storage.
1.2.7.1. Configuring a local persistent volume claim
For the Prometheus or Alertmanager to use a persistent volume (PV), you first must configure a persistent volume claim (PVC).
Prerequisites
-
Make sure you have the
cluster-monitoring-config
ConfigMap object with the
data/config.yaml
section.
Procedure
-
Edit the
cluster-monitoring-config
ConfigMap:
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
-
Put your PVC configuration for the component under
data/config.yaml
:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
<component>:
volumeClaimTemplate:
metadata:
name: <PVC_name_prefix>
spec:
storageClassName: <storage_class>
resources:
requests:
storage: <amount_of_storage>
See the
Kubernetes documentation on PersistentVolumeClaims
for information on how to specify
volumeClaimTemplate
.
For example, to configure a PVC that claims local persistent storage for Prometheus, use:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
prometheusK8s:
volumeClaimTemplate:
metadata:
name: localpvc
spec:
storageClassName: local-storage
resources:
requests:
storage: 40Gi
In the above example, the storage class created by the Local Storage Operator is called
local-storage
.
To configure a PVC that claims local persistent storage for Alertmanager, use:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
alertmanagerMain:
volumeClaimTemplate:
metadata:
name: localpvc
spec:
storageClassName: local-storage
resources:
requests:
storage: 40Gi
-
Save the file to apply the changes. The pods affected by the new configuration are restarted automatically and the new storage configuration is applied.
1.2.7.2. Modifying retention time for Prometheus metrics data
By default, the Prometheus Cluster Monitoring stack configures the retention time for Prometheus data to be 15 days. You can modify the retention time to change how soon the data is deleted.
Prerequisites
-
Make sure you have the
cluster-monitoring-config
ConfigMap object with the
data/config.yaml
section.
Procedure
-
Start editing the
cluster-monitoring-config
ConfigMap:
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
-
Put your retention time configuration under
data/config.yaml
:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
prometheusK8s:
retention: <time_specification>
Substitute
<time_specification>
with a number directly followed by
ms
(milliseconds),
s
(seconds),
m
(minutes),
h
(hours),
d
(days),
w
(weeks), or
y
(years).
For example, to configure retention time to be 24 hours, use:
apiVersion: v1
kind: ConfigMap
metadata:
name: cluster-monitoring-config
namespace: openshift-monitoring
data:
config.yaml: |
prometheusK8s:
retention: 24h
-
Save the file to apply the changes. The pods affected by the new configuration are restarted automatically.
1.2.8. Configuring Alertmanager
The Prometheus Alertmanager is a component that manages incoming alerts, including:
Alert silencing
Alert inhibition
Alert aggregation
Reliable deduplication of alerts
Grouping alerts
Sending grouped alerts as notifications through receivers such as email, PagerDuty, and HipChat
1.2.8.1. Alertmanager default configuration
The default configuration of the OpenShift Container Platform Monitoring Alertmanager cluster is this:
global:
resolve_timeout: 5m
route:
group_wait: 30s
group_interval: 5m
repeat_interval: 12h
receiver: default
routes:
- match:
alertname: Watchdog
repeat_interval: 5m
receiver: watchdog
receivers:
- name: default
- name: watchdog
OpenShift Container Platform monitoring ships with the Watchdog alert, which fires continuously. Alertmanager repeatedly sends notifications for the Watchdog alert to the notification provider, for example, to PagerDuty. The provider is usually configured to notify the administrator when it stops receiving the Watchdog alert. This mechanism helps ensure continuous operation of Prometheus as well as continuous communication between Alertmanager and the notification provider.
1.2.8.2. Applying custom Alertmanager configuration
You can overwrite the default Alertmanager configuration by editing the
alertmanager-main
secret inside the
openshift-monitoring
namespace.
Prerequisites
-
An installed
jq
tool for processing JSON data
Procedure
-
Print the currently active Alertmanager configuration into file
alertmanager.yaml
:
$ oc -n openshift-monitoring get secret alertmanager-main --template='{{ index .data "alertmanager.yaml" }}' |base64 -d > alertmanager.yaml
-
Change the configuration in file
alertmanager.yaml
to your new configuration:
global:
resolve_timeout: 5m
route:
group_wait: 30s
group_interval: 5m
repeat_interval: 12h
receiver: default
routes:
- match:
alertname: Watchdog
repeat_interval: 5m
receiver: watchdog
- match:
service: <your_service> 1
routes:
- match:
<your_matching_rules> 2
receiver: <receiver> 3
receivers:
- name: default
- name: watchdog
- name: <receiver>
<receiver_configuration>
-
1
-
service
specifies the service that fires the alerts.
<your_matching_rules>
specify the target alerts.
receiver
specifies the receiver to use for the alert.
For example, this listing configures PagerDuty for notifications:
global:
resolve_timeout: 5m
route:
group_wait: 30s
group_interval: 5m
repeat_interval: 12h
receiver: default
routes:
- match:
alertname: Watchdog
repeat_interval: 5m
receiver: watchdog
- match: service: example-app routes: - match: severity: critical receiver: team-frontend-page
receivers:
- name: default
- name: watchdog
- name: team-frontend-page pagerduty_configs: - service_key: "your-key"
With this configuration, alerts of
critical
severity fired by the
example-app
service are sent using the
team-frontend-page
receiver, which means that these alerts are paged to a chosen person.
Apply the new configuration in the file:
$ oc -n openshift-monitoring create secret generic alertmanager-main --from-file=alertmanager.yaml --dry-run -o=yaml | oc -n openshift-monitoring replace secret --filename=-
OpenShift Container Platform Cluster Monitoring by default ships with a set of pre-defined alerting rules.
Note that:
The default alerting rules are used specifically for the OpenShift Container Platform cluster and nothing else. For example, you get alerts for a persistent volume in the cluster, but you do not get them for persistent volume in your custom namespace.
Currently you cannot add custom alerting rules.
Some alerting rules have identical names. This is intentional. They are sending alerts about the same event with different thresholds, with different severity, or both.
With the inhibition rules, the lower severity is inhibited when the higher severity is firing.
1.2.8.4. Listing acting alerting rules
You can list the alerting rules that currently apply to the cluster.
Procedure
-
Configure the necessary port forwarding:
$ oc -n openshift-monitoring port-forward svc/prometheus-operated 9090
-
Fetch the JSON object containing acting alerting rules and their properties:
$ curl -s http://localhost:9090/api/v1/rules | jq '[.data.groups[].rules[] | select(.type=="alerting")]'
"name": "ClusterOperatorDown",
"query": "cluster_operator_up{job=\"cluster-version-operator\"} == 0",
"duration": 600,
"labels": {
"severity": "critical"
"annotations": {
"message": "Cluster operator {{ $labels.name }} has not been available for 10 mins. Operator may be down or disabled, cluster will not be kept up to date and upgrades will not be possible."
"alerts": [],
"health": "ok",
"type": "alerting"
"name": "ClusterOperatorDegraded",
...
1.3. Managing cluster alerts
OpenShift Container Platform 4.2 provides a web interface to the Alertmanager, which enables you to manage alerts. This section demonstrates how to use the Alerting UI.
1.3.1. Contents of the Alerting UI
This section shows and explains the contents of the Alerting UI, a web interface to the Alertmanager.
The main three pages of the Alerting UI are the
Alerts
, the
Silences
, and the
YAML
pages.
The
Alerts
page is accessible by clicking
Monitoring
→
Alerting
→
Alerts
in the OpenShift Container Platform web console.
Filtering alerts by their names.
Filtering the alerts by their states. To fire, some alerts need a certain condition to be true for the duration of a timeout. If a condition of an alert is currently true, but the timeout has not been reached, such an alert is in the
Pending
state.
Alert name.
Description of an alert.
Current state of the alert and when the alert went into this state.
Value of the Severity label of the alert.
Actions you can do with the alert.
The
Silences
page is accessible by clicking
Monitoring
→
Alerting
→
Silences
in the OpenShift Container Platform web console.
Creating a silence for an alert.
Filtering silences by their name.
Filtering silences by their states. If a silence is pending, it is currently not active because it is scheduled to start at a later time. If a silence expired, it is no longer active because it has reached its end time.
Description of a silence. It includes the specification of alerts that it matches.
Current state of the silence. For active silences, it shows when it ends, and for pending silences, it shows when it starts.
Number of alerts that are being silenced by the silence.
Actions you can do with a silence.
The
YAML
page is accessible by clicking
Monitoring
→
Alerting
→
YAML
in the OpenShift Container Platform web console.
Upload a file with Alertmanager configuration.
Examine and edit the current Alertmanager configuration.
Save the updated Alertmanager configuration.
Also, next to the title of each of these pages is a link to the old Alertmanager interface.
You can either silence a specific alert or silence alerts that match a specification that you define.
You can edit a silence, which will expire the existing silence and create a new silence with the changed configuration.
Procedure
-
Navigate to the
Monitoring
→
Alerting
→
Silences
page.
For the silence you want to modify, click the button in the last column and click
Edit silence
.
Alternatively, you can click
Actions
→
Edit Silence
in the
Silence Overview
screen for a particular silence.
In the
Edit Silence
screen, enter your changes and click the
Save
button. This will expire the existing silence and create one with the chosen configuration.
You can expire a silence. Expiring a silence deactivates it forever.
Procedure
-
Navigate to the
Monitoring
→
Alerting
→
Silences
page.
For the silence you want to expire, click the button in the last column and click
Expire Silence
.
Alternatively, you can click the
Actions
→
Expire Silence
button in the
Silence Overview
page for a particular silence.
Confirm by clicking
Expire Silence
. This expires the silence.
1.4. Examining cluster metrics
OpenShift Container Platform 4.2 provides a web interface to Prometheus, which enables you to run Prometheus Query Language (PromQL) queries and examine the metrics visualized on a plot. This functionality provides an extensive overview of the cluster state and enables you to troubleshoot problems.
1.4.1. Contents of the Metrics UI
This section shows and explains the contents of the Metrics UI, a web interface to Prometheus.
The
Metrics
page is accessible by clicking
Monitoring
→
Metrics
in the OpenShift Container Platform web console.
Actions.
Add query.
Expand or collapse all query tables.
Delete all queries.
Hide the plot.
The interactive plot.
The catalog of available metrics.
Add query.
Run queries.
Query forms.
Expand or collapse the form.
The query.
Clear query.
Enable or disable query.
Actions for a specific query.
Enable or disable query.
Show or hide all series of the query from the plot.
Delete query.
The metrics table for a query.
Color assigned to the graph of the metric. Clicking the square shows or hides the metric’s graph.
Additionally, there is a link to the old Prometheus interface next to the title of the page.
1.4.2. Running metrics queries
You begin working with metrics by entering one or several Prometheus Query Language (PromQL) queries.
Procedure
-
Open the OpenShift Container Platform web console and navigate to the
Monitoring
→
Metrics
page.
In the query field, enter your PromQL query.
To show all available metrics and PromQL functions, click
Insert Metric at Cursor
.
For multiple queries, click
Add Query
.
For deleting queries, click
for the query, then select
Delete query
.
For keeping but not running a query, click the
Disable query
button.
Once you finish creating queries, click the
Run Queries
button. The metrics from the queries are visualized on the plot. If a query is invalid, the UI shows an error message.
Queries that operate on large amounts of data might timeout or overload the browser when drawing timeseries graphs. To avoid this, hide the graph and calibrate your query using only the metrics table. Then, after finding a feasible query, enable the plot to draw the graphs.
Optional: The page URL now contains the queries you ran. To use this set of queries again in the future, save this URL.
1.4.3. Exploring the visualized metrics
After running the queries, the metrics are displayed on the interactive plot. The X axis of the plot represents time. The Y axis represents the metrics values. Each metric is shown as a colored graph. You can manipulate the plot and explore the metrics.
Procedure
-
Initially, all metrics from all enabled queries are shown on the plot. You can select which metrics are shown.
To hide all metrics from a query, click
for the query and click
Hide all series
.
To hide a specific metric, go to the query table and click the colored square near the metric name.
To zoom into the plot and change the shown time range, do one of the following:
Visually select the time range by clicking and dragging on the plot horizontally.
Use the menu in the left upper corner to select the time range.
To reset the time range, click
Reset Zoom
.
To display outputs of all queries at a specific point in time, hold the mouse cursor on the plot at that point. The query outputs will appear in a pop-up box.
For more detailed information about metrics of a specific query, expand the table of that query using the drop-down button. Every metric is shown with its current value.
To hide the plot, click
Hide Graph
.
1.5. Accessing Prometheus, Alertmanager, and Grafana
To work with data gathered by the monitoring stack, you might want to use the Prometheus, Alertmanager, and Grafana interfaces. They are available by default.
1.5.1. Accessing Prometheus, Alerting UI, and Grafana using the web console
You can access Prometheus, Alerting, and Grafana web UIs using a web browser through the OpenShift Container Platform web console.
The Alerting UI accessed in this procedure is the new interface for Alertmanager.
Prerequisites
-
Authentication is performed against the OpenShift Container Platform identity and uses the same credentials or means of authentication as is used elsewhere in OpenShift Container Platform. You must use a role that has read access to all namespaces, such as the
cluster-monitoring-view
cluster role.
Procedure
-
Navigate to the OpenShift Container Platform web console and authenticate.
To access Prometheus, navigate to the "Monitoring" → "Metrics" page.
To access the Alerting UI, navigate to the "Monitoring" → "Alerting" page.
To access Grafana, navigate to the "Monitoring" → "Dashboards" page.
1.5.2. Accessing Prometheus, Alertmanager, and Grafana directly
You can access Prometheus, Alertmanager, and Grafana web UIs using the
oc
tool and a web browser.
The Alertmanager UI accessed in this procedure is the old interface for Alertmanager.
Prerequisites
-
Authentication is performed against the OpenShift Container Platform identity and uses the same credentials or means of authentication as is used elsewhere in OpenShift Container Platform. You must use a role that has read access to all namespaces, such as the
cluster-monitoring-view
cluster role.
Procedure
-
$ oc -n openshift-monitoring get routes
NAME HOST/PORT ...
alertmanager-main alertmanager-main-openshift-monitoring.apps._url_.openshift.com ...
grafana grafana-openshift-monitoring.apps._url_.openshift.com ...
prometheus-k8s prometheus-k8s-openshift-monitoring.apps._url_.openshift.com ...
-
Prepend
https://
to the address, you cannot access web UIs using unencrypted connection.
For example, this is the resulting URL for Alertmanager:
https://alertmanager-main-openshift-monitoring.apps._url_.openshift.com
-
Navigate to the address using a web browser and authenticate.
The monitoring routes are managed by the Cluster Monitoring Operator and cannot be modified by the user.
Chapter 2. Exposing custom application metrics for autoscaling
You can export custom application metrics for the horizontal pod autoscaler.
Prometheus Adapter is a Technology Preview feature only. Technology Preview features are not supported with Red Hat production service level agreements (SLAs) and might not be functionally complete. Red Hat does not recommend using them in production. These features provide early access to upcoming product features, enabling customers to test functionality and provide feedback during the development process.
For more information about the support scope of Red Hat Technology Preview features, see
https://access.redhat.com/support/offerings/techpreview/
.
2.1. Exposing custom application metrics for horizontal pod autoscaling
You can use the
prometheus-adapter
resource to expose custom application metrics for the horizontal pod autoscaler.
Prerequisites
-
Make sure you have a custom Prometheus instance installed. In this example, it is presumed that Prometheus was installed in the
default
namespace.
Make sure you configured monitoring for your application. In this example, it is presumed that the application and the service monitor for it were installed in the
default
namespace.
Procedure
-
Create a YAML file for your configuration. In this example, it is called
deploy.yaml
.
Add configuration for creating the service account, necessary roles, and role bindings for
prometheus-adapter
:
kind: ServiceAccount
apiVersion: v1
metadata:
name: custom-metrics-apiserver
namespace: default
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: custom-metrics-server-resources
rules:
- apiGroups:
- custom.metrics.k8s.io
resources: ["*"]
verbs: ["*"]
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: custom-metrics-resource-reader
rules:
- apiGroups:
resources:
- namespaces
- pods
- services
verbs:
- get
- list
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: custom-metrics:system:auth-delegator
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: system:auth-delegator
subjects:
- kind: ServiceAccount
name: custom-metrics-apiserver
namespace: default
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: custom-metrics-auth-reader
namespace: kube-system
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: extension-apiserver-authentication-reader
subjects:
- kind: ServiceAccount
name: custom-metrics-apiserver
namespace: default
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: custom-metrics-resource-reader
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: custom-metrics-resource-reader
subjects:
- kind: ServiceAccount
name: custom-metrics-apiserver
namespace: default
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: hpa-controller-custom-metrics
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: custom-metrics-server-resources
subjects:
- kind: ServiceAccount
name: horizontal-pod-autoscaler
namespace: kube-system
Add configuration for the custom metrics for prometheus-adapter:
apiVersion: v1
kind: ConfigMap
metadata:
name: adapter-config
namespace: default
data:
config.yaml: |
rules:
- seriesQuery: 'http_requests_total{namespace!="",pod!=""}' 1
resources:
overrides:
namespace: {resource: "namespace"}
pod: {resource: "pod"}
service: {resource: "service"}
name:
matches: "^(.*)_total"
as: "${1}_per_second" 2
metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m])) by (<<.GroupBy>>)'
---- 1
Specifies the chosen metric to be the number of HTTP requests.
Specifies the frequency for the metric.
Add configuration for registering prometheus-adapter as an API service:
apiVersion: v1
kind: Service
metadata:
annotations:
service.alpha.openshift.io/serving-cert-secret-name: prometheus-adapter-tls
labels:
name: prometheus-adapter
name: prometheus-adapter
namespace: default
spec:
ports:
- name: https
port: 443
targetPort: 6443
selector:
app: prometheus-adapter
type: ClusterIP
apiVersion: apiregistration.k8s.io/v1beta1
kind: APIService
metadata:
name: v1beta1.custom.metrics.k8s.io
spec:
service:
name: prometheus-adapter
namespace: default
group: custom.metrics.k8s.io
version: v1beta1
insecureSkipTLSVerify: true
groupPriorityMinimum: 100
versionPriority: 100
Show the Prometheus Adapter image to use:
$ kubectl get -n openshift-monitoring deploy/prometheus-adapter -o jsonpath="{..image}"
quay.io/openshift-release-dev/ocp-v4.2-art-dev@sha256:76db3c86554ad7f581ba33844d6a6ebc891236f7db64f2d290c3135ba81c264c
-
Add configuration for deploying
prometheus-adapter
:
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: prometheus-adapter
name: prometheus-adapter
namespace: default
spec:
replicas: 1
selector:
matchLabels:
app: prometheus-adapter
template:
metadata:
labels:
app: prometheus-adapter
name: prometheus-adapter
spec:
serviceAccountName: custom-metrics-apiserver
containers:
- name: prometheus-adapter
image: openshift-release-dev/ocp-v4.2-art-dev 1
args:
- --secure-port=6443
- --tls-cert-file=/var/run/serving-cert/tls.crt
- --tls-private-key-file=/var/run/serving-cert/tls.key
- --logtostderr=true
- --prometheus-url=http://prometheus-operated.default.svc:9090/
- --metrics-relist-interval=1m
- --v=4
- --config=/etc/adapter/config.yaml
ports:
- containerPort: 6443
volumeMounts:
- mountPath: /var/run/serving-cert
name: volume-serving-cert
readOnly: true
- mountPath: /etc/adapter/
name: config
readOnly: true
- mountPath: /tmp
name: tmp-vol
volumes:
- name: volume-serving-cert
secret:
secretName: prometheus-adapter-tls
- name: config
configMap:
name: adapter-config
- name: tmp-vol
emptyDir: {}
-
1
-
image: openshift-release-dev/ocp-v4.2-art-dev
specifies the Prometheus Adapter image found in the previous step.
Apply the configuration file to the cluster:
$ oc apply -f deploy.yaml
-
Now the application’s metrics are exposed and can be used to configure horizontal pod autoscaling.
Legal Notice
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at
http://creativecommons.org/licenses/by-sa/3.0/
. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux
® is the registered trademark of Linus Torvalds in the United States and other countries.
Java
® is a registered trademark of Oracle and/or its affiliates.
XFS
® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL
® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js
® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The
OpenStack
® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
|
|