Vermögenswerte im Detail Arten von Vermögenswerten Amazon S3 S3-Ressourcen Docker-Image-Ressourcen AWS CloudFormation Ressourcen-Metadaten

Vermögenswerte und die AWS CDK

Assets sind lokale Dateien, Verzeichnisse oder Docker-Images, die in AWS CDK Bibliotheken und Apps gebündelt werden können. Ein Asset kann beispielsweise ein Verzeichnis sein, das den Handlercode für eine AWS Lambda Funktion enthält. Assets können jedes Artefakt darstellen, das die App für den Betrieb benötigt.

Das folgende Tutorial-Video bietet einen umfassenden Überblick über CDK Ressourcen und erklärt, wie Sie sie in Ihrer Infrastruktur als Code (IaC) verwenden können.

Sie fügen Vermögenswerte hinzuAPIs, die durch bestimmte AWS Konstrukte verfügbar gemacht werden. Wenn Sie beispielsweise ein Lambda.Function-Konstrukt definieren, können Sie mit der Eigenschaft code ein Asset (Verzeichnis) übergeben. Functionverwendet Assets, um den Inhalt des Verzeichnisses zu bündeln und für den Code der Funktion zu verwenden. In ähnlicher Weise, ecs. ContainerImage. fromAssetverwendet bei der Definition einer ECS Amazon-Aufgabendefinition ein Docker-Image, das aus einem lokalen Verzeichnis erstellt wurde.

Vermögenswerte im Detail

Wenn Sie in Ihrer App auf ein Asset verweisen, enthält die Cloud-Assembly, die aus Ihrer Anwendung synthetisiert wird, Metadateninformationen mit Anweisungen für. AWS CDK CLI Die Anweisungen beinhalten, wo sich das Asset auf der lokalen Festplatte befindet und welche Art von Bündelung je nach Asset-Typ durchgeführt werden soll, z. B. ein zu komprimierendes Verzeichnis (zip) oder ein zu erstellendes Docker-Image.

Das AWS CDK generiert einen Quell-Hash für Assets. Dieser kann während der Erstellung verwendet werden, um festzustellen, ob sich der Inhalt eines Assets geändert hat.

Standardmäßig AWS CDK erstellt der eine Kopie des Assets im Cloud-Assembly-Verzeichnis, das standardmäßig aufcdk.out, unter dem Quell-Hash steht. Auf diese Weise ist die Cloud-Assembly eigenständig. Wenn sie also zur Bereitstellung auf einen anderen Host verschoben wurde, kann sie trotzdem bereitgestellt werden. Details dazu finden Sie unter Cloud-Assemblys.

Wenn der eine App AWS CDK bereitstellt, die auf Assets verweist (entweder direkt über den App-Code oder über eine Bibliothek), bereitet der AWS CDK CLI erste die Assets vor und veröffentlicht sie in einem Amazon S3 S3-Bucket oder ECR Amazon-Repository. (Der S3-Bucket oder das Repository wird beim Bootstrapping erstellt.) Erst dann werden die im Stack definierten Ressourcen bereitgestellt.

In diesem Abschnitt wird das im Framework APIs verfügbare Low-Level beschrieben.

Arten von Vermögenswerten

Der AWS CDK unterstützt die folgenden Arten von Vermögenswerten:

Amazon S3 S3-Ressourcen: Dies sind lokale Dateien und Verzeichnisse, die auf Amazon S3 AWS CDK hochgeladen werden.
Docker-Image: Dies sind Docker-Images, die auf Amazon AWS CDK hochgeladen werden. ECR

Diese Asset-Typen werden in den folgenden Abschnitten erklärt.

Amazon S3 S3-Ressourcen

Sie können lokale Dateien und Verzeichnisse als Assets und die AWS CDK Pakete definieren und sie über das aws-s3-assets-Modul auf Amazon S3 hochladen.

Das folgende Beispiel definiert ein lokales Verzeichnis-Asset und ein Datei-Asset.

TypeScript


import { Asset } from 'aws-cdk-lib/aws-s3-assets';

// Archived and uploaded to Amazon S3 as a .zip file
const directoryAsset = new Asset(this, "SampleZippedDirAsset", {
  path: path.join(__dirname, "sample-asset-directory")
});

// Uploaded to Amazon S3 as-is
const fileAsset = new Asset(this, 'SampleSingleFileAsset', {
  path: path.join(__dirname, 'file-asset.txt')
});

JavaScript


const { Asset } = require('aws-cdk-lib/aws-s3-assets');

// Archived and uploaded to Amazon S3 as a .zip file
const directoryAsset = new Asset(this, "SampleZippedDirAsset", {
  path: path.join(__dirname, "sample-asset-directory")
});

// Uploaded to Amazon S3 as-is
const fileAsset = new Asset(this, 'SampleSingleFileAsset', {
  path: path.join(__dirname, 'file-asset.txt')
});

Python


import os.path
dirname = os.path.dirname(__file__)

from aws_cdk.aws_s3_assets import Asset

# Archived and uploaded to Amazon S3 as a .zip file
directory_asset = Asset(self, "SampleZippedDirAsset",
  path=os.path.join(dirname, "sample-asset-directory")
)

# Uploaded to Amazon S3 as-is
file_asset = Asset(self, 'SampleSingleFileAsset',
  path=os.path.join(dirname, 'file-asset.txt')
)

Java


import java.io.File;

import software.amazon.awscdk.services.s3.assets.Asset;

// Directory where app was started
File startDir = new File(System.getProperty("user.dir"));

// Archived and uploaded to Amazon S3 as a .zip file
Asset directoryAsset = Asset.Builder.create(this, "SampleZippedDirAsset")
                .path(new File(startDir, "sample-asset-directory").toString()).build();

// Uploaded to Amazon S3 as-is
Asset fileAsset = Asset.Builder.create(this, "SampleSingleFileAsset")
                .path(new File(startDir, "file-asset.txt").toString()).build();

C#


using System.IO;
using Amazon.CDK.AWS.S3.Assets;

// Archived and uploaded to Amazon S3 as a .zip file
var directoryAsset = new Asset(this, "SampleZippedDirAsset", new AssetProps
{
    Path = Path.Combine(Directory.GetCurrentDirectory(), "sample-asset-directory")
});

// Uploaded to Amazon S3 as-is
var fileAsset = new Asset(this, "SampleSingleFileAsset", new AssetProps
{
    Path = Path.Combine(Directory.GetCurrentDirectory(), "file-asset.txt")
});

Go


dirName, err := os.Getwd()
if err != nil {
  panic(err)
}

awss3assets.NewAsset(stack, jsii.String("SampleZippedDirAsset"), &awss3assets.AssetProps{
  Path: jsii.String(path.Join(dirName, "sample-asset-directory")),
})

awss3assets.NewAsset(stack, jsii.String("SampleSingleFileAsset"), &awss3assets.AssetProps{
  Path: jsii.String(path.Join(dirName, "file-asset.txt")),
})

In den meisten Fällen müssen Sie das nicht direkt APIs im aws-s3-assets Modul verwenden. Module, die Ressourcen unterstützenaws-lambda, verfügen z. B. über praktische Methoden, mit denen Sie Assets verwenden können. Für Lambda-Funktionen können Sie mit der statischen Methode fromAsset() ein Verzeichnis oder eine ZIP-Datei im lokalen Dateisystem angeben.

Beispiel für eine Lambda-Funktion

Ein häufiger Anwendungsfall ist die Erstellung von Lambda-Funktionen mit dem Handlercode als Amazon S3 S3-Asset.

Im folgenden Beispiel wird ein Amazon S3 S3-Asset verwendet, um einen Python-Handler im lokalen Verzeichnis zu definierenhandler. Es erstellt auch eine Lambda-Funktion mit dem lokalen Verzeichnis-Asset als code Eigenschaft. Es folgt der Python-Code für den Handler.


def lambda_handler(event, context):
  message = 'Hello World!'
  return {
    'message': message
  }

Der Code für die AWS CDK Haupt-App sollte wie folgt aussehen.

TypeScript


import * as cdk from 'aws-cdk-lib';
import { Constructs } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as path from 'path';

export class HelloAssetStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    new lambda.Function(this, 'myLambdaFunction', {
      code: lambda.Code.fromAsset(path.join(__dirname, 'handler')),
      runtime: lambda.Runtime.PYTHON_3_6,
      handler: 'index.lambda_handler'
    });
  }
}

JavaScript


const cdk = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const path = require('path');

class HelloAssetStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    new lambda.Function(this, 'myLambdaFunction', {
      code: lambda.Code.fromAsset(path.join(__dirname, 'handler')),
      runtime: lambda.Runtime.PYTHON_3_6,
      handler: 'index.lambda_handler'
    });
  }
}

module.exports = { HelloAssetStack }

Python


from aws_cdk import Stack
from constructs import Construct
from aws_cdk import aws_lambda as lambda_

import os.path
dirname = os.path.dirname(__file__)

class HelloAssetStack(Stack):
    def __init__(self, scope: Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        lambda_.Function(self, 'myLambdaFunction',
            code=lambda_.Code.from_asset(os.path.join(dirname, 'handler')),
            runtime=lambda_.Runtime.PYTHON_3_6,
            handler="index.lambda_handler")

Java


import java.io.File;

import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;

public class HelloAssetStack extends Stack {

    public HelloAssetStack(final App scope, final String id) {
        this(scope, id, null);
    }

    public HelloAssetStack(final App scope, final String id, final StackProps props) {
        super(scope, id, props);

        File startDir = new File(System.getProperty("user.dir"));

        Function.Builder.create(this, "myLambdaFunction")
                .code(Code.fromAsset(new File(startDir, "handler").toString()))
                .runtime(Runtime.PYTHON_3_6)
                .handler("index.lambda_handler").build();        
    }
}

C#


using Amazon.CDK;
using Amazon.CDK.AWS.Lambda;
using System.IO;

public class HelloAssetStack : Stack
{
    public HelloAssetStack(Construct scope, string id, StackProps props) : base(scope, id, props)
    {
        new Function(this, "myLambdaFunction", new FunctionProps
        {
            Code = Code.FromAsset(Path.Combine(Directory.GetCurrentDirectory(), "handler")),
            Runtime = Runtime.PYTHON_3_6,
            Handler = "index.lambda_handler"
        });
    }
}

Go


import (
  "os"
  "path"

  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
  "github.com/aws/aws-cdk-go/awscdk/v2/awss3assets"
  "github.com/aws/constructs-go/constructs/v10"
  "github.com/aws/jsii-runtime-go"
)

func HelloAssetStack(scope constructs.Construct, id string, props *HelloAssetStackProps) awscdk.Stack {
  var sprops awscdk.StackProps
  if props != nil {
    sprops = props.StackProps
  }
  stack := awscdk.NewStack(scope, &id, &sprops)
	
  dirName, err := os.Getwd()
  if err != nil {
    panic(err)
  }
	
  awslambda.NewFunction(stack, jsii.String("myLambdaFunction"), &awslambda.FunctionProps{
    Code: awslambda.AssetCode_FromAsset(jsii.String(path.Join(dirName, "handler")), &awss3assets.AssetOptions{}),
    Runtime: awslambda.Runtime_PYTHON_3_6(),
    Handler: jsii.String("index.lambda_handler"),
  })

  return stack
}

Die Function Methode verwendet Assets, um den Inhalt des Verzeichnisses zu bündeln und ihn für den Code der Funktion zu verwenden.

Tipp

.jarJava-Dateien sind ZIP Dateien mit einer anderen Erweiterung. Diese werden unverändert in Amazon S3 hochgeladen, aber wenn sie als Lambda-Funktion bereitgestellt werden, werden die darin enthaltenen Dateien extrahiert, was Sie möglicherweise nicht möchten. Um dies zu vermeiden, platzieren Sie die .jar Datei in einem Verzeichnis und geben Sie dieses Verzeichnis als Asset an.

Beispiel für Attribute zur Bereitstellungszeit

Amazon S3 S3-Objekttypen stellen auch Bereitstellungszeitattribute zur Verfügung, auf die in AWS CDK Bibliotheken und Apps verwiesen werden kann. Der AWS CDK CLI Befehl cdk synth zeigt Asset-Eigenschaften als AWS CloudFormation Parameter an.

Im folgenden Beispiel werden Bereitstellungszeitattribute verwendet, um den Speicherort eines Image-Assets als Umgebungsvariablen an eine Lambda-Funktion zu übergeben. (Die Art der Datei spielt keine Rolle; das hier verwendete PNG Bild ist nur ein Beispiel.)

TypeScript


import { Asset } from 'aws-cdk-lib/aws-s3-assets';
import * as path from 'path';

const imageAsset = new Asset(this, "SampleAsset", {
  path: path.join(__dirname, "images/my-image.png")
});

new lambda.Function(this, "myLambdaFunction", {
  code: lambda.Code.asset(path.join(__dirname, "handler")),
  runtime: lambda.Runtime.PYTHON_3_6,
  handler: "index.lambda_handler",
  environment: {
    'S3_BUCKET_NAME': imageAsset.s3BucketName,
    'S3_OBJECT_KEY': imageAsset.s3ObjectKey,
    'S3_OBJECT_URL': imageAsset.s3ObjectUrl
  }
});

JavaScript


const { Asset } = require('aws-cdk-lib/aws-s3-assets');
const path = require('path');

const imageAsset = new Asset(this, "SampleAsset", {
  path: path.join(__dirname, "images/my-image.png")
});

new lambda.Function(this, "myLambdaFunction", {
  code: lambda.Code.asset(path.join(__dirname, "handler")),
  runtime: lambda.Runtime.PYTHON_3_6,
  handler: "index.lambda_handler",
  environment: {
    'S3_BUCKET_NAME': imageAsset.s3BucketName,
    'S3_OBJECT_KEY': imageAsset.s3ObjectKey,
    'S3_OBJECT_URL': imageAsset.s3ObjectUrl
  }
});

Python


import os.path

import aws_cdk.aws_lambda as lambda_
from aws_cdk.aws_s3_assets import Asset

dirname = os.path.dirname(__file__)

image_asset = Asset(self, "SampleAsset",
    path=os.path.join(dirname, "images/my-image.png"))

lambda_.Function(self, "myLambdaFunction",
    code=lambda_.Code.asset(os.path.join(dirname, "handler")),
    runtime=lambda_.Runtime.PYTHON_3_6,
    handler="index.lambda_handler",
    environment=dict(
        S3_BUCKET_NAME=image_asset.s3_bucket_name,
        S3_OBJECT_KEY=image_asset.s3_object_key,
        S3_OBJECT_URL=image_asset.s3_object_url))

Java


import java.io.File;

import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.s3.assets.Asset;

public class FunctionStack extends Stack {
    public FunctionStack(final App scope, final String id, final StackProps props) {
        super(scope, id, props);

        File startDir = new File(System.getProperty("user.dir"));

        Asset imageAsset = Asset.Builder.create(this, "SampleAsset")
                .path(new File(startDir, "images/my-image.png").toString()).build())

        Function.Builder.create(this, "myLambdaFunction")
                .code(Code.fromAsset(new File(startDir, "handler").toString()))
                .runtime(Runtime.PYTHON_3_6)
                .handler("index.lambda_handler")
                .environment(java.util.Map.of(    // Java 9 or later
                    "S3_BUCKET_NAME", imageAsset.getS3BucketName(),
                    "S3_OBJECT_KEY", imageAsset.getS3ObjectKey(),
                    "S3_OBJECT_URL", imageAsset.getS3ObjectUrl()))
                .build();
    }
}

