def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
#
# ECR Repository
#
for ecr_repo_name, ecr_repo_configuration in resource_specs.items():
# AWS ECR Dynamic Variables
resource_repo_name = ecr_repo_name
# resource_repo_version = eks_repo_configuration["version"]
resource_repo_tags = None
resource_repo_tags = ecr_repo_configuration[
"tags"] if "tags" in ecr_repo_configuration else None
# Getting list of tags from configuration file
repo_tags_list = {}
if resource_repo_tags is not None:
for each_tag_name, each_tag_value in resource_repo_tags.items(
):
repo_tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
repo_tags_list.update({"Name": resource_repo_name})
repo_tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
repo_tags_list.update(resource_mandatory_tags)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for eip_name, eip_configuration in resource_specs.items():
# AWS Elastic IP Dynamic Variables
resource_name = eip_name
resource_tags = eip_configuration["tags"] if "'tags':" in str(
eip_configuration) else None
# Lists
tags_list = {}
# Getting list of tags from configuration file
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
eip = net.Eip(resource_name, tags=tags_list)
eip_ids_dict.update({eip._name: eip.id})
# Exporting each EIP
pulumi.export(eip._name, eip.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
aws_vpc_id = VPCs.VPCId()
for subnet_name, subnet_configuration in resource_specs.items():
# AWS Subnet Dynamic Variables
resource_name = subnet_name
resource_az = subnet_configuration["az"]
resource_cidr = subnet_configuration["cidr"]
resource_assign_public_ipv4 = subnet_configuration[
"assign-public-ipv4"]
resource_vpc = subnet_configuration["vpc"]
resource_tags = None
resource_tags = subnet_configuration["tags"] if "'tags':" in str(
subnet_configuration) else None
this_vpc = aws_vpc_id[str(resource_vpc)]
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
subnet = net.Subnet(
resource_name,
vpc_id=this_vpc,
cidr_block=resource_cidr,
map_public_ip_on_launch=resource_assign_public_ipv4,
availability_zone=resource_az,
tags=tags_list
# FIXME: This needs to be sorted
# opts = pulumi.ResourceOptions(
# parent = this_vpc,
# depends_on = [this_vpc]
# )
)
subnet_ids_dict.update({subnet._name: subnet.id})
subnet_cidr_blocks_dict.update({subnet._name: subnet.cidr_block})
subnet_azs_dict.update({subnet._name: subnet.availability_zone})
# Exporting each subnet created for future reference
pulumi.export(subnet._name, subnet.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for acm_name, acm_configuration in resource_specs.items():
# AWS ACM Dynamic Variables
resource_name = acm_name
resource_number_of_instances = acm_configuration["domain"]
resource_namespace = acm_configuration["validation_type"]
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
aws_subnet_id = Subnets.SubnetId()
aws_eip_id = ElasticIPs.ElasticIPId()
for natgw_name, natgw_configuration in resource_specs.items():
# AWS NAT Gateway Variables
resource_name = natgw_name
resource_subnet = natgw_configuration["subnet"]
resource_eip = natgw_configuration["elastic_ip"]
resource_tags = None
resource_tags = natgw_configuration[
"tags"] if "tags" in natgw_configuration else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
this_subnet = aws_subnet_id[str(resource_subnet)]
this_eip = aws_eip_id[str(resource_eip)]
aws_natgw = net.NatGateway(resource_name,
subnet_id=this_subnet,
allocation_id=this_eip,
tags=tags_list)
# Update resource dictionaries
natgw_ids_dict.update({aws_natgw._name: aws_natgw.id})
# Export
pulumi.export(aws_natgw._name, aws_natgw.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for vpc_name, vpc_conf in resource_specs.items():
# AWS VPC Dynamic Variables
resource_name = vpc_name
resource_cidr = vpc_conf['cidr']
resource_dns_resolution = vpc_conf['dns-resolution']
resource_dns_hostnames = vpc_conf['dns-hostnames']
resource_tags = None
resource_tags = vpc_conf["tags"] if "tags" in vpc_conf else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Add mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
# Create resource
vpc = net.Vpc(resource_name,
cidr_block=resource_cidr,
enable_dns_support=resource_dns_resolution,
enable_dns_hostnames=resource_dns_hostnames,
tags=tags_list)
# Update resource dictionary
vpc_ids_dict.update({vpc._name: vpc.id})
# Export the name of each VPC
pulumi.export(vpc._name, vpc.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for s3_bucket_name, s3_bucket_configuration in resource_specs.items():
# AWS S3 Dynamic Variables
resource_name = s3_bucket_name
resource_tags = None
resource_tags = s3_bucket_configuration[
"tags"] if "tags" in s3_bucket_configuration else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
sse_config = s3_bucket_configuration[
"serverSideEncryptionConfiguration"] if "serverSideEncryptionConfiguration" in s3_bucket_configuration else None
# Create S3s
bucket = s3.Bucket(
resource_name,
acl=s3_bucket_configuration["acl"],
force_destroy=s3_bucket_configuration["force-destroy"],
tags=tags_list,
server_side_encryption_configuration=sse_config)
# Export
pulumi.export(bucket._name, bucket.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
aws_vpc_id = VPCs.VPCId()
for igw_name, igw_configuration in resource_specs.items():
# AWS Internet Gateway Variables
resource_name = igw_name
resource_vpc = igw_configuration["vpc"]
resource_tags = None
resource_tags = igw_configuration["tags"] if "tags" in igw_configuration else None
this_vpc = aws_vpc_id[str(resource_vpc)]
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({"Project/Stack": pulumi.get_project() + "/" + pulumi.get_stack()})
tags_list.update(resource_mandatory_tags)
aws_igw = igw.InternetGateway(
resource_name,
vpc_id = this_vpc,
tags = resource_tags
)
igw_ids_dict.update({aws_igw._name: aws_igw.id})
# Export the name of each Internet Gateway
pulumi.export(aws_igw._name, aws_igw.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for keypair_name, keypair_configuration in resource_specs.items():
# AWS KeyPair Dynamic Variables
resource_name = keypair_name
resource_public_key = keypair_configuration['public_key']
resource_tags = None
resource_tags = keypair_configuration[
"tags"] if "tags" in keypair_configuration else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
# Create resource
keypair = am.KeyPair(resource_name,
public_key=resource_public_key,
tags=tags_list)
# Update resource dictionary
keypair_ids_dict.update({keypair._name: keypair.id})
# Exporting each KeyPair ID created for future reference
pulumi.export(keypair._name, keypair.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for lambda_name, config in resource_specs.items():
config = config if config else {}
resource_name = lambda_name
resource_tags = config.get("tags")
resource_env = config.get("environment")
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Generating ENV vars
env_list = {}
if resource_env is not None:
for each_env_name, each_env_value in resource_env.items():
env_list.update({each_env_name: each_env_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
lambda_function = lambda_.Function(
lambda_name,
environment=lambda_.FunctionEnvironmentArgs(
variables=env_list),
handler=config.get("handler"),
s3_bucket=config.get("s3_bucket"),
s3_key=config.get("s3_key"),
s3_object_version=config.get("s3_object_version"),
memory_size=config.get("memory_size"),
publish=config.get("publish"),
reserved_concurrent_executions=config.get(
"reserved_concurrent_executions"),
role=IAM.RoleARN()[config.get("role")],
runtime=config.get("runtime"),
timeout=config.get("timeout"),
tags=tags_list)
# Export
pulumi.export(lambda_function._name, lambda_function.id)
# Event source mappings
for mapping_name, mapping_config in config.get(
"event_source_mapping").items():
event_source = mapping_config["event_source"]
assert event_source.get(
"type"
) == "sqs", "Just sqs is currently supported as event source mapping. You're welcome to implement more."
source_arn = SQS.ByName()[event_source["name"]].arn
mapping = lambda_.EventSourceMapping(
mapping_name,
event_source_arn=source_arn,
function_name=lambda_function.arn,
batch_size=mapping_config.get("batch_size"))
pulumi.export(mapping_name, mapping.id)
lambdas_by_name[lambda_name] = lambda_function
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
aws_vpc_id = VPCs.VPCId()
for sg_name, sg_configuration in resource_specs.items():
# AWS Security Groups Dynamic Variables
resource_name = sg_name
resource_description = sg_configuration["description"]
resource_vpc = sg_configuration["vpc"]
resource_ingress_rules = sg_configuration["ingress"]
resource_egress_rules = sg_configuration["egress"]
resource_tags = None
resource_tags = sg_configuration[
"tags"] if "tags" in sg_configuration else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
this_vpc = aws_vpc_id[str(resource_vpc)]
# Empty dictionaries that'll be populated with rules
# coming from each individual security group,
# being ingress or egress
ingress_rules_list = {}
egress_rules_list = {}
# Gathering all ingress rules and return the results
# to the right dictionary defined above
for each_ingress_rule in resource_ingress_rules.items():
for each_ingress_rule_key, each_ingress_rule_value in [
each_ingress_rule
]:
ingress_rules_list.update(
{each_ingress_rule_key: each_ingress_rule_value})
combined_ingress_rules = list(ingress_rules_list.values())
# Gathering all egress rules and return the results
# to the right dictionary defined above
for each_egress_rule in resource_egress_rules.items():
for each_egress_rule_key, each_egress_rule_value in [
each_egress_rule
]:
egress_rules_list.update(
{each_egress_rule_key: each_egress_rule_value})
combined_egress_rules = list(egress_rules_list.values())
# Create Security Group
security_group = net.SecurityGroup(
resource_name,
description=resource_description,
name=resource_name,
vpc_id=this_vpc,
ingress=combined_ingress_rules,
egress=combined_egress_rules,
tags=tags_list)
# Update resource dictionary
sg_ids_dict.update({security_group._name: security_group.id})
# Exporting each security group created for future reference
pulumi.export(security_group._name, security_group.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
aws_subnet_id = Subnets.SubnetId()
aws_sg_id = SecurityGroups.SecurityGroupId()
# aws_keypair_id = KeyPairs.KeyPairId()
for efs_name, efs_configuration in resource_specs.items():
# Resource Name
resource_name = efs_name
# File System Configuration and its Default values
resource_file_system = efs_configuration["file-system"] if "file-system" in efs_configuration else None
resource_file_system_encryption = resource_file_system["encrypted"] if "encrypted" in resource_file_system else True
resource_file_system_performance_mode = resource_file_system["performance_mode"] if "performance_mode" in resource_file_system else "generalPurpose"
# Target Configuration and its Default values
resource_target = efs_configuration["target"] if "target" in efs_configuration else None
resource_target_vpc = resource_target["vpc"] if "vpc" in resource_target else None
resource_target_subnets = resource_target["subnets"] if "subnets" in resource_target else None
resource_target_security_groups = resource_target["security_groups"] if "security_groups" in resource_target else None
# Resource Tags and its Default values
resource_tags = None
resource_tags = efs_configuration["tags"] if "tags" in efs_configuration else None
# Get the list of subnets from the configuration file
# subnets_list = []
# for each_subnet_found in resource_target_subnets:
# this_subnet = aws_subnet_id[str(each_subnet_found)]
# subnets_list.append(this_subnet)
# Getting the list of security groups found
security_groups_list = []
for each_security_group_found in resource_target_security_groups:
this_security_group = aws_sg_id[str(each_security_group_found)]
security_groups_list.append(this_security_group)
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({"Project/Stack": pulumi.get_project() + "/" + pulumi.get_stack()})
tags_list.update(resource_mandatory_tags)
#
# Create EFS Resource
#
# EFS File System
efs_file_system = efs.FileSystem(
resource_name,
encrypted = resource_file_system_encryption,
performance_mode = resource_file_system_performance_mode,
tags = tags_list,
)
# Return a list of all EFSs created
efs_ids_dict.update({efs_file_system._name: efs_file_system.id})
# Create Target(s) based on the number of
# Subnets found in the configuration file
target_index = 0
for each_subnet in resource_target_subnets:
target_index = target_index + 1
this_subnet = aws_subnet_id[str(each_subnet)]
target_name = (resource_name+str("-target-" + str(target_index).zfill(2)))
efs_target = efs.MountTarget(
target_name,
file_system_id = efs_file_system.id,
subnet_id = this_subnet,
security_groups = security_groups_list
)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
aws_vpc_id = VPCs.VPCId()
aws_igw_id = InternetGateways.InternetGatewayId()
aws_natgw_id = NATGateways.NATGatewayId()
aws_subnet_id = Subnets.SubnetId()
for rtb_name, rtb_configuration in resource_specs.items():
# AWS Route Table Variables
resource_name = rtb_name
resource_vpc = rtb_configuration["vpc"]
resource_tags = None
resource_tags = rtb_configuration[
"tags"] if "tags" in rtb_configuration else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
this_vpc = aws_vpc_id[str(resource_vpc)]
#
# Create Route Table
#
aws_rtb = rtb.RouteTable(resource_name,
vpc_id=this_vpc,
tags=tags_list)
rtb_ids_dict.update({aws_rtb._name: aws_rtb.id})
# Export the name of each Route Table
pulumi.export(aws_rtb._name, aws_rtb.id)
#
# Route Table Routes
#
# Routes list
routes_list = []
for each_route_entry, each_route_entry_configuration in rtb_configuration[
"routes"].items():
# NAT Gateways
if each_route_entry_configuration[
"target_type"] == "nat_gateway":
this_natgw = aws_natgw_id[str(
each_route_entry_configuration["target"])]
routes_list.append(
rtb.Route(
(each_route_entry + "-route"),
route_table_id=aws_rtb.id,
destination_cidr_block=
each_route_entry_configuration["destination"],
nat_gateway_id=this_natgw))
# Internet Gateways
elif each_route_entry_configuration[
"target_type"] == "internet_gateway":
this_igw = aws_igw_id[str(
each_route_entry_configuration["target"])]
routes_list.append(
rtb.Route(
(each_route_entry + "-route"),
route_table_id=aws_rtb.id,
destination_cidr_block=
each_route_entry_configuration["destination"],
gateway_id=this_igw), )
else:
print("ERROR | Unsupported 'target_type' found")
for each_route_type in routes_list:
# print(each_route_entry)
rtb_route = (
each_route_type
# opts = pulumi.ResourceOptions(depends_on=[aws_rtb[resource_name]])
)
#
# Subnet Associations
#
# Checking if route-table: key is present
resource_associated_subnet = None
resource_associated_subnet = rtb_configuration[
"associated_subnets"] if "associated_subnets" in rtb_configuration else None
# If the key is present then we'll get the value
# and we'll invoke the association
if resource_associated_subnet is not None:
subnets_count = 0
for each_associated_subnet in resource_associated_subnet:
subnets_count = subnets_count + 1
this_subnet = aws_subnet_id[str(each_associated_subnet)]
route_table_association = rtb.RouteTableAssociation(
(resource_name + "-rtb-as-" +
str(subnets_count).zfill(2)),
subnet_id=this_subnet,
route_table_id=aws_rtb.id)
# Export the name of each Route Table Association
pulumi.export(route_table_association._name,
route_table_association.id)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for sqs_queue_name, sqs_queue_configuration in resource_specs.items():
sqs_queue_configuration = sqs_queue_configuration if sqs_queue_configuration else {}
resource_name = sqs_queue_name
resource_tags = None
resource_tags = sqs_queue_configuration[
"tags"] if "tags" in sqs_queue_configuration else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
fifo_queue = sqs_queue_configuration[
"fifo_queue"] if "fifo_queue" in sqs_queue_configuration else None
content_based_deduplication = sqs_queue_configuration[
"content_based_deduplication"] if "content_based_deduplication" in sqs_queue_configuration else None
delay_seconds = sqs_queue_configuration[
"delay_seconds"] if "delay_seconds" in sqs_queue_configuration else None
max_message_size = sqs_queue_configuration[
"max_message_size_bytes"] if "max_message_size_bytes" in sqs_queue_configuration else None
message_retention_seconds = sqs_queue_configuration[
"message_retention_seconds"] if "message_retention_seconds" in sqs_queue_configuration else None
receive_wait_time_seconds = sqs_queue_configuration[
"receive_wait_time_seconds"] if "receive_wait_time_seconds" in sqs_queue_configuration else None
visibility_timeout_seconds = sqs_queue_configuration[
"visibility_timeout_seconds"] if "visibility_timeout_seconds" in sqs_queue_configuration else None
source_sns_topic_arn = sqs_queue_configuration[
"source_sns_topic_arn"] if "source_sns_topic_arn" in sqs_queue_configuration else None
# Create SQSs
queue = sqs.Queue(
resource_name,
fifo_queue=fifo_queue,
content_based_deduplication=content_based_deduplication,
delay_seconds=delay_seconds,
max_message_size=max_message_size,
message_retention_seconds=message_retention_seconds,
receive_wait_time_seconds=receive_wait_time_seconds,
visibility_timeout_seconds=visibility_timeout_seconds,
tags=tags_list)
sqs_queue_by_name[resource_name] = queue
# Export
pulumi.export(queue._name, queue.id)
if source_sns_topic_arn is not None:
arn = sqs_queue_by_name[resource_name].arn
sqs_policy = iam.get_policy_document(
policy_id="__default_policy_ID",
statements=[
iam.GetPolicyDocumentStatementArgs(
actions=["sqs:SendMessage"],
resources=[arn],
effect="Allow",
principals=[
iam.GetPolicyDocumentStatementPrincipalArgs(
type="Service",
identifiers=["sns.amazonaws.com"])
],
conditions=[
iam.GetPolicyDocumentStatementConditionArgs(
test="ArnEquals",
variable="aws:SourceArn",
values=source_sns_topic_arn,
)
],
)
])
policy = sqs.QueuePolicy(resource_name,
queue_url=queue.id,
policy=sqs_policy.json)
pulumi.export(resource_name + "-policy", policy.policy)
def __init__(self):
resource_specs = ParseYAML(resource_type).getSpecs()
for cloudfront_distribution_name, cloudfront_distribution_configuration in resource_specs.items(
):
cloudfront_distribution_configuration = cloudfront_distribution_configuration if cloudfront_distribution_configuration else {}
resource_name = cloudfront_distribution_name
resource_tags = None
resource_tags = cloudfront_distribution_name[
"tags"] if "tags" in cloudfront_distribution_name else None
# Getting list of tags from configuration file
tags_list = {}
if resource_tags is not None:
for each_tag_name, each_tag_value in resource_tags.items():
tags_list.update({each_tag_name: each_tag_value})
# Adding mandatory tags
tags_list.update({"Name": resource_name})
tags_list.update({
"Project/Stack":
pulumi.get_project() + "/" + pulumi.get_stack()
})
tags_list.update(resource_mandatory_tags)
aliases = cloudfront_distribution_configuration[
"aliases"] if "aliases" in cloudfront_distribution_configuration else None
default_cache_behavior = cloudfront_distribution_configuration[
"default_cache_behavior"] if "default_cache_behavior" in cloudfront_distribution_configuration else None
enabled = cloudfront_distribution_configuration[
"enabled"] if "enabled" in cloudfront_distribution_configuration else None
ordered_cache_behaviors = cloudfront_distribution_configuration[
"ordered_cache_behaviors"] if "ordered_cache_behaviors" in cloudfront_distribution_configuration else None
origins = cloudfront_distribution_configuration[
"origins"] if "origins" in cloudfront_distribution_configuration else None
price_class = cloudfront_distribution_configuration[
"price_class"] if "price_class" in cloudfront_distribution_configuration else None
viewer_certificate = cloudfront_distribution_configuration[
"viewer_certificate"] if "viewer_certificate" in cloudfront_distribution_configuration else None
custom_error_responses = cloudfront_distribution_configuration[
"custom_error_responses"] if "custom_error_responses" in cloudfront_distribution_configuration else None
restrictions = cloudfront_distribution_configuration[
"restrictions"] if "restrictions" in cloudfront_distribution_configuration else {
"geoRestriction": {
"restrictionType": "none"
}
}
# Create Cloudfront Distribution
distribution = cloudfront.Distribution(
resource_name,
aliases=aliases,
default_cache_behavior=default_cache_behavior,
enabled=enabled,
ordered_cache_behaviors=ordered_cache_behaviors,
origins=origins,
price_class=price_class,
viewer_certificate=viewer_certificate,
tags=tags_list,
restrictions=restrictions,
default_root_object="index.html",
custom_error_responses=custom_error_responses,
is_ipv6_enabled=True)
# Export
pulumi.export(distribution._name, distribution.id)