Hey there! Let's walk through how to set up API Gateway to pass parameters to your Lambda function step by step—since you already have a working Lambda that interacts with DynamoDB, this part should be straightforward.

First, head to the AWS API Gateway console:

• Create a REST API (it’s easier for detailed parameter mapping as a beginner) or an HTTP API if you prefer a lighter setup.
• Add a resource (like /data) and a method (e.g., GET or POST) that links to your existing Lambda function. When you bind the Lambda, AWS will usually auto-create the necessary permissions, but double-check if you run into access errors later.

Decide where your parameters will come from, then set them up in the method’s Request tab:

• Path parameters (e.g., /data/{itemId}): Add a path parameter named itemId, and check "Required" if it’s mandatory.
• Query string parameters (e.g., /data?id=123): Add a query string parameter named id.
• Request body parameters (e.g., a JSON payload like {"itemId": "abc123"}): No need to pre-define these, but make sure API Gateway is set to parse JSON requests.

This is the key part—you’ll tell API Gateway how to send request data to your Lambda:

1. Go to the method’s Integration Request tab.
2. Scroll down to Mapping Templates, select "When no template matches the request content type pass through" (or just add a template directly).
3. Add a template with content type application/json, then paste a mapping that fits your parameter source. Here are common examples:
   • Map a path parameter:

     {
       "itemId": "$input.params('itemId')"
     }
     

   • Map a query string parameter:

     {
       "id": "$input.params('id')"
     }
     

   • Map the entire JSON request body:

     $input.json('$')
     

   • Mix multiple parameter types:

     {
       "pathItemId": "$input.params('itemId')",
       "queryName": "$input.params('name')",
       "bodyData": $input.json('$')
     }
     

4. Save the template, then deploy your API to a stage (like dev—you’ll need this deployed stage URL to test later).

Since you’re using Visual Studio (I assume C# for your Lambda), you can create a simple class to deserialize the incoming data:

// Define a class that matches your mapped parameter structure
public class LambdaRequestInput
{
    public string ItemId { get; set; }
    public string Id { get; set; }
    // Add other properties as needed for your parameters
}

public string FunctionHandler(LambdaRequestInput input, ILambdaContext context)
{
    // Now you can use input.ItemId or input.Id to query DynamoDB
    // Your existing logic: check if data exists, create if not
    context.Logger.LogInformation($"Received item ID: {input.ItemId}");
    return "Operation completed";
}

• Use the API Gateway console’s Test tab: Enter your parameters (path, query string, or request body) and hit "Test" to verify Lambda receives the correct data.
• Or use tools like Postman or curl to call your deployed API URL (e.g., https://your-api-id.execute-api.region.amazonaws.com/dev/data?itemId=abc123) and check the response.

• If you get a "permission denied" error, make sure your Lambda’s execution role has the lambda:InvokeFunction permission for API Gateway.
• For HTTP API, parameter mapping is even simpler—you can choose to pass all request data directly to Lambda without writing templates, which is great for faster setups.

内容的提问来源于stack exchange，提问作者Jerimiah Huston