Chapter 2. Configuring the monitoring stack

2.1. Prerequisites
Copia collegamento

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.

2.2. Maintenance and support for monitoring
Copia collegamento

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 resets everything to the defined state by default and by design.

2.2.1. Support considerations for monitoring
Copia collegamento

The following modifications are explicitly not supported:

Creating additional ServiceMonitor, PodMonitor, and PrometheusRule objects in the openshift-* and kube-* projects.
Modifying any resources or objects deployed in the openshift-monitoring or openshift-user-workload-monitoring projects. The resources created by the OpenShift Container Platform monitoring stack are not meant to be used by any other resources, as there are no guarantees about their backward compatibility.
Note
The Alertmanager configuration is deployed as a secret resource in the
openshift-monitoring
namespace. If you have enabled a separate Alertmanager instance for user-defined alert routing, an Alertmanager configuration is also deployed as a secret resource in the
openshift-user-workload-monitoring
namespace. To configure additional routes for any instance of Alertmanager, you need to decode, modify, and then encode that secret. This procedure is a supported exception to the preceding statement.
Modifying resources of the stack. The OpenShift Container Platform monitoring stack ensures its resources are always in the state it expects them to be. If they are modified, the stack will reset them.
Deploying user-defined workloads to openshift-*, and kube-* projects. These projects are reserved for Red Hat provided components and they should not be used for user-defined workloads.
Installing custom Prometheus instances on OpenShift Container Platform. A custom instance is a Prometheus custom resource (CR) managed by the Prometheus Operator.
Enabling symptom based monitoring by using the Probe custom resource definition (CRD) in Prometheus Operator.

Note

Backward compatibility for metrics, recording rules, or alerting rules is not guaranteed.

2.2.2. Support policy for monitoring Operators
Copia collegamento

Monitoring Operators ensure that OpenShift Container Platform monitoring resources function as designed and tested. If Cluster Version Operator (CVO) control of an Operator is overridden, the Operator does not respond to configuration changes, reconcile the intended state of cluster objects, or receive updates.

While overriding CVO control for an Operator can be helpful during debugging, this is unsupported and the cluster administrator assumes full control of the individual component configurations and upgrades.

Overriding the Cluster Version Operator

The

spec.overrides

parameter can be added to the configuration for the CVO to allow administrators to provide a list of overrides to the behavior of the CVO for a component. Setting the

spec.overrides[].unmanaged

parameter to

true

for a component blocks cluster upgrades and alerts the administrator after a CVO override has been set:

Disabling ownership via cluster version overrides prevents upgrades. Please remove overrides before continuing.

Warning

Setting a CVO override puts the entire cluster in an unsupported state and prevents the monitoring stack from being reconciled to its intended state. This impacts the reliability features built into Operators and prevents updates from being received. Reported issues must be reproduced after removing any overrides for support to proceed.

2.3. Preparing to configure the monitoring stack
Copia collegamento

You can configure the monitoring stack by creating and updating monitoring config maps.

2.3.1. Creating a cluster monitoring config map
Copia collegamento

To configure core OpenShift Container Platform monitoring components, you must create the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

project.

Note

When you save your changes to the

cluster-monitoring-config

ConfigMap

object, some or all of the pods in the

openshift-monitoring

project might be redeployed. It can sometimes take a while for these components to redeploy.

Prerequisites

You have access to the cluster as a user with the
```
cluster-admin
```
cluster role.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Check whether the

cluster-monitoring-config

ConfigMap

object exists:

$ oc -n openshift-monitoring get configmap cluster-monitoring-config

If the

ConfigMap

object does not exist:

Create the following YAML manifest. In this example the file is called

cluster-monitoring-config.yaml

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |

Apply the configuration to create the

ConfigMap

object:

$ oc apply -f cluster-monitoring-config.yaml

2.3.2. Creating a user-defined workload monitoring config map
Copia collegamento

To configure the components that monitor user-defined projects, you must create the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project.

Note

When you save your changes to the

user-workload-monitoring-config

ConfigMap

object, some or all of the pods in the

openshift-user-workload-monitoring

project might be redeployed. It can sometimes take a while for these components to redeploy. You can create and configure the config map before you first enable monitoring for user-defined projects, to prevent having to redeploy the pods often.

Prerequisites

You have access to the cluster as a user with the
```
cluster-admin
```
cluster role.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Check whether the

user-workload-monitoring-config

ConfigMap

object exists:

$ oc -n openshift-user-workload-monitoring get configmap user-workload-monitoring-config

If the

user-workload-monitoring-config

ConfigMap

object does not exist:

Create the following YAML manifest. In this example the file is called

user-workload-monitoring-config.yaml

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |

Apply the configuration to create the
```
ConfigMap
```
object:
```
$ oc apply -f user-workload-monitoring-config.yaml
```
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.

2.4. Configuring the monitoring stack
Copia collegamento

In OpenShift Container Platform 4.11, you can configure the monitoring stack using the

cluster-monitoring-config

or

user-workload-monitoring-config

ConfigMap

objects. Config maps configure the Cluster Monitoring Operator (CMO), which in turn configures the components of the stack.

Prerequisites

If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role, or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Edit the

ConfigMap

object.

To configure core OpenShift Container Platform monitoring components:

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

project:

$ oc -n openshift-monitoring edit configmap cluster-monitoring-config

Add your configuration under

data/config.yaml

as a 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.

The following example

ConfigMap

object configures a persistent volume claim (PVC) for Prometheus. This relates to the Prometheus instance that monitors core OpenShift Container Platform components only:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:

1


      volumeClaimTemplate:
        spec:
          storageClassName: fast
          volumeMode: Filesystem
          resources:
            requests:
              storage: 40Gi

1: Defines the Prometheus component and the subsequent lines define its configuration.

To configure components that monitor user-defined projects:

Edit the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project:

$ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config

Add your configuration under

data/config.yaml

as a key-value pair

<component_name>: <component_configuration>

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    <component>:
      <configuration_for_the_component>

Substitute

<component>

and

<configuration_for_the_component>

accordingly.

The following example

ConfigMap

object configures a data retention period and minimum container resource requests for Prometheus. This relates to the Prometheus instance that monitors user-defined projects only:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    prometheus:

1


      retention: 24h

2


      resources:
        requests:
          cpu: 200m

3


          memory: 2Gi

4

1: Defines the Prometheus component and the subsequent lines define its configuration.
2: Configures a twenty-four hour data retention period for the Prometheus instance that monitors user-defined projects.
3: Defines a minimum resource request of 200 millicores for the Prometheus container.
4: Defines a minimum pod resource request of 2 GiB of memory for the Prometheus container.

Note

The Prometheus config map component is called

prometheusK8s

in the

cluster-monitoring-config

ConfigMap

object and

prometheus

in the

user-workload-monitoring-config

ConfigMap

object.

Save the file to apply the changes to the
```
ConfigMap
```
object. The pods affected by the new configuration are restarted automatically.
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.
Warning
When changes are saved to a monitoring config map, the pods and other resources in the related project might be redeployed. The running monitoring processes in that project might also be restarted.

2.5. Configurable monitoring components
Copia collegamento

This table shows the monitoring components you can configure and the keys used to specify the components in the

cluster-monitoring-config

and

user-workload-monitoring-config

ConfigMap

objects:

Expand

