pulumi-aws-kotlin/com.pulumi.aws.opsworks.kotlin/Instance

Instance

class Instance : KotlinCustomResource

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const my_instance = new aws.opsworks.Instance("my-instance", {
    stackId: main.id,
    layerIds: [my_layer&#46;id],
    instanceType: "t2.micro",
    os: "Amazon Linux 2015.09",
    state: "stopped",
});

import pulumi
import pulumi_aws as aws
my_instance = aws.opsworks.Instance("my-instance",
    stack_id=main["id"],
    layer_ids=[my_layer["id"]],
    instance_type="t2.micro",
    os="Amazon Linux 2015.09",
    state="stopped")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var my_instance = new Aws.OpsWorks.Instance("my-instance", new()
    {
        StackId = main.Id,
        LayerIds = new[]
        {
            my_layer.Id,
        },
        InstanceType = "t2.micro",
        Os = "Amazon Linux 2015.09",
        State = "stopped",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/opsworks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opsworks.NewInstance(ctx, "my-instance", &opsworks.InstanceArgs{
			StackId: pulumi.Any(main.Id),
			LayerIds: pulumi.StringArray{
				my_layer.Id,
			},
			InstanceType: pulumi.String("t2.micro"),
			Os:           pulumi.String("Amazon Linux 2015.09"),
			State:        pulumi.String("stopped"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.opsworks.Instance;
import com.pulumi.aws.opsworks.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 my_instance = new Instance("my-instance", InstanceArgs.builder()
            .stackId(main.id())
            .layerIds(my_layer.id())
            .instanceType("t2.micro")
            .os("Amazon Linux 2015.09")
            .state("stopped")
            .build());
    }
}

resources:
  my-instance:
    type: aws:opsworks:Instance
    properties:
      stackId: ${main.id}
      layerIds:
        - ${["my-layer"].id}
      instanceType: t2.micro
      os: Amazon Linux 2015.09
      state: stopped

Block devices

Each of the *_block_device attributes controls a portion of the AWS Instance's "Block Device Mapping". It's a good idea to familiarize yourself with [AWS's Block Device

Mapping docs](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) to understand the implications of using these attributes.

`ebs_block_device`

delete_on_termination - (Optional) Whether the volume should be destroyed on instance termination. Default is true.
device_name - (Required) Name of the device to mount.
iops - (Optional) Amount of provisioned IOPS. This must be set with a volume_type of io1.
snapshot_id - (Optional) Snapshot ID to mount.
volume_size - (Optional) Size of the volume in gigabytes.
volume_type - (Optional) Type of volume. Valid values are standard, gp2, or io1. Default is standard. Modifying any ebs_block_device currently requires resource replacement.

`ephemeral_block_device`

device_name - Name of the block device to mount on the instance.
virtual_name - The Instance Store Device Name (e.g., ephemeral0). Each AWS Instance type has a different set of Instance Store block devices available for attachment. AWS [publishes a
list](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html#StorageOnInstanceTypes) of which ephemeral devices are available on each type. The devices are always identified by the virtual_name in the format ephemeral{0..N}.

`root_block_device`

delete_on_termination - (Optional) Whether the volume should be destroyed on instance termination. Default is true.
iops - (Optional) Amount of provisioned IOPS. This must be set with a volume_type of io1.
volume_size - (Optional) Size of the volume in gigabytes.
volume_type - (Optional) Type of volume. Valid values are standard, gp2, or io1. Default is standard. Modifying any of the root_block_device settings requires resource replacement.

NOTE: Currently, changes to *_block_device configuration of existing resources cannot be automatically detected by this provider. After making updates to block device configuration, resource recreation can be manually triggered by using the up command with the --replace argument.

Import

Using pulumi import, import Opsworks Instances using the instance id. For example:

$ pulumi import aws:opsworks/instance:Instance my_instance 4d6d1710-ded9-42a1-b08e-b043ad7af1e2

Properties

agentVersion

val agentVersion: Output<String>?

OpsWorks agent to install. Default is INHERIT.

amiId

val amiId: Output<String>

AMI to use for the instance. If an AMI is specified, os must be Custom.

architecture

val architecture: Output<String>?

Machine architecture for created instances. Valid values are x86_64 or i386. The default is x86_64.

autoScalingType

val autoScalingType: Output<String>?

Creates load-based or time-based instances. Valid values are load, timer.

availabilityZone

val availabilityZone: Output<String>

Name of the availability zone where instances will be created by default.

createdAt

val createdAt: Output<String>

Time that the instance was created.

deleteEbs

val deleteEbs: Output<Boolean>?

Whether to delete EBS volume on deletion. Default is true.

deleteEip

val deleteEip: Output<Boolean>?

Whether to delete the Elastic IP on deletion.

ebsBlockDevices

val ebsBlockDevices: Output<List<InstanceEbsBlockDevice>>

Configuration block for additional EBS block devices to attach to the instance. See Block Devices below.

ebsOptimized

val ebsOptimized: Output<Boolean>?

Whether the launched EC2 instance will be EBS-optimized.

ec2InstanceId

val ec2InstanceId: Output<String>

EC2 instance ID.

ecsClusterArn

val ecsClusterArn: Output<String>

ECS cluster's ARN for container instances.

elasticIp

val elasticIp: Output<String>

Instance Elastic IP address.

ephemeralBlockDevices

val ephemeralBlockDevices: Output<List<InstanceEphemeralBlockDevice>>

Configuration block for ephemeral (also known as "Instance Store") volumes on the instance. See Block Devices below.

hostname

val hostname: Output<String>

Instance's host name.

val id: Output<String>

infrastructureClass

val infrastructureClass: Output<String>

For registered instances, infrastructure class: ec2 or on-premises.

installUpdatesOnBoot

val installUpdatesOnBoot: Output<Boolean>?

Controls where to install OS and package updates when the instance boots. Default is true.

instanceProfileArn

val instanceProfileArn: Output<String>

ARN of the instance's IAM profile.

instanceType

val instanceType: Output<String>?

Type of instance to start.

lastServiceErrorId

val lastServiceErrorId: Output<String>

ID of the last service error.

layerIds

val layerIds: Output<List<String>>

List of the layers the instance will belong to.

val os: Output<String>

Name of operating system that will be installed.

platform

val platform: Output<String>

Instance's platform.

privateDns

val privateDns: Output<String>

Private DNS name assigned to the instance. Can only be used inside the Amazon EC2, and only available if you've enabled DNS hostnames for your VPC.

privateIp

val privateIp: Output<String>

Private IP address assigned to the instance.

publicDns

val publicDns: Output<String>

Public DNS name assigned to the instance. For EC2-VPC, this is only available if you've enabled DNS hostnames for your VPC.

publicIp

val publicIp: Output<String>

Public IP address assigned to the instance, if applicable.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

registeredBy

val registeredBy: Output<String>

For registered instances, who performed the registration.

reportedAgentVersion

val reportedAgentVersion: Output<String>

Instance's reported AWS OpsWorks Stacks agent version.

reportedOsFamily

val reportedOsFamily: Output<String>

For registered instances, the reported operating system family.

reportedOsName

val reportedOsName: Output<String>

For registered instances, the reported operating system name.

reportedOsVersion

val reportedOsVersion: Output<String>

For registered instances, the reported operating system version.

rootBlockDevices

val rootBlockDevices: Output<List<InstanceRootBlockDevice>>

Configuration block for the root block device of the instance. See Block Devices below.

rootDeviceType

val rootDeviceType: Output<String>

Name of the type of root device instances will have by default. Valid values are ebs or instance-store.

rootDeviceVolumeId

val rootDeviceVolumeId: Output<String>

Root device volume ID.

securityGroupIds

val securityGroupIds: Output<List<String>>

Associated security groups.

sshHostDsaKeyFingerprint

val sshHostDsaKeyFingerprint: Output<String>

SSH key's Deep Security Agent (DSA) fingerprint.

sshHostRsaKeyFingerprint

val sshHostRsaKeyFingerprint: Output<String>

SSH key's RSA fingerprint.

sshKeyName

val sshKeyName: Output<String>

Name of the SSH keypair that instances will have by default.

stackId

val stackId: Output<String>

Identifier of the stack the instance will belong to. The following arguments are optional:

state

val state: Output<String>?

Desired state of the instance. Valid values are running or stopped.

status

val status: Output<String>

Instance status. Will be one of booting, connection_lost, online, pending, rebooting, requested, running_setup, setup_failed, shutting_down, start_failed, stop_failed, stopped, stopping, terminated, or terminating.

subnetId

val subnetId: Output<String>

Subnet ID to attach to.

tenancy

val tenancy: Output<String>

Instance tenancy to use. Valid values are default, dedicated or host.

urn

val urn: Output<String>

virtualizationType

val virtualizationType: Output<String>

Keyword to choose what virtualization mode created instances will use. Valid values are paravirtual or hvm.