### Example: Run Specific Test 'TestStartAndReadMetrics'

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/integration/README.md

An example demonstrating how to run a particular test case, 'TestStartAndReadMetrics', using the TEST_ARGS variable. Be aware of potential delays in metric availability after starting the exporter.

```bash
make test-integration -e TEST_ARGS="-test.run TestStartAndReadMetrics"
```

--------------------------------

### Install DCGM Exporter with Default Configuration

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Installs the DCGM Exporter Helm chart using its default settings. This is a quick way to get started.

```bash
helm install dcgm-exporter ./deployment
```

--------------------------------

### Build and Install DCGM Exporter

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Clone the repository, build the binary, and install the DCGM exporter. Then, run the exporter and query metrics.

```shell
git clone https://github.com/NVIDIA/dcgm-exporter.git
cd dcgm-exporter
make binary
sudo make install
...
dcgm-exporter &
curl localhost:9400/metrics
# HELP DCGM_FI_DEV_SM_CLOCK SM clock frequency (in MHz).
# TYPE DCGM_FI_DEV_SM_CLOCK gauge
# HELP DCGM_FI_DEV_MEM_CLOCK Memory clock frequency (in MHz).
# TYPE DCGM_FI_DEV_MEM_CLOCK gauge
# HELP DCGM_FI_DEV_MEMORY_TEMP Memory temperature (in C).
# TYPE DCGM_FI_DEV_MEMORY_TEMP gauge
...
DCGM_FI_DEV_SM_CLOCK{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52"} 139
DCGM_FI_DEV_MEM_CLOCK{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52"} 405
DCGM_FI_DEV_MEMORY_TEMP{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52"} 9223372036854775794
...
```

--------------------------------

### Verify NVIDIA Container Toolkit Setup

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Run this command to check if the NVIDIA Container Toolkit is correctly installed and configured, allowing Docker to access NVIDIA GPUs.

```bash
# Check NVIDIA Container Toolkit
docker run --rm --gpus all nvidia/cuda:13.2.1-base nvidia-smi
```

--------------------------------

### Run DCGM-Exporter Docker Container

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Starts the DCGM-Exporter container, exposing GPU metrics on port 9400. Ensure Docker and NVIDIA container runtime are installed.

```shell
docker run -d --gpus all --cap-add SYS_ADMIN --rm -p 9400:9400 nvcr.io/nvidia/k8s/dcgm-exporter:4.5.3-4.8.2-distroless
```

--------------------------------

### Install DCGM Exporter with Custom Values

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Installs the DCGM Exporter Helm chart using a custom values file. This allows for specific configurations tailored to your environment.

```bash
helm install dcgm-exporter ./deployment -f my-debug-values.yaml
```

--------------------------------

### Run All Integration Tests

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/integration/README.md

Execute all integration tests for the DCGM Exporter from the project root directory. Ensure Golang and DCGM are installed and configured.

```bash
make test-integration
```

--------------------------------

### Install with Default Debug Configuration Enabled

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Helm command to install the DCGM Exporter with debug dumps enabled using a `--set` flag. Includes a command to verify debug file creation in the default directory.

```bash
# Install with default debug directory (/tmp/dcgm-exporter-debug)
helm install dcgm-exporter ./deployment --set debugDump.enabled=true

# Check if debug files are being created (using default directory)
kubectl exec -n dcgm-exporter <pod-name> -- ls -la /tmp/dcgm-exporter-debug/
```

--------------------------------

### Docker Test Directory Structure

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

This snippet shows the directory structure for the Docker testing setup. It lists the key files involved in setting up and running the tests.

```text
tests/docker/
├── docker_suite_test.go    # Test suite setup
├── image_startup_test.go   # Startup and lifecycle tests
├── image_metrics_test.go   # Metrics and health tests
├── helpers.go              # Docker helper functions
├── Makefile               # Test targets
└── README.md              # This file
```

--------------------------------

### Install DCGM-Exporter Helm Chart

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Installs the DCGM-Exporter using the Helm chart. This command will generate a release name automatically. Ensure Helm is configured and repositories are updated.

```shell
helm install \
    --generate-name \
    gpu-helm-charts/dcgm-exporter
```

--------------------------------

### Start DCGM-Exporter with Web Config File

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Launches the DCGM-Exporter, specifying a web configuration file for TLS and basic authentication. The exporter-toolkit library handles the configuration parsing.

```shell
dcgm-exporter --web-config-file=web-config.yaml
```

--------------------------------

