dcl-ops-lib 6.4.0 → 6.6.0

package/StaticWebsite.d.ts

@@ -31,4 +31,5 @@ export type StaticWebsite = {
     priceClass?: "PriceClass_All" | "PriceClass_200" | "PriceClass_100";
     cachePolicyId?: Input<string>;
     objectOwnership?: string;
+    overrideContentBucketACL?: string;
 };

package/buildStatic.js

@@ -23,7 +23,7 @@ function buildStatic(staticSite) {
     const slug = staticSite.domain.replace(/\./g, "-") + "-";
     // contentBucket is the S3 bucket that the website's contents will be stored in.
     const bucketInfo = {
-        acl: "public-read",
+        acl: staticSite.overrideContentBucketACL ? staticSite.overrideContentBucketACL : "public-read",
         // Configure S3 to serve bucket contents as a website. This way S3 will automatically convert
         // requests for "foo/" to "foo/index.html".
         website: {

package/createFargateTask.d.ts

@@ -53,6 +53,15 @@ export type FargateTaskOptions = {
     mountPoints?: aws.ecs.MountPoint[];
     repositoryCredentials?: aws.ecs.RepositoryCredentials;
     runtimePlatform?: aws.types.input.ecs.TaskDefinitionRuntimePlatform;
+    appAutoscaling?: {
+        maxCapacity: number;
+        metricName: string;
+        targetValue: number;
+        metricDimensionName: string;
+        statistic?: "Average" | "Minimum" | "Maximum";
+        scaleOutCooldown?: number;
+        scaleInCooldown?: number;
+    };
 };
 /**
  *
@@ -65,6 +74,7 @@ export type FargateTaskOptions = {
  * @param options.cluster The cluster where to run this. If none is provided, the `defaultCluster` will be used ({@see infra/defaultCluster.ts})
  * @param options.healthCheckPath
  * @param options.policyArnNamedMap key-value named map of policies to attach to the default execution role for this task
+ * @param options.appAutoscaling Configuration for autoscaling
  */
 export declare function createFargateTask(serviceName: string, dockerImage: string | Promise<string> | pulumi.OutputInstance<string>, dockerListeningPort: number, environment: {
     name: string;
@@ -101,5 +111,14 @@ export type InternalServiceOptions = {
     team: string;
     targetGroups: aws.alb.TargetGroup[];
     runtimePlatform?: aws.types.input.ecs.TaskDefinitionRuntimePlatform;
+    appAutoscaling?: {
+        maxCapacity: number;
+        metricName: string;
+        targetValue: number;
+        metricDimensionName: string;
+        statistic?: "Average" | "Minimum" | "Maximum";
+        scaleOutCooldown?: number;
+        scaleInCooldown?: number;
+    };
 };
 export declare function createInternalService(config: InternalServiceOptions): Promise<import("@pulumi/aws/ecs/service").Service>;

package/createFargateTask.js

@@ -111,6 +111,7 @@ function getFargateTaskRole(name, policyArnNamedMap) {
  * @param options.cluster The cluster where to run this. If none is provided, the `defaultCluster` will be used ({@see infra/defaultCluster.ts})
  * @param options.healthCheckPath
  * @param options.policyArnNamedMap key-value named map of policies to attach to the default execution role for this task
+ * @param options.appAutoscaling Configuration for autoscaling
  */
 function createFargateTask(serviceName, dockerImage, dockerListeningPort, environment, hostname, options) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -334,7 +335,7 @@ function createInternalService(config) {
             volumes: volumes,
             family: (0, stack_1.getStackScopedName)(serviceName),
         }, { dependsOn: [logGroup] });
-        return new aws.ecs.Service((0, stack_1.getStackScopedName)(serviceName), {
+        const service = new aws.ecs.Service((0, stack_1.getStackScopedName)(serviceName), {
             cluster: yield getClusterInstance(cluster),
             tags: { ServiceName: serviceName, StackId: (0, stack_1.getStackId)(), Team: team },
             networkConfiguration: {
@@ -355,6 +356,48 @@ function createInternalService(config) {
                 }))
             ]
         }, Object.assign(Object.assign({}, extraOpts), { dependsOn }));
+        if (!!config.appAutoscaling) {
+            setAutoscaling(service, Object.assign(Object.assign({}, config.appAutoscaling), { desiredCount }));
+        }
+        return service;
+    });
+}
+function setAutoscaling(service, config) {
+    const taskUniqueIdentifier = `${service.name}-${domain_1.env}`;
+    const ecsTarget = new aws.appautoscaling.Target(`ecs-target-${taskUniqueIdentifier}`, {
+        maxCapacity: config.maxCapacity,
+        minCapacity: config.desiredCount,
+        resourceId: `service/${service.cluster}/${service.name}`,
+        scalableDimension: "ecs:service:DesiredCount",
+        serviceNamespace: "ecs",
+    });
+    const CSM_ApproximateNumberOfMessagesVisible = {
+        metricName: config.metricName,
+        namespace: "AWS/SQS",
+        dimensions: [
+            {
+                name: "QueueName",
+                value: config.metricDimensionName
+            },
+        ],
+        statistic: config.statistic,
+        unit: "Count",
+    };
+    let TTS_CustomizedMetricSpecification = undefined;
+    if (config.metricName === "ApproximateNumberOfMessagesVisible") {
+        TTS_CustomizedMetricSpecification = CSM_ApproximateNumberOfMessagesVisible;
+    }
+    new aws.appautoscaling.Policy(`ecs-autoscaling-policy-${taskUniqueIdentifier}`, {
+        policyType: "TargetTrackingScaling",
+        resourceId: ecsTarget.resourceId,
+        scalableDimension: ecsTarget.scalableDimension,
+        serviceNamespace: ecsTarget.serviceNamespace,
+        targetTrackingScalingPolicyConfiguration: {
+            targetValue: config.targetValue,
+            customizedMetricSpecification: TTS_CustomizedMetricSpecification,
+            scaleOutCooldown: config.scaleOutCooldown,
+            scaleInCooldown: config.scaleInCooldown,
+        },
     });
 }
 //# sourceMappingURL=createFargateTask.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcl-ops-lib",
-  "version": "6.4.0",
+  "version": "6.6.0",
   "scripts": {
     "build": "tsc && cp bin/* . && node test.js",
     "clean": "rm *.d.ts *.js *.js.map"