Pool - List By Batch Account

Service:

Batch Management

Version d'API:

2024-07-01

Répertorie tous les pools du compte spécifié.

GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools?api-version=2024-07-01

Avec des paramètres facultatifs:

GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools?maxresults={maxresults}&$select={$select}&$filter={$filter}&api-version=2024-07-01

Paramètres URI

Nom	Dans	Obligatoire	Type	Description
accountName	path	True	string minLength: 3 maxLength: 24 pattern: ^[a-zA-Z0-9]+$	Nom du compte Batch.
resourceGroupName	path	True	string	Nom du groupe de ressources qui contient le compte Batch.
subscriptionId	path	True	string	ID d’abonnement Azure. Il s’agit d’une chaîne au format GUID (par exemple, 000000000-0000-0000-0000-000000000000000000000)
api-version	query	True	string	Version de l’API à utiliser avec la requête HTTP.
$filter	query		string	Expression de filtre OData. Les propriétés valides pour le filtrage sont les suivantes : propriétés name/allocationState properties/allocationStateTransitionTime properties/creationTime properties/provisioningState properties/provisioningStateTransitionTime properties/lastModified properties/vmSize properties/interNodeCommunication properties/scaleSettings/autoScale properties/scaleSettings/fixedScale
$select	query		string	Liste séparée par des virgules des propriétés qui doivent être retournées. par exemple, « properties/provisioningState ». Seules les propriétés de niveau supérieur sous propriétés/sont valides pour la sélection.
maxresults	query		integer (int32)	Nombre maximal d’éléments à retourner dans la réponse.

Réponses

Nom	Type	Description
200 OK	ListPoolsResult	L’opération a réussi. La réponse contient une liste de certificats associés au compte.
Other Status Codes	CloudError	Réponse d’erreur décrivant pourquoi l’opération a échoué.

Sécurité

azure_auth

Flux de code d’authentification Microsoft Entra OAuth 2.0

Type: oauth2
Flux: implicit
URL d’autorisation: https://login.microsoftonline.com/common/oauth2/authorize

Étendues

Nom	Description
user_impersonation	emprunter l’identité de votre compte d’utilisateur

Exemples

ListPool

ListPoolWithFilter

ListPool

Exemple de requête

HTTP

GET https://management.azure.com/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools?api-version=2024-07-01

Java

/**
 * Samples for Pool ListByBatchAccount.
 */
public final class Main {
    /*
     * x-ms-original-file: specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolList.json
     */
    /**
     * Sample code: ListPool.
     * 
     * @param manager Entry point to BatchManager.
     */
    public static void listPool(com.azure.resourcemanager.batch.BatchManager manager) {
        manager.pools().listByBatchAccount("default-azurebatch-japaneast", "sampleacct", null, null, null,
            com.azure.core.util.Context.NONE);
    }
}

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

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.batch import BatchManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-batch
# USAGE
    python pool_list.py

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


def main():
    client = BatchManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="subid",
    )

    response = client.pool.list_by_batch_account(
        resource_group_name="default-azurebatch-japaneast",
        account_name="sampleacct",
    )
    for item in response:
        print(item)


# x-ms-original-file: specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolList.json
if __name__ == "__main__":
    main()

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

Go

