aws.ec2transitgateway.InstanceState

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-focal-20.04-amd64-server-*"],
        },
        {
            name: "virtualization-type",
            values: ["hvm"],
        },
    ],
    owners: ["099720109477"],
});
const test = new aws.ec2.Instance("test", {
    ami: ubuntu.then(ubuntu => ubuntu.id),
    instanceType: aws.ec2.InstanceType.T3_Micro,
    tags: {
        Name: "HelloWorld",
    },
});
const testInstanceState = new aws.ec2transitgateway.InstanceState("test", {
    instanceId: test.id,
    state: "stopped",
});

import pulumi
import pulumi_aws as aws

ubuntu = aws.ec2.get_ami(most_recent=True,
    filters=[
        {
            "name": "name",
            "values": ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"],
        },
        {
            "name": "virtualization-type",
            "values": ["hvm"],
        },
    ],
    owners=["099720109477"])
test = aws.ec2.Instance("test",
    ami=ubuntu.id,
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    tags={
        "Name": "HelloWorld",
    })
test_instance_state = aws.ec2transitgateway.InstanceState("test",
    instance_id=test.id,
    state="stopped")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2transitgateway"
	"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-focal-20.04-amd64-server-*",
					},
				},
				{
					Name: "virtualization-type",
					Values: []string{
						"hvm",
					},
				},
			},
			Owners: []string{
				"099720109477",
			},
		}, nil)
		if err != nil {
			return err
		}
		test, err := ec2.NewInstance(ctx, "test", &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
		}
		_, err = ec2transitgateway.NewInstanceState(ctx, "test", &ec2transitgateway.InstanceStateArgs{
			InstanceId: test.ID(),
			State:      pulumi.String("stopped"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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-focal-20.04-amd64-server-*",
                },
            },
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "virtualization-type",
                Values = new[]
                {
                    "hvm",
                },
            },
        },
        Owners = new[]
        {
            "099720109477",
        },
    });

    var test = new Aws.Ec2.Instance("test", new()
    {
        Ami = ubuntu.Apply(getAmiResult => getAmiResult.Id),
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        Tags = 
        {
            { "Name", "HelloWorld" },
        },
    });

    var testInstanceState = new Aws.Ec2TransitGateway.InstanceState("test", new()
    {
        InstanceId = test.Id,
        State = "stopped",
    });

});

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.ec2transitgateway.InstanceState;
import com.pulumi.aws.ec2transitgateway.InstanceStateArgs;
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-focal-20.04-amd64-server-*")
                    .build(),
                GetAmiFilterArgs.builder()
                    .name("virtualization-type")
                    .values("hvm")
                    .build())
            .owners("099720109477")
            .build());

        var test = new Instance("test", InstanceArgs.builder()
            .ami(ubuntu.applyValue(getAmiResult -> getAmiResult.id()))
            .instanceType("t3.micro")
            .tags(Map.of("Name", "HelloWorld"))
            .build());

        var testInstanceState = new InstanceState("testInstanceState", InstanceStateArgs.builder()
            .instanceId(test.id())
            .state("stopped")
            .build());

    }
}

resources:
  test:
    type: aws:ec2:Instance
    properties:
      ami: ${ubuntu.id}
      instanceType: t3.micro
      tags:
        Name: HelloWorld
  testInstanceState:
    type: aws:ec2transitgateway:InstanceState
    name: test
    properties:
      instanceId: ${test.id}
      state: stopped
variables:
  ubuntu:
    fn::invoke:
      Function: aws:ec2:getAmi
      Arguments:
        mostRecent: true
        filters:
          - name: name
            values:
              - ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*
          - name: virtualization-type
            values:
              - hvm
        owners:
          - '099720109477'

var instanceStateResource = new Aws.Ec2TransitGateway.InstanceState("instanceStateResource", new()
{
    InstanceId = "string",
    State = "string",
    Force = false,
});

example, err := ec2transitgateway.NewInstanceState(ctx, "instanceStateResource", &ec2transitgateway.InstanceStateArgs{
	InstanceId: pulumi.String("string"),
	State:      pulumi.String("string"),
	Force:      pulumi.Bool(false),
})

var instanceStateResource = new InstanceState("instanceStateResource", InstanceStateArgs.builder()
    .instanceId("string")
    .state("string")
    .force(false)
    .build());

instance_state_resource = aws.ec2transitgateway.InstanceState("instanceStateResource",
    instance_id="string",
    state="string",
    force=False)

const instanceStateResource = new aws.ec2transitgateway.InstanceState("instanceStateResource", {
    instanceId: "string",
    state: "string",
    force: false,
});

type: aws:ec2transitgateway:InstanceState
properties:
    force: false
    instanceId: string
    state: string