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

Instance

class Instance : KotlinCustomResource

Provides a Lightsail Instance. Amazon Lightsail is a service to provide easy virtual private servers with custom software already setup. See What is Amazon Lightsail? for more information.

Note: Lightsail is currently only supported in a limited number of AWS Regions, please see "Regions and Availability Zones in Amazon Lightsail" for more details

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// Create a new GitLab Lightsail Instance
const gitlabTest = new aws.lightsail.Instance("gitlab_test", {
    name: "custom_gitlab",
    availabilityZone: "us-east-1b",
    blueprintId: "amazon_linux_2",
    bundleId: "nano_3_0",
    keyPairName: "some_key_name",
    tags: {
        foo: "bar",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# Create a new GitLab Lightsail Instance
gitlab_test = aws.lightsail.Instance("gitlab_test",
    name="custom_gitlab",
    availability_zone="us-east-1b",
    blueprint_id="amazon_linux_2",
    bundle_id="nano_3_0",
    key_pair_name="some_key_name",
    tags={
        "foo": "bar",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // Create a new GitLab Lightsail Instance
    var gitlabTest = new Aws.LightSail.Instance("gitlab_test", new()
    {
        Name = "custom_gitlab",
        AvailabilityZone = "us-east-1b",
        BlueprintId = "amazon_linux_2",
        BundleId = "nano_3_0",
        KeyPairName = "some_key_name",
        Tags =
        {
            { "foo", "bar" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a new GitLab Lightsail Instance
		_, err := lightsail.NewInstance(ctx, "gitlab_test", &lightsail.InstanceArgs{
			Name:             pulumi.String("custom_gitlab"),
			AvailabilityZone: pulumi.String("us-east-1b"),
			BlueprintId:      pulumi.String("amazon_linux_2"),
			BundleId:         pulumi.String("nano_3_0"),
			KeyPairName:      pulumi.String("some_key_name"),
			Tags: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		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.lightsail.Instance;
import com.pulumi.aws.lightsail.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) {
        // Create a new GitLab Lightsail Instance
        var gitlabTest = new Instance("gitlabTest", InstanceArgs.builder()
            .name("custom_gitlab")
            .availabilityZone("us-east-1b")
            .blueprintId("amazon_linux_2")
            .bundleId("nano_3_0")
            .keyPairName("some_key_name")
            .tags(Map.of("foo", "bar"))
            .build());
    }
}
Content copied to clipboard
resources:
  # Create a new GitLab Lightsail Instance
  gitlabTest:
    type: aws:lightsail:Instance
    name: gitlab_test
    properties:
      name: custom_gitlab
      availabilityZone: us-east-1b
      blueprintId: amazon_linux_2
      bundleId: nano_3_0
      keyPairName: some_key_name
      tags:
        foo: bar
Content copied to clipboard

Example With User Data

Lightsail user data is handled differently than ec2 user data. Lightsail user data only accepts a single lined string. The below example shows installing apache and creating the index page.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const custom = new aws.lightsail.Instance("custom", {
    name: "custom",
    availabilityZone: "us-east-1b",
    blueprintId: "amazon_linux_2",
    bundleId: "nano_3_0",
    userData: "sudo yum install -y httpd && sudo systemctl start httpd && sudo systemctl enable httpd && echo '<h1>Deployed via Pulumi</h1>' | sudo tee /var/www/html/index.html",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
custom = aws.lightsail.Instance("custom",
    name="custom",
    availability_zone="us-east-1b",
    blueprint_id="amazon_linux_2",
    bundle_id="nano_3_0",
    user_data="sudo yum install -y httpd && sudo systemctl start httpd && sudo systemctl enable httpd && echo '<h1>Deployed via Pulumi</h1>' | sudo tee /var/www/html/index.html")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var custom = new Aws.LightSail.Instance("custom", new()
    {
        Name = "custom",
        AvailabilityZone = "us-east-1b",
        BlueprintId = "amazon_linux_2",
        BundleId = "nano_3_0",
        UserData = "sudo yum install -y httpd && sudo systemctl start httpd && sudo systemctl enable httpd && echo '<h1>Deployed via Pulumi</h1>' | sudo tee /var/www/html/index.html",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewInstance(ctx, "custom", &lightsail.InstanceArgs{
			Name:             pulumi.String("custom"),
			AvailabilityZone: pulumi.String("us-east-1b"),
			BlueprintId:      pulumi.String("amazon_linux_2"),
			BundleId:         pulumi.String("nano_3_0"),
			UserData:         pulumi.String("sudo yum install -y httpd && sudo systemctl start httpd && sudo systemctl enable httpd && echo '<h1>Deployed via Pulumi</h1>' | sudo tee /var/www/html/index.html"),
		})
		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.lightsail.Instance;
import com.pulumi.aws.lightsail.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 custom = new Instance("custom", InstanceArgs.builder()
            .name("custom")
            .availabilityZone("us-east-1b")
            .blueprintId("amazon_linux_2")
            .bundleId("nano_3_0")
            .userData("sudo yum install -y httpd && sudo systemctl start httpd && sudo systemctl enable httpd && echo '<h1>Deployed via Pulumi</h1>' | sudo tee /var/www/html/index.html")
            .build());
    }
}
Content copied to clipboard
resources:
  custom:
    type: aws:lightsail:Instance
    properties:
      name: custom
      availabilityZone: us-east-1b
      blueprintId: amazon_linux_2
      bundleId: nano_3_0
      userData: sudo yum install -y httpd && sudo systemctl start httpd && sudo systemctl enable httpd && echo '<h1>Deployed via Pulumi</h1>' | sudo tee /var/www/html/index.html
Content copied to clipboard

Enable Auto Snapshots

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const test = new aws.lightsail.Instance("test", {
    name: "custom_instance",
    availabilityZone: "us-east-1b",
    blueprintId: "amazon_linux_2",
    bundleId: "nano_3_0",
    addOn: {
        type: "AutoSnapshot",
        snapshotTime: "06:00",
        status: "Enabled",
    },
    tags: {
        foo: "bar",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
test = aws.lightsail.Instance("test",
    name="custom_instance",
    availability_zone="us-east-1b",
    blueprint_id="amazon_linux_2",
    bundle_id="nano_3_0",
    add_on={
        "type": "AutoSnapshot",
        "snapshot_time": "06:00",
        "status": "Enabled",
    },
    tags={
        "foo": "bar",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var test = new Aws.LightSail.Instance("test", new()
    {
        Name = "custom_instance",
        AvailabilityZone = "us-east-1b",
        BlueprintId = "amazon_linux_2",
        BundleId = "nano_3_0",
        AddOn = new Aws.LightSail.Inputs.InstanceAddOnArgs
        {
            Type = "AutoSnapshot",
            SnapshotTime = "06:00",
            Status = "Enabled",
        },
        Tags =
        {
            { "foo", "bar" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewInstance(ctx, "test", &lightsail.InstanceArgs{
			Name:             pulumi.String("custom_instance"),
			AvailabilityZone: pulumi.String("us-east-1b"),
			BlueprintId:      pulumi.String("amazon_linux_2"),
			BundleId:         pulumi.String("nano_3_0"),
			AddOn: &lightsail.InstanceAddOnArgs{
				Type:         pulumi.String("AutoSnapshot"),
				SnapshotTime: pulumi.String("06:00"),
				Status:       pulumi.String("Enabled"),
			},
			Tags: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		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.lightsail.Instance;
import com.pulumi.aws.lightsail.InstanceArgs;
import com.pulumi.aws.lightsail.inputs.InstanceAddOnArgs;
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 test = new Instance("test", InstanceArgs.builder()
            .name("custom_instance")
            .availabilityZone("us-east-1b")
            .blueprintId("amazon_linux_2")
            .bundleId("nano_3_0")
            .addOn(InstanceAddOnArgs.builder()
                .type("AutoSnapshot")
                .snapshotTime("06:00")
                .status("Enabled")
                .build())
            .tags(Map.of("foo", "bar"))
            .build());
    }
}
Content copied to clipboard
resources:
  test:
    type: aws:lightsail:Instance
    properties:
      name: custom_instance
      availabilityZone: us-east-1b
      blueprintId: amazon_linux_2
      bundleId: nano_3_0
      addOn:
        type: AutoSnapshot
        snapshotTime: 06:00
        status: Enabled
      tags:
        foo: bar
Content copied to clipboard

Import

Using pulumi import, import Lightsail Instances using their name. For example:

$ pulumi import aws:lightsail/instance:Instance gitlab_test 'custom_gitlab'
Content copied to clipboard

Properties

Link copied to clipboard
val addOn: Output<InstanceAddOn>?

The add-on configuration for the instance. Detailed below.

Link copied to clipboard
val arn: Output<String>

The ARN of the Lightsail instance (matches id).

Link copied to clipboard
val availabilityZone: Output<String>

The Availability Zone in which to create your instance. A list of available zones can be obtained using the AWS CLI command: aws lightsail get-regions --include-availability-zones.

Link copied to clipboard
val blueprintId: Output<String>

The ID for a virtual private server image. A list of available blueprint IDs can be obtained using the AWS CLI command: aws lightsail get-blueprints.

Link copied to clipboard
val bundleId: Output<String>

The bundle of specification information. A list of available bundle IDs can be obtained using the AWS CLI command: aws lightsail get-bundles.

Link copied to clipboard
val cpuCount: Output<Int>

The number of vCPUs the instance has.

Link copied to clipboard
val createdAt: Output<String>

The timestamp when the instance was created.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val ipAddressType: Output<String>?

The IP address type of the Lightsail Instance. Valid Values: dualstack, ipv4, and ipv6.

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

List of IPv6 addresses for the Lightsail instance.

Link copied to clipboard
val isStaticIp: Output<Boolean>

A Boolean value indicating whether this instance has a static IP assigned to it.

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

The name of your key pair. Created in the Lightsail console (cannot use aws.ec2.KeyPair at this time)

Link copied to clipboard
val name: Output<String>

The name of the Lightsail Instance. Names must be unique within each AWS Region in your Lightsail account.

Link copied to clipboard
val privateIpAddress: Output<String>

The private IP address of the instance.

Link copied to clipboard
val publicIpAddress: Output<String>

The public IP address of the instance.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val ramSize: Output<Double>

The amount of RAM in GB on the instance (e.g., 1.0).

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

A map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. .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 tagsAll: Output<Map<String, String>>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

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

Single lined launch script as a string to configure server with additional user data

Link copied to clipboard
val username: Output<String>

The user name for connecting to the instance (e.g., ec2-user).