> This page is for Self-Hosted, version v3.0 (default).
> For other versions, use one of these documentation indexes:
> - v3.0 (default): https://docs.nvidia.com/run-ai/self-hosted/v3.0/llms.txt
> - v2.26: https://docs.nvidia.com/run-ai/self-hosted/v2.26/llms.txt
> - v2.25: https://docs.nvidia.com/run-ai/self-hosted/v2.25/llms.txt
> - v2.24: https://docs.nvidia.com/run-ai/self-hosted/v2.24/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/run-ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/run-ai/_mcp/server.

# Patch storage class configuration by id

PATCH http://localhost:8080/api/v1/storage-class-configuration/{id}
Content-Type: application/json

Partially updates an existing storage class configuration by its unique identifier. Use this endpoint to modify specific fields, such as permissions, customization values, or attributes, without replacing the entire configuration.

Reference: https://docs.nvidia.com/run-ai/self-hosted/reference/rest-api/endpoints/workload-assets/storage-class-configuration/patch-storage-class-configuration-by-id

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication

## Request

### Path parameters

- `id` (string, required) — unique identifier of the storage class configuration

### Query parameters

- `tenantId` (integer, optional)

### Body (application/json)

This endpoint expects a StorageClassConfigurationPatchRequest.

- `permissions` (StorageClassPermissions, optional) — Defines the access permissions and behavioral rules for this storage class.
- `customization` (StorageClassConfigurationPatchRequestCustomization, optional, nullable)

## Response

### 200

Storage class configuration

- `id` (string, required) — The unique identifier of the storage class configuration.
- `tenantId` (integer, required) — The id of the tenant.
- `scopeType` (enum, required, default: cluster) — Currently supported value: 'cluster', which is also the default.
  - Allowed values: `cluster`
- `scopeId` (string, required) — The ID of the cluster.
- `name` (string, required) — The name of the storage class to which the configuration applies.
- `permissions` (StorageClassPermissions, optional) — Defines the access permissions and behavioral rules for this storage class.
- `customization` (StorageClassCustomization, optional) — Optional UI/policy controls that define defaults and requirements when creating PVCs with this storage class.

## Errors

### 401 Unauthorized Error

Unauthorized

- `code` (integer, required)
- `message` (string, required)
- `details` (string, optional)

### 403 Forbidden Error

Forbidden

- `code` (integer, required)
- `message` (string, required)
- `details` (string, optional)

### 404 Not Found Error

The specified resource was not found

- `code` (integer, required)
- `message` (string, required)
- `details` (string, optional)

### 500 Internal Server Error

unexpected error

- `code` (integer, required)
- `message` (string, required)
- `details` (string, optional)

### 503 Service Unavailable Error

unexpected error

- `code` (integer, required)
- `message` (string, required)
- `details` (string, optional)

## Types

### StorageClassPermissions

Defines the access permissions and behavioral rules for this storage class.

- `allowedForAssets` (boolean, optional) — Determines whether PVC assets can be created using this storage class.
- `allowedForWorkloads` (boolean, optional) — Allows workloads to include PVCs that use this storage class. When disabled, users cannot (a) include non-existing PVC assets created with this class in asset-based submissions, or (b) attach PVCs with existing=false to workloads using this class.
- `allowedForEphemeralVolumes` (boolean, optional) — Allows workloads to create ephemeral volumes using this storage class. When disabled, users cannot (a) create PVC assets with autoDelete=true and ephemeral=true, or (b) include PVC instances with isEphemeral=false that use this storage class.
- `allowedForPersistentVolumes` (boolean, optional) — Allows workloads to create persistent volumes using this storage class. When disabled, users cannot (a) create PVC assets with autoDelete=true and ephemeral=true, or (b) include PVC instances with isEphemeral=false that use this storage class.
- `allowDataSharing` (boolean, optional) — Allows creation of PVCs using a shared volume.

### StorageClassConfigurationPatchRequestCustomization

- `accessMode` (AccessModeCustomization, optional) — Controls whether PVC access modes are required and what defaults to apply.
- `attributes` (list of PvcAddedAttribute, optional) — Defines additional annotation attributes to be applied to PVCs created under this storage class. Each attribute describes an annotation key and its expected value format, display name, and purpose.
- `attributesToRemove` (list of string, optional)
- `claimSize` (ClaimSizeCustomization, optional) — Defines the default, supported units, and range constraints for PVC claim sizes. These settings control the requested storage capacity when creating a PVC using this storage class.
- `volumeMode` (VolumeModeCustomization, optional) — Defines whether the volumeMode field is required when creating PVCs and specifies default and supported modes for the storage class.

### StorageClassCustomization

Optional UI/policy controls that define defaults and requirements when creating PVCs with this storage class.

- `accessMode` (AccessModeCustomization, optional) — Controls whether PVC access modes are required and what defaults to apply.
- `volumeMode` (VolumeModeCustomization, optional) — Defines whether the volumeMode field is required when creating PVCs and specifies default and supported modes for the storage class.
- `claimSize` (ClaimSizeCustomization, optional) — Defines the default, supported units, and range constraints for PVC claim sizes. These settings control the requested storage capacity when creating a PVC using this storage class.
- `attributes` (list of PvcAddedAttribute, optional) — Defines additional annotation attributes to be applied to PVCs created under this storage class. Each attribute describes an annotation key and its expected value format, display name, and purpose.

### AccessModeCustomization

Controls whether PVC access modes are required and what defaults to apply.

- `required` (boolean, optional, nullable) — If true, the accessMode field is mandatory when creating a PVC that uses this storage class.
- `default` (PvcAccessModes, optional) — Default access mode(s) applied to newly created PVCs unless explicitly overridden.
- `supportedValues` (PvcSupportedAccessModes, optional) — Defines the access modes supported by the given storage class. These values indicate which access configurations can be used when creating PVCs with this class.

### PvcAddedAttribute

Attribute that is added to any PVC of a given storage class.

- `key` (string, required) — The annotation key for the PVC. Must comply with Kubernetes naming rules: ≤63 characters, beginning and ending with an alphanumeric character ([A-Za-z0-9]), and may include dashes (-), underscores (_), or dots (.).
- `format` (enum, optional) — Defines the data type the attribute can accept. Enum: "text" "number" "boolean"
  - Allowed values: `text`, `number`, `boolean`
- `display` (string, optional, nullable) — User-friendly display name for the attribute, shown in the UI.
- `description` (string, optional, nullable) — A description of the attribute's purpose or expected values.
- `placeholder` (string, optional, nullable) — Example or hint text for the attribute's value, displayed as a watermark or help message in the UI.
- `required` (boolean, optional, nullable) — Indicates whether this attribute is mandatory.
- `defaultValue` (string, optional, nullable) — Default value assigned to the attribute when not explicitly provided.
- `validationRegexp` (string, optional, nullable) — Regular expression used to validate user input for text attributes.
- `minValue` (double, optional, nullable) — Minimum allowed value for attributes of type number.
- `maxValue` (double, optional, nullable) — Maximum allowed value for attributes of type number.
- `step` (double, optional, nullable) — Defines the incremental step between allowed numeric values (for example, 1, 0.1).
- `validationError` (string, optional, nullable) — Custom validation error message shown if input fails validation. If omitted, a default error message is generated automatically.

### ClaimSizeCustomization

Defines the default, supported units, and range constraints for PVC claim sizes. These settings control the requested storage capacity when creating a PVC using this storage class.

- `default` (string, optional) — Requested size for the PVC. Mandatory when existingPvc is false. Recommended sizes: TB/GB/MB/TIB/GIB/MIB
- `supportedUnits` (list of enum, optional) — Units supported for specifying PVC sizes. Valid values: "MB", "MiB", "GB", "GiB", "TB", "TiB".
  - Allowed values: `MB`, `MiB`, `GB`, `GiB`, `TB`, `TiB`
- `min` (string, optional) — Minimum claim size allowed for PVCs created with this storage class. Mandatory when existingPvc = false. Recommended values: TB, GB, MB, TIB, GIB, MIB.
- `max` (string, optional) — Maximum claim size allowed for PVCs created with this storage class. Mandatory when existingPvc = false. Recommended values: TB, GB, MB, TIB, GIB, MIB.
- `step` (string, optional) — Defines the incremental step between allowed numeric values (for example, 1, 0.1).

### VolumeModeCustomization

Defines whether the volumeMode field is required when creating PVCs and specifies default and supported modes for the storage class.

- `required` (boolean, optional, nullable) — Indicates whether the volumeMode field is mandatory when creating a PVC.
- `default` (enum, optional) — Default volume mode for the PVC. Choose between Filesystem (default) or Block.
  - Allowed values: `Filesystem`, `Block`
- `supportedValues` (VolumeModeCustomizationSupportedValues, optional, nullable) — Lists which volume modes are supported for this storage class.

### PvcAccessModes

Default access mode(s) applied to newly created PVCs unless explicitly overridden.

- `readWriteOnce` (boolean, optional, nullable, default: true) — Mount the volume as read/write by a single node.
- `readOnlyMany` (boolean, optional, nullable, default: false) — Mount the volume as read-only by many nodes.
- `readWriteMany` (boolean, optional, nullable, default: false) — Mount the volume as read/write by many nodes.

### PvcSupportedAccessModes

Defines the access modes supported by the given storage class. These values indicate which access configurations can be used when creating PVCs with this class.

- `readWriteOnce` (boolean, optional, nullable, default: true) — Indicates whether the readWriteOnce access mode is supported. This mode allows a volume to be mounted as read/write by a single node.
- `readOnlyMany` (boolean, optional, nullable, default: true) — Indicates whether the readOnlyMany access mode is supported. This mode allows a volume to be mounted as read-only by many nodes.
- `readWriteMany` (boolean, optional, nullable, default: true) — Indicates whether the readWriteMany access mode is supported. This mode allows a volume to be mounted as read/write by many nodes.

### VolumeModeCustomizationSupportedValues

Lists which volume modes are supported for this storage class.

- `filesystem` (boolean, optional, nullable, default: true) — Indicates whether filesystem mode is supported. Filesystem allows the volume to be mounted as a filesystem, enabling the usage of directories and files.
- `block` (boolean, optional, nullable, default: true) — Indicates whether block mode is supported. Exposes the volume as a block storage, which can be formatted or used by applications directly without a filesystem.

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "id": "string",
  "tenantId": 1001,
  "scopeType": "cluster",
  "scopeId": "string",
  "name": "Standard",
  "permissions": {
    "allowedForAssets": true,
    "allowedForWorkloads": true,
    "allowedForEphemeralVolumes": true,
    "allowedForPersistentVolumes": true,
    "allowDataSharing": true
  },
  "customization": {
    "accessMode": {
      "required": true,
      "default": {
        "readWriteOnce": true,
        "readOnlyMany": false,
        "readWriteMany": false
      },
      "supportedValues": {
        "readWriteOnce": true,
        "readOnlyMany": true,
        "readWriteMany": true
      }
    },
    "volumeMode": {
      "required": true,
      "default": "Filesystem",
      "supportedValues": {
        "filesystem": true,
        "block": true
      }
    },
    "claimSize": {
      "default": "1G",
      "supportedUnits": [
        "MB"
      ],
      "min": "1G",
      "max": "1G",
      "step": "1G"
    },
    "attributes": [
      {
        "key": "dnsname",
        "format": "text",
        "display": "DNS Name",
        "description": "The host name of the DNS",
        "placeholder": "enter hostname or IP address",
        "required": "true",
        "defaultValue": "my.dns.com",
        "validationRegexp": "^[a-zA-Z0-9.-_]+$",
        "minValue": 100,
        "maxValue": 200,
        "step": 5,
        "validationError": "Invalid URL"
      }
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "http://localhost:8080/api/v1/storage-class-configuration/id"

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'http://localhost:8080/api/v1/storage-class-configuration/id';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "http://localhost:8080/api/v1/storage-class-configuration/id"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("http://localhost:8080/api/v1/storage-class-configuration/id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Patch.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("http://localhost:8080/api/v1/storage-class-configuration/id")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'http://localhost:8080/api/v1/storage-class-configuration/id', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("http://localhost:8080/api/v1/storage-class-configuration/id");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:8080/api/v1/storage-class-configuration/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```