C#


using Amazon.CDK;
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.S3.Assets;
using System.IO;
using System.Collections.Generic;

var imageAsset = new Asset(this, "SampleAsset", new AssetProps
{
    Path = Path.Combine(Directory.GetCurrentDirectory(), @"images\my-image.png")
});

new Function(this, "myLambdaFunction", new FunctionProps
{
    Code = Code.FromAsset(Path.Combine(Directory.GetCurrentDirectory(), "handler")),
    Runtime = Runtime.PYTHON_3_6,
    Handler = "index.lambda_handler",
    Environment = new Dictionary<string, string>
    {
        ["S3_BUCKET_NAME"] = imageAsset.S3BucketName,
        ["S3_OBJECT_KEY"] = imageAsset.S3ObjectKey,
        ["S3_OBJECT_URL"] = imageAsset.S3ObjectUrl
    }
});

Go


import (
  "os"
  "path"
  
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
  "github.com/aws/aws-cdk-go/awscdk/v2/awss3assets"
)

dirName, err := os.Getwd()
if err != nil {
  panic(err)
}

imageAsset := awss3assets.NewAsset(stack, jsii.String("SampleAsset"), &awss3assets.AssetProps{
  Path: jsii.String(path.Join(dirName, "images/my-image.png")),
})

awslambda.NewFunction(stack, jsii.String("myLambdaFunction"), &awslambda.FunctionProps{
  Code: awslambda.AssetCode_FromAsset(jsii.String(path.Join(dirName, "handler"))),
  Runtime: awslambda.Runtime_PYTHON_3_6(),
  Handler: jsii.String("index.lambda_handler"),
  Environment: &map[string]*string{
    "S3_BUCKET_NAME": imageAsset.S3BucketName(),
    "S3_OBJECT_KEY": imageAsset.S3ObjectKey(),
    "S3_URL": imageAsset.S3ObjectUrl(),
  },
})

Berechtigungen

Wenn Sie Amazon S3 S3-Assets direkt über das aws-s3-assets-Modul, IAM Rollen, Benutzer oder Gruppen verwenden und Sie Assets während der Laufzeit lesen müssen, gewähren Sie diesen Assets IAM über das Asset Berechtigungen. grantReadMethode.

Das folgende Beispiel gewährt einer IAM Gruppe Leseberechtigungen für ein Datei-Asset.

TypeScript


import { Asset } from 'aws-cdk-lib/aws-s3-assets';
import * as path from 'path';

const asset = new Asset(this, 'MyFile', {
  path: path.join(__dirname, 'my-image.png')
});

const group = new iam.Group(this, 'MyUserGroup');
asset.grantRead(group);

JavaScript


const { Asset } = require('aws-cdk-lib/aws-s3-assets');
const path = require('path');

const asset = new Asset(this, 'MyFile', {
  path: path.join(__dirname, 'my-image.png')
});

const group = new iam.Group(this, 'MyUserGroup');
asset.grantRead(group);

Python


from aws_cdk.aws_s3_assets import Asset
import aws_cdk.aws_iam as iam

import os.path
dirname = os.path.dirname(__file__)

        asset = Asset(self, "MyFile",
            path=os.path.join(dirname, "my-image.png"))

        group = iam.Group(self, "MyUserGroup")
        asset.grant_read(group)

Java


import java.io.File;

import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.iam.Group;
import software.amazon.awscdk.services.s3.assets.Asset;

public class GrantStack extends Stack {
    public GrantStack(final App scope, final String id, final StackProps props) {
        super(scope, id, props);

        File startDir = new File(System.getProperty("user.dir"));

        Asset asset = Asset.Builder.create(this, "SampleAsset")
                .path(new File(startDir, "images/my-image.png").toString()).build();

        Group group = new Group(this, "MyUserGroup");
        asset.grantRead(group);   }
}

C#


using Amazon.CDK;
using Amazon.CDK.AWS.IAM;
using Amazon.CDK.AWS.S3.Assets;
using System.IO;

var asset = new Asset(this, "MyFile", new AssetProps {
    Path = Path.Combine(Path.Combine(Directory.GetCurrentDirectory(), @"images\my-image.png"))
});

var group = new Group(this, "MyUserGroup");
asset.GrantRead(group);

Go


import (
  "os"
  "path"

  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awsiam"
  "github.com/aws/aws-cdk-go/awscdk/v2/awss3assets"
)

dirName, err := os.Getwd()
if err != nil {
  panic(err)
}

asset := awss3assets.NewAsset(stack, jsii.String("MyFile"), &awss3assets.AssetProps{
  Path: jsii.String(path.Join(dirName, "my-image.png")),
})

group := awsiam.NewGroup(stack, jsii.String("MyUserGroup"), &awsiam.GroupProps{})

asset.GrantRead(group)

Docker-Image-Ressourcen

Das AWS CDK unterstützt das Bündeln lokaler Docker-Images als Assets über das Modul. aws-ecr-assets

Das folgende Beispiel definiert ein Docker-Image, das lokal erstellt und an Amazon ECR übertragen wird. Images werden aus einem lokalen Docker-Kontextverzeichnis (mit einer Docker-Datei) erstellt und über die CI/CD-Pipeline AWS CDK CLI oder die ECR CI/CD-Pipeline Ihrer App auf Amazon hochgeladen. Die Bilder können natürlich in Ihrer App referenziert werden. AWS CDK

Das my-image Verzeichnis muss ein Dockerfile enthalten. Das AWS CDK CLI erstellt ein Docker-Imagemy-image, überträgt es in ein ECR Amazon-Repository und gibt den Namen des Repositorys als AWS CloudFormation Parameter für Ihren Stack an. Docker-Image-Asset-Typen stellen Attribute zur Bereitstellungszeit bereit, auf die in Bibliotheken und Apps verwiesen werden kann. AWS CDK Der AWS CDK CLI Befehl cdk synth zeigt Asset-Eigenschaften als Parameter an. AWS CloudFormation

Beispiel für ECS eine Amazon-Aufgabendefinition

Ein häufiger Anwendungsfall ist die Erstellung eines Amazon ECS TaskDefinitionzum Ausführen von Docker-Containern. Das folgende Beispiel gibt den Speicherort eines Docker-Image-Assets an, das lokal AWS CDK erstellt und an Amazon gesendet wird. ECR

TypeScript


import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as ecr_assets from 'aws-cdk-lib/aws-ecr-assets';
import * as path from 'path';

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef", {
  memoryLimitMiB: 1024,
  cpu: 512
});

const asset = new ecr_assets.DockerImageAsset(this, 'MyBuildImage', {
  directory: path.join(__dirname, 'my-image')
});

taskDefinition.addContainer("my-other-container", {
  image: ecs.ContainerImage.fromDockerImageAsset(asset)
});

JavaScript


const ecs = require('aws-cdk-lib/aws-ecs');
const ecr_assets = require('aws-cdk-lib/aws-ecr-assets');
const path = require('path');

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef", {
  memoryLimitMiB: 1024,
  cpu: 512
});

const asset = new ecr_assets.DockerImageAsset(this, 'MyBuildImage', {
  directory: path.join(__dirname, 'my-image')
});

taskDefinition.addContainer("my-other-container", {
  image: ecs.ContainerImage.fromDockerImageAsset(asset)
});

Python


import aws_cdk.aws_ecs as ecs
import aws_cdk.aws_ecr_assets as ecr_assets 

import os.path
dirname = os.path.dirname(__file__)

task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
    memory_limit_mib=1024,
    cpu=512)

asset = ecr_assets.DockerImageAsset(self, 'MyBuildImage',
    directory=os.path.join(dirname, 'my-image'))

task_definition.add_container("my-other-container",
    image=ecs.ContainerImage.from_docker_image_asset(asset))

Java


import java.io.File;

import software.amazon.awscdk.services.ecs.FargateTaskDefinition;
import software.amazon.awscdk.services.ecs.ContainerDefinitionOptions;
import software.amazon.awscdk.services.ecs.ContainerImage;

import software.amazon.awscdk.services.ecr.assets.DockerImageAsset;

File startDir = new File(System.getProperty("user.dir"));

FargateTaskDefinition taskDefinition = FargateTaskDefinition.Builder.create(
        this, "TaskDef").memoryLimitMiB(1024).cpu(512).build();

DockerImageAsset asset = DockerImageAsset.Builder.create(this, "MyBuildImage")
            .directory(new File(startDir, "my-image").toString()).build();

