pulumi-azure-kotlin/com.pulumi.azure.batch.kotlin/Job

Job

class Job : KotlinCustomResource

Manages a Batch Job.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-rg",
    location: "west europe",
});
const exampleAccount = new azure.batch.Account("example", {
    name: "exampleaccount",
    resourceGroupName: example.name,
    location: example.location,
});
const examplePool = new azure.batch.Pool("example", {
    name: "examplepool",
    resourceGroupName: example.name,
    accountName: exampleAccount.name,
    nodeAgentSkuId: "batch.node.ubuntu 16.04",
    vmSize: "STANDARD_A1_V2",
    fixedScale: {
        targetDedicatedNodes: 1,
    },
    storageImageReference: {
        publisher: "Canonical",
        offer: "0001-com-ubuntu-server-jammy",
        sku: "22_04-lts",
        version: "latest",
    },
});
const exampleJob = new azure.batch.Job("example", {
    name: "examplejob",
    batchPoolId: examplePool.id,
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-rg",
    location="west europe")
example_account = azure.batch.Account("example",
    name="exampleaccount",
    resource_group_name=example.name,
    location=example.location)
example_pool = azure.batch.Pool("example",
    name="examplepool",
    resource_group_name=example.name,
    account_name=example_account.name,
    node_agent_sku_id="batch.node.ubuntu 16.04",
    vm_size="STANDARD_A1_V2",
    fixed_scale={
        "target_dedicated_nodes": 1,
    },
    storage_image_reference={
        "publisher": "Canonical",
        "offer": "0001-com-ubuntu-server-jammy",
        "sku": "22_04-lts",
        "version": "latest",
    })
example_job = azure.batch.Job("example",
    name="examplejob",
    batch_pool_id=example_pool.id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-rg",
        Location = "west europe",
    });
    var exampleAccount = new Azure.Batch.Account("example", new()
    {
        Name = "exampleaccount",
        ResourceGroupName = example.Name,
        Location = example.Location,
    });
    var examplePool = new Azure.Batch.Pool("example", new()
    {
        Name = "examplepool",
        ResourceGroupName = example.Name,
        AccountName = exampleAccount.Name,
        NodeAgentSkuId = "batch.node.ubuntu 16.04",
        VmSize = "STANDARD_A1_V2",
        FixedScale = new Azure.Batch.Inputs.PoolFixedScaleArgs
        {
            TargetDedicatedNodes = 1,
        },
        StorageImageReference = new Azure.Batch.Inputs.PoolStorageImageReferenceArgs
        {
            Publisher = "Canonical",
            Offer = "0001-com-ubuntu-server-jammy",
            Sku = "22_04-lts",
            Version = "latest",
        },
    });
    var exampleJob = new Azure.Batch.Job("example", new()
    {
        Name = "examplejob",
        BatchPoolId = examplePool.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/batch"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-rg"),
			Location: pulumi.String("west europe"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := batch.NewAccount(ctx, "example", &batch.AccountArgs{
			Name:              pulumi.String("exampleaccount"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
		})
		if err != nil {
			return err
		}
		examplePool, err := batch.NewPool(ctx, "example", &batch.PoolArgs{
			Name:              pulumi.String("examplepool"),
			ResourceGroupName: example.Name,
			AccountName:       exampleAccount.Name,
			NodeAgentSkuId:    pulumi.String("batch.node.ubuntu 16.04"),
			VmSize:            pulumi.String("STANDARD_A1_V2"),
			FixedScale: &batch.PoolFixedScaleArgs{
				TargetDedicatedNodes: pulumi.Int(1),
			},
			StorageImageReference: &batch.PoolStorageImageReferenceArgs{
				Publisher: pulumi.String("Canonical"),
				Offer:     pulumi.String("0001-com-ubuntu-server-jammy"),
				Sku:       pulumi.String("22_04-lts"),
				Version:   pulumi.String("latest"),
			},
		})
		if err != nil {
			return err
		}
		_, err = batch.NewJob(ctx, "example", &batch.JobArgs{
			Name:        pulumi.String("examplejob"),
			BatchPoolId: examplePool.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.batch.Account;
import com.pulumi.azure.batch.AccountArgs;
import com.pulumi.azure.batch.Pool;
import com.pulumi.azure.batch.PoolArgs;
import com.pulumi.azure.batch.inputs.PoolFixedScaleArgs;
import com.pulumi.azure.batch.inputs.PoolStorageImageReferenceArgs;
import com.pulumi.azure.batch.Job;
import com.pulumi.azure.batch.JobArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-rg")
            .location("west europe")
            .build());
        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("exampleaccount")
            .resourceGroupName(example.name())
            .location(example.location())
            .build());
        var examplePool = new Pool("examplePool", PoolArgs.builder()
            .name("examplepool")
            .resourceGroupName(example.name())
            .accountName(exampleAccount.name())
            .nodeAgentSkuId("batch.node.ubuntu 16.04")
            .vmSize("STANDARD_A1_V2")
            .fixedScale(PoolFixedScaleArgs.builder()
                .targetDedicatedNodes(1)
                .build())
            .storageImageReference(PoolStorageImageReferenceArgs.builder()
                .publisher("Canonical")
                .offer("0001-com-ubuntu-server-jammy")
                .sku("22_04-lts")
                .version("latest")
                .build())
            .build());
        var exampleJob = new Job("exampleJob", JobArgs.builder()
            .name("examplejob")
            .batchPoolId(examplePool.id())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-rg
      location: west europe
  exampleAccount:
    type: azure:batch:Account
    name: example
    properties:
      name: exampleaccount
      resourceGroupName: ${example.name}
      location: ${example.location}
  examplePool:
    type: azure:batch:Pool
    name: example
    properties:
      name: examplepool
      resourceGroupName: ${example.name}
      accountName: ${exampleAccount.name}
      nodeAgentSkuId: batch.node.ubuntu 16.04
      vmSize: STANDARD_A1_V2
      fixedScale:
        targetDedicatedNodes: 1
      storageImageReference:
        publisher: Canonical
        offer: 0001-com-ubuntu-server-jammy
        sku: 22_04-lts
        version: latest
  exampleJob:
    type: azure:batch:Job
    name: example
    properties:
      name: examplejob
      batchPoolId: ${examplePool.id}
Content copied to clipboard

Import

Batch Jobs can be imported using the resource id, e.g.

$ pulumi import azure:batch/job:Job example /subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Batch/batchAccounts/account1/pools/pool1/jobs/job1
Content copied to clipboard

Properties

Link copied to clipboard
val batchPoolId: Output<String>

The ID of the Batch Pool. Changing this forces a new Batch Job to be created.

Link copied to clipboard
val commonEnvironmentProperties: Output<Map<String, String>>?

Specifies a map of common environment settings applied to this Batch Job. Changing this forces a new Batch Job to be created.

Link copied to clipboard
val displayName: Output<String>?

The display name of this Batch Job. Changing this forces a new Batch Job to be created.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val name: Output<String>

The name which should be used for this Batch Job. Changing this forces a new Batch Job to be created.

Link copied to clipboard
val priority: Output<Int>?

The priority of this Batch Job, possible values can range from -1000 (lowest) to 1000 (highest). Defaults to 0.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val taskRetryMaximum: Output<Int>?

The number of retries to each Batch Task belongs to this Batch Job. If this is set to 0, the Batch service does not retry Tasks. If this is set to -1, the Batch service retries Batch Tasks without limit.

Link copied to clipboard
val urn: Output<String>