@gradientedge/cdk-utils 7.4.0 → 7.6.0

package/dist/src/lib/construct/site-with-ecs-backend/main.d.ts

@@ -8,7 +8,6 @@ import * as iam from 'aws-cdk-lib/aws-iam';
 import * as logs from 'aws-cdk-lib/aws-logs';
 import * as route53 from 'aws-cdk-lib/aws-route53';
 import * as s3 from 'aws-cdk-lib/aws-s3';
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
 import { Construct } from 'constructs';
 import { CommonConstruct } from '../../common';
 import { SiteWithEcsBackendProps } from '../../types';
@@ -55,7 +54,6 @@ export declare class SiteWithEcsBackend extends CommonConstruct {
     siteLogBucket: s3.IBucket;
     siteOrigin: origins.HttpOrigin;
     siteDistribution: cloudfront.Distribution;
-    siteSecretAlgolia: secretsmanager.ISecret;
     siteInternalDomainName: string;
     siteExternalDomainName: string;
     siteDomainNames: string[];

package/dist/src/lib/construct/site-with-ecs-backend/main.js

@@ -24,11 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiteWithEcsBackend = void 0;
-const cdk = __importStar(require("aws-cdk-lib"));
 const cloudfront = __importStar(require("aws-cdk-lib/aws-cloudfront"));
 const origins = __importStar(require("aws-cdk-lib/aws-cloudfront-origins"));
 const ecs = __importStar(require("aws-cdk-lib/aws-ecs"));
-const ecsPatterns = __importStar(require("aws-cdk-lib/aws-ecs-patterns"));
 const iam = __importStar(require("aws-cdk-lib/aws-iam"));
 const common_1 = require("../../common");
 /**
@@ -74,7 +72,6 @@ class SiteWithEcsBackend extends common_1.CommonConstruct {
     siteLogBucket;
     siteOrigin;
     siteDistribution;
-    siteSecretAlgolia;
     siteInternalDomainName;
     siteExternalDomainName;
     siteDomainNames;
@@ -222,47 +219,21 @@ class SiteWithEcsBackend extends common_1.CommonConstruct {
      * @protected
      */
     createEcsService() {
-        const fargateService = new ecsPatterns.ApplicationLoadBalancedFargateService(this, `${this.id}-ecs-service`, {
-            cluster: this.siteEcsCluster,
-            desiredCount: this.props.siteTask.desiredCount,
-            enableECSManagedTags: true,
-            serviceName: `${this.id}-${this.props.stage}`,
-            cpu: this.props.siteTask.cpu,
-            loadBalancerName: `${this.id}-${this.props.stage}`,
-            domainName: this.siteInternalDomainName,
-            domainZone: this.siteHostedZone,
-            listenerPort: this.props.siteTask.listenerPort,
-            memoryLimitMiB: this.props.siteTask.memoryLimitMiB,
-            healthCheckGracePeriod: cdk.Duration.seconds(60),
-            assignPublicIp: true,
-            taskImageOptions: {
-                enableLogging: true,
-                logDriver: ecs.LogDriver.awsLogs({
-                    logGroup: this.siteEcsLogGroup,
-                    streamPrefix: `${this.id}-${this.props.stage}/ecs`,
-                }),
-                image: this.siteEcsContainerImage,
-                executionRole: this.siteEcsRole,
-                taskRole: this.siteEcsRole,
-                containerPort: this.props.siteTask.taskImageOptions?.containerPort,
-                environment: this.siteEcsEnvironment,
-                secrets: this.siteSecrets,
+        const fargateService = this.ecsManager.createLoadBalancedFargateService(this.id, this, {
+            ...this.props.siteTask,
+            ...{
+                domainName: this.siteInternalDomainName,
+                domainZone: this.siteHostedZone,
+                healthCheck: this.props.siteHealthCheck,
+                taskImageOptions: {
+                    environment: this.siteEcsEnvironment,
+                    executionRole: this.siteEcsRole,
+                    taskRole: this.siteEcsRole,
+                    image: this.siteEcsContainerImage,
+                    secrets: this.siteSecrets,
+                },
             },
-        });
-        if (this.props.siteHealthCheck) {
-            fargateService.targetGroup.configureHealthCheck({
-                enabled: this.props.siteHealthCheck.enabled ?? true,
-                path: this.props.siteHealthCheck.path ?? '/',
-                port: this.props.siteHealthCheck.port,
-                interval: cdk.Duration.seconds(this.props.siteHealthCheck.intervalInSecs),
-                timeout: cdk.Duration.seconds(this.props.siteHealthCheck.timeoutInSecs),
-                healthyThresholdCount: this.props.siteHealthCheck.healthyThresholdCount,
-                unhealthyThresholdCount: this.props.siteHealthCheck.unhealthyThresholdCount,
-                healthyGrpcCodes: this.props.siteHealthCheck.healthyGrpcCodes,
-                healthyHttpCodes: this.props.siteHealthCheck.healthyHttpCodes,
-                protocol: this.props.siteHealthCheck.protocol,
-            });
-        }
+        }, this.siteEcsCluster, this.siteEcsLogGroup);
         this.siteEcsService = fargateService.service;
         this.siteEcsTaskDefinition = fargateService.taskDefinition;
         this.siteEcsListener = fargateService.listener;

package/dist/src/lib/manager/aws/ecs-manager.d.ts

@@ -1,3 +1,4 @@
+import * as cdk from 'aws-cdk-lib';
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as ecs from 'aws-cdk-lib/aws-ecs';
 import * as iam from 'aws-cdk-lib/aws-iam';
@@ -32,7 +33,7 @@ export declare class EcsManager {
      * @param {types.EcsClusterProps} props
      * @param {ec2.IVpc} vpc
      */
-    createEcsCluster(id: string, scope: common.CommonConstruct, props: types.EcsClusterProps, vpc: ec2.IVpc): ecs.Cluster;
+    createEcsCluster(id: string, scope: common.CommonConstruct, props: types.EcsClusterProps, vpc: ec2.IVpc): cdk.aws_ecs.Cluster;
     /**
      * @summary Method to create an ecs fargate task
      * @param {string} id scoped id of the resource
@@ -45,5 +46,14 @@ export declare class EcsManager {
      * @param {Map<string, string>} environment
      * @param {Map<string, string>} secrets
      */
-    createEcsFargateTask(id: string, scope: common.CommonConstruct, props: types.EcsTaskProps, cluster: ecs.ICluster, role: iam.Role, logGroup: logs.ILogGroup, containerImage: ecs.ContainerImage, environment?: any, secrets?: any): ecs.TaskDefinition;
+    createEcsFargateTask(id: string, scope: common.CommonConstruct, props: types.EcsTaskProps, cluster: ecs.ICluster, role: iam.Role, logGroup: logs.ILogGroup, containerImage: ecs.ContainerImage, environment?: any, secrets?: any): cdk.aws_ecs.TaskDefinition;
+    /**
+     * @summary Method to create an application loadbalanced ecs fargate task
+     * @param {string} id scoped id of the resource
+     * @param {common.CommonConstruct} scope scope in which this resource is defined
+     * @param {types.EcsApplicationLoadBalancedFargateServiceProps} props
+     * @param {ecs.ICluster} cluster
+     * @param {logs.ILogGroup} logGroup
+     */
+    createLoadBalancedFargateService(id: string, scope: common.CommonConstruct, props: types.EcsApplicationLoadBalancedFargateServiceProps, cluster: ecs.ICluster, logGroup: logs.ILogGroup): cdk.aws_ecs_patterns.ApplicationLoadBalancedFargateService;
 }

package/dist/src/lib/manager/aws/ecs-manager.js

@@ -24,7 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EcsManager = void 0;
+const cdk = __importStar(require("aws-cdk-lib"));
 const ecs = __importStar(require("aws-cdk-lib/aws-ecs"));
+const ecsPatterns = __importStar(require("aws-cdk-lib/aws-ecs-patterns"));
 const utils = __importStar(require("../../utils"));
 /**
  * @stability stable
@@ -121,5 +123,63 @@ class EcsManager {
         utils.createCfnOutput(`${id}-taskArn`, scope, ecsTask.taskDefinitionArn);
         return ecsTask;
     }
+    /**
+     * @summary Method to create an application loadbalanced ecs fargate task
+     * @param {string} id scoped id of the resource
+     * @param {common.CommonConstruct} scope scope in which this resource is defined
+     * @param {types.EcsApplicationLoadBalancedFargateServiceProps} props
+     * @param {ecs.ICluster} cluster
+     * @param {logs.ILogGroup} logGroup
+     */
+    createLoadBalancedFargateService(id, scope, props, cluster, logGroup) {
+        if (!props)
+            throw `EcsLoadbalanced Fargate Serivice props undefined`;
+        if (!props.taskImageOptions)
+            throw `TaskImageOptions for EcsLoadbalanced Fargate Serivice props undefined`;
+        const fargateService = new ecsPatterns.ApplicationLoadBalancedFargateService(scope, `${id}-ecs-service`, {
+            cluster: cluster,
+            desiredCount: props.desiredCount,
+            enableECSManagedTags: true,
+            serviceName: `${id}-${scope.props.stage}`,
+            certificate: props.certificate,
+            cpu: props.cpu,
+            loadBalancerName: `${id}-${scope.props.stage}`,
+            domainName: props.domainName,
+            domainZone: props.domainZone,
+            listenerPort: props.listenerPort,
+            memoryLimitMiB: props.memoryLimitMiB,
+            healthCheckGracePeriod: props.healthCheckGracePeriod ?? cdk.Duration.seconds(60),
+            assignPublicIp: props.assignPublicIp ?? true,
+            taskImageOptions: {
+                enableLogging: props.taskImageOptions?.enableLogging ?? true,
+                logDriver: props.taskImageOptions?.logDriver ??
+                    ecs.LogDriver.awsLogs({
+                        logGroup: logGroup,
+                        streamPrefix: `${id}-${scope.props.stage}/ecs`,
+                    }),
+                image: props.taskImageOptions.image,
+                executionRole: props.taskImageOptions?.executionRole,
+                taskRole: props.taskImageOptions?.taskRole,
+                containerPort: props.taskImageOptions?.containerPort,
+                environment: props.taskImageOptions?.environment,
+                secrets: props.taskImageOptions?.secrets,
+            },
+        });
+        if (props.healthCheck) {
+            fargateService.targetGroup.configureHealthCheck({
+                enabled: props.healthCheck.enabled ?? true,
+                path: props.healthCheck.path ?? '/',
+                port: props.healthCheck.port,
+                interval: props.healthCheck.interval ?? cdk.Duration.seconds(props.healthCheck.intervalInSecs),
+                timeout: props.healthCheck.timeout ?? cdk.Duration.seconds(props.healthCheck.timeoutInSecs),
+                healthyThresholdCount: props.healthCheck.healthyThresholdCount,
+                unhealthyThresholdCount: props.healthCheck.unhealthyThresholdCount,
+                healthyGrpcCodes: props.healthCheck.healthyGrpcCodes,
+                healthyHttpCodes: props.healthCheck.healthyHttpCodes,
+                protocol: props.healthCheck.protocol,
+            });
+        }
+        return fargateService;
+    }
 }
 exports.EcsManager = EcsManager;

package/dist/src/lib/types/aws/index.d.ts

@@ -554,6 +554,13 @@ export interface EcsClusterProps extends ecs.ClusterProps {
  */
 export interface EcsTaskProps extends ecs.TaskDefinitionProps {
 }
+/**
+ * @category cdk-utils.ecs-manager
+ * @subcategory Properties
+ */
+export interface EcsApplicationLoadBalancedFargateServiceProps extends ecsPatterns.ApplicationLoadBalancedFargateServiceProps {
+    healthCheck?: HealthCheck;
+}
 /**
  * @category cdk-utils.eks-manager
  * @subcategory Properties

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradientedge/cdk-utils",
-  "version": "7.4.0",
+  "version": "7.6.0",
   "description": "Utilities for AWS CDK provisioning",
   "main": "dist/index.js",
   "engines": {

package/src/lib/construct/site-with-ecs-backend/main.ts

@@ -1,16 +1,13 @@
-import * as cdk from 'aws-cdk-lib'
 import * as certificateManager from 'aws-cdk-lib/aws-certificatemanager'
 import * as cloudfront from 'aws-cdk-lib/aws-cloudfront'
 import * as origins from 'aws-cdk-lib/aws-cloudfront-origins'
 import * as ec2 from 'aws-cdk-lib/aws-ec2'
 import * as ecs from 'aws-cdk-lib/aws-ecs'
-import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns'
 import * as elb from 'aws-cdk-lib/aws-elasticloadbalancingv2'
 import * as iam from 'aws-cdk-lib/aws-iam'
 import * as logs from 'aws-cdk-lib/aws-logs'
 import * as route53 from 'aws-cdk-lib/aws-route53'
 import * as s3 from 'aws-cdk-lib/aws-s3'
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager'
 import { Construct } from 'constructs'
 import { CommonConstruct } from '../../common'
 import { SiteWithEcsBackendProps } from '../../types'
@@ -59,7 +56,6 @@ export class SiteWithEcsBackend extends CommonConstruct {
   siteLogBucket: s3.IBucket
   siteOrigin: origins.HttpOrigin
   siteDistribution: cloudfront.Distribution
-  siteSecretAlgolia: secretsmanager.ISecret
   siteInternalDomainName: string
   siteExternalDomainName: string
   siteDomainNames: string[]
@@ -245,48 +241,27 @@ export class SiteWithEcsBackend extends CommonConstruct {
    * @protected
    */
   protected createEcsService() {
-    const fargateService = new ecsPatterns.ApplicationLoadBalancedFargateService(this, `${this.id}-ecs-service`, {
-      cluster: this.siteEcsCluster,
-      desiredCount: this.props.siteTask.desiredCount,
-      enableECSManagedTags: true,
-      serviceName: `${this.id}-${this.props.stage}`,
-      cpu: this.props.siteTask.cpu,
-      loadBalancerName: `${this.id}-${this.props.stage}`,
-      domainName: this.siteInternalDomainName,
-      domainZone: this.siteHostedZone,
-      listenerPort: this.props.siteTask.listenerPort,
-      memoryLimitMiB: this.props.siteTask.memoryLimitMiB,
-      healthCheckGracePeriod: cdk.Duration.seconds(60),
-      assignPublicIp: true,
-      taskImageOptions: {
-        enableLogging: true,
-        logDriver: ecs.LogDriver.awsLogs({
-          logGroup: this.siteEcsLogGroup,
-          streamPrefix: `${this.id}-${this.props.stage}/ecs`,
-        }),
-        image: this.siteEcsContainerImage,
-        executionRole: this.siteEcsRole,
-        taskRole: this.siteEcsRole,
-        containerPort: this.props.siteTask.taskImageOptions?.containerPort,
-        environment: this.siteEcsEnvironment,
-        secrets: this.siteSecrets,
+    const fargateService = this.ecsManager.createLoadBalancedFargateService(
+      this.id,
+      this,
+      {
+        ...this.props.siteTask,
+        ...{
+          domainName: this.siteInternalDomainName,
+          domainZone: this.siteHostedZone,
+          healthCheck: this.props.siteHealthCheck,
+          taskImageOptions: {
+            environment: this.siteEcsEnvironment,
+            executionRole: this.siteEcsRole,
+            taskRole: this.siteEcsRole,
+            image: this.siteEcsContainerImage,
+            secrets: this.siteSecrets,
+          },
+        },
       },
-    })
-
-    if (this.props.siteHealthCheck) {
-      fargateService.targetGroup.configureHealthCheck({
-        enabled: this.props.siteHealthCheck.enabled ?? true,
-        path: this.props.siteHealthCheck.path ?? '/',
-        port: this.props.siteHealthCheck.port,
-        interval: cdk.Duration.seconds(this.props.siteHealthCheck.intervalInSecs),
-        timeout: cdk.Duration.seconds(this.props.siteHealthCheck.timeoutInSecs),
-        healthyThresholdCount: this.props.siteHealthCheck.healthyThresholdCount,
-        unhealthyThresholdCount: this.props.siteHealthCheck.unhealthyThresholdCount,
-        healthyGrpcCodes: this.props.siteHealthCheck.healthyGrpcCodes,
-        healthyHttpCodes: this.props.siteHealthCheck.healthyHttpCodes,
-        protocol: this.props.siteHealthCheck.protocol,
-      })
-    }
+      this.siteEcsCluster,
+      this.siteEcsLogGroup
+    )
 
     this.siteEcsService = fargateService.service
     this.siteEcsTaskDefinition = fargateService.taskDefinition

package/src/lib/manager/aws/ecs-manager.ts

@@ -1,5 +1,7 @@
+import * as cdk from 'aws-cdk-lib'
 import * as ec2 from 'aws-cdk-lib/aws-ec2'
 import * as ecs from 'aws-cdk-lib/aws-ecs'
+import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns'
 import * as iam from 'aws-cdk-lib/aws-iam'
 import * as logs from 'aws-cdk-lib/aws-logs'
 import * as common from '../../common'
@@ -117,4 +119,71 @@ export class EcsManager {
 
     return ecsTask
   }
+
+  /**
+   * @summary Method to create an application loadbalanced ecs fargate task
+   * @param {string} id scoped id of the resource
+   * @param {common.CommonConstruct} scope scope in which this resource is defined
+   * @param {types.EcsApplicationLoadBalancedFargateServiceProps} props
+   * @param {ecs.ICluster} cluster
+   * @param {logs.ILogGroup} logGroup
+   */
+  public createLoadBalancedFargateService(
+    id: string,
+    scope: common.CommonConstruct,
+    props: types.EcsApplicationLoadBalancedFargateServiceProps,
+    cluster: ecs.ICluster,
+    logGroup: logs.ILogGroup
+  ) {
+    if (!props) throw `EcsLoadbalanced Fargate Serivice props undefined`
+    if (!props.taskImageOptions) throw `TaskImageOptions for EcsLoadbalanced Fargate Serivice props undefined`
+
+    const fargateService = new ecsPatterns.ApplicationLoadBalancedFargateService(scope, `${id}-ecs-service`, {
+      cluster: cluster,
+      desiredCount: props.desiredCount,
+      enableECSManagedTags: true,
+      serviceName: `${id}-${scope.props.stage}`,
+      certificate: props.certificate,
+      cpu: props.cpu,
+      loadBalancerName: `${id}-${scope.props.stage}`,
+      domainName: props.domainName,
+      domainZone: props.domainZone,
+      listenerPort: props.listenerPort,
+      memoryLimitMiB: props.memoryLimitMiB,
+      healthCheckGracePeriod: props.healthCheckGracePeriod ?? cdk.Duration.seconds(60),
+      assignPublicIp: props.assignPublicIp ?? true,
+      taskImageOptions: {
+        enableLogging: props.taskImageOptions?.enableLogging ?? true,
+        logDriver:
+          props.taskImageOptions?.logDriver ??
+          ecs.LogDriver.awsLogs({
+            logGroup: logGroup,
+            streamPrefix: `${id}-${scope.props.stage}/ecs`,
+          }),
+        image: props.taskImageOptions.image,
+        executionRole: props.taskImageOptions?.executionRole,
+        taskRole: props.taskImageOptions?.taskRole,
+        containerPort: props.taskImageOptions?.containerPort,
+        environment: props.taskImageOptions?.environment,
+        secrets: props.taskImageOptions?.secrets,
+      },
+    })
+
+    if (props.healthCheck) {
+      fargateService.targetGroup.configureHealthCheck({
+        enabled: props.healthCheck.enabled ?? true,
+        path: props.healthCheck.path ?? '/',
+        port: props.healthCheck.port,
+        interval: props.healthCheck.interval ?? cdk.Duration.seconds(props.healthCheck.intervalInSecs),
+        timeout: props.healthCheck.timeout ?? cdk.Duration.seconds(props.healthCheck.timeoutInSecs),
+        healthyThresholdCount: props.healthCheck.healthyThresholdCount,
+        unhealthyThresholdCount: props.healthCheck.unhealthyThresholdCount,
+        healthyGrpcCodes: props.healthCheck.healthyGrpcCodes,
+        healthyHttpCodes: props.healthCheck.healthyHttpCodes,
+        protocol: props.healthCheck.protocol,
+      })
+    }
+
+    return fargateService
+  }
 }

package/src/lib/types/aws/index.ts

@@ -588,6 +588,15 @@ export interface EcsClusterProps extends ecs.ClusterProps {}
  */
 export interface EcsTaskProps extends ecs.TaskDefinitionProps {}
 
+/**
+ * @category cdk-utils.ecs-manager
+ * @subcategory Properties
+ */
+export interface EcsApplicationLoadBalancedFargateServiceProps
+  extends ecsPatterns.ApplicationLoadBalancedFargateServiceProps {
+  healthCheck?: HealthCheck
+}
+
 /**
  * @category cdk-utils.eks-manager
  * @subcategory Properties