### Install with Custom Debug Configuration

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Helm command to install the DCGM Exporter using a custom values file that enables debug dumps. Includes a command to verify debug file creation.

```bash
# Install with custom debug configuration
helm install dcgm-exporter ./deployment -f my-debug-values.yaml

# Check if debug files are being created (adjust path based on your configuration)
kubectl exec -n dcgm-exporter <pod-name> -- ls -la /var/log/dcgm-exporter-debug/
```

--------------------------------

### Get Application URL for NodePort Service

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/templates/NOTES.txt

Use these commands to retrieve the application URL when the service type is NodePort. This involves getting the NodePort and Node IP.

```bash
export NODE_PORT=$(kubectl get --namespace {{ include "dcgm-exporter.namespace" . }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "dcgm-exporter.fullname" . }})
  export NODE_IP=$(kubectl get nodes --namespace {{ include "dcgm-exporter.namespace" . }} -o jsonpath="{.items[0].status.addresses[0].address}")
  echo http://$NODE_IP:$NODE_PORT/metrics
```

--------------------------------

### Configure Remote Hostengine with IPv6 (Environment Variable)

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Sets the DCGM_REMOTE_HOSTENGINE_INFO environment variable to specify the IPv6 address and port for the remote hostengine. The exporter will use this when started.

```shell
export DCGM_REMOTE_HOSTENGINE_INFO="[::1]:5555"
dcgm-exporter
```

--------------------------------

### Get Application URL for ClusterIP Service

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/templates/NOTES.txt

Access the application URL for a ClusterIP service by port-forwarding to the pod. The application will be available at localhost.

```bash
export POD_NAME=$(kubectl get pods -n {{ include "dcgm-exporter.namespace" . }} -l "app.kubernetes.io/name={{ include "dcgm-exporter.name" . }},app.kubernetes.io/instance={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
  kubectl -n {{ include "dcgm-exporter.namespace" . }} port-forward $POD_NAME 8080:{{ .Values.service.port }} &
  echo "Visit http://127.0.0.1:8080/metrics to use your application"
```

--------------------------------

### Add DCGM-Exporter Helm Repository

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Adds the NVIDIA DCGM-Exporter Helm chart repository to your Helm configuration. This is a prerequisite for installing the exporter via Helm.

```shell
helm repo add gpu-helm-charts \
  https://nvidia.github.io/dcgm-exporter/helm-charts
```

--------------------------------

### Get Application URL for LoadBalancer Service

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/templates/NOTES.txt

Retrieve the application URL for a LoadBalancer service. Note that it may take time for the LoadBalancer IP to become available. You can monitor its status with kubectl.

```bash
NOTE: It may take a few minutes for the LoadBalancer IP to be available.
           You can watch the status of by running 'kubectl get --namespace {{ include "dcgm-exporter.namespace" . }} svc -w {{ include "dcgm-exporter.fullname" . }}'
  export SERVICE_IP=$(kubectl get svc --namespace {{ include "dcgm-exporter.namespace" . }} {{ include "dcgm-exporter.fullname" . }} --template "{{ range (index .status.loadBalancer.ingress 0) }}{{.}}{{ end }}")
  echo http://$SERVICE_IP:{{ .Values.service.port }}
```

--------------------------------

### Build and Test Docker Images

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Build Docker images locally and then run tests against all available image variants.

```bash
# Build images locally
make local

# Test all images
make test-images
```

--------------------------------

### Build Distroless DCGM Exporter Image

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Builds the distroless Docker image and exports it to 'docker images'.

```shell
make distroless PLATFORMS=linux/amd64 OUTPUT=type=docker
```

--------------------------------

### Run a Single Integration Test

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/integration/README.md

Focus on a specific integration test by providing its name via the TEST_ARGS environment variable. This is useful for rapid iteration during development.

```bash
make test-integration -e TEST_ARGS="-test.run [test name here]"
```

--------------------------------

### Build Local DCGM-Exporter Images

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/e2e/README.md

Build local Docker images for the DCGM-exporter. This command should be run from the project root directory.

```shell
cd ../../ # go to the project root directory  
make local
```

--------------------------------

### Run Default Docker Tests

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Execute the default Docker image tests, which run against locally built images of the current version.

```bash
cd tests/docker
make docker-test
```

--------------------------------

### Run E2E Tests After Building Local Images

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/e2e/README.md

Execute end-to-end tests after building local images. This requires navigating to the e2e test directory and setting the IMAGE_REPOSITORY environment variable.

