Opération qui récupère des informations sur la réservation de capacité.
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}/capacityReservations/{capacityReservationName}?api-version=2026-04-01
Avec des paramètres facultatifs:
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}/capacityReservations/{capacityReservationName}?api-version=2026-04-01&$expand=instanceView
Paramètres URI
| Nom |
Dans |
Obligatoire |
Type |
Description |
|
capacityReservationGroupName
|
path |
True
|
string
|
Nom du groupe de réservations de capacité.
|
|
capacityReservationName
|
path |
True
|
string
|
Nom de la réservation de capacité.
|
|
resourceGroupName
|
path |
True
|
string
minLength: 1 maxLength: 90
|
Nom du groupe de ressources. Le nom ne respecte pas la casse.
|
|
subscriptionId
|
path |
True
|
string
minLength: 1
|
ID de l’abonnement cible.
|
|
api-version
|
query |
True
|
string
minLength: 1
|
Version de l’API à utiliser pour cette opération.
|
|
$expand
|
query |
|
CapacityReservationInstanceViewTypes
|
Expression de développement à appliquer à l’opération. « InstanceView » récupère un instantané des propriétés d’exécution de la réservation de capacité gérée par la plateforme et peut changer en dehors des opérations du plan de contrôle.
|
Réponses
Sécurité
azure_auth
Flux OAuth2 d’Azure Active Directory.
Type:
oauth2
Flux:
implicit
URL d’autorisation:
https://login.microsoftonline.com/common/oauth2/authorize
Étendues
| Nom |
Description |
|
user_impersonation
|
Usurper l’identité de votre compte utilisateur
|
Exemples
Get a block capacity reservation.
Exemple de requête
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/blockCapacityReservationGroup/capacityReservations/blockCapacityReservation?api-version=2026-04-01&$expand=instanceView
import com.azure.resourcemanager.compute.models.CapacityReservationInstanceViewTypes;
/**
* Samples for CapacityReservations Get.
*/
public final class Main {
/*
* x-ms-original-file: 2026-04-01/capacityReservationExamples/BlockCapacityReservation_Get.json
*/
/**
* Sample code: Get a block capacity reservation.
*
* @param manager Entry point to ComputeManager.
*/
public static void getABlockCapacityReservation(com.azure.resourcemanager.compute.ComputeManager manager) {
manager.serviceClient().getCapacityReservations().getWithResponse("myResourceGroup",
"blockCapacityReservationGroup", "blockCapacityReservation",
CapacityReservationInstanceViewTypes.INSTANCE_VIEW, 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 azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-compute
# USAGE
python block_capacity_reservation_get.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.capacity_reservations.get(
resource_group_name="myResourceGroup",
capacity_reservation_group_name="blockCapacityReservationGroup",
capacity_reservation_name="blockCapacityReservation",
)
print(response)
# x-ms-original-file: 2026-04-01/capacityReservationExamples/BlockCapacityReservation_Get.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/v8"
)
// Generated from example definition: 2026-04-01/capacityReservationExamples/BlockCapacityReservation_Get.json
func ExampleCapacityReservationsClient_Get_getABlockCapacityReservation() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcompute.NewClientFactory("{subscriptionId}", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCapacityReservationsClient().Get(ctx, "myResourceGroup", "blockCapacityReservationGroup", "blockCapacityReservation", &armcompute.CapacityReservationsClientGetOptions{
Expand: to.Ptr(armcompute.CapacityReservationInstanceViewTypesInstanceView)})
if err != nil {
log.Fatalf("failed to finish the request: %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 = armcompute.CapacityReservationsClientGetResponse{
// CapacityReservation: armcompute.CapacityReservation{
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/blockCapacityReservationGroup/capacityReservations/blockCapacityReservation"),
// Properties: &armcompute.CapacityReservationProperties{
// PlatformFaultDomainCount: to.Ptr[int32](3),
// ReservationID: to.Ptr("{GUID}"),
// ProvisioningTime: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// VirtualMachinesAssociated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"),
// },
// },
// ProvisioningState: to.Ptr("Succeeded"),
// InstanceView: &armcompute.CapacityReservationInstanceView{
// UtilizationInfo: &armcompute.CapacityReservationUtilization{
// CurrentCapacity: to.Ptr[int32](5),
// VirtualMachinesAllocated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// },
// },
// Statuses: []*armcompute.InstanceViewStatus{
// {
// Code: to.Ptr("ProvisioningState/succeeded"),
// Level: to.Ptr(armcompute.StatusLevelTypesInfo),
// DisplayStatus: to.Ptr("Provisioning succeeded"),
// },
// },
// },
// ScheduleProfile: &armcompute.ScheduleProfile{
// Start: to.Ptr("2025-08-01T12:00:00Z"),
// End: to.Ptr("2025-08-02T11:30:00Z"),
// },
// TimeCreated: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// },
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "department": to.Ptr("HR"),
// },
// SKU: &armcompute.SKU{
// Name: to.Ptr("Standard_ND96isr_H100_v5"),
// Capacity: to.Ptr[int64](1),
// },
// Zones: []*string{
// to.Ptr("1"),
// },
// Name: to.Ptr("blockCapacityReservation"),
// },
// }
}
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 the operation that retrieves information about the capacity reservation.
*
* @summary the operation that retrieves information about the capacity reservation.
* x-ms-original-file: 2026-04-01/capacityReservationExamples/BlockCapacityReservation_Get.json
*/
async function getABlockCapacityReservation() {
const credential = new DefaultAzureCredential();
const subscriptionId = "{subscriptionId}";
const client = new ComputeManagementClient(credential, subscriptionId);
const result = await client.capacityReservations.get(
"myResourceGroup",
"blockCapacityReservationGroup",
"blockCapacityReservation",
{ expand: "instanceView" },
);
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
Exemple de réponse
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/blockCapacityReservationGroup/capacityReservations/blockCapacityReservation",
"properties": {
"platformFaultDomainCount": 3,
"reservationId": "{GUID}",
"provisioningTime": "2021-06-27T01:02:38.3138469+00:00",
"virtualMachinesAssociated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"
}
],
"provisioningState": "Succeeded",
"instanceView": {
"utilizationInfo": {
"currentCapacity": 5,
"virtualMachinesAllocated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
}
]
},
"statuses": [
{
"code": "ProvisioningState/succeeded",
"level": "Info",
"displayStatus": "Provisioning succeeded"
}
]
},
"scheduleProfile": {
"start": "2025-08-01T12:00:00Z",
"end": "2025-08-02T11:30:00Z"
},
"timeCreated": "2021-06-27T01:02:38.3138469+00:00"
},
"location": "westus",
"tags": {
"department": "HR"
},
"sku": {
"name": "Standard_ND96isr_H100_v5",
"capacity": 1
},
"zones": [
"1"
],
"name": "blockCapacityReservation"
}
Get a capacity reservation.
Exemple de requête
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/myCapacityReservationGroup/capacityReservations/myCapacityReservation?api-version=2026-04-01&$expand=instanceView
import com.azure.resourcemanager.compute.models.CapacityReservationInstanceViewTypes;
/**
* Samples for CapacityReservations Get.
*/
public final class Main {
/*
* x-ms-original-file: 2026-04-01/capacityReservationExamples/CapacityReservation_Get.json
*/
/**
* Sample code: Get a capacity reservation.
*
* @param manager Entry point to ComputeManager.
*/
public static void getACapacityReservation(com.azure.resourcemanager.compute.ComputeManager manager) {
manager.serviceClient().getCapacityReservations().getWithResponse("myResourceGroup",
"myCapacityReservationGroup", "myCapacityReservation", CapacityReservationInstanceViewTypes.INSTANCE_VIEW,
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 azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-compute
# USAGE
python capacity_reservation_get.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.capacity_reservations.get(
resource_group_name="myResourceGroup",
capacity_reservation_group_name="myCapacityReservationGroup",
capacity_reservation_name="myCapacityReservation",
)
print(response)
# x-ms-original-file: 2026-04-01/capacityReservationExamples/CapacityReservation_Get.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/v8"
)
// Generated from example definition: 2026-04-01/capacityReservationExamples/CapacityReservation_Get.json
func ExampleCapacityReservationsClient_Get_getACapacityReservation() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcompute.NewClientFactory("{subscriptionId}", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCapacityReservationsClient().Get(ctx, "myResourceGroup", "myCapacityReservationGroup", "myCapacityReservation", &armcompute.CapacityReservationsClientGetOptions{
Expand: to.Ptr(armcompute.CapacityReservationInstanceViewTypesInstanceView)})
if err != nil {
log.Fatalf("failed to finish the request: %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 = armcompute.CapacityReservationsClientGetResponse{
// CapacityReservation: armcompute.CapacityReservation{
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/myCapacityReservationGroup/capacityReservations/myCapacityReservation"),
// Properties: &armcompute.CapacityReservationProperties{
// PlatformFaultDomainCount: to.Ptr[int32](3),
// ReservationID: to.Ptr("{GUID}"),
// ProvisioningTime: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// VirtualMachinesAssociated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"),
// },
// },
// ProvisioningState: to.Ptr("Succeeded"),
// InstanceView: &armcompute.CapacityReservationInstanceView{
// UtilizationInfo: &armcompute.CapacityReservationUtilization{
// CurrentCapacity: to.Ptr[int32](5),
// VirtualMachinesAllocated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// },
// },
// Statuses: []*armcompute.InstanceViewStatus{
// {
// Code: to.Ptr("ProvisioningState/succeeded"),
// Level: to.Ptr(armcompute.StatusLevelTypesInfo),
// DisplayStatus: to.Ptr("Provisioning succeeded"),
// },
// },
// },
// TimeCreated: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// },
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "department": to.Ptr("HR"),
// },
// SKU: &armcompute.SKU{
// Name: to.Ptr("Standard_DS1_v2"),
// Capacity: to.Ptr[int64](4),
// },
// Zones: []*string{
// to.Ptr("1"),
// },
// Name: to.Ptr("myCapacityReservation"),
// },
// }
}
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 the operation that retrieves information about the capacity reservation.
*
* @summary the operation that retrieves information about the capacity reservation.
* x-ms-original-file: 2026-04-01/capacityReservationExamples/CapacityReservation_Get.json
*/
async function getACapacityReservation() {
const credential = new DefaultAzureCredential();
const subscriptionId = "{subscriptionId}";
const client = new ComputeManagementClient(credential, subscriptionId);
const result = await client.capacityReservations.get(
"myResourceGroup",
"myCapacityReservationGroup",
"myCapacityReservation",
{ expand: "instanceView" },
);
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
Exemple de réponse
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/myCapacityReservationGroup/capacityReservations/myCapacityReservation",
"properties": {
"platformFaultDomainCount": 3,
"reservationId": "{GUID}",
"provisioningTime": "2021-06-27T01:02:38.3138469+00:00",
"virtualMachinesAssociated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"
}
],
"provisioningState": "Succeeded",
"instanceView": {
"utilizationInfo": {
"currentCapacity": 5,
"virtualMachinesAllocated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
}
]
},
"statuses": [
{
"code": "ProvisioningState/succeeded",
"level": "Info",
"displayStatus": "Provisioning succeeded"
}
]
},
"timeCreated": "2021-06-27T01:02:38.3138469+00:00"
},
"location": "westus",
"tags": {
"department": "HR"
},
"sku": {
"name": "Standard_DS1_v2",
"capacity": 4
},
"zones": [
"1"
],
"name": "myCapacityReservation"
}
Get a Future capacity reservation.
Exemple de requête
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/futureCapacityReservationGroup/capacityReservations/futureCapacityReservation?api-version=2026-04-01&$expand=instanceView
import com.azure.resourcemanager.compute.models.CapacityReservationInstanceViewTypes;
/**
* Samples for CapacityReservations Get.
*/
public final class Main {
/*
* x-ms-original-file: 2026-04-01/capacityReservationExamples/FutureCapacityReservation_Get.json
*/
/**
* Sample code: Get a Future capacity reservation.
*
* @param manager Entry point to ComputeManager.
*/
public static void getAFutureCapacityReservation(com.azure.resourcemanager.compute.ComputeManager manager) {
manager.serviceClient().getCapacityReservations().getWithResponse("myResourceGroup",
"futureCapacityReservationGroup", "futureCapacityReservation",
CapacityReservationInstanceViewTypes.INSTANCE_VIEW, 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 azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-compute
# USAGE
python future_capacity_reservation_get.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.capacity_reservations.get(
resource_group_name="myResourceGroup",
capacity_reservation_group_name="futureCapacityReservationGroup",
capacity_reservation_name="futureCapacityReservation",
)
print(response)
# x-ms-original-file: 2026-04-01/capacityReservationExamples/FutureCapacityReservation_Get.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/v8"
)
// Generated from example definition: 2026-04-01/capacityReservationExamples/FutureCapacityReservation_Get.json
func ExampleCapacityReservationsClient_Get_getAFutureCapacityReservation() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcompute.NewClientFactory("{subscriptionId}", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCapacityReservationsClient().Get(ctx, "myResourceGroup", "futureCapacityReservationGroup", "futureCapacityReservation", &armcompute.CapacityReservationsClientGetOptions{
Expand: to.Ptr(armcompute.CapacityReservationInstanceViewTypesInstanceView)})
if err != nil {
log.Fatalf("failed to finish the request: %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 = armcompute.CapacityReservationsClientGetResponse{
// CapacityReservation: armcompute.CapacityReservation{
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/futureCapacityReservationGroup/capacityReservations/futureCapacityReservation"),
// Properties: &armcompute.CapacityReservationProperties{
// PlatformFaultDomainCount: to.Ptr[int32](3),
// ReservationID: to.Ptr("{GUID}"),
// ProvisioningTime: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// VirtualMachinesAssociated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"),
// },
// },
// ProvisioningState: to.Ptr("Succeeded"),
// InstanceView: &armcompute.CapacityReservationInstanceView{
// UtilizationInfo: &armcompute.CapacityReservationUtilization{
// CurrentCapacity: to.Ptr[int32](4),
// VirtualMachinesAllocated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// },
// },
// Statuses: []*armcompute.InstanceViewStatus{
// {
// Code: to.Ptr("ProvisioningState/succeeded"),
// Level: to.Ptr(armcompute.StatusLevelTypesInfo),
// DisplayStatus: to.Ptr("Provisioning succeeded"),
// },
// },
// ReservationStateInfo: &armcompute.CapacityReservationStateInfo{
// ReservationState: to.Ptr(armcompute.ReservationStateLive),
// },
// },
// ScheduleProfile: &armcompute.ScheduleProfile{
// Start: to.Ptr("2026-08-01T12:00:00Z"),
// MinimumCommitmentDays: to.Ptr[int32](30),
// ModifiableUntil: to.Ptr(time.Date(2026, time.June, 6, 12, 0, 0, 0, time.UTC)),
// },
// TimeCreated: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// },
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "department": to.Ptr("HR"),
// },
// SKU: &armcompute.SKU{
// Name: to.Ptr("Standard_DS1_v2"),
// Capacity: to.Ptr[int64](4),
// },
// Zones: []*string{
// to.Ptr("1"),
// },
// Name: to.Ptr("futureCapacityReservation"),
// },
// }
}
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 the operation that retrieves information about the capacity reservation.
*
* @summary the operation that retrieves information about the capacity reservation.
* x-ms-original-file: 2026-04-01/capacityReservationExamples/FutureCapacityReservation_Get.json
*/
async function getAFutureCapacityReservation() {
const credential = new DefaultAzureCredential();
const subscriptionId = "{subscriptionId}";
const client = new ComputeManagementClient(credential, subscriptionId);
const result = await client.capacityReservations.get(
"myResourceGroup",
"futureCapacityReservationGroup",
"futureCapacityReservation",
{ expand: "instanceView" },
);
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
Exemple de réponse
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/futureCapacityReservationGroup/capacityReservations/futureCapacityReservation",
"properties": {
"platformFaultDomainCount": 3,
"reservationId": "{GUID}",
"provisioningTime": "2021-06-27T01:02:38.3138469+00:00",
"virtualMachinesAssociated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"
}
],
"provisioningState": "Succeeded",
"instanceView": {
"utilizationInfo": {
"currentCapacity": 4,
"virtualMachinesAllocated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
}
]
},
"statuses": [
{
"code": "ProvisioningState/succeeded",
"level": "Info",
"displayStatus": "Provisioning succeeded"
}
],
"reservationStateInfo": {
"reservationState": "Live"
}
},
"scheduleProfile": {
"start": "2026-08-01T12:00:00Z",
"minimumCommitmentDays": 30,
"modifiableUntil": "2026-06-06T12:00:00Z"
},
"timeCreated": "2021-06-27T01:02:38.3138469+00:00"
},
"location": "westus",
"tags": {
"department": "HR"
},
"sku": {
"name": "Standard_DS1_v2",
"capacity": 4
},
"zones": [
"1"
],
"name": "futureCapacityReservation"
}
Get a targeted capacity reservation.
Exemple de requête
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/targetedCapacityReservationGroup/capacityReservations/targetedCapacityReservation?api-version=2026-04-01&$expand=instanceView
import com.azure.resourcemanager.compute.models.CapacityReservationInstanceViewTypes;
/**
* Samples for CapacityReservations Get.
*/
public final class Main {
/*
* x-ms-original-file: 2026-04-01/capacityReservationExamples/TargetedCapacityReservation_Get.json
*/
/**
* Sample code: Get a targeted capacity reservation.
*
* @param manager Entry point to ComputeManager.
*/
public static void getATargetedCapacityReservation(com.azure.resourcemanager.compute.ComputeManager manager) {
manager.serviceClient().getCapacityReservations().getWithResponse("myResourceGroup",
"targetedCapacityReservationGroup", "targetedCapacityReservation",
CapacityReservationInstanceViewTypes.INSTANCE_VIEW, 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 azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-compute
# USAGE
python targeted_capacity_reservation_get.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.capacity_reservations.get(
resource_group_name="myResourceGroup",
capacity_reservation_group_name="targetedCapacityReservationGroup",
capacity_reservation_name="targetedCapacityReservation",
)
print(response)
# x-ms-original-file: 2026-04-01/capacityReservationExamples/TargetedCapacityReservation_Get.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/v8"
)
// Generated from example definition: 2026-04-01/capacityReservationExamples/TargetedCapacityReservation_Get.json
func ExampleCapacityReservationsClient_Get_getATargetedCapacityReservation() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcompute.NewClientFactory("{subscriptionId}", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCapacityReservationsClient().Get(ctx, "myResourceGroup", "targetedCapacityReservationGroup", "targetedCapacityReservation", &armcompute.CapacityReservationsClientGetOptions{
Expand: to.Ptr(armcompute.CapacityReservationInstanceViewTypesInstanceView)})
if err != nil {
log.Fatalf("failed to finish the request: %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 = armcompute.CapacityReservationsClientGetResponse{
// CapacityReservation: armcompute.CapacityReservation{
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/targetedCapacityReservationGroup/capacityReservations/targetedCapacityReservation"),
// Properties: &armcompute.CapacityReservationProperties{
// PlatformFaultDomainCount: to.Ptr[int32](3),
// ReservationID: to.Ptr("{GUID}"),
// ProvisioningTime: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// VirtualMachinesAssociated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"),
// },
// },
// ProvisioningState: to.Ptr("Succeeded"),
// InstanceView: &armcompute.CapacityReservationInstanceView{
// UtilizationInfo: &armcompute.CapacityReservationUtilization{
// CurrentCapacity: to.Ptr[int32](5),
// VirtualMachinesAllocated: []*armcompute.SubResourceReadOnly{
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"),
// },
// {
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"),
// },
// },
// },
// Statuses: []*armcompute.InstanceViewStatus{
// {
// Code: to.Ptr("ProvisioningState/succeeded"),
// Level: to.Ptr(armcompute.StatusLevelTypesInfo),
// DisplayStatus: to.Ptr("Provisioning succeeded"),
// },
// },
// },
// TimeCreated: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// },
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "department": to.Ptr("HR"),
// },
// SKU: &armcompute.SKU{
// Name: to.Ptr("Standard_DS1_v2"),
// Capacity: to.Ptr[int64](4),
// },
// Zones: []*string{
// to.Ptr("1"),
// },
// Name: to.Ptr("targetedCapacityReservation"),
// },
// }
}
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 the operation that retrieves information about the capacity reservation.
*
* @summary the operation that retrieves information about the capacity reservation.
* x-ms-original-file: 2026-04-01/capacityReservationExamples/TargetedCapacityReservation_Get.json
*/
async function getATargetedCapacityReservation() {
const credential = new DefaultAzureCredential();
const subscriptionId = "{subscriptionId}";
const client = new ComputeManagementClient(credential, subscriptionId);
const result = await client.capacityReservations.get(
"myResourceGroup",
"targetedCapacityReservationGroup",
"targetedCapacityReservation",
{ expand: "instanceView" },
);
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
Exemple de réponse
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/targetedCapacityReservationGroup/capacityReservations/targetedCapacityReservation",
"properties": {
"platformFaultDomainCount": 3,
"reservationId": "{GUID}",
"provisioningTime": "2021-06-27T01:02:38.3138469+00:00",
"virtualMachinesAssociated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM3"
}
],
"provisioningState": "Succeeded",
"instanceView": {
"utilizationInfo": {
"currentCapacity": 5,
"virtualMachinesAllocated": [
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM1"
},
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM2"
}
]
},
"statuses": [
{
"code": "ProvisioningState/succeeded",
"level": "Info",
"displayStatus": "Provisioning succeeded"
}
]
},
"timeCreated": "2021-06-27T01:02:38.3138469+00:00"
},
"location": "westus",
"tags": {
"department": "HR"
},
"sku": {
"name": "Standard_DS1_v2",
"capacity": 4
},
"zones": [
"1"
],
"name": "targetedCapacityReservation"
}
Get an open capacity reservation with instance view.
Exemple de requête
GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/openCapacityReservationGroup/capacityReservations/openCapacityReservation?api-version=2026-04-01&$expand=instanceView
import com.azure.resourcemanager.compute.models.CapacityReservationInstanceViewTypes;
/**
* Samples for CapacityReservations Get.
*/
public final class Main {
/*
* x-ms-original-file: 2026-04-01/capacityReservationExamples/OpenCapacityReservation_Get.json
*/
/**
* Sample code: Get an open capacity reservation with instance view.
*
* @param manager Entry point to ComputeManager.
*/
public static void
getAnOpenCapacityReservationWithInstanceView(com.azure.resourcemanager.compute.ComputeManager manager) {
manager.serviceClient().getCapacityReservations().getWithResponse("myResourceGroup",
"openCapacityReservationGroup", "openCapacityReservation",
CapacityReservationInstanceViewTypes.INSTANCE_VIEW, 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 azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-compute
# USAGE
python open_capacity_reservation_get.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.capacity_reservations.get(
resource_group_name="myResourceGroup",
capacity_reservation_group_name="openCapacityReservationGroup",
capacity_reservation_name="openCapacityReservation",
)
print(response)
# x-ms-original-file: 2026-04-01/capacityReservationExamples/OpenCapacityReservation_Get.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/v8"
)
// Generated from example definition: 2026-04-01/capacityReservationExamples/OpenCapacityReservation_Get.json
func ExampleCapacityReservationsClient_Get_getAnOpenCapacityReservationWithInstanceView() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcompute.NewClientFactory("{subscriptionId}", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewCapacityReservationsClient().Get(ctx, "myResourceGroup", "openCapacityReservationGroup", "openCapacityReservation", &armcompute.CapacityReservationsClientGetOptions{
Expand: to.Ptr(armcompute.CapacityReservationInstanceViewTypesInstanceView)})
if err != nil {
log.Fatalf("failed to finish the request: %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 = armcompute.CapacityReservationsClientGetResponse{
// CapacityReservation: armcompute.CapacityReservation{
// ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/openCapacityReservationGroup/capacityReservations/openCapacityReservation"),
// Properties: &armcompute.CapacityReservationProperties{
// PlatformFaultDomainCount: to.Ptr[int32](3),
// ReservationID: to.Ptr("{GUID}"),
// ProvisioningTime: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// ProvisioningState: to.Ptr("Succeeded"),
// InstanceView: &armcompute.CapacityReservationInstanceView{
// UtilizationInfo: &armcompute.CapacityReservationUtilization{
// CurrentCapacity: to.Ptr[int32](10),
// UsedReservedCountBySubscription: map[string]*int32{
// "{subscription-id1}": to.Ptr[int32](3),
// "{subscription-id2}": to.Ptr[int32](2),
// },
// },
// Statuses: []*armcompute.InstanceViewStatus{
// {
// Code: to.Ptr("ProvisioningState/succeeded"),
// Level: to.Ptr(armcompute.StatusLevelTypesInfo),
// DisplayStatus: to.Ptr("Provisioning succeeded"),
// },
// },
// },
// TimeCreated: to.Ptr(time.Date(2021, time.June, 27, 1, 2, 38, 313846900, time.UTC)),
// },
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "{tagName}": to.Ptr("{tagValue}"),
// },
// SKU: &armcompute.SKU{
// Name: to.Ptr("Standard_DS1_v2"),
// Capacity: to.Ptr[int64](10),
// },
// Zones: []*string{
// to.Ptr("1"),
// },
// Name: to.Ptr("openCapacityReservation"),
// },
// }
}
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 the operation that retrieves information about the capacity reservation.
*
* @summary the operation that retrieves information about the capacity reservation.
* x-ms-original-file: 2026-04-01/capacityReservationExamples/OpenCapacityReservation_Get.json
*/
async function getAnOpenCapacityReservationWithInstanceView() {
const credential = new DefaultAzureCredential();
const subscriptionId = "{subscriptionId}";
const client = new ComputeManagementClient(credential, subscriptionId);
const result = await client.capacityReservations.get(
"myResourceGroup",
"openCapacityReservationGroup",
"openCapacityReservation",
{ expand: "instanceView" },
);
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
Exemple de réponse
{
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/capacityReservationGroups/openCapacityReservationGroup/capacityReservations/openCapacityReservation",
"properties": {
"platformFaultDomainCount": 3,
"reservationId": "{GUID}",
"provisioningTime": "2021-06-27T01:02:38.3138469+00:00",
"provisioningState": "Succeeded",
"instanceView": {
"utilizationInfo": {
"currentCapacity": 10,
"usedReservedCountBySubscription": {
"{subscription-id1}": 3,
"{subscription-id2}": 2
}
},
"statuses": [
{
"code": "ProvisioningState/succeeded",
"level": "Info",
"displayStatus": "Provisioning succeeded"
}
]
},
"timeCreated": "2021-06-27T01:02:38.3138469+00:00"
},
"location": "westus",
"tags": {
"{tagName}": "{tagValue}"
},
"sku": {
"name": "Standard_DS1_v2",
"capacity": 10
},
"zones": [
"1"
],
"name": "openCapacityReservation"
}
Définitions
| Nom |
Description |
|
ApiError
|
Erreur d’API.
|
|
ApiErrorBase
|
Base d’erreurs d’API.
|
|
CapacityReservation
|
Spécifie des informations sur la réservation de capacité.
|
|
CapacityReservationInstanceView
|
Vue d’instance d’une réservation de capacité qui fournit un instantané des propriétés d’exécution de la réservation de capacité gérée par la plateforme et peut changer en dehors des opérations du plan de contrôle.
|
|
CapacityReservationInstanceViewTypes
|
|
|
CapacityReservationStateInfo
|
Détails relatifs à l’état actuel pour une future réservation de capacité.
|
|
CapacityReservationUtilization
|
Représente l’utilisation de la réservation de capacité en termes de ressources allouées.
|
|
CloudError
|
Réponse d’erreur du service de calcul.
|
|
createdByType
|
Type d’identité qui a créé la ressource.
|
|
InnerError
|
Détails de l’erreur interne.
|
|
InstanceViewStatus
|
État de l’affichage de l’instance.
|
|
ReservationState
|
L’état actuel d’une réserve de capacité future.
|
|
ScheduleProfile
|
Définit le planning des réservations de capacité par blocs et futurs. Spécifie la planification pendant laquelle la réservation de capacité est active et où la ressource VM ou VMSS peut être allouée à l’aide de la réservation. Pour les réservations de capacité de bloc, les champs ScheduleProfile, start et end sont immuables après création. Pour plus d’informations, reportez-vous à https://aka.ms/blockcapacityreservation. Version minimale de l’API pour les réservations de capacité de bloc : 01-04-2025. Les futures réservations de capacité doivent utiliser cette propriété avec seulement une heure de début, qui peut être modifiée jusqu’à l’heure « modifiable jusqu’à ». Pour plus d’informations, reportez-vous à https://aka.ms/futurecapacityreservation. Version minimale de l’API pour les réservations de capacité futures : 01-04-2026.
|
|
Sku
|
Décrit une référence SKU de groupe de machines virtuelles identiques. REMARQUE : Si la nouvelle référence SKU de machine virtuelle n’est pas prise en charge sur le matériel sur lequel le groupe identique est actuellement activé, vous devez libérer les machines virtuelles du groupe identique avant de modifier le nom de la référence SKU.
|
|
StatusLevelTypes
|
Code de niveau.
|
|
SubResourceReadOnly
|
|
|
systemData
|
Métadonnées relatives à la création et à la dernière modification de la ressource.
|
ApiError
Objet
Erreur d’API.
| Nom |
Type |
Description |
|
code
|
string
|
Code d’erreur.
|
|
details
|
ApiErrorBase[]
|
Détails de l’erreur api
|
|
innererror
|
InnerError
|
Erreur interne de l’API
|
|
message
|
string
|
Message d’erreur.
|
|
target
|
string
|
Cible de l’erreur particulière.
|
ApiErrorBase
Objet
Base d’erreurs d’API.
| Nom |
Type |
Description |
|
code
|
string
|
Code d’erreur.
|
|
message
|
string
|
Message d’erreur.
|
|
target
|
string
|
Cible de l’erreur particulière.
|
CapacityReservation
Objet
Spécifie des informations sur la réservation de capacité.
| Nom |
Type |
Description |
|
id
|
string
|
Identifiant de ressource entièrement qualifié pour la ressource. ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
|
|
location
|
string
|
Emplacement géographique où réside la ressource
|
|
name
|
string
|
nom de la ressource.
|
|
properties.instanceView
|
CapacityReservationInstanceView
|
La vue de l’instance de réservation de capacité.
|
|
properties.platformFaultDomainCount
|
integer
(int32)
|
Spécifie la valeur du nombre de domaines d’erreur pris en charge par la réservation de capacité pour la taille de machine virtuelle demandée.
Note: Le nombre de domaines d’erreur spécifié pour une ressource (comme les machines virtuelles identiques) doit être inférieur ou égal à cette valeur si elle est déployée à l’aide de la réservation de capacité. Version minimale de l’API : 2022-08-01.
|
|
properties.provisioningState
|
string
|
État d’approvisionnement, qui apparaît uniquement dans la réponse.
|
|
properties.provisioningTime
|
string
(date-time)
|
Date et heure de la dernière mise à jour de la réservation de capacité.
|
|
properties.reservationId
|
string
|
Un identifiant unique généré et attribué à la réservation de capacité par la plateforme qui ne change pas pendant toute la durée de vie de la ressource.
|
|
properties.scheduleProfile
|
ScheduleProfile
|
Définit le planning des réservations de capacité par blocs et futurs. Spécifie la planification pendant laquelle la réservation de capacité est active et où la ressource VM ou VMSS peut être allouée à l’aide de la réservation. Pour les réservations de capacité de bloc, les champs ScheduleProfile, start et end sont immuables après création. Pour plus d’informations, reportez-vous à https://aka.ms/blockcapacityreservation. Version minimale de l’API pour les réservations de capacité de bloc : 01-04-2025. Les futures réservations de capacité doivent utiliser cette propriété avec seulement une heure de début, qui peut être modifiée jusqu’à l’heure « modifiable jusqu’à ». Pour plus d’informations, reportez-vous à https://aka.ms/futurecapacityreservation. Version minimale de l’API pour les réservations de capacité futures : 01-04-2026.
|
|
properties.timeCreated
|
string
(date-time)
|
Spécifie l’heure à laquelle la ressource Réservation de capacité a été créée. Version minimale de l’API : 2021-11-01.
|
|
properties.virtualMachinesAssociated
|
SubResourceReadOnly[]
|
Liste de tous les ID de ressource de machine virtuelle associés à la réservation de capacité.
|
|
sku
|
Sku
|
Référence SKU de la ressource pour laquelle la capacité doit être réservée. Le nom et la capacité de la référence SKU doivent être définis. Pour les réservations de capacité de bloc, sku.capacity ne peut accepter que les valeurs 1, 2, 4, 8, 16, 32, 64. Actuellement, les références SKU de machine virtuelle avec la fonctionnalité appelée « CapacityReservationSupported » définie sur true sont prises en charge. Lorsque la valeur « CapacityReservationSupported » est true, la fonctionnalité de référence SKU spécifie également « SupportedCapacityReservationTypes », qui répertorie les types de réservations de capacité (par exemple, Targeted ou Block) pris en charge par la référence SKU. Reportez-vous à la liste Microsoft. Références SKU de calcul dans une région (https://docs.microsoft.com/rest/api/compute/resourceskus/list) pour les valeurs prises en charge.
|
|
systemData
|
systemData
|
Métadonnées Azure Resource Manager contenant les informations createdBy et modifiedBy.
|
|
tags
|
object
|
Balises de ressources.
|
|
type
|
string
|
Type de la ressource. Par exemple, « Microsoft.Compute/virtualMachines » ou « Microsoft.Storage/storageAccounts »
|
|
zones
|
string[]
|
Zones de disponibilité.
|
CapacityReservationInstanceView
Objet
Vue d’instance d’une réservation de capacité qui fournit un instantané des propriétés d’exécution de la réservation de capacité gérée par la plateforme et peut changer en dehors des opérations du plan de contrôle.
| Nom |
Type |
Description |
|
reservationStateInfo
|
CapacityReservationStateInfo
|
Les informations sur la réservation pour une capacité sont principalement fournies pour les futures réservations de capacité. Version minimale de l’API : 01-04-2026.
|
|
statuses
|
InstanceViewStatus[]
|
Informations d’état de la ressource.
|
|
utilizationInfo
|
CapacityReservationUtilization
|
Capacité inutilisée de la réservation de capacité.
|
CapacityReservationInstanceViewTypes
Énumération
| Valeur |
Description |
|
instanceView
|
|
CapacityReservationStateInfo
Objet
Détails relatifs à l’état actuel pour une future réservation de capacité.
| Nom |
Type |
Description |
|
reservationState
|
ReservationState
|
L’état actuel de la réservation de capacité.
|
CapacityReservationUtilization
Objet
Représente l’utilisation de la réservation de capacité en termes de ressources allouées.
| Nom |
Type |
Description |
|
currentCapacity
|
integer
(int32)
|
La valeur fournit la capacité actuelle de la taille de machine virtuelle qui a été réservée avec succès et pour laquelle le client est facturé. Version minimale de l’API : 2022-08-01.
|
|
usedReservedCountBySubscription
|
object
|
Pour les réservations de capacité ouverte, cela fournit une carte du nombre de capacité réservée utilisée, indexée par l’identifiant d’abonnement (un GUID) qui consomme la capacité, c’est-à-dire que chaque entrée associe un identifiant d’abonnement consommant au nombre de capacité réservée qu’elle utilise actuellement. Cette fonction est remplie uniquement pour les réservations de capacité ouverte et n’est pas signalée pour les réservations ciblées et de bloc, qui rapportent à la place l’allocation via virtualMachinesAllocated. Version API minimale : 01-04-2026.
|
|
virtualMachinesAllocated
|
SubResourceReadOnly[]
|
Liste de tous les ID de ressource de machines virtuelles alloués à la réservation de capacité.
|
CloudError
Objet
Réponse d’erreur du service de calcul.
| Nom |
Type |
Description |
|
error
|
ApiError
|
Erreur d’API.
|
createdByType
Énumération
Type d’identité qui a créé la ressource.
| Valeur |
Description |
|
User
|
|
|
Application
|
|
|
ManagedIdentity
|
|
|
Key
|
|
InnerError
Objet
Détails de l’erreur interne.
| Nom |
Type |
Description |
|
errordetail
|
string
|
Message d’erreur interne ou vidage d’exception.
|
|
exceptiontype
|
string
|
Type d'exception.
|
InstanceViewStatus
Objet
État de l’affichage de l’instance.
| Nom |
Type |
Description |
|
code
|
string
|
Code d’état.
|
|
displayStatus
|
string
|
Étiquette localisable courte pour l’état.
|
|
level
|
StatusLevelTypes
|
Code de niveau.
|
|
message
|
string
|
Message d’état détaillé, y compris pour les alertes et les messages d’erreur.
|
|
time
|
string
(date-time)
|
Heure de l’état.
|
ReservationState
Énumération
L’état actuel d’une réserve de capacité future.
| Valeur |
Description |
|
Pending
|
La demande de réservation de capacité a été soumise et attend son évaluation.
|
|
Declined
|
La demande de réservation de capacité a été rejetée et ne changera plus sans intervention de l’utilisateur.
|
|
Approved
|
La demande de réservation de capacité a été approuvée par Azure et attend d’être prise en charge.
|
|
FulfillmentFailed
|
Un échec est survenu lors de la tentative de remplir la demande de réservation de capacité.
|
|
Committed
|
La réservation de capacité est verrouillée et ne peut être mise à jour ou supprimée avant la mise en ligne.
|
|
Live
|
La réservation de capacité est active et disponible pour l’utilisation, et ne peut être modifiée ou supprimée avant l’expiration de la période minimale d’engagement.
|
|
PartiallyFulfilled
|
Azure n’a pu fournir qu’une partie de la capacité demandée. La réservation de capacité ne peut être modifiée ou supprimée avant l’expiration de la période minimale d’engagement. La portion de capacité remplie peut être consultée en inspectant la vue d’instance de la réservation de capacité, affichée comme currentCapacity dans l’Utilisation Info.
|
ScheduleProfile
Objet
Définit le planning des réservations de capacité par blocs et futurs. Spécifie la planification pendant laquelle la réservation de capacité est active et où la ressource VM ou VMSS peut être allouée à l’aide de la réservation. Pour les réservations de capacité de bloc, les champs ScheduleProfile, start et end sont immuables après création. Pour plus d’informations, reportez-vous à https://aka.ms/blockcapacityreservation. Version minimale de l’API pour les réservations de capacité de bloc : 01-04-2025. Les futures réservations de capacité doivent utiliser cette propriété avec seulement une heure de début, qui peut être modifiée jusqu’à l’heure « modifiable jusqu’à ». Pour plus d’informations, reportez-vous à https://aka.ms/futurecapacityreservation. Version minimale de l’API pour les réservations de capacité futures : 01-04-2026.
| Nom |
Type |
Description |
|
end
|
string
|
La date de fin requise pour les réservations de capacité du bloc. Doit être postérieur à la date de début, avec une durée de 1 à 14 jours entiers ou de 3 à 26 semaines entières. Exemple : 2025-06-28.
|
|
minimumCommitmentDays
|
integer
(int32)
|
Le nombre minimum de jours qui doivent s’écouler après la date de début avant une réservation de capacité future peut être mis à jour ou supprimé une fois qu’elle a été engagée. Sera rempli avec une valeur par défaut si elle n’est pas fournie.
|
|
modifiableUntil
|
string
(date-time)
|
La date/heure jusqu’à laquelle une réservation de capacité future peut être mise à jour ou supprimée. Lecture seule.
|
|
start
|
string
|
La date de début requise pour les réservations de capacité par bloc ou future. Réservations de capacité par bloc : doivent avoir lieu aujourd’hui ou dans les 56 jours à venir. Pour la programmation le jour même, les demandes doivent être soumises avant 11 h 30 UTC. Réservations de capacité futures : doivent être au moins 7 jours dans le futur, et maximum 6 mois dans le futur. Version minimale de l’API pour les réservations de capacité futures : 01-04-2026. Exemple : 27-06-2025, applicable pour les réservations de capacité Block et Future.
|
Sku
Objet
Décrit une référence SKU de groupe de machines virtuelles identiques. REMARQUE : Si la nouvelle référence SKU de machine virtuelle n’est pas prise en charge sur le matériel sur lequel le groupe identique est actuellement activé, vous devez libérer les machines virtuelles du groupe identique avant de modifier le nom de la référence SKU.
| Nom |
Type |
Description |
|
capacity
|
integer
(int64)
|
Spécifie le nombre de machines virtuelles dans le groupe identique.
|
|
name
|
string
|
Nom de la référence SKU.
|
|
tier
|
string
|
Spécifie le niveau des machines virtuelles dans un groupe identique.
Valeurs possibles :
Standard
Basic
|
StatusLevelTypes
Énumération
Code de niveau.
| Valeur |
Description |
|
Info
|
|
|
Warning
|
|
|
Error
|
|
SubResourceReadOnly
Objet
| Nom |
Type |
Description |
|
id
|
string
|
ID de ressource
|
systemData
Objet
Métadonnées relatives à la création et à la dernière modification de la ressource.
| Nom |
Type |
Description |
|
createdAt
|
string
(date-time)
|
Horodatage de la création de ressources (UTC).
|
|
createdBy
|
string
|
Identité qui a créé la ressource.
|
|
createdByType
|
createdByType
|
Type d’identité qui a créé la ressource.
|
|
lastModifiedAt
|
string
(date-time)
|
Horodatage de la dernière modification de ressource (UTC)
|
|
lastModifiedBy
|
string
|
Identité qui a modifié la ressource pour la dernière fois.
|
|
lastModifiedByType
|
createdByType
|
Type d’identité qui a modifié la ressource pour la dernière fois.
|