Procedure

1. Log in to the Web Console for the Red Hat OpenShift Service on AWS AWS Account and navigate to the VPC Dashboard in the region where the cluster is being hosted.
2. Go to the Peering Connections page and click the Create Peering Connection button.

3. Verify the details of the account you are logged in to and the details of the account and VPC you are connecting to:

   1. Peering connection name tag: Set a descriptive name for the VPC Peering Connection.
   2. VPC (Requester): Select the Red Hat OpenShift Service on AWS Cluster VPC ID from the dropdown *list.
   3. Account: Select Another account and provide the Customer AWS Account number *(without dashes).
   4. Region: If the Customer VPC Region differs from the current region, select Another Region and select the customer VPC Region from the dropdown list.
   5. VPC (Accepter): Set the Customer VPC ID.
4. Click Create Peering Connection.
5. Confirm that the request enters a Pending state. If it enters a Failed state, confirm the details and repeat the process.

Procedure

1. Log in to the AWS Web Console.
2. Navigate to VPC Service.
3. Go to Peering Connections.
4. Click on Pending peering connection.
5. Confirm the AWS Account and VPC ID that the request originated from. This should be from the Red Hat OpenShift Service on AWS AWS Account and Red Hat OpenShift Service on AWS Cluster VPC.
6. Click Accept Request.

Procedure

1. Log in to the AWS Web Console for the Red Hat OpenShift Service on AWS AWS Account.
2. Navigate to the VPC Service, then Route Tables.

3. Select the Route Table for the Red Hat OpenShift Service on AWS Cluster VPC.

   Note

   On some clusters, there may be more than one route table for a particular VPC. Select the private one that has a number of explicitly associated subnets.

4. Select the Routes tab, then Edit.
5. Enter the Customer VPC CIDR block in the Destination text box.
6. Enter the Peering Connection ID in the Target text box.
7. Click Save.

8. You must complete the same process with the other VPC’s CIDR block:

   1. Log into the Customer AWS Web Console → VPC Service → Route Tables.
   2. Select the Route Table for your VPC.
   3. Select the Routes tab, then Edit.
   4. Enter the Red Hat OpenShift Service on AWS Cluster VPC CIDR block in the Destination text box.
   5. Enter the Peering Connection ID in the Target text box.
   6. Click Save.

Procedure

1. Verify the tunnel is up in AWS.

   1. From the VPC Dashboard, click on VPN Connections.
   2. Select the VPN connection you created previously and click the Tunnel Details tab.
   3. You should be able to see that at least one of the VPN tunnels is Up.

2. Verify the connection.

   To test network connectivity to an endpoint device, nc (or netcat) is a helpful troubleshooting tool. It is included in the default image and provides quick and clear output if a connection can be established:

   1. Create a temporary pod using the busybox image, which cleans up after itself:

      $ oc run netcat-test \
          --image=busybox -i -t \
          --restart=Never --rm \
          -- /bin/sh

   2. Check the connection using nc.

      • Example successful connection results:

        / nc -zvv 192.168.1.1 8080
        10.181.3.180 (10.181.3.180:8080) open
        sent 0, rcvd 0

      • Example failed connection results:

        / nc -zvv 192.168.1.2 8080
        nc: 10.181.3.180 (10.181.3.180:8081): Connection refused
        sent 0, rcvd 0

   3. Exit the container, which automatically deletes the Pod:

      / exit

Procedure

1. Log in to the Red Hat OpenShift Service on AWS AWS Account Dashboard and select the correct region.
2. From the Red Hat OpenShift Service on AWS AWS Account region, select VPC from the Services menu.
3. From VPN Connections, select Virtual Private Gateways.
4. Select Create Virtual Private Gateway.
5. Give the Virtual Private Gateway a suitable name.
6. Click Custom ASN and enter the Amazon side ASN value gathered previously or use the Amazon Provided ASN.
7. Create the Virtual Private Gateway.
8. In the Navigation pane of the Red Hat OpenShift Service on AWS AWS Account Dashboard, choose Virtual private gateways and select the virtual private gateway. Choose View details.
9. Choose Direct Connect gateway associations and click Associate Direct Connect gateway.
10. Under Association account type, for Account owner, choose Another account.
11. For Direct Connect gateway owner, enter the ID of the AWS account that owns the Direct Connect gateway.
12. Under Association settings, for Direct Connect gateway ID, enter the ID of the Direct Connect gateway.
13. Under Association settings, for Virtual interface owner, enter the ID of the AWS account that owns the virtual interface for the association.
14. Optional: Add prefixes to Allowed prefixes, separating them using commas.
15. Choose Associate Direct Connect gateway.
16. After the Association Proposal has been sent, it will be waiting for your acceptance. The final steps you must perform are available in the AWS Documentation.