Table 2.1. Configurable monitoring components
Component	cluster-monitoring-config config map key	user-workload-monitoring-config config map key
Prometheus Operator	`prometheusOperator`	`prometheusOperator`
Prometheus	`prometheusK8s`	`prometheus`
Alertmanager	`alertmanagerMain`	`alertmanager`
kube-state-metrics	`kubeStateMetrics`
openshift-state-metrics	`openshiftStateMetrics`
Telemeter Client	`telemeterClient`
Prometheus Adapter	`k8sPrometheusAdapter`
Thanos Querier	`thanosQuerier`
Thanos Ruler		`thanosRuler`

Note

The Prometheus key is called

prometheusK8s

in the

cluster-monitoring-config

ConfigMap

object and

prometheus

in the

user-workload-monitoring-config

ConfigMap

object.

2.6. Using node selectors to move monitoring components
Copia collegamento

By using the

nodeSelector

constraint with labeled nodes, you can move any of the monitoring stack components to specific nodes. By doing so, you can control the placement and distribution of the monitoring components across a cluster.

By controlling placement and distribution of monitoring components, you can optimize system resource use, improve performance, and segregate workloads based on specific requirements or policies.

2.6.1. How node selectors work with other constraints
Copia collegamento

If you move monitoring components by using node selector constraints, be aware that other constraints to control pod scheduling might exist for a cluster:

Topology spread constraints might be in place to control pod placement.
Hard anti-affinity rules are in place for Prometheus, Thanos Querier, Alertmanager, and other monitoring components to ensure that multiple pods for these components are always spread across different nodes and are therefore always highly available.

When scheduling pods onto nodes, the pod scheduler tries to satisfy all existing constraints when determining pod placement. That is, all constraints compound when the pod scheduler determines which pods will be placed on which nodes.

Therefore, if you configure a node selector constraint but existing constraints cannot all be satisfied, the pod scheduler cannot match all constraints and will not schedule a pod for placement onto a node.

To maintain resilience and high availability for monitoring components, ensure that enough nodes are available and match all constraints when you configure a node selector constraint to move a component.

2.6.2. Moving monitoring components to different nodes
Copia collegamento

To specify the nodes in your cluster on which monitoring stack components will run, configure the

nodeSelector

constraint in the component’s

ConfigMap

object to match labels assigned to the nodes.

Note

You cannot add a node selector constraint directly to an existing scheduled pod.

Prerequisites

If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

If you have not done so yet, add a label to the nodes on which you want to run the monitoring components:
```
$ oc label nodes <node-name> <node-label>
```
Edit the
```
ConfigMap
```
object:
- To move a component that monitors core OpenShift Container Platform projects:
  1. Edit the
    
    cluster-monitoring-config
    
    ConfigMap
    
    object in the
    
    openshift-monitoring
    
    project:
    
    $ oc -n openshift-monitoring edit configmap cluster-monitoring-config
  2. Specify the node labels for 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>:
    1
    nodeSelector: <node-label-1>
    2
    <node-label-2>
    3
    <...>
    
    1
    Substitute <component> with the appropriate monitoring stack component name.
    2
    Substitute <node-label-1> with the label you added to the node.
    3
    Optional: Specify additional labels. If you specify additional labels, the pods for the component are only scheduled on the nodes that contain all of the specified labels.
    Note
    If monitoring components remain in a
    
    Pending
    
    state after configuring the
    
    nodeSelector
    
    constraint, check the pod events for errors relating to taints and tolerations.
- To move a component that monitors user-defined projects:
  1. Edit the
    
    user-workload-monitoring-config
    
    ConfigMap
    
    object in the
    
    openshift-user-workload-monitoring
    
    project:
    
    $ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config
  2. Specify the node labels for the
    
    nodeSelector
    
    constraint for the component under
    
    data/config.yaml
    
    :
    
    apiVersion: v1 kind: ConfigMap metadata: name: user-workload-monitoring-config namespace: openshift-user-workload-monitoring data: config.yaml: | <component>:
    1
    nodeSelector: <node-label-1>
    2
    <node-label-2>
    3
    <...>
    
    1
    Substitute <component> with the appropriate monitoring stack component name.
    2
    Substitute <node-label-1> with the label you added to the node.
    3
    Optional: Specify additional labels. If you specify additional labels, the pods for the component are only scheduled on the nodes that contain all of the specified labels.
    Note
    If monitoring components remain in a
    
    Pending
    
    state after configuring the
    
    nodeSelector
    
    constraint, check the pod events for errors relating to taints and tolerations.
Save the file to apply the changes. The components specified in the new configuration are moved to the new nodes automatically.
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.
Warning
When you save changes to a monitoring config map, the pods and other resources in the project might be redeployed. The running monitoring processes in that project might also restart.

2.7. Assigning tolerations to monitoring components
Copia collegamento

You can assign tolerations to any of the monitoring stack components to enable moving them to tainted nodes.

Prerequisites

If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role, or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Edit the

ConfigMap

object:

To assign tolerations to a component that monitors core OpenShift Container Platform projects:

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

project:

$ 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,

oc adm taint nodes node1 key1=value1:NoSchedule

adds a taint to

node1

with the key

key1

and the value

value1

. This prevents monitoring components from deploying pods on

node1

unless a toleration is configured for that taint. The following example configures the

alertmanagerMain

component to tolerate the example taint:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    alertmanagerMain:
      tolerations:
      - key: "key1"
        operator: "Equal"
        value: "value1"
        effect: "NoSchedule"

To assign tolerations to a component that monitors user-defined projects:

Edit the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project:

$ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config

Specify

tolerations

for the component:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    <component>:
      tolerations:
        <toleration_specification>

Substitute

<component>

and

<toleration_specification>

accordingly.

For example,

oc adm taint nodes node1 key1=value1:NoSchedule

adds a taint to

node1

with the key

key1

and the value

value1

. This prevents monitoring components from deploying pods on

node1

unless a toleration is configured for that taint. The following example configures the

thanosRuler

component to tolerate the example taint:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    thanosRuler:
      tolerations:
      - key: "key1"
        operator: "Equal"
        value: "value1"
        effect: "NoSchedule"

Save the file to apply the changes. The new component placement configuration is applied automatically.
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.
Warning
When changes are saved to a monitoring config map, the pods and other resources in the related project might be redeployed. The running monitoring processes in that project might also be restarted.

2.8. Setting the body size limit for metrics scraping
Copia collegamento

By default, no limit exists for the uncompressed body size for data returned from scraped metrics targets. You can set a body size limit to help avoid situations in which Prometheus consumes excessive amounts of memory when scraped targets return a response that contains a large amount of data. In addition, by setting a body size limit, you can reduce the impact that a malicious target might have on Prometheus and on the cluster as a whole.

After you set a value for

enforcedBodySizeLimit

, the alert

PrometheusScrapeBodySizeLimitHit

fires when at least one Prometheus scrape target replies with a response body larger than the configured value.

Note

If metrics data scraped from a target has an uncompressed body size exceeding the configured size limit, the scrape fails. Prometheus then considers this target to be down and sets its

up

metric value to

, which can trigger the

TargetDown

alert.

Prerequisites

You have access to the cluster as a user with the
```
cluster-admin
```
cluster role.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

namespace:

$ oc -n openshift-monitoring edit configmap cluster-monitoring-config

