Storage

Update a server disk

Since 7.1.0
PUT/servers/{serverId}/disks/{diskRef}

Change a disk's bus, cache, IO mode or QoS, or grow it with sizeGb at the next power change. apply: true pushes a QoS change to the running server; disks cannot be shrunk.

Request

Authorization
Provide your bearer token in the Authorization header when making requests to protected resources.
Example: Authorization: Bearer ********************
Path Params#
serverIdinteger#required

A valid server ID as shown in VirtFusion.

Example: 1
diskRefstring#required

Which disk: its id from the list, or its drive letter (a is the primary disk).

Example: b
Body Paramsapplication/json#

Any subset of the disk's settings, or a new size.

ServerDiskUpdate
busstring#
Allowed values:defaultvirtiovirtio-scsisatavirtio-discardvirtio-scsi-single
cachestring#
Allowed values:defaultnonewritethroughwritebackdirectsyncunsafe
iostring#
Allowed values:defaultthreadsnativeio_uringnone
qosobject#

Nested fields left out are preserved; 0 or null clears a limit.

fields
readIopsinteger#nullable
writeIopsinteger#nullable
readBytesinteger#nullable
writeBytesinteger#nullable
enabledboolean#

Not for the primary disk.

sizeGbinteger#

New size, larger than the current one; queues a grow.

applyboolean#

Push the QoS to the running server now. Only with qos.

Examples
{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}
{
    "bus": "virtio-scsi",
    "cache": "writeback"
}
{
    "sizeGb": 200
}

Request Code Samples

Showing the Limit IOPS on a running server now example from Body Params.
curl --location --request PUT 'https://cp.domain.com/api/v1/servers/1/disks/b' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data-raw '{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}'
wget --quiet --output-document=- \
  --method=PUT \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  --header='Content-Type: application/json' \
  --body-data='{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}' \
  'https://cp.domain.com/api/v1/servers/1/disks/b'
http PUT 'https://cp.domain.com/api/v1/servers/1/disks/b' \
  'Authorization: Bearer <token>' \
  'Accept: application/json' \
  'Content-Type: application/json' <<< '{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}'
const response = await fetch("https://cp.domain.com/api/v1/servers/1/disks/b", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        "qos": {
            "readIops": 500,
            "writeIops": 500
        },
        "apply": true
    }),
});

const data = await response.json();
console.log(response.status, data);
import axios from "axios";

const response = await axios({
    method: "put",
    url: "https://cp.domain.com/api/v1/servers/1/disks/b",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    data: {
        "qos": {
            "readIops": 500,
            "writeIops": 500
        },
        "apply": true
    },
});

console.log(response.status, response.data);
const https = require("https");

const payload = JSON.stringify({
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
});

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/1/disks/b",
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(payload),
    },
}, (res) => {
    let data = "";
    res.on("data", (chunk) => (data += chunk));
    res.on("end", () => console.log(res.statusCode, JSON.parse(data)));
});

req.on("error", (err) => console.error(err));
req.write(payload);
req.end();
import requests

url = "https://cp.domain.com/api/v1/servers/1/disks/b"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = {
    "qos": {
        "readIops": 500,
        "writeIops": 500,
    },
    "apply": True,
}

response = requests.request("PUT", url, headers=headers, json=payload)

print(response.status_code)
print(response.json())
import http.client
import json

conn = http.client.HTTPSConnection("cp.domain.com")
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = json.dumps({
    "qos": {
        "readIops": 500,
        "writeIops": 500,
    },
    "apply": True,
})

conn.request("PUT", "/api/v1/servers/1/disks/b", payload, headers)
response = conn.getresponse()

print(response.status)
print(json.loads(response.read()))
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://cp.domain.com/api/v1/servers/1/disks/b',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'qos' => [
            'readIops' => 500,
            'writeIops' => 500,
        ],
        'apply' => true,
    ]),
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json',
        'Content-Type: application/json'
    ),
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;
<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->request('PUT', 'https://cp.domain.com/api/v1/servers/1/disks/b', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
    'json' => [
        'qos' => [
            'readIops' => 500,
            'writeIops' => 500,
        ],
        'apply' => true,
    ],
]);

