pulumi-aws-kotlin/com.pulumi.aws.ec2.kotlin/InstanceArgs

InstanceArgs

data class InstanceArgs(val ami: Output<String>? = null, val associatePublicIpAddress: Output<Boolean>? = null, val availabilityZone: Output<String>? = null, val capacityReservationSpecification: Output<InstanceCapacityReservationSpecificationArgs>? = null, val cpuCoreCount: Output<Int>? = null, val cpuOptions: Output<InstanceCpuOptionsArgs>? = null, val cpuThreadsPerCore: Output<Int>? = null, val creditSpecification: Output<InstanceCreditSpecificationArgs>? = null, val disableApiStop: Output<Boolean>? = null, val disableApiTermination: Output<Boolean>? = null, val ebsBlockDevices: Output<List<InstanceEbsBlockDeviceArgs>>? = null, val ebsOptimized: Output<Boolean>? = null, val enablePrimaryIpv6: Output<Boolean>? = null, val enclaveOptions: Output<InstanceEnclaveOptionsArgs>? = null, val ephemeralBlockDevices: Output<List<InstanceEphemeralBlockDeviceArgs>>? = null, val getPasswordData: Output<Boolean>? = null, val hibernation: Output<Boolean>? = null, val hostId: Output<String>? = null, val hostResourceGroupArn: Output<String>? = null, val iamInstanceProfile: Output<String>? = null, val instanceInitiatedShutdownBehavior: Output<String>? = null, val instanceMarketOptions: Output<InstanceInstanceMarketOptionsArgs>? = null, val instanceType: Output<Either<String, InstanceType>>? = null, val ipv6AddressCount: Output<Int>? = null, val ipv6Addresses: Output<List<String>>? = null, val keyName: Output<String>? = null, val launchTemplate: Output<InstanceLaunchTemplateArgs>? = null, val maintenanceOptions: Output<InstanceMaintenanceOptionsArgs>? = null, val metadataOptions: Output<InstanceMetadataOptionsArgs>? = null, val monitoring: Output<Boolean>? = null, val networkInterfaces: Output<List<InstanceNetworkInterfaceArgs>>? = null, val placementGroup: Output<String>? = null, val placementPartitionNumber: Output<Int>? = null, val privateDnsNameOptions: Output<InstancePrivateDnsNameOptionsArgs>? = null, val privateIp: Output<String>? = null, val rootBlockDevice: Output<InstanceRootBlockDeviceArgs>? = null, val secondaryPrivateIps: Output<List<String>>? = null, val securityGroups: Output<List<String>>? = null, val sourceDestCheck: Output<Boolean>? = null, val subnetId: Output<String>? = null, val tags: Output<Map<String, String>>? = null, val tenancy: Output<Either<String, Tenancy>>? = null, val userData: Output<String>? = null, val userDataBase64: Output<String>? = null, val userDataReplaceOnChange: Output<Boolean>? = null, val volumeTags: Output<Map<String, String>>? = null, val vpcSecurityGroupIds: Output<List<String>>? = null) : ConvertibleToJava<InstanceArgs>

Provides an EC2 instance resource. This allows instances to be created, updated, and deleted.

Example Usage

Basic example using AMI lookup

