Announcing AWS CDK Mixins: Composable Abstractions for AWS Resources¶

import * as cdk from 'aws-cdk-lib/core'; 
import * as s3 from 'aws-cdk-lib/aws-s3'; 
import { CfnBucketPropsMixin } from '@aws-cdk/cfn-property-mixins/aws-s3'; 
// CDK Mixins can be used with L1s 
new s3.CfnBucket(stack, "MixinsL1DemoBucket") 
  // Use the fluent .with() syntax (available in JavaScript/TypeScript) 
  // .with() silently skips unsupported constructs 
  .with(new s3.mixins.BucketVersioning()); 
// ... or with L2s 
new s3.Bucket(stack, "MixinsL2DemoBucket") 
  // Cfn Property Mixins provide type-safe fallbacks for L2s 
  // and configuration after initial creation 
  .with(new CfnBucketPropsMixin({ 
    objectLockEnabled: true, 
    objectLockConfiguration: { 
      objectLockEnabled: "Enabled", 
      rule: { 
        defaultRetention: { 
          mode: "COMPLIANCE", 
          days: 30, 
        }, 
      }, 
    }, 
  })); 

// Use Mixins.of() to apply Mixins in other languages 
// This also gives you more options to apply only to certain constructs 
cdk.Mixins.of(stack, cdk.ConstructSelector.byId('MixinsL1DemoBucket')) 
  .apply(new s3.mixins.BucketAutoDeleteObjects()); 

// Apply your Mixins to the whole app 
cdk.Mixins.of(app).apply(new MyDataRecovery()); 
// ... or only to some constructs 
cdk.Mixins.of(app, cdk.ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)).apply(new MyDataRecovery()); 

// It's easy to develop your own Mixins 
class MyDataRecovery extends cdk.Mixin implements IMixin { 
  public supports(construct: any): construct is s3.CfnBucket | dynamodb.CfnTable { 
    // Mixins can be cross-service and support different resources at once 
    return s3.CfnBucket.isCfnBucket(construct) || dynamodb.CfnTable.isCfnTable(construct); 
  } 
  // applyTo modifies the construct in place (returns void) 
  public applyTo(construct: IConstruct): void { 
    if (s3.CfnBucket.isCfnBucket(construct)) { 
      construct.versioningConfiguration = { 
        status: 'Enabled', 
      }; 
    } 
    if (dynamodb.CfnTable.isCfnTable(construct)) { 
      construct.pointInTimeRecoverySpecification = { 
        pointInTimeRecoveryEnabled: true, 
      }; 
    } 
  } 
} 

// ... and to use them: 
new s3.Bucket(stack, 'AcmeBucket'); 
new dynamodb.TableV2(stack, 'AcmeTable', { 
  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING }, 
}); 
// Apply your Mixins to the whole app 
cdk.Mixins.of(app).apply(new MyDataRecovery()); 
// ... or only to some constructs 
cdk.Mixins.of(app, cdk.ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)).apply(new MyDataRecovery()); 

// Graceful: apply() silently skips unsupported constructs 
const logGroup = new logs.CfnLogGroup(stack, 'LogGroup'); 
cdk.Mixins.of(logGroup).apply(new s3.mixins.BucketAutoDeleteObjects()); 
// requireAll: Throws if ANY selected construct is not supported by the mixin 
cdk.Mixins.of(logGroup).apply(new s3.mixins.BucketAutoDeleteObjects()).requireAll(); 
// requireAny: Throws if NO selected construct is supported by the mixin 
cdk.Mixins.of(stack).apply(new s3.mixins.BucketVersioning()).requireAny(); 

const applicator = cdk.Mixins.of(app, cdk.ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)); 
const result = applicator.apply(new s3.mixins.BucketVersioning()); 
// See which constructs were matched by the selector 
console.table(applicator.selectedConstructs.map(c => c.node.path)); 
// Inspect which constructs were successfully modified, grouped by construct 
console.table(result.report.map(r => ({ construct: r.construct.node.path, mixin: util.inspect(r.mixin) }))); 

import * as ecs from 'aws-cdk-lib/aws-ecs'; 
import * as ec2 from 'aws-cdk-lib/aws-ec2'; 
// Works with L1 constructs 
new ecs.CfnCluster(stack, 'L1Cluster', { clusterName: 'my-cluster' }) 
  .with(new ecs.mixins.ClusterSettings([ 
    { name: 'containerInsights', value: 'enhanced' }, 
  ])); 
