For a web app, I am making an AWS Lambda function which is triggered by the api gateway. I have the api gateway linked to a cognito user pool so you need to sign in before triggering the function. The "Options" part has no authorization enabled and the "post" method has the cognito user pool as the authorizer. When I press a button on the front end to trigger it, the function runs correctly. My problem is that context.identity.cognito_identity_id always returns a null value and not a sub uuid as expected. I don't know why this is. I tried enabling "Invoke with caller credentials" but when I mouse over the check box is says I can't enable it. This is my current lambda function:
import json
def lambda_handler(event, context):
UniqueUser = context.identity.cognito_identity_id
if not UniqueUser:
UniqueUser = "fail"
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*'
},
'body': json.dumps('Hello from Lambda ' + UniqueUser + "!")
};
How can I make it so that context.identity.cognito_identity_id (or something similar) returns the user's uuid as I believe it should?
Looks like sub and/or email are in event['requestContext']['authorizer']['claims']
I'm uploading an image to s3, through a lambda, and everything works well, with no errors, but the response from API Gateway is 500 Internal Server Error.
I configured my api-gateway following this tutorial: Binary Support for API Integrations with Amazon API Gateway.
My lambda receives the base64Image, decode it and successfully upload to s3.
This is my lambda code:
def upload_image(event, context):
s3 = boto3.client('s3')
b64_image = event['base64Image']
image = base64.b64decode(b64_image)
try:
with io.BytesIO(image) as buffer_image:
buffer_image.seek(0)
s3.upload_fileobj(buffer_image, 'MY-BUCKET', 'image')
return {'status': True}
except ClientError as e:
return {'status': False, 'error': repr(e)}
This is what i'm receiving:
{
"message": "Internal server error"
}, with a 500 status code.
Obs: I'm not using lambda proxy integration.
You need to return a header in the response, e.g. in Python:
return {
"statusCode": 200,
'headers': { 'Content-Type': 'application/json' },
"body": json.dumps(body)
}
That example looks like it falls short on mapping the responses section in favor of a pass through. In which case changing your return to: return {'status': True, 'statusCode': 200} might work.
Generally speaking there are two paths when building a response with ApiGateway-Lambda. One is the lambda-proxy (where your lambda function defines the response), the other is where ApiGateway transforms your responses and generates the appropriate headers/status based on a mapping.
The path from the example is for the latter.
Personally I would change:
return {'status': True}
to return {'status': "Success"} And create a regex that looks for the word "Success" and "Error" respectively.
I have used this blog post successfully with this technique (it also describes at length the differences between the two approaches). Once you get one mapping working you could adjust it as is more appropriate for your implementation.
EDIT: hot tip these decorators are awesome and make python & lambda even cleaner/easier but mostly for the proxy setup
I have a lambda function invoked from my browser. I know that is working because the response is correct. In my lambda, I want to write into a dynamo table so I updated my function to include this logic.
When I test my function in the lambda console it works as expected. When the lambda is called from the browser (via API Gateway), it does not execute any of the new code that I added.
Here is my code:
#set-up table connection
dynamodb = boto3.resource('dynamodb', region_name='us-east-1')
table = dynamodb.Table('XXXX')
tString = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
#print("Received event: " +
# json.dumps(event, indent=2))
#recieve parameters
if 'userid' in event:
userid = event['userid']
else:
userid = 'nothing'
if 'token' in event:
token = event['token']
else:
token = 'nothing'
if 'appid' in event:
appid = event['appid']
else:
appid = 'connection'
response = table.put_item(
Item = {
'ID': userid,
'token': 'test2',
'appid': 'test2',
'authApp': 'test2',
'authUser': 'test2'
})
return userid
Are you invoking your Lambda via API Gateway? If so, check the Lambda integration for the endpoint you are hitting in API Gateway and see if the version/alias of the Lambda function is hardcoded. You can find this by looking at the value of "Lambda Function" in the Integration Request section of the API Gateway method:
Lambda Function: my_function:dev
In the example above, this means your API Gateway is invoking the "dev" version of the "my_function" lambda.
Then check in the Lambda console if the version/alias you are invoking in the console, the one with the recent DynamoDB changes, matches the version/alias that is being invoked by the API Gateway.
I have spent a day or two smashing my head against the keyboard trying to figure out why my updates weren't being executed to realize that the API Gateway was pointing at a different/older version of my function.
I have an API gateway that invokes a lambda function using proxy integration. The lambda handler is like this:
def lambda_handler(event, context):
# TODO implement
return {
'statusCode': 200,
'body': json.dumps(my_func(event["queryStringParameters"]["level"]))
}
When I hit test on the API gateway and pass a param level=easy, the function runs correctly and I see the output in json. However when I take the invoke URL that is shown under stages and run it from the browser
https://xxxx.execute-api.us-west-2.amazonaws.com/default/myendpoint?level=easy
It errors out like this:
{"errorMessage": "'queryStringParameters'",
"errorType": "KeyError", "stackTrace":
[["/var/task/lambda_function.py", 95, "lambda_handler", "'body' : json.dumps(get_puzzle(event[\"queryStringParameters\"][\"level\"]))"]]}
What am I missing?
In an AWS Lambda code, how can I get the HTTP method (e.g. GET, POST...) of an HTTP request coming from the AWS Gateway API?
I understand from the documentation that context.httpMethod is the solution for that.
However, I cannot manage to make it work.
For instance, when I try to add the following 3 lines:
if (context.httpMethod) {
console.log('HTTP method:', context.httpMethod)
}
into the AWS sample code of the "microservice-http-endpoint" blueprint as follows:
exports.handler = function(event, context) {
if (context.httpMethod) {
console.log('HTTP method:', context.httpMethod)
}
console.log('Received event:', JSON.stringify(event, null, 2));
// For clarity, I have removed the remaining part of the sample
// provided by AWS, which works well, for instance when triggered
// with Postman through the API Gateway as an intermediary.
};
I never have anything in the log because httpMethod is always empty.
The context.httpMethod approach works only in templates. So, if you want to have access to the HTTP method in your Lambda function, you need to find the method in the API Gateway (e.g. GET), go to the Integration Request section, click on Mapping Templates, and add a new mapping template for application/json. Then, select the application/json and select Mapping Template and in the edit box enter something like:
{
"http_method": "$context.httpMethod"
}
Then, when your Lambda function is called, you should see a new attribute in the event passed in called http_method which contains the HTTP method used to invoke the function.
API Gateway now has a built-in mapping template that passes along stuff like http method, route, and a lot more. I can't embed because I don't have enough points, but you get the idea.
Here is a screenshot of how you add it in the API Gateway console:
To get there navigate to AWS Console > API Gateway > (select a resource, IE - GET /home) > Integration Request > Mapping Templates > Then click on application/json and select Method Request Passthrough from dropdown shown in the screenshot above
I had this problem when I created a template microservice-http-endpoint-python project from functions.
Since it creates an HTTP API Gateway, and only REST APIs have Mapping template I was not able to put this work. Only changing the code of Lambda.
Basically, the code does the same, but I am not using the event['httpMethod']
Please check this:
import boto3
import json
print('Loading function')
dynamo = boto3.client('dynamodb')
def respond(err, res=None):
return {
'statusCode': '400' if err else '200',
'body': err.message if err else json.dumps(res),
'headers': {
'Content-Type': 'application/json',
},
}
def lambda_handler(event, context):
'''Demonstrates a simple HTTP endpoint using API Gateway. You have full
access to the request and response payload, including headers and
status code.
To scan a DynamoDB table, make a GET request with the TableName as a
query string parameter. To put, update, or delete an item, make a POST,
PUT, or DELETE request respectively, passing in the payload to the
DynamoDB API as a JSON body.
'''
print("Received event: " + json.dumps(event, indent=2))
operations = {
'DELETE': lambda dynamo, x: dynamo.delete_item(**x),
'GET': lambda dynamo, x: dynamo.scan(**x),
'POST': lambda dynamo, x: dynamo.put_item(**x),
'PUT': lambda dynamo, x: dynamo.update_item(**x),
}
operation = event['requestContext']['http']['method']
if operation in operations:
payload = event['queryStringParameters'] if operation == 'GET' else json.loads(event['body'])
return respond(None, operations[operation](dynamo, payload))
else:
return respond(ValueError('Unsupported method "{}"'.format(operation)))
I changed the code from:
operation = event['httpMethod']
to
operation = event['requestContext']['http']['method']
How do I get this solution?
I simply returned the entire event, checked the JSON and put it to work with the correct format.
If event appears an empty object, make sure you enabled proxy integration for the method. Proxy integration for an HTTP method adds request information into event.
See Use Lambda Proxy integration on API Gateway page.
If you are using API gateway, http method will be automatically passed to the event parameter when the lambda is triggered.
export const handler: Handler<APIGatewayProxyEvent> = async (
event: APIGatewayEvent,
context: Context
): Promise<APIGatewayProxyResult> => {
const httpMethod = event.httpMethod;
...
}