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 )