Add a value for
```
enforcedBodySizeLimit
```
to
```
data/config.yaml/prometheusK8s
```
to limit the body size that can be accepted per target scrape:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |-
    prometheusK8s:
      enforcedBodySizeLimit: 40MB 
```
1
1
Specify the maximum body size for scraped metrics targets. This enforcedBodySizeLimit example limits the uncompressed size per target scrape to 40 megabytes. Valid numeric values use the Prometheus data size format: B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), PB (petabytes), and EB (exabytes). The default value is 0, which specifies no limit. You can also set the value to automatic to calculate the limit automatically based on cluster capacity.
Save the file to apply the changes automatically.
Warning
When you save changes to a
cluster-monitoring-config
config map, the pods and other resources in the
openshift-monitoring
project might be redeployed. The running monitoring processes in that project might also restart.

2.9. Configuring a dedicated service monitor
Copia collegamento

You can configure OpenShift Container Platform core platform monitoring to use dedicated service monitors to collect metrics for the resource metrics pipeline.

When enabled, a dedicated service monitor exposes two additional metrics from the kubelet endpoint and sets the value of the

honorTimestamps

field to true.

By enabling a dedicated service monitor, you can improve the consistency of Prometheus Adapter-based CPU usage measurements used by, for example, the

oc adm top pod

command or the Horizontal Pod Autoscaler.

2.9.1. Enabling a dedicated service monitor
Copia collegamento

You can configure core platform monitoring to use a dedicated service monitor by configuring the

dedicatedServiceMonitors

key in the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

namespace.

Prerequisites

You have installed the OpenShift CLI (
```
oc
```
).
You have access to the cluster as a user with the
```
cluster-admin
```
cluster role.
You have created the
```
cluster-monitoring-config
```
```
ConfigMap
```
object.

Procedure

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

namespace:

$ oc -n openshift-monitoring edit configmap cluster-monitoring-config

Add an

enabled: true

key-value pair as shown in the following sample:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    k8sPrometheusAdapter:
      dedicatedServiceMonitors:
        enabled: true

1

1: Set the value of the enabled field to true to deploy a dedicated service monitor that exposes the kubelet /metrics/resource endpoint.

Save the file to apply the changes automatically.
Warning
When you save changes to a
cluster-monitoring-config
config map, the pods and other resources in the
openshift-monitoring
project might be redeployed. The running monitoring processes in that project might also restart.

2.10. Configuring persistent storage
Copia collegamento

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.

2.10.1. Persistent storage prerequisites
Copia collegamento

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.
Verify that you have a persistent volume (PV) ready to be claimed by the persistent volume claim (PVC), one PV for each replica. Because Prometheus and Alertmanager both have two replicas, you need four PVs to support the entire monitoring stack. The PVs are available from the Local Storage Operator, but not if you have enabled dynamically provisioned storage.
Use
```
Filesystem
```
as the storage type value for the
```
volumeMode
```
parameter when you configure the persistent volume.
Note
If you use a local volume for persistent storage, do not use a raw block volume, which is described with
volumeMode: Block
in the
LocalVolume
object. Prometheus cannot use raw block volumes.
Important
Prometheus does not support file systems that are not POSIX compliant. For example, some NFS file system implementations are not POSIX compliant. If you want to use an NFS file system for storage, verify with the vendor that their NFS implementation is fully POSIX compliant.

2.10.2. Configuring a local persistent volume claim
Copia collegamento

For monitoring components to use a persistent volume (PV), you must configure a persistent volume claim (PVC).

Prerequisites

If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role, or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Edit the

ConfigMap

object:

To configure a PVC for a component that monitors core OpenShift Container Platform projects:

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

project:

$ oc -n openshift-monitoring edit configmap cluster-monitoring-config

Add 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:
        spec:
          storageClassName: <storage_class>
          resources:
            requests:
              storage: <amount_of_storage>

See the Kubernetes documentation on PersistentVolumeClaims for information on how to specify

volumeClaimTemplate

.

The following example configures a PVC that claims local persistent storage for the Prometheus instance that monitors core OpenShift Container Platform components:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      volumeClaimTemplate:
        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

.

The following example configures a PVC that claims local persistent storage for Alertmanager:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    alertmanagerMain:
      volumeClaimTemplate:
        spec:
          storageClassName: local-storage
          resources:
            requests:
              storage: 10Gi

To configure a PVC for a component that monitors user-defined projects:

Edit the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project:

$ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config

Add your PVC configuration for the component under

data/config.yaml

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    <component>:
      volumeClaimTemplate:
        spec:
          storageClassName: <storage_class>
          resources:
            requests:
              storage: <amount_of_storage>

See the Kubernetes documentation on PersistentVolumeClaims for information on how to specify

volumeClaimTemplate

.

The following example configures a PVC that claims local persistent storage for the Prometheus instance that monitors user-defined projects:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    prometheus:
      volumeClaimTemplate:
        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

.

The following example configures a PVC that claims local persistent storage for Thanos Ruler:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    thanosRuler:
      volumeClaimTemplate:
        spec:
          storageClassName: local-storage
          resources:
            requests:
              storage: 10Gi

Note

Storage requirements for the

thanosRuler

component depend on the number of rules that are evaluated and how many samples each rule generates.

Save the file to apply the changes. The pods affected by the new configuration are restarted automatically and the new storage configuration is applied.
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.
Warning
When changes are saved to a monitoring config map, the pods and other resources in the related project might be redeployed. The running monitoring processes in that project might also be restarted.

2.10.3. Resizing a persistent storage volume
Copia collegamento

OpenShift Container Platform does not support resizing an existing persistent storage volume used by

StatefulSet

resources, even if the underlying

StorageClass

resource used supports persistent volume sizing. Therefore, even if you update the

storage

field for an existing persistent volume claim (PVC) with a larger size, this setting will not be propagated to the associated persistent volume (PV).

However, resizing a PV is still possible by using a manual process. If you want to resize a PV for a monitoring component such as Prometheus, Thanos Ruler, or Alertmanager, you can update the appropriate config map in which the component is configured. Then, patch the PVC, and delete and orphan the pods. Orphaning the pods recreates the

StatefulSet

resource immediately and automatically updates the size of the volumes mounted in the pods with the new PVC settings. No service disruption occurs during this process.

Prerequisites

You have installed the OpenShift CLI (
```
oc
```
).
If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
- You have configured at least one PVC for core OpenShift Container Platform monitoring components.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role, or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
- You have configured at least one PVC for components that monitor user-defined projects.

Procedure

Edit the

ConfigMap

object:

To resize a PVC for a component that monitors core OpenShift Container Platform projects:

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

project:

$ oc -n openshift-monitoring edit configmap cluster-monitoring-config

Add a new storage size for the 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>:

1


      volumeClaimTemplate:
        spec:
          storageClassName: <storage_class>

2


          resources:
            requests:
              storage: <amount_of_storage>

3

1: Specify the core monitoring component.
2: Specify the storage class.
3: Specify the new size for the storage volume.

The following example configures a PVC that sets the local persistent storage to 100 gigabytes for the Prometheus instance that monitors core OpenShift Container Platform components:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      volumeClaimTemplate:
        spec:
          storageClassName: local-storage
          resources:
            requests:
              storage: 100Gi

The following example configures a PVC that sets the local persistent storage for Alertmanager to 40 gigabytes:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    alertmanagerMain:
      volumeClaimTemplate:
        spec:
          storageClassName: local-storage
          resources:
            requests:
              storage: 40Gi

To resize a PVC for a component that monitors user-defined projects:

Note

You can resize the volumes for the Thanos Ruler and Prometheus instances that monitor user-defined projects.

Edit the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project:

$ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config

Update the PVC configuration for the monitoring component under

data/config.yaml

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    <component>:

1


      volumeClaimTemplate:
        spec:
          storageClassName: <storage_class>

2


          resources:
            requests:
              storage: <amount_of_storage>

3

1: Specify the core monitoring component.
2: Specify the storage class.
3: Specify the new size for the storage volume.

The following example configures the PVC size to 100 gigabytes for the Prometheus instance that monitors user-defined projects:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    prometheus:
      volumeClaimTemplate:
        spec:
          storageClassName: local-storage
          resources:
            requests:
              storage: 100Gi

The following example sets the PVC size to 20 gigabytes for Thanos Ruler:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    thanosRuler:
      volumeClaimTemplate:
        spec:
          storageClassName: local-storage
          resources:
            requests:
              storage: 20Gi

Note

Storage requirements for the

thanosRuler

component depend on the number of rules that are evaluated and how many samples each rule generates.

Save the file to apply the changes. The pods affected by the new configuration restart automatically.
Warning
When you save changes to a monitoring config map, the pods and other resources in the related project might be redeployed. The monitoring processes running in that project might also be restarted.

Manually patch every PVC with the updated storage request. The following example resizes the storage size for the Prometheus component in the

openshift-monitoring

namespace to 100Gi:

$ for p in $(oc -n openshift-monitoring get pvc -l app.kubernetes.io/name=prometheus -o jsonpath='{range .items[*]}{.metadata.name} {end}'); do \
  oc -n openshift-monitoring patch pvc/${p} --patch '{"spec": {"resources": {"requests": {"storage":"100Gi"}}}}'; \
  done

Delete the underlying StatefulSet with the

--cascade=orphan

parameter:

$ oc delete statefulset -l app.kubernetes.io/name=prometheus --cascade=orphan

2.10.4. Modifying the retention time and size for Prometheus metrics data
Copia collegamento

By default, Prometheus automatically retains metrics data for 15 days. You can modify the retention time to change how soon data is deleted by specifying a time value in the

retention

field. You can also configure the maximum amount of disk space the retained metrics data uses by specifying a size value in the

retentionSize

field. If the data reaches this size limit, Prometheus deletes the oldest data first until the disk space used is again below the limit.

Note the following behaviors of these data retention settings:

The size-based retention policy applies to all data block directories in the
```
/prometheus
```
directory, including persistent blocks, write-ahead log (WAL) data, and m-mapped chunks.
Data in the
```
/wal
```
and
```
/head_chunks
```
directories counts toward the retention size limit, but Prometheus never purges data from these directories based on size- or time-based retention policies. Thus, if you set a retention size limit lower than the maximum size set for the
```
/wal
```
and
```
/head_chunks
```
directories, you have configured the system not to retain any data blocks in the
```
/prometheus
```
data directories.
The size-based retention policy is applied only when Prometheus cuts a new data block, which occurs every two hours after the WAL contains at least three hours of data.
If you do not explicitly define values for either
```
retention
```
or
```
retentionSize
```
, retention time defaults to 15 days, and retention size is not set.
If you define values for both
```
retention
```
and
```
retentionSize
```
, both values apply. If any data blocks exceed the defined retention time or the defined size limit, Prometheus purges these data blocks.
If you define a value for
```
retentionSize
```
and do not define
```
retention
```
, only the
```
retentionSize
```
value applies.
If you do not define a value for
```
retentionSize
```
and only define a value for
```
retention
```
, only the
```
retention
```
value applies.

Prerequisites

If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- A cluster administrator has enabled monitoring for user-defined projects.
- You have access to the cluster as a user with the
  cluster-admin
  cluster role, or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
You have installed the OpenShift CLI (
```
oc
```
).

Warning

Saving changes to a monitoring config map might restart monitoring processes and redeploy the pods and other resources in the related project. The running monitoring processes in that project might also restart.

Procedure

Edit the
```
ConfigMap
```
object:
- To modify the retention time and size for the Prometheus instance that monitors core OpenShift Container Platform projects:
  1. Edit the
    
    cluster-monitoring-config
    
    ConfigMap
    
    object in the
    
    openshift-monitoring
    
    project:
    
    $ oc -n openshift-monitoring edit configmap cluster-monitoring-config
  2. Add the retention time and size configuration under
    
    data/config.yaml
    
    :
    
    apiVersion: v1 kind: ConfigMap metadata: name: cluster-monitoring-config namespace: openshift-monitoring data: config.yaml: | prometheusK8s: retention: <time_specification>
    1
    retentionSize: <size_specification>
    2
    
    1
    The retention time: a number directly followed by ms (milliseconds), s (seconds), m (minutes), h (hours), d (days), w (weeks), or y (years). You can also combine time values for specific times, such as 1h30m15s.
    2
    The retention size: a number directly followed by B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), PB (petabytes), and EB (exabytes).
    The following example sets the retention time to 24 hours and the retention size to 10 gigabytes for the Prometheus instance that monitors core OpenShift Container Platform components:
    
    apiVersion: v1 kind: ConfigMap metadata: name: cluster-monitoring-config namespace: openshift-monitoring data: config.yaml: | prometheusK8s: retention: 24h retentionSize: 10GB
- To modify the retention time and size for the Prometheus instance that monitors user-defined projects:
  1. Edit the
    
    user-workload-monitoring-config
    
    ConfigMap
    
    object in the
    
    openshift-user-workload-monitoring
    
    project:
    
    $ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config
  2. Add the retention time and size configuration under
    
    data/config.yaml
    
    :
    
    apiVersion: v1 kind: ConfigMap metadata: name: user-workload-monitoring-config namespace: openshift-user-workload-monitoring data: config.yaml: | prometheus: retention: <time_specification>
    1
    retentionSize: <size_specification>
    2
    
    1
    The retention time: a number directly followed by ms (milliseconds), s (seconds), m (minutes), h (hours), d (days), w (weeks), or y (years). You can also combine time values for specific times, such as 1h30m15s.
    2
    The retention size: a number directly followed by B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes), PB (petabytes), or EB (exabytes).
    The following example sets the retention time to 24 hours and the retention size to 10 gigabytes for the Prometheus instance that monitors user-defined projects:
    
    apiVersion: v1 kind: ConfigMap metadata: name: user-workload-monitoring-config namespace: openshift-user-workload-monitoring data: config.yaml: | prometheus: retention: 24h retentionSize: 10GB
Save the file to apply the changes. The pods affected by the new configuration restart automatically.

2.10.5. Modifying the retention time for Thanos Ruler metrics data
Copia collegamento

By default, for user-defined projects, Thanos Ruler automatically retains metrics data for 24 hours. You can modify the retention time to change how long this data is retained by specifying a time value in the

user-workload-monitoring-config

config map in the

openshift-user-workload-monitoring

namespace.

Prerequisites

You have installed the OpenShift CLI (
```
oc
```
).
A cluster administrator has enabled monitoring for user-defined projects.
You have access to the cluster as a user with the
```
cluster-admin
```
cluster role or as a user with the
```
user-workload-monitoring-config-edit
```
role in the
```
openshift-user-workload-monitoring
```
project.

You have created the

user-workload-monitoring-config

ConfigMap

object.

Warning

Saving changes to a monitoring config map might restart monitoring processes and redeploy the pods and other resources in the related project. The running monitoring processes in that project might also restart.

Procedure

Edit the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project:

$ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config

Add the retention time configuration under

data/config.yaml

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    thanosRuler:
      retention: <time_specification>

1

1: Specify the retention time in the following format: a number directly followed by ms (milliseconds), s (seconds), m (minutes), h (hours), d (days), w (weeks), or y (years). You can also combine time values for specific times, such as 1h30m15s. The default is 24h.

The following example sets the retention time to 10 days for Thanos Ruler data:

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    thanosRuler:
      retention: 10d

Save the file to apply the changes. The pods affected by the new configuration automatically restart.

2.11. Configuring remote write storage
Copia collegamento

You can configure remote write storage to enable Prometheus to send ingested metrics to remote systems for long-term storage. Doing so has no impact on how or for how long Prometheus stores metrics.

Prerequisites

If you are configuring core OpenShift Container Platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.
You have installed the OpenShift CLI (
```
oc
```
).
You have set up a remote write compatible endpoint (such as Thanos) and know the endpoint URL. See the Prometheus remote endpoints and storage documentation for information about endpoints that are compatible with the remote write feature.
You have set up authentication credentials in a
```
Secret
```
object for the remote write endpoint. You must create the secret in the same namespace as the Prometheus object for which you configure remote write: the
```
openshift-monitoring
```
namespace for default platform monitoring or the
```
openshift-user-workload-monitoring
```
namespace for user workload monitoring.
Important
To reduce security risks, use HTTPS and authentication to send metrics to an endpoint.

Procedure

Follow these steps to configure remote write for default platform monitoring in the

cluster-monitoring-config

config map in the

openshift-monitoring

namespace.

Note

If you configure remote write for the Prometheus instance that monitors user-defined projects, make similar edits to the

user-workload-monitoring-config

config map in the

openshift-user-workload-monitoring

namespace. Note that the Prometheus config map component is called

prometheus

in the

user-workload-monitoring-config

ConfigMap

object and not

prometheusK8s

, as it is in the

cluster-monitoring-config

ConfigMap

object.

Edit the

cluster-monitoring-config

ConfigMap

object in the

openshift-monitoring

project:

$ oc -n openshift-monitoring edit configmap cluster-monitoring-config

Add a

remoteWrite:

section under

data/config.yaml/prometheusK8s

.

Add an endpoint URL and authentication credentials in this section:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com" 
```
1
```
        <endpoint_authentication_credentials> 
```
2
1
The URL of the remote write endpoint.
2
The authentication method and credentials for the endpoint. Currently supported authentication methods are AWS Signature Version 4, authentication using HTTP in an Authorization request header, Basic authentication, OAuth 2.0, and TLS client. See Supported remote write authentication settings for sample configurations of supported authentication methods.