// Works with L2 constructs too 
new ecs.Cluster(stack, 'L2Cluster', { vpc, clusterName: 'my-cluster' }) 
  .with(new ecs.mixins.ClusterSettings([ 
    { name: 'containerInsights', value: 'enhanced' }, 
  ])); 

import * as s3 from 'aws-cdk-lib/aws-s3'; 
// Block all public access on S3 buckets 
new s3.CfnBucket(stack, 'SecureBucket') 
  .with(new s3.mixins.BucketBlockPublicAccess()); 
// Apply public access block across all S3 buckets in the app 
cdk.Mixins.of(app, cdk.ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)) 
  .apply(new s3.mixins.BucketBlockPublicAccess()) 
  .requireAll(); 

// NOTE: Vended log delivery mixins are still in @aws-cdk/mixins-preview 
import * as wafv2Mixins from '@aws-cdk/mixins-preview/aws-wafv2/mixins'; 
// Set up vended log delivery to an S3 bucket 
const bucket = new s3.Bucket(stack, 'LogBucket'); 
new wafv2.CfnWebACL(stack, 'WebAcl', { /* ... */ }) 
  .with(new wafv2Mixins.CfnWebACLAccessLogs().toS3(bucket)); 
// Same pattern, different destination - works identically 
const logGroup = new logs.LogGroup(stack, 'LogGroup'); 
new wafv2.CfnWebACL(stack, 'WebAcl2', { /* ... */ }) 
  .with(new wafv2Mixins.CfnWebACLAccessLogs().toLogGroup(logGroup)); 

const destination = logs.CfnDeliveryDestination.fromDeliveryDestinationName( 
  stack, 'Dest', 'my-cross-account-destination' 
); 
new wafv2.CfnWebACL(stack, 'WebAcl3', { /* ... */ }) 
  .with(new wafv2Mixins.CfnWebACLAccessLogs().toDestination(destination)); 

// 测试 Mixin 对目标类型的支持判断 
class MyDataRecovery extends cdk.Mixin implements IMixin { 
  public supports(construct: any): construct is s3.CfnBucket | dynamodb.CfnTable { 
    return s3.CfnBucket.isCfnBucket(construct) || dynamodb.CfnTable.isCfnTable(construct); 
  } 
  public applyTo(construct: IConstruct): void { 
    // 实现... 
  } 
} 

// 1. 测试 supports() 对支持类型的返回 true 
test('supports returns true for CfnBucket', () => { 
  const bucket = new s3.CfnBucket(stack, 'TestBucket'); 
  const mixin = new MyDataRecovery(); 
  expect(mixin.supports(bucket)).toBe(true); 
}); 

// 2. 测试 supports() 对不支持类型的返回 false 
test('supports returns false for LogGroup', () => { 
  const logGroup = new logs.CfnLogGroup(stack, 'TestLogGroup'); 
  const mixin = new MyDataRecovery(); 
  expect(mixin.supports(logGroup)).toBe(false); 
}); 

// 3. 测试 applyTo() 正确修改构造块 
test('applyTo enables versioning on CfnBucket', () => { 
  const bucket = new s3.CfnBucket(stack, 'TestBucket'); 
  const mixin = new MyDataRecovery(); 
  mixin.applyTo(bucket); 
  expect(bucket.versioningConfiguration).toEqual({ status: 'Enabled' }); 
}); 

import * as pipelines from 'aws-cdk-lib/pipelines'; 
import * as cdk from 'aws-cdk-lib/core'; 

class ProductionMixins extends cdk.Mixin implements IMixin { 
  public supports(construct: any): boolean { 
    return s3.CfnBucket.isCfnBucket(construct); 
  } 
  public applyTo(construct: IConstruct): void { 
    if (s3.CfnBucket.isCfnBucket(construct)) { 
      construct.lifecycleRules = [{ 
        expiration: cdk.Duration.days(90), 
      }]; 
    } 
  } 
} 

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

    const pipeline = new pipelines.CodePipeline(this, 'Pipeline', { 
      // ... pipeline configuration 
    }); 

    // 在每个阶段应用不同的 Mixin 组合 
    pipeline.addStage('Production', { 
      post: [ 
        new cdk.AspectOf(() => { 
          cdk.Mixins.of(this, cdk.ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)) 
            .apply(new ProductionMixins()); 
        }), 
      ], 
    }); 
  } 
}