package armbatch_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/batch/armbatch/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e79d9ef3e065f2dcb6bd1db51e29c62a99dff5cb/specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolList.json
func ExamplePoolClient_NewListByBatchAccountPager_listPool() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbatch.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPoolClient().NewListByBatchAccountPager("default-azurebatch-japaneast", "sampleacct", &armbatch.PoolClientListByBatchAccountOptions{Maxresults: nil,
		Select: nil,
		Filter: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ListPoolsResult = armbatch.ListPoolsResult{
		// 	Value: []*armbatch.Pool{
		// 		{
		// 			Name: to.Ptr("testpool"),
		// 			Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
		// 			Etag: to.Ptr("W/\"0x8D4EDFEBFADF4AB\""),
		// 			ID: to.Ptr("/subscriptions/subid/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.940Z"); return t}()),
		// 				ApplicationLicenses: []*string{
		// 					to.Ptr("app-license0"),
		// 					to.Ptr("app-license1")},
		// 					ApplicationPackages: []*armbatch.ApplicationPackageReference{
		// 						{
		// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool/applications/app_1234"),
		// 							Version: to.Ptr("asdf"),
		// 					}},
		// 					Certificates: []*armbatch.CertificateReference{
		// 						{
		// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool/certificates/sha1-1234567"),
		// 							StoreLocation: to.Ptr(armbatch.CertificateStoreLocationLocalMachine),
		// 							StoreName: to.Ptr("MY"),
		// 							Visibility: []*armbatch.CertificateVisibility{
		// 								to.Ptr(armbatch.CertificateVisibilityRemoteUser)},
		// 						}},
		// 						CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.940Z"); 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("2016-Datacenter-SmallDisk"),
		// 									Version: to.Ptr("latest"),
		// 								},
		// 								NodeAgentSKUID: to.Ptr("batch.node.windows amd64"),
		// 							},
		// 						},
		// 						InterNodeCommunication: to.Ptr(armbatch.InterNodeCommunicationStateEnabled),
		// 						LastModified: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.940Z"); return t}()),
		// 						Metadata: []*armbatch.MetadataItem{
		// 							{
		// 								Name: to.Ptr("metadata-1"),
		// 								Value: to.Ptr("value-1"),
		// 							},
		// 							{
		// 								Name: to.Ptr("metadata-2"),
		// 								Value: to.Ptr("value-2"),
		// 						}},
		// 						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("*")},
		// 												},
		// 												{
		// 													Access: to.Ptr(armbatch.NetworkSecurityGroupRuleAccessDeny),
		// 													Priority: to.Ptr[int32](3500),
		// 													SourceAddressPrefix: to.Ptr("*"),
		// 													SourcePortRanges: []*string{
		// 														to.Ptr("*")},
		// 												}},
		// 												Protocol: to.Ptr(armbatch.InboundEndpointProtocolTCP),
		// 										}},
		// 									},
		// 									SubnetID: to.Ptr("/subscriptions/subid/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.940Z"); return t}()),
		// 								ResizeOperationStatus: &armbatch.ResizeOperationStatus{
		// 									Errors: []*armbatch.ResizeError{
		// 										{
		// 											Code: to.Ptr("AllocationTimedout"),
		// 											Message: to.Ptr("Desired number of dedicated nodes could not be allocated as the resize timeout was reached"),
		// 									}},
		// 									NodeDeallocationOption: to.Ptr(armbatch.ComputeNodeDeallocationOptionTaskCompletion),
		// 									ResizeTimeout: to.Ptr("PT8M"),
		// 									StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.940Z"); return t}()),
		// 									TargetDedicatedNodes: to.Ptr[int32](6),
		// 									TargetLowPriorityNodes: to.Ptr[int32](28),
		// 								},
		// 								ScaleSettings: &armbatch.ScaleSettings{
		// 									FixedScale: &armbatch.FixedScaleSettings{
		// 										ResizeTimeout: to.Ptr("PT8M"),
		// 										TargetDedicatedNodes: to.Ptr[int32](6),
		// 										TargetLowPriorityNodes: to.Ptr[int32](28),
		// 									},
		// 								},
		// 								StartTask: &armbatch.StartTask{
		// 									CommandLine: to.Ptr("cmd /c SET"),
		// 									EnvironmentSettings: []*armbatch.EnvironmentSetting{
		// 										{
		// 											Name: to.Ptr("MYSET"),
		// 											Value: to.Ptr("1234"),
		// 									}},
		// 									MaxTaskRetryCount: to.Ptr[int32](6),
		// 									ResourceFiles: []*armbatch.ResourceFile{
		// 										{
		// 											FileMode: to.Ptr("777"),
		// 											FilePath: to.Ptr("c:\\temp\\gohere"),
		// 											HTTPURL: to.Ptr("https://testaccount.blob.core.windows.net/example-blob-file"),
		// 									}},
		// 									UserIdentity: &armbatch.UserIdentity{
		// 										AutoUser: &armbatch.AutoUserSpecification{
		// 											ElevationLevel: to.Ptr(armbatch.ElevationLevelAdmin),
		// 											Scope: to.Ptr(armbatch.AutoUserScopePool),
		// 										},
		// 									},
		// 									WaitForSuccess: to.Ptr(true),
		// 								},
		// 								TaskSchedulingPolicy: &armbatch.TaskSchedulingPolicy{
		// 									NodeFillType: to.Ptr(armbatch.ComputeNodeFillTypePack),
		// 								},
		// 								TaskSlotsPerNode: to.Ptr[int32](13),
		// 								UserAccounts: []*armbatch.UserAccount{
		// 									{
		// 										Name: to.Ptr("username1"),
		// 										ElevationLevel: to.Ptr(armbatch.ElevationLevelAdmin),
		// 										LinuxUserConfiguration: &armbatch.LinuxUserConfiguration{
		// 											Gid: to.Ptr[int32](4567),
		// 											UID: to.Ptr[int32](1234),
		// 										},
		// 								}},
		// 								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

JavaScript

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

/**
 * This sample demonstrates how to Lists all of the pools in the specified account.
 *
 * @summary Lists all of the pools in the specified account.
 * x-ms-original-file: specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolList.json
 */
async function listPool() {
  const subscriptionId = process.env["BATCH_SUBSCRIPTION_ID"] || "subid";
  const resourceGroupName = process.env["BATCH_RESOURCE_GROUP"] || "default-azurebatch-japaneast";
  const accountName = "sampleacct";
  const credential = new DefaultAzureCredential();
  const client = new BatchManagementClient(credential, subscriptionId);
  const resArray = new Array();
  for await (let item of client.poolOperations.listByBatchAccount(resourceGroupName, accountName)) {
    resArray.push(item);
  }
  console.log(resArray);
}

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

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Collections.Generic;
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/stable/2024-07-01/examples/PoolList.json
// this example is just showing the usage of "Pool_ListByBatchAccount" 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 = "subid";
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 and iterate over the result
await foreach (BatchAccountPoolResource item in collection.GetAllAsync())
{
    // the variable item 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 = item.Data;
    // for demo we just print out the id
    Console.WriteLine($"Succeeded on id: {resourceData.Id}");
}

Console.WriteLine($"Succeeded");

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

Exemple de réponse

Code d’état:

200

{
  "value": [
    {
      "id": "/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
      "name": "testpool",
      "type": "Microsoft.Batch/batchAccounts/pools",
      "etag": "W/\"0x8D4EDFEBFADF4AB\"",
      "properties": {
        "lastModified": "2017-08-28T10:22:55.9407275Z",
        "creationTime": "2017-08-28T10:22:55.9407275Z",
        "provisioningState": "Succeeded",
        "provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
        "allocationState": "Steady",
        "allocationStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
        "vmSize": "STANDARD_D4",
        "interNodeCommunication": "Enabled",
        "taskSlotsPerNode": 13,
        "taskSchedulingPolicy": {
          "nodeFillType": "Pack"
        },
        "deploymentConfiguration": {
          "virtualMachineConfiguration": {
            "imageReference": {
              "publisher": "MicrosoftWindowsServer",
              "offer": "WindowsServer",
              "sku": "2016-Datacenter-SmallDisk",
              "version": "latest"
            },
            "nodeAgentSkuId": "batch.node.windows amd64"
          }
        },
        "scaleSettings": {
          "fixedScale": {
            "targetDedicatedNodes": 6,
            "targetLowPriorityNodes": 28,
            "resizeTimeout": "PT8M"
          }
        },
        "networkConfiguration": {
          "subnetId": "/subscriptions/subid/resourceGroups/rg1234/providers/Microsoft.Network/virtualNetworks/network1234/subnets/subnet123",
          "endpointConfiguration": {
            "inboundNatPools": [
              {
                "name": "testnat",
                "protocol": "TCP",
                "backendPort": 12001,
                "frontendPortRangeStart": 15000,
                "frontendPortRangeEnd": 15100,
                "networkSecurityGroupRules": [
                  {
                    "access": "Allow",
                    "sourceAddressPrefix": "192.100.12.45",
                    "priority": 150,
                    "sourcePortRanges": [
                      "*"
                    ]
                  },
                  {
                    "access": "Deny",
                    "sourceAddressPrefix": "*",
                    "priority": 3500,
                    "sourcePortRanges": [
                      "*"
                    ]
                  }
                ]
              }
            ]
          }
        },
        "metadata": [
          {
            "name": "metadata-1",
            "value": "value-1"
          },
          {
            "name": "metadata-2",
            "value": "value-2"
          }
        ],
        "startTask": {
          "commandLine": "cmd /c SET",
          "resourceFiles": [
            {
              "httpUrl": "https://testaccount.blob.core.windows.net/example-blob-file",
              "filePath": "c:\\temp\\gohere",
              "fileMode": "777"
            }
          ],
          "environmentSettings": [
            {
              "name": "MYSET",
              "value": "1234"
            }
          ],
          "userIdentity": {
            "autoUser": {
              "scope": "Pool",
              "elevationLevel": "Admin"
            }
          },
          "maxTaskRetryCount": 6,
          "waitForSuccess": true
        },
        "userAccounts": [
          {
            "name": "username1",
            "elevationLevel": "Admin",
            "linuxUserConfiguration": {
              "uid": 1234,
              "gid": 4567
            }
          }
        ],
        "applicationPackages": [
          {
            "id": "/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool/applications/app_1234",
            "version": "asdf"
          }
        ],
        "certificates": [
          {
            "id": "/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool/certificates/sha1-1234567",
            "storeLocation": "LocalMachine",
            "storeName": "MY",
            "visibility": [
              "RemoteUser"
            ]
          }
        ],
        "applicationLicenses": [
          "app-license0",
          "app-license1"
        ],
        "currentDedicatedNodes": 0,
        "currentLowPriorityNodes": 0,
        "resizeOperationStatus": {
          "startTime": "2017-08-28T10:22:55.9407275Z",
          "targetDedicatedNodes": 6,
          "targetLowPriorityNodes": 28,
          "nodeDeallocationOption": "TaskCompletion",
          "resizeTimeout": "PT8M",
          "errors": [
            {
              "code": "AllocationTimedout",
              "message": "Desired number of dedicated nodes could not be allocated as the resize timeout was reached"
            }
          ]
        }
      }
    }
  ]
}

ListPoolWithFilter

Exemple de requête

HTTP

GET https://management.azure.com/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools?$select=properties/allocationState,properties/provisioningStateTransitionTime,properties/currentDedicatedNodes,properties/currentLowPriorityNodes&$filter=startswith(name, 'po') or (properties/allocationState eq 'Steady' and properties/provisioningStateTransitionTime lt datetime'2017-02-02')&api-version=2024-07-01

Java

/**
 * Samples for Pool ListByBatchAccount.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolListWithFilter.json
     */
    /**
     * Sample code: ListPoolWithFilter.
     * 
     * @param manager Entry point to BatchManager.
     */
    public static void listPoolWithFilter(com.azure.resourcemanager.batch.BatchManager manager) {
        manager.pools().listByBatchAccount("default-azurebatch-japaneast", "sampleacct", 50,
            "properties/allocationState,properties/provisioningStateTransitionTime,properties/currentDedicatedNodes,properties/currentLowPriorityNodes",
            "startswith(name, 'po') or (properties/allocationState eq 'Steady' and properties/provisioningStateTransitionTime lt datetime'2017-02-02')",
            com.azure.core.util.Context.NONE);
    }
}

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

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.batch import BatchManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-batch
# USAGE
    python pool_list_with_filter.py

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


def main():
    client = BatchManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="subid",
    )

    response = client.pool.list_by_batch_account(
        resource_group_name="default-azurebatch-japaneast",
        account_name="sampleacct",
    )
    for item in response:
        print(item)


# x-ms-original-file: specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolListWithFilter.json
if __name__ == "__main__":
    main()

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

Go

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/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e79d9ef3e065f2dcb6bd1db51e29c62a99dff5cb/specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolListWithFilter.json
func ExamplePoolClient_NewListByBatchAccountPager_listPoolWithFilter() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armbatch.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPoolClient().NewListByBatchAccountPager("default-azurebatch-japaneast", "sampleacct", &armbatch.PoolClientListByBatchAccountOptions{Maxresults: nil,
		Select: to.Ptr("properties/allocationState,properties/provisioningStateTransitionTime,properties/currentDedicatedNodes,properties/currentLowPriorityNodes"),
		Filter: to.Ptr("startswith(name, 'po') or (properties/allocationState eq 'Steady' and properties/provisioningStateTransitionTime lt datetime'2017-02-02')"),
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ListPoolsResult = armbatch.ListPoolsResult{
		// 	Value: []*armbatch.Pool{
		// 		{
		// 			Name: to.Ptr("testpool"),
		// 			Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
		// 			Etag: to.Ptr("W/\"0x8D4EDFEBFADF4AB\""),
		// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool"),
		// 			Properties: &armbatch.PoolProperties{
		// 				AllocationState: to.Ptr(armbatch.AllocationStateSteady),
		// 				CurrentDedicatedNodes: to.Ptr[int32](0),
		// 				CurrentLowPriorityNodes: to.Ptr[int32](2),
		// 				ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-28T10:22:55.940Z"); return t}()),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("pooltest"),
		// 			Type: to.Ptr("Microsoft.Batch/batchAccounts/pools"),
		// 			Etag: to.Ptr("W/\"0x8D4EDFEBFADF4AB\""),
		// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/pooltest"),
		// 			Properties: &armbatch.PoolProperties{
		// 				AllocationState: to.Ptr(armbatch.AllocationStateResizing),
		// 				CurrentDedicatedNodes: to.Ptr[int32](4),
		// 				CurrentLowPriorityNodes: to.Ptr[int32](0),
		// 				ProvisioningStateTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-26T10:22:55.940Z"); return t}()),
		// 			},
		// 	}},
		// }
	}
}

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

JavaScript

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

/**
 * This sample demonstrates how to Lists all of the pools in the specified account.
 *
 * @summary Lists all of the pools in the specified account.
 * x-ms-original-file: specification/batch/resource-manager/Microsoft.Batch/stable/2024-07-01/examples/PoolListWithFilter.json
 */
async function listPoolWithFilter() {
  const subscriptionId = process.env["BATCH_SUBSCRIPTION_ID"] || "subid";
  const resourceGroupName = process.env["BATCH_RESOURCE_GROUP"] || "default-azurebatch-japaneast";
  const accountName = "sampleacct";
  const select =
    "properties/allocationState,properties/provisioningStateTransitionTime,properties/currentDedicatedNodes,properties/currentLowPriorityNodes";
  const filter =
    "startswith(name, 'po') or (properties/allocationState eq 'Steady' and properties/provisioningStateTransitionTime lt datetime'2017-02-02')";
  const options = { select, filter };
  const credential = new DefaultAzureCredential();
  const client = new BatchManagementClient(credential, subscriptionId);
  const resArray = new Array();
  for await (let item of client.poolOperations.listByBatchAccount(
    resourceGroupName,
    accountName,
    options,
  )) {
    resArray.push(item);
  }
  console.log(resArray);
}

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

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Collections.Generic;
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/stable/2024-07-01/examples/PoolListWithFilter.json
// this example is just showing the usage of "Pool_ListByBatchAccount" 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 = "subid";
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 and iterate over the result
string select = "properties/allocationState,properties/provisioningStateTransitionTime,properties/currentDedicatedNodes,properties/currentLowPriorityNodes";
string filter = "startswith(name, 'po') or (properties/allocationState eq 'Steady' and properties/provisioningStateTransitionTime lt datetime'2017-02-02')";
await foreach (BatchAccountPoolResource item in collection.GetAllAsync(select: select, filter: filter))
{
    // the variable item 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 = item.Data;
    // for demo we just print out the id
    Console.WriteLine($"Succeeded on id: {resourceData.Id}");
}

Console.WriteLine($"Succeeded");

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

Exemple de réponse

Code d’état:

200

{
  "value": [
    {
      "id": "/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/testpool",
      "name": "testpool",
      "type": "Microsoft.Batch/batchAccounts/pools",
      "etag": "W/\"0x8D4EDFEBFADF4AB\"",
      "properties": {
        "provisioningStateTransitionTime": "2017-08-28T10:22:55.9407275Z",
        "allocationState": "Steady",
        "currentDedicatedNodes": 0,
        "currentLowPriorityNodes": 2
      }
    },
    {
      "id": "/subscriptions/subid/resourceGroups/default-azurebatch-japaneast/providers/Microsoft.Batch/batchAccounts/sampleacct/pools/pooltest",
      "name": "pooltest",
      "type": "Microsoft.Batch/batchAccounts/pools",
      "etag": "W/\"0x8D4EDFEBFADF4AB\"",
      "properties": {
        "provisioningStateTransitionTime": "2017-08-26T10:22:55.9407275Z",
        "allocationState": "Resizing",
        "currentDedicatedNodes": 4,
        "currentLowPriorityNodes": 0
      }
    }
  ]
}

Définitions

Nom	Description
AllocationState	Indique si le redimensionnement du pool est en cours.
ApplicationPackageReference	Lien vers un package d’application à l’intérieur du compte batch
AutomaticOSUpgradePolicy	Paramètres de configuration utilisés pour effectuer la mise à niveau automatique du système d’exploitation.
AutoScaleRun	Résultats et erreurs d’une exécution d’une formule de mise à l’échelle automatique du pool.
AutoScaleRunError	Erreur qui s’est produite lors de la mise à l’échelle automatique d’un pool.
AutoScaleSettings	Paramètres de mise à l’échelle automatique pour le pool.
AutoUserScope	Étendue de l’utilisateur automatique
AutoUserSpecification	Spécifie les paramètres de l’utilisateur automatique qui exécute une tâche sur le service Batch.
AzureBlobFileSystemConfiguration	Informations utilisées pour se connecter à un conteneur de stockage Azure à l’aide d’Blobfuse.
AzureFileShareConfiguration	Informations utilisées pour se connecter à un partage de fichiers Azure.
BatchPoolIdentity	Identité du pool Batch, s’il est configuré. Si l’identité du pool est mise à jour pendant la mise à jour d’un pool existant, seules les nouvelles machines virtuelles créées après la réduction du pool à 0 auront les identités mises à jour
CachingType	Type de mise en cache à activer pour le disque.
CertificateReference	Référence à un certificat à installer sur des nœuds de calcul dans un pool. Cela doit exister dans le même compte que le pool.
CertificateStoreLocation	Emplacement du magasin de certificats sur le nœud de calcul dans lequel installer le certificat.
CertificateVisibility	Quels comptes d’utilisateur sur le nœud de calcul doivent avoir accès aux données privées du certificat.
CIFSMountConfiguration	Informations utilisées pour se connecter à un système de fichiers CIFS.
CloudError	Réponse d’erreur du service Batch.
CloudErrorBody	Réponse d’erreur du service Batch.
ComputeNodeDeallocationOption	Détermine ce qu’il faut faire avec un nœud et ses tâches en cours d’exécution une fois qu’elle a été sélectionnée pour la désallocation.
ComputeNodeFillType	Comment les tâches doivent être distribuées entre les nœuds de calcul.
ComputeNodeIdentityReference	Référence à une identité affectée par l’utilisateur associée au pool Batch qu’un nœud de calcul utilisera.
ContainerConfiguration	Configuration des pools avec conteneur.
ContainerHostBatchBindMountEntry	Entrée du chemin d’accès et du mode montage que vous souhaitez monter dans le conteneur de tâches.
ContainerHostDataPath	Chemins d’accès qui seront montés sur le conteneur de la tâche de conteneur.
ContainerRegistry	Registre de conteneurs privé.
ContainerType	Technologie de conteneur à utiliser.
ContainerWorkingDirectory	Indicateur permettant d’indiquer où se trouve le répertoire de travail de la tâche de conteneur. La valeur par défaut est « taskWorkingDirectory ».
DataDisk	Paramètres qui seront utilisés par les disques de données associés aux nœuds de calcul dans le pool. Lorsque vous utilisez des disques de données attachés, vous devez monter et mettre en forme les disques à partir d’une machine virtuelle pour les utiliser.
DeploymentConfiguration	Propriétés de configuration du déploiement.
DiffDiskPlacement	Spécifie le placement éphémère du disque du système d’exploitation pour toutes les machines virtuelles du pool.
DiffDiskSettings	Spécifie les paramètres de disque éphémères pour le disque du système d’exploitation utilisé par la machine virtuelle.
DiskEncryptionConfiguration	Configuration de chiffrement de disque appliquée aux nœuds de calcul du pool. La configuration du chiffrement de disque n’est pas prise en charge sur le pool Linux créé avec l’image de machine virtuelle ou l’image de la galerie de calcul Azure.
DiskEncryptionTarget	La liste des cibles de disque batch Service chiffre sur le nœud de calcul
DynamicVNetAssignmentScope	Étendue de l’attribution de réseau virtuel dynamique.
ElevationLevel	Niveau d’élévation de l’utilisateur.
EnvironmentSetting	Variable d’environnement à définir sur un processus de tâche.
FixedScaleSettings	Paramètres de mise à l’échelle fixes pour le pool.
ImageReference	Référence à une image de la Place de marché des machines virtuelles Azure ou à la ressource Image Azure d’une machine virtuelle personnalisée. Pour obtenir la liste de toutes les images Vérifiées par Azure Batch, consultez l’opération « Répertorier les références SKU de l’agent de nœud prises en charge ».
InboundEndpointProtocol	Protocole du point de terminaison.
InboundNatPool	Pool NAT entrant qui peut être utilisé pour traiter des ports spécifiques sur des nœuds de calcul dans un pool Batch en externe.
InterNodeCommunicationState	Indique si le pool autorise la communication directe entre les nœuds.
IPAddressProvisioningType	Type d’approvisionnement pour les adresses IP publiques pour le pool Batch.
LinuxUserConfiguration	Propriétés utilisées pour créer un compte d’utilisateur sur un nœud Linux.
ListPoolsResult	Valeurs retournées par l’opération Liste.
LoginMode	Mode de connexion pour l’utilisateur
ManagedDisk
MetadataItem	Paire nom-valeur associée à une ressource de service Batch.
MountConfiguration	Système de fichiers à monter sur chaque nœud.
NetworkConfiguration	Configuration réseau d’un pool.
NetworkSecurityGroupRule	Règle de groupe de sécurité réseau à appliquer à un point de terminaison entrant.
NetworkSecurityGroupRuleAccess	Action qui doit être effectuée pour une adresse IP, une plage de sous-réseaux ou une balise spécifiée.
NFSMountConfiguration	Informations utilisées pour se connecter à un système de fichiers NFS.
NodeCommunicationMode	Détermine comment un pool communique avec le service Batch.
NodePlacementConfiguration	Configuration de placement de nœud pour les pools de lots.
NodePlacementPolicyType	Stratégie de placement pour l’allocation de nœuds dans le pool.
OSDisk	Paramètres du disque du système d’exploitation de la machine virtuelle.
Pool	Contient des informations sur un pool.
PoolEndpointConfiguration	Configuration du point de terminaison d’un pool.
PoolIdentityType	Type d’identité utilisé pour le pool Batch.
PoolProvisioningState	État actuel du pool.
PublicIPAddressConfiguration	Configuration d’adresse IP publique de la configuration réseau d’un pool.
ResizeError	Erreur qui s’est produite lors du redimensionnement d’un pool.
ResizeOperationStatus	Détails sur l’opération de redimensionnement en cours ou la dernière fois terminée.
ResourceFile	Un seul fichier ou plusieurs fichiers à télécharger sur un nœud de calcul.
RollingUpgradePolicy	Paramètres de configuration utilisés lors de l’exécution d’une mise à niveau propagée.
ScaleSettings	Mettre à l’échelle les paramètres du pool
SecurityEncryptionTypes	Spécifie le EncryptionType du disque managé. Il est défini sur VMGuestStateOnly pour le chiffrement de l’objet blob VMGuestState et nonPersistedTPM pour ne pas conserver l’état du microprogramme dans l’objet blob VMGuestState. Remarque: elle peut être définie uniquement pour les machines virtuelles confidentielles et requises lors de l’utilisation de machines virtuelles confidentielles.
SecurityProfile	Spécifie les paramètres de profil de sécurité de la machine virtuelle ou du groupe de machines virtuelles identiques.
SecurityTypes	Spécifie le SecurityType de la machine virtuelle. Il doit être défini sur n’importe quelle valeur spécifiée pour activer UefiSettings.
ServiceArtifactReference	Spécifie l’ID de référence de l’artefact de service utilisé pour définir la même version d’image pour toutes les machines virtuelles du groupe identique lors de l’utilisation de la version d’image la plus récente.
StartTask	Tâche exécutée lorsqu’un nœud de calcul joint un pool dans le service Azure Batch, ou lorsque le nœud de calcul est redémarré ou réimagené.
StorageAccountType	Type de compte de stockage à utiliser pour créer des disques de données ou un disque de système d’exploitation.
TaskContainerSettings	Paramètres de conteneur d’une tâche.
TaskSchedulingPolicy	Spécifie la façon dont les tâches doivent être distribuées entre les nœuds de calcul.
UefiSettings	Spécifie les paramètres de sécurité tels que le démarrage sécurisé et vTPM utilisés lors de la création de la machine virtuelle.
UpgradeMode	Spécifie le mode d’une mise à niveau vers des machines virtuelles dans le groupe identique. Les valeurs possibles sont les suivantes : manuel : vous contrôlez l’application des mises à jour des machines virtuelles dans le groupe identique. Pour ce faire, utilisez l’action manualUpgrade. automatique : toutes les machines virtuelles du groupe identique sont automatiquement mises à jour en même temps. rolling - Le groupe identique effectue des mises à jour par lots avec une durée de pause facultative entre les deux.
UpgradePolicy	Décrit une stratégie de mise à niveau : automatique, manuelle ou propagée.
UserAccount	Propriétés utilisées pour créer un utilisateur sur un nœud Azure Batch.
UserAssignedIdentities	Liste des identités utilisateur associées.
UserIdentity	Définition de l’identité de l’utilisateur sous laquelle la tâche est exécutée.
VirtualMachineConfiguration	Configuration des nœuds de calcul dans un pool en fonction de l’infrastructure des machines virtuelles Azure.
VMDiskSecurityProfile	Spécifie les paramètres du profil de sécurité pour le disque managé. Remarque: elle ne peut être définie que pour les machines virtuelles confidentielles et est requise lors de l’utilisation de machines virtuelles confidentielles.
VMExtension	Configuration des extensions de machine virtuelle.
WindowsConfiguration	Paramètres du système d’exploitation Windows à appliquer à la machine virtuelle.
WindowsUserConfiguration	Propriétés utilisées pour créer un compte d’utilisateur sur un nœud Windows.

AllocationState

Énumération

Indique si le redimensionnement du pool est en cours.

Valeur	Description
Resizing	Le pool est redimensionnement ; autrement dit, les nœuds de calcul sont ajoutés ou supprimés du pool.
Steady	Le pool n’est pas redimensionnement. Il n’y a aucune modification du nombre de nœuds dans le pool en cours. Un pool entre dans cet état lors de sa création et lorsqu’aucune opération n’est effectuée sur le pool pour modifier le nombre de nœuds.
Stopping	Le pool a été redimensionné, mais l’utilisateur a demandé que le redimensionnement soit arrêté, mais que la demande d’arrêt n’a pas encore été terminée.

ApplicationPackageReference

Object

Lien vers un package d’application à l’intérieur du compte batch

Nom	Type	Description
id	string	ID du package d’application à installer. Cela doit se trouver dans le même compte batch que le pool. Il peut s’agir d’une référence à une version spécifique ou à la version par défaut s’il en existe une.
version	string	Version de l’application à déployer. En cas d’omission, la version par défaut est déployée. Si cela est omis et qu’aucune version par défaut n’est spécifiée pour cette application, la requête échoue avec le code d’erreur InvalidApplicationPackageReferences. Si vous appelez directement l’API REST, le code d’état HTTP est 409.

AutomaticOSUpgradePolicy

Object

Paramètres de configuration utilisés pour effectuer la mise à niveau automatique du système d’exploitation.

Nom	Type	Description
disableAutomaticRollback	boolean	Indique si la fonctionnalité de restauration d’image du système d’exploitation doit être désactivée.
enableAutomaticOSUpgrade	boolean	Indique si les mises à niveau du système d’exploitation doivent être appliquées automatiquement aux instances de groupe identique de manière propagée lorsqu’une version plus récente de l’image du système d’exploitation devient disponible. Si cette valeur est définie sur true pour les pools Windows, WindowsConfiguration.enableAutomaticUpdates ne peut pas être définie sur true.
osRollingUpgradeDeferral	boolean	Différer les mises à niveau du système d’exploitation sur les machines virtuelles si elles exécutent des tâches.
useRollingUpgradePolicy	boolean	Indique si la stratégie de mise à niveau propagée doit être utilisée pendant la mise à niveau automatique du système d’exploitation. La mise à niveau automatique du système d’exploitation revient à la stratégie par défaut si aucune stratégie n’est définie sur vmSS.

AutoScaleRun

Object

Résultats et erreurs d’une exécution d’une formule de mise à l’échelle automatique du pool.

Nom	Type	Description
error	AutoScaleRunError	Détails de l’erreur rencontrée lors de l’évaluation de la formule de mise à l’échelle automatique sur le pool, si l’évaluation a échoué.
evaluationTime	string (date-time)	Heure à laquelle la formule de mise à l’échelle automatique a été évaluée pour la dernière fois.
results	string	Valeurs finales de toutes les variables utilisées dans l’évaluation de la formule de mise à l’échelle automatique. Chaque valeur de variable est retournée sous la forme $variable=value, et les variables sont séparées par des points-virgules.

AutoScaleRunError

Object

Erreur qui s’est produite lors de la mise à l’échelle automatique d’un pool.

Nom	Type	Description
code	string	Identificateur de l’erreur. Les codes sont invariants et sont destinés à être consommés par programme.
details	AutoScaleRunError[]	Détails supplémentaires sur l’erreur.
message	string	Message décrivant l’erreur, destiné à être adapté à l’affichage dans une interface utilisateur.

AutoScaleSettings

Object

Paramètres de mise à l’échelle automatique pour le pool.

Nom	Type	Description
evaluationInterval	string (duration)	Intervalle de temps auquel ajuster automatiquement la taille du pool en fonction de la formule de mise à l’échelle automatique. Si elle est omise, la valeur par défaut est de 15 minutes (PT15M).
formula	string	Formule pour le nombre souhaité de nœuds de calcul dans le pool.

AutoUserScope

Énumération

Étendue de l’utilisateur automatique

Valeur	Description
Pool	Spécifie que la tâche s’exécute en tant que compte d’utilisateur automatique commun créé sur chaque nœud d’un pool.
Task	Spécifie que le service doit créer un utilisateur pour la tâche.

AutoUserSpecification

Object

Spécifie les paramètres de l’utilisateur automatique qui exécute une tâche sur le service Batch.

Nom	Type	Description
elevationLevel	ElevationLevel	Niveau d’élévation de l’utilisateur automatique. La valeur par défaut n’est pasAdmin.
scope	AutoUserScope	Étendue de l’utilisateur automatique La valeur par défaut est Pool. Si le pool exécute Windows, une valeur de tâche doit être spécifiée si une isolation plus stricte entre les tâches est requise. Par exemple, si la tâche mute le Registre d’une manière qui peut avoir un impact sur d’autres tâches ou si des certificats ont été spécifiés sur le pool qui ne doit pas être accessible par les tâches normales, mais qu’elles doivent être accessibles par les tâches de démarrage.

AzureBlobFileSystemConfiguration

Object

Informations utilisées pour se connecter à un conteneur de stockage Azure à l’aide d’Blobfuse.

Nom	Type	Description
accountKey	string	Clé de compte de stockage Azure. Cette propriété s’exclue mutuellement avec sasKey et l’identité ; exactement un doit être spécifié.
accountName	string	Nom du compte de stockage Azure.
blobfuseOptions	string	Options de ligne de commande supplémentaires à passer à la commande de montage. Il s’agit des options « net use » dans les options Windows et « mount » dans Linux.
containerName	string	Nom du conteneur stockage Blob Azure.
identityReference	ComputeNodeIdentityReference	Référence à l’identité affectée par l’utilisateur à utiliser pour accéder à containerName Cette propriété s’exclue mutuellement avec accountKey et sasKey ; exactement un doit être spécifié.
relativeMountPath	string	Chemin d’accès relatif sur le nœud de calcul où le système de fichiers sera monté Tous les systèmes de fichiers sont montés par rapport au répertoire de montage Batch, accessible via la variable d’environnement AZ_BATCH_NODE_MOUNTS_DIR.
sasKey	string	Jeton SAP stockage Azure. Cette propriété s’exclue mutuellement avec accountKey et l’identité ; exactement un doit être spécifié.

AzureFileShareConfiguration

Object

Informations utilisées pour se connecter à un partage de fichiers Azure.

Nom	Type	Description
accountKey	string	Clé du compte stockage Azure.
accountName	string	Nom du compte stockage Azure.
azureFileUrl	string	URL Azure Files. Il s’agit de la forme « https://{account}.file.core.windows.net/ ».
mountOptions	string	Options de ligne de commande supplémentaires à passer à la commande de montage. Il s’agit des options « net use » dans les options Windows et « mount » dans Linux.
relativeMountPath	string	Chemin d’accès relatif sur le nœud de calcul où le système de fichiers sera monté Tous les systèmes de fichiers sont montés par rapport au répertoire de montage Batch, accessible via la variable d’environnement AZ_BATCH_NODE_MOUNTS_DIR.

BatchPoolIdentity

Object

Identité du pool Batch, s’il est configuré. Si l’identité du pool est mise à jour pendant la mise à jour d’un pool existant, seules les nouvelles machines virtuelles créées après la réduction du pool à 0 auront les identités mises à jour

Nom	Type	Description
type	PoolIdentityType	Type d’identité utilisé pour le pool Batch.
userAssignedIdentities	<string,  UserAssignedIdentities>	Liste des identités utilisateur associées au pool Batch.

CachingType

Énumération

Type de mise en cache à activer pour le disque.

Valeur	Description
None	Le mode de mise en cache du disque n’est pas activé.
ReadOnly	Le mode de mise en cache du disque est en lecture seule.
ReadWrite	Le mode de mise en cache du disque est en lecture et en écriture.

CertificateReference

Object

Référence à un certificat à installer sur des nœuds de calcul dans un pool. Cela doit exister dans le même compte que le pool.

Nom	Type	Description
id	string	ID complet du certificat à installer sur le pool. Cela doit se trouver dans le même compte batch que le pool.
storeLocation	CertificateStoreLocation	Emplacement du magasin de certificats sur le nœud de calcul dans lequel installer le certificat. La valeur par défaut est currentUser. Cette propriété s’applique uniquement aux pools configurés avec des nœuds de calcul Windows. Pour les nœuds de calcul Linux, les certificats sont stockés dans un répertoire à l’intérieur du répertoire de travail de la tâche et une variable d’environnement AZ_BATCH_CERTIFICATES_DIR est fournie à la tâche pour interroger cet emplacement. Pour les certificats avec visibilité de « remoteUser », un répertoire « certificats » est créé dans le répertoire de base de l’utilisateur (par exemple, /home/{user-name}/certs) et les certificats sont placés dans ce répertoire.
storeName	string	Nom du magasin de certificats sur le nœud de calcul dans lequel installer le certificat. Cette propriété s’applique uniquement aux pools configurés avec des nœuds de calcul Windows. Les noms de magasin courants sont : My, Root, CA, Trust, Disallowed, TrustedPeople, TrustedPublisher, AuthRoot, AddressBook, mais tout nom de magasin personnalisé peut également être utilisé. La valeur par défaut est My.
visibility	CertificateVisibility[]	Quels comptes d’utilisateur sur le nœud de calcul doivent avoir accès aux données privées du certificat.

CertificateStoreLocation

Énumération

Emplacement du magasin de certificats sur le nœud de calcul dans lequel installer le certificat.

Valeur	Description
CurrentUser	Les certificats doivent être installés dans le magasin de certificats CurrentUser.
LocalMachine	Les certificats doivent être installés dans le magasin de certificats LocalMachine.

CertificateVisibility

Énumération

Quels comptes d’utilisateur sur le nœud de calcul doivent avoir accès aux données privées du certificat.

Valeur	Description
RemoteUser	Le certificat doit être visible pour les comptes d’utilisateur sous lesquels les utilisateurs accèdent à distance au nœud.
StartTask	Le certificat doit être visible pour le compte d’utilisateur sous lequel la tâche de démarrage est exécutée. Notez que si l’étendue de l’utilisateur automatique est pool pour startTask et une tâche, ce certificat sera également visible pour la tâche.
Task	Le certificat doit être visible pour les comptes d’utilisateur sous lesquels les tâches de travail sont exécutées.

CIFSMountConfiguration

Object

Informations utilisées pour se connecter à un système de fichiers CIFS.

Nom	Type	Description
mountOptions	string	Options de ligne de commande supplémentaires à passer à la commande de montage. Il s’agit des options « net use » dans les options Windows et « mount » dans Linux.
password	string	Mot de passe à utiliser pour l’authentification auprès du système de fichiers CIFS.
relativeMountPath	string	Chemin d’accès relatif sur le nœud de calcul où le système de fichiers sera monté Tous les systèmes de fichiers sont montés par rapport au répertoire de montage Batch, accessible via la variable d’environnement AZ_BATCH_NODE_MOUNTS_DIR.
source	string	URI du système de fichiers à monter.
userName	string	Utilisateur à utiliser pour l’authentification auprès du système de fichiers CIFS.

CloudError

Object

Réponse d’erreur du service Batch.

Nom	Type	Description
error	CloudErrorBody	Corps de la réponse d’erreur.

CloudErrorBody

Object

Réponse d’erreur du service Batch.

Nom	Type	Description
code	string	Identificateur de l’erreur. Les codes sont invariants et sont destinés à être consommés par programme.
details	CloudErrorBody[]	Liste des détails supplémentaires sur l’erreur.
message	string	Message décrivant l’erreur, destiné à être adapté à l’affichage dans une interface utilisateur.
target	string	Cible de l’erreur particulière. Par exemple, le nom de la propriété en erreur.

ComputeNodeDeallocationOption

Énumération

Détermine ce qu’il faut faire avec un nœud et ses tâches en cours d’exécution une fois qu’elle a été sélectionnée pour la désallocation.

Valeur	Description
Requeue	Arrêtez l’exécution des processus de tâche et requeuez les tâches. Les tâches s’exécutent à nouveau lorsqu’un nœud est disponible. Supprimez les nœuds dès que les tâches ont été arrêtées.
RetainedData	Autorisez la fin des tâches en cours d’exécution, puis attendez que toutes les périodes de rétention des données des tâches expirent. Planifiez aucune nouvelle tâche en attendant. Supprimez les nœuds lorsque toutes les périodes de rétention des tâches ont expiré.
TaskCompletion	Autoriser l’exécution des tâches en cours d’exécution. Planifiez aucune nouvelle tâche en attendant. Supprimez les nœuds lorsque toutes les tâches sont terminées.
Terminate	Arrêtez les tâches en cours d’exécution. Les tâches sont terminées avec failureInfo indiquant qu’elles ont été arrêtées et ne sont pas réexécuter. Supprimez les nœuds dès que les tâches ont été arrêtées.

ComputeNodeFillType

Énumération

Comment les tâches doivent être distribuées entre les nœuds de calcul.

Valeur	Description
Pack	Autant de tâches que possible (taskSlotsPerNode) doivent être affectées à chaque nœud du pool avant que toutes les tâches ne soient affectées au nœud suivant dans le pool.
Spread	Les tâches doivent être affectées uniformément sur tous les nœuds du pool.

ComputeNodeIdentityReference

Object

Référence à une identité affectée par l’utilisateur associée au pool Batch qu’un nœud de calcul utilisera.

Nom	Type	Description
resourceId	string	ID de ressource ARM de l’identité affectée par l’utilisateur.

ContainerConfiguration

Object

Configuration des pools avec conteneur.

Nom	Type	Description
containerImageNames	string[]	Collection de noms d’images conteneur. Il s’agit de la référence d’image complète, comme indiqué dans « docker pull ». Une image est source du registre Docker par défaut, sauf si l’image est entièrement qualifiée avec un autre registre.
containerRegistries	ContainerRegistry[]	Registres privés supplémentaires à partir desquels les conteneurs peuvent être extraits. Si des images doivent être téléchargées à partir d’un registre privé qui nécessite des informations d’identification, ces informations d’identification doivent être fournies ici.
type	ContainerType	Technologie de conteneur à utiliser.

ContainerHostBatchBindMountEntry

Object

Entrée du chemin d’accès et du mode montage que vous souhaitez monter dans le conteneur de tâches.

Nom	Type	Description
isReadOnly	boolean	Montez ce chemin source en mode lecture seule ou non. La valeur par défaut est false (mode lecture/écriture). Pour Linux, si vous montez ce chemin en mode lecture/écriture, cela ne signifie pas que tous les utilisateurs du conteneur disposent de l’accès en lecture/écriture pour le chemin d’accès, cela dépend de l’accès dans la machine virtuelle hôte. Si ce chemin d’accès est monté en lecture seule, tous les utilisateurs du conteneur ne pourront pas modifier le chemin d’accès.
source	ContainerHostDataPath	Le chemin d’accès à monter sur le client conteneur peut être sélectionné.

ContainerHostDataPath

Énumération

Chemins d’accès qui seront montés sur le conteneur de la tâche de conteneur.

Valeur	Description
Applications	Chemin d’accès des applications.
JobPrep	Chemin de la tâche de préparation du travail.
Shared	Chemin d’accès de la tâche multi-instances pour partager leurs fichiers.
Startup	Chemin d’accès de la tâche de démarrage.
Task	Chemin d’accès de la tâche.
VfsMounts	Le chemin d’accès contient tous les systèmes de fichiers virtuels sont montés sur ce nœud.

ContainerRegistry

Object

Registre de conteneurs privé.

Nom	Type	Description
identityReference	ComputeNodeIdentityReference	Référence à l’identité affectée par l’utilisateur à utiliser pour accéder à azure Container Registry au lieu du nom d’utilisateur et du mot de passe. Référence à une identité affectée par l’utilisateur associée au pool Batch qu’un nœud de calcul utilisera.
password	string	Mot de passe pour vous connecter au serveur de Registre.
registryServer	string	URL du Registre. S’il est omis, la valeur par défaut est « docker.io ».
username	string	Nom d’utilisateur à connecter au serveur de Registre.

ContainerType

Énumération

Technologie de conteneur à utiliser.

Valeur	Description
CriCompatible	Une technologie basée sur CRI sera utilisée pour lancer les conteneurs.
DockerCompatible	Une technologie de conteneur compatible Docker sera utilisée pour lancer les conteneurs.

ContainerWorkingDirectory

Énumération

Indicateur permettant d’indiquer où se trouve le répertoire de travail de la tâche de conteneur. La valeur par défaut est « taskWorkingDirectory ».

Valeur	Description
ContainerImageDefault	Utilisation du répertoire de travail défini par l’image conteneur. Veillez à ce que ce répertoire ne contienne pas les fichiers de ressources téléchargés par Batch.
TaskWorkingDirectory	Utilisez le répertoire de travail de tâche de service Batch standard, qui contiendra les fichiers de ressources de tâche renseignés par Batch.

DataDisk

Object

Paramètres qui seront utilisés par les disques de données associés aux nœuds de calcul dans le pool. Lorsque vous utilisez des disques de données attachés, vous devez monter et mettre en forme les disques à partir d’une machine virtuelle pour les utiliser.

Nom	Type	Description
caching	CachingType	Type de mise en cache à activer pour les disques de données. Les valeurs sont les suivantes : none : le mode de mise en cache du disque n’est pas activé. readOnly : le mode de mise en cache du disque est en lecture seule. readWrite : le mode de mise en cache du disque est en lecture et en écriture. La valeur par défaut de la mise en cache n’est pas. Pour plus d’informations sur les options de mise en cache, consultez : https://blogs.msdn.microsoft.com/windowsazurestorage/2012/06/27/exploring-windows-azure-drives-disks-and-images/.
diskSizeGB	integer (int32)	Taille initiale du disque en Go lors de la création d’un disque de données.
lun	integer (int32)	Numéro d’unité logique. Le lun est utilisé pour identifier de manière unique chaque disque de données. Si vous attachez plusieurs disques, chacun doit avoir un lun distinct. La valeur doit être comprise entre 0 et 63, inclus.
storageAccountType	StorageAccountType	Type de compte de stockage à utiliser pour le disque de données. S’il est omis, la valeur par défaut est « Standard_LRS ». Les valeurs sont les suivantes : Standard_LRS : le disque de données doit utiliser un stockage standard localement redondant. Premium_LRS : le disque de données doit utiliser un stockage premium localement redondant.

DeploymentConfiguration

Object

Propriétés de configuration du déploiement.

Nom	Type	Description
virtualMachineConfiguration	VirtualMachineConfiguration	Configuration de la machine virtuelle pour le pool.

DiffDiskPlacement

Énumération

Spécifie le placement éphémère du disque du système d’exploitation pour toutes les machines virtuelles du pool.

Valeur	Description
CacheDisk	Le disque de système d’exploitation éphémère est stocké sur le cache de la machine virtuelle.

DiffDiskSettings

Object

Spécifie les paramètres de disque éphémères pour le disque du système d’exploitation utilisé par la machine virtuelle.

Nom	Type	Description
placement	DiffDiskPlacement	Spécifie le placement éphémère du disque du système d’exploitation pour toutes les machines virtuelles du pool. Cette propriété peut être utilisée par l’utilisateur dans la demande pour choisir l’emplacement dans lequel le système d’exploitation doit se trouver. Par exemple, cachez l’espace disque pour l’approvisionnement de disque de système d’exploitation éphémère. Pour plus d’informations sur les exigences de taille de disque de système d’exploitation éphémère, reportez-vous à la configuration requise pour la taille de disque du système d’exploitation éphémère pour les machines virtuelles Windows à https://learn.microsoft.com/azure/virtual-machines/windows/ephemeral-os-disks#size-requirements et les machines virtuelles Linux à https://learn.microsoft.com/azure/virtual-machines/linux/ephemeral-os-disks#size-requirements.

DiskEncryptionConfiguration

Object

Configuration de chiffrement de disque appliquée aux nœuds de calcul du pool. La configuration du chiffrement de disque n’est pas prise en charge sur le pool Linux créé avec l’image de machine virtuelle ou l’image de la galerie de calcul Azure.

Nom	Type	Description
targets	DiskEncryptionTarget[]	La liste des cibles de disque batch Service chiffre sur le nœud de calcul Sur le pool Linux, seul « TemporaryDisk » est pris en charge ; sur le pool Windows, « OsDisk » et « TemporaryDisk » doivent être spécifiés.

DiskEncryptionTarget

Énumération

La liste des cibles de disque batch Service chiffre sur le nœud de calcul

Valeur	Description
OsDisk	Le disque du système d’exploitation sur le nœud de calcul est chiffré.
TemporaryDisk	Le disque temporaire sur le nœud de calcul est chiffré. Sur Linux, ce chiffrement s’applique à d’autres partitions (telles que celles sur des disques de données montés) lorsque le chiffrement se produit au moment du démarrage.

DynamicVNetAssignmentScope

Énumération

Étendue de l’attribution de réseau virtuel dynamique.

Valeur	Description
job	L’attribution de réseau virtuel dynamique est effectuée par travail. Si cette valeur est définie, l’ID de sous-réseau de configuration réseau doit également être défini. Cette fonctionnalité nécessite une approbation avant l’utilisation, contactez le support technique
none	Aucune attribution de réseau virtuel dynamique n’est activée.

ElevationLevel

Énumération

Niveau d’élévation de l’utilisateur.

Valeur	Description
Admin	L’utilisateur est un utilisateur disposant d’un accès élevé et fonctionne avec des autorisations d’administrateur complètes.
NonAdmin	L’utilisateur est un utilisateur standard sans accès élevé.

EnvironmentSetting

Object

Variable d’environnement à définir sur un processus de tâche.

Nom	Type	Description
name	string	Nom de la variable d’environnement.
value	string	Valeur de la variable d’environnement.

FixedScaleSettings

Object

Paramètres de mise à l’échelle fixes pour le pool.

Nom	Type	Valeur par défaut	Description
nodeDeallocationOption	ComputeNodeDeallocationOption		Détermine ce qu’il faut faire avec un nœud et ses tâches en cours d’exécution si la taille du pool diminue. Si elle est omise, la valeur par défaut est Requeue.
resizeTimeout	string (duration)	PT15M	Délai d’expiration pour l’allocation de nœuds de calcul au pool. La valeur par défaut est de 15 minutes. Les valeurs de délai d’expiration utilisent le format ISO 8601. Par exemple, utilisez PT10M pendant 10 minutes. La valeur minimale est de 5 minutes. Si vous spécifiez une valeur inférieure à 5 minutes, le service Batch rejette la demande avec une erreur ; si vous appelez directement l’API REST, le code d’état HTTP est 400 (requête incorrecte).
targetDedicatedNodes	integer (int32)		Nombre souhaité de nœuds de calcul dédiés dans le pool. Au moins un des targetDedicatedNodes, targetLowPriorityNodes doit être défini.
targetLowPriorityNodes	integer (int32)		Nombre souhaité de nœuds de calcul Spot/basse priorité dans le pool. Au moins un des targetDedicatedNodes, targetLowPriorityNodes doit être défini.

ImageReference

Object

Référence à une image de la Place de marché des machines virtuelles Azure ou à la ressource Image Azure d’une machine virtuelle personnalisée. Pour obtenir la liste de toutes les images Vérifiées par Azure Batch, consultez l’opération « Répertorier les références SKU de l’agent de nœud prises en charge ».

Nom	Type	Description
communityGalleryImageId	string	Identificateur unique de l’image de la galerie de communautés Cette propriété s’exclue mutuellement avec d’autres propriétés et peut être extraite de l’appel GET de la galerie de la galerie de communautés.
id	string	Identificateur de ressource ARM de l’image de la galerie de calcul Azure. Les nœuds de calcul du pool sont créés à l’aide de cet ID d’image. Il s’agit de la forme /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageDefinitionName}/versions/{versionId}. Cette propriété s’exclue mutuellement avec d’autres propriétés. L’image de la galerie de calcul Azure doit avoir des réplicas dans la même région que le compte Azure Batch. Pour plus d’informations sur les paramètres de pare-feu de l’agent de nœud Batch pour communiquer avec le service Batch, consultez https://learn.microsoft.com/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration.
offer	string	Type d’offre de l’image place de marché des machines virtuelles Azure. Par exemple, UbuntuServer ou WindowsServer.
publisher	string	Éditeur de l’image place de marché des machines virtuelles Azure. Par exemple, Canonical ou MicrosoftWindowsServer.
sharedGalleryImageId	string	Identificateur unique de l’image de la galerie partagée Cette propriété s’exclue mutuellement avec d’autres propriétés et peut être extraite de l’appel GET de l’image de galerie partagée.
sku	string	Référence SKU de l’image place de marché des machines virtuelles Azure. Par exemple, 18.04-LTS ou 2022-datacenter.
version	string	Version de l’image place de marché des machines virtuelles Azure. Vous pouvez spécifier la valeur « latest » pour sélectionner la dernière version d’une image. S’il est omis, la valeur par défaut est « latest ».

InboundEndpointProtocol

Énumération

Protocole du point de terminaison.

Valeur	Description
TCP	Utilisez TCP pour le point de terminaison.
UDP	Utilisez UDP pour le point de terminaison.

InboundNatPool

Object

Pool NAT entrant qui peut être utilisé pour traiter des ports spécifiques sur des nœuds de calcul dans un pool Batch en externe.

Nom	Type	Description
backendPort	integer (int32)	Numéro de port sur le nœud de calcul. Cela doit être unique dans un pool Batch. Les valeurs acceptables sont comprises entre 1 et 65535, sauf pour 29876 et 29877, car elles sont réservées. Si des valeurs réservées sont fournies, la requête échoue avec le code d’état HTTP 400.
frontendPortRangeEnd	integer (int32)	Dernier numéro de port dans la plage de ports externes qui seront utilisés pour fournir un accès entrant au backendPort sur des nœuds de calcul individuels. Les valeurs acceptables sont comprises entre 1 et 65534, à l’exception des ports compris entre 5 000 et 55 000, qui sont réservés par le service Batch. Toutes les plages d’un pool doivent être distinctes et ne peuvent pas se chevaucher. Si des valeurs réservées ou superposées sont fournies, la requête échoue avec le code d’état HTTP 400.
frontendPortRangeStart	integer (int32)	Premier numéro de port dans la plage de ports externes qui seront utilisés pour fournir un accès entrant au backendPort sur des nœuds de calcul individuels. Les valeurs acceptables sont comprises entre 1 et 65534, à l’exception des ports compris entre 50000 et 55000, qui sont réservés. Toutes les plages d’un pool doivent être distinctes et ne peuvent pas se chevaucher. Si des valeurs réservées ou superposées sont fournies, la requête échoue avec le code d’état HTTP 400.
name	string	Nom du point de terminaison. Le nom doit être unique dans un pool Batch, peut contenir des lettres, des chiffres, des traits de soulignement, des points et des traits d’union. Les noms doivent commencer par une lettre ou un nombre, doivent se terminer par une lettre, un nombre ou un trait de soulignement, et ne peuvent pas dépasser 77 caractères. Si des valeurs non valides sont fournies, la requête échoue avec le code d’état HTTP 400.
networkSecurityGroupRules	NetworkSecurityGroupRule[]	Liste des règles de groupe de sécurité réseau qui seront appliquées au point de terminaison. Le nombre maximal de règles qui peuvent être spécifiées sur tous les points de terminaison d’un pool Batch est de 25. Si aucune règle de groupe de sécurité réseau n’est spécifiée, une règle par défaut est créée pour autoriser l’accès entrant au backendPort spécifié. Si le nombre maximal de règles de groupe de sécurité réseau est dépassé, la requête échoue avec le code d’état HTTP 400.
protocol	InboundEndpointProtocol	Protocole du point de terminaison.

InterNodeCommunicationState

Énumération

Indique si le pool autorise la communication directe entre les nœuds.

Valeur	Description
Disabled	Désactivez la communication réseau entre les machines virtuelles.
Enabled	Activez la communication réseau entre les machines virtuelles.

IPAddressProvisioningType

Énumération

Type d’approvisionnement pour les adresses IP publiques pour le pool Batch.

Valeur	Description
BatchManaged	Une adresse IP publique sera créée et gérée par Batch. Il peut y avoir plusieurs adresses IP publiques en fonction de la taille du pool.
NoPublicIPAddresses	Aucune adresse IP publique n’est créée pour les nœuds de calcul dans le pool.
UserManaged	Les adresses IP publiques sont fournies par l’utilisateur et seront utilisées pour approvisionner les nœuds de calcul.

LinuxUserConfiguration

Object

Propriétés utilisées pour créer un compte d’utilisateur sur un nœud Linux.

Nom	Type	Description
gid	integer (int32)	ID de groupe du compte d’utilisateur. Les propriétés uid et gid doivent être spécifiées ensemble ou pas du tout. Si le système d’exploitation sous-jacent n’est pas spécifié, le gid est sélectionné.
sshPrivateKey	string	Clé privée SSH pour le compte d’utilisateur. La clé privée ne doit pas être protégée par mot de passe. La clé privée est utilisée pour configurer automatiquement l’authentification basée sur une clé asymétrique pour SSH entre les nœuds d’un pool Linux lorsque la propriété enableInterNodeCommunication du pool est true (elle est ignorée si enableInterNodeCommunication est false). Pour ce faire, placez la paire de clés dans le répertoire .ssh de l’utilisateur. S’il n’est pas spécifié, ssh sans mot de passe n’est pas configuré entre les nœuds (aucune modification du répertoire .ssh de l’utilisateur est effectuée).
uid	integer (int32)	ID d’utilisateur du compte d’utilisateur. Les propriétés uid et gid doivent être spécifiées ensemble ou pas du tout. S’il n’est pas spécifié, le système d’exploitation sous-jacent sélectionne l’interface utilisateur.

ListPoolsResult

Object

Valeurs retournées par l’opération Liste.

Nom	Type	Description
nextLink	string	Jeton de continuation.
value	Pool[]	Collection de pools retournés.

LoginMode

Énumération

Mode de connexion pour l’utilisateur

Valeur	Description
Batch	Mode de connexion Win32 LOGON32_LOGON_BATCH. Le mode de connexion par lots est recommandé pour les processus parallèles longs.
Interactive	Mode de connexion Win32 LOGON32_LOGON_INTERACTIVE. Certaines applications nécessitent des autorisations associées au mode de connexion interactif. Si c’est le cas pour une application utilisée dans votre tâche, cette option est recommandée.

ManagedDisk

Object

Nom	Type	Description
securityProfile	VMDiskSecurityProfile	Spécifie le profil de sécurité du disque managé. Spécifie les paramètres du profil de sécurité pour le disque managé. Remarque: elle ne peut être définie que pour les machines virtuelles confidentielles et est requise lors de l’utilisation de machines virtuelles confidentielles.
storageAccountType	StorageAccountType	Type de compte de stockage pour disque managé.

MetadataItem

Object

Paire nom-valeur associée à une ressource de service Batch.

Nom	Type	Description
name	string	Nom de l’élément de métadonnées.
value	string	Valeur de l’élément de métadonnées.

MountConfiguration

Object

Système de fichiers à monter sur chaque nœud.

Nom	Type	Description
azureBlobFileSystemConfiguration	AzureBlobFileSystemConfiguration	Conteneur de stockage Azure à monter à l’aide de FUSE d’objet blob sur chaque nœud. Cette propriété s’exclue mutuellement avec toutes les autres propriétés.
azureFileShareConfiguration	AzureFileShareConfiguration	Partage de fichiers Azure à monter sur chaque nœud. Cette propriété s’exclue mutuellement avec toutes les autres propriétés.
cifsMountConfiguration	CIFSMountConfiguration	Système de fichiers CIFS/SMB à monter sur chaque nœud. Cette propriété s’exclue mutuellement avec toutes les autres propriétés.
nfsMountConfiguration	NFSMountConfiguration	Système de fichiers NFS à monter sur chaque nœud. Cette propriété s’exclue mutuellement avec toutes les autres propriétés.

NetworkConfiguration

Object

Configuration réseau d’un pool.

Nom	Type	Valeur par défaut	Description
dynamicVnetAssignmentScope	DynamicVNetAssignmentScope	none	Étendue de l’attribution de réseau virtuel dynamique.
enableAcceleratedNetworking	boolean		Indique si ce pool doit activer la mise en réseau accélérée. La mise en réseau accélérée permet une virtualisation d’E/S racine unique (SR-IOV) vers une machine virtuelle, ce qui peut entraîner une amélioration des performances réseau. Pour plus d’informations, consultez : https://learn.microsoft.com/azure/virtual-network/accelerated-networking-overview.
endpointConfiguration	PoolEndpointConfiguration		Configuration des points de terminaison sur les nœuds de calcul dans le pool Batch.
publicIPAddressConfiguration	PublicIPAddressConfiguration		Configuration IPAddress publique pour les nœuds de calcul dans le pool Batch. Configuration d’adresse IP publique de la configuration réseau d’un pool.
subnetId	string		Identificateur de ressource ARM du sous-réseau de réseau virtuel auquel les nœuds de calcul du pool seront joints. Il s’agit de la forme /subscriptions/{subscription}/resourceGroups/{group}/providers/{provider}/virtualNetworks/{network}/subnets/{subnet}. Le réseau virtuel doit se trouver dans la même région et dans le même abonnement que le compte Azure Batch. Le sous-réseau spécifié doit avoir suffisamment d’adresses IP libres pour prendre en charge le nombre de nœuds dans le pool. Si le sous-réseau n’a pas suffisamment d’adresses IP gratuites, le pool alloue partiellement des nœuds de calcul et une erreur de redimensionnement se produit. Le principal de service « MicrosoftAzureBatch » doit avoir le rôle « Contributeur de machine virtuelle classique » Role-Based Contrôle d’accès (RBAC) pour le réseau virtuel spécifié. Le sous-réseau spécifié doit autoriser la communication du service Azure Batch à planifier des tâches sur les nœuds de calcul. Cela peut être vérifié en vérifiant si le réseau virtuel spécifié a des groupes de sécurité réseau (NSG) associés. Si la communication aux nœuds de calcul dans le sous-réseau spécifié est refusée par un groupe de sécurité réseau, le service Batch définit l’état des nœuds de calcul sur inutilisable. Si le réseau virtuel spécifié a des groupes de sécurité réseau (NSG) associés, quelques ports système réservés doivent être activés pour la communication entrante, y compris les ports 29876 et 29877. Activez également les connexions sortantes au stockage Azure sur le port 443. Pour plus d’informations, consultez : https://learn.microsoft.com/azure/batch/batch-api-basics#virtual-network-vnet-and-firewall-configuration

NetworkSecurityGroupRule

Object

Règle de groupe de sécurité réseau à appliquer à un point de terminaison entrant.

Nom	Type	Description
access	NetworkSecurityGroupRuleAccess	Action qui doit être effectuée pour une adresse IP, une plage de sous-réseaux ou une balise spécifiée.
priority	integer (int32)	Priorité de cette règle. Les priorités au sein d’un pool doivent être uniques et sont évaluées par ordre de priorité. Plus le nombre est faible, plus la priorité est élevée. Par exemple, les règles peuvent être spécifiées avec des numéros de commande de 150, 250 et 350. La règle avec le numéro d’ordre de 150 est prioritaire sur la règle dont l’ordre est de 250. Les priorités autorisées sont de 150 à 4096. Si des valeurs réservées ou dupliquées sont fournies, la requête échoue avec le code d’état HTTP 400.
sourceAddressPrefix	string	Préfixe ou balise d’adresse source à mettre en correspondance pour la règle. Les valeurs valides sont une seule adresse IP (c’est-à-dire 10.10.10.10), un sous-réseau IP (par exemple, 192.168.1.0/24), une balise par défaut ou * (pour toutes les adresses). Si d’autres valeurs sont fournies, la requête échoue avec le code d’état HTTP 400.
sourcePortRanges	string[]	Plages de ports sources à mettre en correspondance pour la règle. Les valeurs valides sont « * » (pour tous les ports 0 - 65535) ou des tableaux de ports ou plages de ports (c’est-à-dire 100-200). Les ports doivent se trouver dans la plage de 0 à 65535 et les plages de ports ou ports ne peuvent pas se chevaucher. Si d’autres valeurs sont fournies, la requête échoue avec le code d’état HTTP 400. La valeur par défaut est *.

NetworkSecurityGroupRuleAccess

Énumération

Action qui doit être effectuée pour une adresse IP, une plage de sous-réseaux ou une balise spécifiée.

Valeur	Description
Allow	Autoriser l’accès.
Deny	Refuser l’accès.

NFSMountConfiguration

Object

Informations utilisées pour se connecter à un système de fichiers NFS.

Nom	Type	Description
mountOptions	string	Options de ligne de commande supplémentaires à passer à la commande de montage. Il s’agit des options « net use » dans les options Windows et « mount » dans Linux.
relativeMountPath	string	Chemin d’accès relatif sur le nœud de calcul où le système de fichiers sera monté Tous les systèmes de fichiers sont montés par rapport au répertoire de montage Batch, accessible via la variable d’environnement AZ_BATCH_NODE_MOUNTS_DIR.
source	string	URI du système de fichiers à monter.

NodeCommunicationMode

Énumération

Détermine comment un pool communique avec le service Batch.

Valeur	Description
Classic	Les nœuds utilisant le mode de communication Classique nécessitent une communication TCP entrante sur les ports 29876 et 29877 à partir du « BatchNodeManagement ». Balise de service {region} » et communication TCP sortante sur le port 443 vers « Storage.region » et « BatchNodeManagement ». Balises de service {region}".
Default	Le mode de communication de nœud est automatiquement défini par le service Batch.
Simplified	Les nœuds utilisant le mode de communication simplifié nécessitent une communication TCP sortante sur le port 443 vers le « BatchNodeManagement ». Balise de service {region}". Aucun port entrant ouvert n’est requis.

NodePlacementConfiguration

Object

Configuration de placement de nœud pour les pools de lots.

Nom	Type	Description
policy	NodePlacementPolicyType	Type de stratégie de placement de nœud sur les pools Batch. Stratégie d’allocation utilisée par le service Batch pour approvisionner les nœuds. S’il n’est pas spécifié, Batch utilise la stratégie régionale.

NodePlacementPolicyType

Énumération

Stratégie de placement pour l’allocation de nœuds dans le pool.

Valeur	Description
Regional	Tous les nœuds du pool seront alloués dans la même région.
Zonal	Les nœuds du pool sont répartis entre différentes zones avec un équilibrage de l’effort optimal.

OSDisk

Object

Paramètres du disque du système d’exploitation de la machine virtuelle.

Nom	Type	Description
caching	CachingType	Spécifie les exigences de mise en cache. Les valeurs possibles sont : None, ReadOnly, ReadWrite. Les valeurs par défaut sont : Aucune pour le stockage Standard. ReadOnly pour le stockage Premium.
diskSizeGB	integer (int32)	Taille initiale du disque en Go lors de la création d’un disque de système d’exploitation.
ephemeralOSDiskSettings	DiffDiskSettings	Spécifie les paramètres de disque éphémères pour le disque du système d’exploitation utilisé par la machine virtuelle.
managedDisk	ManagedDisk	Paramètres de disque managé.
writeAcceleratorEnabled	boolean	Spécifie si writeAccelerator doit être activé ou désactivé sur le disque.

Pool

Object

Contient des informations sur un pool.

Nom	Type	Valeur par défaut	Description
etag	string		ETag de la ressource, utilisée pour les instructions d’accès concurrentiel.
id	string		ID de la ressource.
identity	BatchPoolIdentity		Type d’identité utilisé pour le pool Batch. Type d’identité utilisé pour le pool Batch.
name	string		Nom de la ressource.
properties.allocationState	AllocationState		Indique si le redimensionnement du pool est en cours.
properties.allocationStateTransitionTime	string (date-time)		Heure à laquelle le pool a entré son état d’allocation actuel.
properties.applicationLicenses	string[]		La liste des licences d’application que le service Batch mettra à disposition sur chaque nœud de calcul du pool. La liste des licences d’application doit être un sous-ensemble de licences d’application de service Batch disponibles. Si une licence n’est pas prise en charge, la création du pool échoue.
properties.applicationPackages	ApplicationPackageReference[]		Liste des packages d’application à installer sur chaque nœud de calcul du pool. Les modifications apportées aux références de package d’application affectent tous les nouveaux nœuds de calcul qui rejoignent le pool, mais n’affectent pas les nœuds de calcul qui se trouvent déjà dans le pool tant qu’ils ne sont pas redémarrés ou réimages. Il existe au maximum 10 références de package d’application sur un pool donné.
properties.autoScaleRun	AutoScaleRun		Résultats et erreurs de la dernière exécution de la formule de mise à l’échelle automatique. Cette propriété est définie uniquement si le pool est automatiquement mis à l’échelle, c’est-à-dire que les autoScaleSettings sont utilisés.
properties.certificates	CertificateReference[]		Liste des certificats à installer sur chaque nœud de calcul du pool. Pour les nœuds de calcul Windows, le service Batch installe les certificats dans le magasin de certificats et l’emplacement spécifiés. Pour les nœuds de calcul Linux, les certificats sont stockés dans un répertoire à l’intérieur du répertoire de travail de la tâche et une variable d’environnement AZ_BATCH_CERTIFICATES_DIR est fournie à la tâche pour interroger cet emplacement. Pour les certificats avec visibilité de « remoteUser », un répertoire « certificats » est créé dans le répertoire de base de l’utilisateur (par exemple, /home/{user-name}/certs) et les certificats sont placés dans ce répertoire. Avertissement : cette propriété est déconseillée et sera supprimée après février 2024. Utilisez plutôt l''extension Azure KeyVault.
properties.creationTime	string (date-time)		Heure de création du pool.
properties.currentDedicatedNodes	integer (int32)		Nombre de nœuds de calcul dédiés actuellement dans le pool.
properties.currentLowPriorityNodes	integer (int32)		Nombre de nœuds de calcul Spot/basse priorité actuellement dans le pool.
properties.currentNodeCommunicationMode	NodeCommunicationMode		État actuel du mode de communication du pool.
properties.deploymentConfiguration	DeploymentConfiguration		Cette propriété décrit les machines virtuelles sur lesquelles les nœuds du pool seront déployés.
properties.displayName	string		Nom complet du pool. Le nom complet n’a pas besoin d’être unique et peut contenir des caractères Unicode pouvant atteindre une longueur maximale de 1024.
properties.interNodeCommunication	InterNodeCommunicationState		Indique si le pool autorise la communication directe entre les nœuds. Cela impose des restrictions sur les nœuds qui peuvent être affectés au pool. L’activation de cette valeur peut réduire le nombre de nœuds demandé à allouer dans le pool. Si elle n’est pas spécifiée, cette valeur est définie par défaut sur « Disabled ».
properties.lastModified	string (date-time)		Heure de la dernière modification du pool. Il s’agit de la dernière fois où les données au niveau du pool, telles que targetDedicatedNodes ou autoScaleSettings, ont changé. Elle ne prend pas en compte les modifications au niveau du nœud, telles qu’un nœud de calcul qui change d’état.
properties.metadata	MetadataItem[]		Liste des paires nom-valeur associées au pool en tant que métadonnées. Le service Batch n’affecte aucune signification aux métadonnées ; il s’agit uniquement de l’utilisation du code utilisateur.
properties.mountConfiguration	MountConfiguration[]		Liste des systèmes de fichiers à monter sur chaque nœud du pool. Cela prend en charge Azure Files, NFS, CIFS/SMB et Blobfuse.
properties.networkConfiguration	NetworkConfiguration		Configuration réseau du pool. Configuration réseau d’un pool.
properties.provisioningState	PoolProvisioningState		État actuel du pool.
properties.provisioningStateTransitionTime	string (date-time)		Heure à laquelle le pool a entré son état actuel.
properties.resizeOperationStatus	ResizeOperationStatus		Contient des détails sur l’opération de redimensionnement actuelle ou la dernière fois terminée. Décrit l’opération actuelle (si le pool AllocationState est redimensionnement) ou l’opération précédemment terminée (si AllocationState est stable).
properties.resourceTags	object		Balises spécifiées par l’utilisateur associées au pool. Balises définies par l’utilisateur à associer au pool Azure Batch. Quand elles sont spécifiées, ces balises sont propagées aux ressources Azure de stockage associées au pool. Cette propriété ne peut être spécifiée que lorsque le compte Batch a été créé avec la propriété poolAllocationMode définie sur « UserSubscription ».
properties.scaleSettings	ScaleSettings		Paramètres qui configurent le nombre de nœuds dans le pool. Définit la taille souhaitée du pool. Il peut s’agir de « fixedScale » où les targetDedicatedNodes demandés sont spécifiés, ou « autoScale » qui définit une formule qui est régulièrement réévaluée. Si cette propriété n’est pas spécifiée, le pool aura une échelle fixe avec 0 targetDedicatedNodes.
properties.startTask	StartTask		Tâche spécifiée pour s’exécuter sur chaque nœud de calcul au fur et à mesure qu’elle joint le pool. Dans une opération PATCH (mise à jour), cette propriété peut être définie sur un objet vide pour supprimer la tâche de démarrage du pool.
properties.targetNodeCommunicationMode	NodeCommunicationMode		Mode de communication de nœud souhaité pour le pool. Si elle est omise, la valeur par défaut est Default.
properties.taskSchedulingPolicy	TaskSchedulingPolicy		Comment les tâches sont distribuées entre les nœuds de calcul d’un pool. S’il n’est pas spécifié, la valeur par défaut est répartie.
properties.taskSlotsPerNode	integer (int32)	1	Nombre d’emplacements de tâche qui peuvent être utilisés pour exécuter des tâches simultanées sur un nœud de calcul unique dans le pool. La valeur par défaut est 1. La valeur maximale est la plus petite de 4 fois le nombre de cœurs de la vmSize du pool ou 256.
properties.upgradePolicy	UpgradePolicy		Stratégie de mise à niveau pour le pool. Décrit une stratégie de mise à niveau : automatique, manuelle ou propagée.
properties.userAccounts	UserAccount[]		Liste des comptes d’utilisateur à créer sur chaque nœud du pool.
properties.vmSize	string		Taille des machines virtuelles dans le pool. Toutes les machines virtuelles d’un pool sont de la même taille. Pour plus d’informations sur les tailles de machine virtuelle disponibles, consultez Tailles des machines virtuelles dans Azure (https://learn.microsoft.com/azure/virtual-machines/sizes/overview). Batch prend en charge toutes les tailles de machine virtuelle Azure, à l’exception des STANDARD_A0 et celles avec stockage Premium (STANDARD_GS, STANDARD_DS et série STANDARD_DSV2).
tags	object		Balises de la ressource.
type	string		Type de la ressource.

PoolEndpointConfiguration

Object

Configuration du point de terminaison d’un pool.

Nom	Type	Description
inboundNatPools	InboundNatPool[]	Liste des pools NAT entrants qui peuvent être utilisés pour traiter des ports spécifiques sur un nœud de calcul individuel en externe. Le nombre maximal de pools NAT entrants par pool Batch est de 5. Si le nombre maximal de pools NAT entrants est dépassé, la requête échoue avec le code d’état HTTP 400. Cela ne peut pas être spécifié si IPAddressProvisioningType est NoPublicIPAddresses.

PoolIdentityType

Énumération

Type d’identité utilisé pour le pool Batch.

Valeur	Description
None	Le pool Batch n’a aucune identité associée. La définition None dans le pool de mises à jour supprime les identités existantes.
UserAssigned	Le pool Batch a des identités affectées par l’utilisateur avec elle.

PoolProvisioningState

Énumération

État actuel du pool.

Valeur	Description
Deleting	L’utilisateur a demandé que le pool soit supprimé, mais que l’opération de suppression n’a pas encore été terminée.
Succeeded	Le pool est disponible pour exécuter des tâches soumises à la disponibilité des nœuds de calcul.

PublicIPAddressConfiguration

Object

Configuration d’adresse IP publique de la configuration réseau d’un pool.

Nom	Type	Description
ipAddressIds	string[]	Liste des adresses IP publiques que le service Batch utilisera lors de l’approvisionnement de nœuds de calcul. Le nombre d’adresses IP spécifiées ici limite la taille maximale du pool - 100 nœuds dédiés ou 100 nœuds Spot/basse priorité peuvent être alloués pour chaque adresse IP publique. Par exemple, un pool nécessitant 250 machines virtuelles dédiées aurait besoin d’au moins 3 adresses IP publiques spécifiées. Chaque élément de cette collection est de la forme : /subscriptions/{subscription}/resourceGroups/{group}/providers/Microsoft.Network/publicIPAddresses/{ip}.
provision	IPAddressProvisioningType	Type d’approvisionnement pour les adresses IP publiques pour le pool La valeur par défaut est BatchManaged

ResizeError

Object

Erreur qui s’est produite lors du redimensionnement d’un pool.

Nom	Type	Description
code	string	Identificateur de l’erreur. Les codes sont invariants et sont destinés à être consommés par programme.
details	ResizeError[]	Détails supplémentaires sur l’erreur.
message	string	Message décrivant l’erreur, destiné à être adapté à l’affichage dans une interface utilisateur.

ResizeOperationStatus

Object

Détails sur l’opération de redimensionnement en cours ou la dernière fois terminée.

Nom	Type	Description
errors	ResizeError[]	Détails des erreurs rencontrées lors de l’exécution du dernier redimensionnement sur le pool. Cette propriété est définie uniquement si une erreur s’est produite pendant le dernier redimensionnement du pool, et uniquement lorsque l’allocationState du pool est stable.
nodeDeallocationOption	ComputeNodeDeallocationOption	Détermine ce qu’il faut faire avec un nœud et ses tâches en cours d’exécution si la taille du pool diminue. La valeur par défaut est requeue.
resizeTimeout	string (duration)	Délai d’expiration de l’allocation de nœuds de calcul au pool ou suppression de nœuds de calcul du pool. La valeur par défaut est de 15 minutes. La valeur minimale est de 5 minutes. Si vous spécifiez une valeur inférieure à 5 minutes, le service Batch retourne une erreur ; si vous appelez directement l’API REST, le code d’état HTTP est 400 (requête incorrecte).
startTime	string (date-time)	Heure de démarrage de cette opération de redimensionnement.
targetDedicatedNodes	integer (int32)	Nombre souhaité de nœuds de calcul dédiés dans le pool.
targetLowPriorityNodes	integer (int32)	Nombre souhaité de nœuds de calcul Spot/basse priorité dans le pool.

ResourceFile

Object

Un seul fichier ou plusieurs fichiers à télécharger sur un nœud de calcul.

Nom	Type	Description
autoStorageContainerName	string	Nom du conteneur de stockage dans le compte de stockage automatique. Les propriétés autoStorageContainerName, storageContainerUrl et httpUrl s’excluent mutuellement et l’une d’elles doit être spécifiée.
blobPrefix	string	Préfixe d’objet blob à utiliser lors du téléchargement d’objets blob à partir d’un conteneur stockage Azure. Seuls les objets blob dont les noms commencent par le préfixe spécifié sont téléchargés. La propriété est valide uniquement lorsque autoStorageContainerName ou storageContainerUrl est utilisé. Ce préfixe peut être un nom de fichier partiel ou un sous-répertoire. Si aucun préfixe n’est spécifié, tous les fichiers du conteneur sont téléchargés.
fileMode	string	Attribut du mode d’autorisation de fichier au format octal. Cette propriété s’applique uniquement aux fichiers téléchargés sur des nœuds de calcul Linux. Il sera ignoré s’il est spécifié pour un resourceFile qui sera téléchargé sur un nœud Windows. Si cette propriété n’est pas spécifiée pour un nœud Linux, la valeur par défaut 0770 est appliquée au fichier.
filePath	string	Emplacement sur le nœud de calcul auquel télécharger le fichier, par rapport au répertoire de travail de la tâche. Si la propriété httpUrl est spécifiée, filePath est requis et décrit le chemin vers lequel le fichier sera téléchargé, y compris le nom de fichier. Sinon, si la propriété autoStorageContainerName ou storageContainerUrl est spécifiée, filePath est facultatif et est le répertoire dans lequel télécharger les fichiers. Dans le cas où filePath est utilisé comme répertoire, toute structure de répertoires déjà associée aux données d’entrée sera conservée dans son intégralité et ajoutée au répertoire filePath spécifié. Le chemin d’accès relatif spécifié ne peut pas décomposer le répertoire de travail de la tâche (par exemple à l’aide de '..').
httpUrl	string	URL du fichier à télécharger. Les propriétés autoStorageContainerName, storageContainerUrl et httpUrl s’excluent mutuellement et l’une d’elles doit être spécifiée. Si l’URL pointe vers stockage Blob Azure, elle doit être lisible à partir de nœuds de calcul. Il existe trois façons d’obtenir cette URL pour un objet blob dans le stockage Azure : incluez une signature d’accès partagé (SAP) accordant des autorisations de lecture sur l’objet blob, utilisez une identité managée avec une autorisation de lecture ou définissez la liste de contrôle d’accès pour l’objet blob ou son conteneur afin d’autoriser l’accès public.
identityReference	ComputeNodeIdentityReference	Référence à l’identité affectée par l’utilisateur à utiliser pour accéder au stockage Blob Azure spécifié par storageContainerUrl ou httpUrl Référence à une identité affectée par l’utilisateur associée au pool Batch qu’un nœud de calcul utilisera.
storageContainerUrl	string	URL du conteneur d’objets blob dans Stockage Blob Azure. Les propriétés autoStorageContainerName, storageContainerUrl et httpUrl s’excluent mutuellement et l’une d’elles doit être spécifiée. Cette URL doit être lisible et listable à partir de nœuds de calcul. Il existe trois façons d’obtenir une telle URL pour un conteneur dans le stockage Azure : inclure une signature d’accès partagé (SAP) accordant des autorisations de lecture et de liste sur le conteneur, utiliser une identité managée avec des autorisations de lecture et de liste, ou définir la liste de contrôle d’accès pour le conteneur afin d’autoriser l’accès public.

RollingUpgradePolicy

Object

Paramètres de configuration utilisés lors de l’exécution d’une mise à niveau propagée.

Nom	Type	Description
enableCrossZoneUpgrade	boolean	Autorisez VMSS à ignorer les limites AZ lors de la construction de lots de mise à niveau. Prenez en compte le domaine de mise à jour et maxBatchInstancePercent pour déterminer la taille du lot. Si ce champ n’est pas défini, Azure Azure Batch ne définit pas sa valeur par défaut. La valeur d’enableCrossZoneUpgrade sur virtualMachineScaleSet créée sera définie par les configurations par défaut sur VirtualMachineScaleSet. Ce champ peut être défini sur true ou false uniquement lors de l’utilisation de NodePlacementConfiguration comme Zonal.
maxBatchInstancePercent	integer (int32) minimum: 5 maximum: 100	Pourcentage maximal d’instances de machines virtuelles totales qui seront mises à niveau simultanément par la mise à niveau propagée dans un lot. Comme il s’agit d’un nombre maximal d’instances non saines dans les lots précédents ou futurs, le pourcentage d’instances d’un lot peut diminuer pour garantir une fiabilité plus élevée. La valeur de ce champ doit être comprise entre 5 et 100, inclus. Si maxBatchInstancePercent et maxUnhealthyInstancePercent sont attribués avec la valeur, la valeur de maxBatchInstancePercent ne doit pas être supérieure à maxUnhealthyInstancePercent.
maxUnhealthyInstancePercent	integer (int32) minimum: 5 maximum: 100	Pourcentage maximal des instances de machine virtuelle totales dans le groupe identique qui peuvent être simultanément non saines, soit en raison d’une mise à niveau, soit en étant trouvées dans un état non sain par les vérifications d’intégrité de la machine virtuelle avant l’abandon de la mise à niveau propagée. Cette contrainte sera vérifiée avant de démarrer un lot. La valeur de ce champ doit être comprise entre 5 et 100, inclus. Si maxBatchInstancePercent et maxUnhealthyInstancePercent sont attribués avec la valeur, la valeur de maxBatchInstancePercent ne doit pas être supérieure à maxUnhealthyInstancePercent.
maxUnhealthyUpgradedInstancePercent	integer (int32) minimum: 0 maximum: 100	Pourcentage maximal d’instances de machine virtuelle mises à niveau qui peuvent être trouvées dans un état non sain. Cette vérification se produit après la mise à niveau de chaque lot. Si ce pourcentage est jamais dépassé, la mise à jour propagée abandonne. La valeur de ce champ doit être comprise entre 0 et 100, inclus.
pauseTimeBetweenBatches	string	Délai d’attente entre la fin de la mise à jour pour toutes les machines virtuelles d’un lot et le démarrage du lot suivant. La durée doit être spécifiée au format ISO 8601.
prioritizeUnhealthyInstances	boolean	Mettez à niveau toutes les instances non saines dans un groupe identique avant toutes les instances saines.
rollbackFailedInstancesOnPolicyBreach	boolean	Échec de restauration des instances dans le modèle précédent si la stratégie de mise à niveau propagée est enfreinte.

ScaleSettings

Object

Mettre à l’échelle les paramètres du pool

Nom	Type	Description
autoScale	AutoScaleSettings	Paramètres de mise à l’échelle automatique pour le pool. Cette propriété et fixedScale s’excluent mutuellement et l’une des propriétés doit être spécifiée.
fixedScale	FixedScaleSettings	Paramètres de mise à l’échelle fixes pour le pool. Cette propriété et cette mise à l’échelle automatique sont mutuellement exclusives et l’une des propriétés doit être spécifiée.

SecurityEncryptionTypes

Énumération

Spécifie le EncryptionType du disque managé. Il est défini sur VMGuestStateOnly pour le chiffrement de l’objet blob VMGuestState et nonPersistedTPM pour ne pas conserver l’état du microprogramme dans l’objet blob VMGuestState. Remarque: elle peut être définie uniquement pour les machines virtuelles confidentielles et requises lors de l’utilisation de machines virtuelles confidentielles.

Valeur	Description
NonPersistedTPM
VMGuestStateOnly

SecurityProfile

Object

Spécifie les paramètres de profil de sécurité de la machine virtuelle ou du groupe de machines virtuelles identiques.

Nom	Type	Description
encryptionAtHost	boolean	Cette propriété peut être utilisée par l’utilisateur dans la demande pour activer ou désactiver le chiffrement de l’hôte pour la machine virtuelle ou le groupe de machines virtuelles identiques. Cela active le chiffrement pour tous les disques, y compris le disque Resource/Temp sur l’hôte lui-même.
securityType	SecurityTypes	Spécifie le SecurityType de la machine virtuelle. Il doit être défini sur n’importe quelle valeur spécifiée pour activer UefiSettings.
uefiSettings	UefiSettings	Spécifie les paramètres de sécurité tels que le démarrage sécurisé et vTPM utilisés lors de la création de la machine virtuelle. Spécifie les paramètres de sécurité tels que le démarrage sécurisé et vTPM utilisés lors de la création de la machine virtuelle.

SecurityTypes

Énumération

Spécifie le SecurityType de la machine virtuelle. Il doit être défini sur n’importe quelle valeur spécifiée pour activer UefiSettings.

Valeur	Description
confidentialVM	L’informatique confidentielle Azure offre des machines virtuelles confidentielles pour les locataires avec des exigences de sécurité et de confidentialité élevées. Ces machines virtuelles fournissent une limite forte et matérielle appliquée pour répondre à vos besoins de sécurité. Vous pouvez utiliser des machines virtuelles confidentielles pour les migrations sans apporter de modifications à votre code, avec la plateforme protégeant l’état de votre machine virtuelle contre la lecture ou la modification.
trustedLaunch	Le lancement approuvé protège contre les techniques d’attaque avancées et persistantes.

ServiceArtifactReference

Object

Spécifie l’ID de référence de l’artefact de service utilisé pour définir la même version d’image pour toutes les machines virtuelles du groupe identique lors de l’utilisation de la version d’image la plus récente.

Nom	Type	Description
id	string	ID de référence de l’artefact de service de ServiceArtifactReference ID de référence de l’artefact de service sous la forme de /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactName}/vmArtifactsProfiles/{vmArtifactsProfilesName}

StartTask

Object

Tâche exécutée lorsqu’un nœud de calcul joint un pool dans le service Azure Batch, ou lorsque le nœud de calcul est redémarré ou réimagené.

Nom	Type	Valeur par défaut	Description
commandLine	string		Ligne de commande de la tâche de démarrage. La ligne de commande ne s’exécute pas sous un interpréteur de commandes et ne peut donc pas tirer parti des fonctionnalités de l’interpréteur de commandes telles que l’extension de variable d’environnement. Si vous souhaitez tirer parti de ces fonctionnalités, vous devez appeler l’interpréteur de commandes dans la ligne de commande, par exemple en utilisant « cmd /c MyCommand » dans Windows ou « /bin/sh -c MyCommand » dans Linux. Obligatoire si d’autres propriétés de startTask sont spécifiées.
containerSettings	TaskContainerSettings		Paramètres du conteneur sous lequel la tâche de démarrage s’exécute. Lorsque cela est spécifié, tous les répertoires sont récursifs sous la AZ_BATCH_NODE_ROOT_DIR (la racine des répertoires Azure Batch sur le nœud) sont mappés dans le conteneur, toutes les variables d’environnement de tâche sont mappées dans le conteneur et la ligne de commande de tâche est exécutée dans le conteneur.
environmentSettings	EnvironmentSetting[]		Liste des paramètres de variable d’environnement pour la tâche de démarrage.
maxTaskRetryCount	integer (int32)	0	Nombre maximal de fois où la tâche peut être retentée. Le service Batch retente une tâche si son code de sortie n’est pas différent de zéro. Notez que cette valeur contrôle spécifiquement le nombre de nouvelles tentatives. Le service Batch essaie la tâche une fois, puis peut réessayer jusqu’à cette limite. Par exemple, si le nombre maximal de nouvelles tentatives est égal à 3, Batch tente la tâche jusqu’à 4 fois (une tentative initiale et 3 nouvelles tentatives). Si le nombre maximal de nouvelles tentatives est égal à 0, le service Batch ne réessaye pas la tâche. Si le nombre maximal de nouvelles tentatives est -1, le service Batch retente la tâche sans limite. La valeur par défaut est 0
resourceFiles	ResourceFile[]		Liste des fichiers que le service Batch télécharge sur le nœud de calcul avant d’exécuter la ligne de commande.
userIdentity	UserIdentity		Identité de l’utilisateur sous laquelle la tâche de démarrage s’exécute. Si elle est omise, la tâche s’exécute en tant qu’utilisateur non administratif unique à la tâche.
waitForSuccess	boolean		Indique si le service Batch doit attendre que la tâche de démarrage se termine correctement (autrement dit, pour quitter avec le code de sortie 0) avant de planifier des tâches sur le nœud de calcul. Si la valeur est true et que la tâche de démarrage échoue sur un nœud de calcul, le service Batch retente la tâche de démarrage jusqu’à son nombre maximal de nouvelles tentatives (maxTaskRetryCount). Si la tâche n’est toujours pas terminée après toutes les nouvelles tentatives, le service Batch marque le nœud de calcul inutilisable et ne planifie pas les tâches. Cette condition peut être détectée via l’état du nœud et la planification des détails d’erreur. Si la valeur est false, le service Batch n’attend pas la fin de la tâche de démarrage. Dans ce cas, d’autres tâches peuvent commencer à s’exécuter sur le nœud de calcul pendant que la tâche de démarrage est toujours en cours d’exécution ; et même si la tâche de démarrage échoue, les nouvelles tâches continueront d’être planifiées sur le nœud. La valeur par défaut est true.

StorageAccountType

Énumération

Type de compte de stockage à utiliser pour créer des disques de données ou un disque de système d’exploitation.

Valeur	Description
Premium_LRS	Le disque de données/disque du système d’exploitation doit utiliser un stockage premium localement redondant.
StandardSSD_LRS	Le disque de données/disque du système d’exploitation doit utiliser un stockage SSD standard localement redondant.
Standard_LRS	Le disque de données/disque du système d’exploitation doit utiliser un stockage localement redondant standard.

TaskContainerSettings

Object

Paramètres de conteneur d’une tâche.

Nom	Type	Description
containerHostBatchBindMounts	ContainerHostBatchBindMountEntry[]	Chemins que vous souhaitez monter sur la tâche conteneur. Si ce tableau est null ou n’est pas présent, la tâche de conteneur monte l’intégralité du lecteur de disque temporaire dans windows (ou AZ_BATCH_NODE_ROOT_DIR sous Linux). Il ne monte aucun chemin de données dans un conteneur si ce tableau est défini comme vide.
containerRunOptions	string	Options supplémentaires pour la commande de création de conteneur. Ces options supplémentaires sont fournies en tant qu’arguments de la commande « docker create », en plus de celles contrôlées par le service Batch.
imageName	string	Image à utiliser pour créer le conteneur dans lequel la tâche s’exécutera. Il s’agit de la référence d’image complète, comme indiqué dans « docker pull ». Si aucune balise n’est fournie dans le cadre du nom de l’image, la balise « :latest » est utilisée comme valeur par défaut.
registry	ContainerRegistry	Registre privé qui contient l’image conteneur. Ce paramètre peut être omis s’il a déjà été fourni lors de la création du pool.
workingDirectory	ContainerWorkingDirectory	Indicateur permettant d’indiquer où se trouve le répertoire de travail de la tâche de conteneur. La valeur par défaut est « taskWorkingDirectory ».

TaskSchedulingPolicy

Object

Spécifie la façon dont les tâches doivent être distribuées entre les nœuds de calcul.

Nom	Type	Valeur par défaut	Description
nodeFillType	ComputeNodeFillType	Spread	Comment les tâches doivent être distribuées entre les nœuds de calcul.

UefiSettings

Object

Spécifie les paramètres de sécurité tels que le démarrage sécurisé et vTPM utilisés lors de la création de la machine virtuelle.

Nom	Type	Description
secureBootEnabled	boolean	Spécifie si le démarrage sécurisé doit être activé sur la machine virtuelle.
vTpmEnabled	boolean	Spécifie si vTPM doit être activé sur la machine virtuelle.

UpgradeMode

Énumération

Spécifie le mode d’une mise à niveau vers des machines virtuelles dans le groupe identique.

Les valeurs possibles sont les suivantes :

manuel : vous contrôlez l’application des mises à jour des machines virtuelles dans le groupe identique. Pour ce faire, utilisez l’action manualUpgrade.

automatique : toutes les machines virtuelles du groupe identique sont automatiquement mises à jour en même temps.

rolling - Le groupe identique effectue des mises à jour par lots avec une durée de pause facultative entre les deux.

Valeur	Description
automatic	Toutes les machines virtuelles du groupe identique sont automatiquement mises à jour en même temps.
manual	Vous contrôlez l’application des mises à jour des machines virtuelles dans le groupe identique. Pour ce faire, utilisez l’action manualUpgrade.
rolling	Les instances existantes d’un groupe identique sont supprimées par lots pour être mises à niveau. Une fois le lot mis à niveau terminé, les instances commencent à reprendre le trafic et le lot suivant commence. Cela se poursuit jusqu’à ce que toutes les instances ont apporté up-to-date.

UpgradePolicy

Object

Décrit une stratégie de mise à niveau : automatique, manuelle ou propagée.

Nom	Type	Description
automaticOSUpgradePolicy	AutomaticOSUpgradePolicy	Paramètres de configuration utilisés pour effectuer la mise à niveau automatique du système d’exploitation. Paramètres de configuration utilisés pour effectuer la mise à niveau automatique du système d’exploitation.
mode	UpgradeMode	Spécifie le mode d’une mise à niveau vers des machines virtuelles dans le groupe identique. Les valeurs possibles sont les suivantes : manuel : vous contrôlez l’application des mises à jour des machines virtuelles dans le groupe identique. Pour ce faire, utilisez l’action manualUpgrade. automatique : toutes les machines virtuelles du groupe identique sont automatiquement mises à jour en même temps. rolling - Le groupe identique effectue des mises à jour par lots avec une durée de pause facultative entre les deux.
rollingUpgradePolicy	RollingUpgradePolicy	Paramètres de configuration utilisés lors de l’exécution d’une mise à niveau propagée. Paramètres de configuration utilisés lors de l’exécution d’une mise à niveau propagée.

UserAccount

Object

Propriétés utilisées pour créer un utilisateur sur un nœud Azure Batch.

Nom	Type	Description
elevationLevel	ElevationLevel	Niveau d’élévation du compte d’utilisateur. nonAdmin : l’utilisateur automatique est un utilisateur standard sans accès élevé. administrateur : l’utilisateur automatique est un utilisateur disposant d’un accès élevé et fonctionne avec des autorisations d’administrateur complètes. La valeur par défaut n’est pasAdmin.
linuxUserConfiguration	LinuxUserConfiguration	Configuration utilisateur spécifique à Linux pour le compte d’utilisateur. Cette propriété est ignorée si elle est spécifiée sur un pool Windows. S’il n’est pas spécifié, l’utilisateur est créé avec les options par défaut.
name	string	Nom du compte d’utilisateur. Les noms peuvent contenir n’importe quel caractère Unicode jusqu’à une longueur maximale de 20.
password	string	Mot de passe du compte d’utilisateur.
windowsUserConfiguration	WindowsUserConfiguration	Configuration utilisateur spécifique à Windows pour le compte d’utilisateur. Cette propriété ne peut être spécifiée que si l’utilisateur se trouve sur un pool Windows. S’il n’est pas spécifié et sur un pool Windows, l’utilisateur est créé avec les options par défaut.

UserAssignedIdentities

Object

Liste des identités utilisateur associées.

Nom	Type	Description
clientId	string	ID client de l’identité affectée par l’utilisateur.
principalId	string	ID principal de l’identité affectée par l’utilisateur.

UserIdentity

Object

Définition de l’identité de l’utilisateur sous laquelle la tâche est exécutée.

Nom	Type	Description
autoUser	AutoUserSpecification	Utilisateur automatique sous lequel la tâche est exécutée. Les propriétés userName et autoUser s’excluent mutuellement ; vous devez en spécifier un, mais pas les deux.
userName	string	Nom de l’identité de l’utilisateur sous lequel la tâche est exécutée. Les propriétés userName et autoUser s’excluent mutuellement ; vous devez en spécifier un, mais pas les deux.

VirtualMachineConfiguration

Object

Configuration des nœuds de calcul dans un pool en fonction de l’infrastructure des machines virtuelles Azure.

Nom	Type	Description
containerConfiguration	ContainerConfiguration	Configuration du conteneur pour le pool. Si elle est spécifiée, le programme d’installation est effectué sur chaque nœud du pool pour permettre l’exécution des tâches dans des conteneurs. Toutes les tâches régulières et les tâches du gestionnaire de travaux s’exécutent sur ce pool doivent spécifier la propriété containerSettings, et toutes les autres tâches peuvent la spécifier.
dataDisks	DataDisk[]	Configuration des disques de données attachés aux nœuds de calcul du pool. Cette propriété doit être spécifiée si les nœuds de calcul du pool doivent avoir des disques de données vides attachés.
diskEncryptionConfiguration	DiskEncryptionConfiguration	Configuration du chiffrement de disque pour le pool. Si spécifié, le chiffrement est effectué sur chaque nœud du pool pendant l’approvisionnement de nœuds.
extensions	VMExtension[]	Extension de machine virtuelle pour le pool. Si elle est spécifiée, les extensions mentionnées dans cette configuration sont installées sur chaque nœud.
imageReference	ImageReference	Référence à l’image de la Place de marché des machines virtuelles Azure ou à l’image de machine virtuelle personnalisée à utiliser.
licenseType	string	Type de licence locale à utiliser lors du déploiement du système d’exploitation. Cela s’applique uniquement aux images qui contiennent le système d’exploitation Windows et ne doivent être utilisées que lorsque vous conservez des licences locales valides pour les nœuds qui seront déployés. En cas d’omission, aucune remise de licence locale n’est appliquée. Les valeurs sont les suivantes : Windows_Server : la licence locale est destinée à Windows Server. Windows_Client : la licence locale est destinée au client Windows.
nodeAgentSkuId	string	Référence SKU de l’agent de nœud Batch à provisionner sur les nœuds de calcul du pool. L’agent de nœud Batch est un programme qui s’exécute sur chaque nœud du pool et fournit l’interface de commande et de contrôle entre le nœud et le service Batch. Il existe différentes implémentations de l’agent de nœud, appelées références SKU, pour différents systèmes d’exploitation. Vous devez spécifier une référence SKU de l’agent de nœud qui correspond à la référence d’image sélectionnée. Pour obtenir la liste des références SKU de l’agent de nœud prises en charge, ainsi que leur liste de références d’images vérifiées, consultez l’opération « Répertorier les références SKU de l’agent de nœud prises en charge ».
nodePlacementConfiguration	NodePlacementConfiguration	Configuration de placement de nœud pour le pool. Cette configuration spécifie des règles sur la façon dont les nœuds du pool seront alloués physiquement.
osDisk	OSDisk	Paramètres du disque du système d’exploitation de la machine virtuelle. Contient la configuration des paramètres OSDisk éphémères.
securityProfile	SecurityProfile	Spécifie les paramètres de profil de sécurité de la machine virtuelle ou du groupe de machines virtuelles identiques. Spécifie les paramètres de profil de sécurité de la machine virtuelle ou du groupe de machines virtuelles identiques.
serviceArtifactReference	ServiceArtifactReference	Spécifie l’ID de référence de l’artefact de service utilisé pour définir la même version d’image pour toutes les machines virtuelles du groupe identique lors de l’utilisation de la version d’image la plus récente. ID de référence de l’artefact de service sous la forme de /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactName}/vmArtifactsProfiles/{vmArtifactsProfilesName}
windowsConfiguration	WindowsConfiguration	Paramètres du système d’exploitation Windows sur la machine virtuelle. Cette propriété ne doit pas être spécifiée si l’imageReference spécifie une image de système d’exploitation Linux.