Add write relabel configuration values after the authentication credentials:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com"
        <endpoint_authentication_credentials>
        <write_relabel_configs>

1

1: The write relabel configuration settings.

For

<write_relabel_configs>

substitute a list of write relabel configurations for metrics that you want to send to the remote endpoint.

The following sample shows how to forward a single metric called

my_metric

:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com"
        writeRelabelConfigs:
        - sourceLabels: [__name__]
          regex: 'my_metric'
          action: keep

See the Prometheus relabel_config documentation for information about write relabel configuration options.

Save the file to apply the changes to the
```
ConfigMap
```
object. The pods affected by the new configuration restart automatically.
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.
Warning
Saving changes to a monitoring
ConfigMap
object might redeploy the pods and other resources in the related project. Saving changes might also restart the running monitoring processes in that project.

2.11.1. Supported remote write authentication settings
Copia collegamento

You can use different methods to authenticate with a remote write endpoint. Currently supported authentication methods are AWS Signature Version 4, Basic authentication, authentication using HTTP in an

Authorization

request header, OAuth 2.0, and TLS client. The following table provides details about supported authentication methods for use with remote write.

Expand

Authentication method	Config map field	Description
AWS Signature Version 4	`sigv4`	This method uses AWS Signature Version 4 authentication to sign requests. You cannot use this method simultaneously with authorization, OAuth 2.0, or Basic authentication.
Basic authentication	`basicAuth`	Basic authentication sets the authorization header on every remote write request with the configured username and password.
authorization	`authorization`	Authorization sets the `Authorization` header on every remote write request using the configured token.
OAuth 2.0	`oauth2`	An OAuth 2.0 configuration uses the client credentials grant type. Prometheus fetches an access token from `tokenUrl` with the specified client ID and client secret to access the remote write endpoint. You cannot use this method simultaneously with authorization, AWS Signature Version 4, or Basic authentication.
TLS client	`tlsConfig`	A TLS client configuration specifies the CA certificate, the client certificate, and the client key file information used to authenticate with the remote write endpoint server using TLS. The sample configuration assumes that you have already created a CA certificate file, a client certificate file, and a client key file.

