Add multi-architecture Lambda support to canary runner

Author: vcjana

.github/workflows/ci.yml

@@ -344,10 +344,10 @@ jobs:
       fail-fast: false
       matrix:
         target:
-          - x86_64-unknown-linux-gnu
-          - x86_64-unknown-linux-musl
-          - aarch64-unknown-linux-gnu
-          - aarch64-unknown-linux-musl
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        - aarch64-unknown-linux-musl
     steps:
     - uses: actions/checkout@v4
       with:
@@ -394,10 +394,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - arch: x86_64
-            runner: smithy_ubuntu-latest_8-core
-          - arch: aarch64
-            runner: smithy_ubuntu-latest_8-core-arm
+        - arch: x86_64
+          runner: smithy_ubuntu-latest_8-core
+        - arch: aarch64
+          runner: smithy_ubuntu-latest_8-core-arm
     steps:
     - uses: GitHubSecurityLab/actions-permissions/monitor@v1
     - uses: actions/checkout@v4
@@ -415,7 +415,7 @@ jobs:
       uses: ./smithy-rs/.github/actions/docker-build
       with:
         action: run-canary
-        action-arguments: ${{ secrets.CANARY_STACK_CDK_OUTPUTS_BUCKET_NAME }} ${{ steps.creds.outputs.aws-access-key-id }} ${{ steps.creds.outputs.aws-secret-access-key }} ${{ steps.creds.outputs.aws-session-token }}
+        action-arguments: ${{ secrets.CANARY_STACK_CDK_OUTPUTS_BUCKET_NAME }} ${{ steps.creds.outputs.aws-access-key-id }} ${{ steps.creds.outputs.aws-secret-access-key }} ${{ steps.creds.outputs.aws-session-token }} ${{ matrix.arch }}
 
   # This is always a failing job since forked repositories do not have necessary repository secrets
   # to run the PR bot workflow or the canary workflow

tools/ci-cdk/canary-runner/src/build_bundle.rs

@@ -204,6 +204,39 @@ lazy_static! {
     ];
 }
 
