#149 — May 8, 2020

Read on the Web

Serverless Status
Serverless news, views, and developments every Friday

How to Build a Serverless Martian Weather Display with CircuitPython and AWS Lambda — When there’s no big news it’s always nice to lead with something a bit fun! This tutorial demonstrates the creation of a standalone digital weather display for Mars (yes, the planet!) including showing the latest images from the Mars Curiosity Rover. AWS Lambda is involved, naturally, but some of the other bits might be new to you including the Adafruit PyPortal and CircuitPython. (This has just made me buy one!)

Moheeb Zara (AWS)

Serverless Events: A Curated List of Serverless Events — Of course, the best thing about this list right now is that all (but one!) of the events are online, so there’s lots of things you can attend. Most are single talks rather than lengthy events. You’re also invited to submit your events.

Gunnar Grosch

Full Observability for Microservice Environments — Monitor & troubleshoot serverless functions to get the full picture of what they're doing & why they fail. Optimize service costs, troubleshoot issues quickly & reduce MTTR with full data correlation, payload visibility & distributed tracing. Try Free.

Epsagon sponsor

Making the Case for Serverless Use Cases — Jeremy writes up nine neat use cases for serverless that he discussed with Serverless Inc’s Gareth McCumskey on the Serverless Chats podcast recently. RESTful APIs, cron jobs, and machine learning all get a look in.

Jeremy Daly

Serverless in the Wild: Azure Functions Production Usage Statistics — A couple of months ago we featured a paper about how Azure Functions allocates and provisions resources based on workload. This article, by an Azure MVP, summarizes the most interesting points in a more accessible way.

Mikhail Shilkov

Serverless Needs Standardization to Be the Future of Application Infrastructure — A lot of the technologies serverless platforms use under the hood are standardized but the way they work isn’t necessarily as generic and apps built for one platform may not easily transition to another. This needs to change, argues Gadi Naor.

Gadi Naor

Creating a Scalable Serverless Import Process for Amazon DynamoDB — How to import large amounts of data into DynamoDB from S3 using a parallel serverless approach, initially with a Lambda function alone, but at higher scale with two functions and an SQS queue in between.

James Beswick

Using AWS API Gateway to Run Database Queries — API Gateway is commonly used to hook up HTTP endpoints to AWS Lambda functions but did you know it can directly connect to DynamoDB? (Or any AWS service that lets you query over the AWS API, so not RDS.)

Renato Byrro

How to Remain Agile with DynamoDB — Amazon DynamoDB delivers performance at scale but at a cost to flexibility (particularly early on in the development cycle when your eventual access patterns aren’t always known) – there are some mitigations, however.

Rob Cronin

Reusing Redis Connections in AWS Lambda — Of course, this only works if the same hot instance of the function is run again, but callbackWaitsForEmptyEventLoop is well worth knowing about.

Sven Anderson

The Database for Serverless Real-time Applications — An in-depth look into the Aggregator Leaf Tailer Architecture (ALT) used by Rockset to auto-scale ingest and queries independently for fast queries on fresh data.

Rockset sponsor

TLDR: Writing a Slack bot to Summarize Articles — Using state-of-the-art NLP to read more news, faster? I always find automated summaries to be kinda useless, but the way it’s put together is neat nonetheless.

Chris Ismael

▶  A Chat with James Beswick, AWS Serverless Developer Advocate

Serverless Transformation Podcast podcast

sls-dev-tools: Dev Tools for the Serverless World, Now with Notifications — We featured this project just two issues ago but development is happening fast and the latest version now lets you get push notifications if any lambdas you’re monitoring encounter errors.. neat!

Theodo UK

🐦 An interesting Twitter thread

Check out this thread by Jeremy Thomerson. You might think that using as little memory as necessary is the way to go on AWS Lambda but he's noticed that if you turn the taps up a little bit, you can end up with a bigger decrease in running time.

You'd need to do a performance vs cost analysis for your own use case though, since you're charged for 100ms at minimum even if your function only takes 20ms to run.. but in Jeremy's case, the savings are well worth it both ways.

Follow @jthomerson while you're over there as well 😄