AWS CDK Reference

Appearance

v2.274.0

AssetImage Class ​

An image that will be built from a local directory with a Dockerfile.

Source
aws-ecs/lib/images/asset-image.ts

Example ​

ts
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import * as cdk from 'aws-cdk-lib';
import { aws_ecr_assets as ecr_assets } from 'aws-cdk-lib';
import { aws_ecs as ecs } from 'aws-cdk-lib';

declare const networkMode: ecr_assets.NetworkMode;
declare const platform: ecr_assets.Platform;
const assetImage = ecs.AssetImage.fromAsset('directory', /* all optional props */ {
  assetName: 'assetName',
  buildArgs: {
    buildArgsKey: 'buildArgs',
  },
  buildContexts: {
    buildContextsKey: 'buildContexts',
  },
  buildSecrets: {
    buildSecretsKey: 'buildSecrets',
  },
  buildSsh: 'buildSsh',
  cacheDisabled: false,
  cacheFrom: [{
    type: 'type',

    // the properties below are optional
    params: {
      paramsKey: 'params',
    },
  }],
  cacheTo: {
    type: 'type',

    // the properties below are optional
    params: {
      paramsKey: 'params',
    },
  },
  displayName: 'displayName',
  exclude: ['exclude'],
  extraHash: 'extraHash',
  file: 'file',
  followSymlinks: cdk.SymlinkFollowMode.NEVER,
  ignoreMode: cdk.IgnoreMode.GLOB,
  invalidation: {
    buildArgs: false,
    buildContexts: false,
    buildSecrets: false,
    buildSsh: false,
    extraHash: false,
    file: false,
    networkMode: false,
    outputs: false,
    platform: false,
    repositoryName: false,
    target: false,
  },
  networkMode: networkMode,
  outputs: ['outputs'],
  platform: platform,
  target: 'target',
});
python
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
import aws_cdk as cdk
from aws_cdk import aws_ecr_assets as ecr_assets
from aws_cdk import aws_ecs as ecs

# network_mode: ecr_assets.NetworkMode
# platform: ecr_assets.Platform

asset_image = ecs.AssetImage.from_asset("directory",
    asset_name="assetName",
    build_args={
        "build_args_key": "buildArgs"
    },
    build_contexts={
        "build_contexts_key": "buildContexts"
    },
    build_secrets={
        "build_secrets_key": "buildSecrets"
    },
    build_ssh="buildSsh",
    cache_disabled=False,
    cache_from=[ecr_assets.DockerCacheOption(
        type="type",

        # the properties below are optional
        params={
            "params_key": "params"
        }
    )],
    cache_to=ecr_assets.DockerCacheOption(
        type="type",

        # the properties below are optional
        params={
            "params_key": "params"
        }
    ),
    display_name="displayName",
    exclude=["exclude"],
    extra_hash="extraHash",
    file="file",
    follow_symlinks=cdk.SymlinkFollowMode.NEVER,
    ignore_mode=cdk.IgnoreMode.GLOB,
    invalidation=ecr_assets.DockerImageAssetInvalidationOptions(
        build_args=False,
        build_contexts=False,
        build_secrets=False,
        build_ssh=False,
        extra_hash=False,
        file=False,
        network_mode=False,
        outputs=False,
        platform=False,
        repository_name=False,
        target=False
    ),
    network_mode=network_mode,
    outputs=["outputs"],
    platform=platform,
    target="target"
)
java
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.*;
import software.amazon.awscdk.services.ecr.assets.*;
import software.amazon.awscdk.services.ecs.*;

NetworkMode networkMode;
Platform platform;

AssetImage assetImage = AssetImage.fromAsset("directory", AssetImageProps.builder()
        .assetName("assetName")
        .buildArgs(Map.of(
                "buildArgsKey", "buildArgs"))
        .buildContexts(Map.of(
                "buildContextsKey", "buildContexts"))
        .buildSecrets(Map.of(
                "buildSecretsKey", "buildSecrets"))
        .buildSsh("buildSsh")
        .cacheDisabled(false)
        .cacheFrom(List.of(DockerCacheOption.builder()
                .type("type")

                // the properties below are optional
                .params(Map.of(
                        "paramsKey", "params"))
                .build()))
        .cacheTo(DockerCacheOption.builder()
                .type("type")

                // the properties below are optional
                .params(Map.of(
                        "paramsKey", "params"))
                .build())
        .displayName("displayName")
        .exclude(List.of("exclude"))
        .extraHash("extraHash")
        .file("file")
        .followSymlinks(SymlinkFollowMode.NEVER)
        .ignoreMode(IgnoreMode.GLOB)
        .invalidation(DockerImageAssetInvalidationOptions.builder()
                .buildArgs(false)
                .buildContexts(false)
                .buildSecrets(false)
                .buildSsh(false)
                .extraHash(false)
                .file(false)
                .networkMode(false)
                .outputs(false)
                .platform(false)
                .repositoryName(false)
                .target(false)
                .build())
        .networkMode(networkMode)
        .outputs(List.of("outputs"))
        .platform(platform)
        .target("target")
        .build());
csharp
// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK;
using Amazon.CDK.AWS.Ecr.Assets;
using Amazon.CDK.AWS.ECS;

NetworkMode networkMode;
Platform platform;

var assetImage = AssetImage.FromAsset("directory", new AssetImageProps {
    AssetName = "assetName",
    BuildArgs = new Dictionary<string, string> {
        { "buildArgsKey", "buildArgs" }
    },
    BuildContexts = new Dictionary<string, string> {
        { "buildContextsKey", "buildContexts" }
    },
    BuildSecrets = new Dictionary<string, string> {
        { "buildSecretsKey", "buildSecrets" }
    },
    BuildSsh = "buildSsh",
    CacheDisabled = false,
    CacheFrom = new [] { new DockerCacheOption {
        Type = "type",

        // the properties below are optional
        Params = new Dictionary<string, string> {
            { "paramsKey", "params" }
        }
    } },
    CacheTo = new DockerCacheOption {
        Type = "type",

        // the properties below are optional
        Params = new Dictionary<string, string> {
            { "paramsKey", "params" }
        }
    },
    DisplayName = "displayName",
    Exclude = new [] { "exclude" },
    ExtraHash = "extraHash",
    File = "file",
    FollowSymlinks = SymlinkFollowMode.NEVER,
    IgnoreMode = IgnoreMode.GLOB,
    Invalidation = new DockerImageAssetInvalidationOptions {
        BuildArgs = false,
        BuildContexts = false,
        BuildSecrets = false,
        BuildSsh = false,
        ExtraHash = false,
        File = false,
        NetworkMode = false,
        Outputs = false,
        Platform = false,
        RepositoryName = false,
        Target = false
    },
    NetworkMode = networkMode,
    Outputs = new [] { "outputs" },
    Platform = platform,
    Target = "target"
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var networkMode NetworkMode
var platform Platform

assetImage := awscdk.Aws_ecs.AssetImage_FromAsset(jsii.String("directory"), &AssetImageProps{
	AssetName: jsii.String("assetName"),
	BuildArgs: map[string]*string{
		"buildArgsKey": jsii.String("buildArgs"),
	},
	BuildContexts: map[string]*string{
		"buildContextsKey": jsii.String("buildContexts"),
	},
	BuildSecrets: map[string]*string{
		"buildSecretsKey": jsii.String("buildSecrets"),
	},
	BuildSsh: jsii.String("buildSsh"),
	CacheDisabled: jsii.Boolean(false),
	CacheFrom: []DockerCacheOption{
		&DockerCacheOption{
			Type: jsii.String("type"),

			// the properties below are optional
			Params: map[string]*string{
				"paramsKey": jsii.String("params"),
			},
		},
	},
	CacheTo: &DockerCacheOption{
		Type: jsii.String("type"),

		// the properties below are optional
		Params: map[string]*string{
			"paramsKey": jsii.String("params"),
		},
	},
	DisplayName: jsii.String("displayName"),
	Exclude: []*string{
		jsii.String("exclude"),
	},
	ExtraHash: jsii.String("extraHash"),
	File: jsii.String("file"),
	FollowSymlinks: cdk.SymlinkFollowMode_NEVER,
	IgnoreMode: cdk.IgnoreMode_GLOB,
	Invalidation: &DockerImageAssetInvalidationOptions{
		BuildArgs: jsii.Boolean(false),
		BuildContexts: jsii.Boolean(false),
		BuildSecrets: jsii.Boolean(false),
		BuildSsh: jsii.Boolean(false),
		ExtraHash: jsii.Boolean(false),
		File: jsii.Boolean(false),
		NetworkMode: jsii.Boolean(false),
		Outputs: jsii.Boolean(false),
		Platform: jsii.Boolean(false),
		RepositoryName: jsii.Boolean(false),
		Target: jsii.Boolean(false),
	},
	NetworkMode: networkMode,
	Outputs: []*string{
		jsii.String("outputs"),
	},
	Platform: platform,
	Target: jsii.String("target"),
})

Initializer ​

ts
new AssetImage(directory: string, props?: AssetImageProps)
python
AssetImage(directory: str, props: typing.Optional[AssetImageProps] = None)
java
new AssetImage(String directory, AssetImageProps props)
csharp
new AssetImage(string directory, AssetImageProps? props = null)
go
NewAssetImage(Directory *string, Props AssetImageProps)

Methods ​

bind(scope: Construct, containerDefinition: ContainerDefinition): ContainerImageConfigdef bind(self, scope: Construct, container_definition: ContainerDefinition) -> ContainerImageConfigpublic ContainerImageConfig bind(Construct scope, ContainerDefinition containerDefinition)public ContainerImageConfig Bind(Construct scope, ContainerDefinition containerDefinition)func Bind(Scope Construct, ContainerDefinition ContainerDefinition) ContainerImageConfig#
Called when the image is used by a ContainerDefinition.
fromAsset(directory: string, props?: AssetImageProps): AssetImage // chainable@staticmethod def from_asset(directory: str, props: typing.Optional[AssetImageProps] = None) -> AssetImagepublic static AssetImage fromAsset(String directory, AssetImageProps props)public static AssetImage FromAsset(string directory, AssetImageProps? props = null)func FromAsset(Directory *string, Props AssetImageProps) AssetImagestatic#
Reference an image that's constructed directly from sources on disk.

If you already have a DockerImageAsset instance, you can use the ContainerImage.fromDockerImageAsset method instead.

1 parameter

Parameters

  • directorydirectorydirectorydirectoryDirectory — The directory containing the Dockerfile.
fromDockerImageAsset(asset: DockerImageAsset): ContainerImage@staticmethod def from_docker_image_asset(asset: DockerImageAsset) -> ContainerImagepublic static ContainerImage fromDockerImageAsset(DockerImageAsset asset)public static ContainerImage FromDockerImageAsset(DockerImageAsset asset)func FromDockerImageAsset(Asset DockerImageAsset) ContainerImagestatic#
Use an existing `DockerImageAsset` for this container image.
1 parameter

Parameters

  • assetassetassetassetAsset — The DockerImageAsset to use for this container definition.
fromEcrRepository(repository: IRepository, tag?: string): EcrImage@staticmethod def from_ecr_repository(repository: IRepository, tag: typing.Optional[str] = None) -> EcrImagepublic static EcrImage fromEcrRepository(IRepository repository, String tag)public static EcrImage FromEcrRepository(IRepository repository, string? tag = null)func FromEcrRepository(Repository IRepository, Tag *string) EcrImagestatic#
Reference an image in an ECR repository.
1 parameter

Parameters

  • tagtagtagtagTag — If you don't specify this parameter, latest is used as default.
fromRegistry(name: string, props?: RepositoryImageProps): RepositoryImage@staticmethod def from_registry(name: str, props: typing.Optional[RepositoryImageProps] = None) -> RepositoryImagepublic static RepositoryImage fromRegistry(String name, RepositoryImageProps props)public static RepositoryImage FromRegistry(string name, RepositoryImageProps? props = null)func FromRegistry(Name *string, Props RepositoryImageProps) RepositoryImagestatic#
Reference an image on DockerHub or another online registry.
fromTarball(tarballFile: string): ContainerImage@staticmethod def from_tarball(tarball_file: str) -> ContainerImagepublic static ContainerImage fromTarball(String tarballFile)public static ContainerImage FromTarball(string tarballFile)func FromTarball(TarballFile *string) ContainerImagestatic#
Use an existing tarball for this container image.

Use this method if the container image has already been created by another process (e.g. jib) and you want to add it as a container image asset.

1 parameter

Parameters

  • tarballFiletarball_filetarballFiletarballFileTarballFile — Absolute path to the tarball.