Procedure

1. List the machine pools in the cluster:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID        AUTOSCALING   REPLICAS    INSTANCE TYPE  LABELS    TAINTS   AVAILABILITY ZONES
   default   No            2           m5.xlarge                        us-east-1a
   mp1       No            2           m5.xlarge                        us-east-1a

2. Increase or decrease the number of compute node replicas in a machine pool:

   $ rosa edit machinepool --cluster=<cluster_name> \
                           --replicas=<replica_count> \ 1
                           <machine_pool_id> 2

   1

   If you deployed Red Hat OpenShift Service on AWS (ROSA) using a single availability zone, the replica count defines the number of compute nodes to provision to the machine pool for the zone. If you deployed your cluster using multiple availability zones, the count defines the total number of compute nodes in the machine pool across all zones and must be a multiple of 3.

   2

   Replace <machine_pool_id> with the ID of your machine pool, as listed in the output of the preceding command.

Verification

1. List the available machine pools in your cluster:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID        AUTOSCALING   REPLICAS    INSTANCE TYPE  LABELS    TAINTS   AVAILABILITY ZONES
   default   No            2           m5.xlarge                        us-east-1a
   mp1       No            3           m5.xlarge                        us-east-1a

2. In the output of the preceding command, verify that the compute node replica count is as expected for your machine pool. In the example output, the compute node replica count for the mp1 machine pool is scaled to 3.

Procedure

1. List the machine pools in the cluster:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID           AUTOSCALING  REPLICAS  INSTANCE TYPE  LABELS    TAINTS    AVAILABILITY ZONES    SPOT INSTANCES
   Default      No           2         m5.xlarge                          us-east-1a            N/A
   db-nodes-mp  No           2         m5.xlarge                          us-east-1a            No

2. Add or update the node labels for a machine pool:

   • To add or update node labels for a machine pool that does not use autoscaling, run the following command:

     $ rosa edit machinepool --cluster=<cluster_name> \
                             --replicas=<replica_count> \ 1
                             --labels=<key>=<value>,<key>=<value> \ 2
                             <machine_pool_id>

     1

     For machine pools that do not use autoscaling, you must provide a replica count when adding node labels. If you do not specify the --replicas argument, you are prompted for a replica count before the command completes. If you deployed Red Hat OpenShift Service on AWS (ROSA) using a single availability zone, the replica count defines the number of compute nodes to provision to the machine pool for the zone. If you deployed your cluster using multiple availability zones, the count defines the total number of compute nodes in the machine pool across all zones and must be a multiple of 3.

     2

     Replace <key>=<value>,<key>=<value> with a comma-delimited list of key-value pairs, for example --labels=key1=value1,key2=value2. This list overwrites any modifications made to node labels on an ongoing basis.

     The following example adds labels to the db-nodes-mp machine pool:

     $ rosa edit machinepool --cluster=mycluster --replicas=2 --labels=app=db,tier=backend db-nodes-mp

     Example output

     I: Updated machine pool 'db-nodes-mp' on cluster 'mycluster'

   • To add or update node labels for a machine pool that uses autoscaling, run the following command:

     $ rosa edit machinepool --cluster=<cluster_name> \
                             --min-replicas=<minimum_replica_count> \ 1
                             --max-replicas=<maximum_replica_count> \ 2
                             --labels=<key>=<value>,<key>=<value> \ 3
                             <machine_pool_id>

     1 2

     For machine pools that use autoscaling, you must provide minimum and maximum compute node replica limits. If you do not specify the arguments, you are prompted for the values before the command completes. The cluster autoscaler does not reduce or increase the machine pool node count beyond the limits that you specify. If you deployed ROSA using a single availability zone, the --min-replicas and --max-replicas arguments define the autoscaling limits in the machine pool for the zone. If you deployed your cluster using multiple availability zones, the arguments define the autoscaling limits in total across all zones and the counts must be multiples of 3.

     3

     Replace <key>=<value>,<key>=<value> with a comma-delimited list of key-value pairs, for example --labels=key1=value1,key2=value2. This list overwrites any modifications made to node labels on an ongoing basis.

     The following example adds labels to the db-nodes-mp machine pool:

     $ rosa edit machinepool --cluster=mycluster --min-replicas=2 --max-replicas=3 --labels=app=db,tier=backend db-nodes-mp

     Example output

     I: Updated machine pool 'db-nodes-mp' on cluster 'mycluster'

