Post Syndicated from James Beswick original https://aws.amazon.com/blogs/compute/sending-mobile-push-notifications-and-managing-device-tokens-with-serverless-application/
This post is written by Rafa Xu, Cloud Architect, Serverless and Joely Huang, Cloud Architect, Serverless.
Amazon Simple Notification Service (SNS) is a fast, flexible, fully managed push messaging service in the cloud. SNS can send mobile push notifications directly to applications on mobile devices such as message alerts and badge updates. SNS sends push notifications to a mobile endpoint created by supplying a mobile token and platform application.
When publishing mobile push notifications, a device token is used to generate an endpoint. This identifies where the push notification is sent (target destination). To push notifications successfully, the token must be up to date and the endpoint must be validated and enabled.
A common challenge when pushing notifications is keeping the token up to date. Tokens can automatically change due to reasons such as mobile operating system (OS) updates and application store updates.
This post provides a serverless solution to this challenge. It also provides a way to publish push notifications to specific end users by maintaining a mapping between users, endpoints, and tokens.
Overview
To publish mobile push notifications using SNS, generate an SNS endpoint to use as a destination target for the push notification. To create the endpoint, you must supply:
- A mobile application token: The mobile operating system (OS) issues the token to the application. It is a unique identifier for the application and mobile device pair.
- Platform Application Amazon Resource Name (ARN): SNS provides this ARN when you create a platform application object. The platform application object requires a valid set of credentials issued by the mobile platform, which you provide to SNS.
Once the endpoint is generated, you can store and reuse it again. This prevents the application from creating endpoints indefinitely, which could exhaust the SNS endpoint limit.
To reuse the endpoints and successfully push notifications, there are a number of challenges:
- Mobile application tokens can change due to a number of reasons, such as application updates. As a result, the publisher must update the platform endpoint to ensure it uses an up-to-date token.
- Mobile application tokens can become invalid. When this happens, messages won’t be published, and SNS disables the endpoint with the invalid token. To resolve this, publishers must retrieve a valid token and re-enable the platform endpoint
- Mobile applications can have many users, each user could have multiple devices, or one device could have multiple users. To send a push notification to a specific user, a mapping between the user, device, and platform endpoints should be maintained.
For more information on best practices for managing mobile tokens, refer to this post.
Follow along the blog post to learn how to implement a serverless workflow for managing and maintaining valid endpoints and user mappings.
Solution overview
The solution uses the following AWS services:
- Amazon API Gateway: Provides a token registration endpoint URL used by the mobile application. Once called, it invokes an AWS Lambda function via the Lambda integration.
- Amazon SNS: Generates and maintains the target endpoint and manages platform application objects.
- Amazon DynamoDB: Serverless database for storing endpoints that also maintains a mapping between the user, endpoint, and mobile operating system.
- AWS Lambda: Retrieves endpoints from DynamoDB, validates and generates endpoints, and publishes notifications by making requests to SNS.
The following diagram represents a simplified interaction flow between the AWS services:
To register the token, the mobile app invokes the registration token endpoint URL generated by Amazon API Gateway. The token registration happens every time a user logs in or opens the application. This ensures that the token and endpoints are always valid during the application usage.
The mobile application passes the token, user, and mobileOS as parameters to API Gateway, which forwards the request to the Lambda function.
The Lambda function validates the token and endpoint for the user by making API calls to DynamoDB and SNS:
- The Lambda function checks DynamoDB to see if the endpoint has been previously created.
- If the endpoint does not exist, it creates a platform endpoint via SNS.
- Obtain the endpoint attributes from SNS:
- Check the “enabled” endpoint attribute and set to “true” to enable the platform endpoint, if necessary.
- Validate the “token” endpoint attribute with the token provided in the API Gateway request. If it does not match, update the “token” attribute.
- Send a request to SNS to update the endpoint attributes.
- If a new endpoint is created, update DynamoDB with the new endpoint.
- Return a successful response to API Gateway.
Deploying the AWS Serverless Application Model (AWS SAM) template
Use the AWS SAM template to deploy the infrastructure for this workflow. Before deploying the template, first create a platform application in SNS.
- Navigate to the SNS console. Select Push Notifications on the left-hand menu to create a platform application:
- This shows the creation of a platform application for iOS applications:
- To install AWS SAM, visit the installation page.
- To deploy the AWS SAM template, navigate to the directory where the template is located. Run the commands in the terminal:
git clone https://github.com/aws-samples/serverless-mobile-push-notification cd serverless-mobile-push-notification sam build sam deploy --guided
Lambda function code snippets
The following section explains code from the Lambda function for the workflow.
Create the platform endpoint
If the endpoint exists, store it as a variable in the code. If the platform endpoint does not exist in the DynamoDB database, create a new endpoint:
need_update_ddb = False
response = table.get_item(Key={'username': username, 'appos': appos})
if 'Item' not in response:
# create endpoint
response = snsClient.create_platform_endpoint(
PlatformApplicationArn=SUPPORTED_PLATFORM[appos],
Token=token,
)
devicePushEndpoint = response['EndpointArn']
need_update_ddb = True
else:
# update the endpoint
devicePushEndpoint = response['Item']['endpoint']
Check and update endpoint attributes
Check that the token attribute for the platform endpoint matches the token received from the mobile application through the request. This also checks for the endpoint “enabled” attribute and re-enables the endpoint if necessary:
response = snsClient.get_endpoint_attributes(
EndpointArn=devicePushEndpoint
)
endpointAttributes = response['Attributes']
previousToken = endpointAttributes['Token']
previousStatus = endpointAttributes['Enabled']
if previousStatus.lower() != 'true' or previousToken != token:
snsClient.set_endpoint_attributes(
EndpointArn=devicePushEndpoint,
Attributes={
'Token': token,
'Enabled': 'true'
}
)
Update the DynamoDB table with the newly generated endpoint
If a platform endpoint is newly created, meaning there is no item in the DynamoDB table, create a new item in the table:
if need_update_ddb:
table.update_item(
Key={
'username': username,
'appos': appos
},
UpdateExpression="set endpoint=:e",
ExpressionAttributeValues={
':e': devicePushEndpoint
},
ReturnValues="UPDATED_NEW"
)
As best practice, the code cleans up the table, in case there are multiple entries for the same endpoint mapped to different users. This can happen when the mobile application is used by multiple users on the same device. When one user logs out and a different user logs in, this creates a new entry in the DynamoDB table to map the endpoint with the new user.
As a result, you must remove the entry that maps the same endpoint to the previously logged in user. This way, you only keep the endpoint that matches the user provided by the mobile application through the request.
result = table.query(
# Add the name of the index you want to use in your query.
IndexName="endpoint-index",
KeyConditionExpression=Key('endpoint').eq(devicePushEndpoint),
)
for item in result['Items']:
if item['username'] != username and item['appos'] == appos:
print(f"deleting orphan item: username {username}, os {appos}".format(username=item['username'], appos=appos))
table.delete_item(
Key={
'username': item['username'],
'appos': appos
},
)
Conclusion
This blog shows how to deploy a serverless solution for validating and managing SNS platform endpoints and tokens. To publish push notifications successfully, use SNS to check the endpoint attribute and ensure it is mapped to the correct token and the endpoint is enabled.
This approach uses DynamoDB to store the device token and platform endpoints for each user. This allows you to send push notifications to specific users, retrieve, and reuse previously created endpoints. You create a Lambda function to facilitate the workflow, including validating the DynamoDB item for storing an enabled and up-to-date token.
Visit this link to learn more about Amazon SNS mobile push notifications: http://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html
For more serverless learning resources, visit Serverless Land.
