def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
# Import Existing Clouformation Template):
try:
with open(
"stacks_from_cfn/sample_templates/create_s3_bucket_template.json",
mode="r") as file:
cfn_template = json.load(file)
except OSError:
print("Unable to read Cfn Template")
# includes cloudformation template
resoures_from_cfn_template = core.CfnInclude(self,
'konstoneInfra',
template=cfn_template)
# get arn from resource in template
encrypted_bkt_arn = core.Fn.get_att("EncryptedS3Bucket", "Arn")
# Output Arn of encrypted Bucket
output_1 = core.CfnOutput(
self,
"EncryptedBucketArn",
value=f"{encrypted_bkt_arn.to_string()}",
description="Arn of Encrypted Bucket from Cfn Template")
def __init__(self, scope: core.Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
#import from cloud-formation template
try:
with open("import_from_cfn/s3.json", mode="r") as file:
cfn_template = json.load(file)
except OSError:
print("CFN Read error")
import_from_cfn = core.CfnInclude(
self,
"importfromcfn",
template=cfn_template
)
s3_bucket_arn = core.Fn.get_att("S3Bucket", "Arn")
#output
output_s3 = core.CfnOutput(
self,
"s3arnoutput",
value=f"{s3_bucket_arn.to_string()}",
description="arn for s3 from imported cfn"
)
def __init__(self,
scope: cdk.Construct,
id: str,
*,
source_dir: str,
stage_config: Dict,
docker_config: DockerConfig = None,
**kwargs) -> None:
"""
:param str source_dir: Path to Chalice application source code
:param Dict stage_config: Chalice stage configuration.
The configuration object should have the same structure as Chalice JSON
stage configuration.
:param DockerConfig docker_config: If your functions depend on packages
that have natively compiled dependencies, build your functions inside
an AWS Lambda-like Docker container (or your own container).
:raises ChaliceError: Error packaging the application.
"""
super().__init__(scope, id, **kwargs)
self.source_dir = source_dir
self.stage_name = scope.to_string()
self.stage_config = stage_config
self.docker_config = docker_config
self._create_stage_with_config()
sam_package_dir = self._package_app()
sam_template = self._update_sam_template(sam_package_dir)
cdk.CfnInclude(self, 'ChaliceApp', template=sam_template)
def __init__(self, scope: core.Construct, id: str, **kwargs) -> None:
super().__init__(scope, id, **kwargs)
try:
with open("./resources/create_s3_bucket_template.json", "r") as f:
cfn_template = json.load(f)
except OSError:
print("unable to read Cfn Template")
resources_from_cfn = core.CfnInclude(self,
"CustomInfra",
template=cfn_template)
encrypted_bkt_arn = core.Fn.get_att("EncryptedS3Bucket", "Arn")
output1 = core.CfnOutput(self,
"EncryptedS3BucketArn",
value=f"{encrypted_bkt_arn.to_string()}")
def __init__(self, scope: cdk.Construct, id: str, *, source_dir: str, stage_config: dict,
package_config: PackageConfig = None, **kwargs) -> None:
"""
:param str source_dir: Path to Chalice application source code.
:param dict stage_config: Chalice stage configuration.
The configuration object should have the same structure as Chalice JSON
stage configuration.
:param `PackageConfig` package_config: Configuration for packaging the
Chalice application.
:raises `ChaliceError`: Error packaging the Chalice application.
"""
super().__init__(scope, id, **kwargs)
#: Path to Chalice application source code.
self.source_dir = os.path.abspath(source_dir)
#: Chalice stage name.
#: It is automatically assigned the encompassing CDK ``scope``'s name.
self.stage_name = scope.to_string()
#: Chalice stage configuration.
#: The object has the same structure as Chalice JSON stage configuration.
self.stage_config = stage_config
#: :class:`PackageConfig` object.
#: If not provided, :class:`PackageConfig` instance with default arguments is used.
self.package_config = PackageConfig() if package_config is None else package_config
self._create_stage_with_config()
#: Path to directory with output of `chalice package` command.
self.sam_package_dir = self._package_app()
#: AWS SAM template updated with AWS CDK values where applicable.
self.sam_template = self._update_sam_template()
cdk.CfnInclude(self, 'ChaliceApp', template=self.sam_template)
def __init__(
self,
scope: core.Construct,
id: str,
source_directory: Union[Path, str],
stage_config: Optional[dict] = None,
lambda_configs: Optional[dict] = None,
environment: Optional[dict] = None,
**kwargs,
):
"""
Args:
scope: cdk stack or construct
id: identifier
source_directory: the output directory of `chalice package` or the base path of the
chalice codebase
environment: environment variables to apply across lambdas
stage_config: stage-level configuration options i.e. `api_gateway_endpoint_type`
overwrites `dev`
lambda_configs: lambda-level configurations, will be passed to `lambda_functions`
in `dev`
**kwargs:
"""
super().__init__(scope, id, **kwargs)
stage_config = stage_config if stage_config is not None else {}
lambda_configs = lambda_configs if lambda_configs is not None else {}
environment = environment if environment is not None else {}
source_path = Path(source_directory)
if Path(source_path, "app.py").exists():
logging.debug("assuming app has not been packaged")
config_path = Path(source_path, ".chalice", "config.json")
original_config_text = config_path.read_text()
config_data = json.loads(original_config_text)
config_data["stages"]["dev"].update(stage_config)
if lambda_configs:
config_data["stages"]["dev"]["lambda_functions"] = {
**config_data["stages"]["dev"].get("lambda_function", {}),
**lambda_configs,
}
updated_config = json.dumps(config_data, indent=2)
logging.debug(updated_config)
config_path.write_text(updated_config)
output_dir = "chalice.out"
sp.run(f"chalice package {output_dir}", shell=True, check=True)
config_path.write_text(original_config_text)
package_path = Path(output_dir)
else:
package_path = Path(source_directory)
sam_path = Path(package_path, "sam.json")
text = sam_path.read_text()
self.template = json.loads(text)
zip_path = Path(package_path, "deployment.zip")
s3_asset = aws_s3_assets.Asset(self,
"chalice-app-s3-object",
path=zip_path.__fspath__())
for resource_name, resource in self.template["Resources"].items():
if resource["Type"] == "AWS::Serverless::Function":
properties = resource["Properties"]
properties["CodeUri"] = {
"Bucket": s3_asset.s3_bucket_name,
"Key": s3_asset.s3_object_key,
}
properties.setdefault("Environment",
{}).setdefault("Variables",
{}).update(environment)
core.CfnInclude(self, "chalice-app", template=self.template)