Verification

1. List the available machine pools in your cluster:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID           AUTOSCALING  REPLICAS  INSTANCE TYPE  LABELS                  TAINTS    AVAILABILITY ZONES    SPOT INSTANCES
   Default      No           2         m5.xlarge                                        us-east-1a            N/A
   db-nodes-mp  No           2         m5.xlarge      app=db, tier=backend              us-east-1a            No

2. Verify that the labels are included for your machine pool in the output.

Procedure

1. List the machine pools in the cluster:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID           AUTOSCALING  REPLICAS  INSTANCE TYPE  LABELS    TAINTS    AVAILABILITY ZONES    SPOT INSTANCES
   Default      No           2         m5.xlarge                          us-east-1a            N/A
   db-nodes-mp  No           2         m5.xlarge                          us-east-1a            No

2. Add or update the taints for a machine pool:

   • To add or update taints for a machine pool that does not use autoscaling, run the following command:

     $ rosa edit machinepool --cluster=<cluster_name> \
                             --replicas=<replica_count> \ 1
                             --taints=<key>=<value>:<effect>,<key>=<value>:<effect> \ 2
                             <machine_pool_id>

     1

     For machine pools that do not use autoscaling, you must provide a replica count when adding taints. If you do not specify the --replicas argument, you are prompted for a replica count before the command completes. If you deployed Red Hat OpenShift Service on AWS (ROSA) using a single availability zone, the replica count defines the number of compute nodes to provision to the machine pool for the zone. If you deployed your cluster using multiple availability zones, the count defines the total number of compute nodes in the machine pool across all zones and must be a multiple of 3.

     2

     Replace <key>=<value>:<effect>,<key>=<value>:<effect> with a key, value, and effect for each taint, for example --taints=key1=value1:NoSchedule,key2=value2:NoExecute. Available effects include NoSchedule, PreferNoSchedule, and NoExecute.This list overwrites any modifications made to node taints on an ongoing basis.

     The following example adds taints to the db-nodes-mp machine pool:

     $ rosa edit machinepool --cluster=mycluster --replicas 2 --taints=key1=value1:NoSchedule,key2=value2:NoExecute db-nodes-mp

     Example output

     I: Updated machine pool 'db-nodes-mp' on cluster 'mycluster'

   • To add or update taints for a machine pool that uses autoscaling, run the following command:

     $ rosa edit machinepool --cluster=<cluster_name> \
                             --min-replicas=<minimum_replica_count> \ 1
                             --max-replicas=<maximum_replica_count> \ 2
                             --taints=<key>=<value>:<effect>,<key>=<value>:<effect> \ 3
                             <machine_pool_id>

     1 2

     For machine pools that use autoscaling, you must provide minimum and maximum compute node replica limits. If you do not specify the arguments, you are prompted for the values before the command completes. The cluster autoscaler does not reduce or increase the machine pool node count beyond the limits that you specify. If you deployed ROSA using a single availability zone, the --min-replicas and --max-replicas arguments define the autoscaling limits in the machine pool for the zone. If you deployed your cluster using multiple availability zones, the arguments define the autoscaling limits in total across all zones and the counts must be multiples of 3.

     3

     Replace <key>=<value>:<effect>,<key>=<value>:<effect> with a key, value, and effect for each taint, for example --taints=key1=value1:NoSchedule,key2=value2:NoExecute. Available effects include NoSchedule, PreferNoSchedule, and NoExecute.This list overwrites any modifications made to node taints on an ongoing basis.

     The following example adds taints to the db-nodes-mp machine pool:

     $ rosa edit machinepool --cluster=mycluster --min-replicas=2 --max-replicas=3 --taints=key1=value1:NoSchedule,key2=value2:NoExecute db-nodes-mp

     Example output

     I: Updated machine pool 'db-nodes-mp' on cluster 'mycluster'

Verification

1. List the available machine pools in your cluster:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID           AUTOSCALING  REPLICAS  INSTANCE TYPE  LABELS    TAINTS                                           AVAILABILITY ZONES    SPOT INSTANCES
   Default      No           2         m5.xlarge                                                                 us-east-1a            N/A
   db-nodes-mp  No           2         m5.xlarge                key1=value1:NoSchedule, key2=value2:NoExecute    us-east-1a            No

2. Verify that the taints are included for your machine pool in the output.

Procedure

1. From OpenShift Cluster Manager, navigate to the Clusters page and select the cluster that you want to enable autoscaling for.
2. On the selected cluster, select the Machine pools tab.
3. Click the Options menu at the end of the machine pool that you want to enable autoscaling for and select Scale.
4. On the Edit node count dialog, select the Enable autoscaling checkbox.
5. Select Apply to save these changes and enable autoscaling for the cluster.

Procedure

1. To identify the machine pool IDs in a cluster, enter the following command:

   $ rosa list machinepools --cluster=<cluster_name>

   Example output

   ID        AUTOSCALING   REPLICAS    INSTANCE TYPE  LABELS    TINTS   AVAILABILITY ZONES
   default   No            2           m5.xlarge                        us-east-1a
   mp1       No            2           m5.xlarge                        us-east-1a

2. Get the ID of the machine pools that you want to configure.

3. To enable autoscaling on a machine pool, enter the following command:

   $ rosa edit machinepool --cluster=<cluster_name> <machinepool_ID> --enable-autoscaling --min-replicas=<number> --max-replicas=<number>

   Example

   Enable autoscaling on a machine pool with the ID mp1 on a cluster named mycluster, with the number of replicas set to scale between 2 and 5 worker nodes:

   $ rosa edit machinepool --cluster=mycluster mp1 --enable-autoscaling --min-replicas=2 --max-replicas=5

Procedure

1. From OpenShift Cluster Manager, navigate to the Clusters page and select the cluster with autoscaling that must be disabled.
2. On the selected cluster, select the Machine pools tab.
3. Click the Options menu at the end of the machine pool with autoscaling and select Scale.
4. On the "Edit node count" dialog, deselect the Enable autoscaling checkbox.
5. Select Apply to save these changes and disable autoscaling from the cluster.

Procedure

1. Enter the following command:

   $ rosa edit machinepool --cluster=<cluster_name> <machinepool_ID> --enable-autoscaling=false --replicas=<number>

   Example

   Disable autoscaling on the default machine pool on a cluster named mycluster:

   $ rosa edit machinepool --cluster=mycluster default --enable-autoscaling=false --replicas=3

Procedure

1. Navigate to OpenShift Cluster Manager and select your cluster.
2. In the Overview page for your cluster, view the service logs in the Cluster history section.
3. Optional: Filter the cluster service logs by Description or Severity from the drop-down menu. You can filter further by entering a specific item in the search bar.
4. Optional: Click Download history to download the service logs for your cluster in JSON or CSV format.

Procedure

1. Navigate to OpenShift Cluster Manager and select your cluster.
2. On the Support tab, under the Notification contacts heading, click Add notification contact.

3. Enter the Red Hat username or email of the contact you want to add.

   Note

   The username or email address must relate to a user account in the Red Hat organization where the cluster is deployed.

4. Click Add contact.

Procedure

1. Enter the following command:

   $ rosa install addon cluster-logging-operator --cluster=<cluster_name> --interactive

   For <cluster_name>, enter the name of your cluster.

2. When prompted, accept the default yes to install the cluster-logging-operator.

3. When prompted, accept the default yes to install the optional Amazon CloudWatch log forwarding add-on or enter no to decline the installation of this add-on.

   Note

   It is not necessary to install the AWS CloudWatch service when you install the cluster-logging-operator. You can install the AWS CloudWatch service at any time through OpenShift Cluster Manager console from the cluster’s Add-ons tab.

4. For the collection of applications, infrastructure, and audit logs, accept the default values or change them as needed:

   • Applications logs: Lets the Operator collect application logs, which includes everything that is not deployed in the openshift-, kube-, and default namespaces. Default: yes
   • Infrastructure logs: Lets the Operator collect logs from OpenShift Container Platform, Kubernetes, and some nodes. Default: yes
   • Audit logs: Type yes to let the Operator collect node logs related to security audits. By default, Red Hat stores audit logs outside the cluster through a separate mechanism that does not rely on the Cluster Logging Operator. For more information about default audit logging, see the ROSA Service Definition. Default: no

