One of the CDK's greatest strengths is the ability to create a library of components to be shared across your company or shared with the world on . But how do you create a construct based on other constructs in the same stack without forcing the developer to call a method for each one? That's exactly what aspects allow you to do. constructs.dev What are Aspects? The CDK uses a four-step process to convert your code into a CloudFormation template: construct, prepare, validate, and synthesize. Since aspects are used during the second step, you need to understand how the first two steps are related. When you run a CDK command, it starts by executing your code. Usually, this is some file in the project's directory where your App is created. This will create all of the constructs that you've added to your project, keeping only the level 1 or constructs for the next step. bin/ Cfn* The prepare step is where aspects are used. Each scope has a set of aspects registered to it during the construct phase. The CDK travels down the construct tree, and if it finds a registered aspect, it will pass in all of the constructs in the current scope and any child scopes. Creating the Dashboard Construct If you don't have the CDK installed, you can find instructions in the . getting started guide Now that you've seen aspects work behind the scenes let's create one of our own. We'll create a CloudWatch dashboard construct that dynamically adds widgets for every DynamoDB table in the construct's scope. Start by creating a skeleton project by running the following commands. mkdir dynamo-dashboard
cd dynamo-dashboard
cdk init app --language typescript Create the Construct First, create a new construct called . Create the class in and make sure it implements . DynamoDashboard lib/dynamoDashboard.ts IAspect Next, you'll need to add some properties to store the dashboard's state between calls to its method. The first property is a reference to the CloudWatch dashboard that will be updated. The second property will store all of the widgets that you create. visit private dashboard: cw.CfnDashboard;
widgets: Array<Widget> = []; Finally, add a constructor. It should register itself as an Aspect in its scope and create the dashboard construct. constructor(scope: cdk.Construct, id: string) {
	super(scope, id);
	
	// Register this as an aspect
  cdk.Aspects.of(scope).add(this);

	this.dashboard = new cw.CfnDashboard(this, `Dashboard`, {
    dashboardBody: ""
  });
} Implementing visit() Adding a widget to the dashboard requires three steps: find a free spot, add a widget object to the array, and update the dashboard body definition. Use the following method to figure out where the next available spot is. You can change the width/height values, but keep in mind that the dashboard is 24 units wide. widgets getNextPosition(): {x: number; y: number; width: number; height: number;} {
	let x = 0;
  let y = 0;

  if (this.widgets.length > 0) {
    const lastWidget = this.widgets[this.widgets.length - 1];
    x = lastWidget.x + lastWidget.width;
    y = lastWidget.y;

    if (x >= DASHBOARD_WIDTH - 1) {
      x = 0;
      y += this.props.widgetHeight + 1;
    }
  }

	return {x, y, width: 12, height: 6};
} Now you can implement the actual method. The first thing you need to do is make sure the node is a DynamoDB table. Since every construct passed into the visit method will be level 1, you will be checking if the node is a instance. visit CfnTable visit(node: cdk.IConstruct): void {
	if(node instanceof dynamodb.CfnTable) {
	}
} If the node is a table instance, you can create a new widget and update the dashboard. visit(node: cdk.IConstruct): void {
  if (node instanceof dynamo.CfnTable) {
    const position = this.getNextPosition();

    this.widgets.push({
		  ...position,
		  type: "metric",
		  properties: {
		    metrics: [
		      [
		        "AWS/DynamoDB",
		        "ConsumedReadCapacityUnits",
		        "TableName",
		        node.ref,
		        { label: "Read (max)" },
		      ],
		      [".", "ConsumedWriteCapacityUnits", ".", ".", { label: "Write (max)" }],
		    ],
		    view: "timeSeries",
		    stacked: false,
		    region: node.stack.region,
		    title: node.logicalId,
		    stat: "Maximum",
		    period: 300,
		    liveData: true,
		  },
		});

    this.dashboard.dashboardBody = JSON.stringify({ widgets: this.widgets });
  }
} Testing It Now comes the fun part, it's time to test your component. Go to your project's default stack and create an instance of the component. Next, add a couple of DynamoDB tables. Even though your method is looking for instances you can use the class since it creates a instance in its constructor. visit CfnTable Table CfnTable export class DynamoDashboardStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    new DynamoDashboard(this, `DynamoDashboard`);

    new dynamo.Table(this, `FirstTable`, {
      partitionKey: {
        name: "pk",
        type: dynamo.AttributeType.STRING,
      },
    });

    new dynamo.Table(this, `SecondTable`, {
      partitionKey: {
        name: "pk",
        type: dynamo.AttributeType.STRING,
      },
    });
  }
} Everything should be good to go at this point; run to send your stack to the cloud. Once it's done deploying, open up CloudWatch and find your dashboard. Now enjoy the fact that you don't have to manually add every table to it! cdk deploy Conclusion In this article, you've seen what CDK aspects are and how to use them to dynamically update resources. I haven't seen many other examples of aspects, but hopefully, you'll be inspired to create something awesome and share it! Also Published At: https://thebenforce.com/post/dynamic-cdk-dashboards You can find the final source for this tutorial at https://github.com/theBenForce/dynamo-dashboard

Amazon

Super

Connecting Event Bridges Across AWS Accounts: A How-To Guide

An Introduction to the Main AWS Storage Services

Visit My Blog

Nominated for 2022 - HackerNoon Contributor of the Year - Devops

Too Long; Didn't Read

Make resilience your competitive advantage

An Intro to Dynamic CDK Dashboards

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

An Introduction to the Main AWS Storage Services

AOP Frameworks Can Do Wonders For Your Project — Here's How

101 Stories To Learn About Cloud Infrastructure

10 Things in Engineering We Don't Spend Enough Time On

10 Things I Did To Increase CloudTrail Logs Security

An Introduction to the Main AWS Storage Services

AOP Frameworks Can Do Wonders For Your Project — Here's How

101 Stories To Learn About Cloud Infrastructure

10 Things in Engineering We Don't Spend Enough Time On

10 Things I Did To Increase CloudTrail Logs Security

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps