def create_service(self,
service_name,
family,
container_name,
environment,
command,
desired_count=1,
cpu="512",
memory="1024",
max_healthy_percent=200):
worker_task_def = ecs.TaskDefinition(
self,
family,
cpu=cpu,
memory_mib=memory,
compatibility=ecs.Compatibility.FARGATE,
family=family,
network_mode=ecs.NetworkMode.AWS_VPC)
worker_task_def.add_container(container_name,
image=self.image,
command=[command],
environment=environment,
secrets=self.secrets,
logging=ecs.LogDrivers.aws_logs(
stream_prefix=family,
log_retention=RetentionDays.ONE_DAY))
return ecs.FargateService(
self,
service_name,
service_name=service_name,
task_definition=worker_task_def,
cluster=self.cluster,
desired_count=desired_count,
platform_version=ecs.FargatePlatformVersion.VERSION1_4,
max_healthy_percent=max_healthy_percent)
def __init__(self, scope: core.Stack, id: str, **kwargs):
super().__init__(scope, id, **kwargs)
self.base_platform = BasePlatform(self, self.stack_name)
self.fargate_task_def = aws_ecs.TaskDefinition(
self,
"TaskDef",
compatibility=aws_ecs.Compatibility.EC2_AND_FARGATE,
cpu='256',
memory_mib='512',
)
self.container = self.fargate_task_def.add_container(
"CrystalServiceContainerDef",
image=aws_ecs.ContainerImage.from_registry(
"brentley/ecsdemo-crystal"),
memory_reservation_mib=512,
logging=aws_ecs.LogDriver.aws_logs(
stream_prefix='ecsworkshop-crystal'))
self.container.add_port_mappings(
aws_ecs.PortMapping(container_port=3000))
self.fargate_service = aws_ecs.FargateService(
self,
"CrystalFargateService",
task_definition=self.fargate_task_def,
cluster=self.base_platform.ecs_cluster,
security_group=self.base_platform.services_sec_grp,
desired_count=1,
cloud_map_options=aws_ecs.CloudMapOptions(
cloud_map_namespace=self.base_platform.sd_namespace,
name='ecsdemo-crystal'))
def __init__(self,
scope: Construct,
id: str,
*,
vpc: aws_ec2.IVpc,
subnets: typing.Sequence[aws_ec2.ISubnet],
cluster: aws_ecs.ICluster = None,
cluster_name: str = None,
service_name: str,
container_definition: aws_ecs.ContainerDefinitionOptions,
desired_count: int = 2,
**kwargs) -> None:
super().__init__(scope,
id,
vpc=vpc,
subnets=subnets,
container_definition=container_definition)
if not cluster:
cluster = self.setup_cluster(cluster_name=cluster_name)
self.service = aws_ecs.FargateService(
self,
'fargate',
platform_version=aws_ecs.FargatePlatformVersion.VERSION1_4,
security_groups=[self.security_group],
desired_count=desired_count,
task_definition=self.task_definition,
vpc_subnets=self.subnets,
cluster=cluster,
enable_ecs_managed_tags=True,
service_name=service_name,
**kwargs)
def __init__(
self,
scope: core.Construct,
id: str,
**kwargs,
) -> None:
super().__init__(
scope,
id,
**kwargs,
)
self.backend_task = ecs.FargateTaskDefinition(self, "BackendTask")
self.backend_task.add_container(
"BackendContainer",
image=scope.image,
logging=ecs.LogDrivers.aws_logs(
stream_prefix="BackendContainer",
log_retention=logs.RetentionDays.ONE_WEEK,
),
environment=scope.variables.regular_variables,
secrets=scope.variables.secret_variables,
command=["/start_prod.sh"],
)
scope.backend_assets_bucket.grant_read_write(
self.backend_task.task_role)
for secret in [scope.variables.django_secret_key, scope.rds.db_secret]:
secret.grant_read(self.backend_task.task_role)
port_mapping = ecs.PortMapping(container_port=8000,
protocol=ecs.Protocol.TCP)
self.backend_task.default_container.add_port_mappings(port_mapping)
self.backend_service = ecs.FargateService(
self,
"BackendService",
task_definition=self.backend_task,
assign_public_ip=True,
cluster=scope.ecs.cluster,
security_group=ec2.SecurityGroup.from_security_group_id(
self,
"BackendServiceSecurityGroup",
security_group_id=scope.vpc.vpc_default_security_group,
),
)
scope.https_listener.add_targets(
"BackendTarget",
port=80,
targets=[self.backend_service],
priority=2,
path_patterns=["*"],
health_check=elbv2.HealthCheck(
healthy_http_codes="200-299",
path="/api/health-check/",
),
)
def fargate_service(self, id, cluster, is_alb=False, desired_count=None):
if self.task_definition is None:
raise ValueError(
"Task definition needs to be set") # TODO: make this better.
if desired_count is None:
desired_count = 1
if is_alb is False:
self.service = ecs.FargateService(
self.stack,
id,
task_definition=self.task_definition,
cluster=cluster,
desired_count=desired_count)
else:
alb = ecs_patterns.ApplicationLoadBalancedFargateService(
self.stack,
id,
task_definition=self.task_definition,
protocol=elb.ApplicationProtocol.HTTP,
cluster=cluster,
desired_count=desired_count)
self.service = alb.service
def __init__(self, scope: Construct, id: str, *, vpc: aws_ec2.IVpc,
url: str, tps: int):
"""
Defines an instance of the traffic generator.
:param scope: construct scope
:param id: construct id
:param vpc: the VPC in which to host the traffic generator
:param url: the URL to hit
:param tps: the number of transactions per second
"""
super().__init__(scope, id)
## Define an ECS Cluster hosted within the requested VPC
cluster = aws_ecs.Cluster(self, 'cluster', vpc=vpc)
## Define our ECS Task Definition with a single Container.
## The image is built & published from a local asset directory
task_definition = aws_ecs.FargateTaskDefinition(self, 'PingTask')
task_definition.add_container(
'Pinger',
image=aws_ecs.ContainerImage.from_asset("pinger"),
environment={'URL': url})
## Define our Fargate Service. TPS determines how many Instances we
## want from our Task (each Task produces a single TPS)
aws_ecs.FargateService(self,
'service',
cluster=cluster,
task_definition=task_definition,
desired_count=tps)
def create_service(self):
"""
Create service
"""
return ecs.FargateService(self,
"service",
cluster=self.cluster,
task_definition=self.task)
def __init__(self, scope: core.Construct, id: str, vpc, redis,
**kwargs) -> None:
super().__init__(scope, id, **kwargs)
self.ecr = _ecr.Repository(self, "ecrRepo")
self.ecs_cluster = _ecs.Cluster(self,
"ecsCluster",
container_insights=True,
vpc=vpc)
self.task_definition = _ecs.FargateTaskDefinition(self,
"taskDefinition",
memory_limit_mib=512,
cpu=256)
self.docker_image = _ecr_assets.DockerImageAsset(self,
"dockerImage",
directory="./code")
self.container = self.task_definition.add_container(
"testContainer",
image=_ecs.ContainerImage.from_docker_image_asset(
self.docker_image),
logging=_ecs.LogDriver.aws_logs(stream_prefix="containerlogs"),
environment={
"STAGE": "dev",
"REDIS_ENDPOINT": redis.attr_configuration_end_point_address
},
)
self.container.add_port_mappings(
_ecs.PortMapping(container_port=5000, protocol=_ecs.Protocol.TCP))
self.service = _ecs.FargateService(
self,
"fargateService",
cluster=self.ecs_cluster,
task_definition=self.task_definition,
desired_count=3,
vpc_subnets=_ec2.SubnetSelection(subnets=vpc.private_subnets),
security_groups=[vpc.sg])
self.lb = _elbv2.ApplicationLoadBalancer(self,
"alb",
vpc=vpc,
security_group=vpc.sg,
internet_facing=True)
listener = self.lb.add_listener("listener", port=80)
self.target_group = listener.add_targets("fargateTarget",
port=80,
targets=[self.service])
core.CfnOutput(self,
"albDnsName",
value=self.lb.load_balancer_dns_name)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
#initialize all the required parameters
vpc_id = '[fill in VPC ID]'
security_group_id = '[fill in sg id]'
#existing subnetids for two availiability zones which
subnet_id_1a = '[fill in subnetid]'
subnet_id_1b = '[fill in subnetid]'
#name of the existing ecs cluster where the fargate service needs to be deployed
ecs_cluster_name = '[fill in name for cluster]'
#get an instance of existing vpc
vpc = ec2.Vpc.from_lookup(self, 'vpc', vpc_id=vpc_id)
#get handle for existing security group
security_group = ec2.SecurityGroup.from_security_group_id(
self, "SG", security_group_id, mutable=True)
#get handle for existing subnets
subnet1a = ec2.Subnet.from_subnet_attributes(
self,
'subnet1a',
availability_zone='us-east-1a',
subnet_id=subnet_id_1a)
subnet1b = ec2.Subnet.from_subnet_attributes(
self,
'subnet1b',
availability_zone='us-east-1b',
subnet_id=subnet_id_1b)
vpc_subnets_selection = ec2.SubnetSelection(
subnets=[subnet1a, subnet1b])
#get handle for existing ecs cluster
cluster = ecs.Cluster.from_cluster_attributes(
self,
'test-cluster',
cluster_name=ecs_cluster_name,
vpc=vpc,
security_groups=[security_group])
#create fargate task definition
task_definition = ecs.FargateTaskDefinition(self,
"test-with-cdk",
cpu=256,
memory_limit_mib=512)
#add a container to task definition using a sample image
container = task_definition.add_container(
"test-with-cdk",
image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
memory_limit_mib=256)
#expose required ports
port_mapping = ecs.PortMapping(container_port=80,
protocol=ecs.Protocol.TCP)
#adding port mappings to container
container.add_port_mappings(port_mapping)
#creating fargate service with all required inputs
fargateService = ecs.FargateService(self,
"test-with-cdk-service",
cluster=cluster,
task_definition=task_definition,
vpc_subnets=vpc_subnets_selection,
security_group=security_group)
def __init__(self, scope: core.Construct, id: str, name_extension: str, stage:str, tags:[], vpc_name:str, region:str, ecs_conf:dict, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
self.base_platform = bp.BasePlatform(self, id, name_extension, stage, vpc_name)
self.objects_list = []
self.ecr = _ecr.Repository.from_repository_name(self, "nginx-ecr", repository_name="nginx")
self.fargate_task_def = _ecs.FargateTaskDefinition(
self,
"lz-nginx-ecr-td",
family=ecs_conf["task_name"],
cpu=256,
memory_limit_mib=512,
)
self.container = self.fargate_task_def.add_container(
"lz-nginx-ecr-container",
image=_ecs.ContainerImage.from_ecr_repository(self.ecr, "latest"),
memory_reservation_mib=512,
logging=_ecs.LogDriver.aws_logs(
stream_prefix=name_extension+"-nginx-container"
),
environment={
"REGION": region
},
)
self.container.add_port_mappings(
_ecs.PortMapping(
container_port=80
)
)
self.fargate_service = _ecs.FargateService(
self,
"lz-nginx-ecr-service",
task_definition=self.fargate_task_def,
cluster=self.base_platform.ecs_cluster,
security_group=self.base_platform.services_sec_grp,
desired_count=1,
cloud_map_options=_ecs.CloudMapOptions(
cloud_map_namespace=self.base_platform.sd_namespace,
name=ecs_conf["dns_name"]
),
service_name=ecs_conf["service_name"],
platform_version=_ecs.FargatePlatformVersion.VERSION1_4,
)
self.objects_list.append(self.ecr)
self.objects_list.append(self.fargate_service)
self.objects_list.append(self.container)
self.objects_list.append(self.fargate_task_def)
self.tags_creation(tags)
def create_fagate_NLB_autoscaling(self, vpc):
cluster = ecs.Cluster(self, 'fargate-service-autoscaling', vpc=vpc)
# config IAM role
# add managed policy statement
ecs_base_role = iam.Role(
self,
"ecs_service_role",
assumed_by=iam.ServicePrincipal("ecs.amazonaws.com"))
ecs_role = ecs_base_role.from_role_arn(
self,
'gw-ecr-role-test',
role_arn='arn:aws:iam::002224604296:role/ecsTaskExecutionRole')
# Create Fargate Task Definition
fargate_task = ecs.FargateTaskDefinition(
self,
"graph-inference-task-definition",
execution_role=ecs_role,
task_role=ecs_role,
cpu=2048,
memory_limit_mib=4096)
#ecr_repo = ecr.IRepository(self, "002224604296.dkr.ecr.us-east-1.amazonaws.com/sagemaker-recsys-graph-inference")
ecr_repo = ecr.Repository.from_repository_name(
self,
id="graph-inference-docker",
repository_name="sagemaker-recsys-graph-inference")
port_mapping = ecs.PortMapping(container_port=8080,
host_port=8001,
protocol=ecs.Protocol.TCP)
ecs_log = ecs.LogDrivers.aws_logs(stream_prefix='gw-inference-test')
farget_container = fargate_task.add_container(
"graph-inference",
image=ecs.ContainerImage.from_ecr_repository(ecr_repo),
logging=ecs_log)
farget_container.add_port_mappings(port_mapping)
fargate_service = ecs.FargateService(self,
'graph-inference-service',
cluster=cluster,
task_definition=fargate_task,
assign_public_ip=True)
fargate_service.connections.security_groups[0].add_ingress_rule(
peer=ec2.Peer.ipv4('0.0.0.0/0'),
connection=ec2.Port.tcp(8080),
description="Allow http inbound from VPC")
return fargate_service.load_balancer.load_balancer_dns_name
def __create_pull_service(self, service_name: str, ctx: object):
ctx_srv = getattr(ctx.inbound.services.pull, service_name)
ecs_task_role = self.__create_default_task_role(service_name)
log_driver = ecs.LogDriver.aws_logs(log_group=self.log_group,
stream_prefix=service_name)
# create a Fargate task definition
task_definition = ecs.FargateTaskDefinition(
scope=self,
id=f"{service_name}_task_definition",
cpu=ctx_srv.size.cpu,
memory_limit_mib=ctx_srv.size.ram,
execution_role=self.ecs_exec_role,
task_role=ecs_task_role,
)
# create a container definition and associate with the Fargate task
container_vars = self.__get_container_vars(service_name, ctx, ctx_srv)
container = ecs.ContainerDefinition(
scope=self,
id=f"{service_name}_container_definition",
task_definition=task_definition,
image=ecs.ContainerImage.from_ecr_repository(
self.ecr_repository, "latest"),
logging=log_driver,
**container_vars)
security_group = ec2.SecurityGroup(scope=self,
id=f"{service_name}_sg",
vpc=self.vpc)
service = ecs.FargateService(scope=self,
id=f"{service_name}_service",
task_definition=task_definition,
cluster=self.cluster,
desired_count=getattr(
ctx_srv, "desired_count",
ctx.default_desired_count),
service_name=service_name,
security_group=security_group)
scaling = service.auto_scale_task_count(
max_capacity=ctx_srv.scaling.max_capacity,
min_capacity=ctx_srv.scaling.min_capacity)
scaling.scale_on_cpu_utilization(
id="cpu_scaling",
target_utilization_percent=ctx_srv.scaling.
target_utilization_percent,
scale_in_cooldown=core.Duration.seconds(
ctx_srv.scaling.scale_in_cooldown_seconds),
scale_out_cooldown=core.Duration.seconds(
ctx_srv.scaling.scale_out_cooldown_seconds))
def __init__(self, scope: core.Construct, id: str, vpc, security_group: ec2.SecurityGroup, rds: rds.DatabaseInstance,
config: dict, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
self.cluster = ecs.Cluster(
self,
"VdbEcsStackCluster",
cluster_name="VdbCluster",
vpc=vpc
)
self.cluster.add_capacity("DefaultAutoScalingGroup",
instance_type=ec2.InstanceType("t2.xlarge"),
vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE),
max_capacity=1)
execute_task_definition = ecs.FargateTaskDefinition(
self,
"ExecuteTaskDef",
cpu=1024,
memory_limit_mib=2048
)
execute_container = execute_task_definition.add_container(
"execute",
image=ecs.ContainerImage.from_registry(name=config['VDB_EXECUTE_IMAGE']),
entry_point=[
"sh",
"-c"
],
command=[
"./startup_script.sh"
],
logging=ecs.LogDrivers.aws_logs(stream_prefix="VdbExecuteLogs"),
environment={
"DATABASE_USER": config['DATABASE_USER'],
"DATABASE_PASSWORD": config['DATABASE_PASSWORD'],
"DATABASE_NAME": config['DATABASE_NAME'],
"DATABASE_PORT": rds.db_instance_endpoint_port,
"DATABASE_HOSTNAME": rds.db_instance_endpoint_address,
"STORAGEDIFFS_SOURCE": "geth",
"CLIENT_IPCPATH": config['CLIENT_IPCPATH']
}
)
ecs.FargateService(
self, "VdbExecuteService",
cluster=self.cluster,
task_definition=execute_task_definition,
service_name="VdbExecuteService",
security_group=security_group
)
def __init__(self, scope: cdk.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
ecs_vpc = aws_ec2.Vpc(
self, "EcsVPC",
max_azs=2) # minimum number of AZs is 2 for this stack to deploy
ecs_vpc.apply_removal_policy(cdk.RemovalPolicy.DESTROY)
ecs_cluster = aws_ecs.Cluster(self, "EcsCluster", vpc=ecs_vpc)
ecs_taskdefinition = aws_ecs.FargateTaskDefinition(
self, "EcsTaskDefinition")
ecs_taskdefinition.add_container(
"ecsContainer",
image=aws_ecs.ContainerImage.from_registry(
'coderaiser/cloudcmd:latest'), # change image here
cpu=256,
memory_limit_mib=512,
port_mappings=[aws_ecs.PortMapping(container_port=8000)
] # container port used for the image
)
ecs_fargate_service = aws_ecs.FargateService(
self,
"FargateService",
cluster=ecs_cluster,
task_definition=ecs_taskdefinition)
ecs_application_lb = aws_elasticloadbalancingv2.ApplicationLoadBalancer(
self, "EcsAlb", vpc=ecs_vpc, internet_facing=True)
alb_listener = ecs_application_lb.add_listener("AlbListener", port=80)
ecs_tg = alb_listener.add_targets(
"EcsTG",
port=80,
targets=[
ecs_fargate_service.load_balancer_target(
container_name="ecsContainer",
container_port=8000 # container port used for the image
)
])
cdk.CfnOutput(
self,
"WebUrl",
description="URL from the load balancer",
value=f"http://{ecs_application_lb.load_balancer_dns_name}/")
def create_service(self, name, guild, operators, type):
service = ecs.FargateService(
self,
name + "-service",
cluster=self.cluster,
task_definition=self.create_task(name, guild, operators, type),
assign_public_ip=True,
desired_count=0,
security_group=self.minecraft_sg,
propagate_tags=ecs.PropagatedTagSource.SERVICE,
platform_version=ecs.FargatePlatformVersion.VERSION1_4)
# guild tag allows us to find it easily for stop/start
core.Tags.of(service).add("guild", guild)
return service
def __init__(self, scope: core.Stack, id: str, **kwargs):
super().__init__(scope, id, **kwargs)
self.base_platform = BasePlatform(self, self.stack_name)
self.fargate_task_def = aws_ecs.TaskDefinition(
self, "TaskDef",
compatibility=aws_ecs.Compatibility.EC2_AND_FARGATE,
cpu='256',
memory_mib='512',
)
self.container = self.fargate_task_def.add_container(
"CrystalServiceContainerDef",
image=aws_ecs.ContainerImage.from_registry("adam9098/ecsdemo-crystal"),
memory_reservation_mib=512,
logging=aws_ecs.LogDriver.aws_logs(
stream_prefix='ecsworkshop-crystal'
),
environment={
"REGION": getenv('AWS_DEFAULT_REGION')
},
)
self.container.add_port_mappings(
aws_ecs.PortMapping(
container_port=3000
)
)
self.fargate_service = aws_ecs.FargateService(
self, "CrystalFargateService",
service_name='ecsdemo-crystal',
task_definition=self.fargate_task_def,
cluster=self.base_platform.ecs_cluster,
security_group=self.base_platform.services_sec_grp,
desired_count=1,
cloud_map_options=aws_ecs.CloudMapOptions(
cloud_map_namespace=self.base_platform.sd_namespace,
name='ecsdemo-crystal'
)
)
self.fargate_task_def.add_to_task_role_policy(
aws_iam.PolicyStatement(
actions=['ec2:DescribeSubnets'],
resources=['*']
)
)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# Create the ECR Repository
ecr_repository = ecr.Repository(self,
"ecs-devops-sandbox-repository",
repository_name="ecs-devops-sandbox-repository")
# Create the ECS Cluster (and VPC)
vpc = ec2.Vpc(self,
"ecs-devops-sandbox-vpc",
max_azs=3)
cluster = ecs.Cluster(self,
"ecs-devops-sandbox-cluster",
cluster_name="ecs-devops-sandbox-cluster",
vpc=vpc)
# Create the ECS Task Definition with placeholder container (and named Task Execution IAM Role)
execution_role = iam.Role(self,
"ecs-devops-sandbox-execution-role",
assumed_by=iam.ServicePrincipal("ecs-tasks.amazonaws.com"),
role_name="ecs-devops-sandbox-execution-role")
execution_role.add_to_policy(iam.PolicyStatement(
effect=iam.Effect.ALLOW,
resources=["*"],
actions=[
"ecr:GetAuthorizationToken",
"ecr:BatchCheckLayerAvailability",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"logs:CreateLogStream",
"logs:PutLogEvents"
]
))
task_definition = ecs.FargateTaskDefinition(self,
"ecs-devops-sandbox-task-definition",
execution_role=execution_role,
family="ecs-devops-sandbox-task-definition")
container = task_definition.add_container(
"ecs-devops-sandbox",
image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
)
# Create the ECS Service
service = ecs.FargateService(self,
"ecs-devops-sandbox-service",
cluster=cluster,
task_definition=task_definition,
service_name="ecs-devops-sandbox-service")
def __init__(self, scope: cdk.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# The code that defines your stack goes here
ecr_repository = ecr.Repository(
self,
"ecs-devops-sandbox-repository",
repository_name="ecs-devops-sandbox-repository")
vpc = ec2.Vpc(self, "ecs-devops-sandbox-vpc", max_azs=3)
cluster = ecs.Cluster(self,
"ecs-devops-sandbox-cluster",
cluster_name="ecs-devops-sandbox-cluster",
vpc=vpc)
execution_role = iam.Role(
self,
"ecs-devops-sandbox-execution-role",
assumed_by=iam.ServicePrincipal("ecs-tasks.amazonaws.com"),
role_name="ecs-devops-sandbox-execution-role")
execution_role.add_to_policy(
iam.PolicyStatement(effect=iam.Effect.ALLOW,
resources=["*"],
actions=[
'ecr:GetAuthorizationToken',
'ecr:BatchCheckLayerAvailability',
'ecr:GetDownloadUrlForLayer',
'ecr:BatchGetImage',
'logs:CreateLogStream', 'logs:PutLogEvents'
]))
task_definition = ecs.FargateTaskDefinition(
self,
"ecs-devops-sandbox-task-definition",
execution_role=execution_role,
family="ecs-devops-sandbox-task-definition")
container = task_definition.add_container(
"ecs-devops-sandbox",
image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"))
service = ecs.FargateService(self,
"ecs-devops-sandbox-service",
cluster=cluster,
task_definition=task_definition,
service_name="ecs-devops-sandbox-service")
def __init__(self, scope: core.Stack, id: str, cluster: ecs.ICluster, vpc, private_subnets, sec_group, desired_service_count, **kwargs):
super().__init__(scope, id, **kwargs)
self.cluster = cluster
self.vpc = vpc
self.private_subnets = private_subnets
self.sec_group = sec_group
self.service_discovery = cluster.default_cloud_map_namespace
self.desired_service_count = desired_service_count
self.task_definition = ecs.FargateTaskDefinition(
self, "BackendNodeServiceTaskDef",
cpu=256,
memory_limit_mib=512,
)
self.task_definition.add_container(
"BackendNodeServiceContainer",
image=ecs.ContainerImage.from_registry("brentley/ecsdemo-nodejs"),
logging=ecs.LogDrivers.firelens(
options={
"Name": "cloudwatch",
"log_key": "log",
"region": "us-west-2",
"delivery_stream": "my-stream",
"log_group_name": "firelens-fluent-bit",
"auto_create_group": "true",
"log_stream_prefix": "from-fluent-bit"}
)
)
self.fargate_service = ecs.FargateService(
self, "BackendNodeFargateService",
service_name="Fargate-Backend-NodeJS",
task_definition=self.task_definition,
cluster=self.cluster,
max_healthy_percent=100,
min_healthy_percent=0,
vpc_subnets={
"subnet_name" : "Private"
},
desired_count=self.desired_service_count,
security_group=self.sec_group,
cloud_map_options={
"name": "ecsdemo-nodejs"
},
)
def __init__(self, scope: Construct, id: str, url: str, tps: int):
super().__init__(scope, id)
cluster = aws_ecs.Cluster(self, 'Cluster')
taskdef = aws_ecs.FargateTaskDefinition(self, 'PingerTask')
taskdef.add_container(
"Pinger",
image=aws_ecs.ContainerImage.from_asset('./pinger'),
environment={'URL': url})
# since each container generate 1 tps to url, we can adjust desired tps by using desire container count
aws_ecs.FargateService(self,
'PingerService',
cluster=cluster,
task_definition=taskdef,
desired_count=tps)
def __init__(self, scope: core.Construct, id: str, *, ping_url: str,
tps: int, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
vpc = _ec2.Vpc(self, 'ClusterVpc', max_azs=2)
cluster = _ecs.Cluster(self, 'Cluster', vpc=vpc)
taskdef = _ecs.FargateTaskDefinition(self, 'PingItTask')
env = {'PING_URL': ping_url}
taskdef.add_container('PingIt',
image=_ecs.ContainerImage.from_asset('./pingit'),
environment=env)
_ecs.FargateService(self,
'PingItService',
cluster=cluster,
task_definition=taskdef,
desired_count=tps)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# Create the VPC for the honeypot(s), default is all AZs in region
vpc = ec2.Vpc(self, "HoneypotVpc", max_azs=3)
# Create the ECS cluster where fargate can deploy the Docker containers
cluster = ecs.Cluster(self, "HoneypotCluster", vpc=vpc)
# Define task definition for Fargate Service
task_definition = ecs.FargateTaskDefinition(self,
"HoneypotTasks",
cpu=256,
memory_limit_mib=512)
# Container definition
container_definition = ecs.ContainerDefinition(
self,
"HoneypotContainerDefinition",
image=ecs.ContainerImage.from_registry("statixs/cowrie"),
#image=ecs.ContainerImage.from_asset(directory = "docker"),
task_definition=task_definition,
stop_timeout=core.Duration.seconds(2),
logging=ecs.AwsLogDriver(
stream_prefix="cowrie",
log_retention=logs.RetentionDays.ONE_WEEK,
),
)
# ECS Security Group definition
sg_ssh = ec2.SecurityGroup(self,
"honeypot-sg-ssh",
vpc=vpc,
description="Allow SSH to the honeypot")
sg_ssh.add_ingress_rule(ec2.Peer.ipv4("0.0.0.0/0"), ec2.Port.tcp(22))
# Fargate service definition
fargate_service = ecs.FargateService(
self,
"HoneypotFargate",
cluster=cluster,
assign_public_ip=True,
desired_count=1,
security_group=sg_ssh,
task_definition=task_definition,
platform_version=ecs.FargatePlatformVersion.VERSION1_4)
def __init__(self, scope: Construct, id: str, url: str, tps: int):
super().__init__(scope, id)
# cluster = aws_ecs.Cluster(self, "MyCluster", vpc=vpc)
cluster = aws_ecs.Cluster(self, "MyCluster")
taskdef = aws_ecs.FargateTaskDefinition(self, "MyTaskDef")
taskdef.add_container(
"MyContainer",
image=aws_ecs.ContainerImage.from_asset("./pinger"),
environment={"URL": url})
aws_ecs.FargateService(self,
"MyPingerService",
cluster=cluster,
task_definition=taskdef,
desired_count=tps)
def __init__(self, scope: core.Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
vpc = aws_ec2.Vpc(self, "CDK_loadtester", max_azs=2)
cluster = aws_ecs.Cluster(self, 'Cluster', vpc=vpc)
taskdef = aws_ecs.FargateTaskDefinition(self, 'PingerTask')
taskdef.add_container('Pinger',
image=aws_ecs.ContainerImage.from_asset('./pinger'),
environment={
'URL': 'sample-elb-886491630.us-east-1.elb.amazonaws.com'
})
aws_ecs.FargateService(self, 'PingerService',
cluster=cluster,
task_definition=taskdef,
desired_count=10
)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# Janus Image
janus_asset = DockerImageAsset(self,
"JanusBuildImage",
directory=os.path.join(
dirname, "janus-image"))
# VPC
vpc = ec2.Vpc(self,
"VPC",
nat_gateways=0,
subnet_configuration=[
ec2.SubnetConfiguration(
name="public", subnet_type=ec2.SubnetType.PUBLIC)
])
# Create an ECS cluster
cluster = ecs.Cluster(self, "JanusCluster", vpc=vpc)
#Task definition
task_definition = ecs.FargateTaskDefinition(self, 'JanusTask')
task_definition.add_container(
"Janus",
image=ecs.ContainerImage.from_docker_image_asset(janus_asset),
cpu=256,
memory_limit_mib=512,
logging=ecs.LogDriver.aws_logs(
stream_prefix='JanusTask',
log_retention=RetentionDays("ONE_DAY")),
health_check=ecs.HealthCheck(command=[
"CMD-SHELL",
"curl -fs http://localhost:7088/admin | grep error"
]))
#Service
ecs.FargateService(self,
'JanusService',
cluster=cluster,
task_definition=task_definition,
desired_count=1,
assign_public_ip=True)
def __init__(self, scope: Construct, id: str, vpc: aws_ec2.IVpc, url: str,
tps: int):
super().__init__(scope, id)
cluster = aws_ecs.Cluster(self, "cluster", vpc=vpc)
task_definition = aws_ecs.FargateTaskDefinition(self, "PingerTask")
task_definition.add_container(
"Pinger",
image=aws_ecs.ContainerImage.from_asset(
directory="./aws_examples/url_shortner/pinger"),
environment={"URL": url})
fargate_service = aws_ecs.FargateService(
self,
"PingerService",
cluster=cluster,
task_definition=task_definition,
desired_count=tps)
def __init__(self, scope: core.Construct, id: str, env_config: dict,
**kwargs) -> None:
super().__init__(scope, id, **kwargs)
vpc = aws_ec2.Vpc.from_lookup(self,
'Vpc',
tags={
"tag:environment": "dev",
"tag:project": "cdk-example"
})
cluster = aws_ecs.Cluster.from_cluster_attributes(
self, 'Cluster', cluster_name='cdk-example', vpc=vpc)
task_definition = aws_ecs.FargateTaskDefinition(self,
"TaskDefinition",
cpu=256,
memory_limit_mib=512)
container = task_definition.add_container(
"nginx",
image=aws_ecs.ContainerImage.from_registry("nginx:latest"))
container.add_port_mappings(
aws_ecs.PortMapping(container_port=80,
protocol=aws_ecs.Protocol.TCP))
security_group = aws_ec2.SecurityGroup(self,
"cdk-fargate-example",
vpc=vpc)
security_group.add_ingress_rule(aws_ec2.Peer.ipv4(vpc.vpc_cidr_block),
aws_ec2.Port.tcp(80))
service = aws_ecs.FargateService(
self,
"FargateService",
cluster=cluster,
security_group=security_group,
service_name="cdk-fargate-example",
task_definition=task_definition,
vpc_subnets={"subnetType": aws_ec2.SubnetType.PRIVATE},
)
def __configure_fundamentals(self) -> None:
"""
Configure the daily check for fundamental data data.
"""
fundamental_definition = AmeritradeTask(
self,
'FundamentalTask',
context=self.context,
entry_point=["/usr/bin/python3", "/app/get_fundamentals.py"],
directory=path.join(src_root_dir, 'src/collectors'),
repository_name='finsurf-pm-fundamentals',
env_vars={'STREAM_NAME': self.quotes_stream.stream_name})
self.fundamental_stream.grant_write(
fundamental_definition.task_definition.task_role)
#fundamental_definition.add_kinesis_subscription(stream=self.fundamental_stream
self.fundamental_svc = ecs.FargateService(
self,
'FundamentalSvc',
cluster=self.pm_compute_cluster,
assign_public_ip=False,
desired_count=0,
security_group=self.security_group,
service_name='finsurf-pm-fundamental',
vpc_subnets=ec2.SubnetSelection(subnet_group_name='Collections'),
task_definition=fundamental_definition.task_definition)
sft = ecsp.ScheduledFargateTask(
self,
'FundamentalsTask',
schedule=scale.Schedule.cron(hour="22", minute="0", week_day="6"),
cluster=self.pm_compute_cluster,
desired_task_count=1,
scheduled_fargate_task_definition_options=ecsp.
ScheduledFargateTaskDefinitionOptions(
task_definition=fundamental_definition.task_definition),
subnet_selection=ec2.SubnetSelection(
subnet_group_name='Collections'),
vpc=self.vpc)
def __init__(self, scope: core.Construct, id: str, cluster: ecs.Cluster, security_group: ec2.SecurityGroup,
rds: rds.DatabaseInstance, config: dict, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
header_sync_task_definition = ecs.FargateTaskDefinition(
self,
"HeaderSyncTaskDef",
cpu=1024,
memory_limit_mib=2048
)
header_sync_container = header_sync_task_definition.add_container(
"header-sync",
image=ecs.ContainerImage.from_registry(name=config['VDB_HEADER_SYNC_IMAGE']),
entry_point=[
"sh",
"-c"
],
command=[
"./startup_script.sh"
],
logging=ecs.LogDrivers.aws_logs(stream_prefix="VdbHeaderSyncLogs"),
environment={
"DATABASE_USER": config['DATABASE_USER'],
"DATABASE_PASSWORD": config['DATABASE_PASSWORD'],
"DATABASE_NAME": config['DATABASE_NAME'],
"DATABASE_PORT": rds.db_instance_endpoint_port,
"DATABASE_HOSTNAME": rds.db_instance_endpoint_address,
"STARTING_BLOCK_NUMBER": "8928152",
"CLIENT_IPCPATH": config['CLIENT_IPCPATH']
}
)
ecs.FargateService(
self, "VdbHeaderSyncService",
cluster=cluster,
task_definition=header_sync_task_definition,
service_name="VdbHeaderSyncService",
security_group=security_group
)
def __init__(self, scope: core.Stack, id: str, cluster: ecs.ICluster, vpc, private_subnets, sec_group, desired_service_count, **kwargs):
super().__init__(scope, id, **kwargs)
self.cluster = cluster
self.vpc = vpc
self.private_subnets = private_subnets
self.sec_group = sec_group
self.service_discovery = cluster.default_cloud_map_namespace
self.desired_service_count = desired_service_count
self.task_definition = ecs.FargateTaskDefinition(
self, "BackendCrystalServiceTaskDef",
cpu=256,
memory_limit_mib=512,
)
self.task_definition.add_container(
"BackendCrystalServiceContainer",
image=ecs.ContainerImage.from_registry("adam9098/ecsdemo-crystal"),
logging=ecs.AwsLogDriver(stream_prefix="ecsdemo-crystal", log_retention=logs.RetentionDays.THREE_DAYS),
)
self.fargate_service = ecs.FargateService(
self, "BackendCrystalFargateService",
service_name="Fargate-Backend-Crystal",
task_definition=self.task_definition,
cluster=self.cluster,
max_healthy_percent=100,
min_healthy_percent=0,
vpc_subnets={
"subnet_name" : "Private"
},
desired_count=self.desired_service_count,
cloud_map_options={
"name": "ecsdemo-crystal"
},
security_group=self.sec_group
)
