Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi IDP Pulumi Cloud Packages Tutorials
  1. Packages
  2. AWS
  3. API Docs
  4. lightsail
  5. ContainerService
AWS v6.83.0 published on Monday, Jun 16, 2025 by Pulumi
pulumi/pulumi-aws

aws.lightsail.ContainerService

Explore with Pulumi AI

aws logo
AWS v6.83.0 published on Monday, Jun 16, 2025 by Pulumi
pulumi/pulumi-aws

    Manages a Lightsail container service. Use this resource to create and manage a scalable compute and networking platform for deploying, running, and managing containerized applications in Lightsail.

    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”.

    NOTE: You must create and validate an SSL/TLS certificate before you can use public_domain_names with your container service. For more information, see Enabling and managing custom domains for your Amazon Lightsail container services.

    Example Usage

    Basic Usage

    import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.lightsail.ContainerService("example", {
    name: "container-service-1",
    power: "nano",
    scale: 1,
    isDisabled: false,
    tags: {
        foo1: "bar1",
        foo2: "",
    },
});

    import pulumi
import pulumi_aws as aws

example = aws.lightsail.ContainerService("example",
    name="container-service-1",
    power="nano",
    scale=1,
    is_disabled=False,
    tags={
        "foo1": "bar1",
        "foo2": "",
    })

    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.NewContainerService(ctx, "example", &lightsail.ContainerServiceArgs{
			Name:       pulumi.String("container-service-1"),
			Power:      pulumi.String("nano"),
			Scale:      pulumi.Int(1),
			IsDisabled: pulumi.Bool(false),
			Tags: pulumi.StringMap{
				"foo1": pulumi.String("bar1"),
				"foo2": pulumi.String(""),
			},
		})
		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.ContainerService("example", new()
    {
        Name = "container-service-1",
        Power = "nano",
        Scale = 1,
        IsDisabled = false,
        Tags = 
        {
            { "foo1", "bar1" },
            { "foo2", "" },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.ContainerService;
import com.pulumi.aws.lightsail.ContainerServiceArgs;
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 ContainerService("example", ContainerServiceArgs.builder()
            .name("container-service-1")
            .power("nano")
            .scale(1)
            .isDisabled(false)
            .tags(Map.ofEntries(
                Map.entry("foo1", "bar1"),
                Map.entry("foo2", "")
            ))
            .build());

    }
}

    resources:
  example:
    type: aws:lightsail:ContainerService
    properties:
      name: container-service-1
      power: nano
      scale: 1
      isDisabled: false
      tags:
        foo1: bar1
        foo2: ""

    Public Domain Names

    import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.lightsail.ContainerService("example", {publicDomainNames: {
    certificates: [{
        certificateName: "example-certificate",
        domainNames: ["www.example.com"],
    }],
}});

    import pulumi
import pulumi_aws as aws

example = aws.lightsail.ContainerService("example", public_domain_names={
    "certificates": [{
        "certificate_name": "example-certificate",
        "domain_names": ["www.example.com"],
    }],
})

    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.NewContainerService(ctx, "example", &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
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.LightSail.ContainerService("example", new()
    {
        PublicDomainNames = new Aws.LightSail.Inputs.ContainerServicePublicDomainNamesArgs
        {
            Certificates = new[]
            {
                new Aws.LightSail.Inputs.ContainerServicePublicDomainNamesCertificateArgs
                {
                    CertificateName = "example-certificate",
                    DomainNames = new[]
                    {
                        "www.example.com",
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.ContainerService;
import com.pulumi.aws.lightsail.ContainerServiceArgs;
import com.pulumi.aws.lightsail.inputs.ContainerServicePublicDomainNamesArgs;
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 ContainerService("example", ContainerServiceArgs.builder()
            .publicDomainNames(ContainerServicePublicDomainNamesArgs.builder()
                .certificates(ContainerServicePublicDomainNamesCertificateArgs.builder()
                    .certificateName("example-certificate")
                    .domainNames("www.example.com")
                    .build())
                .build())
            .build());

    }
}

    resources:
  example:
    type: aws:lightsail:ContainerService
    properties:
      publicDomainNames:
        certificates:
          - certificateName: example-certificate
            domainNames:
              - www.example.com

    Private Registry Access

    import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const exampleContainerService = new aws.lightsail.ContainerService("example", {privateRegistryAccess: {
    ecrImagePullerRole: {
        isActive: true,
    },
}});
const example = exampleContainerService.privateRegistryAccess.apply(privateRegistryAccess => aws.iam.getPolicyDocumentOutput({
    statements: [{
        effect: "Allow",
        principals: [{
            type: "AWS",
            identifiers: [privateRegistryAccess.ecrImagePullerRole?.principalArn],
        }],
        actions: [
            "ecr:BatchGetImage",
            "ecr:GetDownloadUrlForLayer",
        ],
    }],
}));
const exampleRepositoryPolicy = new aws.ecr.RepositoryPolicy("example", {
    repository: exampleAwsEcrRepository.name,
    policy: example.apply(example => example.json),
});

    import pulumi
import pulumi_aws as aws

example_container_service = aws.lightsail.ContainerService("example", private_registry_access={
    "ecr_image_puller_role": {
        "is_active": True,
    },
})
example = example_container_service.private_registry_access.apply(lambda private_registry_access: aws.iam.get_policy_document_output(statements=[{
    "effect": "Allow",
    "principals": [{
        "type": "AWS",
        "identifiers": [private_registry_access.ecr_image_puller_role.principal_arn],
    }],
    "actions": [
        "ecr:BatchGetImage",
        "ecr:GetDownloadUrlForLayer",
    ],
}]))
example_repository_policy = aws.ecr.RepositoryPolicy("example",
    repository=example_aws_ecr_repository["name"],
    policy=example.json)

    package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecr"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
	"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 {
exampleContainerService, err := lightsail.NewContainerService(ctx, "example", &lightsail.ContainerServiceArgs{
PrivateRegistryAccess: &lightsail.ContainerServicePrivateRegistryAccessArgs{
EcrImagePullerRole: &lightsail.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs{
IsActive: pulumi.Bool(true),
},
},
})
if err != nil {
return err
}
example := exampleContainerService.PrivateRegistryAccess.ApplyT(func(privateRegistryAccess lightsail.ContainerServicePrivateRegistryAccess) (iam.GetPolicyDocumentResult, error) {
return iam.GetPolicyDocumentResult(interface{}(iam.GetPolicyDocumentOutput(ctx, iam.GetPolicyDocumentOutputArgs{
Statements: []iam.GetPolicyDocumentStatement{
{
Effect: "Allow",
Principals: []iam.GetPolicyDocumentStatementPrincipal{
{
Type: "AWS",
Identifiers: interface{}{
privateRegistryAccess.EcrImagePullerRole.PrincipalArn,
},
},
},
Actions: []string{
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer",
},
},
},
}, nil))), nil
}).(iam.GetPolicyDocumentResultOutput)
_, err = ecr.NewRepositoryPolicy(ctx, "example", &ecr.RepositoryPolicyArgs{
Repository: pulumi.Any(exampleAwsEcrRepository.Name),
Policy: pulumi.String(example.ApplyT(func(example iam.GetPolicyDocumentResult) (*string, error) {
return &example.Json, nil
}).(pulumi.StringPtrOutput)),
})
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 exampleContainerService = new Aws.LightSail.ContainerService("example", new()
    {
        PrivateRegistryAccess = new Aws.LightSail.Inputs.ContainerServicePrivateRegistryAccessArgs
        {
            EcrImagePullerRole = new Aws.LightSail.Inputs.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs
            {
                IsActive = true,
            },
        },
    });

    var example = Aws.Iam.GetPolicyDocument.Invoke(new()
    {
        Statements = new[]
        {
            new Aws.Iam.Inputs.GetPolicyDocumentStatementInputArgs
            {
                Effect = "Allow",
                Principals = new[]
                {
                    new Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalInputArgs
                    {
                        Type = "AWS",
                        Identifiers = new[]
                        {
                            exampleContainerService.PrivateRegistryAccess.EcrImagePullerRole?.PrincipalArn,
                        },
                    },
                },
                Actions = new[]
                {
                    "ecr:BatchGetImage",
                    "ecr:GetDownloadUrlForLayer",
                },
            },
        },
    });

    var exampleRepositoryPolicy = new Aws.Ecr.RepositoryPolicy("example", new()
    {
        Repository = exampleAwsEcrRepository.Name,
        Policy = example.Apply(getPolicyDocumentResult => getPolicyDocumentResult.Json),
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.ContainerService;
import com.pulumi.aws.lightsail.ContainerServiceArgs;
import com.pulumi.aws.lightsail.inputs.ContainerServicePrivateRegistryAccessArgs;
import com.pulumi.aws.lightsail.inputs.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs;
import com.pulumi.aws.iam.IamFunctions;
import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
import com.pulumi.aws.ecr.RepositoryPolicy;
import com.pulumi.aws.ecr.RepositoryPolicyArgs;
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 exampleContainerService = new ContainerService("exampleContainerService", ContainerServiceArgs.builder()
            .privateRegistryAccess(ContainerServicePrivateRegistryAccessArgs.builder()
                .ecrImagePullerRole(ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs.builder()
                    .isActive(true)
                    .build())
                .build())
            .build());

        final var example = exampleContainerService.privateRegistryAccess().applyValue(_privateRegistryAccess -> IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
            .statements(GetPolicyDocumentStatementArgs.builder()
                .effect("Allow")
                .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                    .type("AWS")
                    .identifiers(_privateRegistryAccess.ecrImagePullerRole().principalArn())
                    .build())
                .actions(                
                    "ecr:BatchGetImage",
                    "ecr:GetDownloadUrlForLayer")
                .build())
            .build()));

        var exampleRepositoryPolicy = new RepositoryPolicy("exampleRepositoryPolicy", RepositoryPolicyArgs.builder()
            .repository(exampleAwsEcrRepository.name())
            .policy(example.applyValue(_example -> _example.json()))
            .build());

    }
}

    resources:
  exampleContainerService:
    type: aws:lightsail:ContainerService
    name: example
    properties:
      privateRegistryAccess:
        ecrImagePullerRole:
          isActive: true
  exampleRepositoryPolicy:
    type: aws:ecr:RepositoryPolicy
    name: example
    properties:
      repository: ${exampleAwsEcrRepository.name}
      policy: ${example.json}
variables:
  example:
    fn::invoke:
      function: aws:iam:getPolicyDocument
      arguments:
        statements:
          - effect: Allow
            principals:
              - type: AWS
                identifiers:
                  - ${exampleContainerService.privateRegistryAccess.ecrImagePullerRole.principalArn}
            actions:
              - ecr:BatchGetImage
              - ecr:GetDownloadUrlForLayer

    Create ContainerService Resource

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

    Constructor syntax

    new ContainerService(name: string, args: ContainerServiceArgs, opts?: CustomResourceOptions);
    @overload
def ContainerService(resource_name: str,
                     args: ContainerServiceArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def ContainerService(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     power: Optional[str] = None,
                     scale: Optional[int] = None,
                     is_disabled: Optional[bool] = None,
                     name: Optional[str] = None,
                     private_registry_access: Optional[ContainerServicePrivateRegistryAccessArgs] = None,
                     public_domain_names: Optional[ContainerServicePublicDomainNamesArgs] = None,
                     tags: Optional[Mapping[str, str]] = None)
    func NewContainerService(ctx *Context, name string, args ContainerServiceArgs, opts ...ResourceOption) (*ContainerService, error)
    public ContainerService(string name, ContainerServiceArgs args, CustomResourceOptions? opts = null)
    public ContainerService(String name, ContainerServiceArgs args)
public ContainerService(String name, ContainerServiceArgs args, CustomResourceOptions options)

    type: aws:lightsail:ContainerService
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 ContainerServiceArgs
    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 ContainerServiceArgs
    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 ContainerServiceArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ContainerServiceArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ContainerServiceArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

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

    var containerServiceResource = new Aws.LightSail.ContainerService("containerServiceResource", new()
{
    Power = "string",
    Scale = 0,
    IsDisabled = false,
    Name = "string",
    PrivateRegistryAccess = new Aws.LightSail.Inputs.ContainerServicePrivateRegistryAccessArgs
    {
        EcrImagePullerRole = new Aws.LightSail.Inputs.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs
        {
            IsActive = false,
            PrincipalArn = "string",
        },
    },
    PublicDomainNames = new Aws.LightSail.Inputs.ContainerServicePublicDomainNamesArgs
    {
        Certificates = new[]
        {
            new Aws.LightSail.Inputs.ContainerServicePublicDomainNamesCertificateArgs
            {
                CertificateName = "string",
                DomainNames = new[]
                {
                    "string",
                },
            },
        },
    },
    Tags = 
    {
        { "string", "string" },
    },
});

    example, err := lightsail.NewContainerService(ctx, "containerServiceResource", &lightsail.ContainerServiceArgs{
	Power:      pulumi.String("string"),
	Scale:      pulumi.Int(0),
	IsDisabled: pulumi.Bool(false),
	Name:       pulumi.String("string"),
	PrivateRegistryAccess: &lightsail.ContainerServicePrivateRegistryAccessArgs{
		EcrImagePullerRole: &lightsail.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs{
			IsActive:     pulumi.Bool(false),
			PrincipalArn: pulumi.String("string"),
		},
	},
	PublicDomainNames: &lightsail.ContainerServicePublicDomainNamesArgs{
		Certificates: lightsail.ContainerServicePublicDomainNamesCertificateArray{
			&lightsail.ContainerServicePublicDomainNamesCertificateArgs{
				CertificateName: pulumi.String("string"),
				DomainNames: pulumi.StringArray{
					pulumi.String("string"),
				},
			},
		},
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
})

    var containerServiceResource = new ContainerService("containerServiceResource", ContainerServiceArgs.builder()
    .power("string")
    .scale(0)
    .isDisabled(false)
    .name("string")
    .privateRegistryAccess(ContainerServicePrivateRegistryAccessArgs.builder()
        .ecrImagePullerRole(ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs.builder()
            .isActive(false)
            .principalArn("string")
            .build())
        .build())
    .publicDomainNames(ContainerServicePublicDomainNamesArgs.builder()
        .certificates(ContainerServicePublicDomainNamesCertificateArgs.builder()
            .certificateName("string")
            .domainNames("string")
            .build())
        .build())
    .tags(Map.of("string", "string"))
    .build());

    container_service_resource = aws.lightsail.ContainerService("containerServiceResource",
    power="string",
    scale=0,
    is_disabled=False,
    name="string",
    private_registry_access={
        "ecr_image_puller_role": {
            "is_active": False,
            "principal_arn": "string",
        },
    },
    public_domain_names={
        "certificates": [{
            "certificate_name": "string",
            "domain_names": ["string"],
        }],
    },
    tags={
        "string": "string",
    })

    const containerServiceResource = new aws.lightsail.ContainerService("containerServiceResource", {
    power: "string",
    scale: 0,
    isDisabled: false,
    name: "string",
    privateRegistryAccess: {
        ecrImagePullerRole: {
            isActive: false,
            principalArn: "string",
        },
    },
    publicDomainNames: {
        certificates: [{
            certificateName: "string",
            domainNames: ["string"],
        }],
    },
    tags: {
        string: "string",
    },
});

    type: aws:lightsail:ContainerService
properties:
    isDisabled: false
    name: string
    power: string
    privateRegistryAccess:
        ecrImagePullerRole:
            isActive: false
            principalArn: string
    publicDomainNames:
        certificates:
            - certificateName: string
              domainNames:
                - string
    scale: 0
    tags:
        string: string

    ContainerService Resource Properties

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

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The ContainerService resource accepts the following input properties:

    Power string
    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.
    Scale int

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

    The following arguments are optional:

    IsDisabled bool
    Whether to disable the container service. Defaults to false.
    Name string
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccess
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    PublicDomainNames ContainerServicePublicDomainNames
    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. See below.
    Tags Dictionary<string, string>
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    Power string
    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.
    Scale int

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

    The following arguments are optional:

    IsDisabled bool
    Whether to disable the container service. Defaults to false.
    Name string
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccessArgs
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    PublicDomainNames ContainerServicePublicDomainNamesArgs
    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. See below.
    Tags map[string]string
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power String
    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.
    scale Integer

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

    The following arguments are optional:

    isDisabled Boolean
    Whether to disable the container service. Defaults to false.
    name String
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    publicDomainNames ContainerServicePublicDomainNames
    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. See below.
    tags Map<String,String>
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power string
    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.
    scale number

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

    The following arguments are optional:

    isDisabled boolean
    Whether to disable the container service. Defaults to false.
    name string
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    publicDomainNames ContainerServicePublicDomainNames
    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. See below.
    tags {[key: string]: string}
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power str
    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.
    scale int

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

    The following arguments are optional:

    is_disabled bool
    Whether to disable the container service. Defaults to false.
    name str
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    private_registry_access ContainerServicePrivateRegistryAccessArgs
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    public_domain_names ContainerServicePublicDomainNamesArgs
    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. See below.
    tags Mapping[str, str]
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power String
    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.
    scale Number

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

    The following arguments are optional:

    isDisabled Boolean
    Whether to disable the container service. Defaults to false.
    name String
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    privateRegistryAccess Property Map
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    publicDomainNames Property Map
    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. See below.
    tags Map<String>
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

    Outputs

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

    Arn string
    ARN of the container service.
    AvailabilityZone string
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    Date and time when the container service was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    PowerId string
    Power ID of the container service.
    PrincipalArn string
    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.
    PrivateDomainName string
    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.
    ResourceType string
    Lightsail resource type of the container service (i.e., ContainerService).
    State string
    Current state of the container service.
    TagsAll Dictionary<string, string>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    Arn string
    ARN of the container service.
    AvailabilityZone string
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    Date and time when the container service was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    PowerId string
    Power ID of the container service.
    PrincipalArn string
    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.
    PrivateDomainName string
    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.
    ResourceType string
    Lightsail resource type of the container service (i.e., ContainerService).
    State string
    Current state of the container service.
    TagsAll map[string]string
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    ARN of the container service.
    availabilityZone String
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    Date and time when the container service was created.
    id String
    The provider-assigned unique ID for this managed resource.
    powerId String
    Power ID of the container service.
    principalArn String
    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.
    privateDomainName String
    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.
    resourceType String
    Lightsail resource type of the container service (i.e., ContainerService).
    state String
    Current state of the container service.
    tagsAll Map<String,String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url String
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn string
    ARN of the container service.
    availabilityZone string
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt string
    Date and time when the container service was created.
    id string
    The provider-assigned unique ID for this managed resource.
    powerId string
    Power ID of the container service.
    principalArn string
    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.
    privateDomainName string
    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.
    resourceType string
    Lightsail resource type of the container service (i.e., ContainerService).
    state string
    Current state of the container service.
    tagsAll {[key: string]: string}
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url string
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn str
    ARN of the container service.
    availability_zone str
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    created_at str
    Date and time when the container service was created.
    id str
    The provider-assigned unique ID for this managed resource.
    power_id str
    Power ID of the container service.
    principal_arn str
    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.
    private_domain_name str
    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.
    resource_type str
    Lightsail resource type of the container service (i.e., ContainerService).
    state str
    Current state of the container service.
    tags_all Mapping[str, str]
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url str
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    ARN of the container service.
    availabilityZone String
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    Date and time when the container service was created.
    id String
    The provider-assigned unique ID for this managed resource.
    powerId String
    Power ID of the container service.
    principalArn String
    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.
    privateDomainName String
    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.
    resourceType String
    Lightsail resource type of the container service (i.e., ContainerService).
    state String
    Current state of the container service.
    tagsAll Map<String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

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

    Look up Existing ContainerService Resource

    Get an existing ContainerService 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?: ContainerServiceState, opts?: CustomResourceOptions): ContainerService
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        arn: Optional[str] = None,
        availability_zone: Optional[str] = None,
        created_at: Optional[str] = None,
        is_disabled: Optional[bool] = None,
        name: Optional[str] = None,
        power: Optional[str] = None,
        power_id: Optional[str] = None,
        principal_arn: Optional[str] = None,
        private_domain_name: Optional[str] = None,
        private_registry_access: Optional[ContainerServicePrivateRegistryAccessArgs] = None,
        public_domain_names: Optional[ContainerServicePublicDomainNamesArgs] = None,
        resource_type: Optional[str] = None,
        scale: Optional[int] = None,
        state: Optional[str] = None,
        tags: Optional[Mapping[str, str]] = None,
        tags_all: Optional[Mapping[str, str]] = None,
        url: Optional[str] = None) -> ContainerService
    func GetContainerService(ctx *Context, name string, id IDInput, state *ContainerServiceState, opts ...ResourceOption) (*ContainerService, error)
    public static ContainerService Get(string name, Input<string> id, ContainerServiceState? state, CustomResourceOptions? opts = null)
    public static ContainerService get(String name, Output<String> id, ContainerServiceState state, CustomResourceOptions options)
    resources:  _:    type: aws:lightsail:ContainerService    get:      id: ${id}
    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:
    Arn string
    ARN of the container service.
    AvailabilityZone string
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    Date and time when the container service was created.
    IsDisabled bool
    Whether to disable the container service. Defaults to false.
    Name string
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    Power string
    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.
    PowerId string
    Power ID of the container service.
    PrincipalArn string
    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.
    PrivateDomainName string
    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.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccess
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    PublicDomainNames ContainerServicePublicDomainNames
    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. See below.
    ResourceType string
    Lightsail resource type of the container service (i.e., ContainerService).
    Scale int

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

    The following arguments are optional:

    State string
    Current state of the container service.
    Tags Dictionary<string, string>
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    TagsAll Dictionary<string, string>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    Arn string
    ARN of the container service.
    AvailabilityZone string
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    Date and time when the container service was created.
    IsDisabled bool
    Whether to disable the container service. Defaults to false.
    Name string
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    Power string
    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.
    PowerId string
    Power ID of the container service.
    PrincipalArn string
    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.
    PrivateDomainName string
    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.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccessArgs
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    PublicDomainNames ContainerServicePublicDomainNamesArgs
    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. See below.
    ResourceType string
    Lightsail resource type of the container service (i.e., ContainerService).
    Scale int

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

    The following arguments are optional:

    State string
    Current state of the container service.
    Tags map[string]string
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    TagsAll map[string]string
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    ARN of the container service.
    availabilityZone String
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    Date and time when the container service was created.
    isDisabled Boolean
    Whether to disable the container service. Defaults to false.
    name String
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power String
    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.
    powerId String
    Power ID of the container service.
    principalArn String
    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.
    privateDomainName String
    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.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    publicDomainNames ContainerServicePublicDomainNames
    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. See below.
    resourceType String
    Lightsail resource type of the container service (i.e., ContainerService).
    scale Integer

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

    The following arguments are optional:

    state String
    Current state of the container service.
    tags Map<String,String>
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tagsAll Map<String,String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url String
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn string
    ARN of the container service.
    availabilityZone string
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt string
    Date and time when the container service was created.
    isDisabled boolean
    Whether to disable the container service. Defaults to false.
    name string
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power string
    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.
    powerId string
    Power ID of the container service.
    principalArn string
    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.
    privateDomainName string
    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.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    publicDomainNames ContainerServicePublicDomainNames
    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. See below.
    resourceType string
    Lightsail resource type of the container service (i.e., ContainerService).
    scale number

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

    The following arguments are optional:

    state string
    Current state of the container service.
    tags {[key: string]: string}
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tagsAll {[key: string]: string}
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url string
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn str
    ARN of the container service.
    availability_zone str
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    created_at str
    Date and time when the container service was created.
    is_disabled bool
    Whether to disable the container service. Defaults to false.
    name str
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power str
    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_id str
    Power ID of the container service.
    principal_arn str
    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.
    private_domain_name str
    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.
    private_registry_access ContainerServicePrivateRegistryAccessArgs
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    public_domain_names ContainerServicePublicDomainNamesArgs
    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. See below.
    resource_type str
    Lightsail resource type of the container service (i.e., ContainerService).
    scale int

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

    The following arguments are optional:

    state str
    Current state of the container service.
    tags Mapping[str, str]
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tags_all Mapping[str, str]
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url str
    Publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    ARN of the container service.
    availabilityZone String
    Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    Date and time when the container service was created.
    isDisabled Boolean
    Whether to disable the container service. Defaults to false.
    name String
    Name of the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power String
    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.
    powerId String
    Power ID of the container service.
    principalArn String
    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.
    privateDomainName String
    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.
    privateRegistryAccess Property Map
    Configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    publicDomainNames Property Map
    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. See below.
    resourceType String
    Lightsail resource type of the container service (i.e., ContainerService).
    scale Number

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

    The following arguments are optional:

    state String
    Current state of the container service.
    tags Map<String>
    Map of tags to assign to the resource. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tagsAll Map<String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

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

    Supporting Types

    ContainerServicePrivateRegistryAccess, ContainerServicePrivateRegistryAccessArgs

    EcrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Configuration to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    EcrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Configuration to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    ecrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Configuration to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    ecrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Configuration to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    ecr_image_puller_role ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Configuration to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.
    ecrImagePullerRole Property Map
    Configuration to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See below.

    ContainerServicePrivateRegistryAccessEcrImagePullerRole, ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs

    IsActive bool
    Whether to activate the role. Defaults to false.
    PrincipalArn string
    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.
    IsActive bool
    Whether to activate the role. Defaults to false.
    PrincipalArn string
    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.
    isActive Boolean
    Whether to activate the role. Defaults to false.
    principalArn String
    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.
    isActive boolean
    Whether to activate the role. Defaults to false.
    principalArn string
    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.
    is_active bool
    Whether to activate the role. Defaults to false.
    principal_arn str
    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.
    isActive Boolean
    Whether to activate the role. Defaults to false.
    principalArn String
    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.

    ContainerServicePublicDomainNames, ContainerServicePublicDomainNamesArgs

    Certificates List<ContainerServicePublicDomainNamesCertificate>
    Set of certificate configurations for the public domain names. Each element contains the following attributes:
    Certificates []ContainerServicePublicDomainNamesCertificate
    Set of certificate configurations for the public domain names. Each element contains the following attributes:
    certificates List<ContainerServicePublicDomainNamesCertificate>
    Set of certificate configurations for the public domain names. Each element contains the following attributes:
    certificates ContainerServicePublicDomainNamesCertificate[]
    Set of certificate configurations for the public domain names. Each element contains the following attributes:
    certificates Sequence[ContainerServicePublicDomainNamesCertificate]
    Set of certificate configurations for the public domain names. Each element contains the following attributes:
    certificates List<Property Map>
    Set of certificate configurations for the public domain names. Each element contains the following attributes:

    ContainerServicePublicDomainNamesCertificate, ContainerServicePublicDomainNamesCertificateArgs

    CertificateName string
    Name of the certificate.
    DomainNames List<string>
    List of domain names for the certificate.
    CertificateName string
    Name of the certificate.
    DomainNames []string
    List of domain names for the certificate.
    certificateName String
    Name of the certificate.
    domainNames List<String>
    List of domain names for the certificate.
    certificateName string
    Name of the certificate.
    domainNames string[]
    List of domain names for the certificate.
    certificate_name str
    Name of the certificate.
    domain_names Sequence[str]
    List of domain names for the certificate.
    certificateName String
    Name of the certificate.
    domainNames List<String>
    List of domain names for the certificate.

    Import

    Using pulumi import, import Lightsail Container Service using the name. For example:

    $ pulumi import aws:lightsail/containerService:ContainerService example container-service-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
    AWS v6.83.0 published on Monday, Jun 16, 2025 by Pulumi
    pulumi/pulumi-aws