lightsail

package
v5.13.0 Latest Latest
Warning

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

 Go to latest Published: Aug 26, 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 ContainerService added in v5.9.0 

type ContainerService struct {
	pulumi.CustomResourceState

	// The Amazon Resource Name (ARN) of the container service.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The Availability Zone. Follows the format us-east-2a (case-sensitive).
	AvailabilityZone pulumi.StringOutput `pulumi:"availabilityZone"`
	CreatedAt        pulumi.StringOutput `pulumi:"createdAt"`
	// A Boolean value indicating whether the container service is disabled. Defaults to `false`.
	IsDisabled pulumi.BoolPtrOutput `pulumi:"isDisabled"`
	// The name for the container service. Names must be of length 1 to 63, and be
	// unique within each AWS Region in your Lightsail account.
	Name pulumi.StringOutput `pulumi:"name"`
	// The power specification for the container service. The power specifies the amount of memory,
	// the number of vCPUs, and the monthly price of each node of the container service.
	// Possible values: `nano`, `micro`, `small`, `medium`, `large`, `xlarge`.
	Power pulumi.StringOutput `pulumi:"power"`
	// The ID of the power of the container service.
	// * `principalArn`- The principal ARN of the container service. The principal ARN can be used to create a trust
	//   relationship between your standard AWS account and your Lightsail container service. This allows you to give your
	//   service permission to access resources in your standard AWS account.
	PowerId      pulumi.StringOutput `pulumi:"powerId"`
	PrincipalArn pulumi.StringOutput `pulumi:"principalArn"`
	// The private domain name of the container service. The private domain name is accessible only
	// by other resources within the default virtual private cloud (VPC) of your Lightsail account.
	PrivateDomainName pulumi.StringOutput `pulumi:"privateDomainName"`
	// The public domain names to use with the container service, such as example.com
	// and www.example.com. You can specify up to four public domain names for a container service. The domain names that you
	// specify are used when you create a deployment with a container configured as the public endpoint of your container
	// service. If you don't specify public domain names, then you can use the default domain of the container service.
	// Defined below.
	PublicDomainNames ContainerServicePublicDomainNamesPtrOutput `pulumi:"publicDomainNames"`
	// The Lightsail resource type of the container service (i.e., ContainerService).
	ResourceType pulumi.StringOutput `pulumi:"resourceType"`
	// The scale specification for the container service. The scale specifies the allocated compute
	// nodes of the container service.
	Scale pulumi.IntOutput `pulumi:"scale"`
	// The current state of the container service.
	State   pulumi.StringOutput    `pulumi:"state"`
	Tags    pulumi.StringMapOutput `pulumi:"tags"`
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// The publicly accessible URL of the container service. If no public endpoint is specified in the
	// currentDeployment, this URL returns a 404 response.
	Url pulumi.StringOutput `pulumi:"url"`
}

An Amazon Lightsail container service is a highly scalable compute and networking resource on which you can deploy, run, and manage containers. For more information, see [Container services in Amazon Lightsail](https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-container-services).

> **Note:** For more information about the AWS Regions in which you can create Amazon Lightsail container services, 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).

## Example Usage ### Basic Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewContainerService(ctx, "myContainerService", &lightsail.ContainerServiceArgs{
			IsDisabled: pulumi.Bool(false),
			Power:      pulumi.String("nano"),
			Scale:      pulumi.Int(1),
			Tags: pulumi.StringMap{
				"foo1": pulumi.String("bar1"),
				"foo2": pulumi.String(""),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Public Domain Names

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewContainerService(ctx, "myContainerService", &lightsail.ContainerServiceArgs{
			PublicDomainNames: &lightsail.ContainerServicePublicDomainNamesArgs{
				Certificates: lightsail.ContainerServicePublicDomainNamesCertificateArray{
					&lightsail.ContainerServicePublicDomainNamesCertificateArgs{
						CertificateName: pulumi.String("example-certificate"),
						DomainNames: pulumi.StringArray{
							pulumi.String("www.example.com"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Lightsail Container Service can be imported using the `name`, e.g.,

```sh 

$ pulumi import aws:lightsail/containerService:ContainerService my_container_service container-service-1

```

func GetContainerService added in v5.9.0 

func GetContainerService(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ContainerServiceState, opts ...pulumi.ResourceOption) (*ContainerService, error)

GetContainerService gets an existing ContainerService 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 NewContainerService added in v5.9.0 

func NewContainerService(ctx *pulumi.Context,
	name string, args *ContainerServiceArgs, opts ...pulumi.ResourceOption) (*ContainerService, error)

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

func (*ContainerService) ElementType added in v5.9.0 

func (*ContainerService) ElementType() reflect.Type

func (*ContainerService) ToContainerServiceOutput added in v5.9.0 

func (i *ContainerService) ToContainerServiceOutput() ContainerServiceOutput

func (*ContainerService) ToContainerServiceOutputWithContext added in v5.9.0 

func (i *ContainerService) ToContainerServiceOutputWithContext(ctx context.Context) ContainerServiceOutput

type ContainerServiceArgs added in v5.9.0 

type ContainerServiceArgs struct {
	// A Boolean value indicating whether the container service is disabled. Defaults to `false`.
	IsDisabled pulumi.BoolPtrInput
	// The name for the container service. Names must be of length 1 to 63, and be
	// unique within each AWS Region in your Lightsail account.
	Name pulumi.StringPtrInput
	// The power specification for the container service. The power specifies the amount of memory,
	// the number of vCPUs, and the monthly price of each node of the container service.
	// Possible values: `nano`, `micro`, `small`, `medium`, `large`, `xlarge`.
	Power pulumi.StringInput
	// The public domain names to use with the container service, such as example.com
	// and www.example.com. You can specify up to four public domain names for a container service. The domain names that you
	// specify are used when you create a deployment with a container configured as the public endpoint of your container
	// service. If you don't specify public domain names, then you can use the default domain of the container service.
	// Defined below.
	PublicDomainNames ContainerServicePublicDomainNamesPtrInput
	// The scale specification for the container service. The scale specifies the allocated compute
	// nodes of the container service.
	Scale pulumi.IntInput
	Tags  pulumi.StringMapInput
}

The set of arguments for constructing a ContainerService resource.

func (ContainerServiceArgs) ElementType added in v5.9.0 

func (ContainerServiceArgs) ElementType() reflect.Type

type ContainerServiceArray added in v5.9.0 

type ContainerServiceArray []ContainerServiceInput

func (ContainerServiceArray) ElementType added in v5.9.0 

func (ContainerServiceArray) ElementType() reflect.Type

func (ContainerServiceArray) ToContainerServiceArrayOutput added in v5.9.0 

func (i ContainerServiceArray) ToContainerServiceArrayOutput() ContainerServiceArrayOutput

func (ContainerServiceArray) ToContainerServiceArrayOutputWithContext added in v5.9.0 

func (i ContainerServiceArray) ToContainerServiceArrayOutputWithContext(ctx context.Context) ContainerServiceArrayOutput

type ContainerServiceArrayInput added in v5.9.0 

type ContainerServiceArrayInput interface {
	pulumi.Input

	ToContainerServiceArrayOutput() ContainerServiceArrayOutput
	ToContainerServiceArrayOutputWithContext(context.Context) ContainerServiceArrayOutput
}

ContainerServiceArrayInput is an input type that accepts ContainerServiceArray and ContainerServiceArrayOutput values. You can construct a concrete instance of `ContainerServiceArrayInput` via: 

ContainerServiceArray{ ContainerServiceArgs{...} }

type ContainerServiceArrayOutput added in v5.9.0 

type ContainerServiceArrayOutput struct{ *pulumi.OutputState }

func (ContainerServiceArrayOutput) ElementType added in v5.9.0 

func (ContainerServiceArrayOutput) ElementType() reflect.Type

func (ContainerServiceArrayOutput) Index added in v5.9.0 

func (o ContainerServiceArrayOutput) Index(i pulumi.IntInput) ContainerServiceOutput

func (ContainerServiceArrayOutput) ToContainerServiceArrayOutput added in v5.9.0 

func (o ContainerServiceArrayOutput) ToContainerServiceArrayOutput() ContainerServiceArrayOutput

func (ContainerServiceArrayOutput) ToContainerServiceArrayOutputWithContext added in v5.9.0 

func (o ContainerServiceArrayOutput) ToContainerServiceArrayOutputWithContext(ctx context.Context) ContainerServiceArrayOutput

type ContainerServiceDeploymentVersion added in v5.9.0 

type ContainerServiceDeploymentVersion struct {
	pulumi.CustomResourceState

	// A set of configuration blocks that describe the settings of the containers that will be launched on the container service. Maximum of 53. Detailed below.
	Containers ContainerServiceDeploymentVersionContainerArrayOutput `pulumi:"containers"`
	// The timestamp when the deployment was created.
	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
	// A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
	PublicEndpoint ContainerServiceDeploymentVersionPublicEndpointPtrOutput `pulumi:"publicEndpoint"`
	// The name for the container service.
	ServiceName pulumi.StringOutput `pulumi:"serviceName"`
	// The current state of the container service.
	State pulumi.StringOutput `pulumi:"state"`
	// The version number of the deployment.
	Version pulumi.IntOutput `pulumi:"version"`
}

## Example Usage ### Basic Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewContainerServiceDeploymentVersion(ctx, "example", &lightsail.ContainerServiceDeploymentVersionArgs{
			Containers: lightsail.ContainerServiceDeploymentVersionContainerArray{
				&lightsail.ContainerServiceDeploymentVersionContainerArgs{
					ContainerName: pulumi.String("hello-world"),
					Image:         pulumi.String("amazon/amazon-lightsail:hello-world"),
					Commands:      pulumi.StringArray{},
					Environment: pulumi.StringMap{
						"MY_ENVIRONMENT_VARIABLE": pulumi.String("my_value"),
					},
					Ports: pulumi.StringMap{
						"80": pulumi.String("HTTP"),
					},
				},
			},
			PublicEndpoint: &lightsail.ContainerServiceDeploymentVersionPublicEndpointArgs{
				ContainerName: pulumi.String("hello-world"),
				ContainerPort: pulumi.Int(80),
				HealthCheck: &lightsail.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs{
					HealthyThreshold:   pulumi.Int(2),
					UnhealthyThreshold: pulumi.Int(2),
					TimeoutSeconds:     pulumi.Int(2),
					IntervalSeconds:    pulumi.Int(5),
					Path:               pulumi.String("/"),
					SuccessCodes:       pulumi.String("200-499"),
				},
			},
			ServiceName: pulumi.Any(aws_lightsail_container_service.Example.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Lightsail Container Service Deployment Version can be imported using the `service_name` and `version` separated by a slash (`/`), e.g.,

```sh 

$ pulumi import aws:lightsail/containerServiceDeploymentVersion:ContainerServiceDeploymentVersion example container-service-1/1

```

func GetContainerServiceDeploymentVersion added in v5.9.0 

func GetContainerServiceDeploymentVersion(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ContainerServiceDeploymentVersionState, opts ...pulumi.ResourceOption) (*ContainerServiceDeploymentVersion, error)

GetContainerServiceDeploymentVersion gets an existing ContainerServiceDeploymentVersion 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 NewContainerServiceDeploymentVersion added in v5.9.0 

func NewContainerServiceDeploymentVersion(ctx *pulumi.Context,
	name string, args *ContainerServiceDeploymentVersionArgs, opts ...pulumi.ResourceOption) (*ContainerServiceDeploymentVersion, error)

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

func (*ContainerServiceDeploymentVersion) ElementType added in v5.9.0 

func (*ContainerServiceDeploymentVersion) ElementType() reflect.Type

func (*ContainerServiceDeploymentVersion) ToContainerServiceDeploymentVersionOutput added in v5.9.0 

func (i *ContainerServiceDeploymentVersion) ToContainerServiceDeploymentVersionOutput() ContainerServiceDeploymentVersionOutput

func (*ContainerServiceDeploymentVersion) ToContainerServiceDeploymentVersionOutputWithContext added in v5.9.0 

func (i *ContainerServiceDeploymentVersion) ToContainerServiceDeploymentVersionOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionOutput

type ContainerServiceDeploymentVersionArgs added in v5.9.0 

type ContainerServiceDeploymentVersionArgs struct {
	// A set of configuration blocks that describe the settings of the containers that will be launched on the container service. Maximum of 53. Detailed below.
	Containers ContainerServiceDeploymentVersionContainerArrayInput
	// A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
	PublicEndpoint ContainerServiceDeploymentVersionPublicEndpointPtrInput
	// The name for the container service.
	ServiceName pulumi.StringInput
}

The set of arguments for constructing a ContainerServiceDeploymentVersion resource.

func (ContainerServiceDeploymentVersionArgs) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionArgs) ElementType() reflect.Type

type ContainerServiceDeploymentVersionArray added in v5.9.0 

type ContainerServiceDeploymentVersionArray []ContainerServiceDeploymentVersionInput

func (ContainerServiceDeploymentVersionArray) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionArray) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionArray) ToContainerServiceDeploymentVersionArrayOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionArray) ToContainerServiceDeploymentVersionArrayOutput() ContainerServiceDeploymentVersionArrayOutput

func (ContainerServiceDeploymentVersionArray) ToContainerServiceDeploymentVersionArrayOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionArray) ToContainerServiceDeploymentVersionArrayOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionArrayOutput

type ContainerServiceDeploymentVersionArrayInput added in v5.9.0 

type ContainerServiceDeploymentVersionArrayInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionArrayOutput() ContainerServiceDeploymentVersionArrayOutput
	ToContainerServiceDeploymentVersionArrayOutputWithContext(context.Context) ContainerServiceDeploymentVersionArrayOutput
}

ContainerServiceDeploymentVersionArrayInput is an input type that accepts ContainerServiceDeploymentVersionArray and ContainerServiceDeploymentVersionArrayOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionArrayInput` via: 

ContainerServiceDeploymentVersionArray{ ContainerServiceDeploymentVersionArgs{...} }

type ContainerServiceDeploymentVersionArrayOutput added in v5.9.0 

type ContainerServiceDeploymentVersionArrayOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionArrayOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionArrayOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionArrayOutput) Index added in v5.9.0 

func (o ContainerServiceDeploymentVersionArrayOutput) Index(i pulumi.IntInput) ContainerServiceDeploymentVersionOutput

func (ContainerServiceDeploymentVersionArrayOutput) ToContainerServiceDeploymentVersionArrayOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionArrayOutput) ToContainerServiceDeploymentVersionArrayOutput() ContainerServiceDeploymentVersionArrayOutput

func (ContainerServiceDeploymentVersionArrayOutput) ToContainerServiceDeploymentVersionArrayOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionArrayOutput) ToContainerServiceDeploymentVersionArrayOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionArrayOutput

type ContainerServiceDeploymentVersionContainer added in v5.9.0 

type ContainerServiceDeploymentVersionContainer struct {
	// The launch command for the container. A list of string.
	Commands []string `pulumi:"commands"`
	// The name for the container.
	ContainerName string `pulumi:"containerName"`
	// A key-value map of the environment variables of the container.
	Environment map[string]string `pulumi:"environment"`
	// The name of the image used for the container. Container images sourced from your Lightsail container service, that are registered and stored on your service, start with a colon (`:`). For example, `:container-service-1.mystaticwebsite.1`. Container images sourced from a public registry like Docker Hub don't start with a colon. For example, `nginx:latest` or `nginx`.
	Image string `pulumi:"image"`
	// A key-value map of the open firewall ports of the container. Valid values: `HTTP`, `HTTPS`, `TCP`, `UDP`.
	Ports map[string]string `pulumi:"ports"`
}

type ContainerServiceDeploymentVersionContainerArgs added in v5.9.0 

type ContainerServiceDeploymentVersionContainerArgs struct {
	// The launch command for the container. A list of string.
	Commands pulumi.StringArrayInput `pulumi:"commands"`
	// The name for the container.
	ContainerName pulumi.StringInput `pulumi:"containerName"`
	// A key-value map of the environment variables of the container.
	Environment pulumi.StringMapInput `pulumi:"environment"`
	// The name of the image used for the container. Container images sourced from your Lightsail container service, that are registered and stored on your service, start with a colon (`:`). For example, `:container-service-1.mystaticwebsite.1`. Container images sourced from a public registry like Docker Hub don't start with a colon. For example, `nginx:latest` or `nginx`.
	Image pulumi.StringInput `pulumi:"image"`
	// A key-value map of the open firewall ports of the container. Valid values: `HTTP`, `HTTPS`, `TCP`, `UDP`.
	Ports pulumi.StringMapInput `pulumi:"ports"`
}

func (ContainerServiceDeploymentVersionContainerArgs) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionContainerArgs) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionContainerArgs) ToContainerServiceDeploymentVersionContainerOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionContainerArgs) ToContainerServiceDeploymentVersionContainerOutput() ContainerServiceDeploymentVersionContainerOutput

func (ContainerServiceDeploymentVersionContainerArgs) ToContainerServiceDeploymentVersionContainerOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionContainerArgs) ToContainerServiceDeploymentVersionContainerOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionContainerOutput

type ContainerServiceDeploymentVersionContainerArray added in v5.9.0 

type ContainerServiceDeploymentVersionContainerArray []ContainerServiceDeploymentVersionContainerInput

func (ContainerServiceDeploymentVersionContainerArray) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionContainerArray) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionContainerArray) ToContainerServiceDeploymentVersionContainerArrayOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionContainerArray) ToContainerServiceDeploymentVersionContainerArrayOutput() ContainerServiceDeploymentVersionContainerArrayOutput

func (ContainerServiceDeploymentVersionContainerArray) ToContainerServiceDeploymentVersionContainerArrayOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionContainerArray) ToContainerServiceDeploymentVersionContainerArrayOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionContainerArrayOutput

type ContainerServiceDeploymentVersionContainerArrayInput added in v5.9.0 

type ContainerServiceDeploymentVersionContainerArrayInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionContainerArrayOutput() ContainerServiceDeploymentVersionContainerArrayOutput
	ToContainerServiceDeploymentVersionContainerArrayOutputWithContext(context.Context) ContainerServiceDeploymentVersionContainerArrayOutput
}

ContainerServiceDeploymentVersionContainerArrayInput is an input type that accepts ContainerServiceDeploymentVersionContainerArray and ContainerServiceDeploymentVersionContainerArrayOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionContainerArrayInput` via: 

ContainerServiceDeploymentVersionContainerArray{ ContainerServiceDeploymentVersionContainerArgs{...} }

type ContainerServiceDeploymentVersionContainerArrayOutput added in v5.9.0 

type ContainerServiceDeploymentVersionContainerArrayOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionContainerArrayOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionContainerArrayOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionContainerArrayOutput) Index added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerArrayOutput) Index(i pulumi.IntInput) ContainerServiceDeploymentVersionContainerOutput

func (ContainerServiceDeploymentVersionContainerArrayOutput) ToContainerServiceDeploymentVersionContainerArrayOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerArrayOutput) ToContainerServiceDeploymentVersionContainerArrayOutput() ContainerServiceDeploymentVersionContainerArrayOutput

func (ContainerServiceDeploymentVersionContainerArrayOutput) ToContainerServiceDeploymentVersionContainerArrayOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerArrayOutput) ToContainerServiceDeploymentVersionContainerArrayOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionContainerArrayOutput

type ContainerServiceDeploymentVersionContainerInput added in v5.9.0 

type ContainerServiceDeploymentVersionContainerInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionContainerOutput() ContainerServiceDeploymentVersionContainerOutput
	ToContainerServiceDeploymentVersionContainerOutputWithContext(context.Context) ContainerServiceDeploymentVersionContainerOutput
}

ContainerServiceDeploymentVersionContainerInput is an input type that accepts ContainerServiceDeploymentVersionContainerArgs and ContainerServiceDeploymentVersionContainerOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionContainerInput` via: 

ContainerServiceDeploymentVersionContainerArgs{...}

type ContainerServiceDeploymentVersionContainerOutput added in v5.9.0 

type ContainerServiceDeploymentVersionContainerOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionContainerOutput) Commands added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) Commands() pulumi.StringArrayOutput

The launch command for the container. A list of string.

func (ContainerServiceDeploymentVersionContainerOutput) ContainerName added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) ContainerName() pulumi.StringOutput

The name for the container.

func (ContainerServiceDeploymentVersionContainerOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionContainerOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionContainerOutput) Environment added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) Environment() pulumi.StringMapOutput

A key-value map of the environment variables of the container.

func (ContainerServiceDeploymentVersionContainerOutput) Image added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) Image() pulumi.StringOutput

The name of the image used for the container. Container images sourced from your Lightsail container service, that are registered and stored on your service, start with a colon (`:`). For example, `:container-service-1.mystaticwebsite.1`. Container images sourced from a public registry like Docker Hub don't start with a colon. For example, `nginx:latest` or `nginx`.

func (ContainerServiceDeploymentVersionContainerOutput) Ports added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) Ports() pulumi.StringMapOutput

A key-value map of the open firewall ports of the container. Valid values: `HTTP`, `HTTPS`, `TCP`, `UDP`.

func (ContainerServiceDeploymentVersionContainerOutput) ToContainerServiceDeploymentVersionContainerOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) ToContainerServiceDeploymentVersionContainerOutput() ContainerServiceDeploymentVersionContainerOutput

func (ContainerServiceDeploymentVersionContainerOutput) ToContainerServiceDeploymentVersionContainerOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionContainerOutput) ToContainerServiceDeploymentVersionContainerOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionContainerOutput

type ContainerServiceDeploymentVersionInput added in v5.9.0 

type ContainerServiceDeploymentVersionInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionOutput() ContainerServiceDeploymentVersionOutput
	ToContainerServiceDeploymentVersionOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionOutput
}

type ContainerServiceDeploymentVersionMap added in v5.9.0 

type ContainerServiceDeploymentVersionMap map[string]ContainerServiceDeploymentVersionInput

func (ContainerServiceDeploymentVersionMap) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionMap) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionMap) ToContainerServiceDeploymentVersionMapOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionMap) ToContainerServiceDeploymentVersionMapOutput() ContainerServiceDeploymentVersionMapOutput

func (ContainerServiceDeploymentVersionMap) ToContainerServiceDeploymentVersionMapOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionMap) ToContainerServiceDeploymentVersionMapOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionMapOutput

type ContainerServiceDeploymentVersionMapInput added in v5.9.0 

type ContainerServiceDeploymentVersionMapInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionMapOutput() ContainerServiceDeploymentVersionMapOutput
	ToContainerServiceDeploymentVersionMapOutputWithContext(context.Context) ContainerServiceDeploymentVersionMapOutput
}

ContainerServiceDeploymentVersionMapInput is an input type that accepts ContainerServiceDeploymentVersionMap and ContainerServiceDeploymentVersionMapOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionMapInput` via: 

ContainerServiceDeploymentVersionMap{ "key": ContainerServiceDeploymentVersionArgs{...} }

type ContainerServiceDeploymentVersionMapOutput added in v5.9.0 

type ContainerServiceDeploymentVersionMapOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionMapOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionMapOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionMapOutput) MapIndex added in v5.9.0 

func (o ContainerServiceDeploymentVersionMapOutput) MapIndex(k pulumi.StringInput) ContainerServiceDeploymentVersionOutput

func (ContainerServiceDeploymentVersionMapOutput) ToContainerServiceDeploymentVersionMapOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionMapOutput) ToContainerServiceDeploymentVersionMapOutput() ContainerServiceDeploymentVersionMapOutput

func (ContainerServiceDeploymentVersionMapOutput) ToContainerServiceDeploymentVersionMapOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionMapOutput) ToContainerServiceDeploymentVersionMapOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionMapOutput

type ContainerServiceDeploymentVersionOutput added in v5.9.0 

type ContainerServiceDeploymentVersionOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionOutput) Containers added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) Containers() ContainerServiceDeploymentVersionContainerArrayOutput

A set of configuration blocks that describe the settings of the containers that will be launched on the container service. Maximum of 53. Detailed below.

func (ContainerServiceDeploymentVersionOutput) CreatedAt added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) CreatedAt() pulumi.StringOutput

The timestamp when the deployment was created.

func (ContainerServiceDeploymentVersionOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionOutput) PublicEndpoint added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) PublicEndpoint() ContainerServiceDeploymentVersionPublicEndpointPtrOutput

A configuration block that describes the settings of the public endpoint for the container service. Detailed below.

func (ContainerServiceDeploymentVersionOutput) ServiceName added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) ServiceName() pulumi.StringOutput

The name for the container service.

func (ContainerServiceDeploymentVersionOutput) State added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) State() pulumi.StringOutput

The current state of the container service.

func (ContainerServiceDeploymentVersionOutput) ToContainerServiceDeploymentVersionOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) ToContainerServiceDeploymentVersionOutput() ContainerServiceDeploymentVersionOutput

func (ContainerServiceDeploymentVersionOutput) ToContainerServiceDeploymentVersionOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) ToContainerServiceDeploymentVersionOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionOutput

func (ContainerServiceDeploymentVersionOutput) Version added in v5.9.0 

func (o ContainerServiceDeploymentVersionOutput) Version() pulumi.IntOutput

The version number of the deployment.

type ContainerServiceDeploymentVersionPublicEndpoint added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpoint struct {
	// The name of the container for the endpoint.
	ContainerName string `pulumi:"containerName"`
	// The port of the container to which traffic is forwarded to.
	ContainerPort int `pulumi:"containerPort"`
	// A configuration block that describes the health check configuration of the container. Detailed below.
	HealthCheck ContainerServiceDeploymentVersionPublicEndpointHealthCheck `pulumi:"healthCheck"`
}

type ContainerServiceDeploymentVersionPublicEndpointArgs added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointArgs struct {
	// The name of the container for the endpoint.
	ContainerName pulumi.StringInput `pulumi:"containerName"`
	// The port of the container to which traffic is forwarded to.
	ContainerPort pulumi.IntInput `pulumi:"containerPort"`
	// A configuration block that describes the health check configuration of the container. Detailed below.
	HealthCheck ContainerServiceDeploymentVersionPublicEndpointHealthCheckInput `pulumi:"healthCheck"`
}

func (ContainerServiceDeploymentVersionPublicEndpointArgs) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionPublicEndpointArgs) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointOutput() ContainerServiceDeploymentVersionPublicEndpointOutput

func (ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointOutput

func (ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointPtrOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointPtrOutput() ContainerServiceDeploymentVersionPublicEndpointPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointArgs) ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointPtrOutput

type ContainerServiceDeploymentVersionPublicEndpointHealthCheck added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointHealthCheck struct {
	// The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
	HealthyThreshold *int `pulumi:"healthyThreshold"`
	// The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
	IntervalSeconds *int `pulumi:"intervalSeconds"`
	// The path on the container on which to perform the health check. Defaults to "/".
	Path *string `pulumi:"path"`
	// The HTTP codes to use when checking for a successful response from a container. You can specify values between 200 and 499. Defaults to "200-499".
	SuccessCodes *string `pulumi:"successCodes"`
	// The amount of time, in seconds, during which no response means a failed health check. You can specify between 2 and 60 seconds. Defaults to 2.
	TimeoutSeconds *int `pulumi:"timeoutSeconds"`
	// The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
	UnhealthyThreshold *int `pulumi:"unhealthyThreshold"`
}

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs struct {
	// The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
	HealthyThreshold pulumi.IntPtrInput `pulumi:"healthyThreshold"`
	// The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
	IntervalSeconds pulumi.IntPtrInput `pulumi:"intervalSeconds"`
	// The path on the container on which to perform the health check. Defaults to "/".
	Path pulumi.StringPtrInput `pulumi:"path"`
	// The HTTP codes to use when checking for a successful response from a container. You can specify values between 200 and 499. Defaults to "200-499".
	SuccessCodes pulumi.StringPtrInput `pulumi:"successCodes"`
	// The amount of time, in seconds, during which no response means a failed health check. You can specify between 2 and 60 seconds. Defaults to 2.
	TimeoutSeconds pulumi.IntPtrInput `pulumi:"timeoutSeconds"`
	// The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
	UnhealthyThreshold pulumi.IntPtrInput `pulumi:"unhealthyThreshold"`
}

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext added in v5.9.0 

func (i ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckInput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput
	ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutputWithContext(context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput
}

ContainerServiceDeploymentVersionPublicEndpointHealthCheckInput is an input type that accepts ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs and ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionPublicEndpointHealthCheckInput` via: 

ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs{...}

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) HealthyThreshold added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) HealthyThreshold() pulumi.IntPtrOutput

The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) IntervalSeconds added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) IntervalSeconds() pulumi.IntPtrOutput

The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) Path added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) Path() pulumi.StringPtrOutput

The path on the container on which to perform the health check. Defaults to "/".

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) SuccessCodes added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) SuccessCodes() pulumi.StringPtrOutput

The HTTP codes to use when checking for a successful response from a container. You can specify values between 200 and 499. Defaults to "200-499".

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) TimeoutSeconds added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) TimeoutSeconds() pulumi.IntPtrOutput

The amount of time, in seconds, during which no response means a failed health check. You can specify between 2 and 60 seconds. Defaults to 2.

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) UnhealthyThreshold added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput) UnhealthyThreshold() pulumi.IntPtrOutput

The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrInput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput
	ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext(context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput
}

ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrInput is an input type that accepts ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs, ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtr and ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrInput` via: 

        ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs{...}

or:

        nil

func ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtr added in v5.9.0 

func ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtr(v *ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs) ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrInput

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) Elem added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) Elem() ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) HealthyThreshold added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) HealthyThreshold() pulumi.IntPtrOutput

The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) IntervalSeconds added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) IntervalSeconds() pulumi.IntPtrOutput

The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) Path added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) Path() pulumi.StringPtrOutput

The path on the container on which to perform the health check. Defaults to "/".

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) SuccessCodes added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) SuccessCodes() pulumi.StringPtrOutput

The HTTP codes to use when checking for a successful response from a container. You can specify values between 200 and 499. Defaults to "200-499".

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) TimeoutSeconds added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) TimeoutSeconds() pulumi.IntPtrOutput

The amount of time, in seconds, during which no response means a failed health check. You can specify between 2 and 60 seconds. Defaults to 2.

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput() ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) UnhealthyThreshold added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput) UnhealthyThreshold() pulumi.IntPtrOutput

The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.

type ContainerServiceDeploymentVersionPublicEndpointInput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionPublicEndpointOutput() ContainerServiceDeploymentVersionPublicEndpointOutput
	ToContainerServiceDeploymentVersionPublicEndpointOutputWithContext(context.Context) ContainerServiceDeploymentVersionPublicEndpointOutput
}

ContainerServiceDeploymentVersionPublicEndpointInput is an input type that accepts ContainerServiceDeploymentVersionPublicEndpointArgs and ContainerServiceDeploymentVersionPublicEndpointOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionPublicEndpointInput` via: 

ContainerServiceDeploymentVersionPublicEndpointArgs{...}

type ContainerServiceDeploymentVersionPublicEndpointOutput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ContainerName added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) ContainerName() pulumi.StringOutput

The name of the container for the endpoint.

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ContainerPort added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) ContainerPort() pulumi.IntOutput

The port of the container to which traffic is forwarded to.

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionPublicEndpointOutput) HealthCheck added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) HealthCheck() ContainerServiceDeploymentVersionPublicEndpointHealthCheckOutput

A configuration block that describes the health check configuration of the container. Detailed below.

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointOutput() ContainerServiceDeploymentVersionPublicEndpointOutput

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointOutput

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutput() ContainerServiceDeploymentVersionPublicEndpointPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointPtrOutput

type ContainerServiceDeploymentVersionPublicEndpointPtrInput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointPtrInput interface {
	pulumi.Input

	ToContainerServiceDeploymentVersionPublicEndpointPtrOutput() ContainerServiceDeploymentVersionPublicEndpointPtrOutput
	ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext(context.Context) ContainerServiceDeploymentVersionPublicEndpointPtrOutput
}

ContainerServiceDeploymentVersionPublicEndpointPtrInput is an input type that accepts ContainerServiceDeploymentVersionPublicEndpointArgs, ContainerServiceDeploymentVersionPublicEndpointPtr and ContainerServiceDeploymentVersionPublicEndpointPtrOutput values. You can construct a concrete instance of `ContainerServiceDeploymentVersionPublicEndpointPtrInput` via: 

        ContainerServiceDeploymentVersionPublicEndpointArgs{...}

or:

        nil

func ContainerServiceDeploymentVersionPublicEndpointPtr added in v5.9.0 

func ContainerServiceDeploymentVersionPublicEndpointPtr(v *ContainerServiceDeploymentVersionPublicEndpointArgs) ContainerServiceDeploymentVersionPublicEndpointPtrInput

type ContainerServiceDeploymentVersionPublicEndpointPtrOutput added in v5.9.0 

type ContainerServiceDeploymentVersionPublicEndpointPtrOutput struct{ *pulumi.OutputState }

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ContainerName added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ContainerName() pulumi.StringPtrOutput

The name of the container for the endpoint.

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ContainerPort added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ContainerPort() pulumi.IntPtrOutput

The port of the container to which traffic is forwarded to.

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) Elem added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointPtrOutput) Elem() ContainerServiceDeploymentVersionPublicEndpointOutput

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ElementType() reflect.Type

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) HealthCheck added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointPtrOutput) HealthCheck() ContainerServiceDeploymentVersionPublicEndpointHealthCheckPtrOutput

A configuration block that describes the health check configuration of the container. Detailed below.

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutput added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutput() ContainerServiceDeploymentVersionPublicEndpointPtrOutput

func (ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext added in v5.9.0 

func (o ContainerServiceDeploymentVersionPublicEndpointPtrOutput) ToContainerServiceDeploymentVersionPublicEndpointPtrOutputWithContext(ctx context.Context) ContainerServiceDeploymentVersionPublicEndpointPtrOutput

type ContainerServiceDeploymentVersionState added in v5.9.0 

type ContainerServiceDeploymentVersionState struct {
	// A set of configuration blocks that describe the settings of the containers that will be launched on the container service. Maximum of 53. Detailed below.
	Containers ContainerServiceDeploymentVersionContainerArrayInput
	// The timestamp when the deployment was created.
	CreatedAt pulumi.StringPtrInput
	// A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
	PublicEndpoint ContainerServiceDeploymentVersionPublicEndpointPtrInput
	// The name for the container service.
	ServiceName pulumi.StringPtrInput
	// The current state of the container service.
	State pulumi.StringPtrInput
	// The version number of the deployment.
	Version pulumi.IntPtrInput
}

func (ContainerServiceDeploymentVersionState) ElementType added in v5.9.0 

func (ContainerServiceDeploymentVersionState) ElementType() reflect.Type

type ContainerServiceInput added in v5.9.0 

type ContainerServiceInput interface {
	pulumi.Input

	ToContainerServiceOutput() ContainerServiceOutput
	ToContainerServiceOutputWithContext(ctx context.Context) ContainerServiceOutput
}

type ContainerServiceMap added in v5.9.0 

type ContainerServiceMap map[string]ContainerServiceInput

func (ContainerServiceMap) ElementType added in v5.9.0 

func (ContainerServiceMap) ElementType() reflect.Type

func (ContainerServiceMap) ToContainerServiceMapOutput added in v5.9.0 

func (i ContainerServiceMap) ToContainerServiceMapOutput() ContainerServiceMapOutput

func (ContainerServiceMap) ToContainerServiceMapOutputWithContext added in v5.9.0 

func (i ContainerServiceMap) ToContainerServiceMapOutputWithContext(ctx context.Context) ContainerServiceMapOutput

type ContainerServiceMapInput added in v5.9.0 

type ContainerServiceMapInput interface {
	pulumi.Input

	ToContainerServiceMapOutput() ContainerServiceMapOutput
	ToContainerServiceMapOutputWithContext(context.Context) ContainerServiceMapOutput
}

ContainerServiceMapInput is an input type that accepts ContainerServiceMap and ContainerServiceMapOutput values. You can construct a concrete instance of `ContainerServiceMapInput` via: 

ContainerServiceMap{ "key": ContainerServiceArgs{...} }

type ContainerServiceMapOutput added in v5.9.0 

type ContainerServiceMapOutput struct{ *pulumi.OutputState }

func (ContainerServiceMapOutput) ElementType added in v5.9.0 

func (ContainerServiceMapOutput) ElementType() reflect.Type

func (ContainerServiceMapOutput) MapIndex added in v5.9.0 

func (o ContainerServiceMapOutput) MapIndex(k pulumi.StringInput) ContainerServiceOutput

func (ContainerServiceMapOutput) ToContainerServiceMapOutput added in v5.9.0 

func (o ContainerServiceMapOutput) ToContainerServiceMapOutput() ContainerServiceMapOutput

func (ContainerServiceMapOutput) ToContainerServiceMapOutputWithContext added in v5.9.0 

func (o ContainerServiceMapOutput) ToContainerServiceMapOutputWithContext(ctx context.Context) ContainerServiceMapOutput

type ContainerServiceOutput added in v5.9.0 

type ContainerServiceOutput struct{ *pulumi.OutputState }

func (ContainerServiceOutput) Arn added in v5.9.0 

func (o ContainerServiceOutput) Arn() pulumi.StringOutput

The Amazon Resource Name (ARN) of the container service.

func (ContainerServiceOutput) AvailabilityZone added in v5.9.0 

func (o ContainerServiceOutput) AvailabilityZone() pulumi.StringOutput

The Availability Zone. Follows the format us-east-2a (case-sensitive).

func (ContainerServiceOutput) CreatedAt added in v5.9.0 

func (o ContainerServiceOutput) CreatedAt() pulumi.StringOutput

func (ContainerServiceOutput) ElementType added in v5.9.0 

func (ContainerServiceOutput) ElementType() reflect.Type

func (ContainerServiceOutput) IsDisabled added in v5.9.0 

func (o ContainerServiceOutput) IsDisabled() pulumi.BoolPtrOutput

A Boolean value indicating whether the container service is disabled. Defaults to `false`.

func (ContainerServiceOutput) Name added in v5.9.0 

func (o ContainerServiceOutput) Name() pulumi.StringOutput

The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.

func (ContainerServiceOutput) Power added in v5.9.0 

func (o ContainerServiceOutput) Power() pulumi.StringOutput

The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: `nano`, `micro`, `small`, `medium`, `large`, `xlarge`.

func (ContainerServiceOutput) PowerId added in v5.9.0 

func (o ContainerServiceOutput) PowerId() pulumi.StringOutput

The ID of the power of the container service.

  • `principalArn`- The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.

func (ContainerServiceOutput) PrincipalArn added in v5.9.0 

func (o ContainerServiceOutput) PrincipalArn() pulumi.StringOutput

func (ContainerServiceOutput) PrivateDomainName added in v5.9.0 

func (o ContainerServiceOutput) PrivateDomainName() pulumi.StringOutput

The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.

func (ContainerServiceOutput) PublicDomainNames added in v5.9.0 

func (o ContainerServiceOutput) PublicDomainNames() ContainerServicePublicDomainNamesPtrOutput

The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.

func (ContainerServiceOutput) ResourceType added in v5.9.0 

func (o ContainerServiceOutput) ResourceType() pulumi.StringOutput

The Lightsail resource type of the container service (i.e., ContainerService).

func (ContainerServiceOutput) Scale added in v5.9.0 

func (o ContainerServiceOutput) Scale() pulumi.IntOutput

The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.

func (ContainerServiceOutput) State added in v5.9.0 

func (o ContainerServiceOutput) State() pulumi.StringOutput

The current state of the container service.

func (ContainerServiceOutput) Tags added in v5.9.0 

func (o ContainerServiceOutput) Tags() pulumi.StringMapOutput

func (ContainerServiceOutput) TagsAll added in v5.9.0 

func (o ContainerServiceOutput) TagsAll() pulumi.StringMapOutput

func (ContainerServiceOutput) ToContainerServiceOutput added in v5.9.0 

func (o ContainerServiceOutput) ToContainerServiceOutput() ContainerServiceOutput

func (ContainerServiceOutput) ToContainerServiceOutputWithContext added in v5.9.0 

func (o ContainerServiceOutput) ToContainerServiceOutputWithContext(ctx context.Context) ContainerServiceOutput

func (ContainerServiceOutput) Url added in v5.9.0 

func (o ContainerServiceOutput) Url() pulumi.StringOutput

The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.

type ContainerServicePublicDomainNames added in v5.9.0 

type ContainerServicePublicDomainNames struct {
	Certificates []ContainerServicePublicDomainNamesCertificate `pulumi:"certificates"`
}

type ContainerServicePublicDomainNamesArgs added in v5.9.0 

type ContainerServicePublicDomainNamesArgs struct {
	Certificates ContainerServicePublicDomainNamesCertificateArrayInput `pulumi:"certificates"`
}

func (ContainerServicePublicDomainNamesArgs) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesArgs) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesOutput added in v5.9.0 

func (i ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesOutput() ContainerServicePublicDomainNamesOutput

func (ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesOutputWithContext added in v5.9.0 

func (i ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesOutput

func (ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesPtrOutput added in v5.9.0 

func (i ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesPtrOutput() ContainerServicePublicDomainNamesPtrOutput

func (ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesPtrOutputWithContext added in v5.9.0 

func (i ContainerServicePublicDomainNamesArgs) ToContainerServicePublicDomainNamesPtrOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesPtrOutput

type ContainerServicePublicDomainNamesCertificate added in v5.9.0 

type ContainerServicePublicDomainNamesCertificate struct {
	CertificateName string   `pulumi:"certificateName"`
	DomainNames     []string `pulumi:"domainNames"`
}

type ContainerServicePublicDomainNamesCertificateArgs added in v5.9.0 

type ContainerServicePublicDomainNamesCertificateArgs struct {
	CertificateName pulumi.StringInput      `pulumi:"certificateName"`
	DomainNames     pulumi.StringArrayInput `pulumi:"domainNames"`
}

func (ContainerServicePublicDomainNamesCertificateArgs) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesCertificateArgs) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesCertificateArgs) ToContainerServicePublicDomainNamesCertificateOutput added in v5.9.0 

func (i ContainerServicePublicDomainNamesCertificateArgs) ToContainerServicePublicDomainNamesCertificateOutput() ContainerServicePublicDomainNamesCertificateOutput

func (ContainerServicePublicDomainNamesCertificateArgs) ToContainerServicePublicDomainNamesCertificateOutputWithContext added in v5.9.0 

func (i ContainerServicePublicDomainNamesCertificateArgs) ToContainerServicePublicDomainNamesCertificateOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesCertificateOutput

type ContainerServicePublicDomainNamesCertificateArray added in v5.9.0 

type ContainerServicePublicDomainNamesCertificateArray []ContainerServicePublicDomainNamesCertificateInput

func (ContainerServicePublicDomainNamesCertificateArray) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesCertificateArray) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesCertificateArray) ToContainerServicePublicDomainNamesCertificateArrayOutput added in v5.9.0 

func (i ContainerServicePublicDomainNamesCertificateArray) ToContainerServicePublicDomainNamesCertificateArrayOutput() ContainerServicePublicDomainNamesCertificateArrayOutput

func (ContainerServicePublicDomainNamesCertificateArray) ToContainerServicePublicDomainNamesCertificateArrayOutputWithContext added in v5.9.0 

func (i ContainerServicePublicDomainNamesCertificateArray) ToContainerServicePublicDomainNamesCertificateArrayOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesCertificateArrayOutput

type ContainerServicePublicDomainNamesCertificateArrayInput added in v5.9.0 

type ContainerServicePublicDomainNamesCertificateArrayInput interface {
	pulumi.Input

	ToContainerServicePublicDomainNamesCertificateArrayOutput() ContainerServicePublicDomainNamesCertificateArrayOutput
	ToContainerServicePublicDomainNamesCertificateArrayOutputWithContext(context.Context) ContainerServicePublicDomainNamesCertificateArrayOutput
}

ContainerServicePublicDomainNamesCertificateArrayInput is an input type that accepts ContainerServicePublicDomainNamesCertificateArray and ContainerServicePublicDomainNamesCertificateArrayOutput values. You can construct a concrete instance of `ContainerServicePublicDomainNamesCertificateArrayInput` via: 

ContainerServicePublicDomainNamesCertificateArray{ ContainerServicePublicDomainNamesCertificateArgs{...} }

type ContainerServicePublicDomainNamesCertificateArrayOutput added in v5.9.0 

type ContainerServicePublicDomainNamesCertificateArrayOutput struct{ *pulumi.OutputState }

func (ContainerServicePublicDomainNamesCertificateArrayOutput) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesCertificateArrayOutput) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesCertificateArrayOutput) Index added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateArrayOutput) Index(i pulumi.IntInput) ContainerServicePublicDomainNamesCertificateOutput

func (ContainerServicePublicDomainNamesCertificateArrayOutput) ToContainerServicePublicDomainNamesCertificateArrayOutput added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateArrayOutput) ToContainerServicePublicDomainNamesCertificateArrayOutput() ContainerServicePublicDomainNamesCertificateArrayOutput

func (ContainerServicePublicDomainNamesCertificateArrayOutput) ToContainerServicePublicDomainNamesCertificateArrayOutputWithContext added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateArrayOutput) ToContainerServicePublicDomainNamesCertificateArrayOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesCertificateArrayOutput

type ContainerServicePublicDomainNamesCertificateInput added in v5.9.0 

type ContainerServicePublicDomainNamesCertificateInput interface {
	pulumi.Input

	ToContainerServicePublicDomainNamesCertificateOutput() ContainerServicePublicDomainNamesCertificateOutput
	ToContainerServicePublicDomainNamesCertificateOutputWithContext(context.Context) ContainerServicePublicDomainNamesCertificateOutput
}

ContainerServicePublicDomainNamesCertificateInput is an input type that accepts ContainerServicePublicDomainNamesCertificateArgs and ContainerServicePublicDomainNamesCertificateOutput values. You can construct a concrete instance of `ContainerServicePublicDomainNamesCertificateInput` via: 

ContainerServicePublicDomainNamesCertificateArgs{...}

type ContainerServicePublicDomainNamesCertificateOutput added in v5.9.0 

type ContainerServicePublicDomainNamesCertificateOutput struct{ *pulumi.OutputState }

func (ContainerServicePublicDomainNamesCertificateOutput) CertificateName added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateOutput) CertificateName() pulumi.StringOutput

func (ContainerServicePublicDomainNamesCertificateOutput) DomainNames added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateOutput) DomainNames() pulumi.StringArrayOutput

func (ContainerServicePublicDomainNamesCertificateOutput) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesCertificateOutput) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesCertificateOutput) ToContainerServicePublicDomainNamesCertificateOutput added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateOutput) ToContainerServicePublicDomainNamesCertificateOutput() ContainerServicePublicDomainNamesCertificateOutput

func (ContainerServicePublicDomainNamesCertificateOutput) ToContainerServicePublicDomainNamesCertificateOutputWithContext added in v5.9.0 

func (o ContainerServicePublicDomainNamesCertificateOutput) ToContainerServicePublicDomainNamesCertificateOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesCertificateOutput

type ContainerServicePublicDomainNamesInput added in v5.9.0 

type ContainerServicePublicDomainNamesInput interface {
	pulumi.Input

	ToContainerServicePublicDomainNamesOutput() ContainerServicePublicDomainNamesOutput
	ToContainerServicePublicDomainNamesOutputWithContext(context.Context) ContainerServicePublicDomainNamesOutput
}

ContainerServicePublicDomainNamesInput is an input type that accepts ContainerServicePublicDomainNamesArgs and ContainerServicePublicDomainNamesOutput values. You can construct a concrete instance of `ContainerServicePublicDomainNamesInput` via: 

ContainerServicePublicDomainNamesArgs{...}

type ContainerServicePublicDomainNamesOutput added in v5.9.0 

type ContainerServicePublicDomainNamesOutput struct{ *pulumi.OutputState }

func (ContainerServicePublicDomainNamesOutput) Certificates added in v5.9.0 

func (o ContainerServicePublicDomainNamesOutput) Certificates() ContainerServicePublicDomainNamesCertificateArrayOutput

func (ContainerServicePublicDomainNamesOutput) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesOutput) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesOutput added in v5.9.0 

func (o ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesOutput() ContainerServicePublicDomainNamesOutput

func (ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesOutputWithContext added in v5.9.0 

func (o ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesOutput

func (ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesPtrOutput added in v5.9.0 

func (o ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesPtrOutput() ContainerServicePublicDomainNamesPtrOutput

func (ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesPtrOutputWithContext added in v5.9.0 

func (o ContainerServicePublicDomainNamesOutput) ToContainerServicePublicDomainNamesPtrOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesPtrOutput

type ContainerServicePublicDomainNamesPtrInput added in v5.9.0 

type ContainerServicePublicDomainNamesPtrInput interface {
	pulumi.Input

	ToContainerServicePublicDomainNamesPtrOutput() ContainerServicePublicDomainNamesPtrOutput
	ToContainerServicePublicDomainNamesPtrOutputWithContext(context.Context) ContainerServicePublicDomainNamesPtrOutput
}

ContainerServicePublicDomainNamesPtrInput is an input type that accepts ContainerServicePublicDomainNamesArgs, ContainerServicePublicDomainNamesPtr and ContainerServicePublicDomainNamesPtrOutput values. You can construct a concrete instance of `ContainerServicePublicDomainNamesPtrInput` via: 

        ContainerServicePublicDomainNamesArgs{...}

or:

        nil

func ContainerServicePublicDomainNamesPtr added in v5.9.0 

func ContainerServicePublicDomainNamesPtr(v *ContainerServicePublicDomainNamesArgs) ContainerServicePublicDomainNamesPtrInput

type ContainerServicePublicDomainNamesPtrOutput added in v5.9.0 

type ContainerServicePublicDomainNamesPtrOutput struct{ *pulumi.OutputState }

func (ContainerServicePublicDomainNamesPtrOutput) Certificates added in v5.9.0 

func (o ContainerServicePublicDomainNamesPtrOutput) Certificates() ContainerServicePublicDomainNamesCertificateArrayOutput

func (ContainerServicePublicDomainNamesPtrOutput) Elem added in v5.9.0 

func (o ContainerServicePublicDomainNamesPtrOutput) Elem() ContainerServicePublicDomainNamesOutput

func (ContainerServicePublicDomainNamesPtrOutput) ElementType added in v5.9.0 

func (ContainerServicePublicDomainNamesPtrOutput) ElementType() reflect.Type

func (ContainerServicePublicDomainNamesPtrOutput) ToContainerServicePublicDomainNamesPtrOutput added in v5.9.0 

func (o ContainerServicePublicDomainNamesPtrOutput) ToContainerServicePublicDomainNamesPtrOutput() ContainerServicePublicDomainNamesPtrOutput

func (ContainerServicePublicDomainNamesPtrOutput) ToContainerServicePublicDomainNamesPtrOutputWithContext added in v5.9.0 

func (o ContainerServicePublicDomainNamesPtrOutput) ToContainerServicePublicDomainNamesPtrOutputWithContext(ctx context.Context) ContainerServicePublicDomainNamesPtrOutput

type ContainerServiceState added in v5.9.0 

type ContainerServiceState struct {
	// The Amazon Resource Name (ARN) of the container service.
	Arn pulumi.StringPtrInput
	// The Availability Zone. Follows the format us-east-2a (case-sensitive).
	AvailabilityZone pulumi.StringPtrInput
	CreatedAt        pulumi.StringPtrInput
	// A Boolean value indicating whether the container service is disabled. Defaults to `false`.
	IsDisabled pulumi.BoolPtrInput
	// The name for the container service. Names must be of length 1 to 63, and be
	// unique within each AWS Region in your Lightsail account.
	Name pulumi.StringPtrInput
	// The power specification for the container service. The power specifies the amount of memory,
	// the number of vCPUs, and the monthly price of each node of the container service.
	// Possible values: `nano`, `micro`, `small`, `medium`, `large`, `xlarge`.
	Power pulumi.StringPtrInput
	// The ID of the power of the container service.
	// * `principalArn`- The principal ARN of the container service. The principal ARN can be used to create a trust
	//   relationship between your standard AWS account and your Lightsail container service. This allows you to give your
	//   service permission to access resources in your standard AWS account.
	PowerId      pulumi.StringPtrInput
	PrincipalArn pulumi.StringPtrInput
	// The private domain name of the container service. The private domain name is accessible only
	// by other resources within the default virtual private cloud (VPC) of your Lightsail account.
	PrivateDomainName pulumi.StringPtrInput
	// The public domain names to use with the container service, such as example.com
	// and www.example.com. You can specify up to four public domain names for a container service. The domain names that you
	// specify are used when you create a deployment with a container configured as the public endpoint of your container
	// service. If you don't specify public domain names, then you can use the default domain of the container service.
	// Defined below.
	PublicDomainNames ContainerServicePublicDomainNamesPtrInput
	// The Lightsail resource type of the container service (i.e., ContainerService).
	ResourceType pulumi.StringPtrInput
	// The scale specification for the container service. The scale specifies the allocated compute
	// nodes of the container service.
	Scale pulumi.IntPtrInput
	// The current state of the container service.
	State   pulumi.StringPtrInput
	Tags    pulumi.StringMapInput
	TagsAll pulumi.StringMapInput
	// The publicly accessible URL of the container service. If no public endpoint is specified in the
	// currentDeployment, this URL returns a 404 response.
	Url pulumi.StringPtrInput
}

func (ContainerServiceState) ElementType added in v5.9.0 

func (ContainerServiceState) ElementType() reflect.Type

type Database added in v5.10.0 

type Database struct {
	pulumi.CustomResourceState

	// When true , applies changes immediately. When false , applies changes during the preferred maintenance window. Some changes may cause an outage.
	ApplyImmediately pulumi.BoolOutput `pulumi:"applyImmediately"`
	// The ARN of the Lightsail instance (matches `id`).
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The Availability Zone in which to create your new database. Use the us-east-2a case-sensitive format.
	AvailabilityZone pulumi.StringOutput `pulumi:"availabilityZone"`
	// When true, enables automated backup retention for your database. When false, disables automated backup retention for your database. Disabling backup retention deletes all automated database backups. Before disabling this, you may want to create a snapshot of your database.
	BackupRetentionEnabled pulumi.BoolPtrOutput `pulumi:"backupRetentionEnabled"`
	// The blueprint ID for your new database. A blueprint describes the major engine version of a database. You can get a list of database blueprints IDs by using the AWS CLI command: `aws lightsail get-relational-database-blueprints`
	BlueprintId pulumi.StringOutput `pulumi:"blueprintId"`
	// The bundle ID for your new database. A bundle describes the performance specifications for your database (see list below). You can get a list of database bundle IDs by using the AWS CLI command: `aws lightsail get-relational-database-bundles`.
	BundleId pulumi.StringOutput `pulumi:"bundleId"`
	// The certificate associated with the database.
	CaCertificateIdentifier pulumi.StringOutput `pulumi:"caCertificateIdentifier"`
	// The number of vCPUs for the database.
	CpuCount pulumi.IntOutput `pulumi:"cpuCount"`
	// The timestamp when the instance was created.
	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
	// The size of the disk for the database.
	DiskSize pulumi.Float64Output `pulumi:"diskSize"`
	// The database software (for example, MySQL).
	Engine pulumi.StringOutput `pulumi:"engine"`
	// The database engine version (for example, 5.7.23).
	EngineVersion pulumi.StringOutput `pulumi:"engineVersion"`
	// The name of the database snapshot created if skip final snapshot is false, which is the default value for that parameter.
	FinalSnapshotName pulumi.StringPtrOutput `pulumi:"finalSnapshotName"`
	// The name of the master database created when the Lightsail database resource is created.
	MasterDatabaseName pulumi.StringOutput `pulumi:"masterDatabaseName"`
	// The master endpoint fqdn for the database.
	MasterEndpointAddress pulumi.StringOutput `pulumi:"masterEndpointAddress"`
	// The master endpoint network port for the database.
	MasterEndpointPort pulumi.IntOutput `pulumi:"masterEndpointPort"`
	// The password for the master user of your new database. The password can include any printable ASCII character except "/", """, or "@".
	MasterPassword pulumi.StringOutput `pulumi:"masterPassword"`
	// The master user name for your new database.
	MasterUsername pulumi.StringOutput `pulumi:"masterUsername"`
	// The daily time range during which automated backups are created for your new database if automated backups are enabled. Must be in the hh24:mi-hh24:mi format. Example: `16:00-16:30`. Specified in Coordinated Universal Time (UTC).
	PreferredBackupWindow pulumi.StringOutput `pulumi:"preferredBackupWindow"`
	// The weekly time range during which system maintenance can occur on your new database. Must be in the ddd:hh24:mi-ddd:hh24:mi format. Specified in Coordinated Universal Time (UTC). Example: `Tue:17:00-Tue:17:30`
	PreferredMaintenanceWindow pulumi.StringOutput `pulumi:"preferredMaintenanceWindow"`
	// Specifies the accessibility options for your new database. A value of true specifies a database that is available to resources outside of your Lightsail account. A value of false specifies a database that is available only to your Lightsail resources in the same region as your database.
	PubliclyAccessible pulumi.BoolPtrOutput `pulumi:"publiclyAccessible"`
	// The amount of RAM in GB for the database.
	RamSize                pulumi.Float64Output `pulumi:"ramSize"`
	RelationalDatabaseName pulumi.StringOutput  `pulumi:"relationalDatabaseName"`
	// Describes the secondary Availability Zone of a high availability database. The secondary database is used for failover support of a high availability database.
	SecondaryAvailabilityZone pulumi.StringOutput `pulumi:"secondaryAvailabilityZone"`
	// Determines whether a final database snapshot is created before your database is deleted. If true is specified, no database snapshot is created. If false is specified, a database snapshot is created before your database is deleted. You must specify the final relational database snapshot name parameter if the skip final snapshot parameter is false.
	SkipFinalSnapshot pulumi.BoolPtrOutput `pulumi:"skipFinalSnapshot"`
	// The support code for the database. Include this code in your email to support when you have questions about a database in Lightsail. This code enables our support team to look up your Lightsail information more easily.
	SupportCode pulumi.StringOutput `pulumi:"supportCode"`
	// A map of tags to assign to the resource. To create a key-only tag, use an empty string as the value.
	Tags    pulumi.StringMapOutput `pulumi:"tags"`
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a Lightsail Database. 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"](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) for more details

## Example Usage ## Blueprint Ids

A list of all available Lightsail Blueprints for Relational Databases the [aws lightsail get-relational-database-blueprints](https://docs.aws.amazon.com/cli/latest/reference/lightsail/get-relational-database-blueprints.html) aws cli command.

### Examples

- `mysql80` - `postgres12`

### Prefix

A Blueprint ID starts with a prefix of the engine type.

### Suffix

A Blueprint ID has a sufix of the engine version.

## Bundles

A list of all available Lightsail Bundles for Relational Databases the [aws lightsail get-relational-database-bundles](https://docs.aws.amazon.com/cli/latest/reference/lightsail/get-relational-database-bundles.html) aws cli command.

### Examples

- `small10` - `smallHa10` - `large10` - `largeHa10`

### Prefix

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

- `micro_` - `small_` - `medium_` - `large_`

### Infixes (Optional for HA Database)

A Bundle Id can have the following infix added in order to use the HA option of the selected bundle.

- `ha_`

### Suffix

A Bundle ID ends with one of the following suffix: `10`

## Import

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

```sh 

$ pulumi import aws:lightsail/database:Database foo 'bar'

```

func GetDatabase added in v5.10.0 

func GetDatabase(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DatabaseState, opts ...pulumi.ResourceOption) (*Database, error)

GetDatabase gets an existing Database 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 NewDatabase added in v5.10.0 

func NewDatabase(ctx *pulumi.Context,
	name string, args *DatabaseArgs, opts ...pulumi.ResourceOption) (*Database, error)

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

func (*Database) ElementType added in v5.10.0 

func (*Database) ElementType() reflect.Type

func (*Database) ToDatabaseOutput added in v5.10.0 

func (i *Database) ToDatabaseOutput() DatabaseOutput

func (*Database) ToDatabaseOutputWithContext added in v5.10.0 

func (i *Database) ToDatabaseOutputWithContext(ctx context.Context) DatabaseOutput

type DatabaseArgs added in v5.10.0 

type DatabaseArgs struct {
	// When true , applies changes immediately. When false , applies changes during the preferred maintenance window. Some changes may cause an outage.
	ApplyImmediately pulumi.BoolPtrInput
	// The Availability Zone in which to create your new database. Use the us-east-2a case-sensitive format.
	AvailabilityZone pulumi.StringInput
	// When true, enables automated backup retention for your database. When false, disables automated backup retention for your database. Disabling backup retention deletes all automated database backups. Before disabling this, you may want to create a snapshot of your database.
	BackupRetentionEnabled pulumi.BoolPtrInput
	// The blueprint ID for your new database. A blueprint describes the major engine version of a database. You can get a list of database blueprints IDs by using the AWS CLI command: `aws lightsail get-relational-database-blueprints`
	BlueprintId pulumi.StringInput
	// The bundle ID for your new database. A bundle describes the performance specifications for your database (see list below). You can get a list of database bundle IDs by using the AWS CLI command: `aws lightsail get-relational-database-bundles`.
	BundleId pulumi.StringInput
	// The name of the database snapshot created if skip final snapshot is false, which is the default value for that parameter.
	FinalSnapshotName pulumi.StringPtrInput
	// The name of the master database created when the Lightsail database resource is created.
	MasterDatabaseName pulumi.StringInput
	// The password for the master user of your new database. The password can include any printable ASCII character except "/", """, or "@".
	MasterPassword pulumi.StringInput
	// The master user name for your new database.
	MasterUsername pulumi.StringInput
	// The daily time range during which automated backups are created for your new database if automated backups are enabled. Must be in the hh24:mi-hh24:mi format. Example: `16:00-16:30`. Specified in Coordinated Universal Time (UTC).
	PreferredBackupWindow pulumi.StringPtrInput
	// The weekly time range during which system maintenance can occur on your new database. Must be in the ddd:hh24:mi-ddd:hh24:mi format. Specified in Coordinated Universal Time (UTC). Example: `Tue:17:00-Tue:17:30`
	PreferredMaintenanceWindow pulumi.StringPtrInput
	// Specifies the accessibility options for your new database. A value of true specifies a database that is available to resources outside of your Lightsail account. A value of false specifies a database that is available only to your Lightsail resources in the same region as your database.
	PubliclyAccessible     pulumi.BoolPtrInput
	RelationalDatabaseName pulumi.StringInput
	// Determines whether a final database snapshot is created before your database is deleted. If true is specified, no database snapshot is created. If false is specified, a database snapshot is created before your database is deleted. You must specify the final relational database snapshot name parameter if the skip final snapshot parameter is false.
	SkipFinalSnapshot pulumi.BoolPtrInput
	// A map of tags to assign to the resource. To create a key-only tag, use an empty string as the value.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Database resource.

func (DatabaseArgs) ElementType added in v5.10.0 

func (DatabaseArgs) ElementType() reflect.Type

type DatabaseArray added in v5.10.0 

type DatabaseArray []DatabaseInput

func (DatabaseArray) ElementType added in v5.10.0 

func (DatabaseArray) ElementType() reflect.Type

func (DatabaseArray) ToDatabaseArrayOutput added in v5.10.0 

func (i DatabaseArray) ToDatabaseArrayOutput() DatabaseArrayOutput

func (DatabaseArray) ToDatabaseArrayOutputWithContext added in v5.10.0 

func (i DatabaseArray) ToDatabaseArrayOutputWithContext(ctx context.Context) DatabaseArrayOutput

type DatabaseArrayInput added in v5.10.0 

type DatabaseArrayInput interface {
	pulumi.Input

	ToDatabaseArrayOutput() DatabaseArrayOutput
	ToDatabaseArrayOutputWithContext(context.Context) DatabaseArrayOutput
}

DatabaseArrayInput is an input type that accepts DatabaseArray and DatabaseArrayOutput values. You can construct a concrete instance of `DatabaseArrayInput` via: 

DatabaseArray{ DatabaseArgs{...} }

type DatabaseArrayOutput added in v5.10.0 

type DatabaseArrayOutput struct{ *pulumi.OutputState }

func (DatabaseArrayOutput) ElementType added in v5.10.0 

func (DatabaseArrayOutput) ElementType() reflect.Type

func (DatabaseArrayOutput) Index added in v5.10.0 

func (o DatabaseArrayOutput) Index(i pulumi.IntInput) DatabaseOutput

func (DatabaseArrayOutput) ToDatabaseArrayOutput added in v5.10.0 

func (o DatabaseArrayOutput) ToDatabaseArrayOutput() DatabaseArrayOutput

func (DatabaseArrayOutput) ToDatabaseArrayOutputWithContext added in v5.10.0 

func (o DatabaseArrayOutput) ToDatabaseArrayOutputWithContext(ctx context.Context) DatabaseArrayOutput

type DatabaseInput added in v5.10.0 

type DatabaseInput interface {
	pulumi.Input

	ToDatabaseOutput() DatabaseOutput
	ToDatabaseOutputWithContext(ctx context.Context) DatabaseOutput
}

type DatabaseMap added in v5.10.0 

type DatabaseMap map[string]DatabaseInput

func (DatabaseMap) ElementType added in v5.10.0 

func (DatabaseMap) ElementType() reflect.Type

func (DatabaseMap) ToDatabaseMapOutput added in v5.10.0 

func (i DatabaseMap) ToDatabaseMapOutput() DatabaseMapOutput

func (DatabaseMap) ToDatabaseMapOutputWithContext added in v5.10.0 

func (i DatabaseMap) ToDatabaseMapOutputWithContext(ctx context.Context) DatabaseMapOutput

type DatabaseMapInput added in v5.10.0 

type DatabaseMapInput interface {
	pulumi.Input

	ToDatabaseMapOutput() DatabaseMapOutput
	ToDatabaseMapOutputWithContext(context.Context) DatabaseMapOutput
}

DatabaseMapInput is an input type that accepts DatabaseMap and DatabaseMapOutput values. You can construct a concrete instance of `DatabaseMapInput` via: 

DatabaseMap{ "key": DatabaseArgs{...} }

type DatabaseMapOutput added in v5.10.0 

type DatabaseMapOutput struct{ *pulumi.OutputState }

func (DatabaseMapOutput) ElementType added in v5.10.0 

func (DatabaseMapOutput) ElementType() reflect.Type

func (DatabaseMapOutput) MapIndex added in v5.10.0 

func (o DatabaseMapOutput) MapIndex(k pulumi.StringInput) DatabaseOutput

func (DatabaseMapOutput) ToDatabaseMapOutput added in v5.10.0 

func (o DatabaseMapOutput) ToDatabaseMapOutput() DatabaseMapOutput

func (DatabaseMapOutput) ToDatabaseMapOutputWithContext added in v5.10.0 

func (o DatabaseMapOutput) ToDatabaseMapOutputWithContext(ctx context.Context) DatabaseMapOutput

type DatabaseOutput added in v5.10.0 

type DatabaseOutput struct{ *pulumi.OutputState }

func (DatabaseOutput) ApplyImmediately added in v5.10.0 

func (o DatabaseOutput) ApplyImmediately() pulumi.BoolOutput

When true , applies changes immediately. When false , applies changes during the preferred maintenance window. Some changes may cause an outage.

func (DatabaseOutput) Arn added in v5.10.0 

func (o DatabaseOutput) Arn() pulumi.StringOutput

The ARN of the Lightsail instance (matches `id`).

func (DatabaseOutput) AvailabilityZone added in v5.10.0 

func (o DatabaseOutput) AvailabilityZone() pulumi.StringOutput

The Availability Zone in which to create your new database. Use the us-east-2a case-sensitive format.

func (DatabaseOutput) BackupRetentionEnabled added in v5.10.0 

func (o DatabaseOutput) BackupRetentionEnabled() pulumi.BoolPtrOutput

When true, enables automated backup retention for your database. When false, disables automated backup retention for your database. Disabling backup retention deletes all automated database backups. Before disabling this, you may want to create a snapshot of your database.

func (DatabaseOutput) BlueprintId added in v5.10.0 

func (o DatabaseOutput) BlueprintId() pulumi.StringOutput

The blueprint ID for your new database. A blueprint describes the major engine version of a database. You can get a list of database blueprints IDs by using the AWS CLI command: `aws lightsail get-relational-database-blueprints`

func (DatabaseOutput) BundleId added in v5.10.0 

func (o DatabaseOutput) BundleId() pulumi.StringOutput

The bundle ID for your new database. A bundle describes the performance specifications for your database (see list below). You can get a list of database bundle IDs by using the AWS CLI command: `aws lightsail get-relational-database-bundles`.

func (DatabaseOutput) CaCertificateIdentifier added in v5.10.0 

func (o DatabaseOutput) CaCertificateIdentifier() pulumi.StringOutput

The certificate associated with the database.

func (DatabaseOutput) CpuCount added in v5.10.0 

func (o DatabaseOutput) CpuCount() pulumi.IntOutput

The number of vCPUs for the database.

func (DatabaseOutput) CreatedAt added in v5.10.0 

func (o DatabaseOutput) CreatedAt() pulumi.StringOutput

The timestamp when the instance was created.

func (DatabaseOutput) DiskSize added in v5.10.0 

func (o DatabaseOutput) DiskSize() pulumi.Float64Output

The size of the disk for the database.

func (DatabaseOutput) ElementType added in v5.10.0 

func (DatabaseOutput) ElementType() reflect.Type

func (DatabaseOutput) Engine added in v5.10.0 

func (o DatabaseOutput) Engine() pulumi.StringOutput

The database software (for example, MySQL).

func (DatabaseOutput) EngineVersion added in v5.10.0 

func (o DatabaseOutput) EngineVersion() pulumi.StringOutput

The database engine version (for example, 5.7.23).

func (DatabaseOutput) FinalSnapshotName added in v5.10.0 

func (o DatabaseOutput) FinalSnapshotName() pulumi.StringPtrOutput

The name of the database snapshot created if skip final snapshot is false, which is the default value for that parameter.

func (DatabaseOutput) MasterDatabaseName added in v5.10.0 

func (o DatabaseOutput) MasterDatabaseName() pulumi.StringOutput

The name of the master database created when the Lightsail database resource is created.

func (DatabaseOutput) MasterEndpointAddress added in v5.10.0 

func (o DatabaseOutput) MasterEndpointAddress() pulumi.StringOutput

The master endpoint fqdn for the database.

func (DatabaseOutput) MasterEndpointPort added in v5.10.0 

func (o DatabaseOutput) MasterEndpointPort() pulumi.IntOutput

The master endpoint network port for the database.

func (DatabaseOutput) MasterPassword added in v5.10.0 

func (o DatabaseOutput) MasterPassword() pulumi.StringOutput

The password for the master user of your new database. The password can include any printable ASCII character except "/", """, or "@".

func (DatabaseOutput) MasterUsername added in v5.10.0 

func (o DatabaseOutput) MasterUsername() pulumi.StringOutput

The master user name for your new database.

func (DatabaseOutput) PreferredBackupWindow added in v5.10.0 

func (o DatabaseOutput) PreferredBackupWindow() pulumi.StringOutput

The daily time range during which automated backups are created for your new database if automated backups are enabled. Must be in the hh24:mi-hh24:mi format. Example: `16:00-16:30`. Specified in Coordinated Universal Time (UTC).

func (DatabaseOutput) PreferredMaintenanceWindow added in v5.10.0 

func (o DatabaseOutput) PreferredMaintenanceWindow() pulumi.StringOutput

The weekly time range during which system maintenance can occur on your new database. Must be in the ddd:hh24:mi-ddd:hh24:mi format. Specified in Coordinated Universal Time (UTC). Example: `Tue:17:00-Tue:17:30`

func (DatabaseOutput) PubliclyAccessible added in v5.10.0 

func (o DatabaseOutput) PubliclyAccessible() pulumi.BoolPtrOutput

Specifies the accessibility options for your new database. A value of true specifies a database that is available to resources outside of your Lightsail account. A value of false specifies a database that is available only to your Lightsail resources in the same region as your database.

func (DatabaseOutput) RamSize added in v5.10.0 

func (o DatabaseOutput) RamSize() pulumi.Float64Output

The amount of RAM in GB for the database.

func (DatabaseOutput) RelationalDatabaseName added in v5.10.0 

func (o DatabaseOutput) RelationalDatabaseName() pulumi.StringOutput

func (DatabaseOutput) SecondaryAvailabilityZone added in v5.10.0 

func (o DatabaseOutput) SecondaryAvailabilityZone() pulumi.StringOutput

Describes the secondary Availability Zone of a high availability database. The secondary database is used for failover support of a high availability database.

func (DatabaseOutput) SkipFinalSnapshot added in v5.10.0 

func (o DatabaseOutput) SkipFinalSnapshot() pulumi.BoolPtrOutput

Determines whether a final database snapshot is created before your database is deleted. If true is specified, no database snapshot is created. If false is specified, a database snapshot is created before your database is deleted. You must specify the final relational database snapshot name parameter if the skip final snapshot parameter is false.

func (DatabaseOutput) SupportCode added in v5.10.0 

func (o DatabaseOutput) SupportCode() pulumi.StringOutput

The support code for the database. Include this code in your email to support when you have questions about a database in Lightsail. This code enables our support team to look up your Lightsail information more easily.

func (DatabaseOutput) Tags added in v5.10.0 

func (o DatabaseOutput) Tags() pulumi.StringMapOutput

A map of tags to assign to the resource. To create a key-only tag, use an empty string as the value.

func (DatabaseOutput) TagsAll added in v5.10.0 

func (o DatabaseOutput) TagsAll() pulumi.StringMapOutput

func (DatabaseOutput) ToDatabaseOutput added in v5.10.0 

func (o DatabaseOutput) ToDatabaseOutput() DatabaseOutput

func (DatabaseOutput) ToDatabaseOutputWithContext added in v5.10.0 

func (o DatabaseOutput) ToDatabaseOutputWithContext(ctx context.Context) DatabaseOutput

type DatabaseState added in v5.10.0 

type DatabaseState struct {
	// When true , applies changes immediately. When false , applies changes during the preferred maintenance window. Some changes may cause an outage.
	ApplyImmediately pulumi.BoolPtrInput
	// The ARN of the Lightsail instance (matches `id`).
	Arn pulumi.StringPtrInput
	// The Availability Zone in which to create your new database. Use the us-east-2a case-sensitive format.
	AvailabilityZone pulumi.StringPtrInput
	// When true, enables automated backup retention for your database. When false, disables automated backup retention for your database. Disabling backup retention deletes all automated database backups. Before disabling this, you may want to create a snapshot of your database.
	BackupRetentionEnabled pulumi.BoolPtrInput
	// The blueprint ID for your new database. A blueprint describes the major engine version of a database. You can get a list of database blueprints IDs by using the AWS CLI command: `aws lightsail get-relational-database-blueprints`
	BlueprintId pulumi.StringPtrInput
	// The bundle ID for your new database. A bundle describes the performance specifications for your database (see list below). You can get a list of database bundle IDs by using the AWS CLI command: `aws lightsail get-relational-database-bundles`.
	BundleId pulumi.StringPtrInput
	// The certificate associated with the database.
	CaCertificateIdentifier pulumi.StringPtrInput
	// The number of vCPUs for the database.
	CpuCount pulumi.IntPtrInput
	// The timestamp when the instance was created.
	CreatedAt pulumi.StringPtrInput
	// The size of the disk for the database.
	DiskSize pulumi.Float64PtrInput
	// The database software (for example, MySQL).
	Engine pulumi.StringPtrInput
	// The database engine version (for example, 5.7.23).
	EngineVersion pulumi.StringPtrInput
	// The name of the database snapshot created if skip final snapshot is false, which is the default value for that parameter.
	FinalSnapshotName pulumi.StringPtrInput
	// The name of the master database created when the Lightsail database resource is created.
	MasterDatabaseName pulumi.StringPtrInput
	// The master endpoint fqdn for the database.
	MasterEndpointAddress pulumi.StringPtrInput
	// The master endpoint network port for the database.
	MasterEndpointPort pulumi.IntPtrInput
	// The password for the master user of your new database. The password can include any printable ASCII character except "/", """, or "@".
	MasterPassword pulumi.StringPtrInput
	// The master user name for your new database.
	MasterUsername pulumi.StringPtrInput
	// The daily time range during which automated backups are created for your new database if automated backups are enabled. Must be in the hh24:mi-hh24:mi format. Example: `16:00-16:30`. Specified in Coordinated Universal Time (UTC).
	PreferredBackupWindow pulumi.StringPtrInput
	// The weekly time range during which system maintenance can occur on your new database. Must be in the ddd:hh24:mi-ddd:hh24:mi format. Specified in Coordinated Universal Time (UTC). Example: `Tue:17:00-Tue:17:30`
	PreferredMaintenanceWindow pulumi.StringPtrInput
	// Specifies the accessibility options for your new database. A value of true specifies a database that is available to resources outside of your Lightsail account. A value of false specifies a database that is available only to your Lightsail resources in the same region as your database.
	PubliclyAccessible pulumi.BoolPtrInput
	// The amount of RAM in GB for the database.
	RamSize                pulumi.Float64PtrInput
	RelationalDatabaseName pulumi.StringPtrInput
	// Describes the secondary Availability Zone of a high availability database. The secondary database is used for failover support of a high availability database.
	SecondaryAvailabilityZone pulumi.StringPtrInput
	// Determines whether a final database snapshot is created before your database is deleted. If true is specified, no database snapshot is created. If false is specified, a database snapshot is created before your database is deleted. You must specify the final relational database snapshot name parameter if the skip final snapshot parameter is false.
	SkipFinalSnapshot pulumi.BoolPtrInput
	// The support code for the database. Include this code in your email to support when you have questions about a database in Lightsail. This code enables our support team to look up your Lightsail information more easily.
	SupportCode pulumi.StringPtrInput
	// A map of tags to assign to the resource. To create a key-only tag, use an empty string as the value.
	Tags    pulumi.StringMapInput
	TagsAll pulumi.StringMapInput
}

func (DatabaseState) ElementType added in v5.10.0 

func (DatabaseState) ElementType() reflect.Type

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/v5/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) Arn added in v5.4.0 

func (o DomainOutput) Arn() pulumi.StringOutput

The ARN of the Lightsail domain

func (DomainOutput) DomainName added in v5.4.0 

func (o DomainOutput) DomainName() pulumi.StringOutput

The name of the Lightsail domain to manage

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/v5/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) Arn added in v5.4.0 

func (o InstanceOutput) Arn() pulumi.StringOutput

The ARN of the Lightsail instance (matches `id`).

func (InstanceOutput) AvailabilityZone added in v5.4.0 

func (o InstanceOutput) AvailabilityZone() pulumi.StringOutput

The Availability Zone in which to create your instance (see list below)

func (InstanceOutput) BlueprintId added in v5.4.0 

func (o InstanceOutput) BlueprintId() pulumi.StringOutput

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`