VMDiskSecurityProfile

Object

Spécifie les paramètres du profil de sécurité pour le disque managé. Remarque: elle ne peut être définie que pour les machines virtuelles confidentielles et est requise lors de l’utilisation de machines virtuelles confidentielles.

Nom	Type	Description
securityEncryptionType	SecurityEncryptionTypes	Spécifie le EncryptionType du disque managé. Il est défini sur VMGuestStateOnly pour le chiffrement de l’objet blob VMGuestState et nonPersistedTPM pour ne pas conserver l’état du microprogramme dans l’objet blob VMGuestState. Remarque: elle peut être définie uniquement pour les machines virtuelles confidentielles et requises lors de l’utilisation de machines virtuelles confidentielles.

VMExtension

Object

Configuration des extensions de machine virtuelle.

Nom	Type	Description
autoUpgradeMinorVersion	boolean	Indique si l’extension doit utiliser une version mineure plus récente si elle est disponible au moment du déploiement. Une fois déployée, toutefois, l’extension ne met pas à niveau les versions mineures, sauf si elle est redéployée, même avec cette propriété définie sur true.
enableAutomaticUpgrade	boolean	Indique si l’extension doit être automatiquement mise à niveau par la plateforme s’il existe une version plus récente de l’extension disponible.
name	string	Nom de l’extension de machine virtuelle.
protectedSettings	object	L’extension peut contenir protectedSettings ou protectedSettingsFromKeyVault ou aucun paramètre protégé du tout.
provisionAfterExtensions	string[]	Collection de noms d’extensions. Collection de noms d’extensions après lesquels cette extension doit être provisionnée.
publisher	string	Nom du serveur de publication du gestionnaire d’extensions.
settings	object	Paramètres publics au format JSON pour l’extension.
type	string	Type des extensions.
typeHandlerVersion	string	Version du gestionnaire de scripts.

WindowsConfiguration

Object

Paramètres du système d’exploitation Windows à appliquer à la machine virtuelle.

Nom	Type	Description
enableAutomaticUpdates	boolean	Indique si les mises à jour automatiques sont activées sur la machine virtuelle. Si elle est omise, la valeur par défaut est true.

WindowsUserConfiguration

Object

Propriétés utilisées pour créer un compte d’utilisateur sur un nœud Windows.

Nom	Type	Description
loginMode	LoginMode	Mode de connexion pour l’utilisateur Spécifie le mode de connexion pour l’utilisateur. La valeur par défaut est Interactive.