aws-cdk-lib 2.159.1__py3-none-any.whl → 2.161.0__py3-none-any.whl

aws_cdk/aws_s3/__init__.py

@@ -183,8 +183,8 @@ To use a bucket in a different stack in the same CDK application, pass the objec
 #
 class Producer(Stack):
 
-    def __init__(self, scope, id, *, description=None, env=None, stackName=None, tags=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None):
-        super().__init__(scope, id, description=description, env=env, stackName=stackName, tags=tags, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation)
+    def __init__(self, scope, id, *, description=None, env=None, stackName=None, tags=None, notificationArns=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None):
+        super().__init__(scope, id, description=description, env=env, stackName=stackName, tags=tags, notificationArns=notificationArns, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation)
 
         bucket = s3.Bucket(self, "MyBucket",
             removal_policy=cdk.RemovalPolicy.DESTROY
@@ -195,8 +195,8 @@ class Producer(Stack):
 # Stack that consumes the bucket
 #
 class Consumer(Stack):
-    def __init__(self, scope, id, *, userBucket, description=None, env=None, stackName=None, tags=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None):
-        super().__init__(scope, id, userBucket=userBucket, description=description, env=env, stackName=stackName, tags=tags, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation)
+    def __init__(self, scope, id, *, userBucket, description=None, env=None, stackName=None, tags=None, notificationArns=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None):
+        super().__init__(scope, id, userBucket=userBucket, description=description, env=env, stackName=stackName, tags=tags, notificationArns=notificationArns, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation)
 
         user = iam.User(self, "MyUser")
         user_bucket.grant_read_write(user)
@@ -9426,13 +9426,15 @@ class CfnBucket(
         ) -> None:
             '''Describes the default server-side encryption to apply to new objects in the bucket.
 
-            If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied. If you don't specify a customer managed key at configuration, Amazon S3 automatically creates an AWS KMS key in your AWS account the first time that you add an object encrypted with SSE-KMS to a bucket. By default, Amazon S3 uses this KMS key for SSE-KMS. For more information, see `PUT Bucket encryption <https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html>`_ in the *Amazon S3 API Reference* .
+            If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied. For more information, see `PutBucketEncryption <https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html>`_ .
             .. epigraph::
 
-               If you're specifying a customer managed KMS key, we recommend using a fully qualified KMS key ARN. If you use a KMS key alias instead, then AWS KMS resolves the key within the requester’s account. This behavior can result in data that's encrypted with a KMS key that belongs to the requester, and not the bucket owner.
+               - *General purpose buckets* - If you don't specify a customer managed key at configuration, Amazon S3 automatically creates an AWS KMS key ( ``aws/s3`` ) in your AWS account the first time that you add an object encrypted with SSE-KMS to a bucket. By default, Amazon S3 uses this KMS key for SSE-KMS.
+               - *Directory buckets* - Your SSE-KMS configuration can only support 1 `customer managed key <https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk>`_ per directory bucket for the lifetime of the bucket. `AWS managed key <https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk>`_ ( ``aws/s3`` ) isn't supported.
+               - *Directory buckets* - For directory buckets, there are only two supported options for server-side encryption: SSE-S3 and SSE-KMS.
 
-            :param sse_algorithm: Server-side encryption algorithm to use for the default encryption.
-            :param kms_master_key_id: AWS Key Management Service (KMS) customer AWS KMS key ID to use for the default encryption. This parameter is allowed if and only if ``SSEAlgorithm`` is set to ``aws:kms`` or ``aws:kms:dsse`` . You can specify the key ID, key alias, or the Amazon Resource Name (ARN) of the KMS key. - Key ID: ``1234abcd-12ab-34cd-56ef-1234567890ab`` - Key ARN: ``arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab`` - Key Alias: ``alias/alias-name`` If you use a key ID, you can run into a LogDestination undeliverable error when creating a VPC flow log. If you are using encryption with cross-account or AWS service operations you must use a fully qualified KMS key ARN. For more information, see `Using encryption for cross-account operations <https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html#bucket-encryption-update-bucket-policy>`_ . .. epigraph:: Amazon S3 only supports symmetric encryption KMS keys. For more information, see `Asymmetric keys in AWS KMS <https://docs.aws.amazon.com//kms/latest/developerguide/symmetric-asymmetric.html>`_ in the *AWS Key Management Service Developer Guide* .
+            :param sse_algorithm: Server-side encryption algorithm to use for the default encryption. .. epigraph:: For directory buckets, there are only two supported values for server-side encryption: ``AES256`` and ``aws:kms`` .
+            :param kms_master_key_id: AWS Key Management Service (KMS) customer managed key ID to use for the default encryption. .. epigraph:: - *General purpose buckets* - This parameter is allowed if and only if ``SSEAlgorithm`` is set to ``aws:kms`` or ``aws:kms:dsse`` . - *Directory buckets* - This parameter is allowed if and only if ``SSEAlgorithm`` is set to ``aws:kms`` . You can specify the key ID, key alias, or the Amazon Resource Name (ARN) of the KMS key. - Key ID: ``1234abcd-12ab-34cd-56ef-1234567890ab`` - Key ARN: ``arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab`` - Key Alias: ``alias/alias-name`` If you are using encryption with cross-account or AWS service operations, you must use a fully qualified KMS key ARN. For more information, see `Using encryption for cross-account operations <https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html#bucket-encryption-update-bucket-policy>`_ . .. epigraph:: - *General purpose buckets* - If you're specifying a customer managed KMS key, we recommend using a fully qualified KMS key ARN. If you use a KMS key alias instead, then AWS KMS resolves the key within the requester’s account. This behavior can result in data that's encrypted with a KMS key that belongs to the requester, and not the bucket owner. Also, if you use a key ID, you can run into a LogDestination undeliverable error when creating a VPC flow log. - *Directory buckets* - When you specify an `AWS KMS customer managed key <https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk>`_ for encryption in your directory bucket, only use the key ID or key ARN. The key alias format of the KMS key isn't supported. > Amazon S3 only supports symmetric encryption KMS keys. For more information, see `Asymmetric keys in AWS KMS <https://docs.aws.amazon.com//kms/latest/developerguide/symmetric-asymmetric.html>`_ in the *AWS Key Management Service Developer Guide* .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionbydefault.html
             :exampleMetadata: fixture=_generated
@@ -9464,6 +9466,10 @@ class CfnBucket(
         def sse_algorithm(self) -> builtins.str:
             '''Server-side encryption algorithm to use for the default encryption.
 
+            .. epigraph::
+
+               For directory buckets, there are only two supported values for server-side encryption: ``AES256`` and ``aws:kms`` .
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionbydefault.html#cfn-s3-bucket-serversideencryptionbydefault-ssealgorithm
             '''
             result = self._values.get("sse_algorithm")
@@ -9472,9 +9478,12 @@ class CfnBucket(
 
         @builtins.property
         def kms_master_key_id(self) -> typing.Optional[builtins.str]:
-            '''AWS Key Management Service (KMS) customer AWS KMS key ID to use for the default encryption.
+            '''AWS Key Management Service (KMS) customer managed key ID to use for the default encryption.
 
-            This parameter is allowed if and only if ``SSEAlgorithm`` is set to ``aws:kms`` or ``aws:kms:dsse`` .
+            .. epigraph::
+
+               - *General purpose buckets* - This parameter is allowed if and only if ``SSEAlgorithm`` is set to ``aws:kms`` or ``aws:kms:dsse`` .
+               - *Directory buckets* - This parameter is allowed if and only if ``SSEAlgorithm`` is set to ``aws:kms`` .
 
             You can specify the key ID, key alias, or the Amazon Resource Name (ARN) of the KMS key.
 
@@ -9482,12 +9491,11 @@ class CfnBucket(
             - Key ARN: ``arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab``
             - Key Alias: ``alias/alias-name``
 
-            If you use a key ID, you can run into a LogDestination undeliverable error when creating a VPC flow log.
-
-            If you are using encryption with cross-account or AWS service operations you must use a fully qualified KMS key ARN. For more information, see `Using encryption for cross-account operations <https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html#bucket-encryption-update-bucket-policy>`_ .
+            If you are using encryption with cross-account or AWS service operations, you must use a fully qualified KMS key ARN. For more information, see `Using encryption for cross-account operations <https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-encryption.html#bucket-encryption-update-bucket-policy>`_ .
             .. epigraph::
 
-               Amazon S3 only supports symmetric encryption KMS keys. For more information, see `Asymmetric keys in AWS KMS <https://docs.aws.amazon.com//kms/latest/developerguide/symmetric-asymmetric.html>`_ in the *AWS Key Management Service Developer Guide* .
+               - *General purpose buckets* - If you're specifying a customer managed KMS key, we recommend using a fully qualified KMS key ARN. If you use a KMS key alias instead, then AWS KMS resolves the key within the requester’s account. This behavior can result in data that's encrypted with a KMS key that belongs to the requester, and not the bucket owner. Also, if you use a key ID, you can run into a LogDestination undeliverable error when creating a VPC flow log.
+               - *Directory buckets* - When you specify an `AWS KMS customer managed key <https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk>`_ for encryption in your directory bucket, only use the key ID or key ARN. The key alias format of the KMS key isn't supported. > Amazon S3 only supports symmetric encryption KMS keys. For more information, see `Asymmetric keys in AWS KMS <https://docs.aws.amazon.com//kms/latest/developerguide/symmetric-asymmetric.html>`_ in the *AWS Key Management Service Developer Guide* .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionbydefault.html#cfn-s3-bucket-serversideencryptionbydefault-kmsmasterkeyid
             '''
@@ -9524,7 +9532,8 @@ class CfnBucket(
 
             .. epigraph::
 
-               If you're specifying a customer managed KMS key, we recommend using a fully qualified KMS key ARN. If you use a KMS key alias instead, then AWS KMS resolves the key within the requester’s account. This behavior can result in data that's encrypted with a KMS key that belongs to the requester, and not the bucket owner.
+               - *General purpose buckets* - If you're specifying a customer managed KMS key, we recommend using a fully qualified KMS key ARN. If you use a KMS key alias instead, then AWS KMS resolves the key within the requester’s account. This behavior can result in data that's encrypted with a KMS key that belongs to the requester, and not the bucket owner.
+               - *Directory buckets* - When you specify an `AWS KMS customer managed key <https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk>`_ for encryption in your directory bucket, only use the key ID or key ARN. The key alias format of the KMS key isn't supported.
 
             :param bucket_key_enabled: Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the ``BucketKeyEnabled`` element to ``true`` causes Amazon S3 to use an S3 Bucket Key. By default, S3 Bucket Key is not enabled. For more information, see `Amazon S3 Bucket Keys <https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html>`_ in the *Amazon S3 User Guide* .
             :param server_side_encryption_by_default: Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.

aws_cdk/aws_s3_deployment/__init__.py

@@ -478,6 +478,27 @@ cdk.CfnOutput(self, "ObjectKey",
 )
 ```
 
+## Controlling the Output of Source Object Keys
+
+By default, the keys of the source objects copied to the destination bucket are returned in the Data property of the custom resource. However, you can disable this behavior by setting the outputObjectKeys property to false. This is particularly useful when the number of objects is too large and might exceed the size limit of the responseData property.
+
+```python
+import aws_cdk as cdk
+
+# destination_bucket: s3.Bucket
+
+
+my_bucket_deployment = s3deploy.BucketDeployment(self, "DeployMeWithoutExtractingFilesOnDestination",
+    sources=[s3deploy.Source.asset(path.join(__dirname, "my-website"))],
+    destination_bucket=destination_bucket,
+    output_object_keys=False
+)
+
+cdk.CfnOutput(self, "ObjectKey",
+    value=cdk.Fn.select(0, my_bucket_deployment.object_keys)
+)
+```
+
 ## Notes
 
 * This library uses an AWS CloudFormation custom resource which is about 10MiB in
@@ -619,6 +640,7 @@ class BucketDeployment(
         log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
         memory_limit: typing.Optional[jsii.Number] = None,
         metadata: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        output_object_keys: typing.Optional[builtins.bool] = None,
         prune: typing.Optional[builtins.bool] = None,
         retain_on_delete: typing.Optional[builtins.bool] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
@@ -655,6 +677,7 @@ class BucketDeployment(
         :param log_retention: The number of days that the lambda function's log events are kept in CloudWatch Logs. This is a legacy API and we strongly recommend you migrate to ``logGroup`` if you can. ``logGroup`` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it. Default: logs.RetentionDays.INFINITE
         :param memory_limit: The amount of memory (in MiB) to allocate to the AWS Lambda function which replicates the files from the CDK bucket to the destination bucket. If you are deploying large files, you will need to increase this number accordingly. Default: 128
         :param metadata: User-defined object metadata to be set on all objects in the deployment. Default: - No user metadata is set
+        :param output_object_keys: If set to false, the custom resource will not send back the SourceObjectKeys. This is useful when you are facing the error ``Response object is too long`` See https://github.com/aws/aws-cdk/issues/28579 Default: true
         :param prune: If this is set to false, files in the destination bucket that do not exist in the asset, will NOT be deleted during deployment (create/update). Default: true
         :param retain_on_delete: If this is set to "false", the destination files will be deleted when the resource is deleted or the destination is updated. NOTICE: Configuring this to "false" might have operational implications. Please visit to the package documentation referred below to make sure you fully understand those implications. Default: true - when resource is deleted/updated, files are retained
         :param role: Execution role associated with this function. Default: - A role is automatically created
@@ -693,6 +716,7 @@ class BucketDeployment(
             log_retention=log_retention,
             memory_limit=memory_limit,
             metadata=metadata,
+            output_object_keys=output_object_keys,
             prune=prune,
             retain_on_delete=retain_on_delete,
             role=role,
@@ -793,6 +817,7 @@ class BucketDeployment(
         "log_retention": "logRetention",
         "memory_limit": "memoryLimit",
         "metadata": "metadata",
+        "output_object_keys": "outputObjectKeys",
         "prune": "prune",
         "retain_on_delete": "retainOnDelete",
         "role": "role",
@@ -831,6 +856,7 @@ class BucketDeploymentProps:
         log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
         memory_limit: typing.Optional[jsii.Number] = None,
         metadata: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        output_object_keys: typing.Optional[builtins.bool] = None,
         prune: typing.Optional[builtins.bool] = None,
         retain_on_delete: typing.Optional[builtins.bool] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
@@ -866,6 +892,7 @@ class BucketDeploymentProps:
         :param log_retention: The number of days that the lambda function's log events are kept in CloudWatch Logs. This is a legacy API and we strongly recommend you migrate to ``logGroup`` if you can. ``logGroup`` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it. Default: logs.RetentionDays.INFINITE
         :param memory_limit: The amount of memory (in MiB) to allocate to the AWS Lambda function which replicates the files from the CDK bucket to the destination bucket. If you are deploying large files, you will need to increase this number accordingly. Default: 128
         :param metadata: User-defined object metadata to be set on all objects in the deployment. Default: - No user metadata is set
+        :param output_object_keys: If set to false, the custom resource will not send back the SourceObjectKeys. This is useful when you are facing the error ``Response object is too long`` See https://github.com/aws/aws-cdk/issues/28579 Default: true
         :param prune: If this is set to false, files in the destination bucket that do not exist in the asset, will NOT be deleted during deployment (create/update). Default: true
         :param retain_on_delete: If this is set to "false", the destination files will be deleted when the resource is deleted or the destination is updated. NOTICE: Configuring this to "false" might have operational implications. Please visit to the package documentation referred below to make sure you fully understand those implications. Default: true - when resource is deleted/updated, files are retained
         :param role: Execution role associated with this function. Default: - A role is automatically created
@@ -922,6 +949,7 @@ class BucketDeploymentProps:
             check_type(argname="argument log_retention", value=log_retention, expected_type=type_hints["log_retention"])
             check_type(argname="argument memory_limit", value=memory_limit, expected_type=type_hints["memory_limit"])
             check_type(argname="argument metadata", value=metadata, expected_type=type_hints["metadata"])
+            check_type(argname="argument output_object_keys", value=output_object_keys, expected_type=type_hints["output_object_keys"])
             check_type(argname="argument prune", value=prune, expected_type=type_hints["prune"])
             check_type(argname="argument retain_on_delete", value=retain_on_delete, expected_type=type_hints["retain_on_delete"])
             check_type(argname="argument role", value=role, expected_type=type_hints["role"])
@@ -974,6 +1002,8 @@ class BucketDeploymentProps:
             self._values["memory_limit"] = memory_limit
         if metadata is not None:
             self._values["metadata"] = metadata
+        if output_object_keys is not None:
+            self._values["output_object_keys"] = output_object_keys
         if prune is not None:
             self._values["prune"] = prune
         if retain_on_delete is not None:
@@ -1220,6 +1250,19 @@ class BucketDeploymentProps:
         result = self._values.get("metadata")
         return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
+    @builtins.property
+    def output_object_keys(self) -> typing.Optional[builtins.bool]:
+        '''If set to false, the custom resource will not send back the SourceObjectKeys.
+
+        This is useful when you are facing the error ``Response object is too long``
+
+        See https://github.com/aws/aws-cdk/issues/28579
+
+        :default: true
+        '''
+        result = self._values.get("output_object_keys")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def prune(self) -> typing.Optional[builtins.bool]:
         '''If this is set to false, files in the destination bucket that do not exist in the asset, will NOT be deleted during deployment (create/update).
@@ -2253,6 +2296,7 @@ def _typecheckingstub__2544491e92aa50a255b927ef16b9cde2961eae48803afca3b5d1105bf
     log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
     memory_limit: typing.Optional[jsii.Number] = None,
     metadata: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    output_object_keys: typing.Optional[builtins.bool] = None,
     prune: typing.Optional[builtins.bool] = None,
     retain_on_delete: typing.Optional[builtins.bool] = None,
     role: typing.Optional[_IRole_235f5d8e] = None,
@@ -2297,6 +2341,7 @@ def _typecheckingstub__cbabf07e8b4adfb2b2058c075c4f35512ebc580f80a6db9bf13e90589
     log_retention: typing.Optional[_RetentionDays_070f99f0] = None,
     memory_limit: typing.Optional[jsii.Number] = None,
     metadata: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    output_object_keys: typing.Optional[builtins.bool] = None,
     prune: typing.Optional[builtins.bool] = None,
     retain_on_delete: typing.Optional[builtins.bool] = None,
     role: typing.Optional[_IRole_235f5d8e] = None,