add support for provisionConcurrency, reservedConcurrency & lambda layers

Author: matuscongrady

@generated/schemas/config-schema.json

@@ -11,12 +11,14 @@ export default defineConfig(() => {
         enabled: true
       }
     },
+    provisionedConcurrency: 1,
     transforms: {
       lambda: (props) => {
         return {
           ...props,
           MemorySize: (props.MemorySize ?? 128) * 2,
           Description: 'This is a test lambda',
+          Layers: ['arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1'],
         }
       }
     }

@generated/schemas/validate-config-schema.js

@@ -101,7 +101,10 @@ export const resolveFunction = ({ lambdaProps }: { lambdaProps: StpLambdaFunctio
     volumeMounts,
     type,
     cdn,
-    architecture
+    architecture,
+    provisionedConcurrency,
+    reservedConcurrency,
+    layers
   } = lambdaProps;
 
   if (nameChain[0] !== PARENT_IDENTIFIER_SHARED_GLOBAL) {
@@ -278,6 +281,27 @@ export const resolveFunction = ({ lambdaProps }: { lambdaProps: StpLambdaFunctio
       });
     }
   }
+  if (layers) {
+    lambdaFunctionResource.Properties.Layers = layers;
+  }
+  if (reservedConcurrency) {
+    lambdaFunctionResource.Properties.ReservedConcurrentExecutions = reservedConcurrency;
+  }
+  // Provisioned concurrency requires an alias pointing to a specific version.
+  // If deployment is configured, alias is already created (with code deploy), so we just add provisioned concurrency to it.
+  // If no deployment, we create version + alias specifically for provisioned concurrency.
+  if (provisionedConcurrency && !deployment) {
+    calculatedStackOverviewManager.addCfChildResource({
+      nameChain,
+      cfLogicalName: cfLogicalNames.lambdaVersionPublisherCustomResource(name),
+      resource: getLambdaVersionPublisherCustomResource({ lambdaProps })
+    });
+    calculatedStackOverviewManager.addCfChildResource({
+      nameChain,
+      cfLogicalName: cfLogicalNames.lambdaStpAlias(name),
+      resource: getLambdaAliasResource({ lambdaProps, provisionedConcurrency })
+    });
+  }
   if (
     !joinDefaultVpc &&
     accessToAtlasMongoClusterResources.length &&

_test-stacks/simple-lambda/stacktape.ts

@@ -150,15 +150,23 @@ export const getLambdaFunctionRole = ({
 };
 
 export const getLambdaAliasResource = ({
-  lambdaProps
+  lambdaProps,
+  provisionedConcurrency
 }: {
   lambdaProps: StpLambdaFunction | StpHelperLambdaFunction;
+  provisionedConcurrency?: number;
 }) => {
   const resource = new Alias({
     FunctionName: Ref(lambdaProps.cfLogicalName),
     FunctionVersion: GetAtt(cfLogicalNames.lambdaVersionPublisherCustomResource(lambdaProps.name), 'version'),
     Name: awsResourceNames.lambdaStpAlias()
   });
+  const effectiveProvisionedConcurrency = provisionedConcurrency ?? lambdaProps.provisionedConcurrency;
+  if (effectiveProvisionedConcurrency) {
+    resource.Properties.ProvisionedConcurrencyConfig = {
+      ProvisionedConcurrentExecutions: effectiveProvisionedConcurrency
+    };
+  }
   if (lambdaProps.deployment) {
     resource.UpdatePolicy = {
       CodeDeployLambdaAliasUpdate: {

src/domain/calculated-stack-overview-manager/resource-resolvers/functions/index.ts

@@ -274,7 +274,7 @@ export class ConfigManager {
         handler: getLambdaHandler({ name, packaging }),
         resourceName: awsResourceNames.lambda(name, globalStateManager.targetStack.stackName),
         cfLogicalName: cfLogicalNames.lambda(name),
-        aliasLogicalName: definition.deployment && cfLogicalNames.lambdaStpAlias(name),
+        aliasLogicalName: (definition.deployment || definition.provisionedConcurrency) && cfLogicalNames.lambdaStpAlias(name),
         events: definition.events || [],
         configParentResourceType: 'function'
       } as StpLambdaFunction;

src/domain/calculated-stack-overview-manager/resource-resolvers/functions/utils.ts

@@ -147,6 +147,47 @@ interface LambdaFunctionProps extends ResourceAccessProps {
    *   - Using the `stacktape logs` command to stream logs directly to your terminal.
    */
   logging?: LambdaFunctionLogging;
+  /**
+   * #### Configures the provisioned concurrency for the function.
+   *
+   * ---
+   *
+   * This is the number of pre-initialized execution environments allocated to your function.
+   * These execution environments are ready to respond immediately to incoming function requests.
+   * Provisioned concurrency is useful for reducing cold start latencies for functions and designed to make functions available with double-digit millisecond response times.
+   * Generally, interactive workloads benefit the most from the feature.
+   * Those are applications with users initiating requests, such as web and mobile applications, and are the most sensitive to latency.
+   * Asynchronous workloads, such as data processing pipelines, are often less latency sensitive and so do not usually need provisioned concurrency.
+   * Configuring provisioned concurrency incurs additional charges to your AWS account.
+   */
+  provisionedConcurrency?: number;
+  /**
+   * #### Configures the reserved concurrency for the function.
+   *
+   * ---
+   *
+   * This sets both the maximum and minimum number of concurrent instances allocated to your function.
+   * When a function has reserved concurrency, no other function can use that concurrency.
+   * Reserved concurrency is useful for ensuring that your most critical functions always have enough concurrency to handle incoming requests.
+   * Additionally, reserved concurrency can be used for limiting concurrency to prevent overwhelming downstream resources, like database connections.
+   * Reserved concurrency acts as both a lower and upper bound - it reserves the specified capacity exclusively for your function while also preventing it from scaling beyond that limit.
+   * Configuring reserved concurrency for a function incurs no additional charges.
+   */
+  reservedConcurrency?: number;
+  /**
+   * #### A list of layers to add to the function.
+   *
+   * ---
+   *
+   * A Lambda layer is a .zip file archive that contains supplementary code or data.
+   * Layers usually contain library dependencies, a custom runtime, or configuration files.
+   *
+   * Using layers:
+   * 1. Package your layer content. This means creating a .zip file archive. For more information, see [Packaging your layer content](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html).
+   * 2. Create the layer in Lambda. For more information, see [Creating and deleting layers in Lambda](https://docs.aws.amazon.com/lambda/latest/dg/creating-deleting-layers.html)
+   * 3. Get the layer ARN and put it in the `layers` property of the function.
+  */
+  layers?: string[];
   /**
    * #### Configures the deployment strategy for updating the function.
    *