ApplicationMultipleTargetGroupsServiceBaseProps Struct
The properties for the base ApplicationMultipleTargetGroupsEc2Service or ApplicationMultipleTargetGroupsFargateService service.
| Source | aws-ecs-patterns/lib/base/application-multiple-target-groups-service-base.ts |
|---|---|
| Type last changed |
Example
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import * as cdk from 'aws-cdk-lib';
import { aws_certificatemanager as certificatemanager } from 'aws-cdk-lib';
import { aws_ec2 as ec2 } from 'aws-cdk-lib';
import { aws_ecs as ecs } from 'aws-cdk-lib';
import { aws_ecs_patterns as ecs_patterns } from 'aws-cdk-lib';
import { aws_elasticloadbalancingv2 as elbv2 } from 'aws-cdk-lib';
import { aws_iam as iam } from 'aws-cdk-lib';
import { aws_route53 as route53 } from 'aws-cdk-lib';
import { aws_servicediscovery as servicediscovery } from 'aws-cdk-lib';
declare const certificate: certificatemanager.Certificate;
declare const cluster: ecs.Cluster;
declare const containerDefinition: ecs.ContainerDefinition;
declare const containerImage: ecs.ContainerImage;
declare const hostedZone: route53.HostedZone;
declare const logDriver: ecs.LogDriver;
declare const namespace: servicediscovery.INamespace;
declare const role: iam.Role;
declare const secret: ecs.Secret;
declare const vpc: ec2.Vpc;
const applicationMultipleTargetGroupsServiceBaseProps: ecs_patterns.ApplicationMultipleTargetGroupsServiceBaseProps = {
cloudMapOptions: {
cloudMapNamespace: namespace,
container: containerDefinition,
containerPort: 123,
dnsRecordType: servicediscovery.DnsRecordType.A,
dnsTtl: cdk.Duration.minutes(30),
failureThreshold: 123,
name: 'name',
},
cluster: cluster,
desiredCount: 123,
enableECSManagedTags: false,
enableExecuteCommand: false,
healthCheckGracePeriod: cdk.Duration.minutes(30),
loadBalancers: [{
listeners: [{
name: 'name',
// the properties below are optional
certificate: certificate,
port: 123,
protocol: elbv2.ApplicationProtocol.HTTP,
sslPolicy: elbv2.SslPolicy.RECOMMENDED_TLS,
}],
name: 'name',
// the properties below are optional
domainName: 'domainName',
domainZone: hostedZone,
idleTimeout: cdk.Duration.minutes(30),
publicLoadBalancer: false,
}],
propagateTags: ecs.PropagatedTagSource.SERVICE,
serviceName: 'serviceName',
targetGroups: [{
containerPort: 123,
// the properties below are optional
hostHeader: 'hostHeader',
listener: 'listener',
pathPattern: 'pathPattern',
priority: 123,
protocol: ecs.Protocol.TCP,
}],
taskImageOptions: {
image: containerImage,
// the properties below are optional
containerName: 'containerName',
containerPorts: [123],
dockerLabels: {
dockerLabelsKey: 'dockerLabels',
},
enableLogging: false,
environment: {
environmentKey: 'environment',
},
executionRole: role,
family: 'family',
logDriver: logDriver,
secrets: {
secretsKey: secret,
},
taskRole: role,
},
vpc: vpc,
};
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
import aws_cdk as cdk
from aws_cdk import aws_certificatemanager as certificatemanager
from aws_cdk import aws_ec2 as ec2
from aws_cdk import aws_ecs as ecs
from aws_cdk import aws_ecs_patterns as ecs_patterns
from aws_cdk import aws_elasticloadbalancingv2 as elbv2
from aws_cdk import aws_iam as iam
from aws_cdk import aws_route53 as route53
from aws_cdk import aws_servicediscovery as servicediscovery
# certificate: certificatemanager.Certificate
# cluster: ecs.Cluster
# container_definition: ecs.ContainerDefinition
# container_image: ecs.ContainerImage
# hosted_zone: route53.HostedZone
# log_driver: ecs.LogDriver
# namespace: servicediscovery.INamespace
# role: iam.Role
# secret: ecs.Secret
# vpc: ec2.Vpc
application_multiple_target_groups_service_base_props = ecs_patterns.ApplicationMultipleTargetGroupsServiceBaseProps(
cloud_map_options=ecs.CloudMapOptions(
cloud_map_namespace=namespace,
container=container_definition,
container_port=123,
dns_record_type=servicediscovery.DnsRecordType.A,
dns_ttl=cdk.Duration.minutes(30),
failure_threshold=123,
name="name"
),
cluster=cluster,
desired_count=123,
enable_ecs_managed_tags=False,
enable_execute_command=False,
health_check_grace_period=cdk.Duration.minutes(30),
load_balancers=[ecs_patterns.ApplicationLoadBalancerProps(
listeners=[ecs_patterns.ApplicationListenerProps(
name="name",
# the properties below are optional
certificate=certificate,
port=123,
protocol=elbv2.ApplicationProtocol.HTTP,
ssl_policy=elbv2.SslPolicy.RECOMMENDED_TLS
)],
name="name",
# the properties below are optional
domain_name="domainName",
domain_zone=hosted_zone,
idle_timeout=cdk.Duration.minutes(30),
public_load_balancer=False
)],
propagate_tags=ecs.PropagatedTagSource.SERVICE,
service_name="serviceName",
target_groups=[ecs_patterns.ApplicationTargetProps(
container_port=123,
# the properties below are optional
host_header="hostHeader",
listener="listener",
path_pattern="pathPattern",
priority=123,
protocol=ecs.Protocol.TCP
)],
task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageProps(
image=container_image,
# the properties below are optional
container_name="containerName",
container_ports=[123],
docker_labels={
"docker_labels_key": "dockerLabels"
},
enable_logging=False,
environment={
"environment_key": "environment"
},
execution_role=role,
family="family",
log_driver=log_driver,
secrets={
"secrets_key": secret
},
task_role=role
),
vpc=vpc
)
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.*;
import software.amazon.awscdk.services.certificatemanager.*;
import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
import software.amazon.awscdk.services.elasticloadbalancingv2.*;
import software.amazon.awscdk.services.iam.*;
import software.amazon.awscdk.services.route53.*;
import software.amazon.awscdk.services.servicediscovery.*;
Certificate certificate;
Cluster cluster;
ContainerDefinition containerDefinition;
ContainerImage containerImage;
HostedZone hostedZone;
LogDriver logDriver;
INamespace namespace;
Role role;
Secret secret;
Vpc vpc;
ApplicationMultipleTargetGroupsServiceBaseProps applicationMultipleTargetGroupsServiceBaseProps = ApplicationMultipleTargetGroupsServiceBaseProps.builder()
.cloudMapOptions(CloudMapOptions.builder()
.cloudMapNamespace(namespace)
.container(containerDefinition)
.containerPort(123)
.dnsRecordType(DnsRecordType.A)
.dnsTtl(Duration.minutes(30))
.failureThreshold(123)
.name("name")
.build())
.cluster(cluster)
.desiredCount(123)
.enableECSManagedTags(false)
.enableExecuteCommand(false)
.healthCheckGracePeriod(Duration.minutes(30))
.loadBalancers(List.of(ApplicationLoadBalancerProps.builder()
.listeners(List.of(ApplicationListenerProps.builder()
.name("name")
// the properties below are optional
.certificate(certificate)
.port(123)
.protocol(ApplicationProtocol.HTTP)
.sslPolicy(SslPolicy.RECOMMENDED_TLS)
.build()))
.name("name")
// the properties below are optional
.domainName("domainName")
.domainZone(hostedZone)
.idleTimeout(Duration.minutes(30))
.publicLoadBalancer(false)
.build()))
.propagateTags(PropagatedTagSource.SERVICE)
.serviceName("serviceName")
.targetGroups(List.of(ApplicationTargetProps.builder()
.containerPort(123)
// the properties below are optional
.hostHeader("hostHeader")
.listener("listener")
.pathPattern("pathPattern")
.priority(123)
.protocol(Protocol.TCP)
.build()))
.taskImageOptions(ApplicationLoadBalancedTaskImageProps.builder()
.image(containerImage)
// the properties below are optional
.containerName("containerName")
.containerPorts(List.of(123))
.dockerLabels(Map.of(
"dockerLabelsKey", "dockerLabels"))
.enableLogging(false)
.environment(Map.of(
"environmentKey", "environment"))
.executionRole(role)
.family("family")
.logDriver(logDriver)
.secrets(Map.of(
"secretsKey", secret))
.taskRole(role)
.build())
.vpc(vpc)
.build();
// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK;
using Amazon.CDK.AWS.CertificateManager;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;
using Amazon.CDK.AWS.ElasticLoadBalancingV2;
using Amazon.CDK.AWS.IAM;
using Amazon.CDK.AWS.Route53;
using Amazon.CDK.AWS.ServiceDiscovery;
Certificate certificate;
Cluster cluster;
ContainerDefinition containerDefinition;
ContainerImage containerImage;
HostedZone hostedZone;
LogDriver logDriver;
INamespace namespace;
Role role;
Secret secret;
Vpc vpc;
var applicationMultipleTargetGroupsServiceBaseProps = new ApplicationMultipleTargetGroupsServiceBaseProps {
CloudMapOptions = new CloudMapOptions {
CloudMapNamespace = namespace,
Container = containerDefinition,
ContainerPort = 123,
DnsRecordType = DnsRecordType.A,
DnsTtl = Duration.Minutes(30),
FailureThreshold = 123,
Name = "name"
},
Cluster = cluster,
DesiredCount = 123,
EnableECSManagedTags = false,
EnableExecuteCommand = false,
HealthCheckGracePeriod = Duration.Minutes(30),
LoadBalancers = new [] { new ApplicationLoadBalancerProps {
Listeners = new [] { new ApplicationListenerProps {
Name = "name",
// the properties below are optional
Certificate = certificate,
Port = 123,
Protocol = ApplicationProtocol.HTTP,
SslPolicy = SslPolicy.RECOMMENDED_TLS
} },
Name = "name",
// the properties below are optional
DomainName = "domainName",
DomainZone = hostedZone,
IdleTimeout = Duration.Minutes(30),
PublicLoadBalancer = false
} },
PropagateTags = PropagatedTagSource.SERVICE,
ServiceName = "serviceName",
TargetGroups = new [] { new ApplicationTargetProps {
ContainerPort = 123,
// the properties below are optional
HostHeader = "hostHeader",
Listener = "listener",
PathPattern = "pathPattern",
Priority = 123,
Protocol = Protocol.TCP
} },
TaskImageOptions = new ApplicationLoadBalancedTaskImageProps {
Image = containerImage,
// the properties below are optional
ContainerName = "containerName",
ContainerPorts = new [] { 123 },
DockerLabels = new Dictionary<string, string> {
{ "dockerLabelsKey", "dockerLabels" }
},
EnableLogging = false,
Environment = new Dictionary<string, string> {
{ "environmentKey", "environment" }
},
ExecutionRole = role,
Family = "family",
LogDriver = logDriver,
Secrets = new Dictionary<string, Secret> {
{ "secretsKey", secret }
},
TaskRole = role
},
Vpc = vpc
};
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
var certificate Certificate
var cluster Cluster
var containerDefinition ContainerDefinition
var containerImage ContainerImage
var hostedZone HostedZone
var logDriver LogDriver
var namespace INamespace
var role Role
var secret Secret
var vpc Vpc
applicationMultipleTargetGroupsServiceBaseProps := &ApplicationMultipleTargetGroupsServiceBaseProps{
CloudMapOptions: &CloudMapOptions{
CloudMapNamespace: namespace,
Container: containerDefinition,
ContainerPort: jsii.Number(123),
DnsRecordType: awscdk.Aws_servicediscovery.DnsRecordType_A,
DnsTtl: cdk.Duration_Minutes(jsii.Number(30)),
FailureThreshold: jsii.Number(123),
Name: jsii.String("name"),
},
Cluster: cluster,
DesiredCount: jsii.Number(123),
EnableECSManagedTags: jsii.Boolean(false),
EnableExecuteCommand: jsii.Boolean(false),
HealthCheckGracePeriod: cdk.Duration_*Minutes(jsii.Number(30)),
LoadBalancers: []ApplicationLoadBalancerProps{
&ApplicationLoadBalancerProps{
Listeners: []ApplicationListenerProps{
&ApplicationListenerProps{
Name: jsii.String("name"),
// the properties below are optional
Certificate: certificate,
Port: jsii.Number(123),
Protocol: awscdk.Aws_elasticloadbalancingv2.ApplicationProtocol_HTTP,
SslPolicy: awscdk.*Aws_elasticloadbalancingv2.SslPolicy_RECOMMENDED_TLS,
},
},
Name: jsii.String("name"),
// the properties below are optional
DomainName: jsii.String("domainName"),
DomainZone: hostedZone,
IdleTimeout: cdk.Duration_*Minutes(jsii.Number(30)),
PublicLoadBalancer: jsii.Boolean(false),
},
},
PropagateTags: awscdk.Aws_ecs.PropagatedTagSource_SERVICE,
ServiceName: jsii.String("serviceName"),
TargetGroups: []ApplicationTargetProps{
&ApplicationTargetProps{
ContainerPort: jsii.Number(123),
// the properties below are optional
HostHeader: jsii.String("hostHeader"),
Listener: jsii.String("listener"),
PathPattern: jsii.String("pathPattern"),
Priority: jsii.Number(123),
Protocol: awscdk.*Aws_ecs.Protocol_TCP,
},
},
TaskImageOptions: &ApplicationLoadBalancedTaskImageProps{
Image: containerImage,
// the properties below are optional
ContainerName: jsii.String("containerName"),
ContainerPorts: []*f64{
jsii.Number(123),
},
DockerLabels: map[string]*string{
"dockerLabelsKey": jsii.String("dockerLabels"),
},
EnableLogging: jsii.Boolean(false),
Environment: map[string]*string{
"environmentKey": jsii.String("environment"),
},
ExecutionRole: role,
Family: jsii.String("family"),
LogDriver: logDriver,
Secrets: map[string]Secret{
"secretsKey": secret,
},
TaskRole: role,
},
Vpc: vpc,
}
Properties
cloudMapOptionsoptionalCloudMapOptionscloud_map_optionsoptionalCloudMapOptionscloudMapOptionsoptionalCloudMapOptionsCloudMapOptionsoptionalCloudMapOptionsCloudMapOptionsoptionalCloudMapOptions #Default: AWS Cloud Map service discovery is not enabled.
clusteroptionalIClusterclusteroptionalIClusterclusteroptionalIClusterClusteroptionalIClusterClusteroptionalICluster #Default: create a new cluster; if both cluster and vpc are omitted, a new VPC will be created for you.
If a cluster is specified, the vpc construct should be omitted. Alternatively, you can omit both cluster and vpc.
desiredCountoptionalnumberdesired_countoptionalint | floatdesiredCountoptionalNumberDesiredCountoptionaldoubleDesiredCountoptional*float64 #Default: The default is 1 for all new services and uses the existing service's desired count when updating an existing service.
enableECSManagedTagsoptionalbooleanenable_ecs_managed_tagsoptionalboolenableECSManagedTagsoptionalBooleanEnableECSManagedTagsoptionalboolEnableECSManagedTagsoptional*bool = false #For more information, see Tagging Your Amazon ECS Resources
enableExecuteCommandoptionalbooleanenable_execute_commandoptionalboolenableExecuteCommandoptionalBooleanEnableExecuteCommandoptionalboolEnableExecuteCommandoptional*bool = false #healthCheckGracePeriodoptionalDurationhealth_check_grace_periodoptionalDurationhealthCheckGracePeriodoptionalDurationHealthCheckGracePeriodoptionalDurationHealthCheckGracePeriodoptionalDuration #Default: defaults to 60 seconds if at least one load balancer is in-use and it is not already set
loadBalancersoptionalApplicationLoadBalancerProps[]load_balancersoptionaltyping.List[ApplicationLoadBalancerProps]loadBalancersoptionalList<ApplicationLoadBalancerProps>LoadBalancersoptionalApplicationLoadBalancerProps[]LoadBalancersoptional*[]ApplicationLoadBalancerProps #Default: a new load balancer with a listener will be created.
propagateTagsoptionalPropagatedTagSourcepropagate_tagsoptionalPropagatedTagSourcepropagateTagsoptionalPropagatedTagSourcePropagateTagsoptionalPropagatedTagSourcePropagateTagsoptionalPropagatedTagSource = none #Tags can only be propagated to the tasks within the service during service creation.
serviceNameoptionalstringservice_nameoptionalstrserviceNameoptionalStringServiceNameoptionalstringServiceNameoptional*string #Default: CloudFormation-generated name.
targetGroupsoptionalApplicationTargetProps[]target_groupsoptionaltyping.List[ApplicationTargetProps]targetGroupsoptionalList<ApplicationTargetProps>TargetGroupsoptionalApplicationTargetProps[]TargetGroupsoptional*[]ApplicationTargetProps #Default: default portMapping registered as target group and attached to the first defined listener
taskImageOptionsoptionalApplicationLoadBalancedTaskImagePropstask_image_optionsoptionalApplicationLoadBalancedTaskImagePropstaskImageOptionsoptionalApplicationLoadBalancedTaskImagePropsTaskImageOptionsoptionalApplicationLoadBalancedTaskImagePropsTaskImageOptionsoptionalApplicationLoadBalancedTaskImageProps = none #Only one of TaskDefinition or TaskImageOptions must be specified.
Default: uses the VPC defined in the cluster or creates a new VPC.
If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster.