Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. AWS
  3. API Docs
  4. lightsail
  5. ContainerService
AWS v6.60.0 published on Tuesday, Nov 19, 2024 by Pulumi
pulumi/pulumi-aws

aws.lightsail.ContainerService

Explore with Pulumi AI

aws logo
AWS v6.60.0 published on Tuesday, Nov 19, 2024 by Pulumi
pulumi/pulumi-aws

    An Amazon Lightsail container service is a highly scalable compute and networking resource on which you can deploy, run, and manage containers. For more information, see Container services in Amazon Lightsail.

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

    Example Usage

    Basic Usage

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

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

    import pulumi
import pulumi_aws as aws

my_container_service = aws.lightsail.ContainerService("my_container_service",
    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, "my_container_service", &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 myContainerService = new Aws.LightSail.ContainerService("my_container_service", 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 myContainerService = new ContainerService("myContainerService", ContainerServiceArgs.builder()
            .name("container-service-1")
            .power("nano")
            .scale(1)
            .isDisabled(false)
            .tags(Map.ofEntries(
                Map.entry("foo1", "bar1"),
                Map.entry("foo2", "")
            ))
            .build());

    }
}

    resources:
  myContainerService:
    type: aws:lightsail:ContainerService
    name: my_container_service
    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 myContainerService = new aws.lightsail.ContainerService("my_container_service", {publicDomainNames: {
    certificates: [{
        certificateName: "example-certificate",
        domainNames: ["www.example.com"],
    }],
}});

    import pulumi
import pulumi_aws as aws

my_container_service = aws.lightsail.ContainerService("my_container_service", 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, "my_container_service", &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 myContainerService = new Aws.LightSail.ContainerService("my_container_service", 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 myContainerService = new ContainerService("myContainerService", ContainerServiceArgs.builder()
            .publicDomainNames(ContainerServicePublicDomainNamesArgs.builder()
                .certificates(ContainerServicePublicDomainNamesCertificateArgs.builder()
                    .certificateName("example-certificate")
                    .domainNames("www.example.com")
                    .build())
                .build())
            .build());

    }
}

    resources:
  myContainerService:
    type: aws:lightsail:ContainerService
    name: my_container_service
    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 defaultContainerService = new aws.lightsail.ContainerService("default", {privateRegistryAccess: {
    ecrImagePullerRole: {
        isActive: true,
    },
}});
const default = defaultContainerService.privateRegistryAccess.apply(privateRegistryAccess => aws.iam.getPolicyDocumentOutput({
    statements: [{
        effect: "Allow",
        principals: [{
            type: "AWS",
            identifiers: [privateRegistryAccess.ecrImagePullerRole?.principalArn],
        }],
        actions: [
            "ecr:BatchGetImage",
            "ecr:GetDownloadUrlForLayer",
        ],
    }],
}));
const defaultRepositoryPolicy = new aws.ecr.RepositoryPolicy("default", {
    repository: defaultAwsEcrRepository.name,
    policy: _default.apply(_default => _default.json),
});

    import pulumi
import pulumi_aws as aws