echo $response->getStatusCode() . "\n";
echo $response->getBody();
package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/1/disks/b"
    payload := strings.NewReader(`{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}`)
    req, _ := http.NewRequest("PUT", url, payload)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "application/json")

    res, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()

    body, _ := io.ReadAll(res.Body)
    fmt.Println(res.StatusCode, string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://cp.domain.com/api/v1/servers/1/disks/b"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .header("Content-Type", "application/json")
            .method("PUT", HttpRequest.BodyPublishers.ofString("{\"qos\":{\"readIops\":500,\"writeIops\":500},\"apply\":true}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}
import okhttp3.*;

public class Main {
    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();

        MediaType json = MediaType.get("application/json");
        RequestBody body = RequestBody.create("{\"qos\":{\"readIops\":500,\"writeIops\":500},\"apply\":true}", json);

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/1/disks/b")
            .method("PUT", body)
            .addHeader("Authorization", "Bearer <token>")
            .addHeader("Accept", "application/json")
            .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.code());
            System.out.println(response.body().string());
        }
    }
}
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(new HttpMethod("PUT"), "https://cp.domain.com/api/v1/servers/1/disks/b");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = new StringContent("{\"qos\":{\"readIops\":500,\"writeIops\":500},\"apply\":true}", Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode);
Console.WriteLine(await response.Content.ReadAsStringAsync());
require "net/http"
require "json"

uri = URI("https://cp.domain.com/api/v1/servers/1/disks/b")
request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = "{\"qos\":{\"readIops\":500,\"writeIops\":500},\"apply\":true}"

response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.code
puts JSON.pretty_generate(JSON.parse(response.body))
import Foundation

var request = URLRequest(url: URL(string: "https://cp.domain.com/api/v1/servers/1/disks/b")!)
request.httpMethod = "PUT"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = "{\"qos\":{\"readIops\":500,\"writeIops\":500},\"apply\":true}".data(using: .utf8)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else { print(error ?? "request failed"); return }
    print((response as! HTTPURLResponse).statusCode)
    print(String(data: data, encoding: .utf8) ?? "")
}
task.resume()
// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }, serde_json = "1"
use reqwest::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::PUT, "https://cp.domain.com/api/v1/servers/1/disks/b")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}"#)
        .send()?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}
// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }, tokio = { version = "1", features = ["full"] }, serde_json = "1"
use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::PUT, "https://cp.domain.com/api/v1/servers/1/disks/b")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}"#)
        .send()
        .await?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json().await?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

