```
{% endstep %}
{% step %}
**Locate the dcgm-metrics.csv key**
This key contains the list of DCGM fields exposed by the exporter. Add the following metrics to that list and save the ConfigMap.
```bash
DCGM_FI_DEV_FB_TOTAL, gauge, Total framebuffer memory (in MiB).
DCGM_FI_DEV_FB_RESERVED, gauge, Reserved framebuffer memory (in MiB).
```
{% hint style="info" %}
If `DCGM_FI_DEV_FB_RESERVED` is already present, do not duplicate it. Add only `DCGM_FI_DEV_FB_TOTAL`.
{% endhint %}
{% endstep %}
{% step %}
**Restart the DCGM exporter**
```bash
kubectl rollout restart daemonset -n gpu-operator nvidia-dcgm-exporter
```
{% endstep %}
{% endstepper %}
#### Configure metrics through Helm values
Use this option if the GPU Operator is managed by ArgoCD, Flux, or another GitOps workflow.
In GitOps-managed clusters, manual edits to the ConfigMap are usually overwritten during the next reconciliation. Instead, define a custom metrics ConfigMap and reference it from the GPU Operator Helm values.
{% stepper %}
{% step %}
**Update the GPU Operator Helm values**
```bash
dcgmExporter:
config:
name: metrics-config
env:
- name: DCGM_EXPORTER_COLLECTORS
value: /etc/dcgm-exporter/dcgm-metrics.csv
```
This will point the DCGM exporter to your custom ConfigMap.
{% endstep %}
{% step %}
**Create a ConfigMap with the same name in the gpu-operator namespace**
The ConfigMap must include a `dcgm-metrics.csv` key that contains NVIDIA’s default counters list plus the required framebuffer metrics
```bash
kubectl create configmap metrics-config \
-n gpu-operator \
--from-file=dcgm-metrics.csv=/path/to/your/dcgm-metrics.csv
```
{% endstep %}
{% step %}
**Check if the `dcgm-metrics.csv` file includes the following entries**
```csv
DCGM_FI_DEV_FB_TOTAL, gauge, Total framebuffer memory (in MiB).
DCGM_FI_DEV_FB_RESERVED, gauge, Reserved framebuffer memory (in MiB).
```
{% hint style="info" %}
If `DCGM_FI_DEV_FB_RESERVED` is already present, do not duplicate it. Add only `DCGM_FI_DEV_FB_TOTAL`.
{% endhint %}
{% endstep %}
{% step %}
**Restart the DCGM exporter**
```bash
kubectl rollout restart daemonset -n gpu-operator nvidia-dcgm-exporter
```
{% endstep %}
{% endstepper %}
#### Propagation
After the DCGM exporter restarts, run the verify command again to make sure both metrics are exposed.
Once they are available, it may take up to 15 minutes for GPU memory data to appear in the PerfectScale UI.
## Java containers support
{% hint style="info" %}
The **Coroot agent** is disabled by default. Once enabled, PerfectScale automatically detects Java containers and starts collecting JVM metrics.
Add the following parameter when deploying the PerfectScale agent to enable this feature:
```yaml
--set settings.corootNodeAgent.enabled=true
```
{% endhint %}
{% hint style="info" %}
Coroot supports only Linux nodes.
{% endhint %}
PerfectScale automatically identifies Java containers running in your Kubernetes environment and collects JVM metrics from them. By continuously analyzing them, PerfectScale provides granular visibility into resource usage, identifying potential bottlenecks. Based on this analysis, PerfectScale generates tailored recommendations to help ensure that your services remain efficient and maintain consistent performance.
PerfectScale starts collecting JVM metrics automatically. However, if for some reason you do not want PerfectScale to collect this data, you can disable it by turning off the deployment of `psc-coroot-node-agent` during agent installation:
```
--set settings.corootNodeAgent.enabled=false
```
### Deploy coroot pods to specific nodes
If your cluster includes both Linux and Windows nodes, make sure to set a nodeSelector for Linux when deploying workloads that are not Windows-compatible.
YAML values file example:
```yaml
coroot:
nodeSelector:
kubernetes.io/os: linux
```
Helm command example:
```
helm upgrade --install perfectscale ..... \
--set coroot.nodeSelector."kubernetes\.io/os"=linux \
perfectscale/exporter
```
To restrict workloads to a specific set of nodes (for example, those labeled `component=java`), you can combine multiple node selectors.
YAML values file example:
```
coroot:
nodeSelector:
kubernetes.io/os: linux
component: java
```
Helm command example:
```
helm upgrade --install perfectscale ..... \
--set coroot.nodeSelector."kubernetes\.io/os"=linux \
--set coroot.nodeSelector.component=java \
perfectscale/exporter
```
## Windows containers support
{% hint style="info" %}
Make sure you are using PerfectScale exporter version 1.0.53 or later to enable Windows containers support.
{% endhint %}
PerfectScale supports Windows-based containers, allowing you to optimize and manage them seamlessly. To enable this feature, as a Step 4 in a [cluster configuration](#cluster-configuration), execute the following command:
helm upgrade --install -n perfectscale --create-namespace perfectscale \
--set secret.create=true \
--set secret.clientId=**** \
--set secret.clientSecret=**** \
--set settings.clusterName=your-dev-cluster \
--set settings.deployWindowsExporter=true \
--set settings.windowsExporterEnabled=true \
--set settings.windowsExporterNamespace="perfectscale" \
--set settings.windowsExporterPort="9182" \
--set settings.windowsExporterLabelSelector="app.kubernetes.io/name=prometheus-windows-exporter"
perfectscale/exporter
{% hint style="info" %}
* Make sure the Helm parameter `windowsExporterEnabled` is set to **`true`**
* If the windows-exporter should be deployed by the PerfectScale Helm set `deployWindowsExporter=`**`true`**. In that case, no additional configurations are needed, as the default values will be sufficient.
* If `deployWindowsExporter` set to**`false`**, the additional parameters listed below need to be configured. \
\
Helm parameters should be configured according to the user’s environment:
* `windowsExporterNamespace`
* `windowsExporterPort`
* `windowsExporterLabelSelector`
{% endhint %}
## Size PerfectScale Agent
For large clusters, if you are not using automation, use PerfectScale’s recommendations for `psc-exporter` to properly size it.
## Setting cAdvisor scraping mode
If you prefer not to expose node/proxy permissions, execute the following command when [installing the exporter](/getting-started/how-to-onboard-a-cluster.md#onboarding-instructions):
```
helm upgrade --install -n perfectscale --create-namespace perfectscale \
--set secret.create=true \
--set secret.clientId=**** \
--set secret.clientSecret=**** \
--set settings.clusterName=name \
--set settings.cAdvisorScrapingMode=direct \
perfectscale/exporter
```
Depending on your security and access requirements, specify one of the scraping modes:
* `auto (default)`: Direct scraping with automatic failover to proxy if all nodes fail.
* `direct`: Force direct node scraping; excludes nodes/proxy RBAC permissions.
* `nodeProxy`: Force proxy scraping via the Kubernetes API.
## Uninstalling PerfectScale exporter
To uninstall the PerfectScale Agent, execute the following command
```yaml
helm -n perfectscale uninstall perfectscale
```
## How to whitelist PerfectScale on GKE with binary authorization enabled
If your GKE cluster enforces Binary Authorization, you need to add PerfectScale images to the Binary Authorization policy whitelist before installation.
Add the following entries under `admissionWhitelistPatterns`:
```yaml
- namePattern: public.ecr.aws/perfectscale-io/**
- namePattern: registry.k8s.io/kube-state-metrics/kube-state-metrics*
```
**Example**:
```yaml
admissionWhitelistPatterns:
- namePattern: docker.io/library/alpine*
- namePattern: gcr.io/cloudsql-docker/gce-proxy*
- namePattern: gcr.io/cloud-sql-connectors/cloud-sql-proxy*
- namePattern: docker.io/justwatch/elasticsearch_exporter*
- namePattern: docker.io/otel/opentelemetry-collector-contrib*
- namePattern: us-central1-docker.pkg.dev/doit-glean/gcf-artifacts/**
- namePattern: public.ecr.aws/perfectscale-io/**
- namePattern: registry.k8s.io/kube-state-metrics/kube-state-metrics*
```
These entries allow:
* PerfectScale images from `public.ecr.aws/perfectscale-io`
* `kube-state-metrics` images from `registry.k8s.io`
Without this, PerfectScale components may be blocked from running in clusters where Binary Authorization is enforced.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.perfectscale.io/getting-started/how-to-onboard-a-cluster.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.