2.11.1.1. Config map location for authentication settings
Copia collegamento

The following shows the location of the authentication configuration in the

ConfigMap

object for default platform monitoring.

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com"

1


        <endpoint_authentication_details>

2

1: The URL of the remote write endpoint.
2: The required configuration details for the authentication method for the endpoint. Currently supported authentication methods are Amazon Web Services (AWS) Signature Version 4, authentication using HTTP in an Authorization request header, Basic authentication, OAuth 2.0, and TLS client.

Note

If you configure remote write for the Prometheus instance that monitors user-defined projects, edit the

user-workload-monitoring-config

config map in the

openshift-user-workload-monitoring

namespace. Note that the Prometheus config map component is called

prometheus

in the

user-workload-monitoring-config

ConfigMap

object and not

prometheusK8s

, as it is in the

cluster-monitoring-config

ConfigMap

object.

2.11.1.2. Example remote write authentication settings
Copia collegamento

The following samples show different authentication settings you can use to connect to a remote write endpoint. Each sample also shows how to configure a corresponding

Secret

object that contains authentication credentials and other relevant settings. Each sample configures authentication for use with default platform monitoring in the

openshift-monitoring

namespace.

Sample YAML for AWS Signature Version 4 authentication

The following shows the settings for a

sigv4

secret named

sigv4-credentials

in the

openshift-monitoring

namespace.

apiVersion: v1
kind: Secret
metadata:
  name: sigv4-credentials
  namespace: openshift-monitoring
stringData:
  accessKey: <AWS_access_key>

1


  secretKey: <AWS_secret_key>

2


type: Opaque

1: The AWS API access key.
2: The AWS API secret key.

The following shows sample AWS Signature Version 4 remote write authentication settings that use a

Secret

object named

sigv4-credentials

in the

openshift-monitoring

namespace:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://authorization.example.com/api/write"
        sigv4:
          region: <AWS_region>

1


          accessKey:
            name: sigv4-credentials

2


            key: accessKey

3


          secretKey:
            name: sigv4-credentials

4


            key: secretKey

5


          profile: <AWS_profile_name>

6


          roleArn: <AWS_role_arn>

7