taskDefinition.addContainer("my-other-container",
        ContainerDefinitionOptions.builder()
            .image(ContainerImage.fromDockerImageAsset(asset))
            .build();

C#


using System.IO;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.Ecr.Assets;

var taskDefinition = new FargateTaskDefinition(this, "TaskDef", new FargateTaskDefinitionProps
{
    MemoryLimitMiB = 1024,
    Cpu = 512
});

var asset = new DockerImageAsset(this, "MyBuildImage", new DockerImageAssetProps
{
    Directory = Path.Combine(Directory.GetCurrentDirectory(), "my-image")
});

taskDefinition.AddContainer("my-other-container", new ContainerDefinitionOptions
{
    Image = ContainerImage.FromDockerImageAsset(asset)
});

Go


import (
  "os"
  "path"
  
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awsecrassets"
  "github.com/aws/aws-cdk-go/awscdk/v2/awsecs"
)

dirName, err := os.Getwd()
if err != nil {
  panic(err)
}

taskDefinition := awsecs.NewTaskDefinition(stack, jsii.String("TaskDef"), &awsecs.TaskDefinitionProps{
  MemoryMiB: jsii.String("1024"),
  Cpu: jsii.String("512"),
})

asset := awsecrassets.NewDockerImageAsset(stack, jsii.String("MyBuildImage"), &awsecrassets.DockerImageAssetProps{
  Directory: jsii.String(path.Join(dirName, "my-image")),
})

taskDefinition.AddContainer(jsii.String("MyOtherContainer"), &awsecs.ContainerDefinitionOptions{
  Image: awsecs.ContainerImage_FromDockerImageAsset(asset),
})

Beispiel für Attribute zur Bereitstellungszeit

Das folgende Beispiel zeigt, wie Sie die Bereitstellungszeitattribute verwenden repository und imageUri eine ECS Amazon-Aufgabendefinition mit dem AWS Fargate Starttyp erstellen. Beachten Sie, dass für die ECR Amazon-Repo-Suche das Tag des Bilds erforderlich istURI, nicht das entsprechende. Deshalb schneiden wir es vom Ende des Assets ab. URI

TypeScript


import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as path from 'path';
import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';

const asset = new DockerImageAsset(this, 'my-image', {
  directory: path.join(__dirname, "..", "demo-image")
});

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef", {
  memoryLimitMiB: 1024,
  cpu: 512
});

taskDefinition.addContainer("my-other-container", {
  image: ecs.ContainerImage.fromEcrRepository(asset.repository, asset.imageUri.split(":").pop())
});

JavaScript


const ecs = require('aws-cdk-lib/aws-ecs');
const path = require('path');
const { DockerImageAsset } = require('aws-cdk-lib/aws-ecr-assets');

const asset = new DockerImageAsset(this, 'my-image', {
  directory: path.join(__dirname, "..", "demo-image")
});

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef", {
  memoryLimitMiB: 1024,
  cpu: 512
});

taskDefinition.addContainer("my-other-container", {
  image: ecs.ContainerImage.fromEcrRepository(asset.repository, asset.imageUri.split(":").pop())
});

Python


import aws_cdk.aws_ecs as ecs
from aws_cdk.aws_ecr_assets import DockerImageAsset

import os.path
dirname = os.path.dirname(__file__)

asset = DockerImageAsset(self, 'my-image',
    directory=os.path.join(dirname, "..", "demo-image"))

task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
    memory_limit_mib=1024, cpu=512)

task_definition.add_container("my-other-container",
    image=ecs.ContainerImage.from_ecr_repository(
        asset.repository, asset.image_uri.rpartition(":")[-1]))

Java


import java.io.File;

import software.amazon.awscdk.services.ecr.assets.DockerImageAsset;

import software.amazon.awscdk.services.ecs.FargateTaskDefinition;
import software.amazon.awscdk.services.ecs.ContainerDefinitionOptions;
import software.amazon.awscdk.services.ecs.ContainerImage;

File startDir = new File(System.getProperty("user.dir"));

DockerImageAsset asset = DockerImageAsset.Builder.create(this, "my-image")
            .directory(new File(startDir, "demo-image").toString()).build();

FargateTaskDefinition taskDefinition = FargateTaskDefinition.Builder.create(
        this, "TaskDef").memoryLimitMiB(1024).cpu(512).build();

// extract the tag from the asset's image URI for use in ECR repo lookup
String imageUri = asset.getImageUri();
String imageTag = imageUri.substring(imageUri.lastIndexOf(":") + 1);

taskDefinition.addContainer("my-other-container",
        ContainerDefinitionOptions.builder().image(ContainerImage.fromEcrRepository(
                asset.getRepository(), imageTag)).build());

C#


using System.IO;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECR.Assets;

