1. Packages
  2. AWS Classic
  3. API Docs
  4. lightsail
  5. ContainerServiceDeploymentVersion

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

aws.lightsail.ContainerServiceDeploymentVersion

Explore with Pulumi AI

aws logo

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

    Provides a resource to manage a deployment version for your Amazon Lightsail container service.

    NOTE: The Amazon Lightsail container service must be enabled to create a deployment.

    NOTE: This resource allows you to manage an Amazon Lightsail container service deployment version but the provider cannot destroy it. Removing this resource from your configuration will remove it from your statefile.

    Example Usage

    Basic Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const example = new aws.lightsail.ContainerServiceDeploymentVersion("example", {
        containers: [{
            containerName: "hello-world",
            image: "amazon/amazon-lightsail:hello-world",
            commands: [],
            environment: {
                MY_ENVIRONMENT_VARIABLE: "my_value",
            },
            ports: {
                "80": "HTTP",
            },
        }],
        publicEndpoint: {
            containerName: "hello-world",
            containerPort: 80,
            healthCheck: {
                healthyThreshold: 2,
                unhealthyThreshold: 2,
                timeoutSeconds: 2,
                intervalSeconds: 5,
                path: "/",
                successCodes: "200-499",
            },
        },
        serviceName: exampleAwsLightsailContainerService.name,
    });
    
    import pulumi
    import pulumi_aws as aws
    
    example = aws.lightsail.ContainerServiceDeploymentVersion("example",
        containers=[aws.lightsail.ContainerServiceDeploymentVersionContainerArgs(
            container_name="hello-world",
            image="amazon/amazon-lightsail:hello-world",
            commands=[],
            environment={
                "MY_ENVIRONMENT_VARIABLE": "my_value",
            },
            ports={
                "80": "HTTP",
            },
        )],
        public_endpoint=aws.lightsail.ContainerServiceDeploymentVersionPublicEndpointArgs(
            container_name="hello-world",
            container_port=80,
            health_check=aws.lightsail.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs(
                healthy_threshold=2,
                unhealthy_threshold=2,
                timeout_seconds=2,
                interval_seconds=5,
                path="/",
                success_codes="200-499",
            ),
        ),
        service_name=example_aws_lightsail_container_service["name"])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := lightsail.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(exampleAwsLightsailContainerService.Name),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var example = new Aws.LightSail.ContainerServiceDeploymentVersion("example", new()
        {
            Containers = new[]
            {
                new Aws.LightSail.Inputs.ContainerServiceDeploymentVersionContainerArgs
                {
                    ContainerName = "hello-world",
                    Image = "amazon/amazon-lightsail:hello-world",
                    Commands = new() { },
                    Environment = 
                    {
                        { "MY_ENVIRONMENT_VARIABLE", "my_value" },
                    },
                    Ports = 
                    {
                        { "80", "HTTP" },
                    },
                },
            },
            PublicEndpoint = new Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpointArgs
            {
                ContainerName = "hello-world",
                ContainerPort = 80,
                HealthCheck = new Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs
                {
                    HealthyThreshold = 2,
                    UnhealthyThreshold = 2,
                    TimeoutSeconds = 2,
                    IntervalSeconds = 5,
                    Path = "/",
                    SuccessCodes = "200-499",
                },
            },
            ServiceName = exampleAwsLightsailContainerService.Name,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.lightsail.ContainerServiceDeploymentVersion;
    import com.pulumi.aws.lightsail.ContainerServiceDeploymentVersionArgs;
    import com.pulumi.aws.lightsail.inputs.ContainerServiceDeploymentVersionContainerArgs;
    import com.pulumi.aws.lightsail.inputs.ContainerServiceDeploymentVersionPublicEndpointArgs;
    import com.pulumi.aws.lightsail.inputs.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var example = new ContainerServiceDeploymentVersion("example", ContainerServiceDeploymentVersionArgs.builder()
                .containers(ContainerServiceDeploymentVersionContainerArgs.builder()
                    .containerName("hello-world")
                    .image("amazon/amazon-lightsail:hello-world")
                    .commands()
                    .environment(Map.of("MY_ENVIRONMENT_VARIABLE", "my_value"))
                    .ports(Map.of("80", "HTTP"))
                    .build())
                .publicEndpoint(ContainerServiceDeploymentVersionPublicEndpointArgs.builder()
                    .containerName("hello-world")
                    .containerPort(80)
                    .healthCheck(ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs.builder()
                        .healthyThreshold(2)
                        .unhealthyThreshold(2)
                        .timeoutSeconds(2)
                        .intervalSeconds(5)
                        .path("/")
                        .successCodes("200-499")
                        .build())
                    .build())
                .serviceName(exampleAwsLightsailContainerService.name())
                .build());
    
        }
    }
    
    resources:
      example:
        type: aws:lightsail:ContainerServiceDeploymentVersion
        properties:
          containers:
            - containerName: hello-world
              image: amazon/amazon-lightsail:hello-world
              commands: []
              environment:
                MY_ENVIRONMENT_VARIABLE: my_value
              ports:
                '80': HTTP
          publicEndpoint:
            containerName: hello-world
            containerPort: 80
            healthCheck:
              healthyThreshold: 2
              unhealthyThreshold: 2
              timeoutSeconds: 2
              intervalSeconds: 5
              path: /
              successCodes: 200-499
          serviceName: ${exampleAwsLightsailContainerService.name}
    

    Create ContainerServiceDeploymentVersion Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new ContainerServiceDeploymentVersion(name: string, args: ContainerServiceDeploymentVersionArgs, opts?: CustomResourceOptions);
    @overload
    def ContainerServiceDeploymentVersion(resource_name: str,
                                          args: ContainerServiceDeploymentVersionArgs,
                                          opts: Optional[ResourceOptions] = None)
    
    @overload
    def ContainerServiceDeploymentVersion(resource_name: str,
                                          opts: Optional[ResourceOptions] = None,
                                          containers: Optional[Sequence[ContainerServiceDeploymentVersionContainerArgs]] = None,
                                          service_name: Optional[str] = None,
                                          public_endpoint: Optional[ContainerServiceDeploymentVersionPublicEndpointArgs] = None)
    func NewContainerServiceDeploymentVersion(ctx *Context, name string, args ContainerServiceDeploymentVersionArgs, opts ...ResourceOption) (*ContainerServiceDeploymentVersion, error)
    public ContainerServiceDeploymentVersion(string name, ContainerServiceDeploymentVersionArgs args, CustomResourceOptions? opts = null)
    public ContainerServiceDeploymentVersion(String name, ContainerServiceDeploymentVersionArgs args)
    public ContainerServiceDeploymentVersion(String name, ContainerServiceDeploymentVersionArgs args, CustomResourceOptions options)
    
    type: aws:lightsail:ContainerServiceDeploymentVersion
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args ContainerServiceDeploymentVersionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ContainerServiceDeploymentVersionArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ContainerServiceDeploymentVersionArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ContainerServiceDeploymentVersionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ContainerServiceDeploymentVersionArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var containerServiceDeploymentVersionResource = new Aws.LightSail.ContainerServiceDeploymentVersion("containerServiceDeploymentVersionResource", new()
    {
        Containers = new[]
        {
            new Aws.LightSail.Inputs.ContainerServiceDeploymentVersionContainerArgs
            {
                ContainerName = "string",
                Image = "string",
                Commands = new[]
                {
                    "string",
                },
                Environment = 
                {
                    { "string", "string" },
                },
                Ports = 
                {
                    { "string", "string" },
                },
            },
        },
        ServiceName = "string",
        PublicEndpoint = new Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpointArgs
        {
            ContainerName = "string",
            ContainerPort = 0,
            HealthCheck = new Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs
            {
                HealthyThreshold = 0,
                IntervalSeconds = 0,
                Path = "string",
                SuccessCodes = "string",
                TimeoutSeconds = 0,
                UnhealthyThreshold = 0,
            },
        },
    });
    
    example, err := lightsail.NewContainerServiceDeploymentVersion(ctx, "containerServiceDeploymentVersionResource", &lightsail.ContainerServiceDeploymentVersionArgs{
    	Containers: lightsail.ContainerServiceDeploymentVersionContainerArray{
    		&lightsail.ContainerServiceDeploymentVersionContainerArgs{
    			ContainerName: pulumi.String("string"),
    			Image:         pulumi.String("string"),
    			Commands: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Environment: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    			Ports: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    		},
    	},
    	ServiceName: pulumi.String("string"),
    	PublicEndpoint: &lightsail.ContainerServiceDeploymentVersionPublicEndpointArgs{
    		ContainerName: pulumi.String("string"),
    		ContainerPort: pulumi.Int(0),
    		HealthCheck: &lightsail.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs{
    			HealthyThreshold:   pulumi.Int(0),
    			IntervalSeconds:    pulumi.Int(0),
    			Path:               pulumi.String("string"),
    			SuccessCodes:       pulumi.String("string"),
    			TimeoutSeconds:     pulumi.Int(0),
    			UnhealthyThreshold: pulumi.Int(0),
    		},
    	},
    })
    
    var containerServiceDeploymentVersionResource = new ContainerServiceDeploymentVersion("containerServiceDeploymentVersionResource", ContainerServiceDeploymentVersionArgs.builder()
        .containers(ContainerServiceDeploymentVersionContainerArgs.builder()
            .containerName("string")
            .image("string")
            .commands("string")
            .environment(Map.of("string", "string"))
            .ports(Map.of("string", "string"))
            .build())
        .serviceName("string")
        .publicEndpoint(ContainerServiceDeploymentVersionPublicEndpointArgs.builder()
            .containerName("string")
            .containerPort(0)
            .healthCheck(ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs.builder()
                .healthyThreshold(0)
                .intervalSeconds(0)
                .path("string")
                .successCodes("string")
                .timeoutSeconds(0)
                .unhealthyThreshold(0)
                .build())
            .build())
        .build());
    
    container_service_deployment_version_resource = aws.lightsail.ContainerServiceDeploymentVersion("containerServiceDeploymentVersionResource",
        containers=[aws.lightsail.ContainerServiceDeploymentVersionContainerArgs(
            container_name="string",
            image="string",
            commands=["string"],
            environment={
                "string": "string",
            },
            ports={
                "string": "string",
            },
        )],
        service_name="string",
        public_endpoint=aws.lightsail.ContainerServiceDeploymentVersionPublicEndpointArgs(
            container_name="string",
            container_port=0,
            health_check=aws.lightsail.ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs(
                healthy_threshold=0,
                interval_seconds=0,
                path="string",
                success_codes="string",
                timeout_seconds=0,
                unhealthy_threshold=0,
            ),
        ))
    
    const containerServiceDeploymentVersionResource = new aws.lightsail.ContainerServiceDeploymentVersion("containerServiceDeploymentVersionResource", {
        containers: [{
            containerName: "string",
            image: "string",
            commands: ["string"],
            environment: {
                string: "string",
            },
            ports: {
                string: "string",
            },
        }],
        serviceName: "string",
        publicEndpoint: {
            containerName: "string",
            containerPort: 0,
            healthCheck: {
                healthyThreshold: 0,
                intervalSeconds: 0,
                path: "string",
                successCodes: "string",
                timeoutSeconds: 0,
                unhealthyThreshold: 0,
            },
        },
    });
    
    type: aws:lightsail:ContainerServiceDeploymentVersion
    properties:
        containers:
            - commands:
                - string
              containerName: string
              environment:
                string: string
              image: string
              ports:
                string: string
        publicEndpoint:
            containerName: string
            containerPort: 0
            healthCheck:
                healthyThreshold: 0
                intervalSeconds: 0
                path: string
                successCodes: string
                timeoutSeconds: 0
                unhealthyThreshold: 0
        serviceName: string
    

    ContainerServiceDeploymentVersion Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The ContainerServiceDeploymentVersion resource accepts the following input properties:

    Containers List<Pulumi.Aws.LightSail.Inputs.ContainerServiceDeploymentVersionContainer>
    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.
    ServiceName string
    The name for the container service.
    PublicEndpoint Pulumi.Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpoint
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    Containers []ContainerServiceDeploymentVersionContainerArgs
    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.
    ServiceName string
    The name for the container service.
    PublicEndpoint ContainerServiceDeploymentVersionPublicEndpointArgs
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    containers List<ContainerServiceDeploymentVersionContainer>
    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.
    serviceName String
    The name for the container service.
    publicEndpoint ContainerServiceDeploymentVersionPublicEndpoint
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    containers ContainerServiceDeploymentVersionContainer[]
    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.
    serviceName string
    The name for the container service.
    publicEndpoint ContainerServiceDeploymentVersionPublicEndpoint
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    containers Sequence[ContainerServiceDeploymentVersionContainerArgs]
    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.
    service_name str
    The name for the container service.
    public_endpoint ContainerServiceDeploymentVersionPublicEndpointArgs
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    containers List<Property Map>
    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.
    serviceName String
    The name for the container service.
    publicEndpoint Property Map
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ContainerServiceDeploymentVersion resource produces the following output properties:

    CreatedAt string
    The timestamp when the deployment was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    State string
    The current state of the container service.
    Version int
    The version number of the deployment.
    CreatedAt string
    The timestamp when the deployment was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    State string
    The current state of the container service.
    Version int
    The version number of the deployment.
    createdAt String
    The timestamp when the deployment was created.
    id String
    The provider-assigned unique ID for this managed resource.
    state String
    The current state of the container service.
    version Integer
    The version number of the deployment.
    createdAt string
    The timestamp when the deployment was created.
    id string
    The provider-assigned unique ID for this managed resource.
    state string
    The current state of the container service.
    version number
    The version number of the deployment.
    created_at str
    The timestamp when the deployment was created.
    id str
    The provider-assigned unique ID for this managed resource.
    state str
    The current state of the container service.
    version int
    The version number of the deployment.
    createdAt String
    The timestamp when the deployment was created.
    id String
    The provider-assigned unique ID for this managed resource.
    state String
    The current state of the container service.
    version Number
    The version number of the deployment.

    Look up Existing ContainerServiceDeploymentVersion Resource

    Get an existing ContainerServiceDeploymentVersion resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ContainerServiceDeploymentVersionState, opts?: CustomResourceOptions): ContainerServiceDeploymentVersion
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            containers: Optional[Sequence[ContainerServiceDeploymentVersionContainerArgs]] = None,
            created_at: Optional[str] = None,
            public_endpoint: Optional[ContainerServiceDeploymentVersionPublicEndpointArgs] = None,
            service_name: Optional[str] = None,
            state: Optional[str] = None,
            version: Optional[int] = None) -> ContainerServiceDeploymentVersion
    func GetContainerServiceDeploymentVersion(ctx *Context, name string, id IDInput, state *ContainerServiceDeploymentVersionState, opts ...ResourceOption) (*ContainerServiceDeploymentVersion, error)
    public static ContainerServiceDeploymentVersion Get(string name, Input<string> id, ContainerServiceDeploymentVersionState? state, CustomResourceOptions? opts = null)
    public static ContainerServiceDeploymentVersion get(String name, Output<String> id, ContainerServiceDeploymentVersionState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Containers List<Pulumi.Aws.LightSail.Inputs.ContainerServiceDeploymentVersionContainer>
    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.
    CreatedAt string
    The timestamp when the deployment was created.
    PublicEndpoint Pulumi.Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpoint
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    ServiceName string
    The name for the container service.
    State string
    The current state of the container service.
    Version int
    The version number of the deployment.
    Containers []ContainerServiceDeploymentVersionContainerArgs
    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.
    CreatedAt string
    The timestamp when the deployment was created.
    PublicEndpoint ContainerServiceDeploymentVersionPublicEndpointArgs
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    ServiceName string
    The name for the container service.
    State string
    The current state of the container service.
    Version int
    The version number of the deployment.
    containers List<ContainerServiceDeploymentVersionContainer>
    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.
    createdAt String
    The timestamp when the deployment was created.
    publicEndpoint ContainerServiceDeploymentVersionPublicEndpoint
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    serviceName String
    The name for the container service.
    state String
    The current state of the container service.
    version Integer
    The version number of the deployment.
    containers ContainerServiceDeploymentVersionContainer[]
    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.
    createdAt string
    The timestamp when the deployment was created.
    publicEndpoint ContainerServiceDeploymentVersionPublicEndpoint
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    serviceName string
    The name for the container service.
    state string
    The current state of the container service.
    version number
    The version number of the deployment.
    containers Sequence[ContainerServiceDeploymentVersionContainerArgs]
    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.
    created_at str
    The timestamp when the deployment was created.
    public_endpoint ContainerServiceDeploymentVersionPublicEndpointArgs
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    service_name str
    The name for the container service.
    state str
    The current state of the container service.
    version int
    The version number of the deployment.
    containers List<Property Map>
    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.
    createdAt String
    The timestamp when the deployment was created.
    publicEndpoint Property Map
    A configuration block that describes the settings of the public endpoint for the container service. Detailed below.
    serviceName String
    The name for the container service.
    state String
    The current state of the container service.
    version Number
    The version number of the deployment.

    Supporting Types

    ContainerServiceDeploymentVersionContainer, ContainerServiceDeploymentVersionContainerArgs

    ContainerName string
    The name for the container.
    Image string
    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.
    Commands List<string>
    The launch command for the container. A list of string.
    Environment Dictionary<string, string>
    A key-value map of the environment variables of the container.
    Ports Dictionary<string, string>
    A key-value map of the open firewall ports of the container. Valid values: HTTP, HTTPS, TCP, UDP.
    ContainerName string
    The name for the container.
    Image string
    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.
    Commands []string
    The launch command for the container. A list of string.
    Environment map[string]string
    A key-value map of the environment variables of the container.
    Ports map[string]string
    A key-value map of the open firewall ports of the container. Valid values: HTTP, HTTPS, TCP, UDP.
    containerName String
    The name for the container.
    image String
    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.
    commands List<String>
    The launch command for the container. A list of string.
    environment Map<String,String>
    A key-value map of the environment variables of the container.
    ports Map<String,String>
    A key-value map of the open firewall ports of the container. Valid values: HTTP, HTTPS, TCP, UDP.
    containerName string
    The name for the container.
    image string
    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.
    commands string[]
    The launch command for the container. A list of string.
    environment {[key: string]: string}
    A key-value map of the environment variables of the container.
    ports {[key: string]: string}
    A key-value map of the open firewall ports of the container. Valid values: HTTP, HTTPS, TCP, UDP.
    container_name str
    The name for the container.
    image str
    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.
    commands Sequence[str]
    The launch command for the container. A list of string.
    environment Mapping[str, str]
    A key-value map of the environment variables of the container.
    ports Mapping[str, str]
    A key-value map of the open firewall ports of the container. Valid values: HTTP, HTTPS, TCP, UDP.
    containerName String
    The name for the container.
    image String
    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.
    commands List<String>
    The launch command for the container. A list of string.
    environment Map<String>
    A key-value map of the environment variables of the container.
    ports Map<String>
    A key-value map of the open firewall ports of the container. Valid values: HTTP, HTTPS, TCP, UDP.

    ContainerServiceDeploymentVersionPublicEndpoint, ContainerServiceDeploymentVersionPublicEndpointArgs

    ContainerName string
    The name of the container for the endpoint.
    ContainerPort int
    The port of the container to which traffic is forwarded to.
    HealthCheck Pulumi.Aws.LightSail.Inputs.ContainerServiceDeploymentVersionPublicEndpointHealthCheck
    A configuration block that describes the health check configuration of the container. Detailed below.
    ContainerName string
    The name of the container for the endpoint.
    ContainerPort int
    The port of the container to which traffic is forwarded to.
    HealthCheck ContainerServiceDeploymentVersionPublicEndpointHealthCheck
    A configuration block that describes the health check configuration of the container. Detailed below.
    containerName String
    The name of the container for the endpoint.
    containerPort Integer
    The port of the container to which traffic is forwarded to.
    healthCheck ContainerServiceDeploymentVersionPublicEndpointHealthCheck
    A configuration block that describes the health check configuration of the container. Detailed below.
    containerName string
    The name of the container for the endpoint.
    containerPort number
    The port of the container to which traffic is forwarded to.
    healthCheck ContainerServiceDeploymentVersionPublicEndpointHealthCheck
    A configuration block that describes the health check configuration of the container. Detailed below.
    container_name str
    The name of the container for the endpoint.
    container_port int
    The port of the container to which traffic is forwarded to.
    health_check ContainerServiceDeploymentVersionPublicEndpointHealthCheck
    A configuration block that describes the health check configuration of the container. Detailed below.
    containerName String
    The name of the container for the endpoint.
    containerPort Number
    The port of the container to which traffic is forwarded to.
    healthCheck Property Map
    A configuration block that describes the health check configuration of the container. Detailed below.

    ContainerServiceDeploymentVersionPublicEndpointHealthCheck, ContainerServiceDeploymentVersionPublicEndpointHealthCheckArgs

    HealthyThreshold int
    The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
    IntervalSeconds int
    The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
    Path string
    The path on the container on which to perform the health check. Defaults to "/".
    SuccessCodes string
    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".
    TimeoutSeconds int
    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.
    UnhealthyThreshold int
    The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
    HealthyThreshold int
    The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
    IntervalSeconds int
    The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
    Path string
    The path on the container on which to perform the health check. Defaults to "/".
    SuccessCodes string
    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".
    TimeoutSeconds int
    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.
    UnhealthyThreshold int
    The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
    healthyThreshold Integer
    The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
    intervalSeconds Integer
    The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
    path String
    The path on the container on which to perform the health check. Defaults to "/".
    successCodes String
    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".
    timeoutSeconds Integer
    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.
    unhealthyThreshold Integer
    The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
    healthyThreshold number
    The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
    intervalSeconds number
    The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
    path string
    The path on the container on which to perform the health check. Defaults to "/".
    successCodes string
    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".
    timeoutSeconds number
    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.
    unhealthyThreshold number
    The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
    healthy_threshold int
    The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
    interval_seconds int
    The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
    path str
    The path on the container on which to perform the health check. Defaults to "/".
    success_codes str
    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".
    timeout_seconds int
    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.
    unhealthy_threshold int
    The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.
    healthyThreshold Number
    The number of consecutive health checks successes required before moving the container to the Healthy state. Defaults to 2.
    intervalSeconds Number
    The approximate interval, in seconds, between health checks of an individual container. You can specify between 5 and 300 seconds. Defaults to 5.
    path String
    The path on the container on which to perform the health check. Defaults to "/".
    successCodes String
    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".
    timeoutSeconds Number
    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.
    unhealthyThreshold Number
    The number of consecutive health checks failures required before moving the container to the Unhealthy state. Defaults to 2.

    Import

    Using pulumi import, import Lightsail Container Service Deployment Version using the service_name and version separated by a slash (/). For example:

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

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo

    Try AWS Native preview for resources not in the classic version.

    AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi