def test_fargate_task_definition(stack: Stack) -> None:
"""Test fargate task definition creation."""
docker_container_def = ecs.ContainerDefinition(
Image="image-uri",
Name="container-def-name",
LogConfiguration=ecs.LogConfiguration(
LogDriver="awslogs",
Options={
"awslogs-group": "test-log-group",
"awslogs-create-group": "true",
"awslogs-region": "eu-west-1",
"awslogs-stream-prefix": "test-prefix",
},
),
)
stack.add(
FargateTaskDefinition(
name="test-fargate-task-definition",
container_definitions=[docker_container_def],
task_role_arn="task-role-name",
cpu="1024",
memory="4096",
))
assert stack.export()["Resources"] == EXPECTED_FARGATE_TASK_DEFINITION
def gen_task_definition(self):
log_configuration = ecs.LogConfiguration(
LogDriver="awslogs",
Options={
"awslogs-group": self.log_group_name,
"awslogs-region": Ref("AWS::Region"),
"awslogs-stream-prefix": self.service_name,
},
)
container_definition = ecs.ContainerDefinition(
Name=self.service_name,
Image=self.get_service_image(),
PortMappings=[ecs.PortMapping(ContainerPort=80, Protocol="tcp")],
LogConfiguration=log_configuration,
Essential=True,
)
self.task_definition = ecs.TaskDefinition(
"TasDefinition",
Family="conducto-demo-family",
ExecutionRoleArn=Ref(self.execution_role),
TaskRoleArn=Ref(self.task_role),
NetworkMode="awsvpc",
RequiresCompatibilities=["FARGATE"],
Cpu=f"0.25 vCPU",
Memory="0.5 GB",
ContainerDefinitions=[container_definition],
)
self.template.add_resource(self.task_definition)
def log_configuration(self):
if not self.log_group:
return NoValue
return ecs.LogConfiguration(LogDriver="awslogs",
Options={
"awslogs-group": self.log_group,
"awslogs-region": Region,
"awslogs-stream-prefix":
self.service_name,
})
def configure_awslogs(self, t, container_definition):
logs_group = t.add_resource(logs.LogGroup(self.resource_name_format % ('CloudWatchLogsGroup'), RetentionInDays=90))
container_definition.LogConfiguration = ecs.LogConfiguration(
LogDriver="awslogs",
Options={
"awslogs-group": Ref(logs_group),
"awslogs-region": Region,
"awslogs-datetime-format": self.logs_datetime_format
}
)
def log_configuration(self):
log_config = self.get_variables()["LogConfiguration"]
if not log_config:
log_config = ecs.LogConfiguration(LogDriver="awslogs",
Options={
"awslogs-group":
self.log_group_name,
"awslogs-region":
Region,
"awslogs-stream-prefix":
self.task_name,
})
return log_config
def create_queue_worker_task_definition_resource(template, queue_worker_task_definition_family_variable,
docker_repository_resource, queue_worker_log_group_resource,
default_queue_name_variable, notifications_queue_name_variable,
search_queue_name_variable):
return template.add_resource(
ecs.TaskDefinition(
'QueueWorkerTaskDefinition',
Family=queue_worker_task_definition_family_variable,
NetworkMode='bridge',
RequiresCompatibilities=['EC2'],
ContainerDefinitions=[ecs.ContainerDefinition(
Name='api',
Image=Join('.', [
Ref('AWS::AccountId'),
'dkr.ecr',
Ref('AWS::Region'),
Join('/', [
'amazonaws.com',
Ref(docker_repository_resource)
])
]),
MemoryReservation='256',
Essential=True,
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
'awslogs-group': Ref(queue_worker_log_group_resource),
'awslogs-region': Ref('AWS::Region'),
'awslogs-stream-prefix': 'ecs'
}
),
Command=[
'php',
'artisan',
'queue:work',
'--tries=1',
'--queue=default,notifications,search'
],
WorkingDirectory='/var/www/html',
HealthCheck=ecs.HealthCheck(
Command=[
'CMD-SHELL',
'php -v || exit 1'
],
Interval=30,
Retries=3,
Timeout=5
)
)]
)
)
def build(self, t):
env = []
logConf = None
data = deepcopy(self.data)
if data.get('Environment'):
for v in data.get('Environment'):
e = ecs.Environment(Name=self.jinja_txt(v['name']),
Value=self.jinja_txt(v['value']))
env.append(e)
del data['Environment']
if data.get('Image'):
data['Image'] = self.jinja_txt(data['Image'])
if data.get('LogConfiguration'):
logConf = ecs.LogConfiguration(
LogDriver=data.get('LogConfiguration').get('LogDriver'),
Options={})
if data.get('LogConfiguration').get('Options').get(
'awslogs-group'):
logConf.Options['awslogs-group'] = self.jinja_txt(
data['LogConfiguration']['Options']['awslogs-group'])
if data.get('LogConfiguration').get('Options').get(
'awslogs-region'):
logConf.Options['awslogs-region'] = data['LogConfiguration'][
'Options']['awslogs-region']
if data.get('LogConfiguration').get('Options').get(
'awslogs-stream-prefix'):
logConf.Options['awslogs-stream-prefix'] = data[
'LogConfiguration']['Options']['awslogs-stream-prefix']
del data['LogConfiguration']
ctr = ecs.ContainerDefinition(**data)
ctr.Environment = env
if logConf is not None:
ctr.LogConfiguration = logConf
return ctr
def create_api_task_definition_resource(template, api_task_definition_family_variable, docker_repository_resource,
api_log_group_resource):
return template.add_resource(
ecs.TaskDefinition(
'ApiTaskDefinition',
Family=api_task_definition_family_variable,
NetworkMode='bridge',
RequiresCompatibilities=['EC2'],
ContainerDefinitions=[ecs.ContainerDefinition(
Name='api',
Image=Join('.', [
Ref('AWS::AccountId'),
'dkr.ecr',
Ref('AWS::Region'),
Join('/', [
'amazonaws.com',
Ref(docker_repository_resource)
])
]),
MemoryReservation='256',
PortMappings=[ecs.PortMapping(
HostPort='0',
ContainerPort='80',
Protocol='tcp'
)],
Essential=True,
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
'awslogs-group': Ref(api_log_group_resource),
'awslogs-region': Ref('AWS::Region'),
'awslogs-stream-prefix': 'ecs'
}
)
)]
)
)
Join('/', [
'amazonaws.com',
Ref(docker_repository)
])
]),
MemoryReservation='256',
PortMappings=[ecs.PortMapping(
HostPort='0',
ContainerPort='80',
Protocol='tcp'
)],
Essential=True,
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
'awslogs-group': Ref(api_log_group),
'awslogs-region': Ref('AWS::Region'),
'awslogs-stream-prefix': 'ecs'
}
)
)]
)
)
queue_worker_task_definition = template.add_resource(
ecs.TaskDefinition(
'QueueWorkerTaskDefinition',
Family=Ref(queue_worker_task_definition_name),
NetworkMode='bridge',
RequiresCompatibilities=['EC2'],
ContainerDefinitions=[ecs.ContainerDefinition(
Name='api',
contdef.Environment = [
ecs.Environment(Name="JICKET_IMAP_HOST", Value=jicketimaphost),
ecs.Environment(Name="JICKET_JIRA_USER", Value=jicketjirauser),
ecs.Environment(Name="JICKET_TICKET_ADDRESS", Value=jicketticketaddress),
ecs.Environment(Name="JICKET_SMTP_HOST", Value=jicketsmtphost),
ecs.Environment(Name="JICKET_JIRA_PASS", Value=jicketjirapass),
ecs.Environment(Name="JICKET_JIRA_PROJECT", Value=jicketjiraproject),
ecs.Environment(Name="JICKET_JIRA_URL", Value=jicketjiraurl),
ecs.Environment(Name="JICKET_THREAD_TEMPLATE", Value=jicketthreadtemplate),
ecs.Environment(Name="JICKET_IMAP_PASS", Value=jicketimappass),
ecs.Environment(Name="JICKET_IMAP_USER", Value=jicketimapuser),
]
contdef.Image = "kwpcommunications/jicket:latest"
contdef.MemoryReservation = 512
contdef.Name = "jicket"
logconf = ecs.LogConfiguration()
logconf.LogDriver = "awslogs"
logconf.Options = {
"awslogs-group": "/ecs/jicket-task",
"awslogs-region": "eu-central-1",
"awslogs-stream-prefix": "ecs"
}
contdef.LogConfiguration = logconf
taskdef.ContainerDefinitions = [contdef]
taskdef.Cpu = "256"
taskdef.Family = "jicket-task"
taskdef.RequiresCompatibilities = ["FARGATE"]
taskdef.NetworkMode = "awsvpc"
taskdef.Memory = "512"
taskdef.ExecutionRoleArn = executionrolearn
"TaskDefinition",
DependsOn=TaskExecutionPolicy,
RequiresCompatibilities=["FARGATE"],
Cpu="512",
Memory="1GB",
NetworkMode="awsvpc",
ExecutionRoleArn=GetAtt(TaskExecutionRole, "Arn"),
ContainerDefinitions=[
ecs.ContainerDefinition(
Name="nginx-container",
Image=Ref(NginxImage),
Essential=True,
PortMappings=[ecs.PortMapping(ContainerPort=80)],
LogConfiguration=ecs.LogConfiguration(
LogDriver="awslogs",
Options={"awslogs-group": Ref(CWLogGroup),
"awslogs-region": Ref("AWS::Region"),
"awslogs-stream-prefix": "nginx-container"}
)
)
]
))
Service = t.add_resource(ecs.Service(
"Service",
DependsOn=ALBListener,
Cluster=Ref(ECSCluster),
DesiredCount=1,
TaskDefinition=Ref(TaskDefinition),
LaunchType="FARGATE",
LoadBalancers=[
ecs.LoadBalancer(
Value=ImportValue(
Sub('${CoreStack}-MySQL-Port'))),
ecs.Environment(Name='DB_DATABASE',
Value=Ref('MySQLDbName')),
ecs.Environment(Name='DB_USER', Value=Ref('MySQLUser')),
ecs.Environment(Name='DB_PASSWORD',
Value=Ref('MySQLPass')),
ecs.Environment(Name='PROXY_ADDRESS_FORWARDING',
Value='true'),
],
MemoryReservation='512',
PortMappings=[ecs.PortMapping(ContainerPort=8080, )],
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
"awslogs-group": Sub('${AWS::StackName}-KeycloakTask'),
"awslogs-region": Ref("AWS::Region"),
"awslogs-stream-prefix": "ecs",
},
),
)
],
NetworkMode='awsvpc',
))
keycloakServiceSG = t.add_resource(
ec2.SecurityGroup(
'KeycloakSecurityGroup',
GroupDescription='Keycloak Service SG',
VpcId=ImportValue(Sub('${CoreStack}-VPC-ID')),
SecurityGroupIngress=[{
'IpProtocol':
def add_resources(self):
"""Add resources to template."""
class EcsServiceWithHealthCheckGracePeriodSeconds(ecs.Service):
"""ECS Service class with HealthCheckGracePeriodSeconds added."""
props = ecs.Service.props
props['HealthCheckGracePeriodSeconds'] = (positive_integer, False)
pkg_version = pkg_resources.get_distribution('troposphere').version
if LooseVersion(pkg_version) < LooseVersion('2.1.3'):
ecs_service = EcsServiceWithHealthCheckGracePeriodSeconds
else:
ecs_service = ecs.Service
template = self.template
variables = self.get_variables()
ecstaskrole = template.add_resource(
iam.Role('EcsTaskRole',
AssumeRolePolicyDocument=get_ecs_task_assumerole_policy(),
RoleName=variables['EcsTaskRoleName'].ref))
loggroup = template.add_resource(
logs.LogGroup(
'CloudWatchLogGroup',
LogGroupName=Join('', [
'/ecs/', variables['ContainerName'].ref, '-',
variables['EnvironmentName'].ref
]),
RetentionInDays=variables['EcsCloudWatchLogRetention'].ref))
ecscontainerdef = ecs.ContainerDefinition(
Image=Join('', [
Ref('AWS::AccountId'), '.dkr.ecr.',
Ref('AWS::Region'), '.amazonaws.com/',
variables['ContainerName'].ref, '-',
variables['EnvironmentName'].ref
]),
LogConfiguration=ecs.LogConfiguration(LogDriver='awslogs',
Options={
'awslogs-group':
Ref(loggroup),
'awslogs-region':
Ref('AWS::Region'),
'awslogs-stream-prefix':
'ecs'
}),
Name=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
]),
PortMappings=[
ecs.PortMapping(ContainerPort=variables['ContainerPort'].ref)
])
ecstaskdef = template.add_resource(
ecs.TaskDefinition(
'EcsTaskDef',
ContainerDefinitions=[ecscontainerdef],
Cpu=variables['TaskCpu'].ref,
Memory=variables['TaskMem'].ref,
ExecutionRoleArn=variables['EcsTaskExecIamRoleArn'].ref,
TaskRoleArn=Ref(ecstaskrole),
Family=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
]),
NetworkMode='awsvpc',
RequiresCompatibilities=['FARGATE']))
ecscluster = template.add_resource(
ecs.Cluster('EcsCluster',
ClusterName=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
])))
ecsservice = template.add_resource(
ecs_service(
'EcsService',
Cluster=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
]),
DeploymentConfiguration=ecs.DeploymentConfiguration(
MinimumHealthyPercent=variables['MinHealthyPercent'].ref,
MaximumPercent=variables['MaxPercent'].ref),
DesiredCount=variables['NumberOfTasks'].ref,
HealthCheckGracePeriodSeconds=variables[
'HealthCheckGracePeriod'].ref,
LaunchType='FARGATE',
LoadBalancers=[
ecs.LoadBalancer(
ContainerName=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
]),
ContainerPort=variables['ContainerPort'].ref,
TargetGroupArn=variables['TargetGroupArn'].ref)
],
NetworkConfiguration=ecs.NetworkConfiguration(
AwsvpcConfiguration=ecs.AwsvpcConfiguration(
SecurityGroups=variables['SgIdList'].ref,
Subnets=variables['Subnets'].ref)),
ServiceName=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
]),
TaskDefinition=Ref(ecstaskdef)))
template.add_output(
Output("{}Arn".format(ecstaskrole.title),
Description="ECS Task Role ARN",
Value=GetAtt(ecstaskrole, "Arn"),
Export=Export(
Sub('${AWS::StackName}-%sArn' % ecstaskrole.title))))
template.add_output(
Output("{}Name".format(ecstaskrole.title),
Description="ECS Task Role Name",
Value=Ref(ecstaskrole)))
template.add_output(
Output("{}Arn".format(ecsservice.title),
Description="ARN of the ECS Service",
Value=Ref(ecsservice),
Export=Export(
Sub('${AWS::StackName}-%sArn' % ecsservice.title))))
template.add_output(
Output("{}Name".format(ecsservice.title),
Description="Name of the ECS Service",
Value=GetAtt(ecsservice, "Name"),
Export=Export(
Sub('${AWS::StackName}-%sName' % ecsservice.title))))
template.add_output(
Output("{}Arn".format(ecscluster.title),
Description="ECS Cluster ARN",
Value=GetAtt(ecscluster, "Arn"),
Export=Export(
Sub('${AWS::StackName}-%sArn' % ecscluster.title))))
template.add_output(
Output("{}Arn".format(ecstaskdef.title),
Description="ARN of the Task Definition",
Value=Ref(ecstaskdef),
Export=Export(
Sub('${AWS::StackName}-%sArn' % ecstaskdef.title))))
"""
Task definition
"""
task_definition = t.add_resource(
ecs.TaskDefinition(
"TaskDefinition",
DependsOn=log_group.title,
TaskRoleArn=GetAtt(task_role, "Arn"),
NetworkMode="bridge",
Family=Ref(family),
ContainerDefinitions=[
ecs.ContainerDefinition(
LogConfiguration=ecs.LogConfiguration(
LogDriver="awslogs",
Options={
"awslogs-group": Ref("AWS::StackName"),
"awslogs-region": Ref("AWS::Region"),
"awslogs-stream-prefix": Ref(container_name)
}),
Memory=2048,
PortMappings=[
ecs.PortMapping(HostPort=0,
ContainerPort=Ref(container_port),
Protocol="tcp"),
],
Essential=True,
Command=["/usr/sbin/apache2ctl", "-D", "FOREGROUND"],
Name=Ref(container_name),
Image=Join(
"", [Ref(ecr), "/",
Ref(image_name), ":",
Subnets=['subnet-0c86eeb5d3ab2e031', 'subnet-08d3101feec0e17da'])),
HealthCheckGracePeriodSeconds=120,
SchedulingStrategy='REPLICA'))
ECSTaskDefinition = template.add_resource(
ecs.TaskDefinition(
'ECSTaskDefinition',
ContainerDefinitions=[
ecs.ContainerDefinition(
Essential=True,
Image=
'xli9999/aws-currency-exchange-service-h2-xray:0.0.1-SNAPSHOT',
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
"awslogs-group":
'/ecs/aws-currency-exchange-service-h2-xray',
"awslogs-region": 'us-east-2',
"awslogs-stream-prefix": 'ecs'
}),
Name='aws-currency-exchange-service-h2-xray',
PortMappings=[
ecs.PortMapping(ContainerPort=8000,
HostPort=8000,
Protocol='tcp')
]),
ecs.ContainerDefinition(
Environment=[
ecs.Environment(
Name='APPMESH_VIRTUAL_NODE_NAME',
Value=
'mesh/my-service-mesh/virtualNode/currency-exchange-service-vn'
def __init__(self, title, key, index, **kwargs):
super().__init__(title, **kwargs)
name = self.title # Ex. ContainerDefinitions1
auto_get_props(self, key, recurse=True)
self.Essential = True
if len(cfg.ContainerDefinitions) == 1:
self.Cpu = If(
'CpuTask',
get_endvalue('Cpu'),
get_endvalue(f'{name}Cpu')
)
self.Memory = If(
'LaunchTypeFarGate',
get_endvalue('Memory'),
get_endvalue(f'{name}Memory')
)
if 'RepoName' in key:
self.Image = get_subvalue(
'${1M}.dkr.ecr.${AWS::Region}.amazonaws.com/${2M}:'
'${EnvApp%sVersion}' % index,
['EcrAccount', f'{name}RepoName']
)
# use the same EnvApp version for all containers
elif cfg.RepoName != 'None':
self.Image = get_subvalue(
'${1M}.dkr.ecr.${AWS::Region}.amazonaws.com/${2M}:'
'${EnvApp1Version}',
['EcrAccount', 'RepoName']
)
elif cfg.Image != 'None':
self.Image = get_endvalue('Image')
self.LogConfiguration = If(
'LogConfiguration',
ecs.LogConfiguration(
LogDriver=get_endvalue('LogDriver'),
Options={
# 'awslogs-group': get_endvalue('AwsLogsGroup'),
# 'awslogs-create-group': True,
'awslogs-group': Ref('LogsLogGroup'),
'awslogs-region': Ref('AWS::Region'),
'awslogs-stream-prefix': Ref('AWS::StackName')
}
),
Ref('AWS::NoValue')
)
if 'MountPoints' in key:
self.MountPoints = [
ECSMountPoint(n, key=k) for n, k in key['MountPoints'].items()
]
if 'Name' in key:
self.Name = get_subvalue('${EnvRole}-${1M}', f'{name}Name')
else:
self.Name = Ref('EnvRole')
if 'ContainerPort' in key:
PortMapping = ecs.PortMapping()
auto_get_props(PortMapping, key, mapname=self.title)
if 'HostPort' not in key:
PortMapping.HostPort = If(
'NetworkModeAwsVpc',
get_endvalue(f'{name}ContainerPort'),
0
)
self.PortMappings = [PortMapping]
def munge_container_attributes(self):
image = ':'.join([
self.vars['ContainerImage'],
str(self.vars['ContainerImageVersion']),
])
# munge ECR image path
if self.vars['UseECR']:
image = Join(
'.', [AccountId, 'dkr.ecr', Region, 'amazonaws.com/' + image])
# set required attributes
required = dict(
Name=self.vars['ContainerName'],
Image=image,
PortMappings=[
ecs.PortMapping(
ContainerPort=self.vars['ContainerPort'],
Protocol=self.vars['ContainerProtocol'],
)
],
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
'awslogs-group': Ref(self.log_group),
'awslogs-region': Region,
'awslogs-stream-prefix': self.vars['ContainerName'],
},
),
)
# deal with additional attributes
if self.vars['AdditionalContainerAttributes']:
added = self.vars['AdditionalContainerAttributes']
# deal with troposphere AWSProperty objects
if 'Environment' in added:
added['Environment'] = [
ecs.Environment(**m) for m in added['Environment']
]
if 'ExtraHosts' in added:
added['ExtraHosts'] = [
ecs.HostEntry(**m) for m in added['ExtraHosts']
]
if 'LinuxParameters' in added:
added['LinuxParameters'] = [
ecs.LinuxParameters(**m) for m in added['LinuxParameters']
]
if 'MountPoints' in added:
added['MountPoints'] = [
ecs.MountPoint(**m) for m in added['MountPoints']
]
if 'Ulimit' in added:
added['Ulimit'] = [ecs.Ulimit(**m) for m in added['Ulimit']]
if 'VolumesFrom' in added:
added['VolumesFrom'] = [
ecs.VolumesFrom(**m) for m in added['VolumesFrom']
]
# munge memory
if not 'Memory' in added and not 'MemoryReservation' in added:
added['MemoryReservation'] = self.vars['Memory']
attributes = added.copy()
else:
attributes = dict()
# merge in required attributes.
attributes.update(required)
return attributes
def add_resources(self):
"""Add resources to template."""
template = self.template
variables = self.get_variables()
#SFFU## Save for future use
#SFFU#environment = []
#SFFU#for k, v in variables['ContainerEnvironmentVars'].iteritems():
#SFFU# environment.append(
#SFFU# ecs.Environment(
#SFFU# Name=k,
#SFFU# Value=v,
#SFFU# )
#SFFU# )
#SFFU## Save for future use
#SFFU#links = []
#SFFU#for link in variables['ContainerLinks']:
#SFFU# links.append(link)
portmappings = []
#SFFU#for k, v in variables['ContainerEnvironmentVars'].iteritems():
#SFFU# environment.append(
#SFFU# ecs.Environment(
#SFFU# Name=k,
#SFFU# Value=v,
#SFFU# )
#SFFU# )
for hp, cp in variables['ContainerPorts'].iteritems():
portmappings.append(
ecs.PortMapping(
HostPort=hp,
ContainerPort=cp,
))
#old#for port in variables['ContainerPorts']:
#old# portmappings.append(
#old# ecs.PortMapping(
#old# ContainerPort=port,
#old# HostPort=port
#old# )
#old# )
ecscontainerdef = ecs.ContainerDefinition(
#SFFU## Save for future use
#SFFU#Command=[
#SFFU# variables['ContainerCommand'].ref,
#SFFU#],
#SFFU#EntryPoint=[
#SFFU# variables['ContainerEntryPoint'].ref,
#SFFU#],
#SFFU#Environment=environment,
#SFFU#Links=links,
Image=Join(
'',
[
Ref('AWS::AccountId'),
'.dkr.ecr.',
Ref('AWS::Region'),
'.amazonaws.com/',
variables['App'].ref,
'-',
variables['ContainerName'].ref,
#SFOU#'-',
#SFOU#variables['EnvironmentName'].ref
]),
LogConfiguration=ecs.LogConfiguration(
LogDriver='awslogs',
Options={
'awslogs-group': variables['CwLogGroupName'].ref,
'awslogs-region': Ref('AWS::Region'),
'awslogs-stream-prefix': 'ecs'
}),
Name=variables['ContainerName'].ref,
#SFOU#PortMappings=[
#SFOU# ecs.PortMapping(
#SFOU# ContainerPort=variables['ContainerPort'].ref
#SFOU# )
#SFOU#]
PortMappings=portmappings,
)
ecstaskdefinition = template.add_resource(
ecs.TaskDefinition(
'EcsTaskDefinition',
ContainerDefinitions=[ecscontainerdef],
Cpu=variables['TaskCpu'].ref,
Memory=variables['TaskMem'].ref,
ExecutionRoleArn=variables['ExecutionRoleArn'].ref,
TaskRoleArn=variables['TaskRoleArn'].ref,
Family=Join('-', [
variables['ContainerName'].ref,
variables['EnvironmentName'].ref
]),
NetworkMode=variables['NetworkMode'].ref,
RequiresCompatibilities=[variables['LaunchType'].ref],
# for future reference (need to add imports and variables)
#Volumes=[
# Volume(
# Name=variables['VolumeName'].ref,
# Host=Host(SourcePath=variables['VolumeSourcePath'].ref
# )
#],
))
template.add_output(
Output("{}Arn".format(ecstaskdefinition.title),
Description="ARN of the Task Definition",
Value=Ref(ecstaskdefinition),
Export=Export(
Sub('${AWS::StackName}-%sArn' %
ecstaskdefinition.title))))
