ComputeEnvironment class
Creates a AWS Batch compute environment. Compute environments contain the Amazon ECS container instances that are used to run containerized batch jobs.
For information about AWS Batch, see What is AWS Batch?. For information about compute environment, see Compute Environments.
> Note: To prevent a race condition during environment deletion, make sure to set dependsOn to the related aws.iam.RolePolicyAttachment;
otherwise, the policy may be destroyed too soon and the compute environment will then get stuck in the DELETING state, see Troubleshooting AWS Batch.
Example Usage
EC2 Type
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const ec2AssumeRole = aws.iam.getPolicyDocument({
statements: [{
principals: [{
type: "Service",
identifiers: ["ec2.amazonaws.com"],
}],
effect: "Allow",
actions: ["sts:AssumeRole"],
}],
});
const ecsInstanceRole = new aws.iam.Role("ecs_instance_role", {
name: "ecs_instance_role",
assumeRolePolicy: ec2AssumeRole.then(ec2AssumeRole => ec2AssumeRole.json),
});
const ecsInstanceRoleRolePolicyAttachment = new aws.iam.RolePolicyAttachment("ecs_instance_role", {
role: ecsInstanceRole.name,
policyArn: "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role",
});
const ecsInstanceRoleInstanceProfile = new aws.iam.InstanceProfile("ecs_instance_role", {
name: "ecs_instance_role",
role: ecsInstanceRole.name,
});
const batchAssumeRole = aws.iam.getPolicyDocument({
statements: [{
principals: [{
type: "Service",
identifiers: ["batch.amazonaws.com"],
}],
effect: "Allow",
actions: ["sts:AssumeRole"],
}],
});
const awsBatchServiceRole = new aws.iam.Role("aws_batch_service_role", {
name: "aws_batch_service_role",
assumeRolePolicy: batchAssumeRole.then(batchAssumeRole => batchAssumeRole.json),
});
const awsBatchServiceRoleRolePolicyAttachment = new aws.iam.RolePolicyAttachment("aws_batch_service_role", {
role: awsBatchServiceRole.name,
policyArn: "arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole",
});
const sample = new aws.ec2.SecurityGroup("sample", {
egress: [{
fromPort: 0,
toPort: 0,
protocol: "-1",
cidrBlocks: ["0.0.0.0/0"],
}],
name: "aws_batch_compute_environment_security_group",
});
const sampleVpc = new aws.ec2.Vpc("sample", {cidrBlock: "10.1.0.0/16"});
const sampleSubnet = new aws.ec2.Subnet("sample", {
vpcId: sampleVpc.id,
cidrBlock: "10.1.1.0/24",
});
const samplePlacementGroup = new aws.ec2.PlacementGroup("sample", {
name: "sample",
strategy: aws.ec2.PlacementStrategy.Cluster,
});
const sampleComputeEnvironment = new aws.batch.ComputeEnvironment("sample", {
computeResources: {
instanceRole: ecsInstanceRoleInstanceProfile.arn,
instanceTypes: ["c4.large"],
maxVcpus: 16,
minVcpus: 0,
placementGroup: samplePlacementGroup.name,
securityGroupIds: [sample.id],
subnets: [sampleSubnet.id],
type: "EC2",
},
name: "sample",
serviceRole: awsBatchServiceRole.arn,
type: "MANAGED",
}, {
dependsOn: [awsBatchServiceRoleRolePolicyAttachment],
});
import pulumi
import pulumi_aws as aws
ec2_assume_role = aws.iam.get_policy_document(statements=[{
"principals": [{
"type": "Service",
"identifiers": ["ec2.amazonaws.com"],
}],
"effect": "Allow",
"actions": ["sts:AssumeRole"],
}])
ecs_instance_role = aws.iam.Role("ecs_instance_role",
name="ecs_instance_role",
assume_role_policy=ec2_assume_role.json)
ecs_instance_role_role_policy_attachment = aws.iam.RolePolicyAttachment("ecs_instance_role",
role=ecs_instance_role.name,
policy_arn="arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role")
ecs_instance_role_instance_profile = aws.iam.InstanceProfile("ecs_instance_role",
name="ecs_instance_role",
role=ecs_instance_role.name)
batch_assume_role = aws.iam.get_policy_document(statements=[{
"principals": [{
"type": "Service",
"identifiers": ["batch.amazonaws.com"],
}],
"effect": "Allow",
"actions": ["sts:AssumeRole"],
}])
aws_batch_service_role = aws.iam.Role("aws_batch_service_role",
name="aws_batch_service_role",
assume_role_policy=batch_assume_role.json)
aws_batch_service_role_role_policy_attachment = aws.iam.RolePolicyAttachment("aws_batch_service_role",
role=aws_batch_service_role.name,
policy_arn="arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole")
sample = aws.ec2.SecurityGroup("sample",
egress=[{
"from_port": 0,
"to_port": 0,
"protocol": "-1",
"cidr_blocks": ["0.0.0.0/0"],
}],
name="aws_batch_compute_environment_security_group")
sample_vpc = aws.ec2.Vpc("sample", cidr_block="10.1.0.0/16")
sample_subnet = aws.ec2.Subnet("sample",
vpc_id=sample_vpc.id,
cidr_block="10.1.1.0/24")
sample_placement_group = aws.ec2.PlacementGroup("sample",
name="sample",
strategy=aws.ec2.PlacementStrategy.CLUSTER)
sample_compute_environment = aws.batch.ComputeEnvironment("sample",
compute_resources={
"instance_role": ecs_instance_role_instance_profile.arn,
"instance_types": ["c4.large"],
"max_vcpus": 16,
"min_vcpus": 0,
"placement_group": sample_placement_group.name,
"security_group_ids": [sample.id],
"subnets": [sample_subnet.id],
"type": "EC2",
},
name="sample",
service_role=aws_batch_service_role.arn,
type="MANAGED",
opts = pulumi.ResourceOptions(depends_on=[aws_batch_service_role_role_policy_attachment]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var ec2AssumeRole = Aws.Iam.GetPolicyDocument.Invoke(new()
{
Statements = new[]
{
new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
{
Principals = new[]
{
new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
{
Type = "Service",
Identifiers = new[]
{
"ec2.amazonaws.com",
},
},
},
Effect = "Allow",
Actions = new[]
{
"sts:AssumeRole",
},
},
},
});
var ecsInstanceRole = new Aws.Iam.Role("ecs_instance_role", new()
{
Name = "ecs_instance_role",
AssumeRolePolicy = ec2AssumeRole.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
});
var ecsInstanceRoleRolePolicyAttachment = new Aws.Iam.RolePolicyAttachment("ecs_instance_role", new()
{
Role = ecsInstanceRole.Name,
PolicyArn = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role",
});
var ecsInstanceRoleInstanceProfile = new Aws.Iam.InstanceProfile("ecs_instance_role", new()
{
Name = "ecs_instance_role",
Role = ecsInstanceRole.Name,
});
var batchAssumeRole = Aws.Iam.GetPolicyDocument.Invoke(new()
{
Statements = new[]
{
new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
{
Principals = new[]
{
new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
{
Type = "Service",
Identifiers = new[]
{
"batch.amazonaws.com",
},
},
},
Effect = "Allow",
Actions = new[]
{
"sts:AssumeRole",
},
},
},
});
var awsBatchServiceRole = new Aws.Iam.Role("aws_batch_service_role", new()
{
Name = "aws_batch_service_role",
AssumeRolePolicy = batchAssumeRole.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
});
var awsBatchServiceRoleRolePolicyAttachment = new Aws.Iam.RolePolicyAttachment("aws_batch_service_role", new()
{
Role = awsBatchServiceRole.Name,
PolicyArn = "arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole",
});
var sample = new Aws.Ec2.SecurityGroup("sample", new()
{
Egress = new[]
{
new Aws.Ec2.Inputs.SecurityGroupEgressArgs
{
FromPort = 0,
ToPort = 0,
Protocol = "-1",
CidrBlocks = new[]
{
"0.0.0.0/0",
},
},
},
Name = "aws_batch_compute_environment_security_group",
});
var sampleVpc = new Aws.Ec2.Vpc("sample", new()
{
CidrBlock = "10.1.0.0/16",
});
var sampleSubnet = new Aws.Ec2.Subnet("sample", new()
{
VpcId = sampleVpc.Id,
CidrBlock = "10.1.1.0/24",
});
var samplePlacementGroup = new Aws.Ec2.PlacementGroup("sample", new()
{
Name = "sample",
Strategy = Aws.Ec2.PlacementStrategy.Cluster,
});
var sampleComputeEnvironment = new Aws.Batch.ComputeEnvironment("sample", new()
{
ComputeResources = new Aws.Batch.Inputs.ComputeEnvironmentComputeResourcesArgs
{
InstanceRole = ecsInstanceRoleInstanceProfile.Arn,
InstanceTypes = new[]
{
"c4.large",
},
MaxVcpus = 16,
MinVcpus = 0,
PlacementGroup = samplePlacementGroup.Name,
SecurityGroupIds = new[]
{
sample.Id,
},
Subnets = new[]
{
sampleSubnet.Id,
},
Type = "EC2",
},
Name = "sample",
ServiceRole = awsBatchServiceRole.Arn,
Type = "MANAGED",
}, new CustomResourceOptions
{
DependsOn =
{
awsBatchServiceRoleRolePolicyAttachment,
},
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/batch"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
ec2AssumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
Statements: []iam.GetPolicyDocumentStatement{
{
Principals: []iam.GetPolicyDocumentStatementPrincipal{
{
Type: "Service",
Identifiers: []string{
"ec2.amazonaws.com",
},
},
},
Effect: pulumi.StringRef("Allow"),
Actions: []string{
"sts:AssumeRole",
},
},
},
}, nil)
if err != nil {
return err
}
ecsInstanceRole, err := iam.NewRole(ctx, "ecs_instance_role", &iam.RoleArgs{
Name: pulumi.String("ecs_instance_role"),
AssumeRolePolicy: pulumi.String(ec2AssumeRole.Json),
})
if err != nil {
return err
}
_, err = iam.NewRolePolicyAttachment(ctx, "ecs_instance_role", &iam.RolePolicyAttachmentArgs{
Role: ecsInstanceRole.Name,
PolicyArn: pulumi.String("arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role"),
})
if err != nil {
return err
}
ecsInstanceRoleInstanceProfile, err := iam.NewInstanceProfile(ctx, "ecs_instance_role", &iam.InstanceProfileArgs{
Name: pulumi.String("ecs_instance_role"),
Role: ecsInstanceRole.Name,
})
if err != nil {
return err
}
batchAssumeRole, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
Statements: []iam.GetPolicyDocumentStatement{
{
Principals: []iam.GetPolicyDocumentStatementPrincipal{
{
Type: "Service",
Identifiers: []string{
"batch.amazonaws.com",
},
},
},
Effect: pulumi.StringRef("Allow"),
Actions: []string{
"sts:AssumeRole",
},
},
},
}, nil)
if err != nil {
return err
}
awsBatchServiceRole, err := iam.NewRole(ctx, "aws_batch_service_role", &iam.RoleArgs{
Name: pulumi.String("aws_batch_service_role"),
AssumeRolePolicy: pulumi.String(batchAssumeRole.Json),
})
if err != nil {
return err
}
awsBatchServiceRoleRolePolicyAttachment, err := iam.NewRolePolicyAttachment(ctx, "aws_batch_service_role", &iam.RolePolicyAttachmentArgs{
Role: awsBatchServiceRole.Name,
PolicyArn: pulumi.String("arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole"),
})
if err != nil {
return err
}
sample, err := ec2.NewSecurityGroup(ctx, "sample", &ec2.SecurityGroupArgs{
Egress: ec2.SecurityGroupEgressArray{
&ec2.SecurityGroupEgressArgs{
FromPort: pulumi.Int(0),
ToPort: pulumi.Int(0),
Protocol: pulumi.String("-1"),
CidrBlocks: pulumi.StringArray{
pulumi.String("0.0.0.0/0"),
},
},
},
Name: pulumi.String("aws_batch_compute_environment_security_group"),
})
if err != nil {
return err
}
sampleVpc, err := ec2.NewVpc(ctx, "sample", &ec2.VpcArgs{
CidrBlock: pulumi.String("10.1.0.0/16"),
})
if err != nil {
return err
}
sampleSubnet, err := ec2.NewSubnet(ctx, "sample", &ec2.SubnetArgs{
VpcId: sampleVpc.ID().ToIDOutput().ToStringOutput(),
CidrBlock: pulumi.String("10.1.1.0/24"),
})
if err != nil {
return err
}
samplePlacementGroup, err := ec2.NewPlacementGroup(ctx, "sample", &ec2.PlacementGroupArgs{
Name: pulumi.String("sample"),
Strategy: pulumi.String(ec2.PlacementStrategyCluster),
})
if err != nil {
return err
}
_, err = batch.NewComputeEnvironment(ctx, "sample", &batch.ComputeEnvironmentArgs{
ComputeResources: &batch.ComputeEnvironmentComputeResourcesArgs{
InstanceRole: ecsInstanceRoleInstanceProfile.Arn,
InstanceTypes: pulumi.StringArray{
pulumi.String("c4.large"),
},
MaxVcpus: pulumi.Int(16),
MinVcpus: pulumi.Int(0),
PlacementGroup: samplePlacementGroup.Name,
SecurityGroupIds: pulumi.StringArray{
sample.ID().ToIDOutput().ToStringOutput(),
},
Subnets: pulumi.StringArray{
sampleSubnet.ID().ToIDOutput().ToStringOutput(),
},
Type: pulumi.String("EC2"),
},
Name: pulumi.String("sample"),
ServiceRole: awsBatchServiceRole.Arn,
Type: pulumi.String("MANAGED"),
}, pulumi.DependsOn([]pulumi.Resource{
awsBatchServiceRoleRolePolicyAttachment,
}))
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
data "aws_iam_getpolicydocument" "ec2AssumeRole" {
statements {
principals {
type = "Service"
identifiers = ["ec2.amazonaws.com"]
}
effect = "Allow"
actions = ["sts:AssumeRole"]
}
}
data "aws_iam_getpolicydocument" "batchAssumeRole" {
statements {
principals {
type = "Service"
identifiers = ["batch.amazonaws.com"]
}
effect = "Allow"
actions = ["sts:AssumeRole"]
}
}
resource "aws_iam_role" "ecs_instance_role" {
name = "ecs_instance_role"
assume_role_policy = data.aws_iam_getpolicydocument.ec2AssumeRole.json
}
resource "aws_iam_rolepolicyattachment" "ecs_instance_role" {
role = aws_iam_role.ecs_instance_role.name
policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role"
}
resource "aws_iam_instanceprofile" "ecs_instance_role" {
name = "ecs_instance_role"
role = aws_iam_role.ecs_instance_role.name
}
resource "aws_iam_role" "aws_batch_service_role" {
name = "aws_batch_service_role"
assume_role_policy = data.aws_iam_getpolicydocument.batchAssumeRole.json
}
resource "aws_iam_rolepolicyattachment" "aws_batch_service_role" {
role = aws_iam_role.aws_batch_service_role.name
policy_arn = "arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole"
}
resource "aws_ec2_securitygroup" "sample" {
egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}
name = "aws_batch_compute_environment_security_group"
}
resource "aws_ec2_vpc" "sample" {
cidr_block = "10.1.0.0/16"
}
resource "aws_ec2_subnet" "sample" {
vpc_id = aws_ec2_vpc.sample.id
cidr_block = "10.1.1.0/24"
}
resource "aws_ec2_placementgroup" "sample" {
name = "sample"
strategy = "cluster"
}
resource "aws_batch_computeenvironment" "sample" {
depends_on = [aws_iam_rolepolicyattachment.aws_batch_service_role]
compute_resources = {
instance_role = aws_iam_instanceprofile.ecs_instance_role.arn
instance_types = ["c4.large"]
max_vcpus = 16
min_vcpus = 0
placement_group = aws_ec2_placementgroup.sample.name
security_group_ids = [aws_ec2_securitygroup.sample.id]
subnets = [aws_ec2_subnet.sample.id]
type = "EC2"
}
name = "sample"
service_role = aws_iam_role.aws_batch_service_role.arn
type = "MANAGED"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementArgs;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementPrincipalArgs;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.iam.RolePolicyAttachment;
import com.pulumi.aws.iam.RolePolicyAttachmentArgs;
import com.pulumi.aws.iam.InstanceProfile;
import com.pulumi.aws.iam.InstanceProfileArgs;
import com.pulumi.aws.ec2.SecurityGroup;
import com.pulumi.aws.ec2.SecurityGroupArgs;
import com.pulumi.aws.ec2.inputs.SecurityGroupEgressArgs;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.ec2.Subnet;
import com.pulumi.aws.ec2.SubnetArgs;
import com.pulumi.aws.ec2.PlacementGroup;
import com.pulumi.aws.ec2.PlacementGroupArgs;
import com.pulumi.aws.batch.ComputeEnvironment;
import com.pulumi.aws.batch.ComputeEnvironmentArgs;
import com.pulumi.aws.batch.inputs.ComputeEnvironmentComputeResourcesArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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) {
final var ec2AssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
.statements(GetPolicyDocumentStatementArgs.builder()
.principals(GetPolicyDocumentStatementPrincipalArgs.builder()
.type("Service")
.identifiers("ec2.amazonaws.com")
.build())
.effect("Allow")
.actions("sts:AssumeRole")
.build())
.build());
var ecsInstanceRole = new Role("ecsInstanceRole", RoleArgs.builder()
.name("ecs_instance_role")
.assumeRolePolicy(ec2AssumeRole.json())
.build());
var ecsInstanceRoleRolePolicyAttachment = new RolePolicyAttachment("ecsInstanceRoleRolePolicyAttachment", RolePolicyAttachmentArgs.builder()
.role(ecsInstanceRole.name())
.policyArn("arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role")
.build());
var ecsInstanceRoleInstanceProfile = new InstanceProfile("ecsInstanceRoleInstanceProfile", InstanceProfileArgs.builder()
.name("ecs_instance_role")
.role(ecsInstanceRole.name())
.build());
final var batchAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
.statements(GetPolicyDocumentStatementArgs.builder()
.principals(GetPolicyDocumentStatementPrincipalArgs.builder()
.type("Service")
.identifiers("batch.amazonaws.com")
.build())
.effect("Allow")
.actions("sts:AssumeRole")
.build())
.build());
var awsBatchServiceRole = new Role("awsBatchServiceRole", RoleArgs.builder()
.name("aws_batch_service_role")
.assumeRolePolicy(batchAssumeRole.json())
.build());
var awsBatchServiceRoleRolePolicyAttachment = new RolePolicyAttachment("awsBatchServiceRoleRolePolicyAttachment", RolePolicyAttachmentArgs.builder()
.role(awsBatchServiceRole.name())
.policyArn("arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole")
.build());
var sample = new SecurityGroup("sample", SecurityGroupArgs.builder()
.egress(SecurityGroupEgressArgs.builder()
.fromPort(0)
.toPort(0)
.protocol("-1")
.cidrBlocks("0.0.0.0/0")
.build())
.name("aws_batch_compute_environment_security_group")
.build());
var sampleVpc = new Vpc("sampleVpc", VpcArgs.builder()
.cidrBlock("10.1.0.0/16")
.build());
var sampleSubnet = new Subnet("sampleSubnet", SubnetArgs.builder()
.vpcId(sampleVpc.id())
.cidrBlock("10.1.1.0/24")
.build());
var samplePlacementGroup = new PlacementGroup("samplePlacementGroup", PlacementGroupArgs.builder()
.name("sample")
.strategy("cluster")
.build());
var sampleComputeEnvironment = new ComputeEnvironment("sampleComputeEnvironment", ComputeEnvironmentArgs.builder()
.computeResources(ComputeEnvironmentComputeResourcesArgs.builder()
.instanceRole(ecsInstanceRoleInstanceProfile.arn())
.instanceTypes("c4.large")
.maxVcpus(16)
.minVcpus(0)
.placementGroup(samplePlacementGroup.name())
.securityGroupIds(sample.id())
.subnets(sampleSubnet.id())
.type("EC2")
.build())
.name("sample")
.serviceRole(awsBatchServiceRole.arn())
.type("MANAGED")
.build(), CustomResourceOptions.builder()
.dependsOn(awsBatchServiceRoleRolePolicyAttachment)
.build());
}
}
resources:
ecsInstanceRole:
type: aws:iam:Role
name: ecs_instance_role
properties:
name: ecs_instance_role
assumeRolePolicy: ${ec2AssumeRole.json}
ecsInstanceRoleRolePolicyAttachment:
type: aws:iam:RolePolicyAttachment
name: ecs_instance_role
properties:
role: ${ecsInstanceRole.name}
policyArn: arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role
ecsInstanceRoleInstanceProfile:
type: aws:iam:InstanceProfile
name: ecs_instance_role
properties:
name: ecs_instance_role
role: ${ecsInstanceRole.name}
awsBatchServiceRole:
type: aws:iam:Role
name: aws_batch_service_role
properties:
name: aws_batch_service_role
assumeRolePolicy: ${batchAssumeRole.json}
awsBatchServiceRoleRolePolicyAttachment:
type: aws:iam:RolePolicyAttachment
name: aws_batch_service_role
properties:
role: ${awsBatchServiceRole.name}
policyArn: arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole
sample:
type: aws:ec2:SecurityGroup
properties:
egress:
- fromPort: 0
toPort: 0
protocol: '-1'
cidrBlocks:
- 0.0.0.0/0
name: aws_batch_compute_environment_security_group
sampleVpc:
type: aws:ec2:Vpc
name: sample
properties:
cidrBlock: 10.1.0.0/16
sampleSubnet:
type: aws:ec2:Subnet
name: sample
properties:
vpcId: ${sampleVpc.id}
cidrBlock: 10.1.1.0/24
samplePlacementGroup:
type: aws:ec2:PlacementGroup
name: sample
properties:
name: sample
strategy: cluster
sampleComputeEnvironment:
type: aws:batch:ComputeEnvironment
name: sample
properties:
computeResources:
instanceRole: ${ecsInstanceRoleInstanceProfile.arn}
instanceTypes:
- c4.large
maxVcpus: 16
minVcpus: 0
placementGroup: ${samplePlacementGroup.name}
securityGroupIds:
- ${sample.id}
subnets:
- ${sampleSubnet.id}
type: EC2
name: sample
serviceRole: ${awsBatchServiceRole.arn}
type: MANAGED
options:
dependsOn:
- ${awsBatchServiceRoleRolePolicyAttachment}
variables:
ec2AssumeRole:
fn::invoke:
function: aws:iam:getPolicyDocument
arguments:
statements:
- principals:
- type: Service
identifiers:
- ec2.amazonaws.com
effect: Allow
actions:
- sts:AssumeRole
batchAssumeRole:
fn::invoke:
function: aws:iam:getPolicyDocument
arguments:
statements:
- principals:
- type: Service
identifiers:
- batch.amazonaws.com
effect: Allow
actions:
- sts:AssumeRole
Fargate Type
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const sample = new aws.batch.ComputeEnvironment("sample", {
computeResources: {
maxVcpus: 16,
securityGroupIds: [sampleAwsSecurityGroup.id],
subnets: [sampleAwsSubnet.id],
type: "FARGATE",
},
name: "sample",
serviceRole: awsBatchServiceRoleAwsIamRole.arn,
type: "MANAGED",
}, {
dependsOn: [awsBatchServiceRole],
});
import pulumi
import pulumi_aws as aws
sample = aws.batch.ComputeEnvironment("sample",
compute_resources={
"max_vcpus": 16,
"security_group_ids": [sample_aws_security_group["id"]],
"subnets": [sample_aws_subnet["id"]],
"type": "FARGATE",
},
name="sample",
service_role=aws_batch_service_role_aws_iam_role["arn"],
type="MANAGED",
opts = pulumi.ResourceOptions(depends_on=[aws_batch_service_role]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var sample = new Aws.Batch.ComputeEnvironment("sample", new()
{
ComputeResources = new Aws.Batch.Inputs.ComputeEnvironmentComputeResourcesArgs
{
MaxVcpus = 16,
SecurityGroupIds = new[]
{
sampleAwsSecurityGroup.Id,
},
Subnets = new[]
{
sampleAwsSubnet.Id,
},
Type = "FARGATE",
},
Name = "sample",
ServiceRole = awsBatchServiceRoleAwsIamRole.Arn,
Type = "MANAGED",
}, new CustomResourceOptions
{
DependsOn =
{
awsBatchServiceRole,
},
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/batch"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := batch.NewComputeEnvironment(ctx, "sample", &batch.ComputeEnvironmentArgs{
ComputeResources: &batch.ComputeEnvironmentComputeResourcesArgs{
MaxVcpus: pulumi.Int(16),
SecurityGroupIds: pulumi.StringArray{
sampleAwsSecurityGroup.Id,
},
Subnets: pulumi.StringArray{
sampleAwsSubnet.Id,
},
Type: pulumi.String("FARGATE"),
},
Name: pulumi.String("sample"),
ServiceRole: pulumi.Any(awsBatchServiceRoleAwsIamRole.Arn),
Type: pulumi.String("MANAGED"),
}, pulumi.DependsOn([]pulumi.Resource{
awsBatchServiceRole,
}))
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_batch_computeenvironment" "sample" {
depends_on = [awsBatchServiceRole]
compute_resources = {
max_vcpus = 16
security_group_ids = [sampleAwsSecurityGroup.id]
subnets = [sampleAwsSubnet.id]
type = "FARGATE"
}
name = "sample"
service_role = awsBatchServiceRoleAwsIamRole.arn
type = "MANAGED"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.batch.ComputeEnvironment;
import com.pulumi.aws.batch.ComputeEnvironmentArgs;
import com.pulumi.aws.batch.inputs.ComputeEnvironmentComputeResourcesArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
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 sample = new ComputeEnvironment("sample", ComputeEnvironmentArgs.builder()
.computeResources(ComputeEnvironmentComputeResourcesArgs.builder()
.maxVcpus(16)
.securityGroupIds(sampleAwsSecurityGroup.id())
.subnets(sampleAwsSubnet.id())
.type("FARGATE")
.build())
.name("sample")
.serviceRole(awsBatchServiceRoleAwsIamRole.arn())
.type("MANAGED")
.build(), CustomResourceOptions.builder()
.dependsOn(awsBatchServiceRole)
.build());
}
}
resources:
sample:
type: aws:batch:ComputeEnvironment
properties:
computeResources:
maxVcpus: 16
securityGroupIds:
- ${sampleAwsSecurityGroup.id}
subnets:
- ${sampleAwsSubnet.id}
type: FARGATE
name: sample
serviceRole: ${awsBatchServiceRoleAwsIamRole.arn}
type: MANAGED
options:
dependsOn:
- ${awsBatchServiceRole}
Setting Update Policy
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const sample = new aws.batch.ComputeEnvironment("sample", {
computeResources: {
allocationStrategy: "BEST_FIT_PROGRESSIVE",
instanceRole: ecsInstance.arn,
instanceTypes: ["optimal"],
maxVcpus: 4,
minVcpus: 0,
securityGroupIds: [sampleAwsSecurityGroup.id],
subnets: [sampleAwsSubnet.id],
type: "EC2",
},
updatePolicy: {
jobExecutionTimeoutMinutes: 30,
terminateJobsOnUpdate: false,
},
name: "sample",
type: "MANAGED",
});
import pulumi
import pulumi_aws as aws
sample = aws.batch.ComputeEnvironment("sample",
compute_resources={
"allocation_strategy": "BEST_FIT_PROGRESSIVE",
"instance_role": ecs_instance["arn"],
"instance_types": ["optimal"],
"max_vcpus": 4,
"min_vcpus": 0,
"security_group_ids": [sample_aws_security_group["id"]],
"subnets": [sample_aws_subnet["id"]],
"type": "EC2",
},
update_policy={
"job_execution_timeout_minutes": 30,
"terminate_jobs_on_update": False,
},
name="sample",
type="MANAGED")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var sample = new Aws.Batch.ComputeEnvironment("sample", new()
{
ComputeResources = new Aws.Batch.Inputs.ComputeEnvironmentComputeResourcesArgs
{
AllocationStrategy = "BEST_FIT_PROGRESSIVE",
InstanceRole = ecsInstance.Arn,
InstanceTypes = new[]
{
"optimal",
},
MaxVcpus = 4,
MinVcpus = 0,
SecurityGroupIds = new[]
{
sampleAwsSecurityGroup.Id,
},
Subnets = new[]
{
sampleAwsSubnet.Id,
},
Type = "EC2",
},
UpdatePolicy = new Aws.Batch.Inputs.ComputeEnvironmentUpdatePolicyArgs
{
JobExecutionTimeoutMinutes = 30,
TerminateJobsOnUpdate = false,
},
Name = "sample",
Type = "MANAGED",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/batch"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := batch.NewComputeEnvironment(ctx, "sample", &batch.ComputeEnvironmentArgs{
ComputeResources: &batch.ComputeEnvironmentComputeResourcesArgs{
AllocationStrategy: pulumi.String("BEST_FIT_PROGRESSIVE"),
InstanceRole: pulumi.Any(ecsInstance.Arn),
InstanceTypes: pulumi.StringArray{
pulumi.String("optimal"),
},
MaxVcpus: pulumi.Int(4),
MinVcpus: pulumi.Int(0),
SecurityGroupIds: pulumi.StringArray{
sampleAwsSecurityGroup.Id,
},
Subnets: pulumi.StringArray{
sampleAwsSubnet.Id,
},
Type: pulumi.String("EC2"),
},
UpdatePolicy: &batch.ComputeEnvironmentUpdatePolicyArgs{
JobExecutionTimeoutMinutes: pulumi.Int(30),
TerminateJobsOnUpdate: pulumi.Bool(false),
},
Name: pulumi.String("sample"),
Type: pulumi.String("MANAGED"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_batch_computeenvironment" "sample" {
compute_resources = {
allocation_strategy = "BEST_FIT_PROGRESSIVE"
instance_role = ecsInstance.arn
instance_types = ["optimal"]
max_vcpus = 4
min_vcpus = 0
security_group_ids = [sampleAwsSecurityGroup.id]
subnets = [sampleAwsSubnet.id]
type = "EC2"
}
update_policy = {
job_execution_timeout_minutes = 30
terminate_jobs_on_update = false
}
name = "sample"
type = "MANAGED"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.batch.ComputeEnvironment;
import com.pulumi.aws.batch.ComputeEnvironmentArgs;
import com.pulumi.aws.batch.inputs.ComputeEnvironmentComputeResourcesArgs;
import com.pulumi.aws.batch.inputs.ComputeEnvironmentUpdatePolicyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 sample = new ComputeEnvironment("sample", ComputeEnvironmentArgs.builder()
.computeResources(ComputeEnvironmentComputeResourcesArgs.builder()
.allocationStrategy("BEST_FIT_PROGRESSIVE")
.instanceRole(ecsInstance.arn())
.instanceTypes("optimal")
.maxVcpus(4)
.minVcpus(0)
.securityGroupIds(sampleAwsSecurityGroup.id())
.subnets(sampleAwsSubnet.id())
.type("EC2")
.build())
.updatePolicy(ComputeEnvironmentUpdatePolicyArgs.builder()
.jobExecutionTimeoutMinutes(30)
.terminateJobsOnUpdate(false)
.build())
.name("sample")
.type("MANAGED")
.build());
}
}
resources:
sample:
type: aws:batch:ComputeEnvironment
properties:
computeResources:
allocationStrategy: BEST_FIT_PROGRESSIVE
instanceRole: ${ecsInstance.arn}
instanceTypes:
- optimal
maxVcpus: 4
minVcpus: 0
securityGroupIds:
- ${sampleAwsSecurityGroup.id}
subnets:
- ${sampleAwsSubnet.id}
type: EC2
updatePolicy:
jobExecutionTimeoutMinutes: 30
terminateJobsOnUpdate: false
name: sample
type: MANAGED
Import
Identity Schema
Required
arn(String) ARN of the compute environment.
Using pulumi import, import AWS Batch compute using the name. For example:
$ pulumi import aws:batch/computeEnvironment:ComputeEnvironment sample sample
Constructors
- ComputeEnvironment(String name, {ComputeEnvironmentArgs? args, CustomResourceOptions? options})
-
Creates a new ComputeEnvironment.
nameThe Pulumi resource name.argsArguments used to configure this ComputeEnvironment. The set of arguments for ComputeEnvironment.optionsResource options controlling this resource's behavior. - ComputeEnvironment.reference(String urn)
- Creates a typed reference to an existing ComputeEnvironment resource.
Properties
-
arn
↔ Output<
String> -
ARN of the compute environment.
latefinal
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
computeResources
↔ Output<
ComputeEnvironmentComputeResources> -
Details of the compute resources managed by the compute environment. This parameter is required for managed compute environments. See details below.
latefinal
-
ecsClusterArn
↔ Output<
String> -
ARN of the underlying Amazon ECS cluster used by the compute environment.
latefinal
-
eksConfiguration
↔ Output<
ComputeEnvironmentEksConfiguration?> -
Details for the Amazon EKS cluster that supports the compute environment. See details below.
latefinal
- hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
- isProtected → bool
-
Returns whether this resource is protected from deletion.
no setterinherited
- isRemote → bool
-
Whether this resource is registered as remote.
no setterinherited
- isResourceReference → bool
-
Whether this instance represents a resource value returned over RPC.
finalinherited
-
name
↔ Output<
String> -
The name for your compute environment. Up to 128 letters (uppercase and lowercase), numbers, and underscores are allowed. If omitted, the provider will assign a random, unique name.
latefinal
-
namePrefix
↔ Output<
String> -
Creates a unique compute environment name beginning with the specified prefix. Conflicts with
name.latefinal -
region
↔ Output<
String> -
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
- runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
serviceRole
↔ Output<
String> -
Full ARN of the IAM role that allows AWS Batch to make calls to other AWS services on your behalf.
latefinal
-
state
↔ Output<
String?> -
The state of the compute environment. If the state is
ENABLED, then the compute environment accepts jobs from a queue and can scale out automatically based on queues. Valid items areENABLEDorDISABLED. Defaults toENABLED.latefinal -
status
↔ Output<
String> -
The current status of the compute environment (for example, CREATING or VALID).
latefinal
-
statusReason
↔ Output<
String> -
A short, human-readable string to provide additional details about the current status of the compute environment.
latefinal
-
Key-value map of resource tags. If configured with a provider
defaultTagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.latefinal -
A map of tags assigned to the resource, including those inherited from the provider
defaultTagsconfiguration block.latefinal -
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
type
↔ Output<
String> -
The type of the compute environment. Valid items are
MANAGEDorUNMANAGED.latefinal -
updatePolicy
↔ Output<
ComputeEnvironmentUpdatePolicy> -
Specifies the infrastructure update policy for the compute environment. See details below.
latefinal
-
urn
↔ Output<
String> -
latefinalinherited
Methods
-
failId(
Object error) → void -
Completes this resource ID with an error when registration fails.
inherited
-
failOutputs(
Object error) → void -
Completes all output properties with
error.inherited -
failUrn(
Object error) → void -
Completes this resource URN with an error when registration fails.
inherited
-
getProvider(
String moduleMember) → ProviderResource? -
Returns provider for
moduleMember's package, if configured.inherited -
getResourceName(
) → String -
Returns this resource's logical name.
inherited
-
getResourceType(
) → String -
Returns this resource's Pulumi type token.
inherited
-
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a nonexistent method or property is accessed.
inherited
-
registerOutput<
T> (String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output< T> -
Registers a dynamic output property for this resource.
inherited
-
resolveId(
String? value, {required bool isKnown}) → void -
Resolves the provider-assigned ID for this resource.
inherited
-
resolveOutputs(
Struct outputs) → void -
Resolves all output properties from a monitor response payload.
inherited
-
resolveUrn(
String value) → void -
Resolves this resource's URN once assigned by the engine.
inherited
-
serializeProperties(
Map< String, dynamic> properties) → Future<Struct> -
Serializes resource properties for RPC transmission.
inherited
-
toString(
) → String -
A string representation of this object.
inherited
Operators
-
operator ==(
Object other) → bool -
The equality operator.
inherited
Static Methods
-
get(
String name, Input< String> id, {ComputeEnvironmentState? state, CustomResourceOptions? options}) → ComputeEnvironment -
Gets an existing ComputeEnvironment resource's state with the given
nameandid.