func (InstanceOutput) BundleId added in v5.4.0 

func (o InstanceOutput) BundleId() pulumi.StringOutput

The bundle of specification information (see list below)

func (InstanceOutput) CpuCount added in v5.4.0 

func (o InstanceOutput) CpuCount() pulumi.IntOutput

The number of vCPUs the instance has.

func (InstanceOutput) CreatedAt added in v5.4.0 

func (o InstanceOutput) CreatedAt() pulumi.StringOutput

The timestamp when the instance was created.

func (InstanceOutput) ElementType 

func (InstanceOutput) ElementType() reflect.Type

func (InstanceOutput) Ipv6Address deprecated added in v5.4.0 

func (o InstanceOutput) Ipv6Address() pulumi.StringOutput

(**Deprecated**) The first IPv6 address of the Lightsail instance. Use `ipv6Addresses` attribute instead.

Deprecated: use `ipv6_addresses` attribute instead

func (InstanceOutput) Ipv6Addresses added in v5.4.0 

func (o InstanceOutput) Ipv6Addresses() pulumi.StringArrayOutput

List of IPv6 addresses for the Lightsail instance.

func (InstanceOutput) IsStaticIp added in v5.4.0 

func (o InstanceOutput) IsStaticIp() pulumi.BoolOutput

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

func (InstanceOutput) KeyPairName added in v5.4.0 

func (o InstanceOutput) KeyPairName() pulumi.StringPtrOutput

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

func (InstanceOutput) Name added in v5.4.0 

func (o InstanceOutput) Name() pulumi.StringOutput

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

func (InstanceOutput) PrivateIpAddress added in v5.4.0 

func (o InstanceOutput) PrivateIpAddress() pulumi.StringOutput

The private IP address of the instance.

func (InstanceOutput) PublicIpAddress added in v5.4.0 

func (o InstanceOutput) PublicIpAddress() pulumi.StringOutput

The public IP address of the instance.

func (InstanceOutput) RamSize added in v5.4.0 

func (o InstanceOutput) RamSize() pulumi.Float64Output

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

func (InstanceOutput) Tags added in v5.4.0 

func (o InstanceOutput) Tags() pulumi.StringMapOutput

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.

func (InstanceOutput) TagsAll added in v5.4.0 

func (o InstanceOutput) TagsAll() pulumi.StringMapOutput

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

func (InstanceOutput) ToInstanceOutput 

func (o InstanceOutput) ToInstanceOutput() InstanceOutput

func (InstanceOutput) ToInstanceOutputWithContext 

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

func (InstanceOutput) UserData added in v5.4.0 

func (o InstanceOutput) UserData() pulumi.StringPtrOutput

launch script to configure server with additional user data

func (InstanceOutput) Username added in v5.4.0 

func (o InstanceOutput) Username() pulumi.StringOutput

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

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/v5/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) InstanceName added in v5.4.0 

func (o InstancePublicPortsOutput) InstanceName() pulumi.StringOutput

Name of the Lightsail Instance.

func (InstancePublicPortsOutput) PortInfos added in v5.4.0 

func (o InstancePublicPortsOutput) PortInfos() InstancePublicPortsPortInfoArrayOutput

Configuration block with port information. AWS closes all currently open ports that are not included in the `portInfo`. Detailed below.

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/v5/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/v5/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/v5/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) Arn added in v5.4.0 

func (o KeyPairOutput) Arn() pulumi.StringOutput

The ARN of the Lightsail key pair

func (KeyPairOutput) ElementType 

func (KeyPairOutput) ElementType() reflect.Type

func (KeyPairOutput) EncryptedFingerprint added in v5.4.0 

func (o KeyPairOutput) EncryptedFingerprint() pulumi.StringOutput

The MD5 public key fingerprint for the encrypted private key

func (KeyPairOutput) EncryptedPrivateKey added in v5.4.0 

func (o KeyPairOutput) EncryptedPrivateKey() pulumi.StringOutput

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

func (KeyPairOutput) Fingerprint added in v5.4.0 

func (o KeyPairOutput) Fingerprint() pulumi.StringOutput

The MD5 public key fingerprint as specified in section 4 of RFC 4716.

func (KeyPairOutput) Name added in v5.4.0 

func (o KeyPairOutput) Name() pulumi.StringOutput

The name of the Lightsail Key Pair. If omitted, a unique name will be generated by this provider

func (KeyPairOutput) NamePrefix added in v5.4.0 

func (o KeyPairOutput) NamePrefix() pulumi.StringPtrOutput

func (KeyPairOutput) PgpKey added in v5.4.0 

func (o KeyPairOutput) PgpKey() pulumi.StringPtrOutput

An optional PGP key to encrypt the resulting private key material. Only used when creating a new key pair

func (KeyPairOutput) PrivateKey added in v5.4.0 

func (o KeyPairOutput) PrivateKey() pulumi.StringOutput

the private key, base64 encoded. This is only populated when creating a new key, and when no `pgpKey` is provided

func (KeyPairOutput) PublicKey added in v5.4.0 

func (o KeyPairOutput) PublicKey() pulumi.StringOutput

The public key material. This public key will be imported into Lightsail

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/v5/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/v5/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) InstanceName added in v5.4.0 

func (o StaticIpAttachmentOutput) InstanceName() pulumi.StringOutput

The name of the Lightsail instance to attach the IP to

func (StaticIpAttachmentOutput) IpAddress added in v5.4.0 

func (o StaticIpAttachmentOutput) IpAddress() pulumi.StringOutput

The allocated static IP address

func (StaticIpAttachmentOutput) StaticIpName added in v5.4.0 

func (o StaticIpAttachmentOutput) StaticIpName() pulumi.StringOutput

The name of the allocated static IP

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) Arn added in v5.4.0 

func (o StaticIpOutput) Arn() pulumi.StringOutput

The ARN of the Lightsail static IP

func (StaticIpOutput) ElementType 

func (StaticIpOutput) ElementType() reflect.Type

func (StaticIpOutput) IpAddress added in v5.4.0 

func (o StaticIpOutput) IpAddress() pulumi.StringOutput

The allocated static IP address

func (StaticIpOutput) Name added in v5.4.0 

func (o StaticIpOutput) Name() pulumi.StringOutput

The name for the allocated static IP

func (StaticIpOutput) SupportCode added in v5.4.0 

func (o StaticIpOutput) SupportCode() pulumi.StringOutput

The support code.

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.