Disks - Update

Reference

Služba:: Compute

Verze rozhraní API:: 2024-03-02

Aktualizuje disk (opravy).

PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}?api-version=2024-03-02

Parametry identifikátoru URI

Name	V	Vyžadováno	Typ	Description
diskName	path	True	string	Název vytvořeného spravovaného disku. Název nelze po vytvoření disku změnit. Podporované znaky pro název jsou a-z, A-Z, 0-9, _ a -. Maximální délka názvu je 80 znaků.
resourceGroupName	path	True	string	Název skupiny prostředků.
subscriptionId	path	True	string	Přihlašovací údaje předplatného, které jednoznačně identifikují předplatné Microsoft Azure. ID předplatného tvoří součást identifikátoru URI pro každé volání služby.
api-version	query	True	string	Verze rozhraní API klienta.

Text požadavku

Name	Typ	Description
properties.burstingEnabled	boolean	Nastavte na hodnotu true, aby se umožnilo rozšíření nad rámec zřízeného cíle výkonu disku. Ve výchozím nastavení je shlukování zakázané. Nevztahuje se na disky Úrovně Ultra.
properties.dataAccessAuthMode	DataAccessAuthMode	Další požadavky na ověřování při exportu nebo nahrání na disk nebo snímek
properties.diskAccessId	string	ID ARM prostředku DiskAccess pro použití privátních koncových bodů na discích
properties.diskIOPSReadOnly	integer	Celkový počet vstupně-výstupních operací za sekundu, které budou povoleny pro všechny virtuální počítače, které připojí sdílený disk jako jen pro čtení. Jedna operace se může přenášet mezi 4k a 256k bajty.
properties.diskIOPSReadWrite	integer	Počet vstupně-výstupních operací za sekundu povolených pro tento disk; lze nastavit pouze pro disky UltraSSD. Jedna operace se může přenášet mezi 4k a 256k bajty.
properties.diskMBpsReadOnly	integer	Celková propustnost (MB/s), která bude povolena pro všechny virtuální počítače, které připojí sdílený disk jako jen pro čtení. MBps znamená miliony bajtů za sekundu - MB zde používá zápis ISO, mocnin 10.
properties.diskMBpsReadWrite	integer	Šířka pásma povolená pro tento disk; lze nastavit pouze pro disky UltraSSD. MBps znamená miliony bajtů za sekundu - MB zde používá zápis ISO, mocnin 10.
properties.diskSizeGB	integer	Pokud je creationData.createOption prázdný, je toto pole povinné a označuje velikost disku, který se má vytvořit. Pokud je toto pole k dispozici pro aktualizace nebo vytvoření s jinými možnostmi, znamená to změnu velikosti. Změna velikosti je povolená jenom v případě, že disk není připojený ke spuštěném virtuálnímu počítači a může zvětšit jenom velikost disku.
properties.encryption	Encryption	Vlastnost šifrování se dá použít k šifrování neaktivních uložených dat pomocí klíčů spravovaných zákazníkem nebo klíčů spravovaných platformou.
properties.encryptionSettingsCollection	EncryptionSettingsCollection	Kolekce nastavení šifrování použitá jako Azure Disk Encryption může obsahovat více nastavení šifrování na disk nebo snímek.
properties.maxShares	integer	Maximální počet virtuálních počítačů, které se můžou připojit k disku najednou. Hodnota větší než jedna označuje disk, který lze připojit na více virtuálních počítačů současně.
properties.networkAccessPolicy	NetworkAccessPolicy	Zásady pro přístup k disku přes síť
properties.optimizedForFrequentAttach	boolean	Nastavení této vlastnosti na true zlepšuje spolehlivost a výkon datových disků, které jsou často (více než 5krát denně) odpojením od jednoho virtuálního počítače a připojenými k jinému. Tato vlastnost by neměla být nastavená pro disky, které nejsou odpojené a připojené často, protože to způsobí, že disky nebudou v souladu s doménou selhání virtuálního počítače.
properties.osType	OperatingSystemTypes	typ operačního systému.
properties.publicNetworkAccess	PublicNetworkAccess	Zásady pro řízení exportu na disku
properties.purchasePlan	PurchasePlan	Informace o nákupním plánu, které se mají přidat na disk s operačním systémem
properties.supportedCapabilities	SupportedCapabilities	Seznam podporovaných možností, které se mají přidat na disk s operačním systémem
properties.supportsHibernation	boolean	Označuje operační systém na disku, který podporuje hibernaci.
properties.tier	string	Úroveň výkonu disku (např. P4, S10), jak je popsáno zde: https://azure.microsoft.com/en-us/pricing/details/managed-disks/. Nevztahuje se na disky Úrovně Ultra.
sku	DiskSku	Název skladové položky disků. Může to být Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, StandardSSD_ZRS nebo PremiumV2_LRS.
tags	object	Značky prostředků

Odpovědi

Name	Typ	Description
200 OK	Disk	OK
202 Accepted	Disk	Přijal

Zabezpečení

azure_auth

Azure Active Directory OAuth2 Flow

Typ: oauth2
Tok: implicit
URL autorizace: https://login.microsoftonline.com/common/oauth2/authorize

Rozsahy

Name	Description
user_impersonation	zosobnění uživatelského účtu

Příklady

Create or update a bursting enabled managed disk.

Update a managed disk to add accelerated networking.

Update a managed disk to add architecture.

Update a managed disk to add purchase plan.

Update a managed disk to add supportsHibernation.

Update a managed disk to change tier.

Update a managed disk to disable bursting.

Update a managed disk to disable optimizedForFrequentAttach.

Update a managed disk with diskControllerTypes.

Update managed disk to remove disk access resource association.

Create or update a bursting enabled managed disk.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "diskSizeGB": 1024,
    "burstingEnabled": true
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_CreateOrUpdate_BurstingEnabled.json
     */
    /**
     * Sample code: Create or update a bursting enabled managed disk.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void createOrUpdateABurstingEnabledManagedDisk(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withDiskSizeGB(1024).withBurstingEnabled(true), com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_create_or_update_bursting_enabled.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"burstingEnabled": True, "diskSizeGB": 1024}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_CreateOrUpdate_BurstingEnabled.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_CreateOrUpdate_BurstingEnabled.json
func ExampleDisksClient_BeginUpdate_createOrUpdateABurstingEnabledManagedDisk() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			BurstingEnabled: to.Ptr(true),
			DiskSizeGB:      to.Ptr[int32](1024),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armcompute.DiskProperties{
	// 		BurstingEnabled: to.Ptr(true),
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionEmpty),
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](1024),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_CreateOrUpdate_BurstingEnabled.json
 */
async function createOrUpdateABurstingEnabledManagedDisk() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { burstingEnabled: true, diskSizeGB: 1024 };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_CreateOrUpdate_BurstingEnabled.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    DiskSizeGB = 1024,
    BurstingEnabled = true,
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "id": "/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk",
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "diskSizeGB": 1024,
    "provisioningState": "Updating"
  },
  "location": "West US",
  "name": "myDisk"
}

Stavový kód:: 200

{
  "id": "/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk",
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "diskSizeGB": 1024,
    "burstingEnabled": true,
    "provisioningState": "Succeeded"
  },
  "location": "West US",
  "name": "myDisk"
}