1: The AWS region.
2 4: The name of the Secret object containing the AWS API access credentials.
3: The key that contains the AWS API access key in the specified Secret object.
5: The key that contains the AWS API secret key in the specified Secret object.
6: The name of the AWS profile that is being used to authenticate.
7: The unique identifier for the Amazon Resource Name (ARN) assigned to your role.

Sample YAML for Basic authentication

The following shows sample Basic authentication settings for a

Secret

object named

rw-basic-auth

in the

openshift-monitoring

namespace:

apiVersion: v1
kind: Secret
metadata:
  name: rw-basic-auth
  namespace: openshift-monitoring
stringData:
  user: <basic_username>

1


  password: <basic_password>

2


type: Opaque

1: The username.
2: The password.

The following sample shows a

basicAuth

remote write configuration that uses a

Secret

object named

rw-basic-auth

in the

openshift-monitoring

namespace. It assumes that you have already set up authentication credentials for the endpoint.

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://basicauth.example.com/api/write"
        basicAuth:
          username:
            name: rw-basic-auth

1


            key: user

2


          password:
            name: rw-basic-auth

3


            key: password

4

1 3: The name of the Secret object that contains the authentication credentials.
2: The key that contains the username in the specified Secret object.
4: The key that contains the password in the specified Secret object.

Sample YAML for authentication with a bearer token using a Secret Object

The following shows bearer token settings for a

Secret

object named

rw-bearer-auth

in the

openshift-monitoring

namespace:

apiVersion: v1
kind: Secret
metadata:
  name: rw-bearer-auth
  namespace: openshift-monitoring
stringData:
  token: <authentication_token>

1


type: Opaque

1: The authentication token.

The following shows sample bearer token config map settings that use a

Secret

object named

rw-bearer-auth

in the

openshift-monitoring

namespace:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    enableUserWorkload: true
    prometheusK8s:
      remoteWrite:
      - url: "https://authorization.example.com/api/write"
        authorization:
          type: Bearer

1


          credentials:
            name: rw-bearer-auth

2


            key: token

3

1: The authentication type of the request. The default value is Bearer.
2: The name of the Secret object that contains the authentication credentials.
3: The key that contains the authentication token in the specified Secret object.

Sample YAML for OAuth 2.0 authentication

The following shows sample OAuth 2.0 settings for a

Secret

object named

oauth2-credentials

in the

openshift-monitoring

namespace:

apiVersion: v1
kind: Secret
metadata:
  name: oauth2-credentials
  namespace: openshift-monitoring
stringData:
  id: <oauth2_id>

1


  secret: <oauth2_secret>

2


  token: <oauth2_authentication_token>

3


type: Opaque

1: The Oauth 2.0 ID.
2: The OAuth 2.0 secret.
3: The OAuth 2.0 token.

The following shows an

oauth2

remote write authentication sample configuration that uses a

Secret

object named

oauth2-credentials

in the

openshift-monitoring

namespace:

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://test.example.com/api/write"
        oauth2:
          clientId:
            secret:
              name: oauth2-credentials

1


              key: id

2


          clientSecret:
            name: oauth2-credentials

3


            key: secret

4


          tokenUrl: https://example.com/oauth2/token

5


          scopes:

6


          - <scope_1>
          - <scope_2>
          endpointParams:

7


            param1: <parameter_1>
            param2: <parameter_2>

1 3: The name of the corresponding Secret object. Note that ClientId can alternatively refer to a ConfigMap object, although clientSecret must refer to a Secret object.
2 4: The key that contains the OAuth 2.0 credentials in the specified Secret object.
5: The URL used to fetch a token with the specified clientId and clientSecret.
6: The OAuth 2.0 scopes for the authorization request. These scopes limit what data the tokens can access.
7: The OAuth 2.0 authorization request parameters required for the authorization server.

Sample YAML for TLS client authentication

The following shows sample TLS client settings for a

tls

Secret

object named

mtls-bundle

in the

openshift-monitoring

namespace.

apiVersion: v1
kind: Secret
metadata:
  name: mtls-bundle
  namespace: openshift-monitoring
data:
  ca.crt: <ca_cert>

1


  client.crt: <client_cert>

2


  client.key: <client_key>

3


type: tls

1: The CA certificate in the Prometheus container with which to validate the server certificate.
2: The client certificate for authentication with the server.
3: The client key.

The following sample shows a

tlsConfig

remote write authentication configuration that uses a TLS

Secret

object named

mtls-bundle

.

apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com"
        tlsConfig:
          ca:
            secret:
              name: mtls-bundle

1


              key: ca.crt

2


          cert:
            secret:
              name: mtls-bundle

3


              key: client.crt

4


          keySecret:
            name: mtls-bundle

5


            key: client.key

6

1 3 5: The name of the corresponding Secret object that contains the TLS authentication credentials. Note that ca and cert can alternatively refer to a ConfigMap object, though keySecret must refer to a Secret object.
2: The key in the specified Secret object that contains the CA certificate for the endpoint.
4: The key in the specified Secret object that contains the client certificate for the endpoint.
6: The key in the specified Secret object that contains the client key secret.

Additional resources

See Setting up remote write compatible endpoints for steps to create a remote write compatible endpoint (such as Thanos).
See Tuning remote write settings for information about how to optimize remote write settings for different use cases.
See Understanding secrets for steps to create and configure
```
Secret
```
objects in OpenShift Container Platform.
See the Prometheus REST API reference for remote write for information about additional optional fields.

2.12. Adding cluster ID labels to metrics
Copia collegamento

If you manage multiple OpenShift Container Platform clusters and use the remote write feature to send metrics data from these clusters to an external storage location, you can add cluster ID labels to identify the metrics data coming from different clusters. You can then query these labels to identify the source cluster for a metric and distinguish that data from similar metrics data sent by other clusters.

This way, if you manage many clusters for multiple customers and send metrics data to a single centralized storage system, you can use cluster ID labels to query metrics for a particular cluster or customer.

Creating and using cluster ID labels involves three general steps:

Configuring the write relabel settings for remote write storage.
Adding cluster ID labels to the metrics.
Querying these labels to identify the source cluster or customer for a metric.

2.12.1. Creating cluster ID labels for metrics
Copia collegamento

You can create cluster ID labels for metrics for default platform monitoring and for user workload monitoring.

For default platform monitoring, you add cluster ID labels for metrics in the

write_relabel

settings for remote write storage in the

cluster-monitoring-config

config map in the

openshift-monitoring

namespace.

For user workload monitoring, you edit the settings in the

user-workload-monitoring-config

config map in the

openshift-user-workload-monitoring

namespace.

Note

When Prometheus scrapes user workload targets that expose a

namespace

label, the system stores this label as

exported_namespace

. This behavior ensures that the final namespace label value is equal to the namespace of the target pod. You cannot override this default configuration by setting the value of the

honorLabels

field to

true

for

PodMonitor

or

ServiceMonitor

objects.

Prerequisites

You have installed the OpenShift CLI (
```
oc
```
).
You have configured remote write storage.
If you are configuring default platform monitoring components:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role.
- You have created the
  cluster-monitoring-config
  ConfigMap
  object.
If you are configuring components that monitor user-defined projects:
- You have access to the cluster as a user with the
  cluster-admin
  cluster role or as a user with the
  user-workload-monitoring-config-edit
  role in the
  openshift-user-workload-monitoring
  project.
- You have created the
  user-workload-monitoring-config
  ConfigMap
  object.

Procedure

Edit the
```
cluster-monitoring-config
```
```
ConfigMap
```
object in the
```
openshift-monitoring
```
project:
```
$ oc -n openshift-monitoring edit configmap cluster-monitoring-config
```
Note
If you configure cluster ID labels for metrics for the Prometheus instance that monitors user-defined projects, edit the
user-workload-monitoring-config
config map in the
openshift-user-workload-monitoring
namespace. Note that the Prometheus component is called
prometheus
in this config map and not
prometheusK8s
, which is the name used in the
cluster-monitoring-config
config map.
In the
```
writeRelabelConfigs:
```
section under
```
data/config.yaml/prometheusK8s/remoteWrite
```
, add cluster ID relabel configuration values:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com"
        <endpoint_authentication_credentials>
        writeRelabelConfigs: 
```
1
```
          - <relabel_config> 
```
2
1
Add a list of write relabel configurations for metrics that you want to send to the remote endpoint.
2
Substitute the label configuration for the metrics sent to the remote write endpoint.
The following sample shows how to forward a metric with the cluster ID label
```
cluster_id
```
in default platform monitoring:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-monitoring-config
  namespace: openshift-monitoring
data:
  config.yaml: |
    prometheusK8s:
      remoteWrite:
      - url: "https://remote-write-endpoint.example.com"
        writeRelabelConfigs:
        - sourceLabels:
          - __tmp_openshift_cluster_id__ 
```
1
```
          targetLabel: cluster_id 
```
2
```
          action: replace 
```
3
1
The system initially applies a temporary cluster ID source label named __tmp_openshift_cluster_id__. This temporary label gets replaced by the cluster ID label name that you specify.
2
Specify the name of the cluster ID label for metrics sent to remote write storage. If you use a label name that already exists for a metric, that value is overwritten with the name of this cluster ID label. For the label name, do not use __tmp_openshift_cluster_id__. The final relabeling step removes labels that use this name.
3
The replace write relabel action replaces the temporary label with the target label for outgoing metrics. This action is the default and is applied if no action is specified.
Save the file to apply the changes to the
```
ConfigMap
```
object. The pods affected by the updated configuration automatically restart.
Warning
Saving changes to a monitoring
ConfigMap
object might redeploy the pods and other resources in the related project. Saving changes might also restart the running monitoring processes in that project.

2.13. Controlling the impact of unbound metrics attributes in user-defined projects
Copia collegamento

Developers can create labels to define attributes for metrics in the form of key-value pairs. The number of potential key-value pairs corresponds to the number of possible values for an attribute. An attribute that has an unlimited number of potential values is called an unbound attribute. For example, a

customer_id

attribute is unbound because it has an infinite number of possible values.

Every assigned key-value pair has a unique time series. Using many unbound attributes in labels can create exponentially more time series, which can impact Prometheus performance and available disk space.

Cluster administrators can use the following measures to control the impact of unbound metrics attributes in user-defined projects:

Limit the number of samples that can be accepted per target scrape in user-defined projects
Limit the number of scraped labels, the length of label names, and the length of label values.
Create alerts that fire when a scrape sample threshold is reached or when the target cannot be scraped

Note

To prevent issues caused by adding many unbound attributes, limit the number of scrape samples, label names, and unbound attributes you define for metrics. Also reduce the number of potential key-value pair combinations by using attributes that are bound to a limited set of possible values.

2.13.1. Setting scrape sample and label limits for user-defined projects
Copia collegamento

You can limit the number of samples that can be accepted per target scrape in user-defined projects. You can also limit the number of scraped labels, the length of label names, and the length of label values.

Warning

If you set sample or label limits, no further sample data is ingested for that target scrape after the limit is reached.

Prerequisites

You have access to the cluster as a user with the
```
cluster-admin
```
cluster role, or as a user with the
```
user-workload-monitoring-config-edit
```
role in the
```
openshift-user-workload-monitoring
```
project.
You have enabled monitoring for user-defined projects.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Edit the

user-workload-monitoring-config

ConfigMap

object in the

openshift-user-workload-monitoring

project:

$ oc -n openshift-user-workload-monitoring edit configmap user-workload-monitoring-config

Add the
```
enforcedSampleLimit
```
configuration to
```
data/config.yaml
```
to limit the number of samples that can be accepted per target scrape in user-defined projects:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    prometheus:
      enforcedSampleLimit: 50000 
```
1
1
A value is required if this parameter is specified. This enforcedSampleLimit example limits the number of samples that can be accepted per target scrape in user-defined projects to 50,000.
Add the
```
enforcedLabelLimit
```
,
```
enforcedLabelNameLengthLimit
```
, and
```
enforcedLabelValueLengthLimit
```
configurations to
```
data/config.yaml
```
to limit the number of scraped labels, the length of label names, and the length of label values in user-defined projects:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: user-workload-monitoring-config
  namespace: openshift-user-workload-monitoring
data:
  config.yaml: |
    prometheus:
      enforcedLabelLimit: 500 
```
1
```
      enforcedLabelNameLengthLimit: 50 
```
2
```
      enforcedLabelValueLengthLimit: 600 
```
3
1
Specifies the maximum number of labels per scrape. The default value is 0, which specifies no limit.
2
Specifies the maximum length in characters of a label name. The default value is 0, which specifies no limit.
3
Specifies the maximum length in characters of a label value. The default value is 0, which specifies no limit.
Save the file to apply the changes. The limits are applied automatically.
Note
Configurations applied to the
user-workload-monitoring-config
ConfigMap
object are not activated unless a cluster administrator has enabled monitoring for user-defined projects.
Warning
When changes are saved to the
user-workload-monitoring-config
ConfigMap
object, the pods and other resources in the
openshift-user-workload-monitoring
project might be redeployed. The running monitoring processes in that project might also be restarted.

2.13.2. Creating scrape sample alerts
Copia collegamento

You can create alerts that notify you when:

The target cannot be scraped or is not available for the specified
```
for
```
duration
A scrape sample threshold is reached or is exceeded for the specified
```
for
```
duration

Prerequisites

You have access to the cluster as a user with the
```
cluster-admin
```
cluster role, or as a user with the
```
user-workload-monitoring-config-edit
```
role in the
```
openshift-user-workload-monitoring
```
project.
You have enabled monitoring for user-defined projects.

You have created the

user-workload-monitoring-config

ConfigMap

object.

You have limited the number of samples that can be accepted per target scrape in user-defined projects, by using
```
enforcedSampleLimit
```
.
You have installed the OpenShift CLI (
```
oc
```
).

Procedure