```shell
cd tests/e2e # back to the e2e test directory 

KUBECONFIG="~/.kube/config" IMAGE_REPOSITORY="nvidia/dcgm-exporter"  make e2e-test
```

--------------------------------

### Configure Remote Hostengine with IPv6 (CLI)

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Connects the DCGM-Exporter to a remote hostengine using an IPv6 address and port. The address must be enclosed in brackets, and the CLI requires shell quoting.

```shell
dcgm-exporter -r "[::1]:5555"
```

--------------------------------

### Test Release Candidate Docker Image

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Use this snippet to test a release candidate build by specifying the FULL_VERSION. This allows testing pre-release versions of the exporter.

```bash
# Test release candidate
FULL_VERSION=4.5.3-5.0.0-rc1 make docker-test
```

--------------------------------

### Compare Two Docker Image Versions

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Use this snippet to compare two different Docker image versions by setting specific IMAGE_* variables for each. This is helpful for regression testing or comparing performance between versions.

```bash
# Compare two versions
IMAGE_UBUNTU=nvidia/dcgm-exporter:4.5.3-4.8.2-ubuntu22.04 \
IMAGE_DISTROLESS=nvidia/dcgm-exporter:4.5.3-5.0.0-distroless \
IMAGE_UBI="" \
make docker-test
```

--------------------------------

### Build and Push DCGM Exporter Images

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Builds and pushes Docker images to a specified private registry.

```shell
make REGISTRY=<private_registry> push
```

--------------------------------

### Test Specific Docker Image Variants

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Use dedicated make targets to test individual Docker image variants like Ubuntu, UBI, or distroless.

```bash
# Test only Ubuntu
make docker-test-ubuntu

# Test only UBI
make docker-test-ubi

# Test only distroless
make docker-test-distroless
```

--------------------------------

### Build Local DCGM Exporter Image

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Builds local Docker images based on the machine architecture.

```shell
make local
```

--------------------------------

### List Debug Files on Host Node

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Bash command to list the contents of the debug dump directory on the host node's filesystem.

```bash
ls -la /tmp/dcgm-exporter-debug/
```

--------------------------------

### Update Helm Repositories

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Updates all Helm repositories, including the newly added NVIDIA DCGM-Exporter repository, to fetch the latest chart information. Run this after adding a new repository.

```shell
helm repo update
```

--------------------------------

### List Debug Files within a Pod

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Kubectl command to execute 'ls -la' within a running DCGM Exporter pod to view debug files.

```bash
kubectl exec -n <namespace> <pod-name> -- ls -la /tmp/dcgm-exporter-debug/
```

--------------------------------

### Run Current DCGM-Exporter Release Test

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/e2e/README.md

Execute the end-to-end test for the current DCGM-exporter release using the default Helm chart configuration. Ensure your KUBECONFIG environment variable is set.

```shell
KUBECONFIG="~/.kube/config" make e2e-test
```

--------------------------------

### Test Custom Docker Images with Changed Registry or Version

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Customize tests to use images from a specific registry or test a particular version by setting environment variables.

```bash
# Test from your own registry
REGISTRY=my-registry.io FULL_VERSION=3.0.0-3.1.0 make docker-test

# Test specific version
FULL_VERSION=4.5.3-5.0.0 make docker-test-ubuntu
```

--------------------------------

### Persistent Storage Configuration for Debug Dumps

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

YAML configuration to enable debug dumps and specify a persistent directory using hostPath. Recommended for production environments.

```yaml
debugDump:
  enabled: true
  directory: "/var/log/dcgm-exporter-debug"  # Persistent location
  retention: 48  # hours - extended from default 24h for production use
  compression: true
```

--------------------------------

### Copy Debug Files from Pod

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Kubectl command to copy debug files from a DCGM Exporter pod to the local machine.

```bash
kubectl cp <namespace>/<pod-name>:/tmp/dcgm-exporter-debug/ ./debug-files/
```

--------------------------------

### Deploy DCGM-Exporter Kubernetes Manifest

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Applies a Kubernetes manifest file to deploy the DCGM-Exporter. This is an alternative to the Helm chart for direct deployment.

```shell
kubectl create -f https://raw.githubusercontent.com/NVIDIA/dcgm-exporter/master/dcgm-exporter.yaml
```

--------------------------------

### Automatic Git Commit Signing

Source: https://github.com/nvidia/dcgm-exporter/blob/main/CONTRIBUTING.md

How to configure git to automatically sign your commits using your configured user.name and user.email. This simplifies the commit process.

```git
git commit -s
```

--------------------------------

### Test Pull Request Build Docker Image

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Use this snippet to test a pull request build. You can specify a custom registry and a PR-specific version. This is useful for testing changes before merging.

```bash
# Test PR build
REGISTRY=ci.mycompany.com \
FULL_VERSION=4.5.3-pr-1234 \
make docker-test-ubuntu
```

--------------------------------

### Update DCGM and Exporter Versions

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Use this make command to update the FULL_VERSION in the Dockerfile Makefile when new versions of DCGM or the exporter are released. Ensure you have the correct old and new version numbers.

```bash
# From the project root
make update-version \
  OLD_DCGM_VERSION=4.3.0 \
  NEW_DCGM_VERSION=4.5.3 \
  OLD_EXPORTER_VERSION=4.5.3 \
  NEW_EXPORTER_VERSION=4.8.2

# This will update FULL_VERSION in tests/docker/Makefile from 4.3.0-4.5.3 to 4.5.3-4.8.2
```

--------------------------------

### DaemonSet Volume Definition for Debug Dumps

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

Kubernetes DaemonSet YAML snippet showing the volume definition for persisting debug dump files using a hostPath volume.

```yaml
# Volume definition
volumes:
- name: "debug-dumps"
  hostPath:
    path: {{ .Values.debugDump.directory }}
    type: DirectoryOrCreate

# Volume mount in container
volumeMounts:
- name: "debug-dumps"
  mountPath: {{ .Values.debugDump.directory }}
```

--------------------------------

### Enable Debug Dumps Configuration

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/README.md

YAML configuration to enable debug dump functionality for the DCGM Exporter. Specifies the directory, retention period, and compression settings.

```yaml
debugDump:
  enabled: true
  directory: "/tmp/dcgm-exporter-debug"  # Default location
  retention: 48  # hours (0 = no cleanup) - extended from default 24h for production use
  compression: true
```

--------------------------------

### Access Debug Files

Source: https://github.com/nvidia/dcgm-exporter/blob/main/deployment/templates/NOTES.txt

When debug dump functionality is enabled, use this command to list debug files within the specified directory on a given pod.

```bash
kubectl exec -n {{ include "dcgm-exporter.namespace" . }} <pod-name> -- ls -la {{ .Values.debugDump.directory }}
```

--------------------------------

### Custom Metrics Collection Configuration

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Specify a custom CSV file to configure which DCGM fields are collected. Ensure entries have two commas.

```shell
dcgm-exporter -f /tmp/custom-collectors.csv
```

```text
# Format
# If line starts with a '#' it is considered a comment
# DCGM FIELD, Prometheus metric type, help message

# Clocks
DCGM_FI_DEV_SM_CLOCK,  gauge, SM clock frequency (in MHz).
DCGM_FI_DEV_MEM_CLOCK, gauge, Memory clock frequency (in MHz).
```

--------------------------------

### Verify DCGM Exporter Docker Access

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

This command verifies that the DCGM exporter container can access the NVIDIA GPUs and necessary system capabilities. It requires the NVIDIA Container Toolkit and specific Docker capabilities.

```bash
# Verify DCGM access
docker run --rm --gpus all --cap-add SYS_ADMIN nvcr.io/nvidia/k8s/dcgm-exporter:4.5.3-4.8.2-distroless
```

--------------------------------

### Fetch Metrics via Port-Forwarded Kubernetes Pod

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Retrieves GPU metrics from a DCGM-Exporter pod in Kubernetes using the established port-forward. Assumes the port-forward is active and the pod is running.

```shell
curl -sL http://127.0.0.1:8080/metrics
# HELP DCGM_FI_DEV_SM_CLOCK SM clock frequency (in MHz).
# TYPE DCGM_FI_DEV_SM_CLOCK gauge
# HELP DCGM_FI_DEV_MEM_CLOCK Memory clock frequency (in MHz).
# TYPE DCGM_FI_DEV_MEM_CLOCK gauge
# HELP DCGM_FI_DEV_MEMORY_TEMP Memory temperature (in C).
# TYPE DCGM_FI_DEV_MEMORY_TEMP gauge
...
DCGM_FI_DEV_SM_CLOCK{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52",container="",namespace="",pod=""} 139
DCGM_FI_DEV_MEM_CLOCK{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52",container="",namespace="",pod=""} 405
DCGM_FI_DEV_MEMORY_TEMP{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52",container="",namespace="",pod=""} 9223372036854775794
...
```

--------------------------------