Using a data source

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const ubuntu = aws.ec2.getAmi({
    mostRecent: true,
    filters: [
        {
            name: "name",
            values: ["ubuntu/images/hvm-ssd/ubuntu-jammy-22&#46;04-amd64-server-*"],
        },
        {
            name: "virtualization-type",
            values: ["hvm"],
        },
    ],
    owners: ["099720109477"],
});
const web = new aws.ec2.Instance("web", {
    ami: ubuntu.then(ubuntu => ubuntu.id),
    instanceType: aws.ec2.InstanceType.T3_Micro,
    tags: {
        Name: "HelloWorld",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
ubuntu = aws.ec2.get_ami(most_recent=True,
    filters=[
        {
            "name": "name",
            "values": ["ubuntu/images/hvm-ssd/ubuntu-jammy-22&#46;04-amd64-server-*"],
        },
        {
            "name": "virtualization-type",
            "values": ["hvm"],
        },
    ],
    owners=["099720109477"])
web = aws.ec2.Instance("web",
    ami=ubuntu.id,
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    tags={
        "Name": "HelloWorld",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var ubuntu = Aws.Ec2.GetAmi.Invoke(new()
    {
        MostRecent = true,
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "name",
                Values = new[]
                {
                    "ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*",
                },
            },
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "virtualization-type",
                Values = new[]
                {
                    "hvm",
                },
            },
        },
        Owners = new[]
        {
            "099720109477",
        },
    });
    var web = new Aws.Ec2.Instance("web", new()
    {
        Ami = ubuntu.Apply(getAmiResult => getAmiResult.Id),
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        Tags =
        {
            { "Name", "HelloWorld" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ubuntu, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
			MostRecent: pulumi.BoolRef(true),
			Filters: []ec2.GetAmiFilter{
				{
					Name: "name",
					Values: []string{
						"ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*",
					},
				},
				{
					Name: "virtualization-type",
					Values: []string{
						"hvm",
					},
				},
			},
			Owners: []string{
				"099720109477",
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = ec2.NewInstance(ctx, "web", &ec2.InstanceArgs{
			Ami:          pulumi.String(ubuntu.Id),
			InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("HelloWorld"),
			},
		})
		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.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetAmiArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
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) {
        final var ubuntu = Ec2Functions.getAmi(GetAmiArgs.builder()
            .mostRecent(true)
            .filters(
                GetAmiFilterArgs.builder()
                    .name("name")
                    .values("ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*")
                    .build(),
                GetAmiFilterArgs.builder()
                    .name("virtualization-type")
                    .values("hvm")
                    .build())
            .owners("099720109477")
            .build());
        var web = new Instance("web", InstanceArgs.builder()
            .ami(ubuntu.id())
            .instanceType("t3.micro")
            .tags(Map.of("Name", "HelloWorld"))
            .build());
    }
}
Content copied to clipboard
resources:
  web:
    type: aws:ec2:Instance
    properties:
      ami: ${ubuntu.id}
      instanceType: t3.micro
      tags:
        Name: HelloWorld
variables:
  ubuntu:
    fn::invoke:
      function: aws:ec2:getAmi
      arguments:
        mostRecent: true
        filters:
          - name: name
            values:
              - ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*
          - name: virtualization-type
            values:
              - hvm
        owners:
          - '099720109477'
Content copied to clipboard

Using AWS Systems Manager Parameter Store

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const web = new aws.ec2.Instance("web", {
    ami: "resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64",
    instanceType: aws.ec2.InstanceType.T3_Micro,
    tags: {
        Name: "HelloWorld",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
web = aws.ec2.Instance("web",
    ami="resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64",
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    tags={
        "Name": "HelloWorld",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var web = new Aws.Ec2.Instance("web", new()
    {
        Ami = "resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64",
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        Tags =
        {
            { "Name", "HelloWorld" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewInstance(ctx, "web", &ec2.InstanceArgs{
			Ami:          pulumi.String("resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64"),
			InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("HelloWorld"),
			},
		})
		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.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
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 web = new Instance("web", InstanceArgs.builder()
            .ami("resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64")
            .instanceType("t3.micro")
            .tags(Map.of("Name", "HelloWorld"))
            .build());
    }
}
Content copied to clipboard
resources:
  web:
    type: aws:ec2:Instance
    properties:
      ami: resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64
      instanceType: t3.micro
      tags:
        Name: HelloWorld
Content copied to clipboard

Spot instance example

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const _this = aws.ec2.getAmi({
    mostRecent: true,
    owners: ["amazon"],
    filters: [
        {
            name: "architecture",
            values: ["arm64"],
        },
        {
            name: "name",
            values: ["al2023-ami-2023*"],
        },
    ],
});
const thisInstance = new aws.ec2.Instance("this", {
    ami: _this.then(_this => _this.id),
    instanceMarketOptions: {
        marketType: "spot",
        spotOptions: {
            maxPrice: "0.0031",
        },
    },
    instanceType: aws.ec2.InstanceType.T4g_Nano,
    tags: {
        Name: "test-spot",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
this = aws.ec2.get_ami(most_recent=True,
    owners=["amazon"],
    filters=[
        {
            "name": "architecture",
            "values": ["arm64"],
        },
        {
            "name": "name",
            "values": ["al2023-ami-2023*"],
        },
    ])
this_instance = aws.ec2.Instance("this",
    ami=this.id,
    instance_market_options={
        "market_type": "spot",
        "spot_options": {
            "max_price": "0.0031",
        },
    },
    instance_type=aws.ec2.InstanceType.T4G_NANO,
    tags={
        "Name": "test-spot",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var @this = Aws.Ec2.GetAmi.Invoke(new()
    {
        MostRecent = true,
        Owners = new[]
        {
            "amazon",
        },
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "architecture",
                Values = new[]
                {
                    "arm64",
                },
            },
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "name",
                Values = new[]
                {
                    "al2023-ami-2023*",
                },
            },
        },
    });
    var thisInstance = new Aws.Ec2.Instance("this", new()
    {
        Ami = @this.Apply(@this => @this.Apply(getAmiResult => getAmiResult.Id)),
        InstanceMarketOptions = new Aws.Ec2.Inputs.InstanceInstanceMarketOptionsArgs
        {
            MarketType = "spot",
            SpotOptions = new Aws.Ec2.Inputs.InstanceInstanceMarketOptionsSpotOptionsArgs
            {
                MaxPrice = "0.0031",
            },
        },
        InstanceType = Aws.Ec2.InstanceType.T4g_Nano,
        Tags =
        {
            { "Name", "test-spot" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
			MostRecent: pulumi.BoolRef(true),
			Owners: []string{
				"amazon",
			},
			Filters: []ec2.GetAmiFilter{
				{
					Name: "architecture",
					Values: []string{
						"arm64",
					},
				},
				{
					Name: "name",
					Values: []string{
						"al2023-ami-2023*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = ec2.NewInstance(ctx, "this", &ec2.InstanceArgs{
			Ami: pulumi.String(this.Id),
			InstanceMarketOptions: &ec2.InstanceInstanceMarketOptionsArgs{
				MarketType: pulumi.String("spot"),
				SpotOptions: &ec2.InstanceInstanceMarketOptionsSpotOptionsArgs{
					MaxPrice: pulumi.String("0.0031"),
				},
			},
			InstanceType: pulumi.String(ec2.InstanceType_T4g_Nano),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("test-spot"),
			},
		})
		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.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetAmiArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
import com.pulumi.aws.ec2.inputs.InstanceInstanceMarketOptionsArgs;
import com.pulumi.aws.ec2.inputs.InstanceInstanceMarketOptionsSpotOptionsArgs;
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) {
        final var this = Ec2Functions.getAmi(GetAmiArgs.builder()
            .mostRecent(true)
            .owners("amazon")
            .filters(
                GetAmiFilterArgs.builder()
                    .name("architecture")
                    .values("arm64")
                    .build(),
                GetAmiFilterArgs.builder()
                    .name("name")
                    .values("al2023-ami-2023*")
                    .build())
            .build());
        var thisInstance = new Instance("thisInstance", InstanceArgs.builder()
            .ami(this_.id())
            .instanceMarketOptions(InstanceInstanceMarketOptionsArgs.builder()
                .marketType("spot")
                .spotOptions(InstanceInstanceMarketOptionsSpotOptionsArgs.builder()
                    .maxPrice("0.0031")
                    .build())
                .build())
            .instanceType("t4g.nano")
            .tags(Map.of("Name", "test-spot"))
            .build());
    }
}
Content copied to clipboard
resources:
  thisInstance:
    type: aws:ec2:Instance
    name: this
    properties:
      ami: ${this.id}
      instanceMarketOptions:
        marketType: spot
        spotOptions:
          maxPrice: 0.0031
      instanceType: t4g.nano
      tags:
        Name: test-spot
variables:
  this:
    fn::invoke:
      function: aws:ec2:getAmi
      arguments:
        mostRecent: true
        owners:
          - amazon
        filters:
          - name: architecture
            values:
              - arm64
          - name: name
            values:
              - al2023-ami-2023*
Content copied to clipboard

Network and credit specification example

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const myVpc = new aws.ec2.Vpc("my_vpc", {
    cidrBlock: "172.16.0.0/16",
    tags: {
        Name: "tf-example",
    },
});
const mySubnet = new aws.ec2.Subnet("my_subnet", {
    vpcId: myVpc.id,
    cidrBlock: "172.16.10.0/24",
    availabilityZone: "us-west-2a",
    tags: {
        Name: "tf-example",
    },
});
const foo = new aws.ec2.NetworkInterface("foo", {
    subnetId: mySubnet.id,
    privateIps: ["172&#46;16&#46;10&#46;100"],
    tags: {
        Name: "primary_network_interface",
    },
});
const fooInstance = new aws.ec2.Instance("foo", {
    ami: "ami-005e54dee72cc1d00",
    instanceType: aws.ec2.InstanceType.T2_Micro,
    networkInterfaces: [{
        networkInterfaceId: foo.id,
        deviceIndex: 0,
    }],
    creditSpecification: {
        cpuCredits: "unlimited",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
my_vpc = aws.ec2.Vpc("my_vpc",
    cidr_block="172.16.0.0/16",
    tags={
        "Name": "tf-example",
    })
my_subnet = aws.ec2.Subnet("my_subnet",
    vpc_id=my_vpc.id,
    cidr_block="172.16.10.0/24",
    availability_zone="us-west-2a",
    tags={
        "Name": "tf-example",
    })
foo = aws.ec2.NetworkInterface("foo",
    subnet_id=my_subnet.id,
    private_ips=["172&#46;16&#46;10&#46;100"],
    tags={
        "Name": "primary_network_interface",
    })
foo_instance = aws.ec2.Instance("foo",
    ami="ami-005e54dee72cc1d00",
    instance_type=aws.ec2.InstanceType.T2_MICRO,
    network_interfaces=[{
        "network_interface_id": foo.id,
        "device_index": 0,
    }],
    credit_specification={
        "cpu_credits": "unlimited",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var myVpc = new Aws.Ec2.Vpc("my_vpc", new()
    {
        CidrBlock = "172.16.0.0/16",
        Tags =
        {
            { "Name", "tf-example" },
        },
    });
    var mySubnet = new Aws.Ec2.Subnet("my_subnet", new()
    {
        VpcId = myVpc.Id,
        CidrBlock = "172.16.10.0/24",
        AvailabilityZone = "us-west-2a",
        Tags =
        {
            { "Name", "tf-example" },
        },
    });
    var foo = new Aws.Ec2.NetworkInterface("foo", new()
    {
        SubnetId = mySubnet.Id,
        PrivateIps = new[]
        {
            "172.16.10.100",
        },
        Tags =
        {
            { "Name", "primary_network_interface" },
        },
    });
    var fooInstance = new Aws.Ec2.Instance("foo", new()
    {
        Ami = "ami-005e54dee72cc1d00",
        InstanceType = Aws.Ec2.InstanceType.T2_Micro,
        NetworkInterfaces = new[]
        {
            new Aws.Ec2.Inputs.InstanceNetworkInterfaceArgs
            {
                NetworkInterfaceId = foo.Id,
                DeviceIndex = 0,
            },
        },
        CreditSpecification = new Aws.Ec2.Inputs.InstanceCreditSpecificationArgs
        {
            CpuCredits = "unlimited",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myVpc, err := ec2.NewVpc(ctx, "my_vpc", &ec2.VpcArgs{
			CidrBlock: pulumi.String("172.16.0.0/16"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-example"),
			},
		})
		if err != nil {
			return err
		}
		mySubnet, err := ec2.NewSubnet(ctx, "my_subnet", &ec2.SubnetArgs{
			VpcId:            myVpc.ID(),
			CidrBlock:        pulumi.String("172.16.10.0/24"),
			AvailabilityZone: pulumi.String("us-west-2a"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-example"),
			},
		})
		if err != nil {
			return err
		}
		foo, err := ec2.NewNetworkInterface(ctx, "foo", &ec2.NetworkInterfaceArgs{
			SubnetId: mySubnet.ID(),
			PrivateIps: pulumi.StringArray{
				pulumi.String("172.16.10.100"),
			},
			Tags: pulumi.StringMap{
				"Name": pulumi.String("primary_network_interface"),
			},
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewInstance(ctx, "foo", &ec2.InstanceArgs{
			Ami:          pulumi.String("ami-005e54dee72cc1d00"),
			InstanceType: pulumi.String(ec2.InstanceType_T2_Micro),
			NetworkInterfaces: ec2.InstanceNetworkInterfaceArray{
				&ec2.InstanceNetworkInterfaceArgs{
					NetworkInterfaceId: foo.ID(),
					DeviceIndex:        pulumi.Int(0),
				},
			},
			CreditSpecification: &ec2.InstanceCreditSpecificationArgs{
				CpuCredits: pulumi.String("unlimited"),
			},
		})
		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.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.NetworkInterface;
import com.pulumi.aws.ec2.NetworkInterfaceArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
import com.pulumi.aws.ec2.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.aws.ec2.inputs.InstanceCreditSpecificationArgs;
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 myVpc = new Vpc("myVpc", VpcArgs.builder()
            .cidrBlock("172.16.0.0/16")
            .tags(Map.of("Name", "tf-example"))
            .build());
        var mySubnet = new Subnet("mySubnet", SubnetArgs.builder()
            .vpcId(myVpc.id())
            .cidrBlock("172.16.10.0/24")
            .availabilityZone("us-west-2a")
            .tags(Map.of("Name", "tf-example"))
            .build());
        var foo = new NetworkInterface("foo", NetworkInterfaceArgs.builder()
            .subnetId(mySubnet.id())
            .privateIps("172.16.10.100")
            .tags(Map.of("Name", "primary_network_interface"))
            .build());
        var fooInstance = new Instance("fooInstance", InstanceArgs.builder()
            .ami("ami-005e54dee72cc1d00")
            .instanceType("t2.micro")
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .networkInterfaceId(foo.id())
                .deviceIndex(0)
                .build())
            .creditSpecification(InstanceCreditSpecificationArgs.builder()
                .cpuCredits("unlimited")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  myVpc:
    type: aws:ec2:Vpc
    name: my_vpc
    properties:
      cidrBlock: 172.16.0.0/16
      tags:
        Name: tf-example
  mySubnet:
    type: aws:ec2:Subnet
    name: my_subnet
    properties:
      vpcId: ${myVpc.id}
      cidrBlock: 172.16.10.0/24
      availabilityZone: us-west-2a
      tags:
        Name: tf-example
  foo:
    type: aws:ec2:NetworkInterface
    properties:
      subnetId: ${mySubnet.id}
      privateIps:
        - 172.16.10.100
      tags:
        Name: primary_network_interface
  fooInstance:
    type: aws:ec2:Instance
    name: foo
    properties:
      ami: ami-005e54dee72cc1d00
      instanceType: t2.micro
      networkInterfaces:
        - networkInterfaceId: ${foo.id}
          deviceIndex: 0
      creditSpecification:
        cpuCredits: unlimited
Content copied to clipboard

CPU options example

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.ec2.Vpc("example", {
    cidrBlock: "172.16.0.0/16",
    tags: {
        Name: "tf-example",
    },
});
const exampleSubnet = new aws.ec2.Subnet("example", {
    vpcId: example.id,
    cidrBlock: "172.16.10.0/24",
    availabilityZone: "us-east-2a",
    tags: {
        Name: "tf-example",
    },
});
const amzn_linux_2023_ami = aws.ec2.getAmi({
    mostRecent: true,
    owners: ["amazon"],
    filters: [{
        name: "name",
        values: ["al2023-ami-2023&#46;*-x86_64"],
    }],
});
const exampleInstance = new aws.ec2.Instance("example", {
    ami: amzn_linux_2023_ami.then(amzn_linux_2023_ami => amzn_linux_2023_ami.id),
    instanceType: aws.ec2.InstanceType.C6a_2XLarge,
    subnetId: exampleSubnet.id,
    cpuOptions: {
        coreCount: 2,
        threadsPerCore: 2,
    },
    tags: {
        Name: "tf-example",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.ec2.Vpc("example",
    cidr_block="172.16.0.0/16",
    tags={
        "Name": "tf-example",
    })
example_subnet = aws.ec2.Subnet("example",
    vpc_id=example.id,
    cidr_block="172.16.10.0/24",
    availability_zone="us-east-2a",
    tags={
        "Name": "tf-example",
    })
amzn_linux_2023_ami = aws.ec2.get_ami(most_recent=True,
    owners=["amazon"],
    filters=[{
        "name": "name",
        "values": ["al2023-ami-2023&#46;*-x86_64"],
    }])
example_instance = aws.ec2.Instance("example",
    ami=amzn_linux_2023_ami.id,
    instance_type=aws.ec2.InstanceType.C6A_2_X_LARGE,
    subnet_id=example_subnet.id,
    cpu_options={
        "core_count": 2,
        "threads_per_core": 2,
    },
    tags={
        "Name": "tf-example",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.Vpc("example", new()
    {
        CidrBlock = "172.16.0.0/16",
        Tags =
        {
            { "Name", "tf-example" },
        },
    });
    var exampleSubnet = new Aws.Ec2.Subnet("example", new()
    {
        VpcId = example.Id,
        CidrBlock = "172.16.10.0/24",
        AvailabilityZone = "us-east-2a",
        Tags =
        {
            { "Name", "tf-example" },
        },
    });
    var amzn_linux_2023_ami = Aws.Ec2.GetAmi.Invoke(new()
    {
        MostRecent = true,
        Owners = new[]
        {
            "amazon",
        },
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "name",
                Values = new[]
                {
                    "al2023-ami-2023.*-x86_64",
                },
            },
        },
    });
    var exampleInstance = new Aws.Ec2.Instance("example", new()
    {
        Ami = amzn_linux_2023_ami.Apply(amzn_linux_2023_ami => amzn_linux_2023_ami.Apply(getAmiResult => getAmiResult.Id)),
        InstanceType = Aws.Ec2.InstanceType.C6a_2XLarge,
        SubnetId = exampleSubnet.Id,
        CpuOptions = new Aws.Ec2.Inputs.InstanceCpuOptionsArgs
        {
            CoreCount = 2,
            ThreadsPerCore = 2,
        },
        Tags =
        {
            { "Name", "tf-example" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewVpc(ctx, "example", &ec2.VpcArgs{
			CidrBlock: pulumi.String("172.16.0.0/16"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-example"),
			},
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := ec2.NewSubnet(ctx, "example", &ec2.SubnetArgs{
			VpcId:            example.ID(),
			CidrBlock:        pulumi.String("172.16.10.0/24"),
			AvailabilityZone: pulumi.String("us-east-2a"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-example"),
			},
		})
		if err != nil {
			return err
		}
		amzn_linux_2023_ami, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
			MostRecent: pulumi.BoolRef(true),
			Owners: []string{
				"amazon",
			},
			Filters: []ec2.GetAmiFilter{
				{
					Name: "name",
					Values: []string{
						"al2023-ami-2023.*-x86_64",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = ec2.NewInstance(ctx, "example", &ec2.InstanceArgs{
			Ami:          pulumi.String(amzn_linux_2023_ami.Id),
			InstanceType: pulumi.String(ec2.InstanceType_C6a_2XLarge),
			SubnetId:     exampleSubnet.ID(),
			CpuOptions: &ec2.InstanceCpuOptionsArgs{
				CoreCount:      pulumi.Int(2),
				ThreadsPerCore: pulumi.Int(2),
			},
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-example"),
			},
		})
		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.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.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetAmiArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
import com.pulumi.aws.ec2.inputs.InstanceCpuOptionsArgs;
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 Vpc("example", VpcArgs.builder()
            .cidrBlock("172.16.0.0/16")
            .tags(Map.of("Name", "tf-example"))
            .build());
        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()
            .vpcId(example.id())
            .cidrBlock("172.16.10.0/24")
            .availabilityZone("us-east-2a")
            .tags(Map.of("Name", "tf-example"))
            .build());
        final var amzn-linux-2023-ami = Ec2Functions.getAmi(GetAmiArgs.builder()
            .mostRecent(true)
            .owners("amazon")
            .filters(GetAmiFilterArgs.builder()
                .name("name")
                .values("al2023-ami-2023.*-x86_64")
                .build())
            .build());
        var exampleInstance = new Instance("exampleInstance", InstanceArgs.builder()
            .ami(amzn_linux_2023_ami.id())
            .instanceType("c6a.2xlarge")
            .subnetId(exampleSubnet.id())
            .cpuOptions(InstanceCpuOptionsArgs.builder()
                .coreCount(2)
                .threadsPerCore(2)
                .build())
            .tags(Map.of("Name", "tf-example"))
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 172.16.0.0/16
      tags:
        Name: tf-example
  exampleSubnet:
    type: aws:ec2:Subnet
    name: example
    properties:
      vpcId: ${example.id}
      cidrBlock: 172.16.10.0/24
      availabilityZone: us-east-2a
      tags:
        Name: tf-example
  exampleInstance:
    type: aws:ec2:Instance
    name: example
    properties:
      ami: ${["amzn-linux-2023-ami"].id}
      instanceType: c6a.2xlarge
      subnetId: ${exampleSubnet.id}
      cpuOptions:
        coreCount: 2
        threadsPerCore: 2
      tags:
        Name: tf-example
variables:
  amzn-linux-2023-ami:
    fn::invoke:
      function: aws:ec2:getAmi
      arguments:
        mostRecent: true
        owners:
          - amazon
        filters:
          - name: name
            values:
              - al2023-ami-2023.*-x86_64
Content copied to clipboard

Host resource group or License Manager registered AMI example

A host resource group is a collection of Dedicated Hosts that you can manage as a single entity. As you launch instances, License Manager allocates the hosts and launches instances on them based on the settings that you configured. You can add existing Dedicated Hosts to a host resource group and take advantage of automated host management through License Manager.

NOTE: A dedicated host is automatically associated with a License Manager host resource group if Allocate hosts automatically is enabled. Otherwise, use the host_resource_group_arn argument to explicitly associate the instance with the host resource group.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const _this = new aws.ec2.Instance("this", {
    ami: "ami-0dcc1e21636832c5d",
    instanceType: aws.ec2.InstanceType.M5_Large,
    hostResourceGroupArn: "arn:aws:resource-groups:us-west-2:123456789012:group/win-testhost",
    tenancy: "host",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
this = aws.ec2.Instance("this",
    ami="ami-0dcc1e21636832c5d",
    instance_type=aws.ec2.InstanceType.M5_LARGE,
    host_resource_group_arn="arn:aws:resource-groups:us-west-2:123456789012:group/win-testhost",
    tenancy="host")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var @this = new Aws.Ec2.Instance("this", new()
    {
        Ami = "ami-0dcc1e21636832c5d",
        InstanceType = Aws.Ec2.InstanceType.M5_Large,
        HostResourceGroupArn = "arn:aws:resource-groups:us-west-2:123456789012:group/win-testhost",
        Tenancy = "host",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewInstance(ctx, "this", &ec2.InstanceArgs{
			Ami:                  pulumi.String("ami-0dcc1e21636832c5d"),
			InstanceType:         pulumi.String(ec2.InstanceType_M5_Large),
			HostResourceGroupArn: pulumi.String("arn:aws:resource-groups:us-west-2:123456789012:group/win-testhost"),
			Tenancy:              pulumi.String("host"),
		})
		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.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
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 this_ = new Instance("this", InstanceArgs.builder()
            .ami("ami-0dcc1e21636832c5d")
            .instanceType("m5.large")
            .hostResourceGroupArn("arn:aws:resource-groups:us-west-2:123456789012:group/win-testhost")
            .tenancy("host")
            .build());
    }
}
Content copied to clipboard
resources:
  this:
    type: aws:ec2:Instance
    properties:
      ami: ami-0dcc1e21636832c5d
      instanceType: m5.large
      hostResourceGroupArn: arn:aws:resource-groups:us-west-2:123456789012:group/win-testhost
      tenancy: host
Content copied to clipboard

Tag Guide

These are the five types of tags you might encounter relative to an aws.ec2.Instance:

  1. Instance tags: Applied to instances but not to ebs_block_device and root_block_device volumes.

  2. Default tags: Applied to the instance and to ebs_block_device and root_block_device volumes.

  3. Volume tags: Applied during creation to ebs_block_device and root_block_device volumes.

  4. Root block device tags: Applied only to the root_block_device volume. These conflict with volume_tags.

  5. EBS block device tags: Applied only to the specific ebs_block_device volume you configure them for and cannot be updated. These conflict with volume_tags. Do not use volume_tags if you plan to manage block device tags outside the aws.ec2.Instance configuration, such as using tags in an aws.ebs.Volume resource attached via aws.ec2.VolumeAttachment. Doing so will result in resource cycling and inconsistent behavior.

Import

Using pulumi import, import instances using the id. For example:

$ pulumi import aws:ec2/instance:Instance web i-12345678
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(ami: Output<String>? = null, associatePublicIpAddress: Output<Boolean>? = null, availabilityZone: Output<String>? = null, capacityReservationSpecification: Output<InstanceCapacityReservationSpecificationArgs>? = null, cpuCoreCount: Output<Int>? = null, cpuOptions: Output<InstanceCpuOptionsArgs>? = null, cpuThreadsPerCore: Output<Int>? = null, creditSpecification: Output<InstanceCreditSpecificationArgs>? = null, disableApiStop: Output<Boolean>? = null, disableApiTermination: Output<Boolean>? = null, ebsBlockDevices: Output<List<InstanceEbsBlockDeviceArgs>>? = null, ebsOptimized: Output<Boolean>? = null, enablePrimaryIpv6: Output<Boolean>? = null, enclaveOptions: Output<InstanceEnclaveOptionsArgs>? = null, ephemeralBlockDevices: Output<List<InstanceEphemeralBlockDeviceArgs>>? = null, getPasswordData: Output<Boolean>? = null, hibernation: Output<Boolean>? = null, hostId: Output<String>? = null, hostResourceGroupArn: Output<String>? = null, iamInstanceProfile: Output<String>? = null, instanceInitiatedShutdownBehavior: Output<String>? = null, instanceMarketOptions: Output<InstanceInstanceMarketOptionsArgs>? = null, instanceType: Output<Either<String, InstanceType>>? = null, ipv6AddressCount: Output<Int>? = null, ipv6Addresses: Output<List<String>>? = null, keyName: Output<String>? = null, launchTemplate: Output<InstanceLaunchTemplateArgs>? = null, maintenanceOptions: Output<InstanceMaintenanceOptionsArgs>? = null, metadataOptions: Output<InstanceMetadataOptionsArgs>? = null, monitoring: Output<Boolean>? = null, networkInterfaces: Output<List<InstanceNetworkInterfaceArgs>>? = null, placementGroup: Output<String>? = null, placementPartitionNumber: Output<Int>? = null, privateDnsNameOptions: Output<InstancePrivateDnsNameOptionsArgs>? = null, privateIp: Output<String>? = null, rootBlockDevice: Output<InstanceRootBlockDeviceArgs>? = null, secondaryPrivateIps: Output<List<String>>? = null, securityGroups: Output<List<String>>? = null, sourceDestCheck: Output<Boolean>? = null, subnetId: Output<String>? = null, tags: Output<Map<String, String>>? = null, tenancy: Output<Either<String, Tenancy>>? = null, userData: Output<String>? = null, userDataBase64: Output<String>? = null, userDataReplaceOnChange: Output<Boolean>? = null, volumeTags: Output<Map<String, String>>? = null, vpcSecurityGroupIds: Output<List<String>>? = null)

Properties

Link copied to clipboard
val ami: Output<String>? = null

AMI to use for the instance. Required unless launch_template is specified and the Launch Template specifes an AMI. If an AMI is specified in the Launch Template, setting ami will override the AMI specified in the Launch Template.

Link copied to clipboard
val associatePublicIpAddress: Output<Boolean>? = null

Whether to associate a public IP address with an instance in a VPC.

Link copied to clipboard
val availabilityZone: Output<String>? = null

AZ to start the instance in.

Link copied to clipboard
val capacityReservationSpecification: Output<InstanceCapacityReservationSpecificationArgs>? = null

Describes an instance's Capacity Reservation targeting option. See Capacity Reservation Specification below for more details.

Link copied to clipboard
val cpuCoreCount: Output<Int>? = null

Sets the number of CPU cores for an instance. This option is only supported on creation of instance type that support CPU Options CPU Cores and Threads Per CPU Core Per Instance Type - specifying this option for unsupported instance types will return an error from the EC2 API.

Link copied to clipboard
val cpuOptions: Output<InstanceCpuOptionsArgs>? = null

The CPU options for the instance. See CPU Options below for more details.

Link copied to clipboard
val cpuThreadsPerCore: Output<Int>? = null

If set to 1, hyperthreading is disabled on the launched instance. Defaults to 2 if not set. See Optimizing CPU Options for more information.

Link copied to clipboard
val creditSpecification: Output<InstanceCreditSpecificationArgs>? = null

Configuration block for customizing the credit specification of the instance. See Credit Specification below for more details. This provider will only perform drift detection of its value when present in a configuration. Removing this configuration on existing instances will only stop managing it. It will not change the configuration back to the default for the instance type.

Link copied to clipboard
val disableApiStop: Output<Boolean>? = null

If true, enables EC2 Instance Stop Protection.

Link copied to clipboard
val disableApiTermination: Output<Boolean>? = null

If true, enables EC2 Instance Termination Protection.

Link copied to clipboard
val ebsBlockDevices: Output<List<InstanceEbsBlockDeviceArgs>>? = null

One or more configuration blocks with additional EBS block devices to attach to the instance. Block device configurations only apply on resource creation. See Block Devices below for details on attributes and drift detection. When accessing this as an attribute reference, it is a set of objects.

Link copied to clipboard
val ebsOptimized: Output<Boolean>? = null

If true, the launched EC2 instance will be EBS-optimized. Note that if this is not set on an instance type that is optimized by default then this will show as disabled but if the instance type is optimized by default then there is no need to set this and there is no effect to disabling it. See the EBS Optimized section of the AWS User Guide for more information.

Link copied to clipboard
val enablePrimaryIpv6: Output<Boolean>? = null

Whether to assign a primary IPv6 Global Unicast Address (GUA) to the instance when launched in a dual-stack or IPv6-only subnet. A primary IPv6 address ensures a consistent IPv6 address for the instance and is automatically assigned by AWS to the ENI. Once enabled, the first IPv6 GUA becomes the primary IPv6 address and cannot be disabled. The primary IPv6 address remains until the instance is terminated or the ENI is detached. Disabling enable_primary_ipv6 after it has been enabled forces recreation of the instance.

Link copied to clipboard
val enclaveOptions: Output<InstanceEnclaveOptionsArgs>? = null

Enable Nitro Enclaves on launched instances. See Enclave Options below for more details.

Link copied to clipboard
val ephemeralBlockDevices: Output<List<InstanceEphemeralBlockDeviceArgs>>? = null

One or more configuration blocks to customize Ephemeral (also known as "Instance Store") volumes on the instance. See Block Devices below for details. When accessing this as an attribute reference, it is a set of objects.

Link copied to clipboard
val getPasswordData: Output<Boolean>? = null

If true, wait for password data to become available and retrieve it. Useful for getting the administrator password for instances running Microsoft Windows. The password data is exported to the password_data attribute. See GetPasswordData for more information.

Link copied to clipboard
val hibernation: Output<Boolean>? = null

If true, the launched EC2 instance will support hibernation.

Link copied to clipboard
val hostId: Output<String>? = null

ID of a dedicated host that the instance will be assigned to. Use when an instance is to be launched on a specific dedicated host.

Link copied to clipboard
val hostResourceGroupArn: Output<String>? = null

ARN of the host resource group in which to launch the instances. If you specify an ARN, omit the tenancy parameter or set it to host.

Link copied to clipboard
val iamInstanceProfile: Output<String>? = null

IAM Instance Profile to launch the instance with. Specified as the name of the Instance Profile. Ensure your credentials have the correct permission to assign the instance profile according to the EC2 documentation, notably iam:PassRole.

Link copied to clipboard
val instanceInitiatedShutdownBehavior: Output<String>? = null

Shutdown behavior for the instance. Amazon defaults this to stop for EBS-backed instances and terminate for instance-store instances. Cannot be set on instance-store instances. See Shutdown Behavior for more information.

Link copied to clipboard
val instanceMarketOptions: Output<InstanceInstanceMarketOptionsArgs>? = null

Describes the market (purchasing) option for the instances. See Market Options below for details on attributes.

Link copied to clipboard
val instanceType: Output<Either<String, InstanceType>>? = null

Instance type to use for the instance. Required unless launch_template is specified and the Launch Template specifies an instance type. If an instance type is specified in the Launch Template, setting instance_type will override the instance type specified in the Launch Template. Updates to this field will trigger a stop/start of the EC2 instance.

Link copied to clipboard
val ipv6AddressCount: Output<Int>? = null

Number of IPv6 addresses to associate with the primary network interface. Amazon EC2 chooses the IPv6 addresses from the range of your subnet.

Link copied to clipboard
val ipv6Addresses: Output<List<String>>? = null

Specify one or more IPv6 addresses from the range of the subnet to associate with the primary network interface

Link copied to clipboard
val keyName: Output<String>? = null

Key name of the Key Pair to use for the instance; which can be managed using the aws.ec2.KeyPair resource.

Link copied to clipboard
val launchTemplate: Output<InstanceLaunchTemplateArgs>? = null

Specifies a Launch Template to configure the instance. Parameters configured on this resource will override the corresponding parameters in the Launch Template. See Launch Template Specification below for more details.

Link copied to clipboard
val maintenanceOptions: Output<InstanceMaintenanceOptionsArgs>? = null

Maintenance and recovery options for the instance. See Maintenance Options below for more details.

Link copied to clipboard
val metadataOptions: Output<InstanceMetadataOptionsArgs>? = null

Customize the metadata options of the instance. See Metadata Options below for more details.

Link copied to clipboard
val monitoring: Output<Boolean>? = null

If true, the launched EC2 instance will have detailed monitoring enabled. (Available since v0.6.0)

Link copied to clipboard
val networkInterfaces: Output<List<InstanceNetworkInterfaceArgs>>? = null

Customize network interfaces to be attached at instance boot time. See Network Interfaces below for more details.

Link copied to clipboard
val placementGroup: Output<String>? = null

Placement Group to start the instance in.

Link copied to clipboard
val placementPartitionNumber: Output<Int>? = null

Number of the partition the instance is in. Valid only if the aws.ec2.PlacementGroup resource's strategy argument is set to "partition".

Link copied to clipboard
val privateDnsNameOptions: Output<InstancePrivateDnsNameOptionsArgs>? = null

Options for the instance hostname. The default values are inherited from the subnet. See Private DNS Name Options below for more details.

Link copied to clipboard
val privateIp: Output<String>? = null

Private IP address to associate with the instance in a VPC.

Link copied to clipboard
val rootBlockDevice: Output<InstanceRootBlockDeviceArgs>? = null

Configuration block to customize details about the root block device of the instance. See Block Devices below for details. When accessing this as an attribute reference, it is a list containing one object.

Link copied to clipboard
val secondaryPrivateIps: Output<List<String>>? = null

List of secondary private IPv4 addresses to assign to the instance's primary network interface (eth0) in a VPC. Can only be assigned to the primary network interface (eth0) attached at instance creation, not a pre-existing network interface i.e., referenced in a network_interface block. Refer to the Elastic network interfaces documentation to see the maximum number of private IP addresses allowed per instance type.

Link copied to clipboard
val securityGroups: Output<List<String>>? = null

List of security group names to associate with.

Link copied to clipboard
val sourceDestCheck: Output<Boolean>? = null

Controls if traffic is routed to the instance when the destination address does not match the instance. Used for NAT or VPNs. Defaults true.

Link copied to clipboard
val subnetId: Output<String>? = null

VPC Subnet ID to launch in.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Map of tags to assign to the resource. Note that these tags apply to the instance and not block storage devices. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val tenancy: Output<Either<String, Tenancy>>? = null

Tenancy of the instance (if the instance is running in a VPC). An instance with a tenancy of dedicated runs on single-tenant hardware. The host tenancy is not supported for the import-instance command. Valid values are default, dedicated, and host.

Link copied to clipboard
val userData: Output<String>? = null

User data to provide when launching the instance. Do not pass gzip-compressed data via this argument; see user_data_base64 instead. Updates to this field will trigger a stop/start of the EC2 instance by default. If the user_data_replace_on_change is set then updates to this field will trigger a destroy and recreate of the EC2 instance.

Link copied to clipboard
val userDataBase64: Output<String>? = null

Can be used instead of user_data to pass base64-encoded binary data directly. Use this instead of user_data whenever the value is not a valid UTF-8 string. For example, gzip-encoded user data must be base64-encoded and passed via this argument to avoid corruption. Updates to this field will trigger a stop/start of the EC2 instance by default. If the user_data_replace_on_change is set then updates to this field will trigger a destroy and recreate of the EC2 instance.

Link copied to clipboard
val userDataReplaceOnChange: Output<Boolean>? = null

When used in combination with user_data or user_data_base64 will trigger a destroy and recreate of the EC2 instance when set to true. Defaults to false if not set.

Link copied to clipboard
val volumeTags: Output<Map<String, String>>? = null

Map of tags to assign, at instance-creation time, to root and EBS volumes.

Link copied to clipboard
val vpcSecurityGroupIds: Output<List<String>>? = null

List of security group IDs to associate with.

Functions

Link copied to clipboard
open override fun toJava(): InstanceArgs