def create_template(self):
t = self.template
cluster = t.add_resource(ecs.Cluster("Cluster"))
t.add_output(Output("ClusterId", Value=cluster.Ref()))
t.add_output(Output("ClusterArn", Value=cluster.GetAtt("Arn")))
def __init__(self, key):
# Resources
R_Cluster = ecs.Cluster('Cluster')
add_obj([
R_Cluster,
])
def resources(self, stack: Stack) -> list[AWSObject]:
"""Construct and return ECS cluster troposphere resources."""
c_settings = None
if self.cluster_settings:
c_settings = [
ecs.ClusterSetting(**cs) for cs in self.cluster_settings
]
provider_strategy = None
if self.default_capacity_provider_strategy:
provider_strategy = [
ecs.CapacityProviderStrategyItem(**ps)
for ps in self.default_capacity_provider_strategy
]
kwargs = {
key: val
for key, val in {
"ClusterName": self.name,
"ClusterSettings": c_settings,
"CapacityProviders": self.capacity_providers,
"DefaultCapacityProviderStrategy": provider_strategy,
"Tags": Tags({
"Name": self.name,
**self.tags
}),
}.items() if val is not None
}
return [ecs.Cluster(name_to_id(self.name), **kwargs)]
def add_to_template(self, template):
t = template
cluster = t.add_resource(ecs.Cluster("{}ECSCluster".format(self.name)))
if len(self.name) > 0:
cluster.ClusterName = self.name
t.add_output([
Output("{}ECSCluster".format(self.name), Value=Ref(cluster)),
Output("{}ECSClusterArn".format(self.name),
Value=GetAtt(cluster, 'Arn')),
])
def build_hook(self):
print "Building Template for AWS Frederick ECS"
hosted_zone_name = self.config.get('hosted_zone')
ecs_config = self.config.get('ecs')
if ecs_config is not None:
cluster = self.add_resource(
ecs.Cluster('filesharefrederick',
ClusterName='filesharefrederick'))
for ecs in ecs_config:
self.add_ecs(ecs.get('name'), ecs.get('image'), ecs.get('cpu'),
ecs.get('memory'), ecs.get('container_port'),
ecs.get('alb_port'), ecs.get('envvars'),
self.cidr_range, hosted_zone_name)
def add_resources(self):
"""Add resources to template."""
template = self.template
variables = self.get_variables()
ecscluster = template.add_resource(
ecs.Cluster('EcsCluster',
ClusterName=variables['ClusterName'].ref))
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("{}Name".format(ecscluster.title),
Description="ECS Cluster Name",
Value=Ref(ecscluster),
Export=Export(
Sub('${AWS::StackName}-%sName' % ecscluster.title))))
def test_allow_ref_cluster(self):
task_definition = ecs.TaskDefinition(
"mytaskdef",
ContainerDefinitions=[
ecs.ContainerDefinition(
Image="myimage",
Memory="300",
Name="mycontainer",
)
],
Volumes=[
ecs.Volume(Name="my-vol"),
],
)
cluster = ecs.Cluster("mycluster")
ecs_service = ecs.Service(
'Service',
Cluster=Ref(cluster),
DesiredCount=2,
TaskDefinition=Ref(task_definition),
)
ecs_service.JSONrepr()
def create_ecs_cluster(self):
t = self.template
t.add_resource(ecs.Cluster("EmpireControllerCluster"))
t.add_output(Output("ECSCluster",
Value=Ref("EmpireControllerCluster")))
def main():
template = Template()
template.add_resource(
ecs.Cluster("ECSCluster", ClusterName="WorldCheckCluster"))
template.add_resource(
iam.Role("ECSTaskRole",
AssumeRolePolicyDocument={
"Version":
"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": ["ecs-tasks.amazonaws.com"]
},
"Action": ["sts:AssumeRole"]
}]
}))
template.add_resource(
iam.Role(
"ECSServiceSchedulerRole",
AssumeRolePolicyDocument={
"Version":
"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": ["ecs.amazonaws.com"]
},
"Action": ["sts:AssumeRole"]
}]
},
Policies=[
iam.Policy(PolicyDocument={
"Version":
"2012-10-17",
"Statement": [{
"Effect":
"Allow",
"Action": [
"ec2:Describe*",
"elasticloadbalancing:DeregisterInstancesFromLoadBalancer",
"elasticloadbalancing:DeregisterTargets",
"elasticloadbalancing:Describe*",
"elasticloadbalancing:RegisterInstancesWithLoadBalancer",
"elasticloadbalancing:RegisterTargets"
],
"Resource":
"*"
}]
},
PolicyName="ecs-service")
]))
template.add_resource(
iam.Role("EC2InstanceRole",
AssumeRolePolicyDocument={
"Version":
"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": ["ec2.amazonaws.com"]
},
"Action": ["sts:AssumeRole"]
}]
},
Policies=[
iam.Policy(PolicyDocument={
"Version":
"2012-10-17",
"Statement": [{
"Effect":
"Allow",
"Action": [
"ecs:CreateCluster",
"ecs:DeregisterContainerInstance",
"ecs:DiscoverPollEndpoint", "ecs:Poll",
"ecs:RegisterContainerInstance",
"ecs:StartTelemetrySession",
"ecr:GetAuthorizationToken",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer", "ecs:Submit*",
"logs:CreateLogStream", "logs:PutLogEvents",
"ec2:DescribeTags", "cloudwatch:PutMetricData"
],
"Resource":
"*"
}]
},
PolicyName="ecs-service")
]))
template.add_resource(
iam.InstanceProfile("EC2InstanceProfile",
Roles=[Ref("EC2InstanceRole")]))
with open("user-data.sh", "r") as f:
user_data_content = f.readlines()
template.add_resource(
ec2.Instance(
"EC2Instance",
ImageId="ami-13f7226a",
InstanceType="t2.micro",
SecurityGroups=["default"],
UserData=Base64(Join('', [Sub(x) for x in user_data_content])),
IamInstanceProfile=Ref("EC2InstanceProfile"),
))
template.add_resource(
ecs.TaskDefinition(
"ECSTaskDefinition",
TaskRoleArn=Ref("ECSTaskRole"),
ContainerDefinitions=[
ecs.ContainerDefinition(
Name="SimpleServer",
Memory="128",
Image="abbas123456/simple-server:latest",
PortMappings=[ecs.PortMapping(ContainerPort=8000)],
)
]))
template.add_resource(
elb.TargetGroup(
"ECSTargetGroup",
VpcId="vpc-925497f6",
Port=8000,
Protocol="HTTP",
))
template.add_resource(
elb.LoadBalancer(
"LoadBalancer",
Subnets=["subnet-a321c8fb", "subnet-68fa271e", "subnet-689d350c"],
SecurityGroups=["sg-0202bd65"]))
template.add_resource(
elb.Listener(
"LoadBalancerListener",
DefaultActions=[
elb.Action(Type="forward",
TargetGroupArn=Ref("ECSTargetGroup"))
],
LoadBalancerArn=Ref("LoadBalancer"),
Port=80,
Protocol="HTTP",
))
template.add_resource(
ecs.Service("ECSService",
Cluster=Ref("ECSCluster"),
DesiredCount=1,
LoadBalancers=[
ecs.LoadBalancer(ContainerPort=8000,
ContainerName="SimpleServer",
TargetGroupArn=Ref("ECSTargetGroup"))
],
Role=Ref("ECSServiceSchedulerRole"),
TaskDefinition=Ref("ECSTaskDefinition"),
DependsOn="LoadBalancerListener"))
return template.to_json()
def create_ecs_cluster_resource(template):
return template.add_resource(
ecs.Cluster(
'ApiCluster'
)
)
}
]
}
)
)
ec2_instance_profile = template.add_resource(
iam.InstanceProfile(
'EC2InstanceProfile',
Roles=[Ref(ecs_cluster_role)]
)
)
ecs_cluster = template.add_resource(
ecs.Cluster(
'ApiCluster'
)
)
launch_template = template.add_resource(
ec2.LaunchTemplate(
'LaunchTemplate',
LaunchTemplateName=Ref(api_launch_template_name),
LaunchTemplateData=ec2.LaunchTemplateData(
ImageId='ami-066826c6a40879d75',
InstanceType=Ref(api_instance_class),
IamInstanceProfile=ec2.IamInstanceProfile(
Arn=GetAtt(ec2_instance_profile, 'Arn')
),
InstanceInitiatedShutdownBehavior='terminate',
Monitoring=ec2.Monitoring(Enabled=True),
def create_ecs_cluster(self):
t = self.template
t.add_resource(ecs.Cluster("EmpireMinionCluster"))
t.add_output(
Output("MinionECSCluster", Value=Ref("EmpireMinionCluster")))
jicketsmtphost = "SETME"
jicketticketaddress = "SETME"
jicketjiraurl = "SETME"
jicketjirauser = "******"
jicketjirapass = "******"
jicketjiraproject = "SETME"
jicketthreadtemplate = "/etc/jicket/threadtemplate.html"
t = Template("Jicket ECS Deployment")
# ECS Cluster
# =============
cluster = ecs.Cluster("JicketCluster")
cluster.ClusterName = "Jicket"
t.add_resource(cluster)
# ECS Task Definition
# =====================
taskdef = ecs.TaskDefinition("JicketTask")
contdef = ecs.ContainerDefinition()
contdef.Cpu = 0
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),
BlockDeviceMappings=[
ec2.BlockDeviceMapping(
DeviceName='/dev/xvda',
Ebs=ec2.EBSBlockDevice(
Encrypted=False,
VolumeSize=8,
SnapshotId='snap-0ed4f88be6558a32a',
VolumeType='gp2',
DeleteOnTermination=True))
],
HibernationOptions={"Configured": False}))
ECSCluster = template.add_resource(
ecs.Cluster('ECSCluster',
ClusterName='default',
ClusterSettings=[{
"Name": 'containerInsights',
"Value": 'disabled'
}]))
RDSDBInstance = template.add_resource(
rds.DBInstance('RDSDBInstance',
DBInstanceIdentifier='wcmbpm',
AllocatedStorage=20,
DBInstanceClass='db.t2.micro',
Engine='mysql',
MasterUsername='******',
MasterUserPassword='******',
PreferredBackupWindow='07:30-08:00',
BackupRetentionPeriod=7,
AvailabilityZone='us-east-2b',
PreferredMaintenanceWindow='mon:06:04-mon:06:34',
))
deploy_cloud9 = t.add_parameter(Parameter(
"DeployCloud9",
Type="String",
Description="Whether to deploy Cloud9",
AllowedValues=["true","false"],
Default="true"
))
cloud9_condition = t.add_condition("Cloud9Condition", Equals(Ref(deploy_cloud9), "true"))
# Create the ECS Cluster
ECSCluster = t.add_resource(ecs.Cluster(
"ECSCluster",
ClusterName="Ghost"
))
# Create the CodeCommit Repo
GhostRepo = t.add_resource(codecommit.Repository(
"GhostRepo",
RepositoryName="ghost-ecs-fargate-pipeline"
))
# Create each required stack
init_db_lambda_build = t.add_resource(cloudformation.Stack(
"InitDBLambdaBuild",
TemplateURL="https://s3.amazonaws.com/ghost-ecs-fargate-pipeline/init-db-lambda-build.template",
))
def gen_cluster(self):
self.cluster = ecs.Cluster("ECSCluster",
ClusterName="conducto-demo-cluster")
self.template.add_resource(self.cluster)
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))))
ecs, ec2, elasticloadbalancingv2, logs, iam
t = Template()
t.add_version("2010-09-09")
# Get nginx image parameter
NginxImage = t.add_parameter(Parameter(
"NginxImage",
Default="nginx:alpine",
Description="The nginx container image to run (e.g. nginx:alpine)",
Type="String"
))
# Create the ECS Cluster
ECSCluster = t.add_resource(ecs.Cluster(
"ECSCluster",
ClusterName="Fargate"
))
# Create the VPC
VPC = t.add_resource(ec2.VPC(
"VPC",
CidrBlock="10.0.0.0/16",
EnableDnsSupport="true",
EnableDnsHostnames="true"
))
PubSubnetAz1 = t.add_resource(ec2.Subnet(
"PubSubnetAz1",
CidrBlock="10.0.0.0/24",
VpcId=Ref(VPC),
AvailabilityZone=Join("", [Ref('AWS::Region'), "a"]),
def GenerateStepPublisherLayer():
t = Template()
t.add_description("""\
StepScheduler Layer
""")
stackname_param = t.add_parameter(
Parameter(
"StackName",
Description="Environment Name (default: hackathon)",
Type="String",
Default="hackathon",
))
vpcid_param = t.add_parameter(
Parameter(
"VpcId",
Type="String",
Description="VpcId of your existing Virtual Private Cloud (VPC)",
Default="vpc-fab00e9f"))
subnets = t.add_parameter(
Parameter(
"Subnets",
Type="CommaDelimitedList",
Description=(
"The list SubnetIds, for public subnets in the "
"region and in your Virtual Private Cloud (VPC) - minimum one"
),
Default="subnet-b68f3bef,subnet-9a6208ff,subnet-bfdd4fc8"))
keypair_param = t.add_parameter(
Parameter("KeyPair",
Description="Name of an existing EC2 KeyPair to enable SSH "
"access to the instance",
Type="String",
Default="glueteam"))
scheduler_ami_id_param = t.add_parameter(
Parameter(
"SchedulerAmiId",
Description="Scheduler server AMI ID (default: ami-a10897d6)",
Type="String",
Default="ami-a10897d6"))
cluster_ami_id_param = t.add_parameter(
Parameter("ClusterAmiId",
Description="Cluster server AMI ID (default: ami-3db4ca4a)",
Type="String",
Default="ami-3db4ca4a"))
iam_role_param = t.add_parameter(
Parameter(
"IamRole",
Description="IAM Role name",
Type="String",
))
hashkeyname_param = t.add_parameter(
Parameter(
"HaskKeyElementName",
Description="HashType PrimaryKey Name (default: id)",
Type="String",
AllowedPattern="[a-zA-Z0-9]*",
MinLength="1",
MaxLength="2048",
ConstraintDescription="must contain only alphanumberic characters",
Default="id"))
crontab_tablename_param = t.add_parameter(
Parameter(
"CrontabTablename",
Description="Crontab Table Name",
Type="String",
))
containerlauncher_param = t.add_parameter(
Parameter(
"Containerlauncher",
Description=
"Container Launcher zip file (default: containerLauncher-1.0.zip)",
Type="String",
Default="containerLauncher-1.0.zip"))
zipfileversion_param = t.add_parameter(
Parameter(
"ZipfileVersion",
Description="Container Launcher zip file version",
Type="String",
))
# --------- Lambda Container Launcher
lambda_function = t.add_resource(
Function(
"containerLauncher",
Code=Code(
S3Bucket="hackathon-glueteam-lambda",
S3Key=Ref(containerlauncher_param),
S3ObjectVersion=Ref(zipfileversion_param),
),
Description=Join('',
[Ref(stackname_param), " container Launcher"]),
MemorySize=256,
Handler="com.philips.glueteam.DockerLauncher::myHandler",
Runtime="java8",
Timeout=60,
Role=Join('', [
"arn:aws:iam::",
Ref("AWS::AccountId"), ":role/",
Ref(iam_role_param)
]),
))
townclock_topic = t.add_resource(
sns.Topic(
"TownClock",
Subscription=[
sns.Subscription(Endpoint=GetAtt("containerLauncher", "Arn"),
Protocol="lambda"),
],
))
# --------- Scheduler instance
scheduler_sg = t.add_resource(
ec2.SecurityGroup(
'SchedulerSG',
GroupDescription='Security group for Scheduler host',
VpcId=Ref(vpcid_param),
Tags=Tags(Name=Join("", [Ref(stackname_param), "SchedulerSG"])),
SecurityGroupIngress=[
ec2.SecurityGroupRule(
IpProtocol="tcp",
FromPort="22",
ToPort="22",
CidrIp="0.0.0.0/0",
),
ec2.SecurityGroupRule(
IpProtocol="tcp",
FromPort="8080",
ToPort="8080",
CidrIp="0.0.0.0/0",
),
]))
cluster = t.add_resource(ecs.Cluster("ECSCluster", ))
scheduler_host = t.add_resource(
ec2.Instance(
'SchedulerHost',
ImageId=Ref(scheduler_ami_id_param),
InstanceType='t2.micro',
KeyName=Ref(keypair_param),
IamInstanceProfile=Ref(iam_role_param),
NetworkInterfaces=[
ec2.NetworkInterfaceProperty(
AssociatePublicIpAddress=True,
SubnetId=Select(0, Ref(subnets)),
DeleteOnTermination=True,
GroupSet=[
Ref(scheduler_sg),
],
DeviceIndex=0,
),
],
Tags=Tags(Name=Join("", [Ref(stackname_param), "Scheduler"]),
Id=Join("", [Ref(stackname_param), "Scheduler"])),
UserData=Base64(
Join('', [
'#!/bin/bash\n',
'yum update -y aws-cfn-bootstrap\n',
'sns_topic_arn="',
Ref(townclock_topic),
'"\n',
'region="',
Ref("AWS::Region"),
'"\n',
'crontab_tablename="',
Ref(crontab_tablename_param),
'"\n',
'ecs_clustername="',
Ref(cluster),
'"\n',
'publish_source=https://raw.githubusercontent.com/hngkr/hackathon/master/ansible/files/unreliable-town-clock-publish\n',
'publish=/usr/local/bin/unreliable-town-clock-publish\n',
'curl -s --location --retry 10 -o $publish $publish_source\n',
'chmod +x $publish\n',
'cat <<EOF >/etc/cron.d/unreliable-town-clock\n',
'*/2 * * * * ec2-user $publish "$sns_topic_arn" "$region" "$crontab_tablename" "$ecs_clustername"\n',
'EOF\n',
])),
))
cluster_sg = t.add_resource(
ec2.SecurityGroup(
'ClusterSG',
GroupDescription='Security group for Cluster host',
VpcId=Ref(vpcid_param),
Tags=Tags(Name=Join("", [Ref(stackname_param), "ClusterSG"])),
SecurityGroupIngress=[
ec2.SecurityGroupRule(
IpProtocol="tcp",
FromPort="22",
ToPort="22",
CidrIp="0.0.0.0/0",
),
]))
cluster_host = t.add_resource(
ec2.Instance(
'ClusterHost',
ImageId=Ref(cluster_ami_id_param),
InstanceType='t2.micro',
KeyName=Ref(keypair_param),
# TODO: Should have multiple separate iam roles for townclock / clusterhost
IamInstanceProfile=Ref(iam_role_param),
NetworkInterfaces=[
ec2.NetworkInterfaceProperty(
AssociatePublicIpAddress=True,
SubnetId=Select(0, Ref(subnets)),
DeleteOnTermination=True,
GroupSet=[
Ref(cluster_sg),
],
DeviceIndex=0,
),
],
Tags=Tags(Name=Join("", [Ref(stackname_param), "ClusterNode"]),
Id=Join("", [Ref(stackname_param), "ClusterNode"])),
UserData=Base64(
Join('', [
'#!/bin/bash\n',
'mkdir /etc/ecs\n',
'cat <<EOF >/etc/ecs/ecs.config\n',
'ECS_CLUSTER=',
Ref(cluster),
'\n',
'EOF\n',
])),
))
# --------- Expected DynamoDB Tables
dirtylist_table = t.add_resource(
dynamodb.Table(
"DirtyList",
AttributeDefinitions=[
dynamodb.AttributeDefinition(Ref(hashkeyname_param), "S"),
],
KeySchema=[dynamodb.Key(Ref(hashkeyname_param), "HASH")],
ProvisionedThroughput=dynamodb.ProvisionedThroughput(1, 1)))
runlog_table = t.add_resource(
dynamodb.Table(
"RunLog",
AttributeDefinitions=[
dynamodb.AttributeDefinition(Ref(hashkeyname_param), "S"),
],
KeySchema=[dynamodb.Key(Ref(hashkeyname_param), "HASH")],
ProvisionedThroughput=dynamodb.ProvisionedThroughput(1, 1)))
# --------- Outputs
t.add_output(
[Output(
"clusterid",
Description="Cluster Id",
Value=Ref(cluster),
)])
t.add_output([
Output(
"dirtylist",
Description="DirtyList Tablename",
Value=Ref(dirtylist_table),
)
])
t.add_output([
Output(
"runlog",
Description="Runlog Tablename",
Value=Ref(runlog_table),
)
])
t.add_output([
Output(
"lambdafunctionname",
Description="Lambda Function Name",
Value=Ref(lambda_function),
)
])
t.add_output([
Output(
"clocktowertopicarn",
Description="Clock Tower Topic Arn",
Value=Ref(townclock_topic),
)
])
return t
