ServiceConnect with CDK builds Strong Service Affinity

Containers are a fantastic way to package up your application code and its dependencies. I’m on the record as a huge fan and probably write more production code in containers than I do with Lambda Functions. Call me crazy, but I like frameworks like Axum and ActiveX in Rust. When I’m connecting APIs over either HTTP or gRPC, I generally reach for AWS Elastic Container Service (ECS). I enjoy working with k8s and the plethora of open source tools, but ECS just makes things so simple, highly available, and with the announcement of ServiceConnect in 2022, more connected. In this article, I’m going to explore ServiceConnect with CDK.


Strong Performance with EC2, Lambda, and the Momento SDK for Rust

I wrote recently about Mind Boggling Speed with Caching with Momento and Rust and wanted to continue in that theme as I explore the Momento SDK for Rust. Caching is a technique that builders reach for when looking to accomplish either improved performance or reduce the burden on resource-dependent parts of an application. It might also be a choice when looking to save costs if an operation is charged per read such as with DynamoDB. In any of those scenarios, caching must be fast. But caching must not also introduce a high amount of complexity. This is where I love Momento because I truly do get the best of both worlds. High-performance caching with the simplicity of serverless.

No caching solution would be complete however with the ability to subscribe to cache key changes. Topics aren’t new in the engineering world, but I wanted to sit down and write some code against the Momento SDK for Rust and see how the ergonomics felt in addition to how well it performed. But comparing it in a vacuum against itself didn’t seem like a lot of fun, so I am going to pair it against their companion product in Webhooks.


Mind Boggling Speed when Caching with Momento and Rust

Summer is here and in the northern hemisphere, temperatures are heating up. Living in North Texas, you get used to the heat and humidity but somehow it still always seems to sneak up on me. As I start this new season (which happens to be my favorite) I wanted to reflect a touch and remember the summer of 2023. That summer, I looked at 6 different aspects of serverless development from the perspective of things I wish I had known when I was getting started. Fast forward to this summer when I started with Does Serverless Still Matter? What a year it’s been for sure. And as I look forward to the next few hot months, I’m going to explore my current focus which is highly performant serverless patterns. And to kick things off, let’s get started with caching with Momento and


The Neighborhood Domain will Quickly Improve your Modeling Skills

Microservices are about domain decomposition. This decomposition allows code to be deployed that is more isolated, durable, resilient, and launched in a compute form factor designed for the requirements. In addition, the isolation allows for teams to move on their deployment schedules and cadences. These reasons are attractive, but they do come with domain complexity that often manifests itself as architectural complexity. And while I can’t remove the architectural complexity, I do want to offer an approach to domain modeling that will feel more familiar. Introducing the neighborhood domain.


Secure Pattern for Deploying WASM on S3

Picking up where I left off from the last article, I’d built a simple WASM project with Rust and walked through how to generate a publishable distribution. In this edition, which is probably the penultimate in the series, I need to get a path towards CloudFront and S3. I want to stay true to the Serverless objective and those two services are perfect for shipping web-delivered code. So let’s dive into Deploying WASM on S3.


Surprisingly Powerful – Serverless WASM with Rust Article 1

It’s been a while since I wrote a series going back almost 9 months to my Building Serverless Applications. I enjoyed that so much that I have been wanting to write another, but just didn’t have a continuous thread of material. But lately, I’ve been thinking a lot about “full stack” development and where the future of delivery is going. Some of that thinking has led me down a path of what if. What if I was able to use my favorite programming language and my preferred AWS Serverless tools to build full-stack web applications? I’m not 100% sure I’d do this in production at the moment, but again, I’m exploring what if. This series is the expansion of that thought. Let’s get started on Serverless WASM with Rust.


Guaranteed Safety using Blue Green with ECS and CDK

Buckle up for this one as it’s going to be a lengthy piece. I love writing articles like this one because they contain complete infrastructure builds that highlight some best practices to put multiple components together and act as great starting points for people to use immediately. I’ve been working a great deal with containers lately and I kept finding it difficult to locate a working sample of building Blue Green with ECS and CDK. So I set out to put that together. Let’s get started.


3 Proven Patterns for Reporting with Serverless

Serverless architecture has given developers, architects, and business problem solvers new capabilities to deliver value to customers. It feels like we are in the age of maturation of serverless in so many ways. The boom of containers, the birth of functions, and now the options of even Zero-code serverless implementations (Step Functions). These are all great things from an application developer’s perspective. But what about reporting? There are so many signals emitted from these systems but has the reporting world kept up with the changes in architecture? And what are some strategies to take advantage of data in this current landscape? Let’s have a look at Reporting with Serverless.


An Allow List Lambda Function in Rust is 1 Guaranteed Way to Improve CORS

Some time ago I wrote an article about Cross-Origin Resource Sharing with API Gateway that talks about custom allow lists. I wanted to revisit that implementation not because the code doesn’t work, but because I wanted to see what it would look like in Rust. Remember, I believe that more developers would be choosing Rust with Serverless if more content and examples existed. Let’s dive into building a Lambda Function in Rust for CORS.


A Proven and Comprehensive Pattern for Building an API with Rust and Lambda

I’ve been encouraged lately by all of the Rust and Serverless content that has been posted on various platforms. I’ve also been public about the fact that I believe that Rust adoption with Serverless would be further along if there was more quality content written on the topic. I know for certain that there is interest from developers about whether they should and how would they introduce Rust into their builds and while I’ve tackled pieces of the puzzle, I haven’t taken on a fully working CRUD API. This article looks to change that. Let’s dive into building an API with Rust and Lambda.