AgentCore RuntimeにSession Storage・S3 Files・EFSを同時マウントしてCDKで構築・検証してみた

import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as efs from 'aws-cdk-lib/aws-efs';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as s3files from 'aws-cdk-lib/aws-s3files';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';

export class StorageStack extends cdk.Stack {
  public readonly vpc: ec2.IVpc;
  public readonly mountTargetSg: ec2.SecurityGroup;
  public readonly efsAccessPoint: efs.AccessPoint;
  public readonly s3FilesAccessPointArn: string;

  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const vpcId = this.node.tryGetContext('vpcId');
    this.vpc = ec2.Vpc.fromLookup(this, 'Vpc', { vpcId });

    this.mountTargetSg = new ec2.SecurityGroup(this, 'MountTargetSg', {
      vpc: this.vpc,
      description: 'Allow NFS from AgentCore Runtime',
      allowAllOutbound: false,
    });

    // EFS
    const fileSystem = new efs.FileSystem(this, 'Efs', {
      vpc: this.vpc,
      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },
      securityGroup: this.mountTargetSg,
      performanceMode: efs.PerformanceMode.GENERAL_PURPOSE,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    this.efsAccessPoint = fileSystem.addAccessPoint('AgentCoreAP', {
      path: '/agentcore',
      createAcl: { ownerGid: '1000', ownerUid: '1000', permissions: '755' },
      posixUser: { gid: '1000', uid: '1000' },
    });

    // S3 Files
    const bucket = new s3.Bucket(this, 'S3FilesBucket', {
      versioned: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
    });

    const s3FilesRole = new iam.Role(this, 'S3FilesRole', {
      assumedBy: new iam.ServicePrincipal('elasticfilesystem.amazonaws.com'),
    });
    s3FilesRole.addToPolicy(new iam.PolicyStatement({
      actions: ['s3:ListBucket*'],
      resources: [bucket.bucketArn],
    }));
    s3FilesRole.addToPolicy(new iam.PolicyStatement({
      actions: [
        's3:AbortMultipartUpload', 's3:DeleteObject',
        's3:GetObject*', 's3:List*', 's3:PutObject*',
      ],
      resources: [bucket.arnForObjects('*')],
    }));
    s3FilesRole.addToPolicy(new iam.PolicyStatement({
      actions: [
        'events:DeleteRule', 'events:DisableRule', 'events:EnableRule',
        'events:PutRule', 'events:PutTargets', 'events:RemoveTargets',
      ],
      resources: [`arn:${cdk.Aws.PARTITION}:events:*:*:rule/DO-NOT-DELETE-S3-Files*`],
      conditions: {
        StringEquals: { 'events:ManagedBy': 'elasticfilesystem.amazonaws.com' },
      },
    }));
    s3FilesRole.addToPolicy(new iam.PolicyStatement({
      actions: [
        'events:DescribeRule', 'events:ListRuleNamesByTarget',
        'events:ListRules', 'events:ListTargetsByRule',
      ],
      resources: [`arn:${cdk.Aws.PARTITION}:events:*:*:rule/*`],
    }));

    const s3FilesFs = new s3files.CfnFileSystem(this, 'S3FilesFs', {
      bucket: bucket.bucketArn,
      roleArn: s3FilesRole.roleArn,
    });

    const subnets = this.vpc.isolatedSubnets.length > 0
      ? this.vpc.isolatedSubnets
      : this.vpc.privateSubnets;

    subnets.forEach((subnet, i) => {
      new s3files.CfnMountTarget(this, `S3FilesMt${i}`, {
        fileSystemId: s3FilesFs.attrFileSystemId,
        subnetId: subnet.subnetId,
        securityGroups: [this.mountTargetSg.securityGroupId],
      });
    });

    const s3FilesAp = new s3files.CfnAccessPoint(this, 'S3FilesAP', {
      fileSystemId: s3FilesFs.attrFileSystemId,
      rootDirectory: {
        path: '/agentcore',
        creationPermissions: { ownerGid: '1000', ownerUid: '1000', permissions: '755' },
      },
      posixUser: { gid: '1000', uid: '1000' },
    });

    this.s3FilesAccessPointArn = s3FilesAp.attrAccessPointArn;
  }
}

import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as agentcore from 'aws-cdk-lib/aws-bedrockagentcore';
import { Construct } from 'constructs';
import { StorageStack } from './storage-stack';

interface RuntimeStackProps extends cdk.StackProps {
  storage: StorageStack;
}

export class RuntimeStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props: RuntimeStackProps) {
    super(scope, id, props);

    const { storage } = props;
    const imageUri = this.node.tryGetContext('agentcoreImageUri');

    const runtime = new agentcore.Runtime(this, 'Runtime', {
      runtimeName: 'storageTest',
      agentRuntimeArtifact: agentcore.AgentRuntimeArtifact.fromImageUri(imageUri),
      networkConfiguration: agentcore.RuntimeNetworkConfiguration.usingVpc(this, {
        vpc: storage.vpc,
        vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_ISOLATED },
      }),
    });

    runtime.connections.allowTo(
      storage.mountTargetSg, ec2.Port.tcp(2049), 'NFS to EFS/S3Files'
    );

    runtime.role.addToPrincipalPolicy(new iam.PolicyStatement({
      actions: ['ecr:GetAuthorizationToken'],
      resources: ['*'],
    }));
    runtime.role.addToPrincipalPolicy(new iam.PolicyStatement({
      actions: [
        'ecr:BatchGetImage',
        'ecr:GetDownloadUrlForLayer',
        'ecr:BatchCheckLayerAvailability',
      ],
      resources: [
        `arn:aws:ecr:${this.region}:${this.account}:repository/bedrock-agentcore-agent`,
      ],
    }));

    runtime.role.addToPrincipalPolicy(new iam.PolicyStatement({
      actions: ['elasticfilesystem:ClientMount', 'elasticfilesystem:ClientWrite'],
      resources: [storage.efsAccessPoint.fileSystem.fileSystemArn],
      conditions: {
        StringEquals: {
          'elasticfilesystem:AccessPointArn': storage.efsAccessPoint.accessPointArn,
        },
      },
    }));
    runtime.role.addToPrincipalPolicy(new iam.PolicyStatement({
      actions: [
        'elasticfilesystem:DescribeAccessPoints',
        'elasticfilesystem:DescribeMountTargets',
      ],
      resources: ['*'],
    }));

    runtime.role.addToPrincipalPolicy(new iam.PolicyStatement({
      actions: [
        's3files:ClientMount', 's3files:ClientWrite', 's3files:GetAccessPoint',
        's3files:ListMountTargets', 's3files:DescribeMountTargets',
      ],
      resources: ['*'],
    }));

    const cfnRuntime = runtime.node.defaultChild as agentcore.CfnRuntime;
    cfnRuntime.addPropertyOverride('FilesystemConfigurations', [
      {
        SessionStorage: {
          MountPath: '/mnt/workspace',
        },
      },
      {
        EfsAccessPoint: {
          AccessPointArn: storage.efsAccessPoint.accessPointArn,
          MountPath: '/mnt/efs',
        },
      },
      {
        S3FilesAccessPoint: {
          AccessPointArn: storage.s3FilesAccessPointArn,
          MountPath: '/mnt/s3data',
        },
      },
    ]);
  }
}