var asset = new DockerImageAsset(this, "my-image", new DockerImageAssetProps {
    Directory = Path.Combine(Directory.GetCurrentDirectory(), "demo-image")
});

var taskDefinition = new FargateTaskDefinition(this, "TaskDef", new FargateTaskDefinitionProps
{
    MemoryLimitMiB = 1024,
    Cpu = 512
});

taskDefinition.AddContainer("my-other-container", new ContainerDefinitionOptions
{
    Image = ContainerImage.FromEcrRepository(asset.Repository, asset.ImageUri.Split(":").Last())
});

Go


import (
  "os"
  "path"

  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awsecrassets"
  "github.com/aws/aws-cdk-go/awscdk/v2/awsecs"
)

dirName, err := os.Getwd()
if err != nil {
  panic(err)
}

asset := awsecrassets.NewDockerImageAsset(stack, jsii.String("MyImage"), &awsecrassets.DockerImageAssetProps{
  Directory: jsii.String(path.Join(dirName, "demo-image")),
})

taskDefinition := awsecs.NewFargateTaskDefinition(stack, jsii.String("TaskDef"), &awsecs.FargateTaskDefinitionProps{
  MemoryLimitMiB: jsii.Number(1024),
  Cpu: jsii.Number(512),
})

taskDefinition.AddContainer(jsii.String("MyOtherContainer"), &awsecs.ContainerDefinitionOptions{
  Image: awsecs.ContainerImage_FromEcrRepository(asset.Repository(), asset.ImageTag()),
})

Beispiel für die Erstellung von Argumenten

Sie können benutzerdefinierte Build-Argumente für den Docker-Build-Schritt über die Eigenschaftsoption buildArgs (Python:build_args) angeben, wenn das Image während der Bereitstellung AWS CDK CLI erstellt wird.

Berechtigungen

Wenn Sie ein Modul verwenden, das Docker-Image-Assets unterstützt, z. B. aws-ecs, AWS CDK verwaltet es die Berechtigungen für Sie, wenn Sie Assets direkt oder über diese verwenden. ContainerImage fromEcrRepository(Python:from_ecr_repository). Wenn Sie Docker-Image-Assets direkt verwenden, stellen Sie sicher, dass der Principal, der die Daten verwendet, über die Rechte zum Abrufen des Images verfügt.

In den meisten Fällen sollten Sie asset.repository verwenden. grantPullMethode (Python):grant_pull. Dadurch wird die IAM Richtlinie des Principals geändert, sodass er Bilder aus diesem Repository abrufen kann. Befindet sich der Principal, der das Image abruft, nicht in demselben Konto oder handelt es sich um einen AWS Dienst, der keine Rolle in Ihrem Konto einnimmt (z. B. AWS CodeBuild), müssen Sie Pull-Berechtigungen für die Ressourcenrichtlinie und nicht für die Richtlinie des Prinzipals erteilen. Verwenden Sie das asset.repository. addToResourceRichtlinienmethode (Python:add_to_resource_policy), um die entsprechenden Prinzipalberechtigungen zu gewähren.

AWS CloudFormation Ressourcen-Metadaten

Anmerkung

Dieser Abschnitt ist nur für Konstruktautoren relevant. In bestimmten Situationen müssen Tools wissen, dass eine bestimmte CFN Ressource ein lokales Asset verwendet. Sie können die beispielsweise verwenden, um Lambda-Funktionen lokal AWS SAM CLI zu Debugging-Zwecken aufzurufen. Details dazu finden Sie unter AWS SAM Integration.

Um solche Anwendungsfälle zu ermöglichen, greifen externe Tools auf eine Reihe von Metadateneinträgen zu Ressourcen zurück: AWS CloudFormation

aws:asset:path— Verweist auf den lokalen Pfad des Assets.
aws:asset:property— Der Name der Ressourceneigenschaft, in der das Asset verwendet wird.

Mithilfe dieser beiden Metadateneinträge können Tools erkennen, ob Ressourcen von einer bestimmten Ressource verwendet werden, und erweiterte lokale Benutzererfahrungen ermöglichen.

Verwenden Sie die Methode asset.addResourceMetadata (Python:add_resource_metadata), um diese Metadateneinträge zu einer Ressource hinzuzufügen.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen