lightsail

package
v4.37.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 14, 2022 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Domain 

type Domain struct {
	pulumi.CustomResourceState

	// The ARN of the Lightsail domain
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The name of the Lightsail domain to manage
	DomainName pulumi.StringOutput `pulumi:"domainName"`
}

Creates a domain resource for the specified domain (e.g., example.com). You cannot register a new domain name using Lightsail. You must register a domain name using Amazon Route 53 or another domain name registrar. If you have already registered your domain, you can enter its name in this parameter to manage the DNS records for that domain.

> **Note:** Lightsail is currently only supported in a limited number of AWS Regions, please see ["Regions and Availability Zones in Amazon Lightsail"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewDomain(ctx, "domainTest", &lightsail.DomainArgs{
			DomainName: pulumi.String("mydomain.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetDomain 

func GetDomain(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainState, opts ...pulumi.ResourceOption) (*Domain, error)

GetDomain gets an existing Domain resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDomain 

func NewDomain(ctx *pulumi.Context,
	name string, args *DomainArgs, opts ...pulumi.ResourceOption) (*Domain, error)

NewDomain registers a new resource with the given unique name, arguments, and options.

func (*Domain) ElementType 

func (*Domain) ElementType() reflect.Type

func (*Domain) ToDomainOutput 

func (i *Domain) ToDomainOutput() DomainOutput

func (*Domain) ToDomainOutputWithContext 

func (i *Domain) ToDomainOutputWithContext(ctx context.Context) DomainOutput

type DomainArgs 

type DomainArgs struct {
	// The name of the Lightsail domain to manage
	DomainName pulumi.StringInput
}

The set of arguments for constructing a Domain resource.

func (DomainArgs) ElementType 

func (DomainArgs) ElementType() reflect.Type

type DomainArray 

type DomainArray []DomainInput

func (DomainArray) ElementType 

func (DomainArray) ElementType() reflect.Type

func (DomainArray) ToDomainArrayOutput 

func (i DomainArray) ToDomainArrayOutput() DomainArrayOutput

func (DomainArray) ToDomainArrayOutputWithContext 

func (i DomainArray) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput

type DomainArrayInput 

type DomainArrayInput interface {
	pulumi.Input

	ToDomainArrayOutput() DomainArrayOutput
	ToDomainArrayOutputWithContext(context.Context) DomainArrayOutput
}

DomainArrayInput is an input type that accepts DomainArray and DomainArrayOutput values. You can construct a concrete instance of `DomainArrayInput` via: 

DomainArray{ DomainArgs{...} }

type DomainArrayOutput 

type DomainArrayOutput struct{ *pulumi.OutputState }

func (DomainArrayOutput) ElementType 

func (DomainArrayOutput) ElementType() reflect.Type

func (DomainArrayOutput) Index 

func (o DomainArrayOutput) Index(i pulumi.IntInput) DomainOutput

func (DomainArrayOutput) ToDomainArrayOutput 

func (o DomainArrayOutput) ToDomainArrayOutput() DomainArrayOutput

func (DomainArrayOutput) ToDomainArrayOutputWithContext 

func (o DomainArrayOutput) ToDomainArrayOutputWithContext(ctx context.Context) DomainArrayOutput

type DomainInput 

type DomainInput interface {
	pulumi.Input

	ToDomainOutput() DomainOutput
	ToDomainOutputWithContext(ctx context.Context) DomainOutput
}

type DomainMap 

type DomainMap map[string]DomainInput

func (DomainMap) ElementType 

func (DomainMap) ElementType() reflect.Type

func (DomainMap) ToDomainMapOutput 

func (i DomainMap) ToDomainMapOutput() DomainMapOutput

func (DomainMap) ToDomainMapOutputWithContext 

func (i DomainMap) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput

type DomainMapInput 

type DomainMapInput interface {
	pulumi.Input

	ToDomainMapOutput() DomainMapOutput
	ToDomainMapOutputWithContext(context.Context) DomainMapOutput
}

DomainMapInput is an input type that accepts DomainMap and DomainMapOutput values. You can construct a concrete instance of `DomainMapInput` via: 

DomainMap{ "key": DomainArgs{...} }

type DomainMapOutput 

type DomainMapOutput struct{ *pulumi.OutputState }

func (DomainMapOutput) ElementType 

func (DomainMapOutput) ElementType() reflect.Type

func (DomainMapOutput) MapIndex 

func (o DomainMapOutput) MapIndex(k pulumi.StringInput) DomainOutput

func (DomainMapOutput) ToDomainMapOutput 

func (o DomainMapOutput) ToDomainMapOutput() DomainMapOutput

func (DomainMapOutput) ToDomainMapOutputWithContext 

func (o DomainMapOutput) ToDomainMapOutputWithContext(ctx context.Context) DomainMapOutput

type DomainOutput 

type DomainOutput struct{ *pulumi.OutputState }

func (DomainOutput) ElementType 

func (DomainOutput) ElementType() reflect.Type

func (DomainOutput) ToDomainOutput 

func (o DomainOutput) ToDomainOutput() DomainOutput

func (DomainOutput) ToDomainOutputWithContext 

func (o DomainOutput) ToDomainOutputWithContext(ctx context.Context) DomainOutput

type DomainState 

type DomainState struct {
	// The ARN of the Lightsail domain
	Arn pulumi.StringPtrInput
	// The name of the Lightsail domain to manage
	DomainName pulumi.StringPtrInput
}

func (DomainState) ElementType 

func (DomainState) ElementType() reflect.Type

type Instance 

type Instance struct {
	pulumi.CustomResourceState

	// The ARN of the Lightsail instance (matches `id`).
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The Availability Zone in which to create your
	// instance (see list below)
	AvailabilityZone pulumi.StringOutput `pulumi:"availabilityZone"`
	// 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`
	BlueprintId pulumi.StringOutput `pulumi:"blueprintId"`
	// The bundle of specification information (see list below)
	BundleId pulumi.StringOutput `pulumi:"bundleId"`
	// The number of vCPUs the instance has.
	CpuCount pulumi.IntOutput `pulumi:"cpuCount"`
	// The timestamp when the instance was created.
	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
	// (**Deprecated**) The first IPv6 address of the Lightsail instance. Use `ipv6Addresses` attribute instead.
	//
	// Deprecated: use `ipv6_addresses` attribute instead
	Ipv6Address pulumi.StringOutput `pulumi:"ipv6Address"`
	// List of IPv6 addresses for the Lightsail instance.
	Ipv6Addresses pulumi.StringArrayOutput `pulumi:"ipv6Addresses"`
	// A Boolean value indicating whether this instance has a static IP assigned to it.
	IsStaticIp pulumi.BoolOutput `pulumi:"isStaticIp"`
	// The name of your key pair. Created in the
	// Lightsail console (cannot use `ec2.KeyPair` at this time)
	KeyPairName pulumi.StringPtrOutput `pulumi:"keyPairName"`
	// The name of the Lightsail Instance. Names be unique within each AWS Region in your Lightsail account.
	Name pulumi.StringOutput `pulumi:"name"`
	// The private IP address of the instance.
	PrivateIpAddress pulumi.StringOutput `pulumi:"privateIpAddress"`
	// The public IP address of the instance.
	PublicIpAddress pulumi.StringOutput `pulumi:"publicIpAddress"`
	// The amount of RAM in GB on the instance (e.g., 1.0).
	RamSize pulumi.Float64Output `pulumi:"ramSize"`
	// 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 `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// launch script to configure server with additional user data
	UserData pulumi.StringPtrOutput `pulumi:"userData"`
	// The user name for connecting to the instance (e.g., ec2-user).
	Username pulumi.StringOutput `pulumi:"username"`
}

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?](https://lightsail.aws.amazon.com/ls/docs/getting-started/article/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"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewInstance(ctx, "gitlabTest", &lightsail.InstanceArgs{
			AvailabilityZone: pulumi.String("us-east-1b"),
			BlueprintId:      pulumi.String("string"),
			BundleId:         pulumi.String("string"),
			KeyPairName:      pulumi.String("some_key_name"),
			Tags: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ## Availability Zones

Lightsail currently supports the following Availability Zones (e.g., `us-east-1a`):

- `ap-northeast-1{a,c,d}` - `ap-northeast-2{a,c}` - `ap-south-1{a,b}` - `ap-southeast-1{a,b,c}` - `ap-southeast-2{a,b,c}` - `ca-central-1{a,b}` - `eu-central-1{a,b,c}` - `eu-west-1{a,b,c}` - `eu-west-2{a,b,c}` - `eu-west-3{a,b,c}` - `us-east-1{a,b,c,d,e,f}` - `us-east-2{a,b,c}` - `us-west-2{a,b,c}`

## Bundles

Lightsail currently supports the following Bundle IDs (e.g., an instance in `ap-northeast-1` would use `small20`):

### Prefix

A Bundle ID starts with one of the below size prefixes:

- `nano_` - `micro_` - `small_` - `medium_` - `large_` - `xlarge_` - `2xlarge_`

### Suffix

A Bundle ID ends with one of the following suffixes depending on Availability Zone:

- ap-northeast-1: `20` - ap-northeast-2: `20` - ap-south-1: `21` - ap-southeast-1: `20` - ap-southeast-2: `22` - ca-central-1: `20` - eu-central-1: `20` - eu-west-1: `20` - eu-west-2: `20` - eu-west-3: `20` - us-east-1: `20` - us-east-2: `20` - us-west-2: `20`

## Import

Lightsail Instances can be imported using their name, e.g.,

```sh 

$ pulumi import aws:lightsail/instance:Instance gitlab_test 'custom gitlab'

```

func GetInstance 

func GetInstance(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstanceState, opts ...pulumi.ResourceOption) (*Instance, error)

GetInstance gets an existing Instance resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInstance 

func NewInstance(ctx *pulumi.Context,
	name string, args *InstanceArgs, opts ...pulumi.ResourceOption) (*Instance, error)

NewInstance registers a new resource with the given unique name, arguments, and options.

func (*Instance) ElementType 

func (*Instance) ElementType() reflect.Type

func (*Instance) ToInstanceOutput 

func (i *Instance) ToInstanceOutput() InstanceOutput

func (*Instance) ToInstanceOutputWithContext 

func (i *Instance) ToInstanceOutputWithContext(ctx context.Context) InstanceOutput

type InstanceArgs 

type InstanceArgs struct {
	// The Availability Zone in which to create your
	// instance (see list below)
	AvailabilityZone pulumi.StringInput
	// 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`
	BlueprintId pulumi.StringInput
	// The bundle of specification information (see list below)
	BundleId pulumi.StringInput
	// The name of your key pair. Created in the
	// Lightsail console (cannot use `ec2.KeyPair` at this time)
	KeyPairName pulumi.StringPtrInput
	// The name of the Lightsail Instance. Names be unique within each AWS Region in your Lightsail account.
	Name pulumi.StringPtrInput
	// 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 `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// launch script to configure server with additional user data
	UserData pulumi.StringPtrInput
}

The set of arguments for constructing a Instance resource.

func (InstanceArgs) ElementType 

func (InstanceArgs) ElementType() reflect.Type

type InstanceArray 

type InstanceArray []InstanceInput

func (InstanceArray) ElementType 

func (InstanceArray) ElementType() reflect.Type

func (InstanceArray) ToInstanceArrayOutput 

func (i InstanceArray) ToInstanceArrayOutput() InstanceArrayOutput

func (InstanceArray) ToInstanceArrayOutputWithContext 

func (i InstanceArray) ToInstanceArrayOutputWithContext(ctx context.Context) InstanceArrayOutput

type InstanceArrayInput 

type InstanceArrayInput interface {
	pulumi.Input

	ToInstanceArrayOutput() InstanceArrayOutput
	ToInstanceArrayOutputWithContext(context.Context) InstanceArrayOutput
}

InstanceArrayInput is an input type that accepts InstanceArray and InstanceArrayOutput values. You can construct a concrete instance of `InstanceArrayInput` via: 

InstanceArray{ InstanceArgs{...} }

type InstanceArrayOutput 

type InstanceArrayOutput struct{ *pulumi.OutputState }

func (InstanceArrayOutput) ElementType 

func (InstanceArrayOutput) ElementType() reflect.Type

func (InstanceArrayOutput) Index 

func (o InstanceArrayOutput) Index(i pulumi.IntInput) InstanceOutput

func (InstanceArrayOutput) ToInstanceArrayOutput 

func (o InstanceArrayOutput) ToInstanceArrayOutput() InstanceArrayOutput

func (InstanceArrayOutput) ToInstanceArrayOutputWithContext 

func (o InstanceArrayOutput) ToInstanceArrayOutputWithContext(ctx context.Context) InstanceArrayOutput

type InstanceInput 

type InstanceInput interface {
	pulumi.Input

	ToInstanceOutput() InstanceOutput
	ToInstanceOutputWithContext(ctx context.Context) InstanceOutput
}

type InstanceMap 

type InstanceMap map[string]InstanceInput

func (InstanceMap) ElementType 

func (InstanceMap) ElementType() reflect.Type

func (InstanceMap) ToInstanceMapOutput 

func (i InstanceMap) ToInstanceMapOutput() InstanceMapOutput

func (InstanceMap) ToInstanceMapOutputWithContext 

func (i InstanceMap) ToInstanceMapOutputWithContext(ctx context.Context) InstanceMapOutput

type InstanceMapInput 

type InstanceMapInput interface {
	pulumi.Input

	ToInstanceMapOutput() InstanceMapOutput
	ToInstanceMapOutputWithContext(context.Context) InstanceMapOutput
}

InstanceMapInput is an input type that accepts InstanceMap and InstanceMapOutput values. You can construct a concrete instance of `InstanceMapInput` via: 

InstanceMap{ "key": InstanceArgs{...} }

type InstanceMapOutput 

type InstanceMapOutput struct{ *pulumi.OutputState }

func (InstanceMapOutput) ElementType 

func (InstanceMapOutput) ElementType() reflect.Type

func (InstanceMapOutput) MapIndex 

func (o InstanceMapOutput) MapIndex(k pulumi.StringInput) InstanceOutput

func (InstanceMapOutput) ToInstanceMapOutput 

func (o InstanceMapOutput) ToInstanceMapOutput() InstanceMapOutput

func (InstanceMapOutput) ToInstanceMapOutputWithContext 

func (o InstanceMapOutput) ToInstanceMapOutputWithContext(ctx context.Context) InstanceMapOutput

type InstanceOutput 

type InstanceOutput struct{ *pulumi.OutputState }

func (InstanceOutput) ElementType 

func (InstanceOutput) ElementType() reflect.Type

func (InstanceOutput) ToInstanceOutput 

func (o InstanceOutput) ToInstanceOutput() InstanceOutput

func (InstanceOutput) ToInstanceOutputWithContext 

func (o InstanceOutput) ToInstanceOutputWithContext(ctx context.Context) InstanceOutput

type InstancePublicPorts 

type InstancePublicPorts struct {
	pulumi.CustomResourceState

	// Name of the Lightsail Instance.
	InstanceName pulumi.StringOutput `pulumi:"instanceName"`
	// Configuration block with port information. AWS closes all currently open ports that are not included in the `portInfo`. Detailed below.
	PortInfos InstancePublicPortsPortInfoArrayOutput `pulumi:"portInfos"`
}

Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses allowed to connect to the instance through the ports, and the protocol.

> See [What is Amazon Lightsail?](https://lightsail.aws.amazon.com/ls/docs/getting-started/article/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"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testInstance, err := lightsail.NewInstance(ctx, "testInstance", &lightsail.InstanceArgs{
			AvailabilityZone: pulumi.Any(data.Aws_availability_zones.Available.Names[0]),
			BlueprintId:      pulumi.String("amazon_linux"),
			BundleId:         pulumi.String("nano_1_0"),
		})
		if err != nil {
			return err
		}
		_, err = lightsail.NewInstancePublicPorts(ctx, "testInstancePublicPorts", &lightsail.InstancePublicPortsArgs{
			InstanceName: testInstance.Name,
			PortInfos: lightsail.InstancePublicPortsPortInfoArray{
				&lightsail.InstancePublicPortsPortInfoArgs{
					Protocol: pulumi.String("tcp"),
					FromPort: pulumi.Int(80),
					ToPort:   pulumi.Int(80),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetInstancePublicPorts 

func GetInstancePublicPorts(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstancePublicPortsState, opts ...pulumi.ResourceOption) (*InstancePublicPorts, error)

GetInstancePublicPorts gets an existing InstancePublicPorts resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewInstancePublicPorts 

func NewInstancePublicPorts(ctx *pulumi.Context,
	name string, args *InstancePublicPortsArgs, opts ...pulumi.ResourceOption) (*InstancePublicPorts, error)

NewInstancePublicPorts registers a new resource with the given unique name, arguments, and options.

func (*InstancePublicPorts) ElementType 

func (*InstancePublicPorts) ElementType() reflect.Type

func (*InstancePublicPorts) ToInstancePublicPortsOutput 

func (i *InstancePublicPorts) ToInstancePublicPortsOutput() InstancePublicPortsOutput

func (*InstancePublicPorts) ToInstancePublicPortsOutputWithContext 

func (i *InstancePublicPorts) ToInstancePublicPortsOutputWithContext(ctx context.Context) InstancePublicPortsOutput

type InstancePublicPortsArgs 

type InstancePublicPortsArgs struct {
	// Name of the Lightsail Instance.
	InstanceName pulumi.StringInput
	// Configuration block with port information. AWS closes all currently open ports that are not included in the `portInfo`. Detailed below.
	PortInfos InstancePublicPortsPortInfoArrayInput
}

The set of arguments for constructing a InstancePublicPorts resource.

func (InstancePublicPortsArgs) ElementType 

func (InstancePublicPortsArgs) ElementType() reflect.Type

type InstancePublicPortsArray 

type InstancePublicPortsArray []InstancePublicPortsInput

func (InstancePublicPortsArray) ElementType 

func (InstancePublicPortsArray) ElementType() reflect.Type

func (InstancePublicPortsArray) ToInstancePublicPortsArrayOutput 

func (i InstancePublicPortsArray) ToInstancePublicPortsArrayOutput() InstancePublicPortsArrayOutput

func (InstancePublicPortsArray) ToInstancePublicPortsArrayOutputWithContext 

func (i InstancePublicPortsArray) ToInstancePublicPortsArrayOutputWithContext(ctx context.Context) InstancePublicPortsArrayOutput

type InstancePublicPortsArrayInput 

type InstancePublicPortsArrayInput interface {
	pulumi.Input

	ToInstancePublicPortsArrayOutput() InstancePublicPortsArrayOutput
	ToInstancePublicPortsArrayOutputWithContext(context.Context) InstancePublicPortsArrayOutput
}

InstancePublicPortsArrayInput is an input type that accepts InstancePublicPortsArray and InstancePublicPortsArrayOutput values. You can construct a concrete instance of `InstancePublicPortsArrayInput` via: 

InstancePublicPortsArray{ InstancePublicPortsArgs{...} }

type InstancePublicPortsArrayOutput 

type InstancePublicPortsArrayOutput struct{ *pulumi.OutputState }

func (InstancePublicPortsArrayOutput) ElementType 

func (InstancePublicPortsArrayOutput) ElementType() reflect.Type

func (InstancePublicPortsArrayOutput) Index 

func (o InstancePublicPortsArrayOutput) Index(i pulumi.IntInput) InstancePublicPortsOutput

func (InstancePublicPortsArrayOutput) ToInstancePublicPortsArrayOutput 

func (o InstancePublicPortsArrayOutput) ToInstancePublicPortsArrayOutput() InstancePublicPortsArrayOutput

func (InstancePublicPortsArrayOutput) ToInstancePublicPortsArrayOutputWithContext 

func (o InstancePublicPortsArrayOutput) ToInstancePublicPortsArrayOutputWithContext(ctx context.Context) InstancePublicPortsArrayOutput

type InstancePublicPortsInput 

type InstancePublicPortsInput interface {
	pulumi.Input

	ToInstancePublicPortsOutput() InstancePublicPortsOutput
	ToInstancePublicPortsOutputWithContext(ctx context.Context) InstancePublicPortsOutput
}

type InstancePublicPortsMap 

type InstancePublicPortsMap map[string]InstancePublicPortsInput

func (InstancePublicPortsMap) ElementType 

func (InstancePublicPortsMap) ElementType() reflect.Type

func (InstancePublicPortsMap) ToInstancePublicPortsMapOutput 

func (i InstancePublicPortsMap) ToInstancePublicPortsMapOutput() InstancePublicPortsMapOutput

func (InstancePublicPortsMap) ToInstancePublicPortsMapOutputWithContext 

func (i InstancePublicPortsMap) ToInstancePublicPortsMapOutputWithContext(ctx context.Context) InstancePublicPortsMapOutput

type InstancePublicPortsMapInput 

type InstancePublicPortsMapInput interface {
	pulumi.Input

	ToInstancePublicPortsMapOutput() InstancePublicPortsMapOutput
	ToInstancePublicPortsMapOutputWithContext(context.Context) InstancePublicPortsMapOutput
}

InstancePublicPortsMapInput is an input type that accepts InstancePublicPortsMap and InstancePublicPortsMapOutput values. You can construct a concrete instance of `InstancePublicPortsMapInput` via: 

InstancePublicPortsMap{ "key": InstancePublicPortsArgs{...} }

type InstancePublicPortsMapOutput 

type InstancePublicPortsMapOutput struct{ *pulumi.OutputState }

func (InstancePublicPortsMapOutput) ElementType 

func (InstancePublicPortsMapOutput) ElementType() reflect.Type

func (InstancePublicPortsMapOutput) MapIndex 

func (o InstancePublicPortsMapOutput) MapIndex(k pulumi.StringInput) InstancePublicPortsOutput

func (InstancePublicPortsMapOutput) ToInstancePublicPortsMapOutput 

func (o InstancePublicPortsMapOutput) ToInstancePublicPortsMapOutput() InstancePublicPortsMapOutput

func (InstancePublicPortsMapOutput) ToInstancePublicPortsMapOutputWithContext 

func (o InstancePublicPortsMapOutput) ToInstancePublicPortsMapOutputWithContext(ctx context.Context) InstancePublicPortsMapOutput

type InstancePublicPortsOutput 

type InstancePublicPortsOutput struct{ *pulumi.OutputState }

func (InstancePublicPortsOutput) ElementType 

func (InstancePublicPortsOutput) ElementType() reflect.Type

func (InstancePublicPortsOutput) ToInstancePublicPortsOutput 

func (o InstancePublicPortsOutput) ToInstancePublicPortsOutput() InstancePublicPortsOutput

func (InstancePublicPortsOutput) ToInstancePublicPortsOutputWithContext 

func (o InstancePublicPortsOutput) ToInstancePublicPortsOutputWithContext(ctx context.Context) InstancePublicPortsOutput

type InstancePublicPortsPortInfo 

type InstancePublicPortsPortInfo struct {
	// Set of CIDR blocks.
	Cidrs []string `pulumi:"cidrs"`
	// First port in a range of open ports on an instance.
	FromPort int `pulumi:"fromPort"`
	// IP protocol name. Valid values are `tcp`, `all`, `udp`, and `icmp`.
	Protocol string `pulumi:"protocol"`
	// Last port in a range of open ports on an instance.
	ToPort int `pulumi:"toPort"`
}

type InstancePublicPortsPortInfoArgs 

type InstancePublicPortsPortInfoArgs struct {
	// Set of CIDR blocks.
	Cidrs pulumi.StringArrayInput `pulumi:"cidrs"`
	// First port in a range of open ports on an instance.
	FromPort pulumi.IntInput `pulumi:"fromPort"`
	// IP protocol name. Valid values are `tcp`, `all`, `udp`, and `icmp`.
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// Last port in a range of open ports on an instance.
	ToPort pulumi.IntInput `pulumi:"toPort"`
}

func (InstancePublicPortsPortInfoArgs) ElementType 

func (InstancePublicPortsPortInfoArgs) ElementType() reflect.Type

func (InstancePublicPortsPortInfoArgs) ToInstancePublicPortsPortInfoOutput 

func (i InstancePublicPortsPortInfoArgs) ToInstancePublicPortsPortInfoOutput() InstancePublicPortsPortInfoOutput

func (InstancePublicPortsPortInfoArgs) ToInstancePublicPortsPortInfoOutputWithContext 

func (i InstancePublicPortsPortInfoArgs) ToInstancePublicPortsPortInfoOutputWithContext(ctx context.Context) InstancePublicPortsPortInfoOutput

type InstancePublicPortsPortInfoArray 

type InstancePublicPortsPortInfoArray []InstancePublicPortsPortInfoInput

func (InstancePublicPortsPortInfoArray) ElementType 

func (InstancePublicPortsPortInfoArray) ElementType() reflect.Type

func (InstancePublicPortsPortInfoArray) ToInstancePublicPortsPortInfoArrayOutput 

func (i InstancePublicPortsPortInfoArray) ToInstancePublicPortsPortInfoArrayOutput() InstancePublicPortsPortInfoArrayOutput

func (InstancePublicPortsPortInfoArray) ToInstancePublicPortsPortInfoArrayOutputWithContext 

func (i InstancePublicPortsPortInfoArray) ToInstancePublicPortsPortInfoArrayOutputWithContext(ctx context.Context) InstancePublicPortsPortInfoArrayOutput

type InstancePublicPortsPortInfoArrayInput 

type InstancePublicPortsPortInfoArrayInput interface {
	pulumi.Input

	ToInstancePublicPortsPortInfoArrayOutput() InstancePublicPortsPortInfoArrayOutput
	ToInstancePublicPortsPortInfoArrayOutputWithContext(context.Context) InstancePublicPortsPortInfoArrayOutput
}

InstancePublicPortsPortInfoArrayInput is an input type that accepts InstancePublicPortsPortInfoArray and InstancePublicPortsPortInfoArrayOutput values. You can construct a concrete instance of `InstancePublicPortsPortInfoArrayInput` via: 

InstancePublicPortsPortInfoArray{ InstancePublicPortsPortInfoArgs{...} }

type InstancePublicPortsPortInfoArrayOutput 

type InstancePublicPortsPortInfoArrayOutput struct{ *pulumi.OutputState }

func (InstancePublicPortsPortInfoArrayOutput) ElementType 

func (InstancePublicPortsPortInfoArrayOutput) ElementType() reflect.Type

func (InstancePublicPortsPortInfoArrayOutput) Index 

func (o InstancePublicPortsPortInfoArrayOutput) Index(i pulumi.IntInput) InstancePublicPortsPortInfoOutput

func (InstancePublicPortsPortInfoArrayOutput) ToInstancePublicPortsPortInfoArrayOutput 

func (o InstancePublicPortsPortInfoArrayOutput) ToInstancePublicPortsPortInfoArrayOutput() InstancePublicPortsPortInfoArrayOutput

func (InstancePublicPortsPortInfoArrayOutput) ToInstancePublicPortsPortInfoArrayOutputWithContext 

func (o InstancePublicPortsPortInfoArrayOutput) ToInstancePublicPortsPortInfoArrayOutputWithContext(ctx context.Context) InstancePublicPortsPortInfoArrayOutput

type InstancePublicPortsPortInfoInput 

type InstancePublicPortsPortInfoInput interface {
	pulumi.Input

	ToInstancePublicPortsPortInfoOutput() InstancePublicPortsPortInfoOutput
	ToInstancePublicPortsPortInfoOutputWithContext(context.Context) InstancePublicPortsPortInfoOutput
}

InstancePublicPortsPortInfoInput is an input type that accepts InstancePublicPortsPortInfoArgs and InstancePublicPortsPortInfoOutput values. You can construct a concrete instance of `InstancePublicPortsPortInfoInput` via: 

InstancePublicPortsPortInfoArgs{...}

type InstancePublicPortsPortInfoOutput 

type InstancePublicPortsPortInfoOutput struct{ *pulumi.OutputState }

func (InstancePublicPortsPortInfoOutput) Cidrs 

func (o InstancePublicPortsPortInfoOutput) Cidrs() pulumi.StringArrayOutput

Set of CIDR blocks.

func (InstancePublicPortsPortInfoOutput) ElementType 

func (InstancePublicPortsPortInfoOutput) ElementType() reflect.Type

func (InstancePublicPortsPortInfoOutput) FromPort 

func (o InstancePublicPortsPortInfoOutput) FromPort() pulumi.IntOutput

First port in a range of open ports on an instance.

func (InstancePublicPortsPortInfoOutput) Protocol 

func (o InstancePublicPortsPortInfoOutput) Protocol() pulumi.StringOutput

IP protocol name. Valid values are `tcp`, `all`, `udp`, and `icmp`.

func (InstancePublicPortsPortInfoOutput) ToInstancePublicPortsPortInfoOutput 

func (o InstancePublicPortsPortInfoOutput) ToInstancePublicPortsPortInfoOutput() InstancePublicPortsPortInfoOutput

func (InstancePublicPortsPortInfoOutput) ToInstancePublicPortsPortInfoOutputWithContext 

func (o InstancePublicPortsPortInfoOutput) ToInstancePublicPortsPortInfoOutputWithContext(ctx context.Context) InstancePublicPortsPortInfoOutput

func (InstancePublicPortsPortInfoOutput) ToPort 

func (o InstancePublicPortsPortInfoOutput) ToPort() pulumi.IntOutput

Last port in a range of open ports on an instance.

type InstancePublicPortsState 

type InstancePublicPortsState struct {
	// Name of the Lightsail Instance.
	InstanceName pulumi.StringPtrInput
	// Configuration block with port information. AWS closes all currently open ports that are not included in the `portInfo`. Detailed below.
	PortInfos InstancePublicPortsPortInfoArrayInput
}

func (InstancePublicPortsState) ElementType 

func (InstancePublicPortsState) ElementType() reflect.Type

type InstanceState 

type InstanceState struct {
	// The ARN of the Lightsail instance (matches `id`).
	Arn pulumi.StringPtrInput
	// The Availability Zone in which to create your
	// instance (see list below)
	AvailabilityZone pulumi.StringPtrInput
	// 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`
	BlueprintId pulumi.StringPtrInput
	// The bundle of specification information (see list below)
	BundleId pulumi.StringPtrInput
	// The number of vCPUs the instance has.
	CpuCount pulumi.IntPtrInput
	// The timestamp when the instance was created.
	CreatedAt pulumi.StringPtrInput
	// (**Deprecated**) The first IPv6 address of the Lightsail instance. Use `ipv6Addresses` attribute instead.
	//
	// Deprecated: use `ipv6_addresses` attribute instead
	Ipv6Address pulumi.StringPtrInput
	// List of IPv6 addresses for the Lightsail instance.
	Ipv6Addresses pulumi.StringArrayInput
	// A Boolean value indicating whether this instance has a static IP assigned to it.
	IsStaticIp pulumi.BoolPtrInput
	// The name of your key pair. Created in the
	// Lightsail console (cannot use `ec2.KeyPair` at this time)
	KeyPairName pulumi.StringPtrInput
	// The name of the Lightsail Instance. Names be unique within each AWS Region in your Lightsail account.
	Name pulumi.StringPtrInput
	// The private IP address of the instance.
	PrivateIpAddress pulumi.StringPtrInput
	// The public IP address of the instance.
	PublicIpAddress pulumi.StringPtrInput
	// The amount of RAM in GB on the instance (e.g., 1.0).
	RamSize pulumi.Float64PtrInput
	// 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 `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// launch script to configure server with additional user data
	UserData pulumi.StringPtrInput
	// The user name for connecting to the instance (e.g., ec2-user).
	Username pulumi.StringPtrInput
}

func (InstanceState) ElementType 

func (InstanceState) ElementType() reflect.Type

type KeyPair 

type KeyPair struct {
	pulumi.CustomResourceState

	// The ARN of the Lightsail key pair
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The MD5 public key fingerprint for the encrypted
	// private key
	EncryptedFingerprint pulumi.StringOutput `pulumi:"encryptedFingerprint"`
	// the private key material, base 64 encoded and
	// encrypted with the given `pgpKey`. This is only populated when creating a new
	// key and `pgpKey` is supplied
	EncryptedPrivateKey pulumi.StringOutput `pulumi:"encryptedPrivateKey"`
	// The MD5 public key fingerprint as specified in section 4 of RFC 4716.
	Fingerprint pulumi.StringOutput `pulumi:"fingerprint"`
	// The name of the Lightsail Key Pair. If omitted, a unique
	// name will be generated by this provider
	Name       pulumi.StringOutput    `pulumi:"name"`
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	// An optional PGP key to encrypt the resulting private
	// key material. Only used when creating a new key pair
	PgpKey pulumi.StringPtrOutput `pulumi:"pgpKey"`
	// the private key, base64 encoded. This is only populated
	// when creating a new key, and when no `pgpKey` is provided
	PrivateKey pulumi.StringOutput `pulumi:"privateKey"`
	// The public key material. This public key will be
	// imported into Lightsail
	PublicKey pulumi.StringOutput `pulumi:"publicKey"`
}

Provides a Lightsail Key Pair, for use with Lightsail Instances. These key pairs are separate from EC2 Key Pairs, and must be created or imported for use with Lightsail.

> **Note:** Lightsail is currently only supported in a limited number of AWS Regions, please see ["Regions and Availability Zones in Amazon Lightsail"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details

## Example Usage ### Create New Key Pair

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewKeyPair(ctx, "lgKeyPair", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Create New Key Pair with PGP Encrypted Private Key

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewKeyPair(ctx, "lgKeyPair", &lightsail.KeyPairArgs{
			PgpKey: pulumi.String("keybase:keybaseusername"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Existing Public Key Import

```go package main

import ( 

"io/ioutil"

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := ioutil.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewKeyPair(ctx, "lgKeyPair", &lightsail.KeyPairArgs{
			PublicKey: readFileOrPanic("~/.ssh/id_rsa.pub"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Lightsail Key Pairs cannot be imported, because the private and public key are only available on initial creation.

func GetKeyPair 

func GetKeyPair(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *KeyPairState, opts ...pulumi.ResourceOption) (*KeyPair, error)

GetKeyPair gets an existing KeyPair resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewKeyPair 

func NewKeyPair(ctx *pulumi.Context,
	name string, args *KeyPairArgs, opts ...pulumi.ResourceOption) (*KeyPair, error)

NewKeyPair registers a new resource with the given unique name, arguments, and options.

func (*KeyPair) ElementType 

func (*KeyPair) ElementType() reflect.Type

func (*KeyPair) ToKeyPairOutput 

func (i *KeyPair) ToKeyPairOutput() KeyPairOutput

func (*KeyPair) ToKeyPairOutputWithContext 

func (i *KeyPair) ToKeyPairOutputWithContext(ctx context.Context) KeyPairOutput

type KeyPairArgs 

type KeyPairArgs struct {
	// The name of the Lightsail Key Pair. If omitted, a unique
	// name will be generated by this provider
	Name       pulumi.StringPtrInput
	NamePrefix pulumi.StringPtrInput
	// An optional PGP key to encrypt the resulting private
	// key material. Only used when creating a new key pair
	PgpKey pulumi.StringPtrInput
	// The public key material. This public key will be
	// imported into Lightsail
	PublicKey pulumi.StringPtrInput
}

The set of arguments for constructing a KeyPair resource.

func (KeyPairArgs) ElementType 

func (KeyPairArgs) ElementType() reflect.Type

type KeyPairArray 

type KeyPairArray []KeyPairInput

func (KeyPairArray) ElementType 

func (KeyPairArray) ElementType() reflect.Type

func (KeyPairArray) ToKeyPairArrayOutput 

func (i KeyPairArray) ToKeyPairArrayOutput() KeyPairArrayOutput

func (KeyPairArray) ToKeyPairArrayOutputWithContext 

func (i KeyPairArray) ToKeyPairArrayOutputWithContext(ctx context.Context) KeyPairArrayOutput

type KeyPairArrayInput 

type KeyPairArrayInput interface {
	pulumi.Input

	ToKeyPairArrayOutput() KeyPairArrayOutput
	ToKeyPairArrayOutputWithContext(context.Context) KeyPairArrayOutput
}

KeyPairArrayInput is an input type that accepts KeyPairArray and KeyPairArrayOutput values. You can construct a concrete instance of `KeyPairArrayInput` via: 

KeyPairArray{ KeyPairArgs{...} }

type KeyPairArrayOutput 

type KeyPairArrayOutput struct{ *pulumi.OutputState }

func (KeyPairArrayOutput) ElementType 

func (KeyPairArrayOutput) ElementType() reflect.Type

func (KeyPairArrayOutput) Index 

func (o KeyPairArrayOutput) Index(i pulumi.IntInput) KeyPairOutput

func (KeyPairArrayOutput) ToKeyPairArrayOutput 

func (o KeyPairArrayOutput) ToKeyPairArrayOutput() KeyPairArrayOutput

func (KeyPairArrayOutput) ToKeyPairArrayOutputWithContext 

func (o KeyPairArrayOutput) ToKeyPairArrayOutputWithContext(ctx context.Context) KeyPairArrayOutput

type KeyPairInput 

type KeyPairInput interface {
	pulumi.Input

	ToKeyPairOutput() KeyPairOutput
	ToKeyPairOutputWithContext(ctx context.Context) KeyPairOutput
}

type KeyPairMap 

type KeyPairMap map[string]KeyPairInput

func (KeyPairMap) ElementType 

func (KeyPairMap) ElementType() reflect.Type

func (KeyPairMap) ToKeyPairMapOutput 

func (i KeyPairMap) ToKeyPairMapOutput() KeyPairMapOutput

func (KeyPairMap) ToKeyPairMapOutputWithContext 

func (i KeyPairMap) ToKeyPairMapOutputWithContext(ctx context.Context) KeyPairMapOutput

type KeyPairMapInput 

type KeyPairMapInput interface {
	pulumi.Input

	ToKeyPairMapOutput() KeyPairMapOutput
	ToKeyPairMapOutputWithContext(context.Context) KeyPairMapOutput
}

KeyPairMapInput is an input type that accepts KeyPairMap and KeyPairMapOutput values. You can construct a concrete instance of `KeyPairMapInput` via: 

KeyPairMap{ "key": KeyPairArgs{...} }

type KeyPairMapOutput 

type KeyPairMapOutput struct{ *pulumi.OutputState }

func (KeyPairMapOutput) ElementType 

func (KeyPairMapOutput) ElementType() reflect.Type

func (KeyPairMapOutput) MapIndex 

func (o KeyPairMapOutput) MapIndex(k pulumi.StringInput) KeyPairOutput

func (KeyPairMapOutput) ToKeyPairMapOutput 

func (o KeyPairMapOutput) ToKeyPairMapOutput() KeyPairMapOutput

func (KeyPairMapOutput) ToKeyPairMapOutputWithContext 

func (o KeyPairMapOutput) ToKeyPairMapOutputWithContext(ctx context.Context) KeyPairMapOutput

type KeyPairOutput 

type KeyPairOutput struct{ *pulumi.OutputState }

func (KeyPairOutput) ElementType 

func (KeyPairOutput) ElementType() reflect.Type

func (KeyPairOutput) ToKeyPairOutput 

func (o KeyPairOutput) ToKeyPairOutput() KeyPairOutput

func (KeyPairOutput) ToKeyPairOutputWithContext 

func (o KeyPairOutput) ToKeyPairOutputWithContext(ctx context.Context) KeyPairOutput

type KeyPairState 

type KeyPairState struct {
	// The ARN of the Lightsail key pair
	Arn pulumi.StringPtrInput
	// The MD5 public key fingerprint for the encrypted
	// private key
	EncryptedFingerprint pulumi.StringPtrInput
	// the private key material, base 64 encoded and
	// encrypted with the given `pgpKey`. This is only populated when creating a new
	// key and `pgpKey` is supplied
	EncryptedPrivateKey pulumi.StringPtrInput
	// The MD5 public key fingerprint as specified in section 4 of RFC 4716.
	Fingerprint pulumi.StringPtrInput
	// The name of the Lightsail Key Pair. If omitted, a unique
	// name will be generated by this provider
	Name       pulumi.StringPtrInput
	NamePrefix pulumi.StringPtrInput
	// An optional PGP key to encrypt the resulting private
	// key material. Only used when creating a new key pair
	PgpKey pulumi.StringPtrInput
	// the private key, base64 encoded. This is only populated
	// when creating a new key, and when no `pgpKey` is provided
	PrivateKey pulumi.StringPtrInput
	// The public key material. This public key will be
	// imported into Lightsail
	PublicKey pulumi.StringPtrInput
}

func (KeyPairState) ElementType 

func (KeyPairState) ElementType() reflect.Type

type StaticIp 

type StaticIp struct {
	pulumi.CustomResourceState

	// The ARN of the Lightsail static IP
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The allocated static IP address
	IpAddress pulumi.StringOutput `pulumi:"ipAddress"`
	// The name for the allocated static IP
	Name pulumi.StringOutput `pulumi:"name"`
	// The support code.
	SupportCode pulumi.StringOutput `pulumi:"supportCode"`
}

Allocates a static IP address.

> **Note:** Lightsail is currently only supported in a limited number of AWS Regions, please see ["Regions and Availability Zones in Amazon Lightsail"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewStaticIp(ctx, "test", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetStaticIp 

func GetStaticIp(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *StaticIpState, opts ...pulumi.ResourceOption) (*StaticIp, error)

GetStaticIp gets an existing StaticIp resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewStaticIp 

func NewStaticIp(ctx *pulumi.Context,
	name string, args *StaticIpArgs, opts ...pulumi.ResourceOption) (*StaticIp, error)

NewStaticIp registers a new resource with the given unique name, arguments, and options.

func (*StaticIp) ElementType 

func (*StaticIp) ElementType() reflect.Type

func (*StaticIp) ToStaticIpOutput 

func (i *StaticIp) ToStaticIpOutput() StaticIpOutput

func (*StaticIp) ToStaticIpOutputWithContext 

func (i *StaticIp) ToStaticIpOutputWithContext(ctx context.Context) StaticIpOutput

type StaticIpArgs 

type StaticIpArgs struct {
	// The name for the allocated static IP
	Name pulumi.StringPtrInput
}

The set of arguments for constructing a StaticIp resource.

func (StaticIpArgs) ElementType 

func (StaticIpArgs) ElementType() reflect.Type

type StaticIpArray 

type StaticIpArray []StaticIpInput

func (StaticIpArray) ElementType 

func (StaticIpArray) ElementType() reflect.Type

func (StaticIpArray) ToStaticIpArrayOutput 

func (i StaticIpArray) ToStaticIpArrayOutput() StaticIpArrayOutput

func (StaticIpArray) ToStaticIpArrayOutputWithContext 

func (i StaticIpArray) ToStaticIpArrayOutputWithContext(ctx context.Context) StaticIpArrayOutput

type StaticIpArrayInput 

type StaticIpArrayInput interface {
	pulumi.Input

	ToStaticIpArrayOutput() StaticIpArrayOutput
	ToStaticIpArrayOutputWithContext(context.Context) StaticIpArrayOutput
}

StaticIpArrayInput is an input type that accepts StaticIpArray and StaticIpArrayOutput values. You can construct a concrete instance of `StaticIpArrayInput` via: 

StaticIpArray{ StaticIpArgs{...} }

type StaticIpArrayOutput 

type StaticIpArrayOutput struct{ *pulumi.OutputState }

func (StaticIpArrayOutput) ElementType 

func (StaticIpArrayOutput) ElementType() reflect.Type

func (StaticIpArrayOutput) Index 

func (o StaticIpArrayOutput) Index(i pulumi.IntInput) StaticIpOutput

func (StaticIpArrayOutput) ToStaticIpArrayOutput 

func (o StaticIpArrayOutput) ToStaticIpArrayOutput() StaticIpArrayOutput

func (StaticIpArrayOutput) ToStaticIpArrayOutputWithContext 

func (o StaticIpArrayOutput) ToStaticIpArrayOutputWithContext(ctx context.Context) StaticIpArrayOutput

type StaticIpAttachment 

type StaticIpAttachment struct {
	pulumi.CustomResourceState

	// The name of the Lightsail instance to attach the IP to
	InstanceName pulumi.StringOutput `pulumi:"instanceName"`
	// The allocated static IP address
	IpAddress pulumi.StringOutput `pulumi:"ipAddress"`
	// The name of the allocated static IP
	StaticIpName pulumi.StringOutput `pulumi:"staticIpName"`
}

Provides a static IP address attachment - relationship between a Lightsail static IP & Lightsail instance.

> **Note:** Lightsail is currently only supported in a limited number of AWS Regions, please see ["Regions and Availability Zones in Amazon Lightsail"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/lightsail"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testStaticIp, err := lightsail.NewStaticIp(ctx, "testStaticIp", nil)
		if err != nil {
			return err
		}
		testInstance, err := lightsail.NewInstance(ctx, "testInstance", &lightsail.InstanceArgs{
			AvailabilityZone: pulumi.String("us-east-1b"),
			BlueprintId:      pulumi.String("string"),
			BundleId:         pulumi.String("string"),
			KeyPairName:      pulumi.String("some_key_name"),
		})
		if err != nil {
			return err
		}
		_, err = lightsail.NewStaticIpAttachment(ctx, "testStaticIpAttachment", &lightsail.StaticIpAttachmentArgs{
			StaticIpName: testStaticIp.ID(),
			InstanceName: testInstance.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetStaticIpAttachment 

func GetStaticIpAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *StaticIpAttachmentState, opts ...pulumi.ResourceOption) (*StaticIpAttachment, error)

GetStaticIpAttachment gets an existing StaticIpAttachment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewStaticIpAttachment 

func NewStaticIpAttachment(ctx *pulumi.Context,
	name string, args *StaticIpAttachmentArgs, opts ...pulumi.ResourceOption) (*StaticIpAttachment, error)

NewStaticIpAttachment registers a new resource with the given unique name, arguments, and options.

func (*StaticIpAttachment) ElementType 

func (*StaticIpAttachment) ElementType() reflect.Type

func (*StaticIpAttachment) ToStaticIpAttachmentOutput 

func (i *StaticIpAttachment) ToStaticIpAttachmentOutput() StaticIpAttachmentOutput

func (*StaticIpAttachment) ToStaticIpAttachmentOutputWithContext 

func (i *StaticIpAttachment) ToStaticIpAttachmentOutputWithContext(ctx context.Context) StaticIpAttachmentOutput

type StaticIpAttachmentArgs 

type StaticIpAttachmentArgs struct {
	// The name of the Lightsail instance to attach the IP to
	InstanceName pulumi.StringInput
	// The name of the allocated static IP
	StaticIpName pulumi.StringInput
}

The set of arguments for constructing a StaticIpAttachment resource.

func (StaticIpAttachmentArgs) ElementType 

func (StaticIpAttachmentArgs) ElementType() reflect.Type

type StaticIpAttachmentArray 

type StaticIpAttachmentArray []StaticIpAttachmentInput

func (StaticIpAttachmentArray) ElementType 

func (StaticIpAttachmentArray) ElementType() reflect.Type

func (StaticIpAttachmentArray) ToStaticIpAttachmentArrayOutput 

func (i StaticIpAttachmentArray) ToStaticIpAttachmentArrayOutput() StaticIpAttachmentArrayOutput

func (StaticIpAttachmentArray) ToStaticIpAttachmentArrayOutputWithContext 

func (i StaticIpAttachmentArray) ToStaticIpAttachmentArrayOutputWithContext(ctx context.Context) StaticIpAttachmentArrayOutput

type StaticIpAttachmentArrayInput 

type StaticIpAttachmentArrayInput interface {
	pulumi.Input

	ToStaticIpAttachmentArrayOutput() StaticIpAttachmentArrayOutput
	ToStaticIpAttachmentArrayOutputWithContext(context.Context) StaticIpAttachmentArrayOutput
}

StaticIpAttachmentArrayInput is an input type that accepts StaticIpAttachmentArray and StaticIpAttachmentArrayOutput values. You can construct a concrete instance of `StaticIpAttachmentArrayInput` via: 

StaticIpAttachmentArray{ StaticIpAttachmentArgs{...} }

type StaticIpAttachmentArrayOutput 

type StaticIpAttachmentArrayOutput struct{ *pulumi.OutputState }

func (StaticIpAttachmentArrayOutput) ElementType 

func (StaticIpAttachmentArrayOutput) ElementType() reflect.Type

func (StaticIpAttachmentArrayOutput) Index 

func (o StaticIpAttachmentArrayOutput) Index(i pulumi.IntInput) StaticIpAttachmentOutput

func (StaticIpAttachmentArrayOutput) ToStaticIpAttachmentArrayOutput 

func (o StaticIpAttachmentArrayOutput) ToStaticIpAttachmentArrayOutput() StaticIpAttachmentArrayOutput

func (StaticIpAttachmentArrayOutput) ToStaticIpAttachmentArrayOutputWithContext 

func (o StaticIpAttachmentArrayOutput) ToStaticIpAttachmentArrayOutputWithContext(ctx context.Context) StaticIpAttachmentArrayOutput

type StaticIpAttachmentInput 

type StaticIpAttachmentInput interface {
	pulumi.Input

	ToStaticIpAttachmentOutput() StaticIpAttachmentOutput
	ToStaticIpAttachmentOutputWithContext(ctx context.Context) StaticIpAttachmentOutput
}

type StaticIpAttachmentMap 

type StaticIpAttachmentMap map[string]StaticIpAttachmentInput

func (StaticIpAttachmentMap) ElementType 

func (StaticIpAttachmentMap) ElementType() reflect.Type

func (StaticIpAttachmentMap) ToStaticIpAttachmentMapOutput 

func (i StaticIpAttachmentMap) ToStaticIpAttachmentMapOutput() StaticIpAttachmentMapOutput

func (StaticIpAttachmentMap) ToStaticIpAttachmentMapOutputWithContext 

func (i StaticIpAttachmentMap) ToStaticIpAttachmentMapOutputWithContext(ctx context.Context) StaticIpAttachmentMapOutput

type StaticIpAttachmentMapInput 

type StaticIpAttachmentMapInput interface {
	pulumi.Input

	ToStaticIpAttachmentMapOutput() StaticIpAttachmentMapOutput
	ToStaticIpAttachmentMapOutputWithContext(context.Context) StaticIpAttachmentMapOutput
}

StaticIpAttachmentMapInput is an input type that accepts StaticIpAttachmentMap and StaticIpAttachmentMapOutput values. You can construct a concrete instance of `StaticIpAttachmentMapInput` via: 

StaticIpAttachmentMap{ "key": StaticIpAttachmentArgs{...} }

type StaticIpAttachmentMapOutput 

type StaticIpAttachmentMapOutput struct{ *pulumi.OutputState }

func (StaticIpAttachmentMapOutput) ElementType 

func (StaticIpAttachmentMapOutput) ElementType() reflect.Type

func (StaticIpAttachmentMapOutput) MapIndex 

func (o StaticIpAttachmentMapOutput) MapIndex(k pulumi.StringInput) StaticIpAttachmentOutput

func (StaticIpAttachmentMapOutput) ToStaticIpAttachmentMapOutput 

func (o StaticIpAttachmentMapOutput) ToStaticIpAttachmentMapOutput() StaticIpAttachmentMapOutput

func (StaticIpAttachmentMapOutput) ToStaticIpAttachmentMapOutputWithContext 

func (o StaticIpAttachmentMapOutput) ToStaticIpAttachmentMapOutputWithContext(ctx context.Context) StaticIpAttachmentMapOutput

type StaticIpAttachmentOutput 

type StaticIpAttachmentOutput struct{ *pulumi.OutputState }

func (StaticIpAttachmentOutput) ElementType 

func (StaticIpAttachmentOutput) ElementType() reflect.Type

func (StaticIpAttachmentOutput) ToStaticIpAttachmentOutput 

func (o StaticIpAttachmentOutput) ToStaticIpAttachmentOutput() StaticIpAttachmentOutput

func (StaticIpAttachmentOutput) ToStaticIpAttachmentOutputWithContext 

func (o StaticIpAttachmentOutput) ToStaticIpAttachmentOutputWithContext(ctx context.Context) StaticIpAttachmentOutput

type StaticIpAttachmentState 

type StaticIpAttachmentState struct {
	// The name of the Lightsail instance to attach the IP to
	InstanceName pulumi.StringPtrInput
	// The allocated static IP address
	IpAddress pulumi.StringPtrInput
	// The name of the allocated static IP
	StaticIpName pulumi.StringPtrInput
}

func (StaticIpAttachmentState) ElementType 

func (StaticIpAttachmentState) ElementType() reflect.Type

type StaticIpInput 

type StaticIpInput interface {
	pulumi.Input

	ToStaticIpOutput() StaticIpOutput
	ToStaticIpOutputWithContext(ctx context.Context) StaticIpOutput
}

type StaticIpMap 

type StaticIpMap map[string]StaticIpInput

func (StaticIpMap) ElementType 

func (StaticIpMap) ElementType() reflect.Type

func (StaticIpMap) ToStaticIpMapOutput 

func (i StaticIpMap) ToStaticIpMapOutput() StaticIpMapOutput

func (StaticIpMap) ToStaticIpMapOutputWithContext 

func (i StaticIpMap) ToStaticIpMapOutputWithContext(ctx context.Context) StaticIpMapOutput

type StaticIpMapInput 

type StaticIpMapInput interface {
	pulumi.Input

	ToStaticIpMapOutput() StaticIpMapOutput
	ToStaticIpMapOutputWithContext(context.Context) StaticIpMapOutput
}

StaticIpMapInput is an input type that accepts StaticIpMap and StaticIpMapOutput values. You can construct a concrete instance of `StaticIpMapInput` via: 

StaticIpMap{ "key": StaticIpArgs{...} }

type StaticIpMapOutput 

type StaticIpMapOutput struct{ *pulumi.OutputState }

func (StaticIpMapOutput) ElementType 

func (StaticIpMapOutput) ElementType() reflect.Type

func (StaticIpMapOutput) MapIndex 

func (o StaticIpMapOutput) MapIndex(k pulumi.StringInput) StaticIpOutput

func (StaticIpMapOutput) ToStaticIpMapOutput 

func (o StaticIpMapOutput) ToStaticIpMapOutput() StaticIpMapOutput

func (StaticIpMapOutput) ToStaticIpMapOutputWithContext 

func (o StaticIpMapOutput) ToStaticIpMapOutputWithContext(ctx context.Context) StaticIpMapOutput

type StaticIpOutput 

type StaticIpOutput struct{ *pulumi.OutputState }

func (StaticIpOutput) ElementType 

func (StaticIpOutput) ElementType() reflect.Type

func (StaticIpOutput) ToStaticIpOutput 

func (o StaticIpOutput) ToStaticIpOutput() StaticIpOutput

func (StaticIpOutput) ToStaticIpOutputWithContext 

func (o StaticIpOutput) ToStaticIpOutputWithContext(ctx context.Context) StaticIpOutput

type StaticIpState 

type StaticIpState struct {
	// The ARN of the Lightsail static IP
	Arn pulumi.StringPtrInput
	// The allocated static IP address
	IpAddress pulumi.StringPtrInput
	// The name for the allocated static IP
	Name pulumi.StringPtrInput
	// The support code.
	SupportCode pulumi.StringPtrInput
}

func (StaticIpState) ElementType 

func (StaticIpState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.