aws-cdk-lib 2.186.0__py3-none-any.whl → 2.188.0__py3-none-any.whl

aws_cdk/aws_ecr/__init__.py

@@ -220,6 +220,26 @@ repository.add_to_resource_policy(iam.PolicyStatement(
 ))
 ```
 
+## import existing repository
+
+You can import an existing repository into your CDK app using the `Repository.fromRepositoryArn`, `Repository.fromRepositoryName` or `Repository.fromLookup` method.
+These methods take the ARN or the name of the repository and returns an `IRepository` object.
+
+```python
+# import using repository name
+repository_from_name = ecr.Repository.from_repository_name(self, "ImportedRepoByName", "my-repo-name")
+
+# import using repository ARN
+repository_from_arn = ecr.Repository.from_repository_arn(self, "ImportedRepoByArn", "arn:aws:ecr:us-east-1:123456789012:repository/my-repo-name")
+
+# import using repository lookup
+# You have to provide either `repositoryArn` or `repositoryName` to lookup the repository
+repository_from_lookup = ecr.Repository.from_lookup(self, "ImportedRepoByLookup",
+    repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/my-repo-name",
+    repository_name="my-repo-name"
+)
+```
+
 ## CloudWatch event rules
 
 You can publish repository events to a CloudWatch event rule with `onEvent`:
@@ -4592,6 +4612,83 @@ class RepositoryEncryption(
         return typing.cast(builtins.str, jsii.get(self, "value"))
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecr.RepositoryLookupOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "repository_arn": "repositoryArn",
+        "repository_name": "repositoryName",
+    },
+)
+class RepositoryLookupOptions:
+    def __init__(
+        self,
+        *,
+        repository_arn: typing.Optional[builtins.str] = None,
+        repository_name: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Properties for looking up an existing Repository.
+
+        :param repository_arn: The ARN of the repository. Default: - Do not filter on repository ARN
+        :param repository_name: The name of the repository. Default: - Do not filter on repository name
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # import using repository name
+            repository_from_name = ecr.Repository.from_repository_name(self, "ImportedRepoByName", "my-repo-name")
+            
+            # import using repository ARN
+            repository_from_arn = ecr.Repository.from_repository_arn(self, "ImportedRepoByArn", "arn:aws:ecr:us-east-1:123456789012:repository/my-repo-name")
+            
+            # import using repository lookup
+            # You have to provide either `repositoryArn` or `repositoryName` to lookup the repository
+            repository_from_lookup = ecr.Repository.from_lookup(self, "ImportedRepoByLookup",
+                repository_arn="arn:aws:ecr:us-east-1:123456789012:repository/my-repo-name",
+                repository_name="my-repo-name"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a658f6a6920e4ade279233d8cf708713d19d0c9d50f843184a34d0f926b41442)
+            check_type(argname="argument repository_arn", value=repository_arn, expected_type=type_hints["repository_arn"])
+            check_type(argname="argument repository_name", value=repository_name, expected_type=type_hints["repository_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if repository_arn is not None:
+            self._values["repository_arn"] = repository_arn
+        if repository_name is not None:
+            self._values["repository_name"] = repository_name
+
+    @builtins.property
+    def repository_arn(self) -> typing.Optional[builtins.str]:
+        '''The ARN of the repository.
+
+        :default: - Do not filter on repository ARN
+        '''
+        result = self._values.get("repository_arn")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def repository_name(self) -> typing.Optional[builtins.str]:
+        '''The name of the repository.
+
+        :default: - Do not filter on repository name
+        '''
+        result = self._values.get("repository_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "RepositoryLookupOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_ecr.RepositoryProps",
     jsii_struct_bases=[],
@@ -4929,6 +5026,33 @@ class Repository(
             check_type(argname="argument account", value=account, expected_type=type_hints["account"])
         return typing.cast(builtins.str, jsii.sinvoke(cls, "arnForLocalRepository", [repository_name, scope, account]))
 
+    @jsii.member(jsii_name="fromLookup")
+    @builtins.classmethod
+    def from_lookup(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        repository_arn: typing.Optional[builtins.str] = None,
+        repository_name: typing.Optional[builtins.str] = None,
+    ) -> IRepository:
+        '''Lookup an existing repository.
+
+        :param scope: -
+        :param id: -
+        :param repository_arn: The ARN of the repository. Default: - Do not filter on repository ARN
+        :param repository_name: The name of the repository. Default: - Do not filter on repository name
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d54cc6352f8c9a17166980b2836dc621d78b7af64b87c2ed63ad8a9c274f3591)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        options = RepositoryLookupOptions(
+            repository_arn=repository_arn, repository_name=repository_name
+        )
+
+        return typing.cast(IRepository, jsii.sinvoke(cls, "fromLookup", [scope, id, options]))
+
     @jsii.member(jsii_name="fromRepositoryArn")
     @builtins.classmethod
     def from_repository_arn(
@@ -5087,6 +5211,7 @@ __all__ = [
     "RepositoryAttributes",
     "RepositoryBase",
     "RepositoryEncryption",
+    "RepositoryLookupOptions",
     "RepositoryProps",
     "TagMutability",
     "TagStatus",
@@ -5840,6 +5965,14 @@ def _typecheckingstub__144b557444508fc0a954f4a654cd03105778da2972bab34f799be4e54
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a658f6a6920e4ade279233d8cf708713d19d0c9d50f843184a34d0f926b41442(
+    *,
+    repository_arn: typing.Optional[builtins.str] = None,
+    repository_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__638b63dd5eb589e01019ee47c63d6335810d02b0d769f767f2bf2fddc285af28(
     *,
     auto_delete_images: typing.Optional[builtins.bool] = None,
@@ -5882,6 +6015,16 @@ def _typecheckingstub__50aa60495dfd0ac59e7bbbb1d22e4d7dd496bad018fa9790d09cb317d
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d54cc6352f8c9a17166980b2836dc621d78b7af64b87c2ed63ad8a9c274f3591(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    repository_arn: typing.Optional[builtins.str] = None,
+    repository_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__eb580f927f8776b0abfc35ebe773b5e9b7f5332fd46fd5a456e0b23e497c660e(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,

aws_cdk/aws_ecr_assets/__init__.py

@@ -14,7 +14,10 @@ from aws_cdk.aws_ecr_assets import DockerImageAsset
 
 
 asset = DockerImageAsset(self, "MyBuildImage",
-    directory=path.join(__dirname, "my-image")
+    directory=path.join(__dirname, "my-image"),
+
+    # Optional: describe the purpose of the asset with a human-readable string
+    display_name="Source for my function"
 )
 ```
 
@@ -395,6 +398,7 @@ class DockerImageAsset(
         cache_disabled: typing.Optional[builtins.bool] = None,
         cache_from: typing.Optional[typing.Sequence[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]]] = None,
         cache_to: typing.Optional[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]] = None,
+        display_name: typing.Optional[builtins.str] = None,
         file: typing.Optional[builtins.str] = None,
         invalidation: typing.Optional[typing.Union["DockerImageAssetInvalidationOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         network_mode: typing.Optional["NetworkMode"] = None,
@@ -417,6 +421,7 @@ class DockerImageAsset(
         :param cache_disabled: Disable the cache and pass ``--no-cache`` to the ``docker build`` command. Default: - cache is used
         :param cache_from: Cache from options to pass to the ``docker build`` command. Default: - no cache from options are passed to the build command
         :param cache_to: Cache to options to pass to the ``docker build`` command. Default: - no cache to options are passed to the build command
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. If the same asset is added multiple times, the display name of the first occurrence is used. If ``assetName`` is given, it will also be used as the default ``displayName``. Otherwise, the default is the construct path of the ImageAsset construct, with respect to the enclosing stack. If the asset is produced by a construct helper function (such as ``lambda.Code.fromAssetImage()``), this will look like ``MyFunction/AssetImage``. We use the stack-relative construct path so that in the common case where you have multiple stacks with the same asset, we won't show something like ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to production. Default: - Stack-relative construct path
         :param file: Path to the Dockerfile (relative to the directory). Default: 'Dockerfile'
         :param invalidation: Options to control which parameters are used to invalidate the asset hash. Default: - hash all parameters
         :param network_mode: Networking mode for the RUN commands during build. Support docker API 1.25+. Default: - no networking mode specified (the default networking mode ``NetworkMode.DEFAULT`` will be used)
@@ -441,6 +446,7 @@ class DockerImageAsset(
             cache_disabled=cache_disabled,
             cache_from=cache_from,
             cache_to=cache_to,
+            display_name=display_name,
             file=file,
             invalidation=invalidation,
             network_mode=network_mode,
@@ -744,6 +750,7 @@ class DockerImageAssetInvalidationOptions:
         "cache_disabled": "cacheDisabled",
         "cache_from": "cacheFrom",
         "cache_to": "cacheTo",
+        "display_name": "displayName",
         "file": "file",
         "invalidation": "invalidation",
         "network_mode": "networkMode",
@@ -767,6 +774,7 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
         cache_disabled: typing.Optional[builtins.bool] = None,
         cache_from: typing.Optional[typing.Sequence[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]]] = None,
         cache_to: typing.Optional[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]] = None,
+        display_name: typing.Optional[builtins.str] = None,
         file: typing.Optional[builtins.str] = None,
         invalidation: typing.Optional[typing.Union[DockerImageAssetInvalidationOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         network_mode: typing.Optional["NetworkMode"] = None,
@@ -787,6 +795,7 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
         :param cache_disabled: Disable the cache and pass ``--no-cache`` to the ``docker build`` command. Default: - cache is used
         :param cache_from: Cache from options to pass to the ``docker build`` command. Default: - no cache from options are passed to the build command
         :param cache_to: Cache to options to pass to the ``docker build`` command. Default: - no cache to options are passed to the build command
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. If the same asset is added multiple times, the display name of the first occurrence is used. If ``assetName`` is given, it will also be used as the default ``displayName``. Otherwise, the default is the construct path of the ImageAsset construct, with respect to the enclosing stack. If the asset is produced by a construct helper function (such as ``lambda.Code.fromAssetImage()``), this will look like ``MyFunction/AssetImage``. We use the stack-relative construct path so that in the common case where you have multiple stacks with the same asset, we won't show something like ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to production. Default: - Stack-relative construct path
         :param file: Path to the Dockerfile (relative to the directory). Default: 'Dockerfile'
         :param invalidation: Options to control which parameters are used to invalidate the asset hash. Default: - hash all parameters
         :param network_mode: Networking mode for the RUN commands during build. Support docker API 1.25+. Default: - no networking mode specified (the default networking mode ``NetworkMode.DEFAULT`` will be used)
@@ -832,6 +841,7 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
                         "params_key": "params"
                     }
                 ),
+                display_name="displayName",
                 exclude=["exclude"],
                 extra_hash="extraHash",
                 file="file",
@@ -872,6 +882,7 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
             check_type(argname="argument cache_disabled", value=cache_disabled, expected_type=type_hints["cache_disabled"])
             check_type(argname="argument cache_from", value=cache_from, expected_type=type_hints["cache_from"])
             check_type(argname="argument cache_to", value=cache_to, expected_type=type_hints["cache_to"])
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
             check_type(argname="argument file", value=file, expected_type=type_hints["file"])
             check_type(argname="argument invalidation", value=invalidation, expected_type=type_hints["invalidation"])
             check_type(argname="argument network_mode", value=network_mode, expected_type=type_hints["network_mode"])
@@ -901,6 +912,8 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
             self._values["cache_from"] = cache_from
         if cache_to is not None:
             self._values["cache_to"] = cache_to
+        if display_name is not None:
+            self._values["display_name"] = display_name
         if file is not None:
             self._values["file"] = file
         if invalidation is not None:
@@ -1045,6 +1058,31 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
         result = self._values.get("cache_to")
         return typing.cast(typing.Optional[DockerCacheOption], result)
 
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name for this asset.
+
+        If supplied, the display name will be used in locations where the asset
+        identifier is printed, like in the CLI progress information. If the same
+        asset is added multiple times, the display name of the first occurrence is
+        used.
+
+        If ``assetName`` is given, it will also be used as the default ``displayName``.
+        Otherwise, the default is the construct path of the ImageAsset construct,
+        with respect to the enclosing stack. If the asset is produced by a
+        construct helper function (such as ``lambda.Code.fromAssetImage()``), this
+        will look like ``MyFunction/AssetImage``.
+
+        We use the stack-relative construct path so that in the common case where
+        you have multiple stacks with the same asset, we won't show something like
+        ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to
+        production.
+
+        :default: - Stack-relative construct path
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def file(self) -> typing.Optional[builtins.str]:
         '''Path to the Dockerfile (relative to the directory).
@@ -1132,6 +1170,7 @@ class DockerImageAssetOptions(_FileFingerprintOptions_115b8b51):
         "cache_disabled": "cacheDisabled",
         "cache_from": "cacheFrom",
         "cache_to": "cacheTo",
+        "display_name": "displayName",
         "file": "file",
         "invalidation": "invalidation",
         "network_mode": "networkMode",
@@ -1156,6 +1195,7 @@ class DockerImageAssetProps(DockerImageAssetOptions):
         cache_disabled: typing.Optional[builtins.bool] = None,
         cache_from: typing.Optional[typing.Sequence[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]]] = None,
         cache_to: typing.Optional[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]] = None,
+        display_name: typing.Optional[builtins.str] = None,
         file: typing.Optional[builtins.str] = None,
         invalidation: typing.Optional[typing.Union[DockerImageAssetInvalidationOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         network_mode: typing.Optional["NetworkMode"] = None,
@@ -1177,6 +1217,7 @@ class DockerImageAssetProps(DockerImageAssetOptions):
         :param cache_disabled: Disable the cache and pass ``--no-cache`` to the ``docker build`` command. Default: - cache is used
         :param cache_from: Cache from options to pass to the ``docker build`` command. Default: - no cache from options are passed to the build command
         :param cache_to: Cache to options to pass to the ``docker build`` command. Default: - no cache to options are passed to the build command
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. If the same asset is added multiple times, the display name of the first occurrence is used. If ``assetName`` is given, it will also be used as the default ``displayName``. Otherwise, the default is the construct path of the ImageAsset construct, with respect to the enclosing stack. If the asset is produced by a construct helper function (such as ``lambda.Code.fromAssetImage()``), this will look like ``MyFunction/AssetImage``. We use the stack-relative construct path so that in the common case where you have multiple stacks with the same asset, we won't show something like ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to production. Default: - Stack-relative construct path
         :param file: Path to the Dockerfile (relative to the directory). Default: 'Dockerfile'
         :param invalidation: Options to control which parameters are used to invalidate the asset hash. Default: - hash all parameters
         :param network_mode: Networking mode for the RUN commands during build. Support docker API 1.25+. Default: - no networking mode specified (the default networking mode ``NetworkMode.DEFAULT`` will be used)
@@ -1219,6 +1260,7 @@ class DockerImageAssetProps(DockerImageAssetOptions):
             check_type(argname="argument cache_disabled", value=cache_disabled, expected_type=type_hints["cache_disabled"])
             check_type(argname="argument cache_from", value=cache_from, expected_type=type_hints["cache_from"])
             check_type(argname="argument cache_to", value=cache_to, expected_type=type_hints["cache_to"])
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
             check_type(argname="argument file", value=file, expected_type=type_hints["file"])
             check_type(argname="argument invalidation", value=invalidation, expected_type=type_hints["invalidation"])
             check_type(argname="argument network_mode", value=network_mode, expected_type=type_hints["network_mode"])
@@ -1251,6 +1293,8 @@ class DockerImageAssetProps(DockerImageAssetOptions):
             self._values["cache_from"] = cache_from
         if cache_to is not None:
             self._values["cache_to"] = cache_to
+        if display_name is not None:
+            self._values["display_name"] = display_name
         if file is not None:
             self._values["file"] = file
         if invalidation is not None:
@@ -1395,6 +1439,31 @@ class DockerImageAssetProps(DockerImageAssetOptions):
         result = self._values.get("cache_to")
         return typing.cast(typing.Optional[DockerCacheOption], result)
 
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name for this asset.
+
+        If supplied, the display name will be used in locations where the asset
+        identifier is printed, like in the CLI progress information. If the same
+        asset is added multiple times, the display name of the first occurrence is
+        used.
+
+        If ``assetName`` is given, it will also be used as the default ``displayName``.
+        Otherwise, the default is the construct path of the ImageAsset construct,
+        with respect to the enclosing stack. If the asset is produced by a
+        construct helper function (such as ``lambda.Code.fromAssetImage()``), this
+        will look like ``MyFunction/AssetImage``.
+
+        We use the stack-relative construct path so that in the common case where
+        you have multiple stacks with the same asset, we won't show something like
+        ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to
+        production.
+
+        :default: - Stack-relative construct path
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def file(self) -> typing.Optional[builtins.str]:
         '''Path to the Dockerfile (relative to the directory).
@@ -1622,17 +1691,21 @@ class TarballImageAsset(
         id: builtins.str,
         *,
         tarball_file: builtins.str,
+        display_name: typing.Optional[builtins.str] = None,
     ) -> None:
         '''
         :param scope: -
         :param id: -
         :param tarball_file: Absolute path to the tarball. It is recommended to to use the script running directory (e.g. ``__dirname`` in Node.js projects or dirname of ``__file__`` in Python) if your tarball is located as a resource inside your project.
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. If the same asset is added multiple times, the display name of the first occurrence is used. The default is the construct path of the ``TarballImageAsset`` construct, with respect to the enclosing stack. If the asset is produced by a construct helper function (such as ``lambda.Code.fromAssetImage()``), this will look like ``MyFunction/AssetImage``. We use the stack-relative construct path so that in the common case where you have multiple stacks with the same asset, we won't show something like ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to production. Default: - Stack-relative construct path
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__3e0eaaf11f2e3e296d6157cf12d477a55316a9aefb390c2f9de1711f911d5450)
             check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
-        props = TarballImageAssetProps(tarball_file=tarball_file)
+        props = TarballImageAssetProps(
+            tarball_file=tarball_file, display_name=display_name
+        )
 
         jsii.create(self.__class__, self, [scope, id, props])
 
@@ -1690,13 +1763,19 @@ class TarballImageAsset(
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_ecr_assets.TarballImageAssetProps",
     jsii_struct_bases=[],
-    name_mapping={"tarball_file": "tarballFile"},
+    name_mapping={"tarball_file": "tarballFile", "display_name": "displayName"},
 )
 class TarballImageAssetProps:
-    def __init__(self, *, tarball_file: builtins.str) -> None:
+    def __init__(
+        self,
+        *,
+        tarball_file: builtins.str,
+        display_name: typing.Optional[builtins.str] = None,
+    ) -> None:
         '''Options for TarballImageAsset.
 
         :param tarball_file: Absolute path to the tarball. It is recommended to to use the script running directory (e.g. ``__dirname`` in Node.js projects or dirname of ``__file__`` in Python) if your tarball is located as a resource inside your project.
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. If the same asset is added multiple times, the display name of the first occurrence is used. The default is the construct path of the ``TarballImageAsset`` construct, with respect to the enclosing stack. If the asset is produced by a construct helper function (such as ``lambda.Code.fromAssetImage()``), this will look like ``MyFunction/AssetImage``. We use the stack-relative construct path so that in the common case where you have multiple stacks with the same asset, we won't show something like ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to production. Default: - Stack-relative construct path
 
         :exampleMetadata: infused
 
@@ -1712,9 +1791,12 @@ class TarballImageAssetProps:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__1555ea2241a0a5236409111ebbad425ecc370ebc8987c4a7871719d32389658b)
             check_type(argname="argument tarball_file", value=tarball_file, expected_type=type_hints["tarball_file"])
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "tarball_file": tarball_file,
         }
+        if display_name is not None:
+            self._values["display_name"] = display_name
 
     @builtins.property
     def tarball_file(self) -> builtins.str:
@@ -1728,6 +1810,30 @@ class TarballImageAssetProps:
         assert result is not None, "Required property 'tarball_file' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name for this asset.
+
+        If supplied, the display name will be used in locations where the asset
+        identifier is printed, like in the CLI progress information. If the same
+        asset is added multiple times, the display name of the first occurrence is
+        used.
+
+        The default is the construct path of the ``TarballImageAsset`` construct,
+        with respect to the enclosing stack. If the asset is produced by a
+        construct helper function (such as ``lambda.Code.fromAssetImage()``), this
+        will look like ``MyFunction/AssetImage``.
+
+        We use the stack-relative construct path so that in the common case where
+        you have multiple stacks with the same asset, we won't show something like
+        ``/MyBetaStack/MyFunction/Code`` when you are actually deploying to
+        production.
+
+        :default: - Stack-relative construct path
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -1774,6 +1880,7 @@ def _typecheckingstub__797fbc31925afd247c6567a5b5c30dcdc13a3d9b17aba80ece42c86bd
     cache_disabled: typing.Optional[builtins.bool] = None,
     cache_from: typing.Optional[typing.Sequence[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]]] = None,
     cache_to: typing.Optional[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]] = None,
+    display_name: typing.Optional[builtins.str] = None,
     file: typing.Optional[builtins.str] = None,
     invalidation: typing.Optional[typing.Union[DockerImageAssetInvalidationOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     network_mode: typing.Optional[NetworkMode] = None,
@@ -1836,6 +1943,7 @@ def _typecheckingstub__be58b9ab6157641d31b553709d8decad6c9801460bec8e3ff07aadc33
     cache_disabled: typing.Optional[builtins.bool] = None,
     cache_from: typing.Optional[typing.Sequence[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]]] = None,
     cache_to: typing.Optional[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]] = None,
+    display_name: typing.Optional[builtins.str] = None,
     file: typing.Optional[builtins.str] = None,
     invalidation: typing.Optional[typing.Union[DockerImageAssetInvalidationOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     network_mode: typing.Optional[NetworkMode] = None,
@@ -1859,6 +1967,7 @@ def _typecheckingstub__1abde6bc94231492c7b40171b32143e7c5533e907120fe3e3c2ebeca2
     cache_disabled: typing.Optional[builtins.bool] = None,
     cache_from: typing.Optional[typing.Sequence[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]]] = None,
     cache_to: typing.Optional[typing.Union[DockerCacheOption, typing.Dict[builtins.str, typing.Any]]] = None,
+    display_name: typing.Optional[builtins.str] = None,
     file: typing.Optional[builtins.str] = None,
     invalidation: typing.Optional[typing.Union[DockerImageAssetInvalidationOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     network_mode: typing.Optional[NetworkMode] = None,
@@ -1893,6 +2002,7 @@ def _typecheckingstub__3e0eaaf11f2e3e296d6157cf12d477a55316a9aefb390c2f9de1711f9
     id: builtins.str,
     *,
     tarball_file: builtins.str,
+    display_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -1912,6 +2022,7 @@ def _typecheckingstub__ccb91ed092745a33fafd3df8d94f545ae143be6b4949103c115bc7135
 def _typecheckingstub__1555ea2241a0a5236409111ebbad425ecc370ebc8987c4a7871719d32389658b(
     *,
     tarball_file: builtins.str,
+    display_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass