Adds Architecture Property on defineFunction

.changeset/tall-parrots-sort.md

@@ -0,0 +1,6 @@
+---
+'@aws-amplify/backend-function': minor
+'@aws-amplify/backend': minor
+---
+
+adds support for architecture property on defineFunction

packages/backend-function/API.md

@@ -64,6 +64,9 @@ type DataClientReturn<T> = T extends DataClientEnv ? DataClientConfig : DataClie
 // @public
 export const defineFunction: (props?: FunctionProps) => ConstructFactory<ResourceProvider<FunctionResources> & ResourceAccessAcceptorFactory & AddEnvironmentFactory & StackProvider>;
 
+// @public (undocumented)
+export type FunctionArchitecture = 'x86_64' | 'arm64';
+
 // @public (undocumented)
 export type FunctionBundlingOptions = {
     minify?: boolean;
@@ -94,6 +97,7 @@ export type FunctionProps = {
     ephemeralStorageSizeMB?: number;
     environment?: Record<string, string | BackendSecret>;
     runtime?: NodeVersion;
+    architecture?: FunctionArchitecture;
     schedule?: FunctionSchedule | FunctionSchedule[];
     layers?: Record<string, string>;
     bundling?: FunctionBundlingOptions;

packages/backend-function/src/factory.test.ts

@@ -13,9 +13,13 @@ import {
 } from '@aws-amplify/backend-platform-test-stubs';
 import { defaultLambda } from './test-assets/default-lambda/resource.js';
 import { Template } from 'aws-cdk-lib/assertions';
-import { NodeVersion, defineFunction } from './factory.js';
+import {
+  FunctionArchitecture,
+  NodeVersion,
+  defineFunction,
+} from './factory.js';
 import { lambdaWithDependencies } from './test-assets/lambda-with-dependencies/resource.js';
-import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import { Architecture, Runtime } from 'aws-cdk-lib/aws-lambda';
 import { Policy, PolicyStatement } from 'aws-cdk-lib/aws-iam';
 import fsp from 'fs/promises';
 import path from 'node:path';
@@ -454,6 +458,34 @@ void describe('AmplifyFunctionFactory', () => {
     });
   });
 
+  void describe('architecture property', () => {
+    void it('sets valid architecture', () => {
+      const lambda = defineFunction({
+        entry: './test-assets/default-lambda/handler.ts',
+        architecture: 'arm64',
+      }).getInstance(getInstanceProps);
+      const template = Template.fromStack(lambda.stack);
+
+      template.hasResourceProperties('AWS::Lambda::Function', {
+        Architectures: [Architecture.ARM_64.name],
+      });
+    });
+  });
+
+  void it('throws on invalid architecture', () => {
+    assert.throws(
+      () =>
+        defineFunction({
+          entry: './test-assets/default-lambda/handler.ts',
+          architecture: 'invalid' as FunctionArchitecture,
+        }).getInstance(getInstanceProps),
+      new AmplifyUserError('InvalidArchitectureError', {
+        message: `Invalid function architecture of invalid`,
+        resolution: 'architecture must be one of the following: arm64, x86_64',
+      })
+    );
+  });
+
   void describe('schedule property', () => {
     void it('sets valid schedule - rate', () => {
       const lambda = defineFunction({

packages/backend-function/src/factory.ts

@@ -31,6 +31,7 @@ import { Rule } from 'aws-cdk-lib/aws-events';
 import * as targets from 'aws-cdk-lib/aws-events-targets';
 import { Policy } from 'aws-cdk-lib/aws-iam';
 import {
+  Architecture,
   CfnFunction,
   ILayerVersion,
   LayerVersion,
@@ -134,6 +135,12 @@ export type FunctionProps = {
    */
   runtime?: NodeVersion;
 
+  /**
+   * The architecture of the target platform for the lambda environment.
+   * Defaults to X86_64.
+   */
+  architecture?: FunctionArchitecture;
+
   /**
    * A time interval string to periodically run the function.
    * This can be either a string of `"every <positive whole number><m (minute) or h (hour)>"`, `"every day|week|month|year"` or cron expression.
@@ -246,6 +253,7 @@ class FunctionFactory implements ConstructFactory<AmplifyFunction> {
       ephemeralStorageSizeMB: this.resolveEphemeralStorageSize(),
       environment: this.resolveEnvironment(),
       runtime: this.resolveRuntime(),
+      architecture: this.resolveArchitecture(),
       schedule: this.resolveSchedule(),
       bundling: this.resolveBundling(),
       layers: this.props.layers ?? {},
@@ -401,6 +409,25 @@ class FunctionFactory implements ConstructFactory<AmplifyFunction> {
     return this.props.runtime;
   };
 
+  private resolveArchitecture = () => {
+    const architectureDefault = 'x86_64';
+
+    if (!this.props.architecture) {
+      return architectureDefault;
+    }
+
+    if (!(this.props.architecture in architectureMap)) {
+      throw new AmplifyUserError('InvalidArchitectureError', {
+        message: `Invalid function architecture of ${this.props.architecture}`,
+        resolution: `architecture must be one of the following: ${Object.keys(
+          architectureMap
+        ).join(', ')}`,
+      });
+    }
+
+    return this.props.architecture;
+  };
+
   private resolveSchedule = () => {
     if (!this.props.schedule) {
       return [];
@@ -539,6 +566,7 @@ class AmplifyFunction
         entry: props.entry,
         timeout: Duration.seconds(props.timeoutSeconds),
         memorySize: props.memoryMB,
+        architecture: architectureMap[props.architecture],
         ephemeralStorageSize: Size.mebibytes(props.ephemeralStorageSizeMB),
         runtime: nodeVersionMap[props.runtime],
         layers: props.resolvedLayers,
@@ -678,3 +706,10 @@ const nodeVersionMap: Record<NodeVersion, Runtime> = {
   20: Runtime.NODEJS_20_X,
   22: Runtime.NODEJS_22_X,
 };
+
+export type FunctionArchitecture = 'x86_64' | 'arm64';
+
+const architectureMap: Record<FunctionArchitecture, Architecture> = {
+  arm64: Architecture.ARM_64,
+  x86_64: Architecture.X86_64,
+};