cdk-nag
Version:
Check CDK v2 applications for best practices using a combination on available rule packs.
228 lines • 34.4 kB
JavaScript
"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ServerlessChecks = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
const aws_cdk_lib_1 = require("aws-cdk-lib");
const nag_pack_1 = require("../nag-pack");
const nag_rules_1 = require("../nag-rules");
const apigw_1 = require("../rules/apigw");
const appsync_1 = require("../rules/appsync");
const cloudwatch_1 = require("../rules/cloudwatch");
const eventbridge_1 = require("../rules/eventbridge");
const lambda_1 = require("../rules/lambda");
const sns_1 = require("../rules/sns");
const sqs_1 = require("../rules/sqs");
const stepfunctions_1 = require("../rules/stepfunctions");
/**
* Serverless Checks are a compilation of rules to validate infrastructure-as-code template against recommended practices.
*
*/
class ServerlessChecks extends nag_pack_1.NagPack {
constructor(props) {
super(props);
this.packName = 'Serverless';
}
visit(node) {
if (node instanceof aws_cdk_lib_1.CfnResource) {
this.checkLambda(node);
this.checkCloudwatch(node);
this.checkApiGw(node);
this.checkAppSync(node);
this.checkEventBridge(node);
this.checkSNS(node);
this.checkSQS(node);
this.checkStepFunctions(node);
}
}
/**
* Check Lambda Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkLambda(node) {
this.applyRule({
info: 'The Lambda function does not have a configured failure destination for asynchronous invocations.',
explanation: "When a Lambda function is invoked asynchronously (e.g., by S3, SNS, or EventBridge), it's important to configure a failure destination. This allows you to capture and handle events that fail processing, improving the reliability and observability of your serverless applications.",
level: nag_rules_1.NagMessageLevel.ERROR,
rule: lambda_1.LambdaAsyncFailureDestination,
node: node,
});
this.applyRule({
info: 'The Lambda function does not have an explicit memory value configured.',
explanation: "Lambda allocates CPU power in proportion to the amount of memory configured. By default, your functions have 128 MB of memory allocated. You can increase that value up to 10 GB. With more CPU resources, your Lambda function's duration might decrease. You can use tools such as AWS Lambda Power Tuning to test your function at different memory settings to find the one that matches your cost and performance requirements the best.",
level: nag_rules_1.NagMessageLevel.ERROR,
rule: lambda_1.LambdaDefaultMemorySize,
node: node,
});
this.applyRule({
info: 'The Lambda function does not have an explicitly defined timeout value.',
explanation: 'Lambda functions have a default timeout of 3 seconds. If your timeout value is too short, Lambda might terminate invocations prematurely. On the other side, setting the timeout much higher than the average execution may cause functions to execute for longer upon code malfunction, resulting in higher costs and possibly reaching concurrency limits depending on how such functions are invoked. You can also use AWS Lambda Power Tuning to test your function at different timeout settings to find the one that matches your cost and performance requirements the best.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: lambda_1.LambdaDefaultTimeout,
node: node,
});
this.applyRule({
info: 'The Lambda function does not have a dead letter target configured.',
explanation: 'When a Lambda function has the DeadLetterConfig property set, failed messages can be temporarily stored for review in an SQS queue or an SNS topic.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: lambda_1.LambdaDLQ,
node: node,
});
this.applyRule({
info: 'The Lambda Event Source Mapping does not have a destination configured for failed invocations.',
explanation: 'Configuring a destination for failed invocations in Lambda Event Source Mappings allows you to capture and process events that fail to be processed by your Lambda function. This helps in monitoring, debugging, and implementing retry mechanisms for failed events, improving the reliability and observability of your serverless applications.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: lambda_1.LambdaEventSourceMappingDestination,
node: node,
});
this.applyRule({
info: 'The Lambda function does not use the latest runtime version.',
explanation: 'Using the latest runtime version ensures that your Lambda function has access to the most recent features, performance improvements, and security updates. It is important to regularly update your Lambda functions to use the latest runtime versions to maintain optimal performance and security.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: lambda_1.LambdaLatestVersion,
node: node,
});
this.applyRule({
info: 'The Lambda IAM role uses wildcard permissions.',
explanation: 'You should follow least-privileged access and only allow the access needed to perform a given operation. If your Lambda function needs a broad range of permissions, you should know ahead of time which permissions you will need, have evaluated the risks of using broad permissions and can suppress this rule.',
level: nag_rules_1.NagMessageLevel.WARN,
rule: lambda_1.LambdaStarPermissions,
node: node,
});
this.applyRule({
info: 'The Lambda function does not have tracing set to Tracing.ACTIVE.',
explanation: 'When a Lambda function has ACTIVE tracing, Lambda automatically samples invocation requests, based on the sampling algorithm specified by X-Ray.',
level: nag_rules_1.NagMessageLevel.WARN,
rule: lambda_1.LambdaTracing,
node: node,
});
}
/**
* Check Cloudwatch Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkCloudwatch(node) {
this.applyRule({
info: 'The CloudWatch Log Group does not have an explicit retention policy defined.',
explanation: 'By default, logs are kept indefinitely and never expire. You can adjust the retention policy for each log group, keeping the indefinite retention, or choosing a retention period between one day and 10 years. For Lambda functions, this applies to their automatically created CloudWatch Log Groups.',
level: nag_rules_1.NagMessageLevel.WARN,
rule: cloudwatch_1.CloudWatchLogGroupRetentionPeriod,
node: node,
});
}
/**
* Check API Gateway Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkApiGw(node) {
this.applyRule({
info: 'The API Gateway Stage does not have access logging enabled.',
explanation: 'API Gateway provides access logging for API stages. Enable access logging on your API stages to monitor API requests and responses.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: apigw_1.APIGWAccessLogging,
node: node,
});
this.applyRule({
info: 'The API Gateway Stage is using default throttling setting.',
explanation: 'API Gateway default throttling settings may not be suitable for all applications. Custom throttling limits help protect your backend systems from being overwhelmed with requests, ensure consistent performance, and can be tailored to your specific use case.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: apigw_1.APIGWDefaultThrottling,
node: node,
});
this.applyRule({
info: 'The API Gateway logs are not configured for the JSON format.',
explanation: 'You can customize the log format that Amazon API Gateway uses to send logs. JSON Structured logging makes it easier to derive queries to answer arbitrary questions about the health of your application.',
level: nag_rules_1.NagMessageLevel.WARN,
rule: apigw_1.APIGWStructuredLogging,
node: node,
});
this.applyRule({
info: 'The API Gateway does not have Tracing enabled.',
explanation: 'Amazon API Gateway provides active tracing support for AWS X-Ray. Enable active tracing on your API stages to sample incoming requests and send traces to X-Ray.',
level: nag_rules_1.NagMessageLevel.WARN,
rule: apigw_1.APIGWXrayEnabled,
node: node,
});
}
/**
* Check AppSync Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkAppSync(node) {
this.applyRule({
info: 'The AppSync API does not have tracing enabled',
explanation: 'AWS AppSync can emit traces to AWS X-Ray, which enables visualizing service maps for faster troubleshooting.',
level: nag_rules_1.NagMessageLevel.WARN,
rule: appsync_1.AppSyncTracing,
node: node,
});
}
/**
* Check EventBridge Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkEventBridge(node) {
this.applyRule({
info: 'The EventBridge Target does not have a DLQ configured.',
explanation: "Configuring a Dead-Letter Queue (DLQ) for EventBridge rules helps manage failed event deliveries. When a rule's target fails to process an event, the DLQ captures these failed events, allowing for analysis, troubleshooting, and potential reprocessing. This improves the reliability and observability of your event-driven architectures by providing a safety net for handling delivery failures.",
level: nag_rules_1.NagMessageLevel.ERROR,
rule: eventbridge_1.EventBusDLQ,
node: node,
});
}
/**
* Check SNS Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkSNS(node) {
this.applyRule({
info: 'The SNS subscription does not have a redrive policy configured.',
explanation: 'Configuring a redrive policy helps manage message delivery failures by sending undeliverable messages to a dead-letter queue.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: sns_1.SNSRedrivePolicy,
node: node,
});
}
/**
* Check SQS Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkSQS(node) {
this.applyRule({
info: 'The SQS queue does not have a redrive policy configured.',
explanation: 'Configuring a redrive policy on an SQS queue allows you to define how many times SQS will make messages available for consumers before sending them to a dead-letter queue. This helps in managing message processing failures and provides a mechanism for handling problematic messages.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: sqs_1.SQSRedrivePolicy,
node: node,
});
}
/**
* Check StepFunctions Resources
* @param node the CfnResource to check
* @param ignores list of ignores for the resource
*/
checkStepFunctions(node) {
this.applyRule({
info: 'The StepFunction state machine does not have X-Ray tracing configured.',
explanation: 'AWS StepFunctions provides active tracing support for AWS X-Ray. Enable active tracing on your API stages to sample incoming requests and send traces to X-Ray.',
level: nag_rules_1.NagMessageLevel.ERROR,
rule: stepfunctions_1.StepFunctionStateMachineXray,
node: node,
});
}
}
exports.ServerlessChecks = ServerlessChecks;
_a = JSII_RTTI_SYMBOL_1;
ServerlessChecks[_a] = { fqn: "cdk-nag.ServerlessChecks", version: "2.36.41" };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serverless.js","sourceRoot":"","sources":["../../src/packs/serverless.ts"],"names":[],"mappings":";;;;;AAAA;;;EAGE;AACF,6CAA0C;AAE1C,0CAAoD;AACpD,4CAA+C;AAC/C,0CAKwB;AACxB,8CAAkD;AAClD,oDAAwE;AACxE,sDAAmD;AACnD,4CASyB;AACzB,sCAAgD;AAChD,sCAAgD;AAChD,0DAAsE;AAEtE;;;GAGG;AACH,MAAa,gBAAiB,SAAQ,kBAAO;IAC3C,YAAY,KAAoB;QAC9B,KAAK,CAAC,KAAK,CAAC,CAAC;QACb,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC;IAC/B,CAAC;IACM,KAAK,CAAC,IAAgB;QAC3B,IAAI,IAAI,YAAY,yBAAW,EAAE,CAAC;YAChC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACpB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,WAAW,CAAC,IAAiB;QACnC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,kGAAkG;YACxG,WAAW,EACT,yRAAyR;YAC3R,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,sCAA6B;YACnC,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,wEAAwE;YAC9E,WAAW,EACT,gbAAgb;YAClb,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,gCAAuB;YAC7B,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,wEAAwE;YAC9E,WAAW,EACT,qjBAAqjB;YACvjB,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,6BAAoB;YAC1B,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,oEAAoE;YAC1E,WAAW,EACT,qJAAqJ;YACvJ,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,kBAAS;YACf,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,gGAAgG;YACtG,WAAW,EACT,qVAAqV;YACvV,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,4CAAmC;YACzC,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,8DAA8D;YACpE,WAAW,EACT,uSAAuS;YACzS,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,4BAAmB;YACzB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,gDAAgD;YACtD,WAAW,EACT,qTAAqT;YACvT,KAAK,EAAE,2BAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,8BAAqB;YAC3B,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,kEAAkE;YACxE,WAAW,EACT,kJAAkJ;YACpJ,KAAK,EAAE,2BAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,sBAAa;YACnB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,eAAe,CAAC,IAAiB;QACvC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,8EAA8E;YACpF,WAAW,EACT,0SAA0S;YAC5S,KAAK,EAAE,2BAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,8CAAiC;YACvC,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,UAAU,CAAC,IAAiB;QAClC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,6DAA6D;YACnE,WAAW,EACT,qIAAqI;YACvI,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,0BAAkB;YACxB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,4DAA4D;YAClE,WAAW,EACT,kQAAkQ;YACpQ,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,8BAAsB;YAC5B,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,8DAA8D;YACpE,WAAW,EACT,2MAA2M;YAC7M,KAAK,EAAE,2BAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,8BAAsB;YAC5B,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,gDAAgD;YACtD,WAAW,EACT,kKAAkK;YACpK,KAAK,EAAE,2BAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,wBAAgB;YACtB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,YAAY,CAAC,IAAiB;QACpC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,+CAA+C;YACrD,WAAW,EACT,8GAA8G;YAChH,KAAK,EAAE,2BAAe,CAAC,IAAI;YAC3B,IAAI,EAAE,wBAAc;YACpB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,gBAAgB,CAAC,IAAiB;QACxC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,wDAAwD;YAC9D,WAAW,EACT,0YAA0Y;YAC5Y,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,yBAAW;YACjB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,QAAQ,CAAC,IAAiB;QAChC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,iEAAiE;YACvE,WAAW,EACT,+HAA+H;YACjI,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,sBAAgB;YACtB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,QAAQ,CAAC,IAAiB;QAChC,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,0DAA0D;YAChE,WAAW,EACT,4RAA4R;YAC9R,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,sBAAgB;YACtB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,kBAAkB,CAAC,IAAiB;QAC1C,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,wEAAwE;YAC9E,WAAW,EACT,iKAAiK;YACnK,KAAK,EAAE,2BAAe,CAAC,KAAK;YAC5B,IAAI,EAAE,4CAA4B;YAClC,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;;AA1OH,4CA2OC","sourcesContent":["/*\nCopyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\nSPDX-License-Identifier: Apache-2.0\n*/\nimport { CfnResource } from 'aws-cdk-lib';\nimport { IConstruct } from 'constructs';\nimport { NagPack, NagPackProps } from '../nag-pack';\nimport { NagMessageLevel } from '../nag-rules';\nimport {\n  APIGWAccessLogging,\n  APIGWDefaultThrottling,\n  APIGWStructuredLogging,\n  APIGWXrayEnabled,\n} from '../rules/apigw';\nimport { AppSyncTracing } from '../rules/appsync';\nimport { CloudWatchLogGroupRetentionPeriod } from '../rules/cloudwatch';\nimport { EventBusDLQ } from '../rules/eventbridge';\nimport {\n  LambdaAsyncFailureDestination,\n  LambdaDefaultMemorySize,\n  LambdaDefaultTimeout,\n  LambdaDLQ,\n  LambdaEventSourceMappingDestination,\n  LambdaLatestVersion,\n  LambdaStarPermissions,\n  LambdaTracing,\n} from '../rules/lambda';\nimport { SNSRedrivePolicy } from '../rules/sns';\nimport { SQSRedrivePolicy } from '../rules/sqs';\nimport { StepFunctionStateMachineXray } from '../rules/stepfunctions';\n\n/**\n * Serverless Checks are a compilation of rules to validate infrastructure-as-code template against recommended practices.\n *\n */\nexport class ServerlessChecks extends NagPack {\n  constructor(props?: NagPackProps) {\n    super(props);\n    this.packName = 'Serverless';\n  }\n  public visit(node: IConstruct): void {\n    if (node instanceof CfnResource) {\n      this.checkLambda(node);\n      this.checkCloudwatch(node);\n      this.checkApiGw(node);\n      this.checkAppSync(node);\n      this.checkEventBridge(node);\n      this.checkSNS(node);\n      this.checkSQS(node);\n      this.checkStepFunctions(node);\n    }\n  }\n\n  /**\n   * Check Lambda Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkLambda(node: CfnResource) {\n    this.applyRule({\n      info: 'The Lambda function does not have a configured failure destination for asynchronous invocations.',\n      explanation:\n        \"When a Lambda function is invoked asynchronously (e.g., by S3, SNS, or EventBridge), it's important to configure a failure destination. This allows you to capture and handle events that fail processing, improving the reliability and observability of your serverless applications.\",\n      level: NagMessageLevel.ERROR,\n      rule: LambdaAsyncFailureDestination,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda function does not have an explicit memory value configured.',\n      explanation:\n        \"Lambda allocates CPU power in proportion to the amount of memory configured. By default, your functions have 128 MB of memory allocated. You can increase that value up to 10 GB. With more CPU resources, your Lambda function's duration might decrease.  You can use tools such as AWS Lambda Power Tuning to test your function at different memory settings to find the one that matches your cost and performance requirements the best.\",\n      level: NagMessageLevel.ERROR,\n      rule: LambdaDefaultMemorySize,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda function does not have an explicitly defined timeout value.',\n      explanation:\n        'Lambda functions have a default timeout of 3 seconds. If your timeout value is too short, Lambda might terminate invocations prematurely. On the other side, setting the timeout much higher than the average execution may cause functions to execute for longer upon code malfunction, resulting in higher costs and possibly reaching concurrency limits depending on how such functions are invoked. You can also use AWS Lambda Power Tuning to test your function at different timeout settings to find the one that matches your cost and performance requirements the best.',\n      level: NagMessageLevel.ERROR,\n      rule: LambdaDefaultTimeout,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda function does not have a dead letter target configured.',\n      explanation:\n        'When a Lambda function has the DeadLetterConfig property set, failed messages can be temporarily stored for review in an SQS queue or an SNS topic.',\n      level: NagMessageLevel.ERROR,\n      rule: LambdaDLQ,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda Event Source Mapping does not have a destination configured for failed invocations.',\n      explanation:\n        'Configuring a destination for failed invocations in Lambda Event Source Mappings allows you to capture and process events that fail to be processed by your Lambda function. This helps in monitoring, debugging, and implementing retry mechanisms for failed events, improving the reliability and observability of your serverless applications.',\n      level: NagMessageLevel.ERROR,\n      rule: LambdaEventSourceMappingDestination,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda function does not use the latest runtime version.',\n      explanation:\n        'Using the latest runtime version ensures that your Lambda function has access to the most recent features, performance improvements, and security updates. It is important to regularly update your Lambda functions to use the latest runtime versions to maintain optimal performance and security.',\n      level: NagMessageLevel.ERROR,\n      rule: LambdaLatestVersion,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda IAM role uses wildcard permissions.',\n      explanation:\n        'You should follow least-privileged access and only allow the access needed to perform a given operation. If your Lambda function needs a broad range of permissions, you should know ahead of time which permissions you will need, have evaluated the risks of using broad permissions and can suppress this rule.',\n      level: NagMessageLevel.WARN,\n      rule: LambdaStarPermissions,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The Lambda function does not have tracing set to Tracing.ACTIVE.',\n      explanation:\n        'When a Lambda function has ACTIVE tracing, Lambda automatically samples invocation requests, based on the sampling algorithm specified by X-Ray.',\n      level: NagMessageLevel.WARN,\n      rule: LambdaTracing,\n      node: node,\n    });\n  }\n\n  /**\n   * Check Cloudwatch Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkCloudwatch(node: CfnResource) {\n    this.applyRule({\n      info: 'The CloudWatch Log Group does not have an explicit retention policy defined.',\n      explanation:\n        'By default, logs are kept indefinitely and never expire. You can adjust the retention policy for each log group, keeping the indefinite retention, or choosing a retention period between one day and 10 years. For Lambda functions, this applies to their automatically created CloudWatch Log Groups.',\n      level: NagMessageLevel.WARN,\n      rule: CloudWatchLogGroupRetentionPeriod,\n      node: node,\n    });\n  }\n\n  /**\n   * Check API Gateway Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkApiGw(node: CfnResource) {\n    this.applyRule({\n      info: 'The API Gateway Stage does not have access logging enabled.',\n      explanation:\n        'API Gateway provides access logging for API stages. Enable access logging on your API stages to monitor API requests and responses.',\n      level: NagMessageLevel.ERROR,\n      rule: APIGWAccessLogging,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The API Gateway Stage is using default throttling setting.',\n      explanation:\n        'API Gateway default throttling settings may not be suitable for all applications. Custom throttling limits help protect your backend systems from being overwhelmed with requests, ensure consistent performance, and can be tailored to your specific use case.',\n      level: NagMessageLevel.ERROR,\n      rule: APIGWDefaultThrottling,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The API Gateway logs are not configured for the JSON format.',\n      explanation:\n        'You can customize the log format that Amazon API Gateway uses to send logs. JSON Structured logging makes it easier to derive queries to answer arbitrary questions about the health of your application.',\n      level: NagMessageLevel.WARN,\n      rule: APIGWStructuredLogging,\n      node: node,\n    });\n\n    this.applyRule({\n      info: 'The API Gateway does not have Tracing enabled.',\n      explanation:\n        'Amazon API Gateway provides active tracing support for AWS X-Ray. Enable active tracing on your API stages to sample incoming requests and send traces to X-Ray.',\n      level: NagMessageLevel.WARN,\n      rule: APIGWXrayEnabled,\n      node: node,\n    });\n  }\n\n  /**\n   * Check AppSync Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkAppSync(node: CfnResource) {\n    this.applyRule({\n      info: 'The AppSync API does not have tracing enabled',\n      explanation:\n        'AWS AppSync can emit traces to AWS X-Ray, which enables visualizing service maps for faster troubleshooting.',\n      level: NagMessageLevel.WARN,\n      rule: AppSyncTracing,\n      node: node,\n    });\n  }\n\n  /**\n   * Check EventBridge Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkEventBridge(node: CfnResource) {\n    this.applyRule({\n      info: 'The EventBridge Target does not have a DLQ configured.',\n      explanation:\n        \"Configuring a Dead-Letter Queue (DLQ) for EventBridge rules helps manage failed event deliveries. When a rule's target fails to process an event, the DLQ captures these failed events, allowing for analysis, troubleshooting, and potential reprocessing. This improves the reliability and observability of your event-driven architectures by providing a safety net for handling delivery failures.\",\n      level: NagMessageLevel.ERROR,\n      rule: EventBusDLQ,\n      node: node,\n    });\n  }\n\n  /**\n   * Check SNS Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkSNS(node: CfnResource) {\n    this.applyRule({\n      info: 'The SNS subscription does not have a redrive policy configured.',\n      explanation:\n        'Configuring a redrive policy helps manage message delivery failures by sending undeliverable messages to a dead-letter queue.',\n      level: NagMessageLevel.ERROR,\n      rule: SNSRedrivePolicy,\n      node: node,\n    });\n  }\n\n  /**\n   * Check SQS Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkSQS(node: CfnResource) {\n    this.applyRule({\n      info: 'The SQS queue does not have a redrive policy configured.',\n      explanation:\n        'Configuring a redrive policy on an SQS queue allows you to define how many times SQS will make messages available for consumers before sending them to a dead-letter queue. This helps in managing message processing failures and provides a mechanism for handling problematic messages.',\n      level: NagMessageLevel.ERROR,\n      rule: SQSRedrivePolicy,\n      node: node,\n    });\n  }\n\n  /**\n   * Check StepFunctions Resources\n   * @param node the CfnResource to check\n   * @param ignores list of ignores for the resource\n   */\n  private checkStepFunctions(node: CfnResource) {\n    this.applyRule({\n      info: 'The StepFunction state machine does not have X-Ray tracing configured.',\n      explanation:\n        'AWS StepFunctions provides active tracing support for AWS X-Ray. Enable active tracing on your API stages to sample incoming requests and send traces to X-Ray.',\n      level: NagMessageLevel.ERROR,\n      rule: StepFunctionStateMachineXray,\n      node: node,\n    });\n  }\n}\n"]}