Update a managed disk to add accelerated networking.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "supportedCapabilities": {
      "acceleratedNetwork": false
    }
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;
import com.azure.resourcemanager.compute.models.SupportedCapabilities;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_AddAcceleratedNetworking.json
     */
    /**
     * Sample code: Update a managed disk to add accelerated networking.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        updateAManagedDiskToAddAcceleratedNetworking(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withSupportedCapabilities(new SupportedCapabilities().withAcceleratedNetwork(false)),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_add_accelerated_networking.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"supportedCapabilities": {"acceleratedNetwork": False}}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddAcceleratedNetworking.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddAcceleratedNetworking.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToAddAcceleratedNetworking() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			SupportedCapabilities: &armcompute.SupportedCapabilities{
				AcceleratedNetwork: to.Ptr(false),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("westus"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionFromImage),
	// 			ImageReference: &armcompute.ImageDiskReference{
	// 				ID: to.Ptr("/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"),
	// 			},
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](127),
	// 		HyperVGeneration: to.Ptr(armcompute.HyperVGenerationV1),
	// 		OSType: to.Ptr(armcompute.OperatingSystemTypesWindows),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SupportedCapabilities: &armcompute.SupportedCapabilities{
	// 			AcceleratedNetwork: to.Ptr(false),
	// 		},
	// 	},
	// 	SKU: &armcompute.DiskSKU{
	// 		Name: to.Ptr(armcompute.DiskStorageAccountTypesStandardLRS),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddAcceleratedNetworking.json
 */
async function updateAManagedDiskToAddAcceleratedNetworking() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = {
    supportedCapabilities: { acceleratedNetwork: false },
  };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddAcceleratedNetworking.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    SupportedCapabilities = new SupportedCapabilities
    {
        AcceleratedNetwork = false,
    },
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportedCapabilities": {
      "acceleratedNetwork": false
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Updating"
  }
}

Stavový kód:: 200

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportedCapabilities": {
      "acceleratedNetwork": false
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Succeeded"
  }
}

Update a managed disk to add architecture.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "supportedCapabilities": {
      "architecture": "Arm64"
    }
  }
}


import com.azure.resourcemanager.compute.models.Architecture;
import com.azure.resourcemanager.compute.models.DiskUpdate;
import com.azure.resourcemanager.compute.models.SupportedCapabilities;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_ToAddArchitecture.json
     */
    /**
     * Sample code: Update a managed disk to add architecture.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void updateAManagedDiskToAddArchitecture(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks()
            .update("myResourceGroup", "myDisk",
                new DiskUpdate()
                    .withSupportedCapabilities(new SupportedCapabilities().withArchitecture(Architecture.ARM64)),
                com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_to_add_architecture.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"supportedCapabilities": {"architecture": "Arm64"}}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ToAddArchitecture.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ToAddArchitecture.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToAddArchitecture() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			SupportedCapabilities: &armcompute.SupportedCapabilities{
				Architecture: to.Ptr(armcompute.ArchitectureArm64),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("westus"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionFromImage),
	// 			ImageReference: &armcompute.ImageDiskReference{
	// 				ID: to.Ptr("/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"),
	// 			},
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](127),
	// 		HyperVGeneration: to.Ptr(armcompute.HyperVGenerationV1),
	// 		OSType: to.Ptr(armcompute.OperatingSystemTypesWindows),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SupportedCapabilities: &armcompute.SupportedCapabilities{
	// 			Architecture: to.Ptr(armcompute.ArchitectureArm64),
	// 		},
	// 	},
	// 	SKU: &armcompute.DiskSKU{
	// 		Name: to.Ptr(armcompute.DiskStorageAccountTypesStandardLRS),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ToAddArchitecture.json
 */
async function updateAManagedDiskToAddArchitecture() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { supportedCapabilities: { architecture: "Arm64" } };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ToAddArchitecture.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    SupportedCapabilities = new SupportedCapabilities
    {
        Architecture = ArchitectureType.Arm64,
    },
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportedCapabilities": {
      "architecture": "Arm64"
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Updating"
  }
}

Stavový kód:: 200

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportedCapabilities": {
      "architecture": "Arm64"
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Succeeded"
  }
}

Update a managed disk to add purchase plan.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "purchasePlan": {
      "name": "myPurchasePlanName",
      "publisher": "myPurchasePlanPublisher",
      "product": "myPurchasePlanProduct",
      "promotionCode": "myPurchasePlanPromotionCode"
    }
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;
import com.azure.resourcemanager.compute.models.PurchasePlanAutoGenerated;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_AddPurchasePlan.json
     */
    /**
     * Sample code: Update a managed disk to add purchase plan.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void updateAManagedDiskToAddPurchasePlan(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks()
            .update("myResourceGroup", "myDisk",
                new DiskUpdate().withPurchasePlan(new PurchasePlanAutoGenerated().withName("myPurchasePlanName")
                    .withPublisher("myPurchasePlanPublisher").withProduct("myPurchasePlanProduct")
                    .withPromotionCode("fakeTokenPlaceholder")),
                com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_add_purchase_plan.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={
            "properties": {
                "purchasePlan": {
                    "name": "myPurchasePlanName",
                    "product": "myPurchasePlanProduct",
                    "promotionCode": "myPurchasePlanPromotionCode",
                    "publisher": "myPurchasePlanPublisher",
                }
            }
        },
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddPurchasePlan.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddPurchasePlan.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToAddPurchasePlan() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			PurchasePlan: &armcompute.DiskPurchasePlan{
				Name:          to.Ptr("myPurchasePlanName"),
				Product:       to.Ptr("myPurchasePlanProduct"),
				PromotionCode: to.Ptr("myPurchasePlanPromotionCode"),
				Publisher:     to.Ptr("myPurchasePlanPublisher"),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("westus"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionFromImage),
	// 			ImageReference: &armcompute.ImageDiskReference{
	// 				ID: to.Ptr("/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"),
	// 			},
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](127),
	// 		HyperVGeneration: to.Ptr(armcompute.HyperVGenerationV1),
	// 		OSType: to.Ptr(armcompute.OperatingSystemTypesWindows),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		PurchasePlan: &armcompute.DiskPurchasePlan{
	// 			Name: to.Ptr("myPurchasePlanName"),
	// 			Product: to.Ptr("myPurchasePlanProduct"),
	// 			PromotionCode: to.Ptr("myPurchasePlanPromotionCode"),
	// 			Publisher: to.Ptr("myPurchasePlanPublisher"),
	// 		},
	// 	},
	// 	SKU: &armcompute.DiskSKU{
	// 		Name: to.Ptr(armcompute.DiskStorageAccountTypesStandardLRS),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddPurchasePlan.json
 */
async function updateAManagedDiskToAddPurchasePlan() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = {
    purchasePlan: {
      name: "myPurchasePlanName",
      product: "myPurchasePlanProduct",
      promotionCode: "myPurchasePlanPromotionCode",
      publisher: "myPurchasePlanPublisher",
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddPurchasePlan.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    PurchasePlan = new DiskPurchasePlan("myPurchasePlanName", "myPurchasePlanPublisher", "myPurchasePlanProduct")
    {
        PromotionCode = "myPurchasePlanPromotionCode",
    },
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "purchasePlan": {
      "name": "myPurchasePlanName",
      "publisher": "myPurchasePlanPublisher",
      "product": "myPurchasePlanProduct",
      "promotionCode": "myPurchasePlanPromotionCode"
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Updating"
  }
}

Stavový kód:: 200

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "purchasePlan": {
      "name": "myPurchasePlanName",
      "publisher": "myPurchasePlanPublisher",
      "product": "myPurchasePlanProduct",
      "promotionCode": "myPurchasePlanPromotionCode"
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/test_test_pmc2pc1/ArtifactTypes/VMImage/Offers/marketplace_vm_test/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Succeeded"
  }
}