5. For the Amazon CloudWatch region, use the default cluster region, leave the Cloudwatch region value empty.

   Example output

   ? Are you sure you want to install add-on 'cluster-logging-operator' on cluster '<cluster_name>'? Yes
   ? Use AWS CloudWatch (optional): Yes
   ? Collect Applications logs (optional): Yes
   ? Collect Infrastructure logs (optional): Yes
   ? Collect Audit logs (optional): No
   ? CloudWatch region (optional):
   I: Add-on 'cluster-logging-operator' is now installing. To check the status run 'rosa list addons --cluster=<cluster_name>'

Verification steps

1. To verify the logging installation status, enter the following command:

   $ rosa list addons --cluster=<cluster_name>

2. To verify which pods are deployed by cluster-logging-operator and their state of readiness:

   1. Log in to the oc CLI using cluster-admin credentials:

      $ oc login https://api.mycluster.abwp.s1.example.org:6443 \
         --username cluster-admin
         --password <password>

   2. Enter the following command to get information about the pods for the default project. Alternatively, you can specify a different project.

      $ oc get pods -n openshift-logging

      Example output

      NAME                                        READY         STATUS      RESTARTS   AGE
      cluster-logging-operator-<pod_ID  >         2/2           Running     0          7m1s
      fluentd-4mnwp                               1/1           Running     0          6m3s
      fluentd-6xt25                               1/1           Running     0          6m3s
      fluentd-fqjhv                               1/1           Running     0          6m3s
      fluentd-gcvrg                               1/1           Running     0          6m3s
      fluentd-vpwrt                               1/1           Running     0          6m3s

3. Optional: To get information about the clusterlogging instance, enter the following command:

   $ oc get clusterlogging -n openshift-logging

4. Optional: To get information about clusterlogforwarders instances, enter the following command:

   $ oc get clusterlogforwarders -n openshift-logging

Procedure

1. Log in to the AWS console.
2. Select the region the cluster is deployed in.
3. Select the CloudWatch service.
4. Select Logs from the left column, and select Log Groups.
5. Select a log group to explore. You can view application, infrastructure, or audit logs, depending on which types were enabled during the add-on service installation. See the Amazon CloudWatch User Guide for more information.

Procedure

1. Edit the ConfigMap object.

   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 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 24 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.

2. Save the file to apply the changes to the ConfigMap object. The pods affected by the new configuration are restarted automatically.

   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.

Procedure

1. To move a component that monitors user-defined projects, edit the ConfigMap object:

   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 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>:
            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 nodes. Often, only a single key-value pair is used.

      The component can only run on nodes that have each of the specified key-value pairs as labels. The nodes can have additional labels as well.

      Important

      Many of the monitoring components are deployed by using multiple pods across different nodes in the cluster to maintain high availability. When moving monitoring components to labeled nodes, ensure that enough matching nodes are available to maintain resilience for the component. If only one label is specified, ensure that enough nodes contain that label to distribute all of the pods for the component across separate nodes. Alternatively, you can specify multiple labels each relating to individual nodes.

      Note

      If monitoring components remain in a Pending state after configuring the nodeSelector constraint, check the pod logs for errors relating to taints and tolerations.

      For example, to move monitoring components for user-defined projects to specific worker nodes labeled nodename: worker1, nodename: worker2, and nodename: worker2, use:

      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: user-workload-monitoring-config
        namespace: openshift-user-workload-monitoring
      data:
        config.yaml: |
          prometheusOperator:
            nodeSelector:
              nodename: worker1
          prometheus:
            nodeSelector:
              nodename: worker1
              nodename: worker2
          thanosRuler:
            nodeSelector:
              nodename: worker1
              nodename: worker2

2. Save the file to apply the changes. The components affected by the new configuration are moved to the new nodes automatically.

   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.

Procedure

1. Edit the ConfigMap object:

   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 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"

2. Save the file to apply the changes. The new component placement configuration is applied automatically.

   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.

Procedure

1. Edit the ConfigMap object:

   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 logLevel: <log_level> for a 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
            logLevel: <log_level> 2

      1

      The monitoring component that you are applying a log level to.

      2

      The log level to apply to the component.