+/// Lambda architecture to target
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+pub enum LambdaArchitecture {
+    #[default]
+    X86_64,
+    Arm64,
+}
+
+impl std::str::FromStr for LambdaArchitecture {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "x86_64" | "x86-64" | "amd64" => Ok(LambdaArchitecture::X86_64),
+            "arm64" | "aarch64" => Ok(LambdaArchitecture::Arm64),
+            _ => Err(format!(
+                "Unknown architecture: {}. Use 'x86_64' or 'arm64'",
+                s
+            )),
+        }
+    }
+}
+
+impl LambdaArchitecture {
+    pub fn rust_target(&self, musl: bool) -> &'static str {
+        match (self, musl) {
+            (LambdaArchitecture::X86_64, false) => "x86_64-unknown-linux-gnu",
+            (LambdaArchitecture::X86_64, true) => "x86_64-unknown-linux-musl",
+            (LambdaArchitecture::Arm64, false) => "aarch64-unknown-linux-gnu",
+            (LambdaArchitecture::Arm64, true) => "aarch64-unknown-linux-musl",
+        }
+    }
+}
+
 #[derive(Debug, Parser, Eq, PartialEq)]
 pub struct BuildBundleArgs {
     /// Canary Lambda source code path (defaults to current directory)
@@ -234,6 +267,10 @@ pub struct BuildBundleArgs {
     #[clap(long)]
     pub musl: bool,
 
+    /// Lambda architecture to target (x86_64 or arm64)
+    #[clap(long, default_value = "x86_64")]
+    pub architecture: LambdaArchitecture,
+
     /// Only generate the `Cargo.toml` file rather than building the entire bundle
     #[clap(long)]
     pub manifest_only: bool,
@@ -367,15 +404,14 @@ pub async fn build_bundle(opt: BuildBundleArgs) -> Result<Option<PathBuf>> {
 
     if !opt.manifest_only {
         // Compile the canary Lambda
+        let target = opt.architecture.rust_target(opt.musl);
         let mut command = Command::new("cargo");
         command
             .arg("build")
             .arg("--release")
             .arg("--manifest-path")
-            .arg(&manifest_path);
-        if opt.musl {
-            command.arg("--target=x86_64-unknown-linux-musl");
-        }
+            .arg(&manifest_path)
+            .arg(format!("--target={}", target));
         handle_failure("cargo build", &command.output()?)?;
 
         // Compile the wasm canary to a .wasm binary
@@ -390,13 +426,12 @@ pub async fn build_bundle(opt: BuildBundleArgs) -> Result<Option<PathBuf>> {
 
         // Bundle the Lambda
         let repository_root = find_git_repository_root("smithy-rs", canary_path)?;
-        let target_path = {
-            let mut path = repository_root.join("tools").join("target");
-            if opt.musl {
-                path = path.join("x86_64-unknown-linux-musl");
-            }
-            path.join("release")
-        };
+        let target = opt.architecture.rust_target(opt.musl);
+        let target_path = repository_root
+            .join("tools")
+            .join("target")
+            .join(target)
+            .join("release");
         let wasm_bin_path = {
             repository_root
                 .join("tools")
@@ -492,6 +527,7 @@ mod tests {
                 sdk_release_tag: Some(ReleaseTag::from_str("release-2022-07-26").unwrap()),
                 sdk_path: None,
                 musl: false,
+                architecture: LambdaArchitecture::X86_64,
                 manifest_only: false,
             }),
             Args::try_parse_from([
@@ -509,6 +545,7 @@ mod tests {
                 sdk_release_tag: None,
                 sdk_path: Some("some-sdk-path".into()),
                 musl: false,
+                architecture: LambdaArchitecture::X86_64,
                 manifest_only: false,
             }),
             Args::try_parse_from([
@@ -528,6 +565,7 @@ mod tests {
                 sdk_release_tag: Some(ReleaseTag::from_str("release-2022-07-26").unwrap()),
                 sdk_path: None,
                 musl: true,
+                architecture: LambdaArchitecture::X86_64,
                 manifest_only: true,
             }),
             Args::try_parse_from([
@@ -547,6 +585,7 @@ mod tests {
                 sdk_release_tag: None,
                 sdk_path: Some("some-sdk-path".into()),
                 musl: false,
+                architecture: LambdaArchitecture::X86_64,
                 manifest_only: false,
             }),
             Args::try_parse_from([

tools/ci-cdk/canary-runner/src/run.rs

@@ -119,6 +119,10 @@ pub struct RunArgs {
     /// The ARN of the role that the Lambda will execute as
     #[clap(long, required_unless_present = "cdk-output")]
     lambda_execution_role_arn: Option<String>,
+
+    /// Lambda architecture to target (x86_64 or arm64)
+    #[clap(long, default_value = "x86_64")]
+    architecture: crate::build_bundle::LambdaArchitecture,
 }
 
 #[derive(Debug, Eq, PartialEq)]
@@ -127,6 +131,7 @@ struct Options {
     sdk_release_tag: Option<ReleaseTag>,
     sdk_path: Option<PathBuf>,
     musl: bool,
+    architecture: crate::build_bundle::LambdaArchitecture,
     expected_speech_text_by_transcribe: Option<String>,
     lambda_function_memory_size_in_mb: i32,
     lambda_code_s3_bucket_name: String,
@@ -194,6 +199,7 @@ impl Options {
                 sdk_release_tag: run_opt.sdk_release_tag,
                 sdk_path: run_opt.sdk_path,
                 musl: run_opt.musl,
+                architecture: run_opt.architecture,
                 expected_speech_text_by_transcribe: run_opt.expected_speech_text_by_transcribe,
                 lambda_function_memory_size_in_mb: run_opt
                     .lambda_function_memory_size_in_mb
@@ -210,6 +216,7 @@ impl Options {
                 sdk_release_tag: run_opt.sdk_release_tag,
                 sdk_path: run_opt.sdk_path,
                 musl: run_opt.musl,
+                architecture: run_opt.architecture,
                 expected_speech_text_by_transcribe: run_opt.expected_speech_text_by_transcribe,
                 lambda_function_memory_size_in_mb: run_opt
                     .lambda_function_memory_size_in_mb
@@ -362,6 +369,7 @@ async fn build_bundle(options: &Options) -> Result<PathBuf> {
         sdk_release_tag: options.sdk_release_tag.clone(),
         sdk_path: options.sdk_path.clone(),
         musl: options.musl,
+        architecture: options.architecture,
         manifest_only: false,
     };
     info!("Compiling the canary bundle for Lambda with {build_args:?}. This may take a few minutes...");
@@ -430,10 +438,16 @@ async fn create_lambda_fn(
             ),
     };
 
+    let lambda_arch = match options.architecture {
+        crate::build_bundle::LambdaArchitecture::X86_64 => Architecture::X8664,
+        crate::build_bundle::LambdaArchitecture::Arm64 => Architecture::Arm64,
+    };
+
     lambda_client
         .create_function()
         .function_name(bundle_name)
         .runtime(Runtime::Providedal2)
+        .architectures(lambda_arch)
         .role(&options.lambda_execution_role_arn)
         .handler("aws-sdk-rust-lambda-canary")
         .code(
@@ -544,6 +558,7 @@ async fn delete_lambda_fn(lambda_client: lambda::Client, bundle_name: &str) -> R
 
 #[cfg(test)]
 mod tests {
+    use crate::build_bundle::LambdaArchitecture;
     use crate::run::{Options, RunArgs, DEFAULT_LAMBDA_FUNCTION_MEMORY_SIZE_IN_MB};
     use clap::Parser;
 
@@ -562,7 +577,8 @@ mod tests {
                 lambda_test_s3_bucket_name: None,
                 lambda_execution_role_arn: None,
                 lambda_test_s3_mrap_bucket_arn: None,
-                lambda_test_s3_express_bucket_name: None
+                lambda_test_s3_express_bucket_name: None,
+                architecture: LambdaArchitecture::X86_64,
             },
             RunArgs::try_parse_from([
                 "run",
@@ -605,6 +621,7 @@ mod tests {
                 sdk_release_tag: None,
                 sdk_path: Some("artifact-aws-sdk-rust/sdk".into()),
                 musl: false,
+                architecture: LambdaArchitecture::X86_64,
                 expected_speech_text_by_transcribe: Some("Good day to you transcribe.".to_owned()),
                 lambda_function_memory_size_in_mb: DEFAULT_LAMBDA_FUNCTION_MEMORY_SIZE_IN_MB,
                 lambda_code_s3_bucket_name: "bucket-for-code".to_owned(),

tools/ci-scripts/run-canary

@@ -10,6 +10,7 @@ CANARY_STACK_CDK_OUTPUTS_BUCKET_NAME=$1
 export AWS_ACCESS_KEY_ID=$2
 export AWS_SECRET_ACCESS_KEY=$3
 export AWS_SESSION_TOKEN=$4
+ARCHITECTURE=${5:-x86_64}
 export AWS_REGION=us-west-2
 export RUST_LOG=debug
 
@@ -21,4 +22,5 @@ cargo run -- \
   run --rust-version "${RUST_STABLE_VERSION}" \
       --sdk-path "${SDK_PATH}" \
       --cdk-output cdk-outputs.json \
+      --architecture "${ARCHITECTURE}" \
       --musl