fun main() {
    val client = OkHttpClient()
    val body = """{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/1/disks/b")
        .method("PUT", body)
        .addHeader("Authorization", "Bearer <token>")
        .addHeader("Accept", "application/json")
        .build()

    client.newCall(request).execute().use { response ->
        println(response.code)
        println(response.body?.string())
    }
}
// pubspec.yaml: http: ^1.2.0
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final request = http.Request('PUT', Uri.parse('https://cp.domain.com/api/v1/servers/1/disks/b'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';
  request.headers['Content-Type'] = 'application/json';
  request.body = r'''{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}''';

  final response = await http.Response.fromStream(await request.send());
  print(response.statusCode);
  print(const JsonEncoder.withIndent('  ').convert(jsonDecode(response.body)));
}
#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl = curl_easy_init();
    if (!curl) return 1;

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Authorization: Bearer <token>");
    headers = curl_slist_append(headers, "Accept: application/json");
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/1/disks/b");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{\"qos\":{\"readIops\":500,\"writeIops\":500},\"apply\":true}");

    CURLcode result = curl_easy_perform(curl);
    if (result != CURLE_OK) fprintf(stderr, "%s\n", curl_easy_strerror(result));

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return result == CURLE_OK ? 0 : 1;
}
$headers = @{
    Authorization = "Bearer <token>"
    Accept        = "application/json"
}

$body = @'
{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}
'@

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/1/disks/b" -Method PUT -Headers $headers -ContentType "application/json" -Body $body
$response | ConvertTo-Json -Depth 10
PUT /api/v1/servers/1/disks/b HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json
Content-Type: application/json
Content-Length: 91

{
    "qos": {
        "readIops": 500,
        "writeIops": 500
    },
    "apply": true
}
curl --location --request PUT 'https://cp.domain.com/api/v1/servers/1/disks/b' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data-raw '{
    "bus": "virtio-scsi",
    "cache": "writeback"
}'
wget --quiet --output-document=- \
  --method=PUT \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  --header='Content-Type: application/json' \
  --body-data='{
    "bus": "virtio-scsi",
    "cache": "writeback"
}' \
  'https://cp.domain.com/api/v1/servers/1/disks/b'
http PUT 'https://cp.domain.com/api/v1/servers/1/disks/b' \
  'Authorization: Bearer <token>' \
  'Accept: application/json' \
  'Content-Type: application/json' <<< '{
    "bus": "virtio-scsi",
    "cache": "writeback"
}'
const response = await fetch("https://cp.domain.com/api/v1/servers/1/disks/b", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        "bus": "virtio-scsi",
        "cache": "writeback"
    }),
});

const data = await response.json();
console.log(response.status, data);
import axios from "axios";

const response = await axios({
    method: "put",
    url: "https://cp.domain.com/api/v1/servers/1/disks/b",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    data: {
        "bus": "virtio-scsi",
        "cache": "writeback"
    },
});

console.log(response.status, response.data);
const https = require("https");

const payload = JSON.stringify({
    "bus": "virtio-scsi",
    "cache": "writeback"
});

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/1/disks/b",
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(payload),
    },
}, (res) => {
    let data = "";
    res.on("data", (chunk) => (data += chunk));
    res.on("end", () => console.log(res.statusCode, JSON.parse(data)));
});

req.on("error", (err) => console.error(err));
req.write(payload);
req.end();
import requests

url = "https://cp.domain.com/api/v1/servers/1/disks/b"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = {
    "bus": "virtio-scsi",
    "cache": "writeback",
}

response = requests.request("PUT", url, headers=headers, json=payload)

print(response.status_code)
print(response.json())
import http.client
import json

conn = http.client.HTTPSConnection("cp.domain.com")
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = json.dumps({
    "bus": "virtio-scsi",
    "cache": "writeback",
})

conn.request("PUT", "/api/v1/servers/1/disks/b", payload, headers)
response = conn.getresponse()

print(response.status)
print(json.loads(response.read()))
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://cp.domain.com/api/v1/servers/1/disks/b',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'bus' => 'virtio-scsi',
        'cache' => 'writeback',
    ]),
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json',
        'Content-Type: application/json'
    ),
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;
<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->request('PUT', 'https://cp.domain.com/api/v1/servers/1/disks/b', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
    'json' => [
        'bus' => 'virtio-scsi',
        'cache' => 'writeback',
    ],
]);

echo $response->getStatusCode() . "\n";
echo $response->getBody();
package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/1/disks/b"
    payload := strings.NewReader(`{
    "bus": "virtio-scsi",
    "cache": "writeback"
}`)
    req, _ := http.NewRequest("PUT", url, payload)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "application/json")

    res, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()

    body, _ := io.ReadAll(res.Body)
    fmt.Println(res.StatusCode, string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://cp.domain.com/api/v1/servers/1/disks/b"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .header("Content-Type", "application/json")
            .method("PUT", HttpRequest.BodyPublishers.ofString("{\"bus\":\"virtio-scsi\",\"cache\":\"writeback\"}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}
import okhttp3.*;

public class Main {
    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();

        MediaType json = MediaType.get("application/json");
        RequestBody body = RequestBody.create("{\"bus\":\"virtio-scsi\",\"cache\":\"writeback\"}", json);

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/1/disks/b")
            .method("PUT", body)
            .addHeader("Authorization", "Bearer <token>")
            .addHeader("Accept", "application/json")
            .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.code());
            System.out.println(response.body().string());
        }
    }
}
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(new HttpMethod("PUT"), "https://cp.domain.com/api/v1/servers/1/disks/b");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = new StringContent("{\"bus\":\"virtio-scsi\",\"cache\":\"writeback\"}", Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode);
Console.WriteLine(await response.Content.ReadAsStringAsync());
require "net/http"
require "json"

uri = URI("https://cp.domain.com/api/v1/servers/1/disks/b")
request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = "{\"bus\":\"virtio-scsi\",\"cache\":\"writeback\"}"

response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.code
puts JSON.pretty_generate(JSON.parse(response.body))
import Foundation

var request = URLRequest(url: URL(string: "https://cp.domain.com/api/v1/servers/1/disks/b")!)
request.httpMethod = "PUT"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = "{\"bus\":\"virtio-scsi\",\"cache\":\"writeback\"}".data(using: .utf8)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else { print(error ?? "request failed"); return }
    print((response as! HTTPURLResponse).statusCode)
    print(String(data: data, encoding: .utf8) ?? "")
}
task.resume()
// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }, serde_json = "1"
use reqwest::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::PUT, "https://cp.domain.com/api/v1/servers/1/disks/b")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "bus": "virtio-scsi",
    "cache": "writeback"
}"#)
        .send()?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}
// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }, tokio = { version = "1", features = ["full"] }, serde_json = "1"
use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::PUT, "https://cp.domain.com/api/v1/servers/1/disks/b")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "bus": "virtio-scsi",
    "cache": "writeback"
}"#)
        .send()
        .await?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json().await?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

fun main() {
    val client = OkHttpClient()
    val body = """{
    "bus": "virtio-scsi",
    "cache": "writeback"
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/1/disks/b")
        .method("PUT", body)
        .addHeader("Authorization", "Bearer <token>")
        .addHeader("Accept", "application/json")
        .build()

    client.newCall(request).execute().use { response ->
        println(response.code)
        println(response.body?.string())
    }
}
// pubspec.yaml: http: ^1.2.0
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final request = http.Request('PUT', Uri.parse('https://cp.domain.com/api/v1/servers/1/disks/b'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';
  request.headers['Content-Type'] = 'application/json';
  request.body = r'''{
    "bus": "virtio-scsi",
    "cache": "writeback"
}''';

  final response = await http.Response.fromStream(await request.send());
  print(response.statusCode);
  print(const JsonEncoder.withIndent('  ').convert(jsonDecode(response.body)));
}
#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl = curl_easy_init();
    if (!curl) return 1;

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Authorization: Bearer <token>");
    headers = curl_slist_append(headers, "Accept: application/json");
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/1/disks/b");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{\"bus\":\"virtio-scsi\",\"cache\":\"writeback\"}");

    CURLcode result = curl_easy_perform(curl);
    if (result != CURLE_OK) fprintf(stderr, "%s\n", curl_easy_strerror(result));

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return result == CURLE_OK ? 0 : 1;
}
$headers = @{
    Authorization = "Bearer <token>"
    Accept        = "application/json"
}

$body = @'
{
    "bus": "virtio-scsi",
    "cache": "writeback"
}
'@

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/1/disks/b" -Method PUT -Headers $headers -ContentType "application/json" -Body $body
$response | ConvertTo-Json -Depth 10
PUT /api/v1/servers/1/disks/b HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json
Content-Type: application/json
Content-Length: 54

{
    "bus": "virtio-scsi",
    "cache": "writeback"
}
curl --location --request PUT 'https://cp.domain.com/api/v1/servers/1/disks/b' \
--header 'Authorization: Bearer <token>' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data-raw '{
    "sizeGb": 200
}'
wget --quiet --output-document=- \
  --method=PUT \
  --header='Authorization: Bearer <token>' \
  --header='Accept: application/json' \
  --header='Content-Type: application/json' \
  --body-data='{
    "sizeGb": 200
}' \
  'https://cp.domain.com/api/v1/servers/1/disks/b'
http PUT 'https://cp.domain.com/api/v1/servers/1/disks/b' \
  'Authorization: Bearer <token>' \
  'Accept: application/json' \
  'Content-Type: application/json' <<< '{
    "sizeGb": 200
}'
const response = await fetch("https://cp.domain.com/api/v1/servers/1/disks/b", {
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        "sizeGb": 200
    }),
});

const data = await response.json();
console.log(response.status, data);
import axios from "axios";

const response = await axios({
    method: "put",
    url: "https://cp.domain.com/api/v1/servers/1/disks/b",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
    },
    data: {
        "sizeGb": 200
    },
});

console.log(response.status, response.data);
const https = require("https");

const payload = JSON.stringify({
    "sizeGb": 200
});

const req = https.request({
    hostname: "cp.domain.com",
    path: "/api/v1/servers/1/disks/b",
    method: "PUT",
    headers: {
        "Authorization": "Bearer <token>",
        "Accept": "application/json",
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(payload),
    },
}, (res) => {
    let data = "";
    res.on("data", (chunk) => (data += chunk));
    res.on("end", () => console.log(res.statusCode, JSON.parse(data)));
});

req.on("error", (err) => console.error(err));
req.write(payload);
req.end();
import requests

url = "https://cp.domain.com/api/v1/servers/1/disks/b"
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = {
    "sizeGb": 200,
}

response = requests.request("PUT", url, headers=headers, json=payload)

print(response.status_code)
print(response.json())
import http.client
import json

conn = http.client.HTTPSConnection("cp.domain.com")
headers = {
    "Authorization": "Bearer <token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
payload = json.dumps({
    "sizeGb": 200,
})

conn.request("PUT", "/api/v1/servers/1/disks/b", payload, headers)
response = conn.getresponse()

print(response.status)
print(json.loads(response.read()))
<?php

$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://cp.domain.com/api/v1/servers/1/disks/b',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => json_encode([
        'sizeGb' => 200,
    ]),
    CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer <token>',
        'Accept: application/json',
        'Content-Type: application/json'
    ),
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;
<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client();

$response = $client->request('PUT', 'https://cp.domain.com/api/v1/servers/1/disks/b', [
    'headers' => [
        'Authorization' => 'Bearer <token>',
        'Accept' => 'application/json',
    ],
    'json' => [
        'sizeGb' => 200,
    ],
]);

echo $response->getStatusCode() . "\n";
echo $response->getBody();
package main

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

func main() {
    url := "https://cp.domain.com/api/v1/servers/1/disks/b"
    payload := strings.NewReader(`{
    "sizeGb": 200
}`)
    req, _ := http.NewRequest("PUT", url, payload)
    req.Header.Add("Authorization", "Bearer <token>")
    req.Header.Add("Accept", "application/json")
    req.Header.Add("Content-Type", "application/json")

    res, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()

    body, _ := io.ReadAll(res.Body)
    fmt.Println(res.StatusCode, string(body))
}
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://cp.domain.com/api/v1/servers/1/disks/b"))
            .header("Authorization", "Bearer <token>")
            .header("Accept", "application/json")
            .header("Content-Type", "application/json")
            .method("PUT", HttpRequest.BodyPublishers.ofString("{\"sizeGb\":200}"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}
import okhttp3.*;

public class Main {
    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();

        MediaType json = MediaType.get("application/json");
        RequestBody body = RequestBody.create("{\"sizeGb\":200}", json);

        Request request = new Request.Builder()
            .url("https://cp.domain.com/api/v1/servers/1/disks/b")
            .method("PUT", body)
            .addHeader("Authorization", "Bearer <token>")
            .addHeader("Accept", "application/json")
            .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.code());
            System.out.println(response.body().string());
        }
    }
}
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(new HttpMethod("PUT"), "https://cp.domain.com/api/v1/servers/1/disks/b");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "<token>");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = new StringContent("{\"sizeGb\":200}", Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode);
Console.WriteLine(await response.Content.ReadAsStringAsync());
require "net/http"
require "json"

uri = URI("https://cp.domain.com/api/v1/servers/1/disks/b")
request = Net::HTTP::Put.new(uri)
request["Authorization"] = "Bearer <token>"
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = "{\"sizeGb\":200}"

response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts response.code
puts JSON.pretty_generate(JSON.parse(response.body))
import Foundation

var request = URLRequest(url: URL(string: "https://cp.domain.com/api/v1/servers/1/disks/b")!)
request.httpMethod = "PUT"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = "{\"sizeGb\":200}".data(using: .utf8)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else { print(error ?? "request failed"); return }
    print((response as! HTTPURLResponse).statusCode)
    print(String(data: data, encoding: .utf8) ?? "")
}
task.resume()
// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }, serde_json = "1"
use reqwest::blocking::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::PUT, "https://cp.domain.com/api/v1/servers/1/disks/b")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "sizeGb": 200
}"#)
        .send()?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}
// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }, tokio = { version = "1", features = ["full"] }, serde_json = "1"
use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .request(reqwest::Method::PUT, "https://cp.domain.com/api/v1/servers/1/disks/b")
        .bearer_auth("<token>")
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .body(r#"{
    "sizeGb": 200
}"#)
        .send()
        .await?;

    println!("{}", response.status());
    let json: serde_json::Value = response.json().await?;
    println!("{}", serde_json::to_string_pretty(&json)?);
    Ok(())
}
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

fun main() {
    val client = OkHttpClient()
    val body = """{
    "sizeGb": 200
}""".toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://cp.domain.com/api/v1/servers/1/disks/b")
        .method("PUT", body)
        .addHeader("Authorization", "Bearer <token>")
        .addHeader("Accept", "application/json")
        .build()

    client.newCall(request).execute().use { response ->
        println(response.code)
        println(response.body?.string())
    }
}
// pubspec.yaml: http: ^1.2.0
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final request = http.Request('PUT', Uri.parse('https://cp.domain.com/api/v1/servers/1/disks/b'));
  request.headers['Authorization'] = 'Bearer <token>';
  request.headers['Accept'] = 'application/json';
  request.headers['Content-Type'] = 'application/json';
  request.body = r'''{
    "sizeGb": 200
}''';

  final response = await http.Response.fromStream(await request.send());
  print(response.statusCode);
  print(const JsonEncoder.withIndent('  ').convert(jsonDecode(response.body)));
}
#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl = curl_easy_init();
    if (!curl) return 1;

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Authorization: Bearer <token>");
    headers = curl_slist_append(headers, "Accept: application/json");
    headers = curl_slist_append(headers, "Content-Type: application/json");

    curl_easy_setopt(curl, CURLOPT_URL, "https://cp.domain.com/api/v1/servers/1/disks/b");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{\"sizeGb\":200}");

    CURLcode result = curl_easy_perform(curl);
    if (result != CURLE_OK) fprintf(stderr, "%s\n", curl_easy_strerror(result));

    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return result == CURLE_OK ? 0 : 1;
}
$headers = @{
    Authorization = "Bearer <token>"
    Accept        = "application/json"
}

$body = @'
{
    "sizeGb": 200
}
'@

$response = Invoke-RestMethod -Uri "https://cp.domain.com/api/v1/servers/1/disks/b" -Method PUT -Headers $headers -ContentType "application/json" -Body $body
$response | ConvertTo-Json -Depth 10
PUT /api/v1/servers/1/disks/b HTTP/1.1
Host: cp.domain.com
Authorization: Bearer <token>
Accept: application/json
Content-Type: application/json
Content-Length: 21

{
    "sizeGb": 200
}

Responses

200

Settings saved (and, with apply, the QoS pushed).

#
application/json
object
dataServerDisk#

A server disk. pending is the queued action on it, if any; hypervisor-side changes run at the next power change.

ServerDisk fields
idinteger#
drivestring#

Drive letter, a for the primary disk; accepted in paths.

primaryboolean#
sizeGbinteger#

Confirmed size. A queued grow shows its target in pending.newSizeGb until the hypervisor confirms.

formatstring#
Allowed values:qcow2raw
filesystemstring#nullable

Filesystem created on the disk at creation, if any.

busstring#

default is the hypervisor's setting.

Allowed values:defaultvirtiovirtio-scsisatavirtio-discardvirtio-scsi-single
cachestring#
Allowed values:defaultnonewritethroughwritebackdirectsyncunsafe
iostring#
Allowed values:defaultthreadsnativeio_uringnone
qosobject#

Per-disk limits; null means no limit. IOPS per second, bytes per second.

fields
readIopsinteger#nullable
writeIopsinteger#nullable
readBytesinteger#nullable
writeBytesinteger#nullable
storagePointobject#nullable

null for the hypervisor's local default.

fields
idinteger#
namestring#
localboolean#
statusstring#
Allowed values:pendingactivedeleting
enabledboolean#
pendingobject#nullable
fields
idinteger#

The queued action.

actionstring#
Allowed values:disk.createdisk.destroystorage.increase
statestring#

queued can be cancelled; running cannot; failed retries at the next power change and can be cancelled; stuck means its task ended without finishing it.

Allowed values:queuedrunningfailedstuck
runsAfterstring#
newSizeGbinteger#nullable

For a grow, the size it will reach.

cleanupboolean#

A destroy that cleans up a half-created disk; cannot be cancelled.

queuedstring <date-time>#
appliedboolean#nullable

Only with apply: true pushed, false the hypervisor refused, null unknown (timeout or lost answer). null when apply was not sent. The saved settings stand either way.

errorsarray[string]#
Example
{
    "data": {
        "id": 812,
        "drive": "b",
        "primary": false,
        "sizeGb": 100,
        "format": "raw",
        "filesystem": "xfs",
        "bus": "virtio-scsi",
        "cache": "writeback",
        "io": "native",
        "qos": {
            "readIops": 500,
            "writeIops": null,
            "readBytes": null,
            "writeBytes": null
        },
        "storagePoint": {
            "id": 12,
            "name": "StorPool fast",
            "local": false
        },
        "status": "active",
        "enabled": true,
        "pending": null
    },
    "applied": true
}
202

A grow was queued; the disk is returned with the queued storage.increase under `pendi…

#
application/json

A grow was queued; the disk is returned with the queued storage.increase under pending and its current size.

object
dataServerDisk#

A server disk. pending is the queued action on it, if any; hypervisor-side changes run at the next power change.

ServerDisk fields
idinteger#
drivestring#

Drive letter, a for the primary disk; accepted in paths.

primaryboolean#
sizeGbinteger#

Confirmed size. A queued grow shows its target in pending.newSizeGb until the hypervisor confirms.

formatstring#
Allowed values:qcow2raw
filesystemstring#nullable

Filesystem created on the disk at creation, if any.

busstring#

default is the hypervisor's setting.

Allowed values:defaultvirtiovirtio-scsisatavirtio-discardvirtio-scsi-single
cachestring#
Allowed values:defaultnonewritethroughwritebackdirectsyncunsafe
iostring#
Allowed values:defaultthreadsnativeio_uringnone
qosobject#

Per-disk limits; null means no limit. IOPS per second, bytes per second.

fields
readIopsinteger#nullable
writeIopsinteger#nullable
readBytesinteger#nullable
writeBytesinteger#nullable
storagePointobject#nullable

null for the hypervisor's local default.

fields
idinteger#
namestring#
localboolean#
statusstring#
Allowed values:pendingactivedeleting
enabledboolean#
pendingobject#nullable
fields
idinteger#

The queued action.

actionstring#
Allowed values:disk.createdisk.destroystorage.increase
statestring#

queued can be cancelled; running cannot; failed retries at the next power change and can be cancelled; stuck means its task ended without finishing it.

Allowed values:queuedrunningfailedstuck
runsAfterstring#
newSizeGbinteger#nullable

For a grow, the size it will reach.

cleanupboolean#

A destroy that cleans up a half-created disk; cannot be cancelled.

queuedstring <date-time>#
appliedboolean#nullable
Example
{
    "data": {
        "id": 812,
        "drive": "b",
        "primary": false,
        "sizeGb": 100,
        "format": "raw",
        "filesystem": "xfs",
        "bus": "virtio-scsi",
        "cache": "writeback",
        "io": "native",
        "qos": {
            "readIops": 500,
            "writeIops": null,
            "readBytes": null,
            "writeBytes": null
        },
        "storagePoint": {
            "id": 12,
            "name": "StorPool fast",
            "local": false
        },
        "status": "active",
        "enabled": true,
        "pending": {
            "id": 5540,
            "action": "storage.increase",
            "state": "queued",
            "runsAfter": "next power change",
            "newSizeGb": 200,
            "cleanup": false,
            "queued": "2026-10-06T14:10:00+00:00"
        }
    },
    "applied": null
}
401

The bearer token is missing, invalid, or expired. The response has no body.

#
No response body.
404

The server or the disk was not found.

#
application/json
ErrorMessage
msgstring#
Example
{
    "msg": "disk not found"
}
409

The server is elevated, a grow of this disk is already queued, or the disk is not yet c…

#
application/json

The server is elevated, a grow of this disk is already queued, or the disk is not yet created.

Error
errorsarray[string]#
Example
{
    "errors": [
        "a grow of this disk is already queued"
    ]
}
422

Validation failed, the body had no fields, the primary disk was disabled, apply was s…

#
application/json

Validation failed, the body had no fields, the primary disk was disabled, apply was sent with anything but qos, there is not enough space for the grow, or an unknown field was sent.

ValidationError
errorsobject#
Example
{
    "errors": {
        "bus": [
            "must be one of default, virtio, virtio-scsi, sata, virtio-discard, virtio-scsi-single"
        ]
    }
}
429

Too many requests. Either the token's requests per minute are used up (see the `X-RateL…

#
application/json

Too many requests. Either the token's requests per minute are used up (see the X-RateLimit-* headers) or the calling address has failed authentication 10 times in a minute (the body then includes retry_after_seconds). Retry-After gives the seconds to wait.

object
errorsarray[string]#
retry_after_secondsinteger#

Seconds to wait before retrying. Present on the failed-authentication limit only.

Response headers
Retry-Afterinteger

Seconds to wait before retrying.

X-RateLimit-Limitinteger

The token's requests per minute (token limit only).

X-RateLimit-Remaininginteger

Requests left in the current minute (token limit only).

X-RateLimit-Resetinteger

Unix timestamp at which the minute resets (token limit only).

Examples
{
    "errors": [
        "Too Many Requests"
    ]
}
{
    "errors": [
        "Too many authentication attempts. Try again later."
    ],
    "retry_after_seconds": 42
}
502

With apply: the hypervisor refused the QoS (applied: false) or its answer was lost …

#

With apply: the hypervisor refused the QoS (applied: false) or its answer was lost (applied: null). The settings are saved.

No response body.
504

With apply: the hypervisor did not answer within 30 seconds. The settings are saved; …

#

With apply: the hypervisor did not answer within 30 seconds. The settings are saved; the apply outcome is unknown.

No response body.