@aws-mdaa/ecs-constructs 1.2.0

package/README.md

@@ -0,0 +1,19 @@
+# Construct Overview
+
+Opinionated implementation of the Layer 2 CDK Constructs.
+
+## Security/Compliance
+
+### ECS Clusters
+* Enforce Cluster Name
+* Enforces KMS CMK encryption at rest
+* Enforces container insights
+* Enforces CloudWatch logging
+
+### Fargate Services
+* Enforce Fargate Name
+* Enforces non-public IP
+
+### Container Definitions
+* Enforce Definition Name
+* Enforces CloudWatch logging

package/lib/cluster.d.ts

@@ -0,0 +1,50 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MdaaConstructProps } from '@aws-mdaa/construct';
+import { IVpc } from 'aws-cdk-lib/aws-ec2';
+import { AddCapacityOptions, CloudMapNamespaceOptions, Cluster } from 'aws-cdk-lib/aws-ecs';
+import { IKey } from 'aws-cdk-lib/aws-kms';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+/**
+ * Properties for creating a Compliance ECS cluster
+ */
+export interface MdaaECSClusterProps extends MdaaConstructProps {
+    readonly clusterName?: string;
+    /**
+     * Q-ENHANCED-PROPERTY
+     * Required VPC for ECS cluster deployment providing network isolation and security controls for containerized applications. Defines the network environment where ECS instances and ENIs will be deployed for secure container networking and connectivity.
+     *
+     * Use cases: Network isolation; VPC integration; Secure networking; Container connectivity
+     *
+     * AWS: Amazon VPC for ECS cluster network isolation and secure container deployment
+     *
+     * Validation: Must be valid IVpc interface; required for ECS cluster network deployment and security
+     *   * See: https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IVpc.html
+     **/
+    readonly vpc: IVpc;
+    readonly defaultCloudMapNamespace?: CloudMapNamespaceOptions;
+    /**
+     * Q-ENHANCED-PROPERTY
+     * Optional EC2 capacity configuration for ECS cluster compute resources enabling container hosting and scaling capabilities. Provides EC2-based compute capacity for container workloads with auto-scaling and resource management capabilities.
+     *
+     * Use cases: EC2 capacity; Container hosting; Compute scaling; Resource management
+     *
+     * AWS: Amazon EC2 capacity for ECS cluster compute resources and container hosting
+     *
+     * Validation: Must be valid AddCapacityOptions if provided; enables EC2-based container compute capacity
+     *   **/
+    readonly capacity?: AddCapacityOptions;
+    readonly enableFargateCapacityProviders?: boolean;
+    readonly kmsKey: IKey;
+    readonly logGroup: ILogGroup;
+}
+/**
+ * A construct for creating a compliant ECS cluster resource.
+ */
+export declare class MdaaECSCluster extends Cluster {
+    private static setProps;
+    constructor(scope: Construct, id: string, props: MdaaECSClusterProps);
+}

package/lib/cluster.js

@@ -0,0 +1,53 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdaaECSCluster = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+
+const construct_1 = require("@aws-mdaa/construct"); //NOSONAR
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+/**
+ * A construct for creating a compliant ECS cluster resource.
+ */
+class MdaaECSCluster extends aws_ecs_1.Cluster {
+    static setProps(props) {
+        const overrideProps = {
+            clusterName: props.naming.resourceName(props.clusterName, 255),
+            containerInsights: true,
+            executeCommandConfiguration: {
+                kmsKey: props.kmsKey,
+                logConfiguration: {
+                    cloudWatchEncryptionEnabled: true,
+                    cloudWatchLogGroup: props.logGroup,
+                },
+                logging: aws_ecs_1.ExecuteCommandLogging.OVERRIDE,
+            },
+        };
+        const allProps = {
+            ...props,
+            ...overrideProps,
+        };
+        return allProps;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, MdaaECSCluster.setProps(props));
+        new construct_1.MdaaParamAndOutput(this, {
+            ...{
+                resourceType: 'cluster',
+                resourceId: props.clusterName,
+                name: 'arn',
+                value: this.clusterArn,
+            },
+            ...props,
+        }, scope);
+    }
+}
+exports.MdaaECSCluster = MdaaECSCluster;
+_a = JSII_RTTI_SYMBOL_1;
+MdaaECSCluster[_a] = { fqn: "@aws-mdaa/ecs-constructs.MdaaECSCluster", version: "1.2.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/container-definition.d.ts

@@ -0,0 +1,208 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MdaaConstructProps } from '@aws-mdaa/construct';
+import { Duration } from 'aws-cdk-lib';
+import { ContainerDefinition, ContainerImage, EnvironmentFile, HealthCheck, LinuxParameters, PortMapping, Secret, SystemControl, TaskDefinition, Ulimit } from 'aws-cdk-lib/aws-ecs';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+/**
+ * Properties for creating a Compliance ECS containerdefinition
+ */
+export interface MdaaECSContainerDefinitionProps extends MdaaConstructProps {
+    readonly taskDefinition: TaskDefinition;
+    readonly image: ContainerImage;
+    readonly containerName?: string;
+    /**
+     * Q-ENHANCED-PROPERTY
+     * Optional command array for container execution overriding the default CMD built into the container image. Provides custom command execution for container startup and application initialization with proper command-line argument handling.
+     *
+     * Use cases: Custom command execution; Application startup; Command override; Container initialization
+     *
+     * AWS: Docker container command for custom execution and application startup configuration
+     *
+     * Validation: Must be array of command strings if provided; overrides container image CMD when specified
+     **/
+    readonly command?: string[];
+    readonly cpu?: number;
+    readonly disableNetworking?: boolean;
+    readonly dnsSearchDomains?: string[];
+    readonly dnsServers?: string[];
+    readonly dockerLabels?: {
+        [key: string]: string;
+    };
+    readonly dockerSecurityOptions?: string[];
+    readonly entryPoint?: string[];
+    /**
+     * Q-ENHANCED-PROPERTY
+     * Optional environment variables map for container configuration enabling application configuration and runtime parameter passing. Provides environment variables for container applications with secure configuration management and runtime customization.
+     *
+     * Use cases: Application configuration; Runtime parameters; Environment setup; Configuration management
+     *
+     * AWS: Container environment variables for application configuration and runtime parameter management
+     *
+     * Validation: Must be object with string keys and values if provided; enables application configuration
+     *   **/
+    readonly environment?: {
+        [key: string]: string;
+    };
+    readonly environmentFiles?: EnvironmentFile[];
+    readonly secrets?: {
+        [key: string]: Secret;
+    };
+    /**
+     * Time duration (in seconds) to wait before giving up on resolving dependencies for a container.
+     * @default - none
+     */
+    readonly startTimeout?: Duration;
+    /**
+     * Time duration (in seconds) to wait before the container is forcefully killed if it doesn't exit normally on its own.
+     * @default - none
+     */
+    readonly stopTimeout?: Duration;
+    /**
+     * Specifies whether the container is marked essential.
+     * If the essential parameter of a container is marked as true, and that container fails
+     * or stops for any reason, all other containers that are part of the task are stopped.
+     * If the essential parameter of a container is marked as false, then its failure does not
+     * affect the rest of the containers in a task. All tasks must have at least one essential container.
+     * If this parameter is omitted, a container is assumed to be essential.
+     * @default true
+     */
+    readonly essential?: boolean;
+    /**
+     * A list of hostnames and IP address mappings to append to the /etc/hosts file on the container.
+     * @default - No extra hosts.
+     */
+    readonly extraHosts?: {
+        [name: string]: string;
+    };
+    /**
+     * The health check command and associated configuration parameters for the container.
+     * @default - Health check configuration from container.
+     */
+    readonly healthCheck?: HealthCheck;
+    /**
+     * The hostname to use for your container.
+     * @default - Automatic hostname.
+     */
+    readonly hostname?: string;
+    /**
+     * The amount (in MiB) of memory to present to the container.
+     * If your container attempts to exceed the allocated memory, the container
+     * is terminated.
+     * At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.
+     * @default - No memory limit.
+     */
+    readonly memoryLimitMiB?: number;
+    /**
+     * The soft limit (in MiB) of memory to reserve for the container.
+     * When system memory is under heavy contention, Docker attempts to keep the
+     * container memory to this soft limit. However, your container can consume more
+     * memory when it needs to, up to either the hard limit specified with the memory
+     * parameter (if applicable), or all of the available memory on the container
+     * instance, whichever comes first.
+     * At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.
+     * @default - No memory reserved.
+     */
+    readonly memoryReservationMiB?: number;
+    /**
+     * Specifies whether the container is marked as privileged.
+     * When this parameter is true, the container is given elevated privileges on the host container instance (similar to the root user).
+     * @default false
+     */
+    readonly privileged?: boolean;
+    /**
+     * When this parameter is true, the container is given read-only access to its root file system.
+     * @default false
+     */
+    readonly readonlyRootFilesystem?: boolean;
+    /**
+     * The user name to use inside the container.
+     * @default root
+     */
+    readonly user?: string;
+    /**
+     * The working directory in which to run commands inside the container.
+     * @default /
+     */
+    readonly workingDirectory?: string;
+    /**
+     * Linux-specific modifications that are applied to the container, such as Linux kernel capabilities.
+     * For more information see [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).
+     * @default - No Linux parameters.
+     */
+    readonly linuxParameters?: LinuxParameters;
+    /**
+     * The number of GPUs assigned to the container.
+     * @default - No GPUs assigned.
+     */
+    readonly gpuCount?: number;
+    /**
+     * The port mappings to add to the container definition.
+     * @default - No ports are mapped.
+     */
+    readonly portMappings?: PortMapping[];
+    /**
+     * The inference accelerators referenced by the container.
+     * @default - No inference accelerators assigned.
+     */
+    readonly inferenceAcceleratorResources?: string[];
+    /**
+     * A list of namespaced kernel parameters to set in the container.
+     * @default - No system controls are set.
+     * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-systemcontrol.html
+     * See: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_systemcontrols
+     */
+    readonly systemControls?: SystemControl[];
+    /**
+     * When this parameter is true, a TTY is allocated. This parameter maps to Tty in the "Create a container section" of the
+     * Docker Remote API and the --tty option to `docker run`.
+     * @default - false
+     * See: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_pseudoterminal
+     */
+    readonly pseudoTerminal?: boolean;
+    /**
+     * An array of ulimits to set in the container.
+     */
+    readonly ulimits?: Ulimit[];
+    /**
+     * Prefix for the log streams
+     * The awslogs-stream-prefix option allows you to associate a log stream
+     * with the specified prefix, the container name, and the ID of the Amazon
+     * ECS task to which the container belongs. If you specify a prefix with
+     * this option, then the log stream takes the following format:
+     *     prefix-name/container-name/ecs-task-id
+     */
+    readonly streamPrefix: string;
+    /**
+     * The log group to log to
+     * @default - A log group is automatically created.
+     */
+    readonly logGroup: ILogGroup;
+    /**
+     * This option defines a multiline start pattern in Python strftime format.
+     * A log message consists of a line that matches the pattern and any
+     * following lines that don’t match the pattern. Thus the matched line is
+     * the delimiter between log messages.
+     * @default - No multiline matching.
+     */
+    readonly datetimeFormat?: string;
+    /**
+     * This option defines a multiline start pattern using a regular expression.
+     * A log message consists of a line that matches the pattern and any
+     * following lines that don’t match the pattern. Thus the matched line is
+     * the delimiter between log messages.
+     * This option is ignored if datetimeFormat is also configured.
+     * @default - No multiline matching.
+     */
+    readonly multilinePattern?: string;
+}
+/**
+ * A construct for creating a compliant ECS containerdefinition resource.
+ */
+export declare class MdaaECSContainerDefinition extends ContainerDefinition {
+    private static setProps;
+    constructor(scope: Construct, id: string, props: MdaaECSContainerDefinitionProps);
+}

package/lib/container-definition.js

@@ -0,0 +1,71 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdaaECSContainerDefinition = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+
+const construct_1 = require("@aws-mdaa/construct"); //NOSONAR
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+const construct_2 = require("@aws-mdaa/construct"); //NOSONAR
+/**
+ * A construct for creating a compliant ECS containerdefinition resource.
+ */
+class MdaaECSContainerDefinition extends aws_ecs_1.ContainerDefinition {
+    static setProps(props) {
+        const overrideProps = {
+            containerName: props.naming.resourceName(props.containerName, 255),
+            logging: aws_ecs_1.LogDriver.awsLogs({
+                logGroup: props.logGroup,
+                streamPrefix: props.streamPrefix,
+                datetimeFormat: props.datetimeFormat,
+                multilinePattern: props.multilinePattern,
+            }),
+        };
+        const allProps = {
+            ...props,
+            ...overrideProps,
+        };
+        return allProps;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, MdaaECSContainerDefinition.setProps(props));
+        if (this.taskDefinition.executionRole) {
+            construct_2.MdaaNagSuppressions.addCodeResourceSuppressions(this.taskDefinition.executionRole, [
+                {
+                    id: 'AwsSolutions-IAM5',
+                    reason: 'Access limited to Log Group. Log Stream name not known at deployment time.',
+                },
+                {
+                    id: 'NIST.800.53.R5-IAMNoInlinePolicy',
+                    reason: 'Inline policy is specific to task logging and is appropriate.',
+                },
+                {
+                    id: 'HIPAA.Security-IAMNoInlinePolicy',
+                    reason: 'Inline policy is specific to task logging and is appropriate.',
+                },
+                {
+                    id: 'PCI.DSS.321-IAMNoInlinePolicy',
+                    reason: 'Inline policy is specific to task logging and is appropriate.',
+                },
+            ], true);
+        }
+        new construct_1.MdaaParamAndOutput(this, {
+            ...{
+                resourceType: 'containerdefinition',
+                resourceId: props.containerName,
+                name: 'name',
+                value: this.containerName,
+            },
+            ...props,
+        }, scope);
+    }
+}
+exports.MdaaECSContainerDefinition = MdaaECSContainerDefinition;
+_a = JSII_RTTI_SYMBOL_1;
+MdaaECSContainerDefinition[_a] = { fqn: "@aws-mdaa/ecs-constructs.MdaaECSContainerDefinition", version: "1.2.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-definition.js","sourceRoot":"","sources":["container-definition.ts"],"names":[],"mappings":";;;;;AAAA;;;GAGG;AAEH,mDAA6E,CAAC,SAAS;AAEvF,iDAa6B;AAE7B,mDAA0D,CAAC,SAAS;AAwMpE;;GAEG;AACH,MAAa,0BAA2B,SAAQ,6BAAmB;IACzD,MAAM,CAAC,QAAQ,CAAC,KAAsC;QAC5D,MAAM,aAAa,GAAG;YACpB,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,aAAa,EAAE,GAAG,CAAC;YAClE,OAAO,EAAE,mBAAS,CAAC,OAAO,CAAC;gBACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,cAAc,EAAE,KAAK,CAAC,cAAc;gBACpC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;aACzC,CAAC;SACH,CAAC;QACF,MAAM,QAAQ,GAA6B;YACzC,GAAG,KAAK;YACR,GAAG,aAAa;SACjB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAsC;QAC9E,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,0BAA0B,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;QAE7D,IAAI,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;YACtC,+BAAmB,CAAC,2BAA2B,CAC7C,IAAI,CAAC,cAAc,CAAC,aAAa,EACjC;gBACE;oBACE,EAAE,EAAE,mBAAmB;oBACvB,MAAM,EAAE,4EAA4E;iBACrF;gBACD;oBACE,EAAE,EAAE,kCAAkC;oBACtC,MAAM,EAAE,+DAA+D;iBACxE;gBACD;oBACE,EAAE,EAAE,kCAAkC;oBACtC,MAAM,EAAE,+DAA+D;iBACxE;gBACD;oBACE,EAAE,EAAE,+BAA+B;oBACnC,MAAM,EAAE,+DAA+D;iBACxE;aACF,EACD,IAAI,CACL,CAAC;QACJ,CAAC;QAED,IAAI,8BAAkB,CACpB,IAAI,EACJ;YACE,GAAG;gBACD,YAAY,EAAE,qBAAqB;gBACnC,UAAU,EAAE,KAAK,CAAC,aAAa;gBAC/B,IAAI,EAAE,MAAM;gBACZ,KAAK,EAAE,IAAI,CAAC,aAAa;aAC1B;YACD,GAAG,KAAK;SACT,EACD,KAAK,CACN,CAAC;IACJ,CAAC;;AA3DH,gEA4DC","sourcesContent":["/*!\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { MdaaConstructProps, MdaaParamAndOutput } from '@aws-mdaa/construct'; //NOSONAR\nimport { Duration } from 'aws-cdk-lib';\nimport {\n  ContainerDefinition,\n  ContainerDefinitionProps,\n  ContainerImage,\n  EnvironmentFile,\n  HealthCheck,\n  LinuxParameters,\n  LogDriver,\n  PortMapping,\n  Secret,\n  SystemControl,\n  TaskDefinition,\n  Ulimit,\n} from 'aws-cdk-lib/aws-ecs';\nimport { ILogGroup } from 'aws-cdk-lib/aws-logs';\nimport { MdaaNagSuppressions } from '@aws-mdaa/construct'; //NOSONAR\nimport { Construct } from 'constructs';\n\n/**\n * Properties for creating a Compliance ECS containerdefinition\n */\nexport interface MdaaECSContainerDefinitionProps extends MdaaConstructProps {\n  readonly taskDefinition: TaskDefinition;\n  readonly image: ContainerImage;\n  readonly containerName?: string;\n  /**\n   * Q-ENHANCED-PROPERTY\n   * Optional command array for container execution overriding the default CMD built into the container image. Provides custom command execution for container startup and application initialization with proper command-line argument handling.\n   *\n   * Use cases: Custom command execution; Application startup; Command override; Container initialization\n   *\n   * AWS: Docker container command for custom execution and application startup configuration\n   *\n   * Validation: Must be array of command strings if provided; overrides container image CMD when specified\n   **/\n  readonly command?: string[];\n  readonly cpu?: number;\n  readonly disableNetworking?: boolean;\n  readonly dnsSearchDomains?: string[];\n  readonly dnsServers?: string[];\n  readonly dockerLabels?: {\n    [key: string]: string;\n  };\n  readonly dockerSecurityOptions?: string[];\n  readonly entryPoint?: string[];\n  /**\n   * Q-ENHANCED-PROPERTY\n   * Optional environment variables map for container configuration enabling application configuration and runtime parameter passing. Provides environment variables for container applications with secure configuration management and runtime customization.\n   *\n   * Use cases: Application configuration; Runtime parameters; Environment setup; Configuration management\n   *\n   * AWS: Container environment variables for application configuration and runtime parameter management\n   *\n   * Validation: Must be object with string keys and values if provided; enables application configuration\n   *   **/\n  readonly environment?: {\n    [key: string]: string;\n  };\n  readonly environmentFiles?: EnvironmentFile[];\n  readonly secrets?: {\n    [key: string]: Secret;\n  };\n  /**\n   * Time duration (in seconds) to wait before giving up on resolving dependencies for a container.\n   * @default - none\n   */\n  readonly startTimeout?: Duration;\n  /**\n   * Time duration (in seconds) to wait before the container is forcefully killed if it doesn't exit normally on its own.\n   * @default - none\n   */\n  readonly stopTimeout?: Duration;\n  /**\n   * Specifies whether the container is marked essential.\n   * If the essential parameter of a container is marked as true, and that container fails\n   * or stops for any reason, all other containers that are part of the task are stopped.\n   * If the essential parameter of a container is marked as false, then its failure does not\n   * affect the rest of the containers in a task. All tasks must have at least one essential container.\n   * If this parameter is omitted, a container is assumed to be essential.\n   * @default true\n   */\n  readonly essential?: boolean;\n  /**\n   * A list of hostnames and IP address mappings to append to the /etc/hosts file on the container.\n   * @default - No extra hosts.\n   */\n  readonly extraHosts?: {\n    [name: string]: string;\n  };\n  /**\n   * The health check command and associated configuration parameters for the container.\n   * @default - Health check configuration from container.\n   */\n  readonly healthCheck?: HealthCheck;\n  /**\n   * The hostname to use for your container.\n   * @default - Automatic hostname.\n   */\n  readonly hostname?: string;\n  /**\n   * The amount (in MiB) of memory to present to the container.\n   * If your container attempts to exceed the allocated memory, the container\n   * is terminated.\n   * At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.\n   * @default - No memory limit.\n   */\n  readonly memoryLimitMiB?: number;\n  /**\n   * The soft limit (in MiB) of memory to reserve for the container.\n   * When system memory is under heavy contention, Docker attempts to keep the\n   * container memory to this soft limit. However, your container can consume more\n   * memory when it needs to, up to either the hard limit specified with the memory\n   * parameter (if applicable), or all of the available memory on the container\n   * instance, whichever comes first.\n   * At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.\n   * @default - No memory reserved.\n   */\n  readonly memoryReservationMiB?: number;\n  /**\n   * Specifies whether the container is marked as privileged.\n   * When this parameter is true, the container is given elevated privileges on the host container instance (similar to the root user).\n   * @default false\n   */\n  readonly privileged?: boolean;\n  /**\n   * When this parameter is true, the container is given read-only access to its root file system.\n   * @default false\n   */\n  readonly readonlyRootFilesystem?: boolean;\n  /**\n   * The user name to use inside the container.\n   * @default root\n   */\n  readonly user?: string;\n  /**\n   * The working directory in which to run commands inside the container.\n   * @default /\n   */\n  readonly workingDirectory?: string;\n  /**\n   * Linux-specific modifications that are applied to the container, such as Linux kernel capabilities.\n   * For more information see [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).\n   * @default - No Linux parameters.\n   */\n  readonly linuxParameters?: LinuxParameters;\n  /**\n   * The number of GPUs assigned to the container.\n   * @default - No GPUs assigned.\n   */\n  readonly gpuCount?: number;\n  /**\n   * The port mappings to add to the container definition.\n   * @default - No ports are mapped.\n   */\n  readonly portMappings?: PortMapping[];\n  /**\n   * The inference accelerators referenced by the container.\n   * @default - No inference accelerators assigned.\n   */\n  readonly inferenceAcceleratorResources?: string[];\n  /**\n   * A list of namespaced kernel parameters to set in the container.\n   * @default - No system controls are set.\n   * See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-systemcontrol.html\n   * See: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_systemcontrols\n   */\n  readonly systemControls?: SystemControl[];\n  /**\n   * When this parameter is true, a TTY is allocated. This parameter maps to Tty in the \"Create a container section\" of the\n   * Docker Remote API and the --tty option to `docker run`.\n   * @default - false\n   * See: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_pseudoterminal\n   */\n  readonly pseudoTerminal?: boolean;\n  /**\n   * An array of ulimits to set in the container.\n   */\n  readonly ulimits?: Ulimit[];\n\n  /**\n   * Prefix for the log streams\n   * The awslogs-stream-prefix option allows you to associate a log stream\n   * with the specified prefix, the container name, and the ID of the Amazon\n   * ECS task to which the container belongs. If you specify a prefix with\n   * this option, then the log stream takes the following format:\n   *     prefix-name/container-name/ecs-task-id\n   */\n  readonly streamPrefix: string;\n\n  /**\n   * The log group to log to\n   * @default - A log group is automatically created.\n   */\n  readonly logGroup: ILogGroup;\n\n  /**\n   * This option defines a multiline start pattern in Python strftime format.\n   * A log message consists of a line that matches the pattern and any\n   * following lines that don’t match the pattern. Thus the matched line is\n   * the delimiter between log messages.\n   * @default - No multiline matching.\n   */\n  readonly datetimeFormat?: string;\n\n  /**\n   * This option defines a multiline start pattern using a regular expression.\n   * A log message consists of a line that matches the pattern and any\n   * following lines that don’t match the pattern. Thus the matched line is\n   * the delimiter between log messages.\n   * This option is ignored if datetimeFormat is also configured.\n   * @default - No multiline matching.\n   */\n  readonly multilinePattern?: string;\n}\n\n/**\n * A construct for creating a compliant ECS containerdefinition resource.\n */\nexport class MdaaECSContainerDefinition extends ContainerDefinition {\n  private static setProps(props: MdaaECSContainerDefinitionProps): ContainerDefinitionProps {\n    const overrideProps = {\n      containerName: props.naming.resourceName(props.containerName, 255),\n      logging: LogDriver.awsLogs({\n        logGroup: props.logGroup,\n        streamPrefix: props.streamPrefix,\n        datetimeFormat: props.datetimeFormat,\n        multilinePattern: props.multilinePattern,\n      }),\n    };\n    const allProps: ContainerDefinitionProps = {\n      ...props,\n      ...overrideProps,\n    };\n    return allProps;\n  }\n\n  constructor(scope: Construct, id: string, props: MdaaECSContainerDefinitionProps) {\n    super(scope, id, MdaaECSContainerDefinition.setProps(props));\n\n    if (this.taskDefinition.executionRole) {\n      MdaaNagSuppressions.addCodeResourceSuppressions(\n        this.taskDefinition.executionRole,\n        [\n          {\n            id: 'AwsSolutions-IAM5',\n            reason: 'Access limited to Log Group. Log Stream name not known at deployment time.',\n          },\n          {\n            id: 'NIST.800.53.R5-IAMNoInlinePolicy',\n            reason: 'Inline policy is specific to task logging and is appropriate.',\n          },\n          {\n            id: 'HIPAA.Security-IAMNoInlinePolicy',\n            reason: 'Inline policy is specific to task logging and is appropriate.',\n          },\n          {\n            id: 'PCI.DSS.321-IAMNoInlinePolicy',\n            reason: 'Inline policy is specific to task logging and is appropriate.',\n          },\n        ],\n        true,\n      );\n    }\n\n    new MdaaParamAndOutput(\n      this,\n      {\n        ...{\n          resourceType: 'containerdefinition',\n          resourceId: props.containerName,\n          name: 'name',\n          value: this.containerName,\n        },\n        ...props,\n      },\n      scope,\n    );\n  }\n}\n"]}

package/lib/fargate-service.d.ts

@@ -0,0 +1,69 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MdaaConstructProps } from '@aws-mdaa/construct';
+import { Duration } from 'aws-cdk-lib';
+import { ISecurityGroup, ISubnet } from 'aws-cdk-lib/aws-ec2';
+import { CapacityProviderStrategy, CloudMapOptions, DeploymentCircuitBreaker, DeploymentController, FargateService, ICluster, PropagatedTagSource, ServiceConnectProps, TaskDefinition } from 'aws-cdk-lib/aws-ecs';
+import { Construct } from 'constructs';
+/**
+ * Properties for creating a Compliance ECS fargateservice
+ */
+export interface MdaaECSFargateServiceProps extends MdaaConstructProps {
+    readonly taskDefinition: TaskDefinition;
+    /**
+     * Q-ENHANCED-PROPERTY
+     * Required array of subnets for Fargate service network placement enabling VPC connectivity and network isolation. Defines the network subnets where Fargate tasks will be deployed for secure networking and connectivity within the VPC environment.
+     *
+     * Use cases: Network placement; VPC connectivity; Subnet distribution; Network isolation
+     *
+     * AWS: VPC subnets for ECS Fargate service network placement and connectivity
+     *
+     * Validation: Must be array of valid ISubnet interfaces; required for Fargate service network placement
+     *   * See: https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.ISubnet.html
+     **/
+    readonly subnets: ISubnet[];
+    /**
+     * Q-ENHANCED-PROPERTY
+     * Required array of security groups for Fargate service network access control defining inbound and outbound traffic rules. Provides network-level security controls for Fargate tasks ensuring secure communication and access control within the VPC.
+     *
+     * Use cases: Network security; Access control; Traffic filtering; Security group management
+     *
+     * AWS: VPC security groups for ECS Fargate service network security and access control
+     *
+     * Validation: Must be array of valid ISecurityGroup interfaces; required for network security and access control
+     *   * See: https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.ISecurityGroup.html
+     **/
+    readonly securityGroups: ISecurityGroup[];
+    readonly cluster: ICluster;
+    readonly desiredCount?: number;
+    readonly serviceName?: string;
+    readonly maxHealthyPercent?: number;
+    readonly minHealthyPercent?: number;
+    readonly healthCheckGracePeriod?: Duration;
+    readonly cloudMapOptions?: CloudMapOptions;
+    readonly propagateTags: PropagatedTagSource.TASK_DEFINITION | PropagatedTagSource.SERVICE;
+    readonly enableECSManagedTags?: boolean;
+    readonly deploymentController?: DeploymentController;
+    readonly circuitBreaker?: DeploymentCircuitBreaker;
+    readonly capacityProviderStrategies?: CapacityProviderStrategy[];
+    /**
+     * Whether to enable the ability to execute into a container
+     *  @default - undefined
+     */
+    readonly enableExecuteCommand?: boolean;
+    /**
+     * Configuration for Service Connect.
+     * @default No ports are advertised via Service Connect on this service, and the service
+     * cannot make requests to other services via Service Connect.
+     */
+    readonly serviceConnectConfiguration?: ServiceConnectProps;
+}
+/**
+ * A construct for creating a compliant ECS fargateservice resource.
+ */
+export declare class MdaaECSFargateService extends FargateService {
+    private static setProps;
+    constructor(scope: Construct, id: string, props: MdaaECSFargateServiceProps);
+}

package/lib/fargate-service.js

@@ -0,0 +1,58 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MdaaECSFargateService = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+
+const construct_1 = require("@aws-mdaa/construct"); //NOSONAR
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+/**
+ * A construct for creating a compliant ECS fargateservice resource.
+ */
+class MdaaECSFargateService extends aws_ecs_1.FargateService {
+    static setProps(props) {
+        const overrideProps = {
+            serviceName: props.naming.resourceName(props.serviceName, 255),
+            assignPublicIp: false,
+            platformVersion: aws_ecs_1.FargatePlatformVersion.LATEST,
+            vpcSubnets: {
+                subnets: props.subnets,
+            },
+        };
+        const allProps = {
+            ...props,
+            ...overrideProps,
+        };
+        return allProps;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, MdaaECSFargateService.setProps(props));
+        new construct_1.MdaaParamAndOutput(this, {
+            ...{
+                resourceType: 'fargateservice',
+                resourceId: props.serviceName,
+                name: 'arn',
+                value: this.serviceArn,
+            },
+            ...props,
+        }, scope);
+        new construct_1.MdaaParamAndOutput(this, {
+            ...{
+                resourceType: 'fargateservice',
+                resourceId: props.serviceName,
+                name: 'name',
+                value: this.serviceName,
+            },
+            ...props,
+        }, scope);
+    }
+}
+exports.MdaaECSFargateService = MdaaECSFargateService;
+_a = JSII_RTTI_SYMBOL_1;
+MdaaECSFargateService[_a] = { fqn: "@aws-mdaa/ecs-constructs.MdaaECSFargateService", version: "1.2.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from './cluster';
+export * from './fargate-service';
+export * from './container-definition';

package/lib/index.js

@@ -0,0 +1,26 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cluster"), exports);
+__exportStar(require("./fargate-service"), exports);
+__exportStar(require("./container-definition"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7OztHQUdHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsNENBQTBCO0FBQzFCLG9EQUFrQztBQUNsQyx5REFBdUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCBBbWF6b24uY29tLCBJbmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2NsdXN0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9mYXJnYXRlLXNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250YWluZXItZGVmaW5pdGlvbic7XG4iXX0=