Update a managed disk to add supportsHibernation.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "supportsHibernation": true
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_AddSupportsHibernation.json
     */
    /**
     * Sample code: Update a managed disk to add supportsHibernation.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        updateAManagedDiskToAddSupportsHibernation(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withSupportsHibernation(true), com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_add_supports_hibernation.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"supportsHibernation": True}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddSupportsHibernation.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddSupportsHibernation.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToAddSupportsHibernation() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			SupportsHibernation: to.Ptr(true),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("westus"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionImport),
	// 			SourceURI: to.Ptr("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](127),
	// 		HyperVGeneration: to.Ptr(armcompute.HyperVGenerationV1),
	// 		OSType: to.Ptr(armcompute.OperatingSystemTypesWindows),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SupportsHibernation: to.Ptr(true),
	// 	},
	// 	SKU: &armcompute.DiskSKU{
	// 		Name: to.Ptr(armcompute.DiskStorageAccountTypesStandardLRS),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddSupportsHibernation.json
 */
async function updateAManagedDiskToAddSupportsHibernation() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { supportsHibernation: true };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddSupportsHibernation.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    SupportsHibernation = true,
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportsHibernation": true,
    "creationData": {
      "createOption": "Import",
      "sourceUri": "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"
    },
    "diskSizeGB": 127,
    "provisioningState": "Updating"
  }
}

Stavový kód:: 200

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportsHibernation": true,
    "creationData": {
      "createOption": "Import",
      "sourceUri": "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"
    },
    "diskSizeGB": 127,
    "provisioningState": "Succeeded"
  }
}

Update a managed disk to change tier.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "tier": "P30"
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_ChangeTier.json
     */
    /**
     * Sample code: Update a managed disk to change tier.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void updateAManagedDiskToChangeTier(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withTier("P30"), com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_change_tier.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"tier": "P30"}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ChangeTier.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ChangeTier.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToChangeTier() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			Tier: to.Ptr("P30"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionEmpty),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		Tier: to.Ptr("P30"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ChangeTier.json
 */
async function updateAManagedDiskToChangeTier() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { tier: "P30" };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_ChangeTier.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    Tier = "P30",
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "provisioningState": "Updating",
    "tier": "P10",
    "propertyUpdatesInProgress": {
      "targetTier": "P30"
    }
  },
  "location": "West US",
  "name": "myDisk"
}

Stavový kód:: 200

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "provisioningState": "Succeeded",
    "tier": "P30"
  },
  "location": "West US",
  "name": "myDisk"
}

Update a managed disk to disable bursting.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "burstingEnabled": false
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_DisableBursting.json
     */
    /**
     * Sample code: Update a managed disk to disable bursting.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void updateAManagedDiskToDisableBursting(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withBurstingEnabled(false), com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_disable_bursting.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"burstingEnabled": False}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableBursting.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableBursting.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToDisableBursting() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			BurstingEnabled: to.Ptr(false),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionEmpty),
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableBursting.json
 */
async function updateAManagedDiskToDisableBursting() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { burstingEnabled: false };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableBursting.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    BurstingEnabled = false,
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "provisioningState": "Updating"
  },
  "location": "West US",
  "name": "myDisk"
}

Stavový kód:: 200

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "provisioningState": "Succeeded"
  },
  "location": "West US",
  "name": "myDisk"
}

Update a managed disk to disable optimizedForFrequentAttach.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "optimizedForFrequentAttach": false
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_DisableOptimizedForFrequentAttach.json
     */
    /**
     * Sample code: Update a managed disk to disable optimizedForFrequentAttach.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        updateAManagedDiskToDisableOptimizedForFrequentAttach(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withOptimizedForFrequentAttach(false), com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_disable_optimized_for_frequent_attach.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"optimizedForFrequentAttach": False}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableOptimizedForFrequentAttach.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableOptimizedForFrequentAttach.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskToDisableOptimizedForFrequentAttach() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			OptimizedForFrequentAttach: to.Ptr(false),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionEmpty),
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](200),
	// 		OptimizedForFrequentAttach: to.Ptr(false),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableOptimizedForFrequentAttach.json
 */
async function updateAManagedDiskToDisableOptimizedForFrequentAttach() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { optimizedForFrequentAttach: false };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_DisableOptimizedForFrequentAttach.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    IsOptimizedForFrequentAttach = false,
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "diskSizeGB": 200,
    "provisioningState": "Updating",
    "optimizedForFrequentAttach": false
  },
  "location": "West US",
  "name": "myDisk"
}

Stavový kód:: 200

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "diskSizeGB": 200,
    "provisioningState": "Succeeded",
    "optimizedForFrequentAttach": false
  },
  "location": "West US",
  "name": "myDisk"
}

Update a managed disk with diskControllerTypes.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "supportedCapabilities": {
      "diskControllerTypes": "SCSI"
    }
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;
import com.azure.resourcemanager.compute.models.SupportedCapabilities;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_AddDiskControllerTypes.json
     */
    /**
     * Sample code: Update a managed disk with diskControllerTypes.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void updateAManagedDiskWithDiskControllerTypes(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withSupportedCapabilities(new SupportedCapabilities().withDiskControllerTypes("SCSI")),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_add_disk_controller_types.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"supportedCapabilities": {"diskControllerTypes": "SCSI"}}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddDiskControllerTypes.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddDiskControllerTypes.json
func ExampleDisksClient_BeginUpdate_updateAManagedDiskWithDiskControllerTypes() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			SupportedCapabilities: &armcompute.SupportedCapabilities{
				DiskControllerTypes: to.Ptr("SCSI"),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("westus"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionFromImage),
	// 			ImageReference: &armcompute.ImageDiskReference{
	// 				ID: to.Ptr("/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/marketplacetestfirstparty/ArtifactTypes/VMImage/Offers/nvme_test_062/Skus/test_sku/Versions/1.0.0"),
	// 			},
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](127),
	// 		HyperVGeneration: to.Ptr(armcompute.HyperVGenerationV1),
	// 		OSType: to.Ptr(armcompute.OperatingSystemTypesWindows),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		SupportedCapabilities: &armcompute.SupportedCapabilities{
	// 			DiskControllerTypes: to.Ptr("SCSI"),
	// 		},
	// 	},
	// 	SKU: &armcompute.DiskSKU{
	// 		Name: to.Ptr(armcompute.DiskStorageAccountTypesStandardLRS),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddDiskControllerTypes.json
 */
async function updateAManagedDiskWithDiskControllerTypes() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = {
    supportedCapabilities: { diskControllerTypes: "SCSI" },
  };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_AddDiskControllerTypes.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    SupportedCapabilities = new SupportedCapabilities
    {
        DiskControllerTypes = "SCSI",
    },
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportedCapabilities": {
      "diskControllerTypes": "SCSI"
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/marketplacetestfirstparty/ArtifactTypes/VMImage/Offers/nvme_test_062/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Updating"
  }
}

Stavový kód:: 200

{
  "name": "myDisk",
  "location": "westus",
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "properties": {
    "osType": "Windows",
    "hyperVGeneration": "V1",
    "supportedCapabilities": {
      "diskControllerTypes": "SCSI"
    },
    "creationData": {
      "createOption": "FromImage",
      "imageReference": {
        "id": "/Subscriptions/{subscription-id}/Providers/Microsoft.Compute/Locations/westus/Publishers/marketplacetestfirstparty/ArtifactTypes/VMImage/Offers/nvme_test_062/Skus/test_sku/Versions/1.0.0"
      }
    },
    "diskSizeGB": 127,
    "provisioningState": "Succeeded"
  }
}

Update managed disk to remove disk access resource association.

Ukázkový požadavek

PATCH https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "networkAccessPolicy": "AllowAll"
  }
}


import com.azure.resourcemanager.compute.models.DiskUpdate;
import com.azure.resourcemanager.compute.models.NetworkAccessPolicy;

/**
 * Samples for Disks Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/
     * Disk_Update_RemoveDiskAccess.json
     */
    /**
     * Sample code: Update managed disk to remove disk access resource association.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        updateManagedDiskToRemoveDiskAccessResourceAssociation(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.virtualMachines().manager().serviceClient().getDisks().update("myResourceGroup", "myDisk",
            new DiskUpdate().withNetworkAccessPolicy(NetworkAccessPolicy.ALLOW_ALL), com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.compute import ComputeManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-compute
# USAGE
    python disk_update_remove_disk_access.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ComputeManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="{subscription-id}",
    )

    response = client.disks.begin_update(
        resource_group_name="myResourceGroup",
        disk_name="myDisk",
        disk={"properties": {"networkAccessPolicy": "AllowAll"}},
    ).result()
    print(response)


# x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_RemoveDiskAccess.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armcompute_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v6"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/069a65e8a6d1a6c0c58d9a9d97610b7103b6e8a5/specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_RemoveDiskAccess.json
func ExampleDisksClient_BeginUpdate_updateManagedDiskToRemoveDiskAccessResourceAssociation() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcompute.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDisksClient().BeginUpdate(ctx, "myResourceGroup", "myDisk", armcompute.DiskUpdate{
		Properties: &armcompute.DiskUpdateProperties{
			NetworkAccessPolicy: to.Ptr(armcompute.NetworkAccessPolicyAllowAll),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Disk = armcompute.Disk{
	// 	Name: to.Ptr("myDisk"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armcompute.DiskProperties{
	// 		CreationData: &armcompute.CreationData{
	// 			CreateOption: to.Ptr(armcompute.DiskCreateOptionEmpty),
	// 		},
	// 		DiskSizeGB: to.Ptr[int32](200),
	// 		NetworkAccessPolicy: to.Ptr(armcompute.NetworkAccessPolicyAllowAll),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { ComputeManagementClient } = require("@azure/arm-compute");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Updates (patches) a disk.
 *
 * @summary Updates (patches) a disk.
 * x-ms-original-file: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_RemoveDiskAccess.json
 */
async function updateManagedDiskToRemoveDiskAccessResourceAssociation() {
  const subscriptionId = process.env["COMPUTE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["COMPUTE_RESOURCE_GROUP"] || "myResourceGroup";
  const diskName = "myDisk";
  const disk = { networkAccessPolicy: "AllowAll" };
  const credential = new DefaultAzureCredential();
  const client = new ComputeManagementClient(credential, subscriptionId);
  const result = await client.disks.beginUpdateAndWait(resourceGroupName, diskName, disk);
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Compute.Models;
using Azure.ResourceManager.Compute;

// Generated from example definition: specification/compute/resource-manager/Microsoft.Compute/DiskRP/stable/2024-03-02/examples/diskExamples/Disk_Update_RemoveDiskAccess.json
// this example is just showing the usage of "Disks_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ManagedDiskResource created on azure
// for more information of creating ManagedDiskResource, please refer to the document of ManagedDiskResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "myResourceGroup";
string diskName = "myDisk";
ResourceIdentifier managedDiskResourceId = ManagedDiskResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, diskName);
ManagedDiskResource managedDisk = client.GetManagedDiskResource(managedDiskResourceId);

// invoke the operation
ManagedDiskPatch patch = new ManagedDiskPatch
{
    NetworkAccessPolicy = NetworkAccessPolicy.AllowAll,
};
ArmOperation<ManagedDiskResource> lro = await managedDisk.UpdateAsync(WaitUntil.Completed, patch);
ManagedDiskResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ManagedDiskData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Ukázková odpověď

Stavový kód:: 202

Location: https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk?api-version=2024-03-02

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "diskSizeGB": 200,
    "provisioningState": "Updating",
    "networkAccessPolicy": "AllowAll"
  },
  "location": "West US",
  "name": "myDisk"
}

Stavový kód:: 200

{
  "properties": {
    "creationData": {
      "createOption": "Empty"
    },
    "diskSizeGB": 200,
    "provisioningState": "Succeeded",
    "networkAccessPolicy": "AllowAll"
  },
  "location": "West US",
  "name": "myDisk"
}

Definice

Name	Description
Architecture	Architektura procesoru podporovaná diskem s operačním systémem
CreationData	Data používaná při vytváření disku
DataAccessAuthMode	Další požadavky na ověřování při exportu nebo nahrání na disk nebo snímek
Disk	Prostředek disku
DiskCreateOption	Tím se vytvoří výčet možných zdrojů vytvoření disku.
DiskSecurityProfile	Obsahuje informace související se zabezpečením prostředku.
DiskSecurityTypes	Určuje typ zabezpečení virtuálního počítače. Platí jenom pro disky s operačním systémem.
DiskSku	Název skladové položky disků. Může to být Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, StandardSSD_ZRS nebo PremiumV2_LRS.
DiskState	Tento výčet vytvoří výčet možného stavu disku.
DiskStorageAccountTypes	Název skladové položky.
DiskUpdate	Prostředek aktualizace disku
Encryption	Nastavení šifrování neaktivních uložených dat pro disk nebo snímek
EncryptionSettingsCollection	Nastavení šifrování disku nebo snímku
EncryptionSettingsElement	Nastavení šifrování pro jeden diskový svazek
EncryptionType	Typ klíče, který se používá k šifrování dat disku.
ExtendedLocation	Komplexní typ rozšířeného umístění.
ExtendedLocationTypes	Typ rozšířeného umístění.
HyperVGeneration	Generace hypervisoru virtuálního počítače. Platí jenom pro disky s operačním systémem.
ImageDiskReference	Zdrojová image použitá k vytvoření disku.
KeyVaultAndKeyReference	Adresa URL klíče služby Key Vault a ID trezoru KeK, KeK je volitelné a pokud se používá k rozbalení šifrovacího klíče.
KeyVaultAndSecretReference	Adresa URL tajného klíče služby Key Vault a ID trezoru šifrovacího klíče
NetworkAccessPolicy	Zásady pro přístup k disku přes síť
OperatingSystemTypes	Typ operačního systému.
PropertyUpdatesInProgress	Vlastnosti disku, na který aktualizace čeká.
ProvisionedBandwidthCopyOption	Pokud je toto pole nastavené na snímku a createOption je CopyStart, snímek se zkopíruje rychleji.
PublicNetworkAccess	Zásady pro řízení exportu na disku
PurchasePlan	Používá se k vytvoření kontextu nákupu jakéhokoli artefaktu třetí strany prostřednictvím MarketPlace.
ShareInfoElement
SourceVault	ID trezoru je ID prostředku Azure Resource Manageru ve formátu /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}.
SupportedCapabilities	Seznam podporovaných funkcí uložených v prostředku disku pro použití virtuálního počítače

Architecture

Architektura procesoru podporovaná diskem s operačním systémem

Name	Typ	Description
Arm64	string
x64	string

CreationData

Data používaná při vytváření disku

Name	Typ	Description
createOption	DiskCreateOption	Tím se vytvoří výčet možných zdrojů vytvoření disku.
elasticSanResourceId	string	Vyžaduje se, pokud je createOption CopyFromSanSnapshot. Toto je ID ARM zdrojového snímku elastického san svazku.
galleryImageReference	ImageDiskReference	Vyžaduje se při vytváření z obrázku galerie. ID/sharedGalleryImageId/communityGalleryImageId imageDiskReference bude ID ARM verze sdílené galerie image, ze které se má vytvořit disk.
imageReference	ImageDiskReference	Informace o zdroji disků pro pir nebo uživatelské image
logicalSectorSize	integer	Velikost logického sektoru v bajtech pro disky Úrovně Ultra Podporované hodnoty jsou 512 ad 4096. Výchozí hodnota je 4096.
performancePlus	boolean	Pokud chcete zvýšit výkon nasazeného disku, nastavte tento příznak na hodnotu true, abyste získali vyšší výkon, viz zde odpovídající cíl výkonu. Tento příznak lze nastavit pouze při vytváření disku a po povolení nelze tento příznak zakázat.
provisionedBandwidthCopySpeed	ProvisionedBandwidthCopyOption	Pokud je toto pole nastavené na snímku a createOption je CopyStart, snímek se zkopíruje rychleji.
securityDataUri	string	Pokud je createOption ImportSecure, jedná se o identifikátor URI objektu blob, který se má importovat do stavu hosta virtuálního počítače.
sourceResourceId	string	Pokud je createOption copy, jedná se o ID ARM zdrojového snímku nebo disku.
sourceUniqueId	string	Pokud je toto pole nastavené, jedná se o jedinečné ID identifikující zdroj tohoto prostředku.
sourceUri	string	Pokud je createOption Import, jedná se o identifikátor URI objektu blob, který se má importovat do spravovaného disku.
storageAccountId	string	Vyžaduje se, pokud je createOption import. Identifikátor Azure Resource Manageru účtu úložiště obsahujícího objekt blob, který se má importovat jako disk.
uploadSizeBytes	integer	Pokud je createOption upload, jedná se o velikost obsahu nahrávání, včetně zápatí virtuálního pevného disku. Tato hodnota by měla být mezi 20972032 (20 MiB + 512 bajtů pro zápatí virtuálního pevného disku) a 35183298347520 bajty (32 TiB + 512 bajtů pro zápatí virtuálního pevného disku).

DataAccessAuthMode

Další požadavky na ověřování při exportu nebo nahrání na disk nebo snímek

Name	Typ	Description
AzureActiveDirectory	string	Při použití adresy URL pro export/nahrání systém zkontroluje, jestli má uživatel identitu v Azure Active Directory a má potřebná oprávnění k exportu a nahrání dat. Projděte si aka.ms/DisksAzureADAuth.
None	string	Při přístupu k adrese URL pro export/nahrání by se neprovádělo žádné další ověřování.

Disk

Prostředek disku

Name	Typ	Description
extendedLocation	ExtendedLocation	Rozšířené umístění, ve kterém se disk vytvoří. Rozšířené umístění nelze změnit.
id	string	ID prostředku
location	string	Umístění prostředku
managedBy	string	Relativní identifikátor URI obsahující ID virtuálního počítače s připojeným diskem.
managedByExtended	string[]	Seznam relativních identifikátorů URI obsahujících ID virtuálních počítačů s připojeným diskem Hodnota maxShares by měla být nastavená na hodnotu větší než jedna pro disky, aby bylo možné je připojit k více virtuálním počítačům.
name	string	Název prostředku
properties.LastOwnershipUpdateTime	string	Čas UTC, kdy došlo k poslední změně stavu vlastnictví disku, tj. čas posledního připojení nebo odpojení disku od virtuálního počítače nebo čas uvolnění nebo spuštění disku.
properties.burstingEnabled	boolean	Nastavte na hodnotu true, aby se umožnilo rozšíření nad rámec zřízeného cíle výkonu disku. Ve výchozím nastavení je shlukování zakázané. Nevztahuje se na disky Úrovně Ultra.
properties.burstingEnabledTime	string	Poslední čas posledního povolení nárazového nárůstu na disku
properties.completionPercent	number	Procento dokončení kopírování na pozadí při vytvoření prostředku prostřednictvím operace CopyStart.
properties.creationData	CreationData	Informace o zdroji disků Po vytvoření disku nelze změnit informace o objektu CreationData.
properties.dataAccessAuthMode	DataAccessAuthMode	Další požadavky na ověřování při exportu nebo nahrání na disk nebo snímek
properties.diskAccessId	string	ID ARM prostředku DiskAccess pro použití privátních koncových bodů na discích
properties.diskIOPSReadOnly	integer	Celkový počet vstupně-výstupních operací za sekundu, které budou povoleny pro všechny virtuální počítače, které připojí sdílený disk jako jen pro čtení. Jedna operace se může přenášet mezi 4k a 256k bajty.
properties.diskIOPSReadWrite	integer	Počet vstupně-výstupních operací za sekundu povolených pro tento disk; lze nastavit pouze pro disky UltraSSD. Jedna operace se může přenášet mezi 4k a 256k bajty.
properties.diskMBpsReadOnly	integer	Celková propustnost (MB/s), která bude povolena pro všechny virtuální počítače, které připojí sdílený disk jako jen pro čtení. MBps znamená miliony bajtů za sekundu - MB zde používá zápis ISO, mocnin 10.
properties.diskMBpsReadWrite	integer	Šířka pásma povolená pro tento disk; lze nastavit pouze pro disky UltraSSD. MBps znamená miliony bajtů za sekundu - MB zde používá zápis ISO, mocnin 10.
properties.diskSizeBytes	integer	Velikost disku v bajtech. Toto pole je jen pro čtení.
properties.diskSizeGB	integer	Pokud je creationData.createOption prázdný, je toto pole povinné a označuje velikost disku, který se má vytvořit. Pokud je toto pole k dispozici pro aktualizace nebo vytvoření s jinými možnostmi, znamená to změnu velikosti. Změna velikosti je povolená jenom v případě, že disk není připojený ke spuštěném virtuálnímu počítači a může zvětšit jenom velikost disku.
properties.diskState	DiskState	Stav disku.
properties.encryption	Encryption	Vlastnost šifrování se dá použít k šifrování neaktivních uložených dat pomocí klíčů spravovaných zákazníkem nebo klíčů spravovaných platformou.
properties.encryptionSettingsCollection	EncryptionSettingsCollection	Kolekce nastavení šifrování používaná pro Službu Azure Disk Encryption může obsahovat více nastavení šifrování na disk nebo snímek.
properties.hyperVGeneration	HyperVGeneration	Generace hypervisoru virtuálního počítače. Platí jenom pro disky s operačním systémem.
properties.maxShares	integer	Maximální počet virtuálních počítačů, které se můžou připojit k disku najednou. Hodnota větší než jedna označuje disk, který lze připojit na více virtuálních počítačů současně.
properties.networkAccessPolicy	NetworkAccessPolicy	Zásady pro přístup k disku přes síť
properties.optimizedForFrequentAttach	boolean	Nastavení této vlastnosti na true zlepšuje spolehlivost a výkon datových disků, které jsou často (více než 5krát denně) odpojením od jednoho virtuálního počítače a připojenými k jinému. Tato vlastnost by neměla být nastavená pro disky, které nejsou odpojené a připojené často, protože to způsobí, že disky nebudou v souladu s doménou selhání virtuálního počítače.
properties.osType	OperatingSystemTypes	Typ operačního systému.
properties.propertyUpdatesInProgress	PropertyUpdatesInProgress	Vlastnosti disku, na který aktualizace čeká.
properties.provisioningState	string	Stav zřizování disků.
properties.publicNetworkAccess	PublicNetworkAccess	Zásady pro řízení exportu na disku
properties.purchasePlan	PurchasePlan	Informace o plánu nákupu pro image, ze které byl disk s operačním systémem vytvořen. Příklad: {name: 2019-Datacenter, vydavatel: MicrosoftWindowsServer, produkt: WindowsServer}
properties.securityProfile	DiskSecurityProfile	Obsahuje informace související se zabezpečením prostředku.
properties.shareInfo	ShareInfoElement[]	Podrobnosti o seznamu všech virtuálních počítačů, které mají připojený disk. Hodnota maxShares by měla být nastavená na hodnotu větší než jedna pro disky, aby bylo možné je připojit k více virtuálním počítačům.
properties.supportedCapabilities	SupportedCapabilities	Seznam podporovaných funkcí pro image, ze které byl disk s operačním systémem vytvořen.
properties.supportsHibernation	boolean	Označuje operační systém na disku, který podporuje hibernaci.
properties.tier	string	Úroveň výkonu disku (např. P4, S10), jak je popsáno zde: https://azure.microsoft.com/en-us/pricing/details/managed-disks/. Nevztahuje se na disky Úrovně Ultra.
properties.timeCreated	string	Čas vytvoření disku
properties.uniqueId	string	Jedinečný identifikátor GUID identifikující prostředek
sku	DiskSku	Název skladové položky disků. Může to být Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, StandardSSD_ZRS nebo PremiumV2_LRS.
tags	object	Značky prostředků
type	string	Typ prostředku
zones	string[]	Seznam logických zón pro disk.

DiskCreateOption

Tím se vytvoří výčet možných zdrojů vytvoření disku.

Name	Typ	Description
Attach	string	Disk se připojí k virtuálnímu počítači.
Copy	string	Vytvořte nový disk nebo snímek zkopírováním z disku nebo snímku určeného danou hodnotou sourceResourceId.
CopyFromSanSnapshot	string	Vytvoření nového disku exportem ze snímku elastického san svazku
CopyStart	string	Vytvořte nový disk pomocí procesu hloubkové kopie, kde se vytvoření prostředku považuje za dokončené až po zkopírování všech dat ze zdroje.
Empty	string	Vytvořte prázdný datový disk s velikostí danou diskSizeGB.
FromImage	string	Vytvořte nový disk z image platformy určené danou imageReference nebo galleryImageReference.
Import	string	Vytvořte disk importem z objektu blob určeného identifikátorem sourceUri v účtu úložiště určeném hodnotou storageAccountId.
ImportSecure	string	Podobá se možnosti Vytvořit import. Vytvoření nového disku podporovaného důvěryhodným spouštěcím virtuálním počítačem nebo disku podporovaného důvěrným virtuálním počítačem importem dalšího objektu blob pro stav hosta virtuálního počítače určeného identifikátorem securityDataUri v účtu úložiště určeném hodnotou storageAccountId
Restore	string	Vytvořte nový disk zkopírováním z bodu obnovení zálohy.
Upload	string	Vytvořte nový disk získáním tokenu zápisu a jeho použitím k přímému nahrání obsahu disku.
UploadPreparedSecure	string	Podobně jako možnost Nahrát vytvořit. Vytvořte nový podporovaný disk s důvěryhodným spouštěcím virtuálním počítačem nebo důvěrný disk a nahrajte ho pomocí tokenu zápisu ve stavu hosta disku i virtuálního počítače.

DiskSecurityProfile

Obsahuje informace související se zabezpečením prostředku.

Name	Typ	Description
secureVMDiskEncryptionSetId	string	ResourceId sady šifrování disku přidružené k disku podporovanému důvěrnému virtuálnímu počítači šifrovaného pomocí klíče spravovaného zákazníkem
securityType	DiskSecurityTypes	Určuje typ zabezpečení virtuálního počítače. Platí jenom pro disky s operačním systémem.

DiskSecurityTypes

Určuje typ zabezpečení virtuálního počítače. Platí jenom pro disky s operačním systémem.

Name	Typ	Description
ConfidentialVM_DiskEncryptedWithCustomerKey	string	Označuje důvěrný disk virtuálního počítače s diskem s operačním systémem i stavem hosta virtuálního počítače šifrovaným pomocí klíče spravovaného zákazníkem.
ConfidentialVM_DiskEncryptedWithPlatformKey	string	Označuje důvěrný disk virtuálního počítače s diskem s operačním systémem i stavem hosta virtuálního počítače šifrovaným pomocí klíče spravovaného platformou.
ConfidentialVM_NonPersistedTPM	string	Označuje důvěrný disk virtuálního počítače dočasným virtuálním heslem. Stav virtuálního počítače vTPM se při restartování virtuálního počítače neuchová.
ConfidentialVM_VMGuestStateOnlyEncryptedWithPlatformKey	string	Označuje důvěrný disk virtuálního počítače, který má šifrovaný pouze stav hosta virtuálního počítače.
TrustedLaunch	string	Trusted Launch poskytuje funkce zabezpečení, jako je zabezpečené spouštění a virtuální čip Trusted Platform Module (vTPM).

DiskSku

Název skladové položky disků. Může to být Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, StandardSSD_ZRS nebo PremiumV2_LRS.

Name	Typ	Description
name	DiskStorageAccountTypes	Název skladové položky.
tier	string	Úroveň skladové položky.

DiskState

Tento výčet vytvoří výčet možného stavu disku.

Name	Typ	Description
ActiveSAS	string	K disku je aktuálně přidružený aktivní identifikátor URI SAS.
ActiveSASFrozen	string	Disk je připojený k virtuálnímu počítači ve stavu hibernace a má k němu přidružený aktivní identifikátor URI SAS.
ActiveUpload	string	Vytvoří se disk pro nahrání a pro nahrání se vystavil token pro zápis.
Attached	string	Disk je aktuálně připojený ke spuštěném virtuálnímu počítači.
Frozen	string	Disk je připojený k virtuálnímu počítači, který je ve stavu hibernace.
ReadyToUpload	string	Disk je připravený k vytvoření odesláním vyžádáním tokenu zápisu.
Reserved	string	Disk je připojený k zastaveným uvolněným virtuálním počítačům.
Unattached	string	Disk se nepoužívá a je možné ho připojit k virtuálnímu počítači.

