Crea un nuovo pool all'interno dell'account specificato.
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}?api-version=2025-06-01
Parametri dell'URI
| Nome |
In |
Necessario |
Tipo |
Descrizione |
|
accountName
|
path |
True
|
string
minLength: 3 maxLength: 24 pattern: ^[a-zA-Z0-9]+$
|
Un nome per l'account Batch che deve essere unico all'interno della regione. I nomi dei conti dei lotti devono avere una lunghezza compresa tra 3 e 24 caratteri e devono utilizzare solo numeri e lettere minuscole. Questo nome viene utilizzato come parte del nome DNS utilizzato per accedere al servizio Batch nella regione in cui l'account è stato creato. Ad esempio: http://accountname.region.batch.azure.com/.
|
|
poolName
|
path |
True
|
string
minLength: 1 maxLength: 64 pattern: ^[a-zA-Z0-9_-]+$
|
Nome del pool. Deve essere univoco all'interno dell'account.
|
|
resourceGroupName
|
path |
True
|
string
minLength: 1 maxLength: 90
|
Nome del gruppo di risorse. Il nome è insensibile alle maiuscole e minuscole.
|
|
subscriptionId
|
path |
True
|
string
(uuid)
|
ID della sottoscrizione di destinazione. Il valore deve essere un UUID.
|
|
api-version
|
query |
True
|
string
minLength: 1
|
Versione dell'API da usare per questa operazione.
|
| Nome |
Necessario |
Tipo |
Descrizione |
|
If-Match
|
|
string
|
Versione dello stato dell'entità (ETag) del pool da aggiornare. È possibile usare il valore "*" per applicare l'operazione solo se il pool esiste già. Se omesso, questa operazione verrà sempre applicata.
|
|
If-None-Match
|
|
string
|
Impostare su '*' per consentire la creazione di un nuovo pool, ma per impedire l'aggiornamento di un pool esistente. Gli altri valori verranno ignorati.
|
Corpo della richiesta
| Nome |
Tipo |
Descrizione |
|
identity
|
BatchPoolIdentity
|
Tipo di identità usato per il pool di batch.
|
|
properties.applicationPackages
|
ApplicationPackageReference[]
|
Elenco dei pacchetti dell'applicazione da installare in ogni nodo di calcolo del pool.
Le modifiche apportate ai riferimenti ai pacchetti dell'applicazione influiscono su tutti i nuovi nodi di calcolo che si aggiungono al pool, ma non influiscono sui nodi di calcolo già presenti nel pool finché non vengono riavviati o ricreati l'immagine. È previsto un massimo di 10 riferimenti al pacchetto dell'applicazione in un determinato pool.
|
|
properties.deploymentConfiguration
|
DeploymentConfiguration
|
Questa proprietà descrive le macchine virtuali in cui verranno distribuiti i nodi del pool.
Proprietà di configurazione della distribuzione.
|
|
properties.displayName
|
string
|
Nome visualizzato per il pool.
Il nome visualizzato non deve essere univoco e può contenere caratteri Unicode fino a una lunghezza massima di 1024.
|
|
properties.interNodeCommunication
|
InterNodeCommunicationState
|
Indica se il pool consente la comunicazione diretta tra nodi.
Ciò impone restrizioni sui nodi che possono essere assegnati al pool. L'abilitazione di questo valore può ridurre la probabilità che il numero di nodi richiesto venga allocato nel pool. Se non specificato, il valore predefinito è 'Disabled'.
|
|
properties.metadata
|
MetadataItem[]
|
Elenco di coppie nome-valore associate al pool come metadati.
Il servizio Batch non assegna alcun significato ai metadati; è esclusivamente per l'uso del codice utente.
|
|
properties.mountConfiguration
|
MountConfiguration[]
|
Elenco di file system da montare in ogni nodo del pool.
Supporta File di Azure, NFS, CIFS/SMB e Blobfuse.
|
|
properties.networkConfiguration
|
NetworkConfiguration
|
Configurazione di rete per il pool.
Configurazione di rete per un pool.
|
|
properties.scaleSettings
|
ScaleSettings
|
Impostazioni che configurano il numero di nodi nel pool.
Definisce le dimensioni desiderate del pool. Può trattarsi di "fixedScale" in cui è specificato targetDedicatedNodes richiesto oppure "autoScale" che definisce una formula che viene rivalutata periodicamente. Se questa proprietà non è specificata, il pool avrà una scala fissa con 0 targetDedicatedNodes.
|
|
properties.startTask
|
StartTask
|
Un'attività specificata per l'esecuzione in ogni nodo di calcolo durante l'aggiunta al pool.
In un'operazione PATCH (aggiornamento) questa proprietà può essere impostata su un oggetto vuoto per rimuovere l'attività di avvio dal pool.
|
|
properties.taskSchedulingPolicy
|
TaskSchedulingPolicy
|
Modalità di distribuzione delle attività tra nodi di calcolo in un pool.
Se non specificato, il valore predefinito è spread.
|
|
properties.taskSlotsPerNode
|
integer
(int32)
|
Numero di slot di attività che possono essere usati per eseguire attività simultanee in un singolo nodo di calcolo nel pool.
Il valore predefinito è 1. Il valore massimo è minore di 4 volte il numero di core di vmSize del pool o 256.
|
|
properties.upgradePolicy
|
UpgradePolicy
|
Criteri di aggiornamento per il pool.
Descrive un criterio di aggiornamento: automatico, manuale o in sequenza.
|
|
properties.userAccounts
|
UserAccount[]
|
Elenco di account utente da creare in ogni nodo del pool.
Elenco di account utente da creare in ogni nodo del pool.
|
|
properties.vmSize
|
string
|
Dimensioni delle macchine virtuali nel pool. Tutte le macchine virtuali in un pool hanno le stesse dimensioni.
Per informazioni sulle dimensioni delle macchine virtuali disponibili, vedere Dimensioni per le macchine virtuali in Azure (https://learn.microsoft.com/azure/virtual-machines/sizes/overview). Batch supporta tutte le dimensioni delle macchine virtuali di Azure tranne STANDARD_A0 e quelle con archiviazione Premium (STANDARD_GS, STANDARD_DS e serie di STANDARD_DSV2).
|
|
tags
|
object
|
Tag della risorsa.
|
Risposte
| Nome |
Tipo |
Descrizione |
|
200 OK
|
Pool
|
La richiesta ha avuto esito positivo.
Intestazioni
ETag: string
|
|
Other Status Codes
|
CloudError
|
Risposta di errore imprevista.
|
Sicurezza
azure_auth
Flusso OAuth2 di Azure Active Directory.
Tipo:
oauth2
Flow:
implicit
URL di autorizzazione:
https://login.microsoftonline.com/common/oauth2/authorize
Ambiti
| Nome |
Descrizione |
|
user_impersonation
|
rappresentare l'account utente
|
Esempio
CreatePool - accelerated networking
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2016-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64"
}
},
"networkConfiguration": {
"enableAcceleratedNetworking": true,
"subnetId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"vmSize": "STANDARD_D1_V2"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_AcceleratedNetworking.json
func ExamplePoolClient_Create_createPoolAcceleratedNetworking() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("WindowsServer"),
Publisher: to.Ptr("MicrosoftWindowsServer"),
SKU: to.Ptr("2016-datacenter-smalldisk"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
},
},
NetworkConfiguration: &armbatch.NetworkConfiguration{
EnableAcceleratedNetworking: to.Ptr(true),
SubnetID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
VMSize: to.Ptr("STANDARD_D1_V2"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8DB46CB72A227E2\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateSteady),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-27T03:00:34.0646502Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-27T02:59:41.8592226Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](1),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("WindowsServer"),
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// SKU: to.Ptr("2016-datacenter-smalldisk"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-27T02:59:41.8592226Z"); return t}()),
// NetworkConfiguration: &armbatch.NetworkConfiguration{
// DynamicVNetAssignmentScope: to.Ptr(armbatch.DynamicVNetAssignmentScopeNone),
// EnableAcceleratedNetworking: to.Ptr(true),
// SubnetID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
// },
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-27T02:59:41.8592226Z"); return t}()),
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-04-27T02:59:41.8592226Z"); return t}()),
// TargetDedicatedNodes: to.Ptr[int32](1),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// ResizeTimeout: to.Ptr("PT15M"),
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D1_V2"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_AcceleratedNetworking.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D1_V2",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2016-datacenter-smalldisk",
Version = "latest",
}, "batch.node.windows amd64"),
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 1,
TargetLowPriorityNodes = 0,
},
},
NetworkConfiguration = new BatchNetworkConfiguration
{
SubnetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
EnableAcceleratedNetworking = true,
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8DB46CB72A227E2"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Steady",
"allocationStateTransitionTime": "2023-04-27T03:00:34.0646502Z",
"creationTime": "2023-04-27T02:59:41.8592226Z",
"currentDedicatedNodes": 1,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2016-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2023-04-27T02:59:41.8592226Z",
"networkConfiguration": {
"dynamicVnetAssignmentScope": "none",
"enableAcceleratedNetworking": true,
"subnetId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"
},
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2023-04-27T02:59:41.8592226Z",
"resizeOperationStatus": {
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2023-04-27T02:59:41.8592226Z",
"targetDedicatedNodes": 1
},
"scaleSettings": {
"fixedScale": {
"resizeTimeout": "PT15M",
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D1_V2"
}
}
CreatePool - confidential disk encryption set for user subscription accounts
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"vmSize": "Standard_DC2as_v5",
"taskSchedulingPolicy": {
"nodeFillType": "Pack"
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "MicrosoftWindowsServer",
"offer": "WindowsServer",
"sku": "2019-datacenter-core-g2",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"securityProfile": {
"securityType": "confidentialVM",
"encryptionAtHost": false,
"uefiSettings": {
"vTpmEnabled": true,
"secureBootEnabled": true
}
},
"osDisk": {
"managedDisk": {
"storageAccountType": "Standard_LRS",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"
},
"securityProfile": {
"securityEncryptionType": "DiskWithVMGuestState",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/ConfidentialDiskEncryptionSetId"
}
}
}
},
"dataDisks": [
{
"lun": 0,
"diskSizeGB": 1024,
"managedDisk": {
"storageAccountType": "Standard_LRS",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"
}
}
}
]
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"resizeTimeout": "PT15M"
}
}
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_ConfidentialDiskEncryptionSet_ForUserSubscriptionAccounts.json
func ExamplePoolClient_Create_createPoolConfidentialDiskEncryptionSetForUserSubscriptionAccounts() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
VMSize: to.Ptr("Standard_DC2as_v5"),
TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypePack),
},
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Publisher: to.Ptr("MicrosoftWindowsServer"),
Offer: to.Ptr("WindowsServer"),
SKU: to.Ptr("2019-datacenter-core-g2"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
SecurityProfile: &armbatch.SecurityProfile{
SecurityType: to.Ptr(armbatch.SecurityTypesConfidentialVM),
EncryptionAtHost: to.Ptr(false),
UefiSettings: &armbatch.UefiSettings{
VTpmEnabled: to.Ptr(true),
SecureBootEnabled: to.Ptr(true),
},
},
OSDisk: &armbatch.OSDisk{
ManagedDisk: &armbatch.ManagedDisk{
StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
},
SecurityProfile: &armbatch.VMDiskSecurityProfile{
SecurityEncryptionType: to.Ptr(armbatch.SecurityEncryptionTypesDiskWithVMGuestState),
DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/ConfidentialDiskEncryptionSetId"),
},
},
},
},
DataDisks: []*armbatch.DataDisk{
{
Lun: to.Ptr[int32](0),
DiskSizeGB: to.Ptr[int32](1024),
ManagedDisk: &armbatch.ManagedDisk{
StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
},
},
},
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
ResizeTimeout: to.Ptr("PT15M"),
},
},
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// Etag: to.Ptr("W/\"0x8D4EDFEBFADF4AB\""),
// Properties: &armbatch.PoolProperties{
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:30:49.7522647Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:30:49.7522634Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:30:49.7522634Z"); return t}()),
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:30:49.7522647Z"); return t}()),
// VMSize: to.Ptr("STANDARD_DC2as_v5"),
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// TaskSlotsPerNode: to.Ptr[int32](1),
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypePack),
// JobDefaultOrder: to.Ptr(armbatch.JobDefaultOrderNone),
// },
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// Offer: to.Ptr("WindowsServer"),
// SKU: to.Ptr("2019-datacenter-core-g2"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// DataDisks: []*armbatch.DataDisk{
// {
// Lun: to.Ptr[int32](0),
// Caching: to.Ptr(armbatch.CachingTypeNone),
// DiskSizeGB: to.Ptr[int32](1024),
// ManagedDisk: &armbatch.ManagedDisk{
// StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
// DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
// },
// },
// },
// },
// OSDisk: &armbatch.OSDisk{
// Caching: to.Ptr(armbatch.CachingTypeNone),
// ManagedDisk: &armbatch.ManagedDisk{
// StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
// SecurityProfile: &armbatch.VMDiskSecurityProfile{
// SecurityEncryptionType: to.Ptr(armbatch.SecurityEncryptionTypesDiskWithVMGuestState),
// DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/ConfidentialDiskEncryptionSetId"),
// },
// },
// DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
// },
// },
// },
// SecurityProfile: &armbatch.SecurityProfile{
// SecurityType: to.Ptr(armbatch.SecurityTypesConfidentialVM),
// EncryptionAtHost: to.Ptr(false),
// UefiSettings: &armbatch.UefiSettings{
// SecureBootEnabled: to.Ptr(true),
// VTpmEnabled: to.Ptr(true),
// },
// },
// },
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// ResizeTimeout: to.Ptr("PT15M"),
// },
// },
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// TargetDedicatedNodes: to.Ptr[int32](1),
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:30:49.7522324Z"); return t}()),
// },
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_ConfidentialDiskEncryptionSet_ForUserSubscriptionAccounts.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_DC2as_v5",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2019-datacenter-core-g2",
Version = "latest",
}, "batch.node.windows amd64")
{
DataDisks = {new BatchVmDataDisk(0, 1024)
{
ManagedDisk = new ManagedDisk
{
StorageAccountType = BatchStorageAccountType.StandardLrs,
DiskEncryptionSetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
},
}},
OSDisk = new BatchOSDisk
{
ManagedDisk = new ManagedDisk
{
StorageAccountType = BatchStorageAccountType.StandardLrs,
SecurityProfile = new VmDiskSecurityProfile
{
SecurityEncryptionType = BatchSecurityEncryptionType.DiskWithVmGuestState,
DiskEncryptionSetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/ConfidentialDiskEncryptionSetId"),
},
DiskEncryptionSetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
},
},
SecurityProfile = new BatchSecurityProfile
{
SecurityType = BatchSecurityType.ConfidentialVm,
EncryptionAtHost = false,
UefiSettings = new BatchUefiSettings
{
IsSecureBootEnabled = true,
IsVTpmEnabled = true,
},
},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
ResizeTimeout = XmlConvert.ToTimeSpan("PT15M"),
TargetDedicatedNodes = 1,
},
},
TaskSchedulingPolicy = new BatchTaskSchedulingPolicy(BatchNodeFillType.Pack),
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"etag": "W/\"0x8D4EDFEBFADF4AB\"",
"properties": {
"lastModified": "2025-06-30T07:30:49.7522647Z",
"creationTime": "2025-06-30T07:30:49.7522634Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2025-06-30T07:30:49.7522634Z",
"allocationState": "Resizing",
"allocationStateTransitionTime": "2025-06-30T07:30:49.7522647Z",
"vmSize": "STANDARD_DC2as_v5",
"interNodeCommunication": "Disabled",
"taskSlotsPerNode": 1,
"taskSchedulingPolicy": {
"nodeFillType": "Pack",
"jobDefaultOrder": "None"
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "MicrosoftWindowsServer",
"offer": "WindowsServer",
"sku": "2019-datacenter-core-g2",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"dataDisks": [
{
"lun": 0,
"caching": "None",
"diskSizeGB": 1024,
"managedDisk": {
"storageAccountType": "Standard_LRS",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"
}
}
}
],
"osDisk": {
"caching": "None",
"managedDisk": {
"storageAccountType": "Standard_LRS",
"securityProfile": {
"securityEncryptionType": "DiskWithVMGuestState",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/ConfidentialDiskEncryptionSetId"
}
},
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"
}
}
},
"securityProfile": {
"securityType": "confidentialVM",
"encryptionAtHost": false,
"uefiSettings": {
"secureBootEnabled": true,
"vTpmEnabled": true
}
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0,
"resizeTimeout": "PT15M"
}
},
"resizeOperationStatus": {
"targetDedicatedNodes": 1,
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2025-06-30T07:30:49.7522324Z"
},
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0
}
}
CreatePool - Custom Image
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_SharedImageGallery.json
func ExamplePoolClient_Create_createPoolCustomImage() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
},
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateSteady),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](0),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_SharedImageGallery.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Id = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
}, "batch.node.ubuntu 18.04"),
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Steady",
"allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"creationTime": "2017-08-28T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2017-08-28T10:22:55.9407275Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 0,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - customer managed key for Batch managed accounts
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"vmSize": "Standard_D4ds_v5",
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"sku": "2022-Datacenter",
"publisher": "MicrosoftWindowsServer",
"version": "latest",
"offer": "WindowsServer"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"diskEncryptionConfiguration": {
"targets": [
"OsDisk"
],
"customerManagedKey": {
"keyUrl": "http://sample.vault.azure.net//keys/cmk/bb60031a6d4545d3a60d3f94588538c9",
"identityReference": {
"resourceId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1"
}
}
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"resizeTimeout": "PT15M"
}
}
},
"identity": {
"type": "UserAssigned",
"userAssignedIdentities": {
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {}
}
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_CustomerManagedKey_ForBatchManagedAccounts.json
func ExamplePoolClient_Create_createPoolCustomerManagedKeyForBatchManagedAccounts() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
VMSize: to.Ptr("Standard_D4ds_v5"),
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
SKU: to.Ptr("2022-Datacenter"),
Publisher: to.Ptr("MicrosoftWindowsServer"),
Version: to.Ptr("latest"),
Offer: to.Ptr("WindowsServer"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
DiskEncryptionConfiguration: &armbatch.DiskEncryptionConfiguration{
Targets: []*armbatch.DiskEncryptionTarget{
to.Ptr(armbatch.DiskEncryptionTargetOsDisk),
},
CustomerManagedKey: &armbatch.DiskCustomerManagedKey{
KeyURL: to.Ptr("http://sample.vault.azure.net//keys/cmk/bb60031a6d4545d3a60d3f94588538c9"),
IdentityReference: &armbatch.ComputeNodeIdentityReference{
ResourceID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1"),
},
},
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
ResizeTimeout: to.Ptr("PT15M"),
},
},
},
Identity: &armbatch.PoolIdentity{
Type: to.Ptr(armbatch.PoolIdentityTypeUserAssigned),
UserAssignedIdentities: map[string]*armbatch.UserAssignedIdentities{
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {},
},
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Identity: &armbatch.PoolIdentity{
// Type: to.Ptr(armbatch.PoolIdentityTypeUserAssigned),
// UserAssignedIdentities: map[string]*armbatch.UserAssignedIdentities{
// "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": &armbatch.UserAssignedIdentities{
// PrincipalID: to.Ptr("principalId"),
// ClientID: to.Ptr("clientId"),
// },
// },
// },
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// Etag: to.Ptr("W/\"0x8D4EDFEBFADF4AB\""),
// Properties: &armbatch.PoolProperties{
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:16:33.4309281Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:16:33.4309266Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:16:33.4309266Z"); return t}()),
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:16:33.4309281Z"); return t}()),
// VMSize: to.Ptr("Standard_D4ds_v5"),
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// TaskSlotsPerNode: to.Ptr[int32](1),
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// JobDefaultOrder: to.Ptr(armbatch.JobDefaultOrderNone),
// },
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// Offer: to.Ptr("WindowsServer"),
// SKU: to.Ptr("2022-Datacenter"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// DiskEncryptionConfiguration: &armbatch.DiskEncryptionConfiguration{
// Targets: []*armbatch.DiskEncryptionTarget{
// to.Ptr(armbatch.DiskEncryptionTargetOsDisk),
// },
// CustomerManagedKey: &armbatch.DiskCustomerManagedKey{
// KeyURL: to.Ptr("http://sample.vault.azure.net//keys/cmk/bb60031a6d4545d3a60d3f94588538c9"),
// IdentityReference: &armbatch.ComputeNodeIdentityReference{
// ResourceID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1"),
// },
// },
// },
// },
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// ResizeTimeout: to.Ptr("PT15M"),
// },
// },
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// TargetDedicatedNodes: to.Ptr[int32](1),
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:16:33.4309126Z"); return t}()),
// },
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_CustomerManagedKey_ForBatchManagedAccounts.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
Identity = new ManagedServiceIdentity("UserAssigned")
{
UserAssignedIdentities =
{
[new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1")] = new UserAssignedIdentity()
},
},
VmSize = "Standard_D4ds_v5",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2022-Datacenter",
Version = "latest",
}, "batch.node.windows amd64")
{
DiskEncryptionConfiguration = new BatchDiskEncryptionConfiguration
{
Targets = { BatchDiskEncryptionTarget.OSDisk },
CustomerManagedKey = new BatchDiskCustomerManagedKey
{
KeyUri = new Uri("http://sample.vault.azure.net//keys/cmk/bb60031a6d4545d3a60d3f94588538c9"),
IdentityReferenceResourceId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1"),
},
},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
ResizeTimeout = XmlConvert.ToTimeSpan("PT15M"),
TargetDedicatedNodes = 1,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"identity": {
"type": "UserAssigned",
"userAssignedIdentities": {
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {
"principalId": "principalId",
"clientId": "clientId"
}
}
},
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"etag": "W/\"0x8D4EDFEBFADF4AB\"",
"properties": {
"lastModified": "2025-06-30T07:16:33.4309281Z",
"creationTime": "2025-06-30T07:16:33.4309266Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2025-06-30T07:16:33.4309266Z",
"allocationState": "Resizing",
"allocationStateTransitionTime": "2025-06-30T07:16:33.4309281Z",
"vmSize": "Standard_D4ds_v5",
"interNodeCommunication": "Disabled",
"taskSlotsPerNode": 1,
"taskSchedulingPolicy": {
"nodeFillType": "Spread",
"jobDefaultOrder": "None"
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "MicrosoftWindowsServer",
"offer": "WindowsServer",
"sku": "2022-Datacenter",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"diskEncryptionConfiguration": {
"targets": [
"OsDisk"
],
"customerManagedKey": {
"keyUrl": "http://sample.vault.azure.net//keys/cmk/bb60031a6d4545d3a60d3f94588538c9",
"identityReference": {
"resourceId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1"
}
}
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0,
"resizeTimeout": "PT15M"
}
},
"resizeOperationStatus": {
"targetDedicatedNodes": 1,
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2025-06-30T07:16:33.4309126Z"
},
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0
}
}
CreatePool - disk encryption set for user subscription accounts
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"vmSize": "Standard_D4ds_v5",
"taskSchedulingPolicy": {
"nodeFillType": "Pack"
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"sku": "2022-Datacenter",
"publisher": "MicrosoftWindowsServer",
"version": "latest",
"offer": "WindowsServer"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"securityProfile": {
"encryptionAtHost": false
},
"osDisk": {
"managedDisk": {
"storageAccountType": "Standard_LRS",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"
}
}
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"resizeTimeout": "PT15M"
}
}
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_DiskEncryptionSet_ForUserSubscriptionAccounts.json
func ExamplePoolClient_Create_createPoolDiskEncryptionSetForUserSubscriptionAccounts() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
VMSize: to.Ptr("Standard_D4ds_v5"),
TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypePack),
},
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
SKU: to.Ptr("2022-Datacenter"),
Publisher: to.Ptr("MicrosoftWindowsServer"),
Version: to.Ptr("latest"),
Offer: to.Ptr("WindowsServer"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
SecurityProfile: &armbatch.SecurityProfile{
EncryptionAtHost: to.Ptr(false),
},
OSDisk: &armbatch.OSDisk{
ManagedDisk: &armbatch.ManagedDisk{
StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
},
},
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
ResizeTimeout: to.Ptr("PT15M"),
},
},
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// Etag: to.Ptr("W/\"0x8D4EDFEBFADF4AB\""),
// Properties: &armbatch.PoolProperties{
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:45:46.1580726Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:35:44.5579791Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:35:44.5579791Z"); return t}()),
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:45:46.1580727Z"); return t}()),
// VMSize: to.Ptr("Standard_D4ds_v5"),
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// TaskSlotsPerNode: to.Ptr[int32](1),
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypePack),
// JobDefaultOrder: to.Ptr(armbatch.JobDefaultOrderNone),
// },
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// Offer: to.Ptr("WindowsServer"),
// SKU: to.Ptr("2022-Datacenter"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// OSDisk: &armbatch.OSDisk{
// Caching: to.Ptr(armbatch.CachingTypeNone),
// ManagedDisk: &armbatch.ManagedDisk{
// StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
// DiskEncryptionSet: &armbatch.DiskEncryptionSetParameters{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
// },
// },
// },
// SecurityProfile: &armbatch.SecurityProfile{
// EncryptionAtHost: to.Ptr(false),
// },
// },
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// ResizeTimeout: to.Ptr("PT15M"),
// },
// },
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// TargetDedicatedNodes: to.Ptr[int32](1),
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-06-30T07:45:46.1580724Z"); return t}()),
// },
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_DiskEncryptionSet_ForUserSubscriptionAccounts.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_D4ds_v5",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2022-Datacenter",
Version = "latest",
}, "batch.node.windows amd64")
{
OSDisk = new BatchOSDisk
{
ManagedDisk = new ManagedDisk
{
StorageAccountType = BatchStorageAccountType.StandardLrs,
DiskEncryptionSetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"),
},
},
SecurityProfile = new BatchSecurityProfile
{
EncryptionAtHost = false,
},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
ResizeTimeout = XmlConvert.ToTimeSpan("PT15M"),
TargetDedicatedNodes = 1,
},
},
TaskSchedulingPolicy = new BatchTaskSchedulingPolicy(BatchNodeFillType.Pack),
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"etag": "W/\"0x8D4EDFEBFADF4AB\"",
"properties": {
"lastModified": "2025-06-30T07:45:46.1580726Z",
"creationTime": "2025-06-30T07:35:44.5579791Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2025-06-30T07:35:44.5579791Z",
"allocationState": "Resizing",
"allocationStateTransitionTime": "2025-06-30T07:45:46.1580727Z",
"vmSize": "Standard_D4ds_v5",
"interNodeCommunication": "Disabled",
"taskSlotsPerNode": 1,
"taskSchedulingPolicy": {
"nodeFillType": "Pack",
"jobDefaultOrder": "None"
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "MicrosoftWindowsServer",
"offer": "WindowsServer",
"sku": "2022-Datacenter",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"osDisk": {
"caching": "None",
"managedDisk": {
"storageAccountType": "Standard_LRS",
"diskEncryptionSet": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/diskEncryptionSets/DiskEncryptionSetId"
}
}
},
"securityProfile": {
"encryptionAtHost": false
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0,
"resizeTimeout": "PT15M"
}
},
"resizeOperationStatus": {
"targetDedicatedNodes": 1,
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2025-06-30T07:45:46.1580724Z"
},
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0
}
}
CreatePool - dual stack networking
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch/providers/Microsoft.Batch/batchAccounts/exampleacc/pools/dualstackpool?api-version=2025-06-01
{
"properties": {
"vmSize": "Standard_D4ds_v5",
"networkConfiguration": {
"publicIPAddressConfiguration": {
"ipFamilies": [
"IPv4",
"IPv6"
]
},
"endpointConfiguration": {
"inboundNatPools": [
{
"backendPort": 22,
"frontendPortRangeStart": 40000,
"frontendPortRangeEnd": 40500,
"name": "sshpool",
"protocol": "TCP",
"networkSecurityGroupRules": [
{
"access": "Allow",
"priority": 1000,
"sourceAddressPrefix": "*",
"sourcePortRanges": [
"*"
]
}
]
}
]
}
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "Canonical",
"offer": "ubuntu-24_04-lts",
"sku": "server"
},
"nodeAgentSkuId": "batch.node.ubuntu 24.04"
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
}
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_DualStackNetworking.json
func ExamplePoolClient_Create_createPoolDualStackNetworking() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch", "exampleacc", "dualstackpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
VMSize: to.Ptr("Standard_D4ds_v5"),
NetworkConfiguration: &armbatch.NetworkConfiguration{
PublicIPAddressConfiguration: &armbatch.PublicIPAddressConfiguration{
IPFamilies: []*armbatch.IPFamily{
to.Ptr(armbatch.IPFamilyIPv4),
to.Ptr(armbatch.IPFamilyIPv6),
},
},
EndpointConfiguration: &armbatch.PoolEndpointConfiguration{
InboundNatPools: []*armbatch.InboundNatPool{
{
BackendPort: to.Ptr[int32](22),
FrontendPortRangeStart: to.Ptr[int32](40000),
FrontendPortRangeEnd: to.Ptr[int32](40500),
Name: to.Ptr("sshpool"),
Protocol: to.Ptr(armbatch.InboundEndpointProtocolTCP),
NetworkSecurityGroupRules: []*armbatch.NetworkSecurityGroupRule{
{
Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessAllow),
Priority: to.Ptr[int32](1000),
SourceAddressPrefix: to.Ptr("*"),
SourcePortRanges: []*string{
to.Ptr("*"),
},
},
},
},
},
},
},
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Publisher: to.Ptr("Canonical"),
Offer: to.Ptr("ubuntu-24_04-lts"),
SKU: to.Ptr("server"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 24.04"),
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/dualstackpool"),
// Name: to.Ptr("dualstackpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// Etag: to.Ptr("W/\"0x8DDC34D4A01A419\""),
// Properties: &armbatch.PoolProperties{
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-07-15T03:11:27.7998105Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-07-15T03:11:27.7997967Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-07-15T03:11:27.7997967Z"); return t}()),
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-07-15T03:11:27.7998136Z"); return t}()),
// VMSize: to.Ptr("Standard_D4ds_v5"),
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// TaskSlotsPerNode: to.Ptr[int32](1),
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// JobDefaultOrder: to.Ptr(armbatch.JobDefaultOrderNone),
// },
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Publisher: to.Ptr("Canonical"),
// Offer: to.Ptr("ubuntu-24_04-lts"),
// SKU: to.Ptr("server"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 24.04"),
// },
// },
// NetworkConfiguration: &armbatch.NetworkConfiguration{
// PublicIPAddressConfiguration: &armbatch.PublicIPAddressConfiguration{
// IPFamilies: []*armbatch.IPFamily{
// to.Ptr(armbatch.IPFamilyIPv4),
// to.Ptr(armbatch.IPFamilyIPv6),
// },
// },
// EndpointConfiguration: &armbatch.PoolEndpointConfiguration{
// InboundNatPools: []*armbatch.InboundNatPool{
// {
// Name: to.Ptr("sshpool"),
// Protocol: to.Ptr(armbatch.InboundEndpointProtocolTCP),
// BackendPort: to.Ptr[int32](22),
// FrontendPortRangeStart: to.Ptr[int32](40000),
// FrontendPortRangeEnd: to.Ptr[int32](40500),
// NetworkSecurityGroupRules: []*armbatch.NetworkSecurityGroupRule{
// {
// Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessAllow),
// SourceAddressPrefix: to.Ptr("*"),
// Priority: to.Ptr[int32](1000),
// SourcePortRanges: []*string{
// to.Ptr("*"),
// },
// },
// },
// },
// },
// },
// DynamicVNetAssignmentScope: to.Ptr(armbatch.DynamicVNetAssignmentScopeNone),
// EnableAcceleratedNetworking: to.Ptr(false),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// ResizeTimeout: to.Ptr("PT15M"),
// },
// },
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// TargetDedicatedNodes: to.Ptr[int32](1),
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-07-15T03:11:27.7994621Z"); return t}()),
// },
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_DualStackNetworking.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch";
string accountName = "exampleacc";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "dualstackpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_D4ds_v5",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "Canonical",
Offer = "ubuntu-24_04-lts",
Sku = "server",
}, "batch.node.ubuntu 24.04"),
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 1,
TargetLowPriorityNodes = 0,
},
},
NetworkConfiguration = new BatchNetworkConfiguration
{
EndpointInboundNatPools = {new BatchInboundNatPool("sshpool", BatchInboundEndpointProtocol.Tcp, 22, 40000, 40500)
{
NetworkSecurityGroupRules = {new BatchNetworkSecurityGroupRule(1000, BatchNetworkSecurityGroupRuleAccess.Allow, "*")
{
SourcePortRanges = {"*"},
}},
}},
PublicIPAddressConfiguration = new BatchPublicIPAddressConfiguration
{
IPFamilies = { BatchIPFamily.IPv4, BatchIPFamily.IPv6 },
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/dualstackpool",
"name": "dualstackpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"etag": "W/\"0x8DDC34D4A01A419\"",
"properties": {
"lastModified": "2025-07-15T03:11:27.7998105Z",
"creationTime": "2025-07-15T03:11:27.7997967Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2025-07-15T03:11:27.7997967Z",
"allocationState": "Resizing",
"allocationStateTransitionTime": "2025-07-15T03:11:27.7998136Z",
"vmSize": "Standard_D4ds_v5",
"interNodeCommunication": "Disabled",
"taskSlotsPerNode": 1,
"taskSchedulingPolicy": {
"nodeFillType": "Spread",
"jobDefaultOrder": "None"
},
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "Canonical",
"offer": "ubuntu-24_04-lts",
"sku": "server",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 24.04"
}
},
"networkConfiguration": {
"publicIPAddressConfiguration": {
"ipFamilies": [
"IPv4",
"IPv6"
]
},
"endpointConfiguration": {
"inboundNatPools": [
{
"name": "sshpool",
"protocol": "TCP",
"backendPort": 22,
"frontendPortRangeStart": 40000,
"frontendPortRangeEnd": 40500,
"networkSecurityGroupRules": [
{
"access": "Allow",
"sourceAddressPrefix": "*",
"priority": 1000,
"sourcePortRanges": [
"*"
]
}
]
}
]
},
"dynamicVnetAssignmentScope": "none",
"enableAcceleratedNetworking": false
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0,
"resizeTimeout": "PT15M"
}
},
"resizeOperationStatus": {
"targetDedicatedNodes": 1,
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2025-07-15T03:11:27.7994621Z"
},
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0
}
}
CreatePool - Full VirtualMachineConfiguration
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"dataDisks": [
{
"caching": "ReadWrite",
"diskSizeGB": 30,
"lun": 0,
"managedDisk": {
"storageAccountType": "StandardSSD_LRS"
}
},
{
"caching": "None",
"diskSizeGB": 200,
"lun": 1,
"managedDisk": {
"storageAccountType": "Premium_LRS"
}
}
],
"diskEncryptionConfiguration": {
"targets": [
"OsDisk",
"TemporaryDisk"
]
},
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2016-Datacenter-SmallDisk",
"version": "latest"
},
"licenseType": "Windows_Server",
"nodeAgentSkuId": "batch.node.windows amd64",
"nodePlacementConfiguration": {
"policy": "Zonal"
},
"osDisk": {
"ephemeralOSDiskSettings": {
"placement": "CacheDisk"
}
},
"windowsConfiguration": {
"enableAutomaticUpdates": false
}
}
},
"networkConfiguration": {
"endpointConfiguration": {
"inboundNatPools": [
{
"name": "testnat",
"backendPort": 12001,
"frontendPortRangeEnd": 15100,
"frontendPortRangeStart": 15000,
"networkSecurityGroupRules": [
{
"access": "Allow",
"priority": 150,
"sourceAddressPrefix": "192.100.12.45",
"sourcePortRanges": [
"1",
"2"
]
},
{
"access": "Deny",
"priority": 3500,
"sourceAddressPrefix": "*",
"sourcePortRanges": [
"*"
]
}
],
"protocol": "TCP"
}
]
}
},
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_VirtualMachineConfiguration.json
func ExamplePoolClient_Create_createPoolFullVirtualMachineConfiguration() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
DataDisks: []*armbatch.DataDisk{
{
Caching: to.Ptr(armbatch.CachingTypeReadWrite),
DiskSizeGB: to.Ptr[int32](30),
Lun: to.Ptr[int32](0),
ManagedDisk: &armbatch.ManagedDisk{
StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardSSDLRS),
},
},
{
Caching: to.Ptr(armbatch.CachingTypeNone),
DiskSizeGB: to.Ptr[int32](200),
Lun: to.Ptr[int32](1),
ManagedDisk: &armbatch.ManagedDisk{
StorageAccountType: to.Ptr(armbatch.StorageAccountTypePremiumLRS),
},
},
},
DiskEncryptionConfiguration: &armbatch.DiskEncryptionConfiguration{
Targets: []*armbatch.DiskEncryptionTarget{
to.Ptr(armbatch.DiskEncryptionTargetOsDisk),
to.Ptr(armbatch.DiskEncryptionTargetTemporaryDisk),
},
},
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("WindowsServer"),
Publisher: to.Ptr("MicrosoftWindowsServer"),
SKU: to.Ptr("2016-Datacenter-SmallDisk"),
Version: to.Ptr("latest"),
},
LicenseType: to.Ptr("Windows_Server"),
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
NodePlacementConfiguration: &armbatch.NodePlacementConfiguration{
Policy: to.Ptr(armbatch.NodePlacementPolicyTypeZonal),
},
OSDisk: &armbatch.OSDisk{
EphemeralOSDiskSettings: &armbatch.DiffDiskSettings{
Placement: to.Ptr("CacheDisk"),
},
},
WindowsConfiguration: &armbatch.WindowsConfiguration{
EnableAutomaticUpdates: to.Ptr(false),
},
},
},
NetworkConfiguration: &armbatch.NetworkConfiguration{
EndpointConfiguration: &armbatch.PoolEndpointConfiguration{
InboundNatPools: []*armbatch.InboundNatPool{
{
Name: to.Ptr("testnat"),
BackendPort: to.Ptr[int32](12001),
FrontendPortRangeEnd: to.Ptr[int32](15100),
FrontendPortRangeStart: to.Ptr[int32](15000),
NetworkSecurityGroupRules: []*armbatch.NetworkSecurityGroupRule{
{
Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessAllow),
Priority: to.Ptr[int32](150),
SourceAddressPrefix: to.Ptr("192.100.12.45"),
SourcePortRanges: []*string{
to.Ptr("1"),
to.Ptr("2"),
},
},
{
Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessDeny),
Priority: to.Ptr[int32](3500),
SourceAddressPrefix: to.Ptr("*"),
SourcePortRanges: []*string{
to.Ptr("*"),
},
},
},
Protocol: to.Ptr(armbatch.InboundEndpointProtocolTCP),
},
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
AutoScale: &armbatch.AutoScaleSettings{
EvaluationInterval: to.Ptr("PT5M"),
Formula: to.Ptr("$TargetDedicatedNodes=1"),
},
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// DataDisks: []*armbatch.DataDisk{
// {
// Caching: to.Ptr(armbatch.CachingTypeReadWrite),
// DiskSizeGB: to.Ptr[int32](30),
// Lun: to.Ptr[int32](0),
// ManagedDisk: &armbatch.ManagedDisk{
// StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardSSDLRS),
// },
// },
// {
// Caching: to.Ptr(armbatch.CachingTypeNone),
// DiskSizeGB: to.Ptr[int32](200),
// Lun: to.Ptr[int32](1),
// ManagedDisk: &armbatch.ManagedDisk{
// StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardLRS),
// },
// },
// },
// DiskEncryptionConfiguration: &armbatch.DiskEncryptionConfiguration{
// Targets: []*armbatch.DiskEncryptionTarget{
// to.Ptr(armbatch.DiskEncryptionTargetOsDisk),
// to.Ptr(armbatch.DiskEncryptionTargetTemporaryDisk),
// },
// },
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("WindowsServer"),
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// SKU: to.Ptr("2016-Datacenter-SmallDisk"),
// Version: to.Ptr("latest"),
// },
// LicenseType: to.Ptr("Windows_Server"),
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// NodePlacementConfiguration: &armbatch.NodePlacementConfiguration{
// Policy: to.Ptr(armbatch.NodePlacementPolicyTypeZonal),
// },
// WindowsConfiguration: &armbatch.WindowsConfiguration{
// EnableAutomaticUpdates: to.Ptr(false),
// },
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// NetworkConfiguration: &armbatch.NetworkConfiguration{
// EndpointConfiguration: &armbatch.PoolEndpointConfiguration{
// InboundNatPools: []*armbatch.InboundNatPool{
// {
// Name: to.Ptr("testnat"),
// BackendPort: to.Ptr[int32](12001),
// FrontendPortRangeEnd: to.Ptr[int32](15100),
// FrontendPortRangeStart: to.Ptr[int32](15000),
// NetworkSecurityGroupRules: []*armbatch.NetworkSecurityGroupRule{
// {
// Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessAllow),
// Priority: to.Ptr[int32](150),
// SourceAddressPrefix: to.Ptr("192.100.12.45"),
// SourcePortRanges: []*string{
// to.Ptr("1"),
// to.Ptr("2"),
// },
// },
// {
// Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessDeny),
// Priority: to.Ptr[int32](3500),
// SourceAddressPrefix: to.Ptr("*"),
// SourcePortRanges: []*string{
// to.Ptr("*"),
// },
// },
// },
// Protocol: to.Ptr(armbatch.InboundEndpointProtocolTCP),
// },
// },
// },
// },
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// AutoScale: &armbatch.AutoScaleSettings{
// EvaluationInterval: to.Ptr("PT5M"),
// Formula: to.Ptr("$TargetDedicatedNodes=1"),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_VirtualMachineConfiguration.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2016-Datacenter-SmallDisk",
Version = "latest",
}, "batch.node.windows amd64")
{
IsAutomaticUpdateEnabled = false,
DataDisks = {new BatchVmDataDisk(0, 30)
{
Caching = BatchDiskCachingType.ReadWrite,
ManagedDisk = new ManagedDisk
{
StorageAccountType = BatchStorageAccountType.StandardSsdLrs,
},
}, new BatchVmDataDisk(1, 200)
{
Caching = BatchDiskCachingType.None,
ManagedDisk = new ManagedDisk
{
StorageAccountType = BatchStorageAccountType.PremiumLrs,
},
}},
LicenseType = "Windows_Server",
DiskEncryptionConfiguration = new BatchDiskEncryptionConfiguration
{
Targets = { BatchDiskEncryptionTarget.OSDisk, BatchDiskEncryptionTarget.TemporaryDisk },
},
NodePlacementPolicy = BatchNodePlacementPolicyType.Zonal,
OSDisk = new BatchOSDisk
{
EphemeralOSDiskPlacement = BatchDiffDiskPlacement.CacheDisk,
},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
AutoScale = new BatchAccountAutoScaleSettings("$TargetDedicatedNodes=1")
{
EvaluationInterval = XmlConvert.ToTimeSpan("PT5M"),
},
},
NetworkConfiguration = new BatchNetworkConfiguration
{
EndpointInboundNatPools = {new BatchInboundNatPool("testnat", BatchInboundEndpointProtocol.Tcp, 12001, 15000, 15100)
{
NetworkSecurityGroupRules = {new BatchNetworkSecurityGroupRule(150, BatchNetworkSecurityGroupRuleAccess.Allow, "192.100.12.45")
{
SourcePortRanges = {"1", "2"},
}, new BatchNetworkSecurityGroupRule(3500, BatchNetworkSecurityGroupRuleAccess.Deny, "*")
{
SourcePortRanges = {"*"},
}},
}},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"creationTime": "2017-08-28T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"dataDisks": [
{
"caching": "ReadWrite",
"diskSizeGB": 30,
"lun": 0,
"managedDisk": {
"storageAccountType": "StandardSSD_LRS"
}
},
{
"caching": "None",
"diskSizeGB": 200,
"lun": 1,
"managedDisk": {
"storageAccountType": "Standard_LRS"
}
}
],
"diskEncryptionConfiguration": {
"targets": [
"OsDisk",
"TemporaryDisk"
]
},
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2016-Datacenter-SmallDisk",
"version": "latest"
},
"licenseType": "Windows_Server",
"nodeAgentSkuId": "batch.node.windows amd64",
"nodePlacementConfiguration": {
"policy": "Zonal"
},
"windowsConfiguration": {
"enableAutomaticUpdates": false
}
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2017-08-28T10:22:55.9407275Z",
"networkConfiguration": {
"endpointConfiguration": {
"inboundNatPools": [
{
"name": "testnat",
"backendPort": 12001,
"frontendPortRangeEnd": 15100,
"frontendPortRangeStart": 15000,
"networkSecurityGroupRules": [
{
"access": "Allow",
"priority": 150,
"sourceAddressPrefix": "192.100.12.45",
"sourcePortRanges": [
"1",
"2"
]
},
{
"access": "Deny",
"priority": 3500,
"sourceAddressPrefix": "*",
"sourcePortRanges": [
"*"
]
}
],
"protocol": "TCP"
}
]
}
},
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - Minimal VirtualMachineConfiguration
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "UbuntuServer",
"publisher": "Canonical",
"sku": "18.04-LTS",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_MinimalVirtualMachineConfiguration.json
func ExamplePoolClient_Create_createPoolMinimalVirtualMachineConfiguration() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("UbuntuServer"),
Publisher: to.Ptr("Canonical"),
SKU: to.Ptr("18.04-LTS"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
},
},
ScaleSettings: &armbatch.ScaleSettings{
AutoScale: &armbatch.AutoScaleSettings{
EvaluationInterval: to.Ptr("PT5M"),
Formula: to.Ptr("$TargetDedicatedNodes=1"),
},
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("UbuntuServer"),
// Publisher: to.Ptr("Canonical"),
// SKU: to.Ptr("18.04-LTS"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// AutoScale: &armbatch.AutoScaleSettings{
// EvaluationInterval: to.Ptr("PT5M"),
// Formula: to.Ptr("$TargetDedicatedNodes=1"),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_MinimalVirtualMachineConfiguration.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "Canonical",
Offer = "UbuntuServer",
Sku = "18.04-LTS",
Version = "latest",
}, "batch.node.ubuntu 18.04"),
ScaleSettings = new BatchAccountPoolScaleSettings
{
AutoScale = new BatchAccountAutoScaleSettings("$TargetDedicatedNodes=1")
{
EvaluationInterval = XmlConvert.ToTimeSpan("PT5M"),
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"creationTime": "2017-08-28T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "UbuntuServer",
"publisher": "Canonical",
"sku": "18.04-LTS",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2017-08-28T10:22:55.9407275Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - No public IP
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"networkConfiguration": {
"publicIPAddressConfiguration": {
"provision": "NoPublicIPAddresses"
},
"subnetId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_NoPublicIPAddresses.json
func ExamplePoolClient_Create_createPoolNoPublicIP() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
},
},
NetworkConfiguration: &armbatch.NetworkConfiguration{
PublicIPAddressConfiguration: &armbatch.PublicIPAddressConfiguration{
Provision: to.Ptr(armbatch.IPAddressProvisioningTypeNoPublicIPAddresses),
},
SubnetID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateSteady),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// NetworkConfiguration: &armbatch.NetworkConfiguration{
// PublicIPAddressConfiguration: &armbatch.PublicIPAddressConfiguration{
// Provision: to.Ptr(armbatch.IPAddressProvisioningTypeNoPublicIPAddresses),
// },
// SubnetID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
// },
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](0),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_NoPublicIPAddresses.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Id = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
}, "batch.node.ubuntu 18.04"),
NetworkConfiguration = new BatchNetworkConfiguration
{
SubnetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
PublicIPAddressConfiguration = new BatchPublicIPAddressConfiguration
{
Provision = BatchIPAddressProvisioningType.NoPublicIPAddresses,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Steady",
"allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"creationTime": "2017-08-28T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2017-08-28T10:22:55.9407275Z",
"networkConfiguration": {
"publicIPAddressConfiguration": {
"provision": "NoPublicIPAddresses"
},
"subnetId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"
},
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 0,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - Public IPs
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"networkConfiguration": {
"publicIPAddressConfiguration": {
"ipAddressIds": [
"/subscriptions/12345678-1234-1234-1234-1234567890121/resourceGroups/rg13/providers/Microsoft.Network/publicIPAddresses/ip135"
],
"provision": "UserManaged"
},
"subnetId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_PublicIPs.json
func ExamplePoolClient_Create_createPoolPublicIPs() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
},
},
NetworkConfiguration: &armbatch.NetworkConfiguration{
PublicIPAddressConfiguration: &armbatch.PublicIPAddressConfiguration{
IPAddressIDs: []*string{
to.Ptr("/subscriptions/12345678-1234-1234-1234-1234567890121/resourceGroups/rg13/providers/Microsoft.Network/publicIPAddresses/ip135"),
},
Provision: to.Ptr(armbatch.IPAddressProvisioningTypeUserManaged),
},
SubnetID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateSteady),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// NetworkConfiguration: &armbatch.NetworkConfiguration{
// PublicIPAddressConfiguration: &armbatch.PublicIPAddressConfiguration{
// IPAddressIDs: []*string{
// to.Ptr("/subscriptions/12345678-1234-1234-1234-1234567890121/resourceGroups/rg13/providers/Microsoft.Network/publicIPAddresses/ip135"),
// },
// Provision: to.Ptr(armbatch.IPAddressProvisioningTypeUserManaged),
// },
// SubnetID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
// },
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// TargetDedicatedNodes: to.Ptr[int32](0),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_PublicIPs.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Id = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"),
}, "batch.node.ubuntu 18.04"),
NetworkConfiguration = new BatchNetworkConfiguration
{
SubnetId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"),
PublicIPAddressConfiguration = new BatchPublicIPAddressConfiguration
{
Provision = BatchIPAddressProvisioningType.UserManaged,
IPAddressIds = { new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-1234567890121/resourceGroups/rg13/providers/Microsoft.Network/publicIPAddresses/ip135") },
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Steady",
"allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"creationTime": "2017-08-28T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/networking-group/providers/Microsoft.Compute/galleries/testgallery/images/testimagedef/versions/0.0.1"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2017-08-28T10:22:55.9407275Z",
"networkConfiguration": {
"publicIPAddressConfiguration": {
"ipAddressIds": [
"/subscriptions/12345678-1234-1234-1234-1234567890121/resourceGroups/rg13/providers/Microsoft.Network/publicIPAddresses/ip135"
],
"provision": "UserManaged"
},
"subnetId": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123"
},
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 0,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - SecurityProfile
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "UbuntuServer",
"publisher": "Canonical",
"sku": "18_04-lts-gen2",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04",
"securityProfile": {
"encryptionAtHost": true,
"securityType": "trustedLaunch",
"uefiSettings": {
"secureBootEnabled": null,
"vTpmEnabled": false
}
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"vmSize": "Standard_d4s_v3"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_SecurityProfile.json
func ExamplePoolClient_Create_createPoolSecurityProfile() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("UbuntuServer"),
Publisher: to.Ptr("Canonical"),
SKU: to.Ptr("18_04-lts-gen2"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
SecurityProfile: &armbatch.SecurityProfile{
EncryptionAtHost: to.Ptr(true),
SecurityType: to.Ptr(armbatch.SecurityTypesTrustedLaunch),
UefiSettings: &armbatch.UefiSettings{
VTpmEnabled: to.Ptr(false),
},
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
VMSize: to.Ptr("Standard_d4s_v3"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8DB554F8E08BCF4\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("UbuntuServer"),
// Publisher: to.Ptr("Canonical"),
// SKU: to.Ptr("18_04-lts-gen2"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
// SecurityProfile: &armbatch.SecurityProfile{
// EncryptionAtHost: to.Ptr(true),
// SecurityType: to.Ptr(armbatch.SecurityTypesTrustedLaunch),
// UefiSettings: &armbatch.UefiSettings{
// VTpmEnabled: to.Ptr(false),
// },
// },
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// TargetDedicatedNodes: to.Ptr[int32](1),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// ResizeTimeout: to.Ptr("PT15M"),
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4S_V3"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_SecurityProfile.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_d4s_v3",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "Canonical",
Offer = "UbuntuServer",
Sku = "18_04-lts-gen2",
Version = "latest",
}, "batch.node.ubuntu 18.04")
{
SecurityProfile = new BatchSecurityProfile
{
SecurityType = BatchSecurityType.TrustedLaunch,
EncryptionAtHost = true,
UefiSettings = new BatchUefiSettings
{
IsSecureBootEnabled = default,
IsVTpmEnabled = false,
},
},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 1,
TargetLowPriorityNodes = 0,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8DB554F8E08BCF4"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2023-06-14T07:03:58.3231917Z",
"creationTime": "2023-06-14T07:03:58.3231917Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "UbuntuServer",
"publisher": "Canonical",
"sku": "18_04-lts-gen2",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04",
"securityProfile": {
"encryptionAtHost": true,
"securityType": "trustedLaunch",
"uefiSettings": {
"vTpmEnabled": false
}
}
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2023-06-14T07:03:58.3231917Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2023-06-14T07:03:58.3231917Z",
"resizeOperationStatus": {
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2023-06-14T07:03:58.3231917Z",
"targetDedicatedNodes": 1
},
"scaleSettings": {
"fixedScale": {
"resizeTimeout": "PT15M",
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4S_V3"
}
}
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "0001-com-ubuntu-server-jammy",
"publisher": "Canonical",
"sku": "22_04-lts",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 22.04"
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"vmSize": "Standard_d4s_v3"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_Tags.json
func ExamplePoolClient_Create_createPoolTags() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("0001-com-ubuntu-server-jammy"),
Publisher: to.Ptr("Canonical"),
SKU: to.Ptr("22_04-lts"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 22.04"),
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
VMSize: to.Ptr("Standard_d4s_v3"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8DB554F8E08BCF4\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("0001-com-ubuntu-server-jammy"),
// Publisher: to.Ptr("Canonical"),
// SKU: to.Ptr("22_04-lts"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 22.04"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-14T07:03:58.3231917Z"); return t}()),
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-09-27T07:33:13.0625789Z"); return t}()),
// TargetDedicatedNodes: to.Ptr[int32](1),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// ResizeTimeout: to.Ptr("PT15M"),
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4S_V3"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_Tags.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_d4s_v3",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "Canonical",
Offer = "0001-com-ubuntu-server-jammy",
Sku = "22_04-lts",
Version = "latest",
}, "batch.node.ubuntu 22.04"),
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 1,
TargetLowPriorityNodes = 0,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8DB554F8E08BCF4"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2023-06-14T07:03:58.3231917Z",
"creationTime": "2023-06-14T07:03:58.3231917Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "0001-com-ubuntu-server-jammy",
"publisher": "Canonical",
"sku": "22_04-lts",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 22.04"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2023-06-14T07:03:58.3231917Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2023-06-14T07:03:58.3231917Z",
"resizeOperationStatus": {
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2023-09-27T07:33:13.0625789Z",
"targetDedicatedNodes": 1
},
"scaleSettings": {
"fixedScale": {
"resizeTimeout": "PT15M",
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4S_V3"
}
}
CreatePool - UpgradePolicy
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2019-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"nodePlacementConfiguration": {
"policy": "Zonal"
},
"windowsConfiguration": {
"enableAutomaticUpdates": false
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 2,
"targetLowPriorityNodes": 0
}
},
"upgradePolicy": {
"automaticOSUpgradePolicy": {
"disableAutomaticRollback": true,
"enableAutomaticOSUpgrade": true,
"osRollingUpgradeDeferral": true,
"useRollingUpgradePolicy": true
},
"mode": "automatic",
"rollingUpgradePolicy": {
"enableCrossZoneUpgrade": true,
"maxBatchInstancePercent": 20,
"maxUnhealthyInstancePercent": 20,
"maxUnhealthyUpgradedInstancePercent": 20,
"pauseTimeBetweenBatches": "PT0S",
"prioritizeUnhealthyInstances": false,
"rollbackFailedInstancesOnPolicyBreach": false
}
},
"vmSize": "Standard_d4s_v3"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_UpgradePolicy.json
func ExamplePoolClient_Create_createPoolUpgradePolicy() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("WindowsServer"),
Publisher: to.Ptr("MicrosoftWindowsServer"),
SKU: to.Ptr("2019-datacenter-smalldisk"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
NodePlacementConfiguration: &armbatch.NodePlacementConfiguration{
Policy: to.Ptr(armbatch.NodePlacementPolicyTypeZonal),
},
WindowsConfiguration: &armbatch.WindowsConfiguration{
EnableAutomaticUpdates: to.Ptr(false),
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](2),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
UpgradePolicy: &armbatch.UpgradePolicy{
AutomaticOSUpgradePolicy: &armbatch.AutomaticOSUpgradePolicy{
DisableAutomaticRollback: to.Ptr(true),
EnableAutomaticOSUpgrade: to.Ptr(true),
OSRollingUpgradeDeferral: to.Ptr(true),
UseRollingUpgradePolicy: to.Ptr(true),
},
Mode: to.Ptr(armbatch.UpgradeModeAutomatic),
RollingUpgradePolicy: &armbatch.RollingUpgradePolicy{
EnableCrossZoneUpgrade: to.Ptr(true),
MaxBatchInstancePercent: to.Ptr[int32](20),
MaxUnhealthyInstancePercent: to.Ptr[int32](20),
MaxUnhealthyUpgradedInstancePercent: to.Ptr[int32](20),
PauseTimeBetweenBatches: to.Ptr("PT0S"),
PrioritizeUnhealthyInstances: to.Ptr(false),
RollbackFailedInstancesOnPolicyBreach: to.Ptr(false),
},
},
VMSize: to.Ptr("Standard_d4s_v3"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8DB51E64D3C3B69\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T06:16:44.2372184Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T06:16:44.2372184Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("WindowsServer"),
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// SKU: to.Ptr("2019-datacenter-smalldisk"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// NodePlacementConfiguration: &armbatch.NodePlacementConfiguration{
// Policy: to.Ptr(armbatch.NodePlacementPolicyTypeZonal),
// },
// WindowsConfiguration: &armbatch.WindowsConfiguration{
// EnableAutomaticUpdates: to.Ptr(false),
// },
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T06:16:44.2372184Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T06:16:44.2372184Z"); return t}()),
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T06:16:44.2372184Z"); return t}()),
// TargetDedicatedNodes: to.Ptr[int32](2),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// ResizeTimeout: to.Ptr("PT15M"),
// TargetDedicatedNodes: to.Ptr[int32](2),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// UpgradePolicy: &armbatch.UpgradePolicy{
// AutomaticOSUpgradePolicy: &armbatch.AutomaticOSUpgradePolicy{
// DisableAutomaticRollback: to.Ptr(true),
// EnableAutomaticOSUpgrade: to.Ptr(true),
// OSRollingUpgradeDeferral: to.Ptr(true),
// UseRollingUpgradePolicy: to.Ptr(true),
// },
// Mode: to.Ptr(armbatch.UpgradeModeAutomatic),
// RollingUpgradePolicy: &armbatch.RollingUpgradePolicy{
// EnableCrossZoneUpgrade: to.Ptr(true),
// MaxBatchInstancePercent: to.Ptr[int32](20),
// MaxUnhealthyInstancePercent: to.Ptr[int32](20),
// MaxUnhealthyUpgradedInstancePercent: to.Ptr[int32](20),
// PauseTimeBetweenBatches: to.Ptr("PT0S"),
// PrioritizeUnhealthyInstances: to.Ptr(false),
// RollbackFailedInstancesOnPolicyBreach: to.Ptr(false),
// },
// },
// VMSize: to.Ptr("STANDARD_D4S_V3"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_UpgradePolicy.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_d4s_v3",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2019-datacenter-smalldisk",
Version = "latest",
}, "batch.node.windows amd64")
{
IsAutomaticUpdateEnabled = false,
NodePlacementPolicy = BatchNodePlacementPolicyType.Zonal,
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 2,
TargetLowPriorityNodes = 0,
},
},
UpgradePolicy = new UpgradePolicy(UpgradeMode.Automatic)
{
AutomaticOSUpgradePolicy = new AutomaticOSUpgradePolicy
{
DisableAutomaticRollback = true,
EnableAutomaticOSUpgrade = true,
UseRollingUpgradePolicy = true,
OSRollingUpgradeDeferral = true,
},
RollingUpgradePolicy = new RollingUpgradePolicy
{
EnableCrossZoneUpgrade = true,
MaxBatchInstancePercent = 20,
MaxUnhealthyInstancePercent = 20,
MaxUnhealthyUpgradedInstancePercent = 20,
PauseTimeBetweenBatches = "PT0S",
PrioritizeUnhealthyInstances = false,
RollbackFailedInstancesOnPolicyBreach = false,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8DB51E64D3C3B69"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2023-05-11T06:16:44.2372184Z",
"creationTime": "2023-05-11T06:16:44.2372184Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2019-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"nodePlacementConfiguration": {
"policy": "Zonal"
},
"windowsConfiguration": {
"enableAutomaticUpdates": false
}
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2023-05-11T06:16:44.2372184Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2023-05-11T06:16:44.2372184Z",
"resizeOperationStatus": {
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2023-05-11T06:16:44.2372184Z",
"targetDedicatedNodes": 2
},
"scaleSettings": {
"fixedScale": {
"resizeTimeout": "PT15M",
"targetDedicatedNodes": 2,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"upgradePolicy": {
"automaticOSUpgradePolicy": {
"disableAutomaticRollback": true,
"enableAutomaticOSUpgrade": true,
"osRollingUpgradeDeferral": true,
"useRollingUpgradePolicy": true
},
"mode": "automatic",
"rollingUpgradePolicy": {
"enableCrossZoneUpgrade": true,
"maxBatchInstancePercent": 20,
"maxUnhealthyInstancePercent": 20,
"maxUnhealthyUpgradedInstancePercent": 20,
"pauseTimeBetweenBatches": "PT0S",
"prioritizeUnhealthyInstances": false,
"rollbackFailedInstancesOnPolicyBreach": false
}
},
"vmSize": "STANDARD_D4S_V3"
}
}
CreatePool - UserAssignedIdentities
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"identity": {
"type": "UserAssigned",
"userAssignedIdentities": {
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {},
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2": {}
}
},
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "UbuntuServer",
"publisher": "Canonical",
"sku": "18.04-LTS",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_UserAssignedIdentities.json
func ExamplePoolClient_Create_createPoolUserAssignedIdentities() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Identity: &armbatch.PoolIdentity{
Type: to.Ptr(armbatch.PoolIdentityTypeUserAssigned),
UserAssignedIdentities: map[string]*armbatch.UserAssignedIdentities{
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {},
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2": {},
},
},
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("UbuntuServer"),
Publisher: to.Ptr("Canonical"),
SKU: to.Ptr("18.04-LTS"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
},
},
ScaleSettings: &armbatch.ScaleSettings{
AutoScale: &armbatch.AutoScaleSettings{
EvaluationInterval: to.Ptr("PT5M"),
Formula: to.Ptr("$TargetDedicatedNodes=1"),
},
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Identity: &armbatch.PoolIdentity{
// Type: to.Ptr(armbatch.PoolIdentityTypeUserAssigned),
// UserAssignedIdentities: map[string]*armbatch.UserAssignedIdentities{
// "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": &armbatch.UserAssignedIdentities{
// ClientID: to.Ptr("clientId1"),
// PrincipalID: to.Ptr("principalId1"),
// },
// "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2": &armbatch.UserAssignedIdentities{
// ClientID: to.Ptr("clientId2"),
// PrincipalID: to.Ptr("principalId2"),
// },
// },
// },
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-10-01T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-10-01T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("UbuntuServer"),
// Publisher: to.Ptr("Canonical"),
// SKU: to.Ptr("18.04-LTS"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 18.04"),
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-10-01T10:22:55.9407275Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-10-01T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// AutoScale: &armbatch.AutoScaleSettings{
// EvaluationInterval: to.Ptr("PT5M"),
// Formula: to.Ptr("$TargetDedicatedNodes=1"),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_UserAssignedIdentities.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
Identity = new ManagedServiceIdentity("UserAssigned")
{
UserAssignedIdentities =
{
[new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1")] = new UserAssignedIdentity(),
[new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2")] = new UserAssignedIdentity()
},
},
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "Canonical",
Offer = "UbuntuServer",
Sku = "18.04-LTS",
Version = "latest",
}, "batch.node.ubuntu 18.04"),
ScaleSettings = new BatchAccountPoolScaleSettings
{
AutoScale = new BatchAccountAutoScaleSettings("$TargetDedicatedNodes=1")
{
EvaluationInterval = XmlConvert.ToTimeSpan("PT5M"),
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"identity": {
"type": "UserAssigned",
"userAssignedIdentities": {
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {
"clientId": "clientId1",
"principalId": "principalId1"
},
"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2": {
"clientId": "clientId2",
"principalId": "principalId2"
}
}
},
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2020-10-01T10:22:55.9407275Z",
"creationTime": "2020-10-01T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "UbuntuServer",
"publisher": "Canonical",
"sku": "18.04-LTS",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.ubuntu 18.04"
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2020-10-01T10:22:55.9407275Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2020-10-01T10:22:55.9407275Z",
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - VirtualMachineConfiguration Extensions
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "0001-com-ubuntu-server-focal",
"publisher": "Canonical",
"sku": "20_04-lts"
},
"nodeAgentSkuId": "batch.node.ubuntu 20.04",
"extensions": [
{
"name": "batchextension1",
"type": "KeyVaultForLinux",
"autoUpgradeMinorVersion": true,
"enableAutomaticUpgrade": true,
"publisher": "Microsoft.Azure.KeyVault",
"settings": {
"authenticationSettingsKey": "authenticationSettingsValue",
"secretsManagementSettingsKey": "secretsManagementSettingsValue"
},
"typeHandlerVersion": "2.0"
}
]
}
},
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"vmSize": "STANDARD_D4"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_VirtualMachineConfiguration_Extensions.json
func ExamplePoolClient_Create_createPoolVirtualMachineConfigurationExtensions() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("0001-com-ubuntu-server-focal"),
Publisher: to.Ptr("Canonical"),
SKU: to.Ptr("20_04-lts"),
},
NodeAgentSKUID: to.Ptr("batch.node.ubuntu 20.04"),
Extensions: []*armbatch.VMExtension{
{
Name: to.Ptr("batchextension1"),
Type: to.Ptr("KeyVaultForLinux"),
AutoUpgradeMinorVersion: to.Ptr(true),
EnableAutomaticUpgrade: to.Ptr(true),
Publisher: to.Ptr("Microsoft.Azure.KeyVault"),
Settings: map[string]any{
"authenticationSettingsKey": "authenticationSettingsValue",
"secretsManagementSettingsKey": "secretsManagementSettingsValue",
},
TypeHandlerVersion: to.Ptr("2.0"),
},
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
AutoScale: &armbatch.AutoScaleSettings{
EvaluationInterval: to.Ptr("PT5M"),
Formula: to.Ptr("$TargetDedicatedNodes=1"),
},
},
VMSize: to.Ptr("STANDARD_D4"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8D4EDFEBFADF4AB\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("0001-com-ubuntu-server-focal"),
// Publisher: to.Ptr("Canonical"),
// SKU: to.Ptr("20_04-lts"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.ubuntu 20.04"),
// Extensions: []*armbatch.VMExtension{
// {
// Name: to.Ptr("batchextension1"),
// Type: to.Ptr("KeyVaultForLinux"),
// AutoUpgradeMinorVersion: to.Ptr(true),
// EnableAutomaticUpgrade: to.Ptr(true),
// Publisher: to.Ptr("Microsoft.Azure.KeyVault"),
// Settings: map[string]any{
// "authenticationSettingsKey": "authenticationSettingsValue",
// "secretsManagementSettingsKey": "secretsManagementSettingsValue",
// },
// TypeHandlerVersion: to.Ptr("2.0"),
// },
// },
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.9407275Z"); return t}()),
// ScaleSettings: &armbatch.ScaleSettings{
// AutoScale: &armbatch.AutoScaleSettings{
// EvaluationInterval: to.Ptr("PT5M"),
// Formula: to.Ptr("$TargetDedicatedNodes=1"),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D4"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_VirtualMachineConfiguration_Extensions.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "STANDARD_D4",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "Canonical",
Offer = "0001-com-ubuntu-server-focal",
Sku = "20_04-lts",
}, "batch.node.ubuntu 20.04")
{
Extensions = {new BatchVmExtension("batchextension1", "Microsoft.Azure.KeyVault", "KeyVaultForLinux")
{
TypeHandlerVersion = "2.0",
AutoUpgradeMinorVersion = true,
EnableAutomaticUpgrade = true,
Settings = BinaryData.FromObjectAsJson(new
{
authenticationSettingsKey = "authenticationSettingsValue",
secretsManagementSettingsKey = "secretsManagementSettingsValue",
}),
}},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
AutoScale = new BatchAccountAutoScaleSettings("$TargetDedicatedNodes=1")
{
EvaluationInterval = XmlConvert.ToTimeSpan("PT5M"),
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8D4EDFEBFADF4AB"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"creationTime": "2017-08-28T10:22:55.9407275Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "0001-com-ubuntu-server-focal",
"publisher": "Canonical",
"sku": "20_04-lts"
},
"nodeAgentSkuId": "batch.node.ubuntu 20.04",
"extensions": [
{
"name": "batchextension1",
"type": "KeyVaultForLinux",
"autoUpgradeMinorVersion": true,
"enableAutomaticUpgrade": true,
"publisher": "Microsoft.Azure.KeyVault",
"settings": {
"authenticationSettingsKey": "authenticationSettingsValue",
"secretsManagementSettingsKey": "secretsManagementSettingsValue"
},
"typeHandlerVersion": "2.0"
}
]
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2017-08-28T10:22:55.9407275Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
"scaleSettings": {
"autoScale": {
"evaluationInterval": "PT5M",
"formula": "$TargetDedicatedNodes=1"
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D4"
}
}
CreatePool - VirtualMachineConfiguration OSDisk
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "windowsserver",
"publisher": "microsoftwindowsserver",
"sku": "2022-datacenter-smalldisk"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"osDisk": {
"caching": "ReadWrite",
"diskSizeGB": 100,
"managedDisk": {
"storageAccountType": "StandardSSD_LRS"
},
"writeAcceleratorEnabled": false
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"vmSize": "Standard_d2s_v3"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_VirtualMachineConfiguration_ManagedOSDisk.json
func ExamplePoolClient_Create_createPoolVirtualMachineConfigurationOSDisk() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("windowsserver"),
Publisher: to.Ptr("microsoftwindowsserver"),
SKU: to.Ptr("2022-datacenter-smalldisk"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
OSDisk: &armbatch.OSDisk{
Caching: to.Ptr(armbatch.CachingTypeReadWrite),
DiskSizeGB: to.Ptr[int32](100),
ManagedDisk: &armbatch.ManagedDisk{
StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardSSDLRS),
},
WriteAcceleratorEnabled: to.Ptr(false),
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](1),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
VMSize: to.Ptr("Standard_d2s_v3"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8DB51F14DC1A8AD\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("testpool"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-24T02:12:27.7527697Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-24T02:12:27.7527697Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("windowsserver"),
// Publisher: to.Ptr("microsoftwindowsserver"),
// SKU: to.Ptr("2022-datacenter-smalldisk"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// OSDisk: &armbatch.OSDisk{
// Caching: to.Ptr(armbatch.CachingTypeReadWrite),
// DiskSizeGB: to.Ptr[int32](100),
// ManagedDisk: &armbatch.ManagedDisk{
// StorageAccountType: to.Ptr(armbatch.StorageAccountTypeStandardSSDLRS),
// },
// WriteAcceleratorEnabled: to.Ptr(false),
// },
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-24T02:12:27.7527697Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-24T02:12:27.7527697Z"); return t}()),
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-24T02:12:27.7527697Z"); return t}()),
// TargetDedicatedNodes: to.Ptr[int32](1),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// ResizeTimeout: to.Ptr("PT15M"),
// TargetDedicatedNodes: to.Ptr[int32](1),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// VMSize: to.Ptr("STANDARD_D2_V3"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_VirtualMachineConfiguration_ManagedOSDisk.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_d2s_v3",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "microsoftwindowsserver",
Offer = "windowsserver",
Sku = "2022-datacenter-smalldisk",
}, "batch.node.windows amd64")
{
OSDisk = new BatchOSDisk
{
Caching = BatchDiskCachingType.ReadWrite,
ManagedDisk = new ManagedDisk
{
StorageAccountType = BatchStorageAccountType.StandardSsdLrs,
},
DiskSizeGB = 100,
IsWriteAcceleratorEnabled = false,
},
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 1,
TargetLowPriorityNodes = 0,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8DB51F14DC1A8AD"
{
"name": "testpool",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2023-08-24T02:12:27.7527697Z",
"creationTime": "2023-08-24T02:12:27.7527697Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "windowsserver",
"publisher": "microsoftwindowsserver",
"sku": "2022-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"osDisk": {
"caching": "ReadWrite",
"diskSizeGB": 100,
"managedDisk": {
"storageAccountType": "StandardSSD_LRS"
},
"writeAcceleratorEnabled": false
}
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2023-08-24T02:12:27.7527697Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2023-08-24T02:12:27.7527697Z",
"resizeOperationStatus": {
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2023-08-24T02:12:27.7527697Z",
"targetDedicatedNodes": 1
},
"scaleSettings": {
"fixedScale": {
"resizeTimeout": "PT15M",
"targetDedicatedNodes": 1,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"vmSize": "STANDARD_D2_V3"
}
}
CreatePool - VirtualMachineConfiguration ServiceArtifactReference
Esempio di richiesta
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool?api-version=2025-06-01
{
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2019-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"serviceArtifactReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/galleries/myGallery/serviceArtifacts/myServiceArtifact/vmArtifactsProfiles/vmArtifactsProfile"
},
"windowsConfiguration": {
"enableAutomaticUpdates": false
}
}
},
"scaleSettings": {
"fixedScale": {
"targetDedicatedNodes": 2,
"targetLowPriorityNodes": 0
}
},
"upgradePolicy": {
"automaticOSUpgradePolicy": {
"enableAutomaticOSUpgrade": true
},
"mode": "automatic"
},
"vmSize": "Standard_d4s_v3"
}
}
package armbatch_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/batch/armbatch/v4"
)
// Generated from example definition: 2025-06-01/PoolCreate_VirtualMachineConfiguration_ServiceArtifactReference.json
func ExamplePoolClient_Create_createPoolVirtualMachineConfigurationServiceArtifactReference() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armbatch.NewClientFactory("12345678-1234-1234-1234-123456789012", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPoolClient().Create(ctx, "default-azurebatch-japaneast", "sampleacct", "testpool", armbatch.Pool{
Properties: &armbatch.PoolProperties{
DeploymentConfiguration: &armbatch.DeploymentConfiguration{
VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
ImageReference: &armbatch.ImageReference{
Offer: to.Ptr("WindowsServer"),
Publisher: to.Ptr("MicrosoftWindowsServer"),
SKU: to.Ptr("2019-datacenter-smalldisk"),
Version: to.Ptr("latest"),
},
NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
ServiceArtifactReference: &armbatch.ServiceArtifactReference{
ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/galleries/myGallery/serviceArtifacts/myServiceArtifact/vmArtifactsProfiles/vmArtifactsProfile"),
},
WindowsConfiguration: &armbatch.WindowsConfiguration{
EnableAutomaticUpdates: to.Ptr(false),
},
},
},
ScaleSettings: &armbatch.ScaleSettings{
FixedScale: &armbatch.FixedScaleSettings{
TargetDedicatedNodes: to.Ptr[int32](2),
TargetLowPriorityNodes: to.Ptr[int32](0),
},
},
UpgradePolicy: &armbatch.UpgradePolicy{
AutomaticOSUpgradePolicy: &armbatch.AutomaticOSUpgradePolicy{
EnableAutomaticOSUpgrade: to.Ptr(true),
},
Mode: to.Ptr(armbatch.UpgradeModeAutomatic),
},
VMSize: to.Ptr("Standard_d4s_v3"),
},
}, nil)
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 = armbatch.PoolClientCreateResponse{
// ETag: "W/\"0x8DB51F14DC1A8AD\""
// Pool: &armbatch.Pool{
// Name: to.Ptr("mypool41"),
// Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
// Properties: &armbatch.PoolProperties{
// AllocationState: to.Ptr(armbatch.AllocationStateResizing),
// AllocationStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T07:44:44.8580493Z"); return t}()),
// CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T07:44:44.8580493Z"); return t}()),
// CurrentDedicatedNodes: to.Ptr[int32](0),
// CurrentLowPriorityNodes: to.Ptr[int32](0),
// DeploymentConfiguration: &armbatch.DeploymentConfiguration{
// VirtualMachineConfiguration: &armbatch.VirtualMachineConfiguration{
// ImageReference: &armbatch.ImageReference{
// Offer: to.Ptr("WindowsServer"),
// Publisher: to.Ptr("MicrosoftWindowsServer"),
// SKU: to.Ptr("2019-datacenter-smalldisk"),
// Version: to.Ptr("latest"),
// },
// NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
// ServiceArtifactReference: &armbatch.ServiceArtifactReference{
// ID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/galleries/myGallery/serviceArtifacts/myServiceArtifact/vmArtifactsProfiles/vmArtifactsProfile"),
// },
// WindowsConfiguration: &armbatch.WindowsConfiguration{
// EnableAutomaticUpdates: to.Ptr(false),
// },
// },
// },
// InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateDisabled),
// LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T07:44:44.8580493Z"); return t}()),
// ProvisioningState: to.Ptr(armbatch.PoolProvisioningStateSucceeded),
// ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T07:44:44.8580493Z"); return t}()),
// ResizeOperationStatus: &armbatch.ResizeOperationStatus{
// NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionRequeue),
// ResizeTimeout: to.Ptr("PT15M"),
// StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-11T07:44:44.8580493Z"); return t}()),
// TargetDedicatedNodes: to.Ptr[int32](2),
// },
// ScaleSettings: &armbatch.ScaleSettings{
// FixedScale: &armbatch.FixedScaleSettings{
// ResizeTimeout: to.Ptr("PT15M"),
// TargetDedicatedNodes: to.Ptr[int32](2),
// TargetLowPriorityNodes: to.Ptr[int32](0),
// },
// },
// TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
// NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypeSpread),
// },
// TaskSlotsPerNode: to.Ptr[int32](1),
// UpgradePolicy: &armbatch.UpgradePolicy{
// AutomaticOSUpgradePolicy: &armbatch.AutomaticOSUpgradePolicy{
// EnableAutomaticOSUpgrade: to.Ptr(true),
// },
// Mode: to.Ptr(armbatch.UpgradeModeAutomatic),
// },
// VMSize: to.Ptr("STANDARD_D4S_V3"),
// },
// },
// }
}
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 System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Batch.Models;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Batch;
// Generated from example definition: specification/batch/resource-manager/Microsoft.Batch/Batch/stable/2025-06-01/examples/PoolCreate_VirtualMachineConfiguration_ServiceArtifactReference.json
// this example is just showing the usage of "Pool_Create" 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 BatchAccountResource created on azure
// for more information of creating BatchAccountResource, please refer to the document of BatchAccountResource
string subscriptionId = "12345678-1234-1234-1234-123456789012";
string resourceGroupName = "default-azurebatch-japaneast";
string accountName = "sampleacct";
ResourceIdentifier batchAccountResourceId = BatchAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
BatchAccountResource batchAccount = client.GetBatchAccountResource(batchAccountResourceId);
// get the collection of this BatchAccountPoolResource
BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
// invoke the operation
string poolName = "testpool";
BatchAccountPoolData data = new BatchAccountPoolData
{
VmSize = "Standard_d4s_v3",
DeploymentVmConfiguration = new BatchVmConfiguration(new BatchImageReference
{
Publisher = "MicrosoftWindowsServer",
Offer = "WindowsServer",
Sku = "2019-datacenter-smalldisk",
Version = "latest",
}, "batch.node.windows amd64")
{
IsAutomaticUpdateEnabled = false,
ServiceArtifactReferenceId = new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/galleries/myGallery/serviceArtifacts/myServiceArtifact/vmArtifactsProfiles/vmArtifactsProfile"),
},
ScaleSettings = new BatchAccountPoolScaleSettings
{
FixedScale = new BatchAccountFixedScaleSettings
{
TargetDedicatedNodes = 2,
TargetLowPriorityNodes = 0,
},
},
UpgradePolicy = new UpgradePolicy(UpgradeMode.Automatic)
{
AutomaticOSUpgradePolicy = new AutomaticOSUpgradePolicy
{
EnableAutomaticOSUpgrade = true,
},
},
};
ArmOperation<BatchAccountPoolResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, poolName, data);
BatchAccountPoolResource 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
BatchAccountPoolData 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
Risposta di esempio
ETag: W/"0x8DB51F14DC1A8AD"
{
"name": "mypool41",
"type": "Microsoft.Batch/batchAccounts/pools",
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
"properties": {
"allocationState": "Resizing",
"allocationStateTransitionTime": "2023-05-11T07:44:44.8580493Z",
"creationTime": "2023-05-11T07:44:44.8580493Z",
"currentDedicatedNodes": 0,
"currentLowPriorityNodes": 0,
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"offer": "WindowsServer",
"publisher": "MicrosoftWindowsServer",
"sku": "2019-datacenter-smalldisk",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64",
"serviceArtifactReference": {
"id": "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Compute/galleries/myGallery/serviceArtifacts/myServiceArtifact/vmArtifactsProfiles/vmArtifactsProfile"
},
"windowsConfiguration": {
"enableAutomaticUpdates": false
}
}
},
"interNodeCommunication": "Disabled",
"lastModified": "2023-05-11T07:44:44.8580493Z",
"provisioningState": "Succeeded",
"provisioningStateTransitionTime": "2023-05-11T07:44:44.8580493Z",
"resizeOperationStatus": {
"nodeDeallocationOption": "Requeue",
"resizeTimeout": "PT15M",
"startTime": "2023-05-11T07:44:44.8580493Z",
"targetDedicatedNodes": 2
},
"scaleSettings": {
"fixedScale": {
"resizeTimeout": "PT15M",
"targetDedicatedNodes": 2,
"targetLowPriorityNodes": 0
}
},
"taskSchedulingPolicy": {
"nodeFillType": "Spread"
},
"taskSlotsPerNode": 1,
"upgradePolicy": {
"automaticOSUpgradePolicy": {
"enableAutomaticOSUpgrade": true
},
"mode": "automatic"
},
"vmSize": "STANDARD_D4S_V3"
}
}
Definizioni
| Nome |
Descrizione |
|
AllocationState
|
Indica se il pool sta ridimensionando.
|
|
ApplicationPackageReference
|
Collegamento a un pacchetto dell'applicazione all'interno dell'account batch
|
|
AutomaticOSUpgradePolicy
|
Parametri di configurazione usati per eseguire l'aggiornamento automatico del sistema operativo.
|
|
AutoScaleRun
|
Risultati ed errori da un'esecuzione di una formula di scalabilità automatica del pool.
|
|
AutoScaleRunError
|
Errore che si è verificato durante la scalabilità automatica di un pool.
|
|
AutoScaleSettings
|
Impostazioni di scalabilità automatica per il pool.
|
|
AutoUserScope
|
Il valore predefinito è Pool. Se il pool esegue Windows, è necessario specificare il valore Task se è necessario un isolamento più rigoroso tra le attività. Ad esempio, se l'attività modifica il Registro di sistema in un modo che potrebbe influire su altre attività.
|
|
AutoUserSpecification
|
Specifica i parametri per l'utente automatico che esegue un'attività nel servizio Batch.
|
|
AzureBlobFileSystemConfiguration
|
Informazioni usate per connettersi a un contenitore di archiviazione di Azure usando Blobfuse.
|
|
AzureFileShareConfiguration
|
Informazioni usate per connettersi a una condivisione file di Azure.
|
|
BatchPoolIdentity
|
Identità del pool di Batch, se configurata. Se l'identità del pool viene aggiornata durante l'aggiornamento di un pool esistente, solo le nuove macchine virtuali create dopo che il pool viene ridotto a 0 avranno le identità aggiornate
|
|
CachingType
|
Tipo di memorizzazione nella cache da abilitare per il disco.
|
|
CIFSMountConfiguration
|
Informazioni utilizzate per connettersi a un file system CIFS.
|
|
CloudError
|
Risposta di errore dal servizio Batch.
|
|
CloudErrorBody
|
Risposta di errore dal servizio Batch.
|
|
ComputeNodeDeallocationOption
|
Determina le operazioni da eseguire con un nodo e le relative attività in esecuzione dopo che è stata selezionata per la deallocazione.
|
|
ComputeNodeFillType
|
Modalità di distribuzione delle attività tra i nodi di calcolo.
|
|
ComputeNodeIdentityReference
|
Riferimento a un'identità assegnata dall'utente associata al pool di Batch che verrà usato da un nodo di calcolo.
|
|
ContainerConfiguration
|
Configurazione per i pool abilitati per i contenitori.
|
|
ContainerHostBatchBindMountEntry
|
Voce di percorso e modalità di montaggio da montare nel contenitore di attività.
|
|
ContainerHostDataPath
|
Percorsi che verranno montati nel contenitore dell'attività contenitore.
|
|
ContainerRegistry
|
Registro contenitori privato.
|
|
ContainerType
|
Tecnologia contenitore da usare.
|
|
ContainerWorkingDirectory
|
Flag per indicare dove si trova la directory di lavoro dell'attività contenitore. Il valore predefinito è 'taskWorkingDirectory'.
|
|
createdByType
|
Tipo di identità che ha creato la risorsa.
|
|
DataDisk
|
Impostazioni che verranno usate dai dischi dati associati ai nodi di calcolo nel pool. Quando si usano dischi dati allegati è necessario montare e formattare i dischi all'interno di una macchina virtuale per poterli usare.
|
|
DeploymentConfiguration
|
Proprietà di configurazione della distribuzione.
|
|
DiffDiskPlacement
|
Il luogo dove dovrebbe essere posizionato il disco del sistema operativo.
|
|
DiffDiskSettings
|
Specifica le impostazioni temporanee del disco per il disco del sistema operativo usato dalla macchina virtuale.
|
|
DiskCustomerManagedKey
|
Riferimento alla chiave gestita dal cliente per crittografare il disco.
|
|
DiskEncryptionConfiguration
|
Configurazione della crittografia del disco applicata ai nodi di calcolo nel pool. La configurazione della crittografia del disco non è supportata nel pool Linux creato con l'immagine della macchina virtuale o l'immagine della raccolta di calcolo di Azure.
|
|
DiskEncryptionSetParameters
|
ID risorsa ARM del set di crittografia del disco.
|
|
DiskEncryptionTarget
|
Se omesso, non verrà crittografato alcun disco nei nodi di calcolo nel pool.
|
|
DynamicVNetAssignmentScope
|
Ambito dell'assegnazione dinamica della rete virtuale.
|
|
ElevationLevel
|
Livello di elevazione dell'utente.
|
|
EnvironmentSetting
|
Variabile di ambiente da impostare in un processo di attività.
|
|
FixedScaleSettings
|
Impostazioni di scalabilità fisse per il pool.
|
|
HostEndpointSettings
|
Specifica determinate impostazioni dell'endpoint host.
|
|
HostEndpointSettingsModeTypes
|
Specifica la modalità di esecuzione dei criteri di controllo di accesso.
|
|
ImageReference
|
Riferimento a un'immagine di Azure Virtual Machines Marketplace o alla risorsa Immagine di Azure di una macchina virtuale personalizzata. Per ottenere l'elenco di tutte le immaginiReference verificate da Azure Batch, vedere l'operazione "Elenca gli SKU dell'agente del nodo supportati".
|
|
InboundEndpointProtocol
|
Protocollo dell'endpoint.
|
|
InboundNatPool
|
Pool NAT in ingresso che può essere usato per gestire porte specifiche nei nodi di calcolo in un pool di Batch esternamente.
|
|
InterNodeCommunicationState
|
Ciò impone restrizioni sui nodi che possono essere assegnati al pool. L'abilitazione di questo valore può ridurre la probabilità che il numero di nodi richiesto venga allocato nel pool. Se non specificato, il valore predefinito è 'Disabled'.
|
|
IPAddressProvisioningType
|
Tipo di provisioning per gli indirizzi IP pubblici per il pool di batch.
|
|
IPFamily
|
Le famiglie di IP utilizzate per specificare le versioni IP disponibili per il pool.
|
|
IPTag
|
Specifica la modalità di distribuzione delle attività tra i nodi di calcolo.
|
|
JobDefaultOrder
|
L'ordine per la programmazione delle attività da processi diversi con la stessa priorità.
|
|
LinuxUserConfiguration
|
Proprietà usate per creare un account utente in un nodo Linux.
|
|
LoginMode
|
Specifica la modalità di accesso per l'utente. Il valore predefinito è Interactive.
|
|
ManagedDisk
|
Parametri del disco gestito.
|
|
MetadataItem
|
Coppia nome-valore associata a una risorsa del servizio Batch.
|
|
MountConfiguration
|
File system da montare in ogni nodo.
|
|
NetworkConfiguration
|
Configurazione di rete per un pool.
|
|
NetworkSecurityGroupRule
|
Regola del gruppo di sicurezza di rete da applicare a un endpoint in ingresso.
|
|
NetworkSecurityGroupRuleAccess
|
Azione da eseguire per un indirizzo IP, un intervallo di subnet o un tag specificati.
|
|
NFSMountConfiguration
|
Informazioni utilizzate per connettersi a un file system NFS.
|
|
NodePlacementConfiguration
|
Configurazione del posizionamento dei nodi per i pool batch.
|
|
NodePlacementPolicyType
|
Il valore predefinito è regionale.
|
|
OSDisk
|
Impostazioni per il disco del sistema operativo della macchina virtuale.
|
|
Pool
|
Contiene informazioni su un pool.
|
|
PoolEndpointConfiguration
|
Configurazione dell'endpoint per un pool.
|
|
PoolIdentityType
|
Tipo di identità usato per il pool di batch.
|
|
PoolProvisioningState
|
Stato corrente del pool.
|
|
ProxyAgentSettings
|
Specifica le impostazioni proxyAgent durante la creazione della macchina virtuale.
|
|
PublicIPAddressConfiguration
|
Configurazione dell'indirizzo IP pubblico della configurazione di rete di un pool.
|
|
ResizeError
|
Errore che si è verificato durante il ridimensionamento di un pool.
|
|
ResizeOperationStatus
|
Dettagli sull'operazione di ridimensionamento corrente o dell'ultima operazione di ridimensionamento completata.
|
|
ResourceFile
|
Un singolo file o più file da scaricare in un nodo di calcolo.
|
|
RollingUpgradePolicy
|
Parametri di configurazione usati durante l'esecuzione di un aggiornamento in sequenza.
|
|
ScaleSettings
|
Impostazioni di scalabilità per il pool
|
|
SecurityEncryptionTypes
|
Specifica encryptionType del disco gestito. È impostato su DiskWithVMGuestState per la crittografia del disco gestito insieme al blob VMGuestState, su VMGuestStateOnly per la crittografia solo del blob VMGuestState, e su NonPersistedTPM per la mancata persistenza dello stato firmware nel blob VMGuestState.
Nota: può essere impostata solo per le macchine virtuali riservate e necessarie quando si usano macchine virtuali riservate.
|
|
SecurityProfile
|
Specifica le impostazioni del profilo di sicurezza per la macchina virtuale o il set di scalabilità di macchine virtuali.
|
|
SecurityTypes
|
Specifica il Tipo di sicurezza della macchina virtuale. Deve essere impostato su qualsiasi valore specificato per abilitare UefiSettings.
|
|
ServiceArtifactReference
|
Specifica l'ID di riferimento dell'artefatto del servizio usato per impostare la stessa versione dell'immagine per tutte le macchine virtuali nel set di scalabilità quando si usa la versione dell'immagine 'latest'.
|
|
StartTask
|
Attività che viene eseguita quando un nodo di calcolo aggiunge un pool nel servizio Azure Batch o quando il nodo di calcolo viene riavviato o ricreato l'immagine.
|
|
StorageAccountType
|
Tipo di account di archiviazione da usare per la creazione di dischi dati o disco del sistema operativo.
|
|
systemData
|
Metadati relativi alla creazione e all'ultima modifica della risorsa.
|
|
TaskContainerSettings
|
Impostazioni del contenitore per un'attività.
|
|
TaskSchedulingPolicy
|
Specifica la modalità di distribuzione delle attività tra i nodi di calcolo.
|
|
UefiSettings
|
Specifica le impostazioni di sicurezza, ad esempio l'avvio protetto e vTPM usato durante la creazione della macchina virtuale.
|
|
UpgradeMode
|
Specifica la modalità di un aggiornamento alle macchine virtuali nel set di scalabilità.
I valori possibili sono:
manuale: è possibile controllare l'applicazione degli aggiornamenti alle macchine virtuali nel set di scalabilità. A tale scopo, usare l'azione manualUpgrade.
automatico: tutte le macchine virtuali nel set di scalabilità vengono aggiornate automaticamente contemporaneamente.
in sequenza: il set di scalabilità esegue gli aggiornamenti in batch con un tempo di pausa facoltativo tra di loro.
|
|
UpgradePolicy
|
Descrive un criterio di aggiornamento: automatico, manuale o in sequenza.
|
|
UserAccount
|
Proprietà usate per creare un utente in un nodo di Azure Batch.
|
|
UserAssignedIdentities
|
Elenco delle identità utente associate.
|
|
UserIdentity
|
Definizione dell'identità utente con cui viene eseguita l'attività.
|
|
VirtualMachineConfiguration
|
Configurazione per i nodi di calcolo in un pool basato sull'infrastruttura di Macchine virtuali di Azure.
|
|
VMDiskSecurityProfile
|
Specifica le impostazioni del profilo di sicurezza per il disco gestito.
Nota: può essere impostata solo per le macchine virtuali riservate ed è necessaria quando si usano macchine virtuali riservate.
|
|
VMExtension
|
Configurazione per le estensioni della macchina virtuale.
|
|
WindowsConfiguration
|
Impostazioni del sistema operativo Windows da applicare alla macchina virtuale.
|
|
WindowsUserConfiguration
|
Proprietà usate per creare un account utente in un nodo di Windows.
|
AllocationState
Enumerazione
Indica se il pool sta ridimensionando.
| Valore |
Descrizione |
|
Steady
|
Il pool non viene ridimensionato. Non sono state apportate modifiche al numero di nodi nel pool in corso. Un pool entra in questo stato quando viene creato e quando non viene eseguita alcuna operazione nel pool per modificare il numero di nodi.
|
|
Resizing
|
Il pool sta ridimensionando; ovvero i nodi di calcolo vengono aggiunti o rimossi dal pool.
|
|
Stopping
|
Il ridimensionamento del pool, ma l'utente ha richiesto che il ridimensionamento venga arrestato, ma la richiesta di arresto non è ancora stata completata.
|
ApplicationPackageReference
Oggetto
Collegamento a un pacchetto dell'applicazione all'interno dell'account batch
| Nome |
Tipo |
Descrizione |
|
id
|
string
|
ID del pacchetto dell'applicazione da installare. Questo deve essere all'interno dello stesso account batch del pool. Può trattarsi di un riferimento a una versione specifica o alla versione predefinita, se presente.
ID del pacchetto dell'applicazione da installare. Deve trovarsi nello stesso account batch del pool. Può trattarsi di un riferimento a una versione specifica o alla versione predefinita, se presente.
|
|
version
|
string
|
Versione dell'applicazione da distribuire. Se omesso, viene distribuita la versione predefinita.
Se l'operazione viene omessa e non viene specificata alcuna versione predefinita per questa applicazione, la richiesta ha esito negativo con il codice di errore InvalidApplicationPackageReferences. Se si chiama direttamente l'API REST, il codice di stato HTTP è 409.
|
AutomaticOSUpgradePolicy
Oggetto
Parametri di configurazione usati per eseguire l'aggiornamento automatico del sistema operativo.
| Nome |
Tipo |
Descrizione |
|
disableAutomaticRollback
|
boolean
|
Indica se la funzionalità di rollback dell'immagine del sistema operativo deve essere disabilitata.
|
|
enableAutomaticOSUpgrade
|
boolean
|
Indica se gli aggiornamenti del sistema operativo devono essere applicati automaticamente alle istanze del set di scalabilità in sequenza quando diventa disponibile una versione più recente dell'immagine del sistema operativo.
Se è impostato su true per i pool basati su Windows, WindowsConfiguration.enableAutomaticUpdates non può essere impostato su true.
|
|
osRollingUpgradeDeferral
|
boolean
|
Rinviare gli aggiornamenti del sistema operativo nelle macchine virtuali se eseguono attività.
|
|
useRollingUpgradePolicy
|
boolean
|
Indica se i criteri di aggiornamento in sequenza devono essere usati durante l'aggiornamento automatico del sistema operativo. L'aggiornamento automatico del sistema operativo eseguirà il fallback ai criteri predefiniti se non sono definiti criteri nel set di scalabilità di macchine virtuali.
|
AutoScaleRun
Oggetto
Risultati ed errori da un'esecuzione di una formula di scalabilità automatica del pool.
| Nome |
Tipo |
Descrizione |
|
error
|
AutoScaleRunError
|
Dettagli dell'errore rilevato durante la valutazione della formula di scalabilità automatica nel pool, se la valutazione non è riuscita.
Errore che si è verificato durante la scalabilità automatica di un pool.
|
|
evaluationTime
|
string
(date-time)
|
Ora dell'ultima valutazione della formula di scalabilità automatica.
Ora dell'ultima valutazione della formula di scalabilità automatica.
|
|
results
|
string
|
Valori finali di tutte le variabili usate nella valutazione della formula di scalabilità automatica.
Ogni valore della variabile viene restituito nel formato $variable=value e le variabili sono separate da punti e virgola.
|
AutoScaleRunError
Oggetto
Errore che si è verificato durante la scalabilità automatica di un pool.
| Nome |
Tipo |
Descrizione |
|
code
|
string
|
Identificatore dell'errore. I codici sono invarianti e devono essere utilizzati a livello di codice.
|
|
details
|
AutoScaleRunError[]
|
Altri dettagli sull'errore.
Altri dettagli sull'errore.
|
|
message
|
string
|
Messaggio che descrive l'errore, destinato a essere adatto per la visualizzazione in un'interfaccia utente.
|
AutoScaleSettings
Oggetto
Impostazioni di scalabilità automatica per il pool.
| Nome |
Tipo |
Descrizione |
|
evaluationInterval
|
string
(duration)
|
Intervallo di tempo in cui regolare automaticamente le dimensioni del pool in base alla formula di scalabilità automatica.
Se omesso, il valore predefinito è 15 minuti (PT15M).
|
|
formula
|
string
|
Formula per il numero desiderato di nodi di calcolo nel pool.
Formula per il numero desiderato di nodi di calcolo nel pool.
|
AutoUserScope
Enumerazione
Il valore predefinito è Pool. Se il pool esegue Windows, è necessario specificare il valore Task se è necessario un isolamento più rigoroso tra le attività. Ad esempio, se l'attività modifica il Registro di sistema in un modo che potrebbe influire su altre attività.
| Valore |
Descrizione |
|
Task
|
Specifica che il servizio deve creare un nuovo utente per l'attività.
|
|
Pool
|
Specifica che l'attività viene eseguita come account utente automatico comune creato in ogni nodo di un pool.
|
AutoUserSpecification
Oggetto
Specifica i parametri per l'utente automatico che esegue un'attività nel servizio Batch.
| Nome |
Tipo |
Descrizione |
|
elevationLevel
|
ElevationLevel
|
Livello di elevazione dell'utente.
Il valore predefinito è nonAdmin.
|
|
scope
|
AutoUserScope
|
Ambito dell'utente automatico
Il valore predefinito è Pool. Se il pool esegue Windows, è necessario specificare il valore Task se è necessario un isolamento più rigoroso tra le attività. Ad esempio, se l'attività modifica il Registro di sistema in modo che possa influire su altre attività o se nel pool sono stati specificati certificati che non devono essere accessibili dalle normali attività, ma devono essere accessibili dalle attività iniziali.
|
AzureBlobFileSystemConfiguration
Oggetto
Informazioni usate per connettersi a un contenitore di archiviazione di Azure usando Blobfuse.
| Nome |
Tipo |
Descrizione |
|
accountKey
|
string
(password)
|
Chiave dell'account di archiviazione di Azure.
Questa proprietà si escludono a vicenda sia con sasKey che con l'identità; deve essere specificato esattamente uno.
|
|
accountName
|
string
|
Nome dell'account di archiviazione di Azure.
Nome dell'account di archiviazione di Azure.
|
|
blobfuseOptions
|
string
|
Opzioni della riga di comando aggiuntive da passare al comando mount.
Queste sono le opzioni 'net use' in Windows e 'mount' opzioni in Linux.
|
|
containerName
|
string
|
Nome del contenitore di Archiviazione BLOB di Azure.
Nome del contenitore di Archiviazione BLOB di Azure.
|
|
identityReference
|
ComputeNodeIdentityReference
|
Riferimento all'identità assegnata dall'utente da usare per accedere a containerName
Questa proprietà si escludono a vicenda sia con accountKey che con sasKey; deve essere specificato esattamente uno.
|
|
relativeMountPath
|
string
|
Percorso relativo nel nodo di calcolo in cui verrà montato il file system
Tutti i file system vengono montati in relazione alla directory dei montaggi batch, accessibili tramite la variabile di ambiente AZ_BATCH_NODE_MOUNTS_DIR.
|
|
sasKey
|
string
(password)
|
Token di firma di accesso condiviso di Archiviazione di Azure.
Questa proprietà si escludono a vicenda sia con accountKey che con l'identità; deve essere specificato esattamente uno.
|
AzureFileShareConfiguration
Oggetto
Informazioni usate per connettersi a una condivisione file di Azure.
| Nome |
Tipo |
Descrizione |
|
accountKey
|
string
(password)
|
Chiave dell'account di archiviazione di Azure.
Chiave dell'account di archiviazione di Azure.
|
|
accountName
|
string
|
Nome dell'account di archiviazione di Azure.
Nome dell'account di archiviazione di Azure.
|
|
azureFileUrl
|
string
|
URL di File di Azure.
Si tratta del formato 'https://{account}.file.core.windows.net/'.
|
|
mountOptions
|
string
|
Opzioni della riga di comando aggiuntive da passare al comando mount.
Queste sono le opzioni 'net use' in Windows e 'mount' opzioni in Linux.
|
|
relativeMountPath
|
string
|
Percorso relativo nel nodo di calcolo in cui verrà montato il file system
Tutti i file system vengono montati in relazione alla directory dei montaggi batch, accessibili tramite la variabile di ambiente AZ_BATCH_NODE_MOUNTS_DIR.
|
BatchPoolIdentity
Oggetto
Identità del pool di Batch, se configurata. Se l'identità del pool viene aggiornata durante l'aggiornamento di un pool esistente, solo le nuove macchine virtuali create dopo che il pool viene ridotto a 0 avranno le identità aggiornate
| Nome |
Tipo |
Descrizione |
|
type
|
PoolIdentityType
|
Tipo di identità usato per il pool di batch.
|
|
userAssignedIdentities
|
<string,
UserAssignedIdentities>
|
Elenco di identità utente associate al pool di Batch.
|
CachingType
Enumerazione
Tipo di memorizzazione nella cache da abilitare per il disco.
| Valore |
Descrizione |
|
None
|
La modalità di memorizzazione nella cache per il disco non è abilitata.
|
|
ReadOnly
|
La modalità di memorizzazione nella cache per il disco è di sola lettura.
|
|
ReadWrite
|
La modalità di memorizzazione nella cache per il disco è di lettura e scrittura.
|
CIFSMountConfiguration
Oggetto
Informazioni utilizzate per connettersi a un file system CIFS.
| Nome |
Tipo |
Descrizione |
|
mountOptions
|
string
|
Opzioni della riga di comando aggiuntive da passare al comando mount.
Queste sono le opzioni 'net use' in Windows e 'mount' opzioni in Linux.
|
|
password
|
string
(password)
|
Password da usare per l'autenticazione nel file system CIFS.
Password da usare per l'autenticazione nel file system CIFS.
|
|
relativeMountPath
|
string
|
Percorso relativo nel nodo di calcolo in cui verrà montato il file system
Tutti i file system vengono montati in relazione alla directory dei montaggi batch, accessibili tramite la variabile di ambiente AZ_BATCH_NODE_MOUNTS_DIR.
|
|
source
|
string
|
URI del file system da montare.
URI del file system da montare.
|
|
userName
|
string
|
Utente da usare per l'autenticazione nel file system CIFS.
Utente da usare per l'autenticazione nel file system CIFS.
|
CloudError
Oggetto
Risposta di errore dal servizio Batch.
| Nome |
Tipo |
Descrizione |
|
error
|
CloudErrorBody
|
Corpo della risposta di errore.
|
CloudErrorBody
Oggetto
Risposta di errore dal servizio Batch.
| Nome |
Tipo |
Descrizione |
|
code
|
string
|
Identificatore dell'errore. I codici sono invarianti e devono essere utilizzati a livello di codice.
|
|
details
|
CloudErrorBody[]
|
Elenco di dettagli aggiuntivi sull'errore.
|
|
message
|
string
|
Messaggio che descrive l'errore, destinato a essere adatto per la visualizzazione in un'interfaccia utente.
|
|
target
|
string
|
Destinazione dell'errore specifico. Ad esempio, il nome della proprietà in errore.
|
ComputeNodeDeallocationOption
Enumerazione
Determina le operazioni da eseguire con un nodo e le relative attività in esecuzione dopo che è stata selezionata per la deallocazione.
| Valore |
Descrizione |
|
Requeue
|
Terminare l'esecuzione dei processi delle attività e rieseguere la coda delle attività. Le attività verranno eseguite di nuovo quando è disponibile un nodo. Rimuovere i nodi non appena le attività sono state terminate.
|
|
Terminate
|
Terminare le attività in esecuzione. Le attività verranno completate con failureInfo che indica che sono state terminate e non verranno eseguite di nuovo. Rimuovere i nodi non appena le attività sono state terminate.
|
|
TaskCompletion
|
Consenti il completamento delle attività attualmente in esecuzione. Non pianificare nuove attività durante l'attesa. Rimuovere i nodi al termine di tutte le attività.
|
|
RetainedData
|
Consentire il completamento delle attività attualmente in esecuzione, quindi attendere la scadenza di tutti i periodi di conservazione dei dati delle attività. Non pianificare nuove attività durante l'attesa. Rimuovere i nodi quando tutti i periodi di conservazione delle attività sono scaduti.
|
ComputeNodeFillType
Enumerazione
Modalità di distribuzione delle attività tra i nodi di calcolo.
| Valore |
Descrizione |
|
Spread
|
Le attività devono essere assegnate in modo uniforme in tutti i nodi del pool.
|
|
Pack
|
Il maggior numero possibile di attività (taskSlotsPerNode) deve essere assegnato a ogni nodo del pool prima che tutte le attività vengano assegnate al nodo successivo nel pool.
|
ComputeNodeIdentityReference
Oggetto
Riferimento a un'identità assegnata dall'utente associata al pool di Batch che verrà usato da un nodo di calcolo.
| Nome |
Tipo |
Descrizione |
|
resourceId
|
string
|
ID risorsa ARM dell'identità assegnata dall'utente.
|
ContainerConfiguration
Oggetto
Configurazione per i pool abilitati per i contenitori.
| Nome |
Tipo |
Descrizione |
|
containerImageNames
|
string[]
|
Raccolta di nomi di immagini del contenitore.
Questo è il riferimento completo all'immagine, come sarebbe stato specificato in "docker pull". Un'immagine verrà generata dal registro Docker predefinito, a meno che l'immagine non sia completamente qualificata con un registro alternativo.
|
|
containerRegistries
|
ContainerRegistry[]
|
Registri privati aggiuntivi da cui è possibile eseguire il pull dei contenitori.
Se le immagini devono essere scaricate da un registro privato che richiede credenziali, è necessario specificare le credenziali qui.
|
|
type
|
ContainerType
|
Tecnologia contenitore da usare.
Tecnologia contenitore da usare.
|
ContainerHostBatchBindMountEntry
Oggetto
Voce di percorso e modalità di montaggio da montare nel contenitore di attività.
| Nome |
Tipo |
Descrizione |
|
isReadOnly
|
boolean
|
Montare o meno questo percorso di origine come modalità di sola lettura. Il valore predefinito è false (modalità lettura/scrittura).
Per Linux, se si monta questo percorso come modalità di lettura/scrittura, ciò non significa che tutti gli utenti nel contenitore dispongano dell'accesso in lettura/scrittura per il percorso, dipende dall'accesso nella macchina virtuale host. Se questo percorso viene montato in sola lettura, tutti gli utenti all'interno del contenitore non potranno modificare il percorso.
|
|
source
|
ContainerHostDataPath
|
Percorsi che verranno montati nel contenitore dell'attività contenitore.
Percorsi che verranno montati nel contenitore dell'attività contenitore.
|
ContainerHostDataPath
Enumerazione
Percorsi che verranno montati nel contenitore dell'attività contenitore.
| Valore |
Descrizione |
|
Shared
|
Percorso dell'attività a più istanze in cui condividere i propri file.
|
|
Startup
|
Percorso dell'attività di avvio.
|
|
VfsMounts
|
Il percorso contiene tutti i file system virtuali montati in questo nodo.
|
|
Task
|
Percorso dell'attività.
|
|
JobPrep
|
Percorso dell'attività di preparazione del processo.
|
|
Applications
|
Percorso delle applicazioni.
|
ContainerRegistry
Oggetto
Registro contenitori privato.
| Nome |
Tipo |
Descrizione |
|
identityReference
|
ComputeNodeIdentityReference
|
Riferimento all'identità assegnata dall'utente da usare per accedere a un Registro Azure Container invece di nome utente e password.
Riferimento a un'identità assegnata dall'utente associata al pool di Batch che verrà usato da un nodo di calcolo.
|
|
password
|
string
(password)
|
Password per accedere al server del Registro di sistema.
Password per accedere al server del Registro di sistema.
|
|
registryServer
|
string
|
URL del Registro di sistema.
Se omesso, il valore predefinito è "docker.io".
|
|
username
|
string
|
Nome utente per accedere al server del Registro di sistema.
Nome utente per accedere al server del Registro di sistema.
|
ContainerType
Enumerazione
Tecnologia contenitore da usare.
| Valore |
Descrizione |
|
DockerCompatible
|
Per avviare i contenitori verrà usata una tecnologia contenitore compatibile con Docker.
|
|
CriCompatible
|
Per avviare i contenitori verrà usata una tecnologia basata su CRI.
|
ContainerWorkingDirectory
Enumerazione
Flag per indicare dove si trova la directory di lavoro dell'attività contenitore. Il valore predefinito è 'taskWorkingDirectory'.
| Valore |
Descrizione |
|
TaskWorkingDirectory
|
Usare la directory di lavoro dell'attività del servizio Batch standard, che conterrà i file di risorse attività popolati da Batch.
|
|
ContainerImageDefault
|
Uso della directory di lavoro definita dall'immagine del contenitore. Tenere presente che questa directory non conterrà i file di risorse scaricati da Batch.
|
createdByType
Enumerazione
Tipo di identità che ha creato la risorsa.
| Valore |
Descrizione |
|
User
|
|
|
Application
|
|
|
ManagedIdentity
|
|
|
Key
|
|
DataDisk
Oggetto
Impostazioni che verranno usate dai dischi dati associati ai nodi di calcolo nel pool. Quando si usano dischi dati allegati è necessario montare e formattare i dischi all'interno di una macchina virtuale per poterli usare.
| Nome |
Tipo |
Descrizione |
|
caching
|
CachingType
|
Tipo di memorizzazione nella cache da abilitare per il disco.
I valori sono:
none: la modalità di memorizzazione nella cache per il disco non è abilitata.
readOnly: la modalità di memorizzazione nella cache per il disco è di sola lettura.
readWrite: la modalità di memorizzazione nella cache per il disco è di lettura e scrittura.
Il valore predefinito per la memorizzazione nella cache non è nessuno. Per informazioni sulle opzioni di memorizzazione nella cache, vedere: https://blogs.msdn.microsoft.com/windowsazurestorage/2012/06/27/exploring-windows-azure-drives-disks-and-images/.
|
|
diskSizeGB
|
integer
(int32)
|
Dimensioni iniziali del disco in GB durante la creazione di un nuovo disco dati.
Dimensioni iniziali del disco in GB durante la creazione di un nuovo disco dati.
|
|
lun
|
integer
(int32)
|
Numero di unità logica.
Il lun viene usato per identificare in modo univoco ogni disco dati. Se si collegano più dischi, ognuno deve avere un lun distinto. Il valore deve essere compreso tra 0 e 63 inclusi.
|
|
managedDisk
|
ManagedDisk
|
Parametri del disco gestito.
Parametri del disco gestito.
|
DeploymentConfiguration
Oggetto
Proprietà di configurazione della distribuzione.
| Nome |
Tipo |
Descrizione |
|
virtualMachineConfiguration
|
VirtualMachineConfiguration
|
Configurazione della macchina virtuale per il pool.
Configurazione per i nodi di calcolo in un pool basato sull'infrastruttura di Macchine virtuali di Azure.
|
DiffDiskPlacement
Enumerazione
Il luogo dove dovrebbe essere posizionato il disco del sistema operativo.
| Valore |
Descrizione |
|
CacheDisk
|
Il disco del sistema operativo sarà posizionato sul disco cache della VM.
|
DiffDiskSettings
Oggetto
Specifica le impostazioni temporanee del disco per il disco del sistema operativo usato dalla macchina virtuale.
DiskCustomerManagedKey
Oggetto
Riferimento alla chiave gestita dal cliente per crittografare il disco.
| Nome |
Tipo |
Descrizione |
|
identityReference
|
ComputeNodeIdentityReference
|
Riferimento di una delle identità del pool per crittografare il disco. Questa identità verrà usata per accedere a KeyVault.
|
|
keyUrl
|
string
(uri)
|
URL chiave con versione completa che punta a una chiave in KeyVault. Il segmento di versione dell'URL è obbligatorio indipendentemente dal valore rotationToLatestKeyVersionEnabled.
|
|
rotationToLatestKeyVersionEnabled
|
boolean
|
Impostare questo flag su true per abilitare l'aggiornamento automatico della crittografia del disco alla versione più recente della chiave. Il valore predefinito è false.
|
DiskEncryptionConfiguration
Oggetto
Configurazione della crittografia del disco applicata ai nodi di calcolo nel pool. La configurazione della crittografia del disco non è supportata nel pool Linux creato con l'immagine della macchina virtuale o l'immagine della raccolta di calcolo di Azure.
| Nome |
Tipo |
Descrizione |
|
customerManagedKey
|
DiskCustomerManagedKey
|
Riferimento alla chiave gestita dal cliente per crittografare il disco del sistema operativo.
La chiave gestita dal cliente crittograferà il disco del sistema operativo tramite EncryptionAtRest e, per impostazione predefinita, crittograferà anche il disco dati. Può essere utilizzato solo quando il pool è configurato con un'identità e OsDisk è impostato come una delle destinazioni di DiskEncryption.
|
|
targets
|
DiskEncryptionTarget[]
|
L'elenco delle destinazioni disco del servizio Batch crittograferà nel nodo di calcolo
Nel pool Linux è supportato solo "TemporaryDisk". nel pool di Windows è necessario specificare "OsDisk" e "TemporaryDisk".
|
DiskEncryptionSetParameters
Oggetto
ID risorsa ARM del set di crittografia del disco.
| Nome |
Tipo |
Descrizione |
|
id
|
string
(arm-id)
|
L'ID della risorsa del set di crittografia disco.
ID risorsa ARM del set di crittografia del disco. La risorsa dovrebbe essere nello stesso abbonamento dell'account Batch.
|
DiskEncryptionTarget
Enumerazione
Se omesso, non verrà crittografato alcun disco nei nodi di calcolo nel pool.
| Valore |
Descrizione |
|
OsDisk
|
Il disco del sistema operativo nel nodo di calcolo è crittografato.
|
|
TemporaryDisk
|
Il disco temporaneo nel nodo di calcolo è crittografato. In Linux questa crittografia si applica ad altre partizioni (ad esempio quelle su dischi dati montati) quando la crittografia viene eseguita al momento dell'avvio.
|
DynamicVNetAssignmentScope
Enumerazione
Ambito dell'assegnazione dinamica della rete virtuale.
| Valore |
Descrizione |
|
none
|
Non è abilitata alcuna assegnazione dinamica di rete virtuale.
|
|
job
|
L'assegnazione dinamica della rete virtuale viene eseguita per ogni processo. Se questo valore è impostato, è necessario impostare anche l'ID subnet di configurazione di rete. Questa funzionalità richiede l'approvazione prima dell'uso. Contattare il supporto tecnico
|
ElevationLevel
Enumerazione
Livello di elevazione dell'utente.
| Valore |
Descrizione |
|
NonAdmin
|
L'utente è un utente standard senza accesso con privilegi elevati.
|
|
Admin
|
L'utente è un utente con accesso con privilegi elevati e opera con autorizzazioni di amministratore complete.
|
EnvironmentSetting
Oggetto
Variabile di ambiente da impostare in un processo di attività.
| Nome |
Tipo |
Descrizione |
|
name
|
string
|
Nome della variabile di ambiente.
Nome della variabile di ambiente.
|
|
value
|
string
|
Valore della variabile di ambiente.
Valore della variabile di ambiente.
|
FixedScaleSettings
Oggetto
Impostazioni di scalabilità fisse per il pool.
| Nome |
Tipo |
Valore predefinito |
Descrizione |
|
nodeDeallocationOption
|
ComputeNodeDeallocationOption
|
|
Determina le operazioni da eseguire con un nodo e le relative attività in esecuzione dopo che è stata selezionata per la deallocazione.
Se omesso, il valore predefinito è Requeue.
|
|
resizeTimeout
|
string
(duration)
|
PT15M
|
Timeout per l'allocazione dei nodi di calcolo al pool.
Il valore predefinito è 15 minuti. I valori di timeout usano il formato ISO 8601. Ad esempio, usare PT10M per 10 minuti. Il valore minimo è 5 minuti. Se si specifica un valore inferiore a 5 minuti, il servizio Batch rifiuta la richiesta con un errore; se si chiama direttamente l'API REST, il codice di stato HTTP è 400 (richiesta non valida).
|
|
targetDedicatedNodes
|
integer
(int32)
|
|
Numero desiderato di nodi di calcolo dedicati nel pool.
Almeno uno di targetDedicatedNodes, targetLowPriorityNodes deve essere impostato.
|
|
targetLowPriorityNodes
|
integer
(int32)
|
|
Numero desiderato di nodi di calcolo spot/con priorità bassa nel pool.
Almeno uno di targetDedicatedNodes, targetLowPriorityNodes deve essere impostato.
|
HostEndpointSettings
Oggetto
Specifica determinate impostazioni dell'endpoint host.
| Nome |
Tipo |
Descrizione |
|
inVMAccessControlProfileReferenceId
|
string
(arm-id)
|
Specifica il riferimento all'ID risorsa InVMAccessControlProfileVersion nel formato /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/inVMAccessControlProfiles/{profile}/versions/{version}.
|
|
mode
|
HostEndpointSettingsModeTypes
|
Specifica la modalità di esecuzione dei criteri di controllo di accesso.
|
HostEndpointSettingsModeTypes
Enumerazione
Specifica la modalità di esecuzione dei criteri di controllo di accesso.
| Valore |
Descrizione |
|
Audit
|
In modalità di controllo, il sistema agisce come se applicasse i criteri di controllo di accesso, inclusa l'emissione di voci di rifiuto di accesso nei log, ma non nega effettivamente le richieste agli endpoint host.
|
|
Enforce
|
La modalità di applicazione è la modalità di funzionamento raccomandata e il sistema farà rispettare la politica di controllo accessi. Questa proprietà non può essere usata insieme a 'inVMAccessControlControlProfileReferenceId'.
|
ImageReference
Oggetto
Riferimento a un'immagine di Azure Virtual Machines Marketplace o alla risorsa Immagine di Azure di una macchina virtuale personalizzata. Per ottenere l'elenco di tutte le immaginiReference verificate da Azure Batch, vedere l'operazione "Elenca gli SKU dell'agente del nodo supportati".
| Nome |
Tipo |
Descrizione |
|
communityGalleryImageId
|
string
|
Identificatore univoco dell'immagine della raccolta community
Questa proprietà si escludono a vicenda con altre proprietà e possono essere recuperate dalla chiamata GET dell'immagine della raccolta della community.
|
|
id
|
string
|
Identificatore della risorsa ARM dell'immagine della raccolta di calcolo di Azure. I nodi di calcolo nel pool verranno creati usando questo ID immagine. Si tratta del formato /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageDefinitionName}/versions/{versionId}.
Questa proprietà si escludono a vicenda con altre proprietà. L'immagine della raccolta di calcolo di Azure deve avere repliche nella stessa area dell'account Azure Batch. Per informazioni sulle impostazioni del firewall per l'agente del nodo Batch per comunicare con il servizio Batch, vedere https://learn.microsoft.com/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration.
|
|
offer
|
string
|
Tipo di offerta dell'immagine di Azure Virtual Machines Marketplace.
Ad esempio, UbuntuServer o WindowsServer.
|
|
publisher
|
string
|
Autore dell'immagine del Marketplace delle macchine virtuali di Azure.
Ad esempio, Canonical o MicrosoftWindowsServer.
|
|
sharedGalleryImageId
|
string
|
Identificatore univoco dell'immagine della raccolta condivisa
Questa proprietà si escludono a vicenda con altre proprietà e possono essere recuperate dalla chiamata GET dell'immagine della raccolta condivisa.
|
|
sku
|
string
|
SKU dell'immagine marketplace di Macchine virtuali di Azure.
Ad esempio, 18.04-LTS o 2022-datacenter.
|
|
version
|
string
|
Versione dell'immagine del Marketplace delle macchine virtuali di Azure.
È possibile specificare il valore 'latest' per selezionare la versione più recente di un'immagine. Se omesso, il valore predefinito è 'latest'.
|
InboundEndpointProtocol
Enumerazione
Protocollo dell'endpoint.
| Valore |
Descrizione |
|
TCP
|
Usare TCP per l'endpoint.
|
|
UDP
|
Usare UDP per l'endpoint.
|
InboundNatPool
Oggetto
Pool NAT in ingresso che può essere usato per gestire porte specifiche nei nodi di calcolo in un pool di Batch esternamente.
| Nome |
Tipo |
Descrizione |
|
backendPort
|
integer
(int32)
|
Numero di porta nel nodo di calcolo.
Deve essere univoco all'interno di un pool di Batch. I valori accettabili sono compresi tra 1 e 65535 ad eccezione del 29876 e del 29877, perché sono riservati. Se vengono forniti valori riservati, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
frontendPortRangeEnd
|
integer
(int32)
|
Ultimo numero di porta nell'intervallo di porte esterne che verranno usate per fornire l'accesso in ingresso al back-endPort nei singoli nodi di calcolo.
I valori accettabili sono compresi tra 1 e 65534 ad eccezione delle porte comprese tra 50000 e 55000 riservate dal servizio Batch. Tutti gli intervalli all'interno di un pool devono essere distinti e non possono sovrapporsi. Se vengono forniti valori riservati o sovrapposti, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
frontendPortRangeStart
|
integer
(int32)
|
Primo numero di porta nell'intervallo di porte esterne che verranno usate per fornire l'accesso in ingresso al back-endPort nei singoli nodi di calcolo.
I valori accettabili sono compresi tra 1 e 65534, ad eccezione delle porte da 50000 a 55000 riservate. Tutti gli intervalli all'interno di un pool devono essere distinti e non possono sovrapporsi. Se vengono forniti valori riservati o sovrapposti, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
name
|
string
|
Nome dell'endpoint.
Il nome deve essere univoco all'interno di un pool di Batch, può contenere lettere, numeri, caratteri di sottolineatura, punti e trattini. I nomi devono iniziare con una lettera o un numero, devono terminare con una lettera, un numero o un carattere di sottolineatura e non possono superare 77 caratteri. Se vengono forniti valori non validi, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
networkSecurityGroupRules
|
NetworkSecurityGroupRule[]
|
Elenco delle regole del gruppo di sicurezza di rete che verranno applicate all'endpoint.
Il numero massimo di regole che è possibile specificare in tutti gli endpoint in un pool di Batch è 25. Se non vengono specificate regole del gruppo di sicurezza di rete, verrà creata una regola predefinita per consentire l'accesso in ingresso al back-endPort specificato. Se il numero massimo di regole del gruppo di sicurezza di rete viene superato, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
protocol
|
InboundEndpointProtocol
|
Protocollo dell'endpoint.
Protocollo dell'endpoint.
|
InterNodeCommunicationState
Enumerazione
Ciò impone restrizioni sui nodi che possono essere assegnati al pool. L'abilitazione di questo valore può ridurre la probabilità che il numero di nodi richiesto venga allocato nel pool. Se non specificato, il valore predefinito è 'Disabled'.
| Valore |
Descrizione |
|
Enabled
|
Abilitare la comunicazione di rete tra macchine virtuali.
|
|
Disabled
|
Disabilitare la comunicazione di rete tra macchine virtuali.
|
IPAddressProvisioningType
Enumerazione
Tipo di provisioning per gli indirizzi IP pubblici per il pool di batch.
| Valore |
Descrizione |
|
BatchManaged
|
Un indirizzo IP pubblico verrà creato e gestito da Batch. Possono essere presenti più indirizzi IP pubblici a seconda delle dimensioni del pool.
|
|
UserManaged
|
Gli indirizzi IP pubblici vengono forniti dall'utente e verranno usati per effettuare il provisioning dei nodi di calcolo.
|
|
NoPublicIPAddresses
|
Non verrà creato alcun indirizzo IP pubblico per i nodi di calcolo nel pool.
|
IPFamily
Enumerazione
Le famiglie di IP utilizzate per specificare le versioni IP disponibili per il pool.
| Valore |
Descrizione |
|
IPv4
|
IPv4 è disponibile per il pool.
|
|
IPv6
|
IPv6 è disponibile per il pool.
|
IPTag
Oggetto
Specifica la modalità di distribuzione delle attività tra i nodi di calcolo.
| Nome |
Tipo |
Descrizione |
|
ipTagType
|
string
|
Il tipo di tag IP.
Esempio: FirstPartyUsage.
|
|
tag
|
string
|
Valore del tag IP associato all'indirizzo IP pubblico.
Esempio: SQL.
|
JobDefaultOrder
Enumerazione
L'ordine per la programmazione delle attività da processi diversi con la stessa priorità.
| Valore |
Descrizione |
|
None
|
Le attività dovrebbero essere programmate uniformemente da tutti i lavori di uguale priorità per il pool.
|
|
CreationTime
|
Se i lavori hanno la stessa priorità, i compiti di lavori creati in precedenza dovrebbero essere programmati per primi.
|
LinuxUserConfiguration
Oggetto
Proprietà usate per creare un account utente in un nodo Linux.
| Nome |
Tipo |
Descrizione |
|
gid
|
integer
(int32)
|
ID gruppo per l'account utente.
Le proprietà uid e gid devono essere specificate insieme o non affatto. Se non specificato, il sistema operativo sottostante seleziona il gid.
|
|
sshPrivateKey
|
string
(password)
|
Chiave privata SSH per l'account utente.
La chiave privata non deve essere protetta da password. La chiave privata viene usata per configurare automaticamente l'autenticazione basata su chiave asimmetrica per SSH tra i nodi in un pool Linux quando la proprietà enableInterNodeCommunication del pool è true (viene ignorata se enableInterNodeCommunication è false). A tale scopo, posizionare la coppia di chiavi nella directory .ssh dell'utente. Se non specificato, SSH senza password non è configurato tra i nodi (non viene eseguita alcuna modifica della directory .ssh dell'utente).
|
|
uid
|
integer
(int32)
|
ID utente dell'account utente.
Le proprietà uid e gid devono essere specificate insieme o non affatto. Se non specificato, il sistema operativo sottostante seleziona l'uid.
|
LoginMode
Enumerazione
Specifica la modalità di accesso per l'utente. Il valore predefinito è Interactive.
| Valore |
Descrizione |
|
Batch
|
La LOGON32_LOGON_BATCH modalità di accesso Win32. La modalità di accesso batch è consigliata per i processi paralleli a esecuzione prolungata.
|
|
Interactive
|
La LOGON32_LOGON_INTERACTIVE modalità di accesso Win32. Alcune applicazioni richiedono autorizzazioni associate alla modalità di accesso interattivo. Se questo è il caso di un'applicazione usata nell'attività, questa opzione è consigliata.
|
ManagedDisk
Oggetto
Parametri del disco gestito.
| Nome |
Tipo |
Descrizione |
|
diskEncryptionSet
|
DiskEncryptionSetParameters
|
Specifica l'ID risorsa del set di crittografia dischi gestiti dal cliente per il disco gestito. Può essere impostato solo in modalità UserSubscription.
|
|
securityProfile
|
VMDiskSecurityProfile
|
Specifica il profilo di sicurezza per il disco gestito.
Specifica le impostazioni del profilo di sicurezza per il disco gestito.
Nota: può essere impostata solo per le macchine virtuali riservate ed è necessaria quando si usano macchine virtuali riservate.
|
|
storageAccountType
|
StorageAccountType
|
Tipo di account di archiviazione da usare per la creazione di dischi dati o disco del sistema operativo.
Tipo di account di archiviazione da usare per la creazione di dischi dati o disco del sistema operativo.
|
Oggetto
Coppia nome-valore associata a una risorsa del servizio Batch.
| Nome |
Tipo |
Descrizione |
|
name
|
string
|
Nome dell'elemento di metadati.
Nome dell'elemento di metadati.
|
|
value
|
string
|
Valore dell'elemento di metadati.
Valore dell'elemento di metadati.
|
MountConfiguration
Oggetto
File system da montare in ogni nodo.
| Nome |
Tipo |
Descrizione |
|
azureBlobFileSystemConfiguration
|
AzureBlobFileSystemConfiguration
|
Contenitore di Archiviazione di Azure da montare usando BLOB FUSE in ogni nodo.
Questa proprietà si escludono a vicenda con tutte le altre proprietà.
|
|
azureFileShareConfiguration
|
AzureFileShareConfiguration
|
Condivisione file di Azure da montare in ogni nodo.
Questa proprietà si escludono a vicenda con tutte le altre proprietà.
|
|
cifsMountConfiguration
|
CIFSMountConfiguration
|
File system CIFS/SMB da montare in ogni nodo.
Questa proprietà si escludono a vicenda con tutte le altre proprietà.
|
|
nfsMountConfiguration
|
NFSMountConfiguration
|
File system NFS da montare in ogni nodo.
Questa proprietà si escludono a vicenda con tutte le altre proprietà.
|
NetworkConfiguration
Oggetto
Configurazione di rete per un pool.
| Nome |
Tipo |
Valore predefinito |
Descrizione |
|
dynamicVnetAssignmentScope
|
DynamicVNetAssignmentScope
|
none
|
Ambito dell'assegnazione dinamica della rete virtuale.
Ambito dell'assegnazione dinamica della rete virtuale.
|
|
enableAcceleratedNetworking
|
boolean
|
|
Indica se il pool deve abilitare la rete accelerata.
La rete accelerata consente la virtualizzazione di I/O radice singola (SR-IOV) a una macchina virtuale, con un miglioramento delle prestazioni di rete. Per altri dettagli, vedere: https://learn.microsoft.com/azure/virtual-network/accelerated-networking-overview.
|
|
endpointConfiguration
|
PoolEndpointConfiguration
|
|
Configurazione per gli endpoint nei nodi di calcolo nel pool di Batch.
Configurazione dell'endpoint per un pool.
|
|
publicIPAddressConfiguration
|
PublicIPAddressConfiguration
|
|
Configurazione IPAddress pubblica per i nodi di calcolo nel pool di batch.
Configurazione dell'indirizzo IP pubblico della configurazione di rete di un pool.
|
|
subnetId
|
string
|
|
Identificatore di risorsa ARM della subnet di rete virtuale a cui verranno aggiunti i nodi di calcolo del pool. Si tratta del formato /subscriptions/{subscription}/resourceGroups/{group}/providers/{provider}/virtualNetworks/{network}/subnets/{subnet}.
La rete virtuale deve trovarsi nella stessa area e nella stessa sottoscrizione dell'account Azure Batch. La subnet specificata deve avere indirizzi IP liberi sufficienti per contenere il numero di nodi nel pool. Se la subnet non dispone di un numero sufficiente di indirizzi IP liberi, il pool allocherà parzialmente i nodi di calcolo e si verificherà un errore di ridimensionamento. L'entità servizio "MicrosoftAzureBatch" deve avere il ruolo "Collaboratore macchina virtuale classica" Role-Based controllo di accesso (RBAC) per la rete virtuale specificata. La subnet specificata deve consentire la comunicazione dal servizio Azure Batch per poter pianificare le attività nei nodi di calcolo. Questa operazione può essere verificata controllando se la rete virtuale specificata dispone di gruppi di sicurezza di rete (NSG) associati. Se la comunicazione con i nodi di calcolo nella subnet specificata viene negata da un gruppo di sicurezza di rete, il servizio Batch imposta lo stato dei nodi di calcolo su inutilizzabile. Se la rete virtuale specificata include gruppi di sicurezza di rete associati, è necessario abilitare alcune porte di sistema riservate per la comunicazione in ingresso, incluse le porte 29876 e 29877. Abilitare anche le connessioni in uscita ad Archiviazione di Azure sulla porta 443. Per altri dettagli, vedere: https://learn.microsoft.com/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration
|
NetworkSecurityGroupRule
Oggetto
Regola del gruppo di sicurezza di rete da applicare a un endpoint in ingresso.
| Nome |
Tipo |
Descrizione |
|
access
|
NetworkSecurityGroupRuleAccess
|
Azione da eseguire per un indirizzo IP, un intervallo di subnet o un tag specificati.
Azione da eseguire per un indirizzo IP, un intervallo di subnet o un tag specificati.
|
|
priority
|
integer
(int32)
|
Priorità per questa regola.
Le priorità all'interno di un pool devono essere univoche e vengono valutate in ordine di priorità. Minore è il numero maggiore della priorità. Ad esempio, è possibile specificare regole con numeri di ordine pari a 150, 250 e 350. La regola con il numero di ordine 150 ha la precedenza sulla regola con un ordine pari a 250. Le priorità consentite sono da 150 a 4096. Se vengono forniti valori riservati o duplicati, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
sourceAddressPrefix
|
string
|
Prefisso o tag dell'indirizzo di origine da trovare per la regola.
I valori validi sono un singolo indirizzo IP (ad esempio 10.10.10.10), una subnet IP (ad esempio 192.168.1.0/24), un tag predefinito o * (per tutti gli indirizzi). Se vengono forniti altri valori, la richiesta ha esito negativo con codice di stato HTTP 400.
|
|
sourcePortRanges
|
string[]
|
Intervalli di porte di origine da trovare per la regola.
I valori validi sono '*' (per tutte le porte da 0 a 65535) o matrici di porte o intervalli di porte (ad esempio 100-200). Le porte devono essere incluse nell'intervallo compreso tra 0 e 65535 e gli intervalli di porte o le porte non possono sovrapporsi. Se vengono forniti altri valori, la richiesta ha esito negativo con codice di stato HTTP 400. Il valore predefinito sarà *.
|
NetworkSecurityGroupRuleAccess
Enumerazione
Azione da eseguire per un indirizzo IP, un intervallo di subnet o un tag specificati.
| Valore |
Descrizione |
|
Allow
|
Consentire l'accesso.
|
|
Deny
|
Negare l'accesso.
|
NFSMountConfiguration
Oggetto
Informazioni utilizzate per connettersi a un file system NFS.
| Nome |
Tipo |
Descrizione |
|
mountOptions
|
string
|
Opzioni della riga di comando aggiuntive da passare al comando mount.
Queste sono le opzioni 'net use' in Windows e 'mount' opzioni in Linux.
|
|
relativeMountPath
|
string
|
Percorso relativo nel nodo di calcolo in cui verrà montato il file system
Tutti i file system vengono montati in relazione alla directory dei montaggi batch, accessibili tramite la variabile di ambiente AZ_BATCH_NODE_MOUNTS_DIR.
|
|
source
|
string
|
URI del file system da montare.
URI del file system da montare.
|
NodePlacementConfiguration
Oggetto
Configurazione del posizionamento dei nodi per i pool batch.
| Nome |
Tipo |
Descrizione |
|
policy
|
NodePlacementPolicyType
|
Tipo di politica di posizionamento dei nodi nei pool batch.
Criteri di allocazione usati dal servizio Batch per effettuare il provisioning dei nodi. Se non specificato, Batch userà i criteri internazionali.
|
NodePlacementPolicyType
Enumerazione
Il valore predefinito è regionale.
| Valore |
Descrizione |
|
Regional
|
Tutti i nodi nel pool verranno allocati nella stessa area.
|
|
Zonal
|
I nodi nel pool verranno distribuiti in zone diverse con il bilanciamento del carico ottimale.
|
OSDisk
Oggetto
Impostazioni per il disco del sistema operativo della macchina virtuale.
| Nome |
Tipo |
Descrizione |
|
caching
|
CachingType
|
Tipo di memorizzazione nella cache da abilitare per il disco.
Tipo di memorizzazione nella cache da abilitare per il disco.
|
|
diskSizeGB
|
integer
(int32)
|
Dimensioni iniziali del disco in GB durante la creazione di un nuovo disco del sistema operativo.
Dimensioni iniziali del disco in GB durante la creazione di un nuovo disco del sistema operativo.
|
|
ephemeralOSDiskSettings
|
DiffDiskSettings
|
Specifica le impostazioni temporanee del disco per il disco del sistema operativo usato dalla macchina virtuale.
Specifica le impostazioni temporanee del disco per il disco del sistema operativo usato dalla macchina virtuale.
|
|
managedDisk
|
ManagedDisk
|
Parametri del disco gestito.
Parametri del disco gestito.
|
|
writeAcceleratorEnabled
|
boolean
|
Specifica se writeAccelerator deve essere abilitato o disabilitato sul disco.
Specifica se writeAccelerator deve essere abilitato o disabilitato sul disco.
|
Pool
Oggetto
Contiene informazioni su un pool.
| Nome |
Tipo |
Valore predefinito |
Descrizione |
|
etag
|
string
|
|
ETag della risorsa, usata per le istruzioni di concorrenza.
|
|
id
|
string
(arm-id)
|
|
ID risorsa completo per la risorsa. Ad esempio, "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
|
|
identity
|
BatchPoolIdentity
|
|
Tipo di identità usato per il pool di batch.
|
|
name
|
string
|
|
Nome della risorsa
|
|
properties.allocationState
|
AllocationState
|
|
Indica se il pool sta ridimensionando.
Indica se il pool sta ridimensionando.
|
|
properties.allocationStateTransitionTime
|
string
(date-time)
|
|
Ora in cui il pool ha immesso lo stato di allocazione corrente.
Ora in cui il pool ha immesso lo stato di allocazione corrente.
|
|
properties.applicationPackages
|
ApplicationPackageReference[]
|
|
Elenco dei pacchetti dell'applicazione da installare in ogni nodo di calcolo del pool.
Le modifiche apportate ai riferimenti ai pacchetti dell'applicazione influiscono su tutti i nuovi nodi di calcolo che si aggiungono al pool, ma non influiscono sui nodi di calcolo già presenti nel pool finché non vengono riavviati o ricreati l'immagine. È previsto un massimo di 10 riferimenti al pacchetto dell'applicazione in un determinato pool.
|
|
properties.autoScaleRun
|
AutoScaleRun
|
|
Risultati ed errori dell'ultima esecuzione della formula di scalabilità automatica.
Questa proprietà viene impostata solo se il pool viene ridimensionato automaticamente, ad esempio autoScaleSettings.
|
|
properties.creationTime
|
string
(date-time)
|
|
Ora di creazione del pool.
Ora di creazione del pool.
|
|
properties.currentDedicatedNodes
|
integer
(int32)
|
|
Numero di nodi di calcolo dedicati attualmente presenti nel pool.
Numero di nodi di calcolo dedicati attualmente presenti nel pool.
|
|
properties.currentLowPriorityNodes
|
integer
(int32)
|
|
Numero di nodi di calcolo spot/con priorità bassa attualmente presenti nel pool.
Numero di nodi di calcolo spot/con priorità bassa attualmente presenti nel pool.
|
|
properties.deploymentConfiguration
|
DeploymentConfiguration
|
|
Questa proprietà descrive le macchine virtuali in cui verranno distribuiti i nodi del pool.
Proprietà di configurazione della distribuzione.
|
|
properties.displayName
|
string
|
|
Nome visualizzato per il pool.
Il nome visualizzato non deve essere univoco e può contenere caratteri Unicode fino a una lunghezza massima di 1024.
|
|
properties.interNodeCommunication
|
InterNodeCommunicationState
|
|
Indica se il pool consente la comunicazione diretta tra nodi.
Ciò impone restrizioni sui nodi che possono essere assegnati al pool. L'abilitazione di questo valore può ridurre la probabilità che il numero di nodi richiesto venga allocato nel pool. Se non specificato, il valore predefinito è 'Disabled'.
|
|
properties.lastModified
|
string
(date-time)
|
|
Ora dell'ultima modifica del pool.
Questa è l'ultima volta in cui i dati a livello di pool, ad esempio targetDedicatedNodes o autoScaleSettings, sono stati modificati. Non influisce su modifiche a livello di nodo, ad esempio uno stato di modifica del nodo di calcolo.
|
|
properties.metadata
|
MetadataItem[]
|
|
Elenco di coppie nome-valore associate al pool come metadati.
Il servizio Batch non assegna alcun significato ai metadati; è esclusivamente per l'uso del codice utente.
|
|
properties.mountConfiguration
|
MountConfiguration[]
|
|
Elenco di file system da montare in ogni nodo del pool.
Supporta File di Azure, NFS, CIFS/SMB e Blobfuse.
|
|
properties.networkConfiguration
|
NetworkConfiguration
|
|
Configurazione di rete per il pool.
Configurazione di rete per un pool.
|
|
properties.provisioningState
|
PoolProvisioningState
|
|
Stato corrente del pool.
Stato corrente del pool.
|
|
properties.provisioningStateTransitionTime
|
string
(date-time)
|
|
Ora in cui il pool ha immesso lo stato corrente.
Ora in cui il pool ha immesso lo stato corrente.
|
|
properties.resizeOperationStatus
|
ResizeOperationStatus
|
|
Contiene informazioni dettagliate sull'operazione di ridimensionamento corrente o dell'ultima operazione di ridimensionamento completata.
Descrive l'operazione corrente (se il pool AllocationState sta ridimensionando) o l'operazione completata in precedenza (se AllocationState è Stabile).
|
|
properties.scaleSettings
|
ScaleSettings
|
|
Impostazioni che configurano il numero di nodi nel pool.
Definisce le dimensioni desiderate del pool. Può trattarsi di "fixedScale" in cui è specificato targetDedicatedNodes richiesto oppure "autoScale" che definisce una formula che viene rivalutata periodicamente. Se questa proprietà non è specificata, il pool avrà una scala fissa con 0 targetDedicatedNodes.
|
|
properties.startTask
|
StartTask
|
|
Un'attività specificata per l'esecuzione in ogni nodo di calcolo durante l'aggiunta al pool.
In un'operazione PATCH (aggiornamento) questa proprietà può essere impostata su un oggetto vuoto per rimuovere l'attività di avvio dal pool.
|
|
properties.taskSchedulingPolicy
|
TaskSchedulingPolicy
|
|
Modalità di distribuzione delle attività tra nodi di calcolo in un pool.
Se non specificato, il valore predefinito è spread.
|
|
properties.taskSlotsPerNode
|
integer
(int32)
|
1
|
Numero di slot di attività che possono essere usati per eseguire attività simultanee in un singolo nodo di calcolo nel pool.
Il valore predefinito è 1. Il valore massimo è minore di 4 volte il numero di core di vmSize del pool o 256.
|
|
properties.upgradePolicy
|
UpgradePolicy
|
|
Criteri di aggiornamento per il pool.
Descrive un criterio di aggiornamento: automatico, manuale o in sequenza.
|
|
properties.userAccounts
|
UserAccount[]
|
|
Elenco di account utente da creare in ogni nodo del pool.
Elenco di account utente da creare in ogni nodo del pool.
|
|
properties.vmSize
|
string
|
|
Dimensioni delle macchine virtuali nel pool. Tutte le macchine virtuali in un pool hanno le stesse dimensioni.
Per informazioni sulle dimensioni delle macchine virtuali disponibili, vedere Dimensioni per le macchine virtuali in Azure (https://learn.microsoft.com/azure/virtual-machines/sizes/overview). Batch supporta tutte le dimensioni delle macchine virtuali di Azure tranne STANDARD_A0 e quelle con archiviazione Premium (STANDARD_GS, STANDARD_DS e serie di STANDARD_DSV2).
|
|
systemData
|
systemData
|
|
Metadati di Azure Resource Manager contenenti le informazioni createdBy e modifiedBy.
|
|
tags
|
object
|
|
Tag della risorsa.
|
|
type
|
string
|
|
Tipo di risorsa. Ad esempio, "Microsoft.Compute/virtualMachines" o "Microsoft.Storage/storageAccounts"
|
PoolEndpointConfiguration
Oggetto
Configurazione dell'endpoint per un pool.
| Nome |
Tipo |
Descrizione |
|
inboundNatPools
|
InboundNatPool[]
|
Elenco di pool NAT in ingresso che possono essere usati per gestire porte specifiche in un singolo nodo di calcolo esternamente.
Il numero massimo di pool NAT in ingresso per pool batch è 5. Se il numero massimo di pool NAT in ingresso viene superato, la richiesta ha esito negativo e viene visualizzato il codice di stato HTTP 400. Non è possibile specificare se IPAddressProvisioningType è NoPublicIPAddresses.
|
PoolIdentityType
Enumerazione
Tipo di identità usato per il pool di batch.
| Valore |
Descrizione |
|
UserAssigned
|
Al pool di Batch sono associate identità assegnate dall'utente.
|
|
None
|
Al pool di Batch non è associata alcuna identità. L'impostazione None nel pool di aggiornamenti rimuoverà le identità esistenti.
|
PoolProvisioningState
Enumerazione
Stato corrente del pool.
| Valore |
Descrizione |
|
Succeeded
|
Il pool è disponibile per eseguire attività soggette alla disponibilità dei nodi di calcolo.
|
|
Deleting
|
L'utente ha richiesto l'eliminazione del pool, ma l'operazione di eliminazione non è ancora stata completata.
|
ProxyAgentSettings
Oggetto
Specifica le impostazioni proxyAgent durante la creazione della macchina virtuale.
| Nome |
Tipo |
Descrizione |
|
enabled
|
boolean
|
Specifica se la funzionalità Protocollo di sicurezza dei metadati deve essere abilitata nella macchina virtuale o nel set di scalabilità di macchine virtuali. Il valore predefinito è False.
|
|
imds
|
HostEndpointSettings
|
Impostazioni per l'endpoint IMDS.
|
|
wireServer
|
HostEndpointSettings
|
Impostazioni per l'endpoint WireServer.
|
PublicIPAddressConfiguration
Oggetto
Configurazione dell'indirizzo IP pubblico della configurazione di rete di un pool.
| Nome |
Tipo |
Descrizione |
|
ipAddressIds
|
string[]
|
Elenco di indirizzi IP pubblici che verranno usati dal servizio Batch durante il provisioning dei nodi di calcolo.
Il numero di indirizzi IP specificati qui limita le dimensioni massime del pool : 100 nodi dedicati o 100 nodi spot/con priorità bassa possono essere allocati per ogni indirizzo IP pubblico. Ad esempio, un pool che richiede 250 macchine virtuali dedicate richiederebbe almeno 3 indirizzi IP pubblici specificati. Ogni elemento di questa raccolta è nel formato : /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/publicIPAddresses/{ip}.
|
|
ipFamilies
|
IPFamily[]
|
Le famiglie di IP utilizzate per specificare le versioni IP disponibili per il pool.
Le famiglie IP vengono utilizzate per determinare pool single-stack o dual-stack. Per uno stack singolo, il valore previsto è IPv4. Per dual stack, i valori previsti sono IPv4 e IPv6.
|
|
ipTags
|
IPTag[]
|
IP tag che si applicheranno ai nuovi IP pubblici creati da Batch.
IP tag che si applicheranno ai nuovi IP pubblici creati da Batch.
|
|
provision
|
IPAddressProvisioningType
|
Tipo di provisioning per gli indirizzi IP pubblici per il pool di batch.
Il valore predefinito è BatchManaged
|
ResizeError
Oggetto
Errore che si è verificato durante il ridimensionamento di un pool.
| Nome |
Tipo |
Descrizione |
|
code
|
string
|
Identificatore dell'errore. I codici sono invarianti e devono essere utilizzati a livello di codice.
|
|
details
|
ResizeError[]
|
Altri dettagli sull'errore.
Altri dettagli sull'errore.
|
|
message
|
string
|
Messaggio che descrive l'errore, destinato a essere adatto per la visualizzazione in un'interfaccia utente.
|
ResizeOperationStatus
Oggetto
Dettagli sull'operazione di ridimensionamento corrente o dell'ultima operazione di ridimensionamento completata.
| Nome |
Tipo |
Descrizione |
|
errors
|
ResizeError[]
|
Dettagli di eventuali errori riscontrati durante l'ultima operazione di ridimensionamento nel pool.
Questa proprietà viene impostata solo se si è verificato un errore durante l'ultimo ridimensionamento del pool e solo quando allocationState del pool è Steady.
|
|
nodeDeallocationOption
|
ComputeNodeDeallocationOption
|
Determina le operazioni da eseguire con un nodo e le relative attività in esecuzione dopo che è stata selezionata per la deallocazione.
Il valore predefinito è requeue.
|
|
resizeTimeout
|
string
(duration)
|
Timeout per l'allocazione dei nodi di calcolo al pool o rimozione dei nodi di calcolo dal pool.
Il valore predefinito è 15 minuti. Il valore minimo è 5 minuti. Se si specifica un valore inferiore a 5 minuti, il servizio Batch restituisce un errore; se si chiama direttamente l'API REST, il codice di stato HTTP è 400 (richiesta non valida).
|
|
startTime
|
string
(date-time)
|
Ora di avvio dell'operazione di ridimensionamento.
Ora di avvio dell'operazione di ridimensionamento.
|
|
targetDedicatedNodes
|
integer
(int32)
|
Numero desiderato di nodi di calcolo dedicati nel pool.
Numero desiderato di nodi di calcolo dedicati nel pool.
|
|
targetLowPriorityNodes
|
integer
(int32)
|
Numero desiderato di nodi di calcolo spot/con priorità bassa nel pool.
Numero desiderato di nodi di calcolo spot/con priorità bassa nel pool.
|
ResourceFile
Oggetto
Un singolo file o più file da scaricare in un nodo di calcolo.
| Nome |
Tipo |
Descrizione |
|
autoStorageContainerName
|
string
|
Nome del contenitore di archiviazione nell'account di archiviazione automatica.
Le proprietà autoStorageContainerName, storageContainerUrl e httpUrl si escludono a vicenda e una di esse deve essere specificata.
|
|
blobPrefix
|
string
|
Prefisso BLOB da usare durante il download di BLOB da un contenitore di Archiviazione di Azure. Verranno scaricati solo i BLOB i cui nomi iniziano con il prefisso specificato.
La proprietà è valida solo quando si usa autoStorageContainerName o storageContainerUrl. Questo prefisso può essere un nome file parziale o una sottodirectory. Se non viene specificato un prefisso, verranno scaricati tutti i file nel contenitore.
|
|
fileMode
|
string
|
Attributo della modalità di autorizzazione file in formato ottale.
Questa proprietà si applica solo ai file scaricati nei nodi di calcolo Linux. Verrà ignorato se viene specificato per un oggetto resourceFile che verrà scaricato in un nodo Windows. Se questa proprietà non viene specificata per un nodo Linux, al file viene applicato il valore predefinito 0770.
|
|
filePath
|
string
|
Percorso nel nodo di calcolo in cui scaricare il file, in relazione alla directory di lavoro dell'attività.
Se viene specificata la proprietà httpUrl, filePath è obbligatorio e descrive il percorso in cui verrà scaricato il file, incluso il nome file. In caso contrario, se si specifica la proprietà autoStorageContainerName o storageContainerUrl, filePath è facoltativo ed è la directory in cui scaricare i file. Nel caso in cui filePath venga usato come directory, qualsiasi struttura di directory già associata ai dati di input verrà mantenuta in modo completo e accodato alla directory filePath specificata. Il percorso relativo specificato non può uscire dalla directory di lavoro dell'attività, ad esempio tramite '..'.
|
|
httpUrl
|
string
|
URL del file da scaricare.
Le proprietà autoStorageContainerName, storageContainerUrl e httpUrl si escludono a vicenda e una di esse deve essere specificata. Se l'URL punta ad Archiviazione BLOB di Azure, deve essere leggibile dai nodi di calcolo. Esistono tre modi per ottenere tale URL per un BLOB nell'archiviazione di Azure: includere una firma di accesso condiviso (SAS) che concede le autorizzazioni di lettura per il BLOB, usare un'identità gestita con autorizzazione di lettura o impostare l'ACL per il BLOB o il relativo contenitore per consentire l'accesso pubblico.
|
|
identityReference
|
ComputeNodeIdentityReference
|
Riferimento all'identità assegnata dall'utente da usare per accedere all'archiviazione BLOB di Azure specificata da storageContainerUrl o httpUrl
Riferimento a un'identità assegnata dall'utente associata al pool di Batch che verrà usato da un nodo di calcolo.
|
|
storageContainerUrl
|
string
|
URL del contenitore BLOB all'interno di Archiviazione BLOB di Azure.
Le proprietà autoStorageContainerName, storageContainerUrl e httpUrl si escludono a vicenda e una di esse deve essere specificata. Questo URL deve essere leggibile ed elencabile dai nodi di calcolo. Esistono tre modi per ottenere tale URL per un contenitore nell'archiviazione di Azure: includere una firma di accesso condiviso che concede autorizzazioni di lettura ed elenco per il contenitore, usare un'identità gestita con autorizzazioni di lettura ed elenco o impostare l'ACL per il contenitore per consentire l'accesso pubblico.
|
RollingUpgradePolicy
Oggetto
Parametri di configurazione usati durante l'esecuzione di un aggiornamento in sequenza.
| Nome |
Tipo |
Descrizione |
|
enableCrossZoneUpgrade
|
boolean
|
Consentire al set di scalabilità di macchine virtuali di ignorare i limiti az durante la creazione di batch di aggiornamento. Prendere in considerazione il dominio di aggiornamento e maxBatchInstancePercent per determinare le dimensioni del batch. Se questo campo non è impostato, Azure Batch non imposta il valore predefinito. Il valore di enableCrossZoneUpgrade nell'oggetto VirtualMachineScaleSet creato verrà deciso dalle configurazioni predefinite in VirtualMachineScaleSet. Questo campo può essere impostato su true o false solo quando si usa NodePlacementConfiguration come Zonal.
|
|
maxBatchInstancePercent
|
integer
(int32)
minimum: 5 maximum: 100
|
Percentuale massima delle istanze totali di macchine virtuali che verranno aggiornate contemporaneamente dall'aggiornamento in sequenza in un unico batch. Poiché si tratta di un valore massimo, le istanze non integre nei batch precedenti o futuri possono causare la diminuzione della percentuale di istanze in un batch per garantire una maggiore affidabilità. Il valore di questo campo deve essere compreso tra 5 e 100 inclusi. Se vengono assegnati sia maxBatchInstancePercent che maxUnhealthyInstancePercent con valore, il valore di maxBatchInstancePercent non deve essere maggiore di maxUnhealthyInstancePercent.
|
|
maxUnhealthyInstancePercent
|
integer
(int32)
minimum: 5 maximum: 100
|
Percentuale massima delle istanze totali della macchina virtuale nel set di scalabilità che possono essere contemporaneamente non integre, in seguito all'aggiornamento o rilevate in uno stato non integro dai controlli di integrità della macchina virtuale prima dell'interruzione dell'aggiornamento in sequenza. Questo vincolo verrà controllato prima di avviare qualsiasi batch. Il valore di questo campo deve essere compreso tra 5 e 100 inclusi. Se vengono assegnati sia maxBatchInstancePercent che maxUnhealthyInstancePercent con valore, il valore di maxBatchInstancePercent non deve essere maggiore di maxUnhealthyInstancePercent.
|
|
maxUnhealthyUpgradedInstancePercent
|
integer
(int32)
minimum: 0 maximum: 100
|
Percentuale massima di istanze di macchina virtuale aggiornate che possono essere trovate in uno stato non integro. Questo controllo verrà eseguito dopo l'aggiornamento di ogni batch. Se questa percentuale viene mai superata, l'aggiornamento in sequenza viene interrotto. Il valore di questo campo deve essere compreso tra 0 e 100 inclusi.
|
|
pauseTimeBetweenBatches
|
string
|
Tempo di attesa tra il completamento dell'aggiornamento per tutte le macchine virtuali in un batch e l'avvio del batch successivo. La durata dell'ora deve essere specificata nel formato ISO 8601.
|
|
prioritizeUnhealthyInstances
|
boolean
|
Aggiornare tutte le istanze non integre in un set di scalabilità prima di qualsiasi istanza integra.
|
|
rollbackFailedInstancesOnPolicyBreach
|
boolean
|
Il rollback delle istanze non riuscite nel modello precedente se i criteri di aggiornamento in sequenza vengono violati.
|
ScaleSettings
Oggetto
Impostazioni di scalabilità per il pool
| Nome |
Tipo |
Descrizione |
|
autoScale
|
AutoScaleSettings
|
Impostazioni di scalabilità automatica per il pool.
Questa proprietà e fixedScale si escludono a vicenda e una delle proprietà deve essere specificata.
|
|
fixedScale
|
FixedScaleSettings
|
Impostazioni di scalabilità fisse per il pool.
Questa proprietà e la scalabilità automatica si escludono a vicenda e deve essere specificata una delle proprietà.
|
SecurityEncryptionTypes
Enumerazione
Specifica encryptionType del disco gestito. È impostato su DiskWithVMGuestState per la crittografia del disco gestito insieme al blob VMGuestState, su VMGuestStateOnly per la crittografia solo del blob VMGuestState, e su NonPersistedTPM per la mancata persistenza dello stato firmware nel blob VMGuestState.
Nota: può essere impostata solo per le macchine virtuali riservate e necessarie quando si usano macchine virtuali riservate.
| Valore |
Descrizione |
|
NonPersistedTPM
|
EncryptionType del disco gestito è impostato su NonPersistedTPM per non rendere persistente lo stato del firmware nel BLOB VMGuestState.
|
|
VMGuestStateOnly
|
EncryptionType del disco gestito è impostato su VMGuestStateOnly per la crittografia del solo BLOB VMGuestState.
|
|
DiskWithVMGuestState
|
EncryptionType del disco gestito è impostato su DiskWithVMGuestState per la crittografia del disco gestito insieme al BLOB VMGuestState. Non è supportata nei dischi dati.
|
SecurityProfile
Oggetto
Specifica le impostazioni del profilo di sicurezza per la macchina virtuale o il set di scalabilità di macchine virtuali.
| Nome |
Tipo |
Descrizione |
|
encryptionAtHost
|
boolean
|
Questa proprietà può essere usata dall'utente nella richiesta per abilitare o disabilitare la crittografia host per la macchina virtuale o il set di scalabilità di macchine virtuali. In questo modo verrà abilitata la crittografia per tutti i dischi, incluso il disco Resource/Temp nell'host stesso.
|
|
proxyAgentSettings
|
ProxyAgentSettings
|
Specifica le impostazioni proxyAgent durante la creazione della macchina virtuale.
|
|
securityType
|
SecurityTypes
|
Specifica il Tipo di sicurezza della macchina virtuale. Deve essere impostato su qualsiasi valore specificato per abilitare UefiSettings.
Specifica il Tipo di sicurezza della macchina virtuale. Deve essere impostato su qualsiasi valore specificato per abilitare UefiSettings.
|
|
uefiSettings
|
UefiSettings
|
Specifica le impostazioni di sicurezza, ad esempio l'avvio protetto e vTPM usato durante la creazione della macchina virtuale.
Specifica le impostazioni di sicurezza, ad esempio l'avvio protetto e vTPM usato durante la creazione della macchina virtuale.
|
SecurityTypes
Enumerazione
Specifica il Tipo di sicurezza della macchina virtuale. Deve essere impostato su qualsiasi valore specificato per abilitare UefiSettings.
| Valore |
Descrizione |
|
trustedLaunch
|
L'avvio attendibile protegge da tecniche di attacco avanzate e persistenti.
|
|
confidentialVM
|
Il confidential computing di Azure offre macchine virtuali riservate per i tenant con requisiti di sicurezza e riservatezza elevati. Queste macchine virtuali offrono un limite sicuro e imposto dall'hardware per soddisfare le esigenze di sicurezza. È possibile usare macchine virtuali riservate per le migrazioni senza apportare modifiche al codice, con la piattaforma che protegge lo stato della macchina virtuale dalla lettura o dalla modifica.
|
ServiceArtifactReference
Oggetto
Specifica l'ID di riferimento dell'artefatto del servizio usato per impostare la stessa versione dell'immagine per tutte le macchine virtuali nel set di scalabilità quando si usa la versione dell'immagine 'latest'.
| Nome |
Tipo |
Descrizione |
|
id
|
string
|
ID riferimento dell'artefatto del servizio di ServiceArtifactReference
ID riferimento dell'artefatto del servizio sotto forma di /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactName}/vmArtifactsProfiles/{vmArtifactsProfilesName}
|
StartTask
Oggetto
Attività che viene eseguita quando un nodo di calcolo aggiunge un pool nel servizio Azure Batch o quando il nodo di calcolo viene riavviato o ricreato l'immagine.
| Nome |
Tipo |
Valore predefinito |
Descrizione |
|
commandLine
|
string
|
|
Riga di comando dell'attività di avvio.
La riga di comando non viene eseguita in una shell e pertanto non può sfruttare le funzionalità della shell, ad esempio l'espansione delle variabili di ambiente. Se si desidera sfruttare tali funzionalità, è necessario richiamare la shell nella riga di comando, ad esempio usando "cmd /c MyCommand" in Windows o "/bin/sh -c MyCommand" in Linux. Obbligatorio se vengono specificate altre proprietà di startTask.
|
|
containerSettings
|
TaskContainerSettings
|
|
Impostazioni per il contenitore in cui viene eseguita l'attività di avvio.
Quando si specifica questa opzione, tutte le directory vengono mappate in modo ricorsivo al di sotto del AZ_BATCH_NODE_ROOT_DIR (la radice delle directory di Azure Batch nel nodo) nel contenitore, tutte le variabili di ambiente delle attività vengono mappate nel contenitore e la riga di comando dell'attività viene eseguita nel contenitore.
|
|
environmentSettings
|
EnvironmentSetting[]
|
|
Elenco delle impostazioni delle variabili di ambiente per l'attività di avvio.
Elenco delle impostazioni delle variabili di ambiente per l'attività di avvio.
|
|
maxTaskRetryCount
|
integer
(int32)
|
0
|
Numero massimo di tentativi di ripetizione dell'attività.
Il servizio Batch ritenta un'attività se il codice di uscita è diverso da zero. Si noti che questo valore controlla in modo specifico il numero di tentativi. Il servizio Batch proverà l'attività una sola volta e potrebbe quindi riprovare fino a questo limite. Ad esempio, se il numero massimo di tentativi è 3, Batch prova l'attività fino a 4 volte (un tentativo iniziale e 3 tentativi). Se il numero massimo di tentativi è 0, il servizio Batch non ritenta l'attività. Se il numero massimo di tentativi è -1, il servizio Batch ritenta l'attività senza limiti. Il valore predefinito è 0
|
|
resourceFiles
|
ResourceFile[]
|
|
Elenco di file che il servizio Batch scaricherà nel nodo di calcolo prima di eseguire la riga di comando.
Elenco di file che il servizio Batch scaricherà nel nodo di calcolo prima di eseguire la riga di comando.
|
|
userIdentity
|
UserIdentity
|
|
Identità utente con cui viene eseguita l'attività di avvio.
Se omesso, l'attività viene eseguita come utente non amministrativo univoco per l'attività.
|
|
waitForSuccess
|
boolean
|
|
Indica se il servizio Batch deve attendere che l'attività di avvio venga completata correttamente( ovvero per uscire con il codice di uscita 0) prima di pianificare eventuali attività nel nodo di calcolo.
Se true e l'attività di avvio non riesce in un nodo di calcolo, il servizio Batch ritenta l'attività di avvio fino al numero massimo di tentativi (maxTaskRetryCount). Se l'attività non è ancora stata completata correttamente dopo tutti i tentativi, il servizio Batch contrassegna il nodo di calcolo inutilizzabile e non pianifica le attività. Questa condizione può essere rilevata tramite lo stato del nodo e i dettagli degli errori di pianificazione. Se false, il servizio Batch non attenderà il completamento dell'attività di avvio. In questo caso, altre attività possono avviare l'esecuzione nel nodo di calcolo mentre l'attività di avvio è ancora in esecuzione; e anche se l'attività di avvio non riesce, le nuove attività continueranno a essere pianificate nel nodo. Il valore predefinito è vero.
|
StorageAccountType
Enumerazione
Tipo di account di archiviazione da usare per la creazione di dischi dati o disco del sistema operativo.
| Valore |
Descrizione |
|
Standard_LRS
|
Il disco dati/disco del sistema operativo deve usare l'archiviazione con ridondanza locale standard.
|
|
Premium_LRS
|
Il disco dati/disco del sistema operativo deve usare l'archiviazione con ridondanza locale Premium.
|
|
StandardSSD_LRS
|
Il disco dati/disco del sistema operativo deve usare l'archiviazione con ridondanza locale ssd standard.
|
systemData
Oggetto
Metadati relativi alla creazione e all'ultima modifica della risorsa.
| Nome |
Tipo |
Descrizione |
|
createdAt
|
string
(date-time)
|
Timestamp della creazione della risorsa (UTC).
|
|
createdBy
|
string
|
Identità che ha creato la risorsa.
|
|
createdByType
|
createdByType
|
Tipo di identità che ha creato la risorsa.
|
|
lastModifiedAt
|
string
(date-time)
|
Il timestamp dell'ultima modifica della risorsa (UTC)
|
|
lastModifiedBy
|
string
|
Identità che ha modificato l'ultima volta la risorsa.
|
|
lastModifiedByType
|
createdByType
|
Tipo di identità che ha modificato l'ultima volta la risorsa.
|
TaskContainerSettings
Oggetto
Impostazioni del contenitore per un'attività.
| Nome |
Tipo |
Descrizione |
|
containerHostBatchBindMounts
|
ContainerHostBatchBindMountEntry[]
|
Percorsi da montare nell'attività contenitore.
Se questa matrice è null o non è presente, l'attività contenitore monta l'intera unità disco temporanea in Windows (o AZ_BATCH_NODE_ROOT_DIR in Linux). Se questa matrice è impostata come vuota, non verrà montato alcun percorso dati nel contenitore.
|
|
containerRunOptions
|
string
|
Opzioni aggiuntive per il comando create del contenitore.
Queste opzioni aggiuntive vengono fornite come argomenti al comando "docker create", oltre a quelli controllati dal servizio Batch.
|
|
imageName
|
string
|
Immagine da usare per creare il contenitore in cui verrà eseguita l'attività.
Questo è il riferimento completo all'immagine, come sarebbe stato specificato in "docker pull". Se non viene specificato alcun tag come parte del nome dell'immagine, il tag ":latest" viene usato come valore predefinito.
|
|
registry
|
ContainerRegistry
|
Registro privato che contiene l'immagine del contenitore.
Questa impostazione può essere omessa se è già stata specificata durante la creazione del pool.
|
|
workingDirectory
|
ContainerWorkingDirectory
|
Flag per indicare dove si trova la directory di lavoro dell'attività contenitore. Il valore predefinito è 'taskWorkingDirectory'.
Flag per indicare dove si trova la directory di lavoro dell'attività contenitore. Il valore predefinito è 'taskWorkingDirectory'.
|
TaskSchedulingPolicy
Oggetto
Specifica la modalità di distribuzione delle attività tra i nodi di calcolo.
| Nome |
Tipo |
Valore predefinito |
Descrizione |
|
jobDefaultOrder
|
JobDefaultOrder
|
|
Se non viene specificato, il valore predefinito è nessuno.
L'ordine per la programmazione delle attività da processi diversi con la stessa priorità.
|
|
nodeFillType
|
ComputeNodeFillType
|
Spread
|
Modalità di distribuzione delle attività tra i nodi di calcolo.
Modalità di distribuzione delle attività tra i nodi di calcolo.
|
UefiSettings
Oggetto
Specifica le impostazioni di sicurezza, ad esempio l'avvio protetto e vTPM usato durante la creazione della macchina virtuale.
| Nome |
Tipo |
Descrizione |
|
secureBootEnabled
|
boolean
|
Specifica se l'avvio protetto deve essere abilitato nella macchina virtuale.
|
|
vTpmEnabled
|
boolean
|
Specifica se vTPM deve essere abilitato nella macchina virtuale.
|
UpgradeMode
Enumerazione
Specifica la modalità di un aggiornamento alle macchine virtuali nel set di scalabilità.
I valori possibili sono:
manuale: è possibile controllare l'applicazione degli aggiornamenti alle macchine virtuali nel set di scalabilità. A tale scopo, usare l'azione manualUpgrade.
automatico: tutte le macchine virtuali nel set di scalabilità vengono aggiornate automaticamente contemporaneamente.
in sequenza: il set di scalabilità esegue gli aggiornamenti in batch con un tempo di pausa facoltativo tra di loro.
| Valore |
Descrizione |
|
automatic
|
Tutte le macchine virtuali nel set di scalabilità vengono aggiornate automaticamente contemporaneamente.
|
|
manual
|
È possibile controllare l'applicazione degli aggiornamenti alle macchine virtuali nel set di scalabilità. A tale scopo, usare l'azione manualUpgrade.
|
|
rolling
|
Le istanze esistenti in un set di scalabilità vengono abbassate in batch da aggiornare. Al termine del batch aggiornato, le istanze inizieranno a riprendere il traffico e il batch successivo inizierà. Questo continua fino a quando tutte le istanze non hanno portato up-to-date.
|
UpgradePolicy
Oggetto
Descrive un criterio di aggiornamento: automatico, manuale o in sequenza.
| Nome |
Tipo |
Descrizione |
|
automaticOSUpgradePolicy
|
AutomaticOSUpgradePolicy
|
Parametri di configurazione usati per eseguire l'aggiornamento automatico del sistema operativo.
Parametri di configurazione usati per eseguire l'aggiornamento automatico del sistema operativo.
|
|
mode
|
UpgradeMode
|
Specifica la modalità di un aggiornamento alle macchine virtuali nel set di scalabilità.
I valori possibili sono:
manuale: è possibile controllare l'applicazione degli aggiornamenti alle macchine virtuali nel set di scalabilità. A tale scopo, usare l'azione manualUpgrade.
automatico: tutte le macchine virtuali nel set di scalabilità vengono aggiornate automaticamente contemporaneamente.
in sequenza: il set di scalabilità esegue gli aggiornamenti in batch con un tempo di pausa facoltativo tra di loro.
Specifica la modalità di un aggiornamento alle macchine virtuali nel set di scalabilità.
I valori possibili sono:
manuale: è possibile controllare l'applicazione degli aggiornamenti alle macchine virtuali nel set di scalabilità. A tale scopo, usare l'azione manualUpgrade.
automatico: tutte le macchine virtuali nel set di scalabilità vengono aggiornate automaticamente contemporaneamente.
in sequenza: il set di scalabilità esegue gli aggiornamenti in batch con un tempo di pausa facoltativo tra di loro.
|
|
rollingUpgradePolicy
|
RollingUpgradePolicy
|
Parametri di configurazione usati durante l'esecuzione di un aggiornamento in sequenza.
Parametri di configurazione usati durante l'esecuzione di un aggiornamento in sequenza.
|
UserAccount
Oggetto
Proprietà usate per creare un utente in un nodo di Azure Batch.
| Nome |
Tipo |
Descrizione |
|
elevationLevel
|
ElevationLevel
|
Livello di elevazione dell'utente.
nonAdmin: l'utente automatico è un utente standard senza accesso con privilegi elevati. admin: l'utente automatico è un utente con accesso con privilegi elevati e opera con autorizzazioni di amministratore complete. Il valore predefinito è nonAdmin.
|
|
linuxUserConfiguration
|
LinuxUserConfiguration
|
Configurazione utente specifica di Linux per l'account utente.
Questa proprietà viene ignorata se specificata in un pool di Windows. Se non specificato, l'utente viene creato con le opzioni predefinite.
|
|
name
|
string
|
Nome dell'account utente. I nomi possono contenere qualsiasi carattere Unicode fino a una lunghezza massima di 20.
Nome dell'account utente. I nomi possono contenere qualsiasi carattere Unicode fino a una lunghezza massima di 20.
|
|
password
|
string
(password)
|
Password per l'account utente.
Password per l'account utente.
|
|
windowsUserConfiguration
|
WindowsUserConfiguration
|
Configurazione utente specifica di Windows per l'account utente.
Questa proprietà può essere specificata solo se l'utente si trova in un pool di Windows. Se non specificato e in un pool di Windows, l'utente viene creato con le opzioni predefinite.
|
UserAssignedIdentities
Oggetto
Elenco delle identità utente associate.
| Nome |
Tipo |
Descrizione |
|
clientId
|
string
|
ID client dell'identità assegnata dall'utente.
|
|
principalId
|
string
|
ID principale dell'identità assegnata dall'utente.
|
UserIdentity
Oggetto
Definizione dell'identità utente con cui viene eseguita l'attività.
| Nome |
Tipo |
Descrizione |
|
autoUser
|
AutoUserSpecification
|
Utente automatico con cui viene eseguita l'attività.
Le proprietà userName e autoUser si escludono a vicenda; è necessario specificarne uno ma non entrambi.
|
|
userName
|
string
|
Nome dell'identità utente con cui viene eseguita l'attività.
Le proprietà userName e autoUser si escludono a vicenda; è necessario specificarne uno ma non entrambi.
|
VirtualMachineConfiguration
Oggetto
Configurazione per i nodi di calcolo in un pool basato sull'infrastruttura di Macchine virtuali di Azure.
| Nome |
Tipo |
Descrizione |
|
containerConfiguration
|
ContainerConfiguration
|
Configurazione del contenitore per il pool.
Se specificato, il programma di installazione viene eseguito in ogni nodo del pool per consentire l'esecuzione delle attività nei contenitori. Tutte le normali attività e le attività del gestore di processi eseguite in questo pool devono specificare la proprietà containerSettings e tutte le altre attività possono specificarla.
|
|
dataDisks
|
DataDisk[]
|
Configurazione per i dischi dati collegati ai nodi di calcolo nel pool.
Questa proprietà deve essere specificata se i nodi di calcolo nel pool devono avere dischi dati vuoti collegati.
|
|
diskEncryptionConfiguration
|
DiskEncryptionConfiguration
|
Configurazione della crittografia del disco per il pool.
Se specificato, la crittografia viene eseguita in ogni nodo del pool durante il provisioning dei nodi.
|
|
extensions
|
VMExtension[]
|
Estensione macchina virtuale per il pool.
Se specificato, le estensioni indicate in questa configurazione verranno installate in ogni nodo.
|
|
imageReference
|
ImageReference
|
Riferimento all'immagine del Marketplace delle macchine virtuali di Azure o all'immagine di macchina virtuale personalizzata da usare.
Riferimento a un'immagine di Azure Virtual Machines Marketplace o alla risorsa Immagine di Azure di una macchina virtuale personalizzata. Per ottenere l'elenco di tutte le immaginiReference verificate da Azure Batch, vedere l'operazione "Elenca gli SKU dell'agente del nodo supportati".
|
|
licenseType
|
string
|
Tipo di licenza locale da usare durante la distribuzione del sistema operativo.
Questo vale solo per le immagini che contengono il sistema operativo Windows e devono essere usate solo quando si contengono licenze locali valide per i nodi che verranno distribuiti. Se omesso, non viene applicato alcun sconto sulle licenze locali. I valori sono:
Windows_Server: la licenza locale è per Windows Server.
Windows_Client: la licenza locale è per il client Windows.
|
|
nodeAgentSkuId
|
string
|
SKU dell'agente del nodo Batch di cui eseguire il provisioning nei nodi di calcolo nel pool.
L'agente del nodo Batch è un programma che viene eseguito in ogni nodo del pool e fornisce l'interfaccia di comando e controllo tra il nodo e il servizio Batch. Sono disponibili diverse implementazioni dell'agente del nodo, definite SKU, per sistemi operativi diversi. È necessario specificare uno SKU dell'agente del nodo che corrisponde al riferimento all'immagine selezionata. Per ottenere l'elenco degli SKU dell'agente di nodi supportati insieme all'elenco dei riferimenti alle immagini verificate, vedere l'operazione "Elenca gli SKU dell'agente del nodo supportati".
|
|
nodePlacementConfiguration
|
NodePlacementConfiguration
|
Configurazione del posizionamento del nodo per il pool.
Questa configurazione specificherà le regole sulla modalità di allocazione fisica dei nodi nel pool.
|
|
osDisk
|
OSDisk
|
Impostazioni per il disco del sistema operativo della macchina virtuale.
Contiene la configurazione per le impostazioni temporanee di OSDisk.
|
|
securityProfile
|
SecurityProfile
|
Specifica le impostazioni del profilo di sicurezza per la macchina virtuale o il set di scalabilità di macchine virtuali.
Specifica le impostazioni del profilo di sicurezza per la macchina virtuale o il set di scalabilità di macchine virtuali.
|
|
serviceArtifactReference
|
ServiceArtifactReference
|
Specifica l'ID di riferimento dell'artefatto del servizio usato per impostare la stessa versione dell'immagine per tutte le macchine virtuali nel set di scalabilità quando si usa la versione dell'immagine 'latest'.
ID riferimento dell'artefatto del servizio sotto forma di /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactName}/vmArtifactsProfiles/{vmArtifactsProfilesName}
|
|
windowsConfiguration
|
WindowsConfiguration
|
Impostazioni del sistema operativo Windows nella macchina virtuale.
Questa proprietà non deve essere specificata se imageReference specifica un'immagine del sistema operativo Linux.
|
VMDiskSecurityProfile
Oggetto
Specifica le impostazioni del profilo di sicurezza per il disco gestito.
Nota: può essere impostata solo per le macchine virtuali riservate ed è necessaria quando si usano macchine virtuali riservate.
| Nome |
Tipo |
Descrizione |
|
diskEncryptionSet
|
DiskEncryptionSetParameters
|
Specifica l'ID risorsa del set di crittografia dischi gestiti dal cliente per il disco gestito usato per il disco del sistema operativo ConfidentialVM crittografato con chiave gestita dal cliente e il BLOB VMGuest. Può essere impostato solo in modalità UserSubscription.
|
|
securityEncryptionType
|
SecurityEncryptionTypes
|
Specifica encryptionType del disco gestito. È impostato su VMGuestStateOnly per la crittografia solo del BLOB VMGuestState e NonPersistedTPM per non rendere persistente lo stato del firmware nel BLOB VMGuestState.
Nota: può essere impostata solo per le macchine virtuali riservate e necessarie quando si usano macchine virtuali riservate.
Specifica encryptionType del disco gestito. È impostato su VMGuestStateOnly per la crittografia solo del BLOB VMGuestState e NonPersistedTPM per non rendere persistente lo stato del firmware nel BLOB VMGuestState.
Nota: può essere impostata solo per le macchine virtuali riservate e necessarie quando si usano macchine virtuali riservate.
|
VMExtension
Oggetto
Configurazione per le estensioni della macchina virtuale.
| Nome |
Tipo |
Descrizione |
|
autoUpgradeMinorVersion
|
boolean
|
Indica se l'estensione deve usare una versione secondaria più recente, se disponibile in fase di distribuzione. Dopo la distribuzione, tuttavia, l'estensione non aggiornerà le versioni secondarie a meno che non venga ridistribuibile, anche con questa proprietà impostata su true.
|
|
enableAutomaticUpgrade
|
boolean
|
Indica se l'estensione deve essere aggiornata automaticamente dalla piattaforma se è disponibile una versione più recente dell'estensione.
|
|
name
|
string
|
Nome dell'estensione macchina virtuale.
Nome dell'estensione macchina virtuale.
|
|
protectedSettings
|
|
L'estensione può contenere protectedSettings o protectedSettingsFromKeyVault o nessuna impostazione protetta.
|
|
provisionAfterExtensions
|
string[]
|
Raccolta di nomi di estensione.
Raccolta di nomi di estensione dopo i quali è necessario effettuare il provisioning di questa estensione.
|
|
publisher
|
string
|
Nome del server di pubblicazione del gestore dell'estensione.
Nome del server di pubblicazione del gestore dell'estensione.
|
|
settings
|
|
Impostazioni pubbliche in formato JSON per l'estensione.
Impostazioni pubbliche in formato JSON per l'estensione.
|
|
type
|
string
|
Tipo di estensioni.
Tipo di estensioni.
|
|
typeHandlerVersion
|
string
|
Versione del gestore di script.
Versione del gestore di script.
|
WindowsConfiguration
Oggetto
Impostazioni del sistema operativo Windows da applicare alla macchina virtuale.
| Nome |
Tipo |
Descrizione |
|
enableAutomaticUpdates
|
boolean
|
Indica se gli aggiornamenti automatici sono abilitati nella macchina virtuale.
Se omesso, il valore predefinito è true.
|
WindowsUserConfiguration
Oggetto
Proprietà usate per creare un account utente in un nodo di Windows.
| Nome |
Tipo |
Descrizione |
|
loginMode
|
LoginMode
|
Modalità di accesso per l'utente
Specifica la modalità di accesso per l'utente. Il valore predefinito è Interactive.
|