def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
self.airflow_webserver_repo = ecr.Repository(
self,
"airflow_webserver_repo",
repository_name="airflow_webserver_cdk",
removal_policy=core.RemovalPolicy.DESTROY,
)
self.airflow_scheduler_repo = ecr.Repository(
self,
"airflow_scheduler_repo",
repository_name="airflow_scheduler_cdk",
removal_policy=core.RemovalPolicy.DESTROY,
)
self.airflow_worker_repo = ecr.Repository(
self,
"airflow_worker_repo",
repository_name="airflow_worker_cdk",
removal_policy=core.RemovalPolicy.DESTROY,
)
self.dbt_repo = ecr.Repository(
self,
"dbt_ecr_repository",
repository_name="dbt_cdk",
removal_policy=core.RemovalPolicy.DESTROY,
)
def __init__(self, scope: core.Construct, id: str, repo_name: str,
**kwargs) -> None:
super().__init__(scope, id, **kwargs)
ecr.Repository(scope=self, id=id,
repository_name=repo_name).grant_pull_push(
iam.ServicePrincipal("codebuild.amazonaws.com"))
def _create_ecr_repository(self):
"""
This defines and creates an ECR repository
where our docker image and containers will
be stored.
"""
return ecr.Repository(self, 'ECRRepo')
def __init__(self, scope: core.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
repo = ecr.Repository(self, 'MyRepository', repository_name='cdk-repo')
repo.add_lifecycle_rule(description='Lifecycle rule for cdk-repo',
max_image_count=50,
rule_priority=1)
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 create_repo(self, name: str, removal_policy, image_count: int = 3):
repo_name = "_".join(["quakeservices", name])
repository = ecr.Repository(self,
repo_name,
repository_name=repo_name,
removal_policy=removal_policy)
repository.add_lifecycle_rule(max_image_count=image_count)
def createResources(self, ns):
# ECR Repository
self.bentoECR = ecr.Repository(self, "bento-ecr",
repository_name="{}-ecr-repository".format(ns),
image_scan_on_push=True)
# ECR Policy
self.bentoECR.add_to_resource_policy(self.ecrPolicyStatement)
def __init__(self, scope: core.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
self.ecr_repository = ecr.Repository(
self,
'Repository',
repository_name='mythicalmysfits/service',
)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
ecr.Repository(self,
"customer-extractor-jobs-repo",
repository_name="customer-extractor-job")
sqs.Queue(self,
"customer-extractor-jobs-queue",
visibility_timeout=core.Duration.seconds(300))
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
branch = id.split('-')[-1]
self.flask = ecr.Repository(
self,
'repo4frontend-' + branch,
repository_name='wiki-frontend-' + branch,
)
def create_ecr_repository(scope: core.Construct, stack_name: str):
return ecr.Repository(
scope,
'ecr',
lifecycle_rules=[
ecr.LifecycleRule(max_image_age=core.Duration.days(30))
],
removal_policy=core.RemovalPolicy.DESTROY,
repository_name=stack_name,
)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
cloud_trail = aws_cloudtrail.Trail(self, "Trail")
self.hello_docker_repo = aws_ecr.Repository(
self,
"HelloDocker",
repository_name="hello-docker",
lifecycle_rules=[aws_ecr.LifecycleRule(max_image_count=10)],
removal_policy=core.RemovalPolicy.DESTROY)
self.hello_docker_repo.on_cloud_trail_image_pushed("ImagePushed")
self.tweet_ingest_repo = aws_ecr.Repository(
self,
"TweetIngest",
repository_name="tweet-ingest",
lifecycle_rules=[aws_ecr.LifecycleRule(max_image_count=10)],
removal_policy=core.RemovalPolicy.DESTROY)
self.tweet_ingest_repo.on_cloud_trail_image_pushed("ImagePushed")
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
self.repository = ecr.Repository(self, "ChatRepo", repository_name="chat-image")
self.vpc = ec2.Vpc(self, "chat-vpc",
cidr="10.0.0.0/16",
subnet_configuration=[{
"cidrMask": 24,
"name": 'mainApp',
"subnetType": ec2.SubnetType.PUBLIC
}]
)
def __init__(self, scope: core.Construct, id_: str, props,
**kwargs) -> None:
super().__init__(scope, id_, **kwargs)
namespace = props['namespace']
ecr_repo = ecr.Repository(self,
id="HtsgetRefServerEcrRepo",
repository_name=namespace,
removal_policy=core.RemovalPolicy.RETAIN)
self._ecr_repo = ecr_repo
def __init__(self, scope: core.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define ECR Registries
for cdk_id, registry_name in ECR_Private_Registry_List.items():
aws_ecr.Repository(
self,
cdk_id,
repository_name=registry_name,
removal_policy=core.RemovalPolicy.DESTROY,
)
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")
)
port_mapping = ecs.PortMapping(container_port=5000)
container.add_port_mappings(port_mapping)
# Create a load balanced ECS Service
# Athough this block works, I was not able to
load_balanced_service = ecs_patterns.ApplicationLoadBalancedFargateService(self, "ecs-devops-sandbox-service",
cluster=cluster,
task_definition=task_definition,
service_name="ecs-devops-sandbox-service")
def __init__(self, app: core.App, id: str) -> None:
super().__init__(app, id)
repository = ecr.Repository(
self,
"ModelStackRepository",
image_scan_on_push=True,
repository_name='sagemaker-model-repo' # must have sagemaker in it
)
core.CfnOutput(self, "Output", value=repository.repository_uri)
def __init__(self, scope: core.Construct, id: str, props,
**kwargs) -> None:
super().__init__(scope, id, **kwargs)
# create an ECR repo to deploy the created image to (defined in build spec)
ecr_repo = ecr.Repository(self,
id="UmccriseEcrRepo",
repository_name=props['umccrise_ecr_repo'],
removal_policy=core.RemovalPolicy.RETAIN)
# We assign the repo's arn to a local variable for the Object.
self._ecr_name = ecr_repo.repository_name
self._ecr_arn = ecr_repo.repository_arn
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
ZachRepositoryName = self.__class__.__name__
ZachRepository = ecr.Repository(self, id=ZachRepositoryName)
ZachRepository.add_lifecycle_rule(
max_image_count=100,
rule_priority=50,
tag_status=ecr.TagStatus.TAGGED,
tag_prefix_list=['sit', 'uat', 'dev'])
ZachRepository.add_lifecycle_rule(
max_image_age=core.Duration.days(720), rule_priority=100)
ZachRepository.grant_pull_push(
iam.Role.from_role_arn(
self,
id="EC2FullPrivilege",
role_arn="arn:aws:iam::098380756085:role/Zach_EC2FullPrivilege"
))
ZachRepository.grant_pull(
iam.Role.from_role_arn(
self,
id="EC2ReadPrivilege",
role_arn="arn:aws:iam::098380756085:role/Zach_EC2ReadPrivilege"
))
ZachRepositoryEvent = ZachRepository.on_cloud_trail_event(
id="DockerTrail",
event_pattern=event.EventPattern(account=[
self.node.try_get_context("account") or os.getenv('account')
or '098380756085'
],
region=['ap-southeast-1']))
ZachSNStopic = self.SnsExporter(ZachRepositoryName)
ZachRepositoryEvent.add_target(eventarget.SnsTopic(topic=ZachSNStopic))
core.CfnOutput(self,
id=ZachRepositoryName + "ARN",
value=ZachRepository.repository_arn)
core.CfnOutput(self,
id=ZachRepositoryName + "URI",
value=ZachRepository.repository_uri)
core.CfnOutput(self,
id=ZachRepositoryName + "RuleARN",
value=ZachRepositoryEvent.rule_arn)
core.CfnOutput(self,
id=ZachRepositoryName + "RuleName",
value=ZachRepositoryEvent.rule_name)
core.CfnOutput(self,
id=ZachRepositoryName + "TopicARN",
value=ZachSNStopic.topic_arn)
core.CfnOutput(self,
id=ZachRepositoryName + "TopicName",
value=ZachSNStopic.topic_name)
def create_ecr_component_base_repository(self) -> Resource:
"""コンポーネントを毎回0からビルドすると時間がかかるので、ベースになるイメージを作成
Returns:
Resource: ECR
"""
ecr = aws_ecr.Repository(
self,
id=f"{self.stack_name}_{self.component_id}_component_base".lower(),
repository_name="base." + self.greengrass_component_name,
removal_policy=RemovalPolicy.DESTROY)
return ecr
def create_ecr_component_repository(self) -> Resource:
"""Greengrassのコンポーネント用にビルドしたdockerイメージを保存するレジストリ
Returns:
Resource: ECR
"""
ecr = aws_ecr.Repository(
self,
id=f"{self.stack_name}_{self.component_id}_component".lower(),
repository_name=self.greengrass_component_name,
removal_policy=RemovalPolicy.DESTROY)
return ecr
def __init__(self,
scope: core.Construct,
id: str,
UserName="******",
**kwargs):
super().__init__(scope, id, **kwargs)
self.repositories = {}
# ecr repo to push docker container into
self.string_merge = _ecr.Repository(
self,
"string_merge",
repository_name="batch_" + UserName + "/string_merge",
removal_policy=core.RemovalPolicy.DESTROY)
self.string_repeat = _ecr.Repository(
self,
"string_repeat",
repository_name="batch_" + UserName + "/string_repeat",
removal_policy=core.RemovalPolicy.DESTROY)
self.string_reverse = _ecr.Repository(
self,
"string_reverse",
repository_name="batch_" + UserName + "/string_reverse",
removal_policy=core.RemovalPolicy.DESTROY)
self.string_split = _ecr.Repository(
self,
"string_split",
repository_name="batch_" + UserName + "/string_split",
removal_policy=core.RemovalPolicy.DESTROY)
self.repositories["string_merge"] = self.string_merge
self.repositories["string_repeat"] = self.string_repeat
self.repositories["string_reverse"] = self.string_reverse
self.repositories["string_split"] = self.string_split
def __init__(self, scope: core.Construct, id: str, *, app_env: str,
**kwargs) -> None:
super().__init__(scope, id, **kwargs)
params = {
'repository_name': 'staff-repository',
'removal_policy': core.RemovalPolicy.DESTROY,
}
repository = ecr.Repository(self, 'open-repository', **params)
repository.add_lifecycle_rule(tag_prefix_list=["stg"],
max_image_count=5)
repository.add_lifecycle_rule(tag_prefix_list=["prd"],
max_image_count=5)
self._ecr = repository
def __init__(self, scope: cdk.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# ECR repositories
remove_old_images = ecr.LifecycleRule(
description="Expire old images, keep 2 latest",
rule_priority=1,
max_image_count=2,
tag_status=ecr.TagStatus.ANY,
)
self.repository_web = ecr.Repository(
self,
"accountant-web-repository",
repository_name="accountant-web",
lifecycle_rules=[remove_old_images],
)
self.repository_worker = ecr.Repository(
self,
"accountant-worker-repository",
repository_name="accountant-worker",
lifecycle_rules=[remove_old_images],
)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# Create the ECR Repository
ecr_repository = ecr.Repository(
self,
"zd-add-cust-card-to-stripe-repository",
repository_name="zd-add-cust-card-to-stripe-repository")
# Create the ECS Cluster (and VPC)
vpc = ec2.Vpc(self, "zd-add-cust-card-to-stripe-vpc", max_azs=3)
cluster = ecs.Cluster(
self,
"zd-add-cust-card-to-stripe-cluster",
cluster_name="zd-add-cust-card-to-stripe-cluster",
vpc=vpc)
# Create the ECS Task Definition with placeholder container (and named Task Execution IAM Role)
execution_role = iam.Role(
self,
"zd-add-cust-card-to-stripe-execution-role",
assumed_by=iam.ServicePrincipal("ecs-tasks.amazonaws.com"),
role_name="zd-add-cust-card-to-stripe-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,
"zd-add-cust-card-to-stripe-task-definition",
execution_role=execution_role,
family="zd-add-cust-card-to-stripe-task-definition")
container = task_definition.add_container(
"zd-add-cust-card-to-stripe",
image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"))
# Create the ECS Service
service = ecs.FargateService(
self,
"zd-add-cust-card-to-stripe-service",
cluster=cluster,
task_definition=task_definition,
service_name="zd-add-cust-card-to-stripe-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.Construct, id: str,UserName="******",**kwargs):
super().__init__(scope, id, **kwargs)
self.repositories = {}
# ecr repo to push docker container into
self.web_index = _ecr.Repository(
self, "Web_Index",
repository_name="web_"+UserName+"/index",
removal_policy=core.RemovalPolicy.DESTROY
)
self.repositories["web_index"] = self.web_index
def __init__(self, scope: core.Construct, name: str, **kwargs) -> None:
super().__init__(scope, name, **kwargs)
app_repositories = ['jenkins-workshop-go-app']
default_ecr_lifecyclerule = ecr.LifecycleRule(
description='Default ECR lifecycle Rule',
max_image_count=500,
rule_priority=100)
for a in app_repositories:
ecr.Repository(self,
a,
repository_name=a,
lifecycle_rules=[default_ecr_lifecyclerule],
removal_policy=core.RemovalPolicy.DESTROY)
def make_ecr_repo(self, repo_suffix : str, repo_description : str):
'''
Creates an ECR repo
Parameters
----------
repo_suffix : str
The suffix of the repo. The full repo name is
APPLICATION_PREFIX _ repo_suffix
'''
repo_name = "%s-%s" % (self.APPLICATION_PREFIX, repo_suffix)
repo_description = "%s %s" % (self.APPLICATION_PREFIX, repo_description)
ecr_repo = ecr.Repository(self, repo_name, repository_name=repo_name, removal_policy=core.RemovalPolicy.DESTROY)
util.tag_resource(ecr_repo, repo_name, repo_description)
return ecr_repo
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# create ECR repository
self.ecr_repository = ecr.Repository(
scope=self,
id="ecr"
)
repo_name_output = core.CfnOutput(
scope=self,
id="ecr-repo-name-out",
value=self.ecr_repository.repository_name,
export_name=f"{id}-ecr-repo-name"
)