2. Save the file to apply the changes. The pods for the component restarts automatically when you apply the log-level change.

   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.

3. Confirm that the log level has been applied by reviewing the deployment or pod configuration in the related project. The following example checks the log level in the prometheus-operator deployment in the openshift-user-workload-monitoring project:

   $ oc -n openshift-user-workload-monitoring get deploy prometheus-operator -o yaml |  grep "log-level"

   Example output

           - --log-level=debug

4. Check that the pods for the component are running. The following example lists the status of pods in the openshift-user-workload-monitoring project:

   $ oc -n openshift-user-workload-monitoring get pods

   Note

   If an unrecognized loglevel value is included in the ConfigMap object, the pods for the component might not restart successfully.

Procedure

1. In the Developer perspective in the Red Hat OpenShift Service on AWS web console, navigate to Observe → Dashboard.
2. Choose a project in the Project: list.
3. Choose a workload in the All Workloads list.
4. Optional: Select a time range for the graphs in the Time Range list.
5. Optional: Select a Refresh Interval.
6. Hover over each of the graphs within a dashboard to display detailed information about specific items.

Procedure

1. Query the metric name and verify that the project is correct:

   1. From the Developer perspective in the OpenShift Container Platform web console, select Observe → Metrics.
   2. Select the project that you want to view metrics for in the Project: list.

   3. Choose a query from the Select Query list, or run a custom PromQL query by selecting Show PromQL.

      The Select Query pane shows the metric names.

      Queries must be done on a per-project basis. The metrics that are shown relate to the project that you have selected.

2. Verify that the pod that you want metrics from is actively serving metrics. Run the following oc exec command into a pod to target the podIP, port, and /metrics.

   $ oc exec <sample_pod> -n <sample_namespace> -- curl <target_pod_IP>:<port>/metrics

   Note

   You must run the command on a pod that has curl installed.

   The following example output shows a result with a valid version metric.

   Example output

     % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                    Dload  Upload   Total   Spent    Left  Speed
   # HELP version Version information about this binary-- --:--:-- --:--:--     0
   # TYPE version gauge
   version{version="v0.1.0"} 1
   100   102  100   102    0     0  51000      0 --:--:-- --:--:-- --:--:-- 51000

   An invalid output indicates that there is a problem with the corresponding application.

3. If you are using a PodMonitor CRD, verify that the PodMonitor CRD is configured to point to the correct pods using label matching. For more information, see the Prometheus Operator documentation.

4. If you are using a ServiceMonitor CRD, and if the /metrics endpoint of the pod is showing metric data, follow these steps to verify the configuration:

   1. Verify that the service is pointed to the correct /metrics endpoint. The service labels in this output must match the services monitor labels and the /metrics endpoint defined by the service in the subsequent steps.

      $ oc get service

      Example output

      apiVersion: v1
      kind: Service 1
      metadata:
        labels: 2
          app: prometheus-example-app
        name: prometheus-example-app
        namespace: ns1
      spec:
        ports:
        - port: 8080
          protocol: TCP
          targetPort: 8080
          name: web
        selector:
          app: prometheus-example-app
        type: ClusterIP

      1

      Specifies that this is a service API.

      2

      Specifies the labels that are being used for this service.

   2. Query the serviceIP, port, and /metrics endpoints to see if the same metrics from the curl command you ran on the pod previously:

      1. Run the following command to find the service IP:

         $ oc get service -n <target_namespace>

      2. Query the /metrics endpoint:

         $ oc exec <sample_pod> -n <sample_namespace> -- curl <service_IP>:<port>/metrics

         Valid metrics are returned in the following example.

         Example output

         % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                        Dload  Upload   Total   Spent    Left  Speed
         100   102  100   102    0     0  51000      0 --:--:-- --:--:-- --:--:--   99k
         # HELP version Version information about this binary
         # TYPE version gauge
         version{version="v0.1.0"} 1

   3. Use label matching to verify that the ServiceMonitor object is configured to point to the desired service. To do this, compare the Service object from the oc get service output to the ServiceMonitor object from the oc get servicemonitor output. The labels must match for the metrics to be displayed.

      For example, from the previous steps, notice how the Service object has the app: prometheus-example-app label and the ServiceMonitor object has the same app: prometheus-example-app match label.

5. If everything looks valid and the metrics are still unavailable, please contact the support team for further help.