DiskStorageAccountTypes

Název skladové položky.

Name	Typ	Description
PremiumV2_LRS	string	Místně redundantní úložiště SSD úrovně Premium v2 Nejvhodnější pro úlohy citlivé na produkční a výkon, které konzistentně vyžadují nízkou latenci a vysokou IOPS a propustnost.
Premium_LRS	string	Místně redundantní úložiště SSD úrovně Premium. Nejvhodnější pro produkční a výkonově citlivé úlohy.
Premium_ZRS	string	Zónově redundantní úložiště SSD úrovně Premium. Nejvhodnější pro produkční úlohy, které potřebují odolnost úložiště proti selháním zóny.
StandardSSD_LRS	string	Místně redundantní úložiště SSD úrovně Standard Nejvhodnější pro webové servery, mírně používané podnikové aplikace a vývoj/testování.
StandardSSD_ZRS	string	Zónově redundantní úložiště SSD úrovně Standard. Nejvhodnější pro webové servery, mírně používané podnikové aplikace a vývoj/testování, které potřebují odolnost úložiště proti selháním zón.
Standard_LRS	string	Místně redundantní úložiště HDD úrovně Standard. Nejvhodnější pro zálohování, nekritický a občasný přístup.
UltraSSD_LRS	string	Místně redundantní úložiště SSD úrovně Ultra Nejvhodnější pro úlohy náročné na vstupně-výstupní operace, jako jsou SAP HANA, databáze nejvyšší úrovně (například SQL, Oracle) a další úlohy náročné na transakce.

DiskUpdate

Prostředek aktualizace disku

Name	Typ	Description
properties.burstingEnabled	boolean	Nastavte na hodnotu true, aby se umožnilo rozšíření nad rámec zřízeného cíle výkonu disku. Ve výchozím nastavení je shlukování zakázané. Nevztahuje se na disky Úrovně Ultra.
properties.dataAccessAuthMode	DataAccessAuthMode	Další požadavky na ověřování při exportu nebo nahrání na disk nebo snímek
properties.diskAccessId	string	ID ARM prostředku DiskAccess pro použití privátních koncových bodů na discích
properties.diskIOPSReadOnly	integer	Celkový počet vstupně-výstupních operací za sekundu, které budou povoleny pro všechny virtuální počítače, které připojí sdílený disk jako jen pro čtení. Jedna operace se může přenášet mezi 4k a 256k bajty.
properties.diskIOPSReadWrite	integer	Počet vstupně-výstupních operací za sekundu povolených pro tento disk; lze nastavit pouze pro disky UltraSSD. Jedna operace se může přenášet mezi 4k a 256k bajty.
properties.diskMBpsReadOnly	integer	Celková propustnost (MB/s), která bude povolena pro všechny virtuální počítače, které připojí sdílený disk jako jen pro čtení. MBps znamená miliony bajtů za sekundu - MB zde používá zápis ISO, mocnin 10.
properties.diskMBpsReadWrite	integer	Šířka pásma povolená pro tento disk; lze nastavit pouze pro disky UltraSSD. MBps znamená miliony bajtů za sekundu - MB zde používá zápis ISO, mocnin 10.
properties.diskSizeGB	integer	Pokud je creationData.createOption prázdný, je toto pole povinné a označuje velikost disku, který se má vytvořit. Pokud je toto pole k dispozici pro aktualizace nebo vytvoření s jinými možnostmi, znamená to změnu velikosti. Změna velikosti je povolená jenom v případě, že disk není připojený ke spuštěném virtuálnímu počítači a může zvětšit jenom velikost disku.
properties.encryption	Encryption	Vlastnost šifrování se dá použít k šifrování neaktivních uložených dat pomocí klíčů spravovaných zákazníkem nebo klíčů spravovaných platformou.
properties.encryptionSettingsCollection	EncryptionSettingsCollection	Kolekce nastavení šifrování použitá jako Azure Disk Encryption může obsahovat více nastavení šifrování na disk nebo snímek.
properties.maxShares	integer	Maximální počet virtuálních počítačů, které se můžou připojit k disku najednou. Hodnota větší než jedna označuje disk, který lze připojit na více virtuálních počítačů současně.
properties.networkAccessPolicy	NetworkAccessPolicy	Zásady pro přístup k disku přes síť
properties.optimizedForFrequentAttach	boolean	Nastavení této vlastnosti na true zlepšuje spolehlivost a výkon datových disků, které jsou často (více než 5krát denně) odpojením od jednoho virtuálního počítače a připojenými k jinému. Tato vlastnost by neměla být nastavená pro disky, které nejsou odpojené a připojené často, protože to způsobí, že disky nebudou v souladu s doménou selhání virtuálního počítače.
properties.osType	OperatingSystemTypes	typ operačního systému.
properties.propertyUpdatesInProgress	PropertyUpdatesInProgress	Vlastnosti disku, na který aktualizace čeká.
properties.publicNetworkAccess	PublicNetworkAccess	Zásady pro řízení exportu na disku
properties.purchasePlan	PurchasePlan	Informace o nákupním plánu, které se mají přidat na disk s operačním systémem
properties.supportedCapabilities	SupportedCapabilities	Seznam podporovaných možností, které se mají přidat na disk s operačním systémem
properties.supportsHibernation	boolean	Označuje operační systém na disku, který podporuje hibernaci.
properties.tier	string	Úroveň výkonu disku (např. P4, S10), jak je popsáno zde: https://azure.microsoft.com/en-us/pricing/details/managed-disks/. Nevztahuje se na disky Úrovně Ultra.
sku	DiskSku	Název skladové položky disků. Může to být Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, StandardSSD_ZRS nebo PremiumV2_LRS.
tags	object	Značky prostředků

Encryption

Nastavení šifrování neaktivních uložených dat pro disk nebo snímek

Name	Typ	Description
diskEncryptionSetId	string	ResourceId šifrování disku nastavené pro povolení šifrování neaktivních uložených dat
type	EncryptionType	Typ klíče, který se používá k šifrování dat disku.

EncryptionSettingsCollection

Nastavení šifrování disku nebo snímku

Name	Typ	Description
enabled	boolean	Nastavte tento příznak na true a zadejte DiskEncryptionKey a volitelný KeyEncryptionKey pro povolení šifrování. Nastavte tento příznak na false a odeberte DiskEncryptionKey a KeyEncryptionKey pro zakázání šifrování. Pokud je parametr EncryptionSettings v objektu požadavku null, stávající nastavení zůstanou beze změny.
encryptionSettings	EncryptionSettingsElement[]	Kolekce nastavení šifrování, jedno pro každý svazek disku.
encryptionSettingsVersion	string	Popisuje, jaký typ šifrování se používá pro disky. Jakmile je toto pole nastavené, nelze ho přepsat. Hodnota 1.0 odpovídá službě Azure Disk Encryption s aplikací AAD.'1.1' odpovídá službě Azure Disk Encryption.

EncryptionSettingsElement

Nastavení šifrování pro jeden diskový svazek

Name	Typ	Description
diskEncryptionKey	KeyVaultAndSecretReference	Adresa URL tajného klíče služby Key Vault a ID trezoru šifrovacího klíče disku
keyEncryptionKey	KeyVaultAndKeyReference	Adresa URL klíče služby Key Vault a ID trezoru šifrovacího klíče. KeyEncryptionKey je volitelný a pokud se používá k rozbalení šifrovacího klíče disku.

EncryptionType

Typ klíče, který se používá k šifrování dat disku.

Name	Typ	Description
EncryptionAtRestWithCustomerKey	string	Neaktivní uložený disk se šifruje pomocí klíče spravovaného zákazníkem, který může zákazník změnit a odvolat.
EncryptionAtRestWithPlatformAndCustomerKeys	string	Neaktivní uložený disk je šifrovaný se 2 vrstvami šifrování. Jeden z klíčů je spravovaný zákazníkem a druhý klíč je spravovaný platformou.
EncryptionAtRestWithPlatformKey	string	Neaktivní uložený disk je šifrovaný pomocí spravovaného klíče platformy. Jedná se o výchozí typ šifrování. Toto není platný typ šifrování pro sady šifrování disků.

ExtendedLocation

Komplexní typ rozšířeného umístění.

Name	Typ	Description
name	string	Název rozšířeného umístění.
type	ExtendedLocationTypes	Typ rozšířeného umístění.

ExtendedLocationTypes

Typ rozšířeného umístění.

Name	Typ	Description
EdgeZone	string

HyperVGeneration

Generace hypervisoru virtuálního počítače. Platí jenom pro disky s operačním systémem.

Name	Typ	Description
V1	string
V2	string

ImageDiskReference

Zdrojová image použitá k vytvoření disku.

Name	Typ	Description
communityGalleryImageId	string	Relativní identifikátor URI, který obsahuje referenční informace ke komunitní galerii výpočetních prostředků Azure.
id	string	Relativní identifikátor URI obsahující buď úložiště imagí platformy, image uživatele nebo referenční informace k imagi galerie výpočetních prostředků Azure.
lun	integer	Pokud se disk vytvoří z datového disku image, jedná se o index, který označuje, které datové disky v imagi použít. Pro disky s operačním systémem má toto pole hodnotu null.
sharedGalleryImageId	string	Relativní identifikátor URI obsahující přímý sdílený odkaz na image galerie výpočetních prostředků Azure.

KeyVaultAndKeyReference

Adresa URL klíče služby Key Vault a ID trezoru KeK, KeK je volitelné a pokud se používá k rozbalení šifrovacího klíče.

Name	Typ	Description
keyUrl	string	Adresa URL odkazující na klíč nebo tajný klíč ve službě KeyVault
sourceVault	SourceVault	ID prostředku služby KeyVault obsahující klíč nebo tajný klíč

KeyVaultAndSecretReference

Adresa URL tajného klíče služby Key Vault a ID trezoru šifrovacího klíče

Name	Typ	Description
secretUrl	string	Adresa URL odkazující na klíč nebo tajný klíč ve službě KeyVault
sourceVault	SourceVault	ID prostředku služby KeyVault obsahující klíč nebo tajný klíč

NetworkAccessPolicy

Zásady pro přístup k disku přes síť

Name	Typ	Description
AllowAll	string	Disk je možné exportovat nebo nahrát z libovolné sítě.
AllowPrivate	string	Disk je možné exportovat nebo nahrát do privátních koncových bodů prostředku DiskAccess.
DenyAll	string	Disk nelze exportovat.

OperatingSystemTypes

Typ operačního systému.

Name	Typ	Description
Linux	string
Windows	string

PropertyUpdatesInProgress

Vlastnosti disku, na který aktualizace čeká.

Name	Typ	Description
targetTier	string	Cílová úroveň výkonu disku, pokud probíhá operace změny vrstvy.

ProvisionedBandwidthCopyOption

Pokud je toto pole nastavené na snímku a createOption je CopyStart, snímek se zkopíruje rychleji.

Name	Typ	Description
Enhanced	string
None	string

PublicNetworkAccess

Zásady pro řízení exportu na disku

Name	Typ	Description
Disabled	string	K podkladovým datům disku nelze přistupovat veřejně na internetu, i když je NetworkAccessPolicy nastavená na AllowAll. K datům můžete přistupovat prostřednictvím identifikátoru URI SAS pouze z důvěryhodné virtuální sítě Azure, pokud je networkAccessPolicy nastavená na AllowPrivate.
Enabled	string	Identifikátor URI SAS můžete vygenerovat pro přístup k podkladovým datům disku veřejně na internetu, když je networkAccessPolicy nastavená na AllowAll. K datům můžete přistupovat prostřednictvím identifikátoru URI SAS pouze z důvěryhodné virtuální sítě Azure, pokud je networkAccessPolicy nastavená na AllowPrivate.

PurchasePlan

Používá se k vytvoření kontextu nákupu jakéhokoli artefaktu třetí strany prostřednictvím MarketPlace.

Name	Typ	Description
name	string	ID plánu.
product	string	Určuje produkt image z marketplace. Jedná se o stejnou hodnotu jako Offer pod elementem imageReference.
promotionCode	string	Kód zvýšení úrovně nabídky.
publisher	string	ID vydavatele.

ShareInfoElement

Name	Typ	Description
vmUri	string	Relativní identifikátor URI obsahující ID virtuálního počítače s připojeným diskem.

SourceVault

ID trezoru je ID prostředku Azure Resource Manageru ve formátu /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}.

Name	Typ	Description
id	string	ID prostředku

SupportedCapabilities

Seznam podporovaných funkcí uložených v prostředku disku pro použití virtuálního počítače

Name	Typ	Description
acceleratedNetwork	boolean	Hodnota True, pokud image, ze které je disk s operačním systémem vytvořen, podporuje akcelerované síťové služby.
architecture	Architecture	Architektura procesoru podporovaná diskem s operačním systémem
diskControllerTypes	string	Řadiče disků, které disk s operačním systémem podporuje. Pokud ji nastavíte, může to být SCSI nebo SCSI, NVME nebo NVME, SCSI.

Sdílet prostřednictvím

Disks - Update

Parametry identifikátoru URI

Text požadavku

Odpovědi

Zabezpečení

azure_auth

Rozsahy

Příklady

Create or update a bursting enabled managed disk.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to add accelerated networking.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to add architecture.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to add purchase plan.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to add supportsHibernation.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to change tier.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to disable bursting.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk to disable optimizedForFrequentAttach.

Ukázkový požadavek

Ukázková odpověď

Update a managed disk with diskControllerTypes.

Ukázkový požadavek

Ukázková odpověď

Update managed disk to remove disk access resource association.

Ukázkový požadavek

Ukázková odpověď

Definice

Architecture

CreationData

DataAccessAuthMode

Disk

DiskCreateOption

DiskSecurityProfile

DiskSecurityTypes

DiskSku

DiskState

DiskStorageAccountTypes

DiskUpdate

Encryption

EncryptionSettingsCollection

EncryptionSettingsElement

EncryptionType

ExtendedLocation

ExtendedLocationTypes

HyperVGeneration

ImageDiskReference

KeyVaultAndKeyReference

KeyVaultAndSecretReference

NetworkAccessPolicy

OperatingSystemTypes

PropertyUpdatesInProgress

ProvisionedBandwidthCopyOption

PublicNetworkAccess

PurchasePlan

ShareInfoElement

SourceVault

SupportedCapabilities

Další materiály