### Port-Forward to DCGM-Exporter Pod

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Establishes a port-forwarding connection from your local machine to the DCGM-Exporter pod in Kubernetes. This allows direct access to the metrics endpoint.

```shell
NAME=$(kubectl get pods -l "app.kubernetes.io/name=dcgm-exporter" 
                         -o "jsonpath={ .items[0].metadata.name}")

kubectl port-forward $NAME 8080:9400 &
```

--------------------------------

### Set Metrics Listen Address with IPv6

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Configures the DCGM-Exporter to listen for metrics requests on all available IPv6 interfaces and a specified port. Brackets are required around the IPv6 address.

```shell
dcgm-exporter -a "[::]:9400"
```

--------------------------------

### Fetch Metrics from Docker Container

Source: https://github.com/nvidia/dcgm-exporter/blob/main/README.md

Retrieves GPU metrics from the running DCGM-Exporter Docker container via curl. Assumes the container is running and accessible on localhost:9400.

```shell
curl localhost:9400/metrics
# HELP DCGM_FI_DEV_SM_CLOCK SM clock frequency (in MHz).
# TYPE DCGM_FI_DEV_SM_CLOCK gauge
# HELP DCGM_FI_DEV_MEM_CLOCK Memory clock frequency (in MHz).
# TYPE DCGM_FI_DEV_MEM_CLOCK gauge
# HELP DCGM_FI_DEV_MEMORY_TEMP Memory temperature (in C).
# TYPE DCGM_FI_DEV_MEMORY_TEMP gauge
...
DCGM_FI_DEV_SM_CLOCK{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52"} 139
DCGM_FI_DEV_MEM_CLOCK{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52"} 405
DCGM_FI_DEV_MEMORY_TEMP{gpu="0", UUID="GPU-604ac76c-d9cf-fef3-62e9-d92044ab6e52"} 9223372036854775794
...
```

--------------------------------

### Override Specific Docker Images for Testing

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Override default images by setting environment variables to test specific published or custom images, allowing for mixed local and remote image testing.

```bash
# Test published image
IMAGE_UBUNTU=nvcr.io/nvidia/k8s/dcgm-exporter:4.5.3-4.8.2-ubuntu22.04 \
make docker-test-ubuntu

# Mix local and published images
IMAGE_UBUNTU=nvcr.io/nvidia/k8s/dcgm-exporter:4.5.3-4.8.2-ubuntu22.04 \
IMAGE_UBI="" \
IMAGE_DISTROLESS=my-registry.io/dcgm-exporter:custom-distroless \
make docker-test

# Test from different registries
IMAGE_UBUNTU=registry1.io/dcgm:ubuntu \
IMAGE_UBI=registry2.io/dcgm:ubi \
IMAGE_DISTROLESS=registry3.io/dcgm:distroless \
make docker-test
```

--------------------------------

### Test Single Docker Image Variant

Source: https://github.com/nvidia/dcgm-exporter/blob/main/tests/docker/README.md

Use this snippet to test only one specific Docker image variant by setting the corresponding IMAGE_* variable and clearing others. This is useful for isolating tests to a particular image type.

```bash
# Test only one variant from published registry
IMAGE_UBUNTU=nvcr.io/nvidia/k8s/dcgm-exporter:4.5.3-4.8.2-ubuntu22.04 \
IMAGE_UBI="" \
IMAGE_DISTROLESS="" \
make docker-test
```

--------------------------------

### Developer Certificate of Origin Text

Source: https://github.com/nvidia/dcgm-exporter/blob/main/CONTRIBUTING.md

The full text of the Developer Certificate of Origin (DCO) that contributors must certify. This ensures the legitimacy and licensing of contributions.

```text
Developer Certificate of Origin
Version 1.1

Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
1 Letterman Drive
Suite D4700
San Francisco, CA, 94129

Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.

Developer's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the best
    of my knowledge, is covered under an appropriate open source
    license and I have the right under that license to submit that
    work with modifications, whether created in whole or in part
    by me, under the same open source license (unless I am
    permitted to submit under a different license), as indicated
    in the file; or

(c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.

(d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including all
    personal information I submit with it, including my sign-off) is
    maintained indefinitely and may be redistributed consistent with
    this project or the open source license(s) involved.

```

--------------------------------

### Git Commit Signed-off-by Format

Source: https://github.com/nvidia/dcgm-exporter/blob/main/CONTRIBUTING.md

The required format for the 'Signed-off-by' line in git commit messages. This line certifies your contribution according to the DCO.

```git
Signed-off-by: Joe Smith <joe.smith@email.com>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.