Create a YAML file with alerts that inform you when the targets are down and when the enforced sample limit is approaching. The file in this example is called
```
monitoring-stack-alerts.yaml
```
:
```
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  labels:
    prometheus: k8s
    role: alert-rules
  name: monitoring-stack-alerts 
```
1
```
  namespace: ns1 
```
2
```
spec:
  groups:
  - name: general.rules
    rules:
    - alert: TargetDown 
```
3
```
      annotations:
        message: '{{ printf "%.4g" $value }}% of the {{ $labels.job }}/{{ $labels.service
          }} targets in {{ $labels.namespace }} namespace are down.' 
```
4
```
      expr: 100 * (count(up == 0) BY (job, namespace, service) / count(up) BY (job,
        namespace, service)) > 10
      for: 10m 
```
5
```
      labels:
        severity: warning 
```
6
```
    - alert: ApproachingEnforcedSamplesLimit 
```
7
```
      annotations:
        message: '{{ $labels.container }} container of the {{ $labels.pod }} pod in the {{ $labels.namespace }} namespace consumes {{ $value | humanizePercentage }} of the samples limit budget.' 
```
8
```
      expr: scrape_samples_scraped/50000 > 0.8 
```
9
```
      for: 10m 
```
10
```
      labels:
        severity: warning 
```
11
1
Defines the name of the alerting rule.
2
Specifies the user-defined project where the alerting rule will be deployed.
3
The TargetDown alert will fire if the target cannot be scraped or is not available for the for duration.
4
The message that will be output when the TargetDown alert fires.
5
The conditions for the TargetDown alert must be true for this duration before the alert is fired.
6
Defines the severity for the TargetDown alert.
7
The ApproachingEnforcedSamplesLimit alert will fire when the defined scrape sample threshold is reached or exceeded for the specified for duration.
8
The message that will be output when the ApproachingEnforcedSamplesLimit alert fires.
9
The threshold for the ApproachingEnforcedSamplesLimit alert. In this example the alert will fire when the number of samples per target scrape has exceeded 80% of the enforced sample limit of 50000. The for duration must also have passed before the alert will fire. The <number> in the expression scrape_samples_scraped/<number> > <threshold> must match the enforcedSampleLimit value defined in the user-workload-monitoring-config ConfigMap object.
10
The conditions for the ApproachingEnforcedSamplesLimit alert must be true for this duration before the alert is fired.
11
Defines the severity for the ApproachingEnforcedSamplesLimit alert.
Apply the configuration to the user-defined project:
```
$ oc apply -f monitoring-stack-alerts.yaml
```

Questo contenuto non è disponibile nella lingua selezionata.

2.1. PrerequisitesCopia collegamentoCollegamento copiato negli appunti!

2.2. Maintenance and support for monitoringCopia collegamentoCollegamento copiato negli appunti!

2.2.1. Support considerations for monitoringCopia collegamentoCollegamento copiato negli appunti!

2.2.2. Support policy for monitoring OperatorsCopia collegamentoCollegamento copiato negli appunti!

2.3. Preparing to configure the monitoring stackCopia collegamentoCollegamento copiato negli appunti!

2.3.1. Creating a cluster monitoring config mapCopia collegamentoCollegamento copiato negli appunti!

2.3.2. Creating a user-defined workload monitoring config mapCopia collegamentoCollegamento copiato negli appunti!

2.4. Configuring the monitoring stackCopia collegamentoCollegamento copiato negli appunti!

2.5. Configurable monitoring componentsCopia collegamentoCollegamento copiato negli appunti!

2.6. Using node selectors to move monitoring componentsCopia collegamentoCollegamento copiato negli appunti!

2.6.1. How node selectors work with other constraintsCopia collegamentoCollegamento copiato negli appunti!

2.6.2. Moving monitoring components to different nodesCopia collegamentoCollegamento copiato negli appunti!

2.7. Assigning tolerations to monitoring componentsCopia collegamentoCollegamento copiato negli appunti!

2.8. Setting the body size limit for metrics scrapingCopia collegamentoCollegamento copiato negli appunti!

2.9. Configuring a dedicated service monitorCopia collegamentoCollegamento copiato negli appunti!

2.9.1. Enabling a dedicated service monitorCopia collegamentoCollegamento copiato negli appunti!

2.10. Configuring persistent storageCopia collegamentoCollegamento copiato negli appunti!

2.10.1. Persistent storage prerequisitesCopia collegamentoCollegamento copiato negli appunti!

2.10.2. Configuring a local persistent volume claimCopia collegamentoCollegamento copiato negli appunti!

2.10.3. Resizing a persistent storage volumeCopia collegamentoCollegamento copiato negli appunti!

2.10.4. Modifying the retention time and size for Prometheus metrics dataCopia collegamentoCollegamento copiato negli appunti!

2.10.5. Modifying the retention time for Thanos Ruler metrics dataCopia collegamentoCollegamento copiato negli appunti!

2.11. Configuring remote write storageCopia collegamentoCollegamento copiato negli appunti!

2.11.1. Supported remote write authentication settingsCopia collegamentoCollegamento copiato negli appunti!

2.11.1.1. Config map location for authentication settingsCopia collegamentoCollegamento copiato negli appunti!

2.11.1.2. Example remote write authentication settingsCopia collegamentoCollegamento copiato negli appunti!

2.12. Adding cluster ID labels to metricsCopia collegamentoCollegamento copiato negli appunti!

2.12.1. Creating cluster ID labels for metricsCopia collegamentoCollegamento copiato negli appunti!

2.13. Controlling the impact of unbound metrics attributes in user-defined projectsCopia collegamentoCollegamento copiato negli appunti!

2.13.1. Setting scrape sample and label limits for user-defined projectsCopia collegamentoCollegamento copiato negli appunti!

2.13.2. Creating scrape sample alertsCopia collegamentoCollegamento copiato negli appunti!

Formazione

Prova, acquista e vendi

Community

Informazioni sulla documentazione di Red Hat

Rendiamo l’open source più inclusivo

Informazioni su Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

2.1. Prerequisites
Copia collegamento

2.2. Maintenance and support for monitoring
Copia collegamento

2.2.1. Support considerations for monitoring
Copia collegamento

2.2.2. Support policy for monitoring Operators
Copia collegamento

2.3. Preparing to configure the monitoring stack
Copia collegamento

2.3.1. Creating a cluster monitoring config map
Copia collegamento

2.3.2. Creating a user-defined workload monitoring config map
Copia collegamento

2.4. Configuring the monitoring stack
Copia collegamento

2.5. Configurable monitoring components
Copia collegamento

2.6. Using node selectors to move monitoring components
Copia collegamento

2.6.1. How node selectors work with other constraints
Copia collegamento

2.6.2. Moving monitoring components to different nodes
Copia collegamento

2.7. Assigning tolerations to monitoring components
Copia collegamento

2.8. Setting the body size limit for metrics scraping
Copia collegamento

2.9. Configuring a dedicated service monitor
Copia collegamento

2.9.1. Enabling a dedicated service monitor
Copia collegamento

2.10. Configuring persistent storage
Copia collegamento

2.10.1. Persistent storage prerequisites
Copia collegamento

2.10.2. Configuring a local persistent volume claim
Copia collegamento

2.10.3. Resizing a persistent storage volume
Copia collegamento

2.10.4. Modifying the retention time and size for Prometheus metrics data
Copia collegamento

2.10.5. Modifying the retention time for Thanos Ruler metrics data
Copia collegamento

2.11. Configuring remote write storage
Copia collegamento

2.11.1. Supported remote write authentication settings
Copia collegamento

2.11.1.1. Config map location for authentication settings
Copia collegamento

2.11.1.2. Example remote write authentication settings
Copia collegamento

2.12. Adding cluster ID labels to metrics
Copia collegamento

2.12.1. Creating cluster ID labels for metrics
Copia collegamento

2.13. Controlling the impact of unbound metrics attributes in user-defined projects
Copia collegamento

2.13.1. Setting scrape sample and label limits for user-defined projects
Copia collegamento

2.13.2. Creating scrape sample alerts
Copia collegamento