default_container_service = aws.lightsail.ContainerService("default", private_registry_access={
    "ecr_image_puller_role": {
        "is_active": True,
    },
})
default = default_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",
    ],
}]))
default_repository_policy = aws.ecr.RepositoryPolicy("default",
    repository=default_aws_ecr_repository["name"],
    policy=default.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 {
defaultContainerService, err := lightsail.NewContainerService(ctx, "default", &lightsail.ContainerServiceArgs{
PrivateRegistryAccess: &lightsail.ContainerServicePrivateRegistryAccessArgs{
EcrImagePullerRole: &lightsail.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs{
IsActive: pulumi.Bool(true),
},
},
})
if err != nil {
return err
}
_default := defaultContainerService.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, "default", &ecr.RepositoryPolicyArgs{
Repository: pulumi.Any(defaultAwsEcrRepository.Name),
Policy: pulumi.String(_default.ApplyT(func(_default iam.GetPolicyDocumentResult) (*string, error) {
return &default.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 defaultContainerService = new Aws.LightSail.ContainerService("default", new()
    {
        PrivateRegistryAccess = new Aws.LightSail.Inputs.ContainerServicePrivateRegistryAccessArgs
        {
            EcrImagePullerRole = new Aws.LightSail.Inputs.ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs
            {
                IsActive = true,
            },
        },
    });

    var @default = 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[]
                        {
                            defaultContainerService.PrivateRegistryAccess.EcrImagePullerRole?.PrincipalArn,
                        },
                    },
                },
                Actions = new[]
                {
                    "ecr:BatchGetImage",
                    "ecr:GetDownloadUrlForLayer",
                },
            },
        },
    });

    var defaultRepositoryPolicy = new Aws.Ecr.RepositoryPolicy("default", new()
    {
        Repository = defaultAwsEcrRepository.Name,
        Policy = @default.Apply(@default => @default.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 defaultContainerService = new ContainerService("defaultContainerService", ContainerServiceArgs.builder()
            .privateRegistryAccess(ContainerServicePrivateRegistryAccessArgs.builder()
                .ecrImagePullerRole(ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs.builder()
                    .isActive(true)
                    .build())
                .build())
            .build());

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

        var defaultRepositoryPolicy = new RepositoryPolicy("defaultRepositoryPolicy", RepositoryPolicyArgs.builder()
            .repository(defaultAwsEcrRepository.name())
            .policy(default_.applyValue(default_ -> default_.json()))
            .build());

    }
}

    resources:
  defaultContainerService:
    type: aws:lightsail:ContainerService
    name: default
    properties:
      privateRegistryAccess:
        ecrImagePullerRole:
          isActive: true
  defaultRepositoryPolicy:
    type: aws:ecr:RepositoryPolicy
    name: default
    properties:
      repository: ${defaultAwsEcrRepository.name}
      policy: ${default.json}
variables:
  default:
    fn::invoke:
      Function: aws:iam:getPolicyDocument
      Arguments:
        statements:
          - effect: Allow
            principals:
              - type: AWS
                identifiers:
                  - ${defaultContainerService.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
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    Scale int
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    IsDisabled bool
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    Name string
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccess
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    PublicDomainNames ContainerServicePublicDomainNames
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    Tags Dictionary<string, string>
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    Power string
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    Scale int
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    IsDisabled bool
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    Name string
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccessArgs
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    PublicDomainNames ContainerServicePublicDomainNamesArgs
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    Tags map[string]string
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power String
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    scale Integer
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    isDisabled Boolean
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name String
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    publicDomainNames ContainerServicePublicDomainNames
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    tags Map<String,String>
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power string
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    scale number
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    isDisabled boolean
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name string
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    publicDomainNames ContainerServicePublicDomainNames
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    tags {[key: string]: string}
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power str
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    scale int
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    is_disabled bool
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name str
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    private_registry_access ContainerServicePrivateRegistryAccessArgs
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    public_domain_names ContainerServicePublicDomainNamesArgs
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    tags Mapping[str, str]
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    power String
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    scale Number
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    isDisabled Boolean
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name String
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    privateRegistryAccess Property Map
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    publicDomainNames Property Map
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    tags Map<String>
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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
    The Amazon Resource Name (ARN) of the container service.
    AvailabilityZone string
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    Id string
    The provider-assigned unique ID for this managed resource.
    PowerId string
    The ID of the power of the container service.
    PrincipalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    PrivateDomainName string
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    ResourceType string
    The Lightsail resource type of the container service (i.e., ContainerService).
    State string
    The current state of the container service.
    TagsAll Dictionary<string, string>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    Arn string
    The Amazon Resource Name (ARN) of the container service.
    AvailabilityZone string
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    Id string
    The provider-assigned unique ID for this managed resource.
    PowerId string
    The ID of the power of the container service.
    PrincipalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    PrivateDomainName string
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    ResourceType string
    The Lightsail resource type of the container service (i.e., ContainerService).
    State string
    The current state of the container service.
    TagsAll map[string]string
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    The Amazon Resource Name (ARN) of the container service.
    availabilityZone String
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    id String
    The provider-assigned unique ID for this managed resource.
    powerId String
    The ID of the power of the container service.
    principalArn String
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    privateDomainName String
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    resourceType String
    The Lightsail resource type of the container service (i.e., ContainerService).
    state String
    The current state of the container service.
    tagsAll Map<String,String>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url String
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn string
    The Amazon Resource Name (ARN) of the container service.
    availabilityZone string
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt string
    id string
    The provider-assigned unique ID for this managed resource.
    powerId string
    The ID of the power of the container service.
    principalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    privateDomainName string
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    resourceType string
    The Lightsail resource type of the container service (i.e., ContainerService).
    state string
    The current state of the container service.
    tagsAll {[key: string]: string}
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url string
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn str
    The Amazon Resource Name (ARN) of the container service.
    availability_zone str
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    created_at str
    id str
    The provider-assigned unique ID for this managed resource.
    power_id str
    The ID of the power of the container service.
    principal_arn str
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    private_domain_name str
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    resource_type str
    The Lightsail resource type of the container service (i.e., ContainerService).
    state str
    The current state of the container service.
    tags_all Mapping[str, str]
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url str
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    The Amazon Resource Name (ARN) of the container service.
    availabilityZone String
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    id String
    The provider-assigned unique ID for this managed resource.
    powerId String
    The ID of the power of the container service.
    principalArn String
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    privateDomainName String
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    resourceType String
    The Lightsail resource type of the container service (i.e., ContainerService).
    state String
    The current state of the container service.
    tagsAll Map<String>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url String
    The 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)
    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:
    Arn string
    The Amazon Resource Name (ARN) of the container service.
    AvailabilityZone string
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    IsDisabled bool
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    Name string
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    Power string
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    PowerId string
    The ID of the power of the container service.
    PrincipalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    PrivateDomainName string
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccess
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    PublicDomainNames ContainerServicePublicDomainNames
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    ResourceType string
    The Lightsail resource type of the container service (i.e., ContainerService).
    Scale int
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    State string
    The current state of the container service.
    Tags Dictionary<string, string>
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    Arn string
    The Amazon Resource Name (ARN) of the container service.
    AvailabilityZone string
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    CreatedAt string
    IsDisabled bool
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    Name string
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    Power string
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    PowerId string
    The ID of the power of the container service.
    PrincipalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    PrivateDomainName string
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    PrivateRegistryAccess ContainerServicePrivateRegistryAccessArgs
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    PublicDomainNames ContainerServicePublicDomainNamesArgs
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    ResourceType string
    The Lightsail resource type of the container service (i.e., ContainerService).
    Scale int
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    State string
    The current state of the container service.
    Tags map[string]string
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Url string
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    The Amazon Resource Name (ARN) of the container service.
    availabilityZone String
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    isDisabled Boolean
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name String
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power String
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    powerId String
    The ID of the power of the container service.
    principalArn String
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    privateDomainName String
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    publicDomainNames ContainerServicePublicDomainNames
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    resourceType String
    The Lightsail resource type of the container service (i.e., ContainerService).
    scale Integer
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    state String
    The current state of the container service.
    tags Map<String,String>
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url String
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn string
    The Amazon Resource Name (ARN) of the container service.
    availabilityZone string
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt string
    isDisabled boolean
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name string
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power string
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    powerId string
    The ID of the power of the container service.
    principalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    privateDomainName string
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    privateRegistryAccess ContainerServicePrivateRegistryAccess
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    publicDomainNames ContainerServicePublicDomainNames
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    resourceType string
    The Lightsail resource type of the container service (i.e., ContainerService).
    scale number
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    state string
    The current state of the container service.
    tags {[key: string]: string}
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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}
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url string
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn str
    The Amazon Resource Name (ARN) of the container service.
    availability_zone str
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    created_at str
    is_disabled bool
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name str
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power str
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    power_id str
    The ID of the power of the container service.
    principal_arn str
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    private_domain_name str
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    private_registry_access ContainerServicePrivateRegistryAccessArgs
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    public_domain_names ContainerServicePublicDomainNamesArgs
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    resource_type str
    The Lightsail resource type of the container service (i.e., ContainerService).
    scale int
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    state str
    The current state of the container service.
    tags Mapping[str, str]
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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]
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url str
    The publicly accessible URL of the container service. If no public endpoint is specified in the currentDeployment, this URL returns a 404 response.
    arn String
    The Amazon Resource Name (ARN) of the container service.
    availabilityZone String
    The Availability Zone. Follows the format us-east-2a (case-sensitive).
    createdAt String
    isDisabled Boolean
    A Boolean value indicating whether the container service is disabled. Defaults to false.
    name String
    The name for the container service. Names must be of length 1 to 63, and be unique within each AWS Region in your Lightsail account.
    power String
    The power specification for the container service. The power specifies the amount of memory, the number of vCPUs, and the monthly price of each node of the container service. Possible values: nano, micro, small, medium, large, xlarge.
    powerId String
    The ID of the power of the container service.
    principalArn String
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    privateDomainName String
    The private domain name of the container service. The private domain name is accessible only by other resources within the default virtual private cloud (VPC) of your Lightsail account.
    privateRegistryAccess Property Map
    An object to describe the configuration for the container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See Private Registry Access below for more details.
    publicDomainNames Property Map
    The public domain names to use with the container service, such as example.com and www.example.com. You can specify up to four public domain names for a container service. The domain names that you specify are used when you create a deployment with a container configured as the public endpoint of your container service. If you don't specify public domain names, then you can use the default domain of the container service. Defined below.
    resourceType String
    The Lightsail resource type of the container service (i.e., ContainerService).
    scale Number
    The scale specification for the container service. The scale specifies the allocated compute nodes of the container service.
    state String
    The current state of the container service.
    tags Map<String>
    Map of container service tags. To create a key-only tag, use an empty string as the value. To tag at launch, specify the tags in the Launch Template. 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>
    A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    url String
    The 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
    Describes a request to configure an Amazon Lightsail container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See ECR Image Puller Role below for more details.
    EcrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Describes a request to configure an Amazon Lightsail container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See ECR Image Puller Role below for more details.
    ecrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Describes a request to configure an Amazon Lightsail container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See ECR Image Puller Role below for more details.
    ecrImagePullerRole ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Describes a request to configure an Amazon Lightsail container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See ECR Image Puller Role below for more details.
    ecr_image_puller_role ContainerServicePrivateRegistryAccessEcrImagePullerRole
    Describes a request to configure an Amazon Lightsail container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See ECR Image Puller Role below for more details.
    ecrImagePullerRole Property Map
    Describes a request to configure an Amazon Lightsail container service to access private container image repositories, such as Amazon Elastic Container Registry (Amazon ECR) private repositories. See ECR Image Puller Role below for more details.

    ContainerServicePrivateRegistryAccessEcrImagePullerRole, ContainerServicePrivateRegistryAccessEcrImagePullerRoleArgs

    IsActive bool
    A Boolean value that indicates whether to activate the role. The default is false.
    PrincipalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    IsActive bool
    A Boolean value that indicates whether to activate the role. The default is false.
    PrincipalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    isActive Boolean
    A Boolean value that indicates whether to activate the role. The default is false.
    principalArn String
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    isActive boolean
    A Boolean value that indicates whether to activate the role. The default is false.
    principalArn string
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    is_active bool
    A Boolean value that indicates whether to activate the role. The default is false.
    principal_arn str
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.
    isActive Boolean
    A Boolean value that indicates whether to activate the role. The default is false.
    principalArn String
    The principal ARN of the container service. The principal ARN can be used to create a trust relationship between your standard AWS account and your Lightsail container service. This allows you to give your service permission to access resources in your standard AWS account.

    ContainerServicePublicDomainNames, ContainerServicePublicDomainNamesArgs

    ContainerServicePublicDomainNamesCertificate, ContainerServicePublicDomainNamesCertificateArgs

    CertificateName string
    DomainNames List<string>
    certificateName String
    domainNames List<String>
    certificateName String
    domainNames List<String>

    Import

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

    $ pulumi import aws:lightsail/containerService:ContainerService my_container_service 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.60.0 published on Tuesday, Nov 19, 2024 by Pulumi
    pulumi/pulumi-aws