DEV Community: Jonathan Brizio

Enforce Consistent Resource Naming in AWS SAM Templates

Jonathan Brizio — Fri, 02 May 2025 02:36:22 +0000

The problem

If you've worked with AWS SAM templates long enough, you've probably run into messy or inconsistent resource names. These inconsistencies aren’t just an eyesore — they can cause confusion in large teams and complex deployments.

The solution

That’s why I created sam-resource-name-linter — a simple CLI tool to enforce consistent, configurable naming conventions for your AWS SAM resources.

It's a tool written in Javascript that scans your template.yaml files and checks the logical resource names against a naming convention that you define.

It was built to help teams maintain readable, standardized CloudFormation templates — especially in larger serverless projects where consistency can quickly fall apart.

Key Features

✅ Works out of the box with sensible defaults
⚙️ Fully configurable naming conventions (regex-based)
🧪 Simple integration into CI/CD pipelines

How It Works

Install the package globally or as a dev dependency:

npm install --save-dev sam-resource-name-linter

Create a new file called named .sam-resource-name-rules.json in the root directory of your SAM project.
Configure the linter: Before running the linter, personalize your configuration file (.sam-resource-name-rules.json) by defining the resource naming rules that suit your project's needs.
Execute the linter using the following command:

sam-resource-name-linter

Use Cases

Team Enforcement: Codify naming rules in CI to enforce consistency across PRs.
Legacy Cleanup: Identify resources that don’t follow your current naming patterns.
Education: Teach new developers your team's conventions automatically.

Try It Out

👉 NPM: https://www.npmjs.com/package/sam-resource-name-linter
📖 GitHub: https://github.com/jbrizio/sam-resource-name-linter#readme

How to Test AWS Services in Node.js with LocalStack, Testcontainers, and Jest

Jonathan Brizio — Sun, 09 Mar 2025 03:00:00 +0000

Introduction

Testing AWS-integrated applications presents significant challenges, including slow feedback loops and the cost associated with using cloud resources. In our development workflow, we encountered a critical issue: how to efficiently test AWS services in a local environment without deploying them to the cloud. To address this, we explored a combination of tools that would allow for a local, isolated, and reproducible testing setup.

After thorough research, one of our senior developers identified an optimal solution leveraging LocalStack, Testcontainers, and Jest. This combination enables us to simulate AWS services, manage ephemeral test environments, and execute reliable test cases efficiently. In this article, I will show you how these tools work together and how they can be integrated into a Node.js development workflow for testing AWS-dependent applications.

Overview of Tools

LocalStack is an open-source tool that provides a fully functional mock environment for AWS services. It allows developers to run their applications locally while simulating AWS services, eliminating the need to connect to a live AWS instance. This significantly reduces cloud costs and improves the speed of development and testing cycles.
Testcontainers is a library designed to simplify the management of containerized environments for testing. It enables developers to spin up LocalStack instances within isolated containers, ensuring that each test runs in a clean, consistent, and reproducible environment.

Prerequisites

Before proceeding, ensure the following prerequisites are met:

Node.js and npm are installed on your machine
Docker is installed and running

Key Considerations

Testing Framework: This solution is demonstrated using Jest, which will be installed automatically when dependencies are installed via npm. However, other testing frameworks can be substituted based on project requirements.
Service Compatibility: Verify that LocalStack supports the AWS services required for your tests before integrating it into your testing strategy.

Implementation

To illustrate this approach, I prepared a simple AWS Lambda function that returns a greeting message. The repository also includes a test file (lambda.test.js) to validate the Lambda function’s behavior.

Testing Process

Running the test command via npm initializes a local container.
The Lambda function’s source code is zipped and deployed inside the container.
The test executes the Lambda function and validates the returned response as a standard unit test.
All resources are automatically cleaned up upon test completion, ensuring a fast and efficient execution cycle.

Conclusion

By incorporating these tools into our workflow, we have significantly improved test efficiency and resource management. Have you tried using LocalStack or similar tools for AWS testing? We’d love to hear your thoughts and experiences with this approach!

Avoiding Code Chaos: The Broken Windows Principle in Software Development

Jonathan Brizio — Sun, 14 Apr 2024 18:39:01 +0000

In the world of software development, one principle that resonates deeply with programmers is the Broken Windows Theory. This theory was originally proposed by James Q. Wilson and George L. Kelling in the realm of urban sociology and suggests that visible signs of disorder in a community can lead to anti-social behavior. But how does this theory apply to software engineering?

The Broken Windows Theory has a compelling parallel in the world of code. Neglected code elements within a software project such as outdated comments, unused variables, or inconsistent formatting can be considered as "broken windows" of code. If left unaddressed, they can lead to larger issues down the line.

Just as a single broken window in a building can signal to vandals that no one cares about the property, a neglected codebase can communicate to developers that maintenance and cleanliness are not priorities. This can result in decreased developer morale, increased technical debt, and reduced overall productivity, which is a scenario all too familiar to software teams.

To avoid the Broken Windows Theory in their codebase, software engineers need to be proactive in maintaining a culture of cleanliness. Regular code reviews, refactoring sessions, and the use of automated tools for code quality assurance are essential strategies for keeping "digital streets" clean and orderly. Moreover, fostering a team culture that values accountability and takes pride in the quality of its code can go a long way in preventing the accumulation of "broken windows."

By recognizing the importance of maintaining order and cleanliness in code, developers can mitigate the risk of larger issues arising and ensure the long-term health and sustainability of their projects.

Do you have any tips or best practices to share on how to maintain a clean software environment in your projects? I'd love to hear your thoughts and experiences!

Building a Serverless Photomontage WebApp with Node.js

Jonathan Brizio — Mon, 23 Mar 2020 22:21:15 +0000

The benefits of the lambda functions are endless. The good thing is that you can create anything in a few clicks. I'm a big fan of the services that offer AWS. You can start with something really simple and apply more complexity adding more services.

On this opportunity, I will show you how was integrate some components that AWS offers to us to make the final product.

Before putting hands to works, was read some docs and view some implementations to understand if the idea can be viable. The focus was always trying to implement that solution using JavaScript because I have more knowledge of that.

Initial idea

In this case, it was an online photomontage that merges our wanted message into a template that I choose:

Getting Started

The next step was to find a module on npm that resolve our requirement to manipulate images easily. Jimp looks good to me because not have third dependencies and your documentation is complete enough.

With the help of Claudia.js, it was really easy to automate deployments of the lambda functions just with a few commands from the console.

Architecture

The user interacts with an interface, this is located in a bucket (Amazon S3). The form located there, dispatch a POST to an API Rest. Here our AWS API Gateway takes the petition and executes a lambda function to generate the wanted photo in a few seconds.

Services used

Amazon S3
Amazon API Gateway
Amazon Lambda

Online Demo

If you want to see all the components working, can you visit the online demo clicking here. This same concept could be used for multiple scenarios.

Main feature

The part most important of this development is the lambda function. Here you can see the code used to generate the photomontage.

What other scenario do you imagine using this?.

Using Postman like a PRO with these tricks 😎

Jonathan Brizio — Fri, 15 Nov 2019 02:25:14 +0000

In these last months, I learn a lot about this great tool that allows me to speed up and optimize my workflow reducing time on repetitive tasks.

If you're new with this tool, I recommend it before to read the entire documentation to look at the features and practice with some real cases.

👉 Setting environment variables automatically

So, let's start with my favorite trick. This is a script to be executed each time that copies the result of the petition and saves it into environment variables. This is great when you need to specify an authentication token that expires at a certain time.

var data = JSON.parse(responseBody);
pm.environment.set("Access-Token", data.access_token);

With that code, you're copying to your environment variable "Access-Token" the value obtained after executing the request. This script avoids copy and pastes values manually in your environment variables. In this way, you only need to invoke that variable to get the value in the authentication input or somewhere.

👉 Replicating an entire request

Another common trick is that it allows reproducing a request. Let's say we want to reproduce the same request when access to Coindesk to obtain the price of the bitcoin.

Open the browser development tools on Chrome. Then, go to the "Network Tab" and filter the requests desired. Right-click the one you are interested in, and select "Copy as cURL". Now we have the cURL, go back to Postman and click on the top-left of the screen the button "Import", and choose "Paste Raw Text" tab. Paste what you copied, and press Import. Now press "Send" and the request would be executed directly from your client.

💬 Sharing your knowledge

And you, what other trick knows with Postman? Post a comment below.

Real World Developer's Problems: API Versioning

Jonathan Brizio — Fri, 12 Apr 2019 19:13:23 +0000

The backend world is fascinating and full of new things to discover.
In the beginning, you can feel domed with all the information, so the best way to understand is used commons examples that apply these concepts.

When you're designing your backend, it is essential to have on mind some considerations. Think that your contract on the future would change and you need to maintain backward compatibility.

In some moment you API would be evolving, and you need to support the features they provide. Managing the impact of this can be quite a challenge when it threatens to break existing client integrations.

REST doesn’t specify any method of versioning, but the more common approaches are:

Specify the version putting it on the URI:
https://api.example.com/v1/
Using a custom request header:
Accept-version: v1
Alternatively, adding to the HTTP Accept header
Accept: application/json; version=1

With these approaches, your challenge would be managing the entire code base with multiple versions of your resources. Content negotiation may let you prevent modify your entire collection of URLs, but you still have to deal with the all complexity of serving different versions of content.

Another approach can be to develop a consumer-driven contract that allows to consumer declare the data they are interested in consuming as part of a request. On this last case, you're delegating the responsibility to the client.

Whatever approach you take, need to be consistent and active governance over the evolving contract.

Comment here what another approach you recommend or know it to recommend us.

Building My First Alexa Skill with Node.js

Jonathan Brizio — Sun, 07 Apr 2019 18:35:29 +0000

Requirements

Amazon Developer Account
Experience with Node.js

What's Alexa?

This is Amazon’s voice-control system. With that, you can control music, create shopping lists or reminders, get instant weather reports, and control popular smart-home products using nothing else that the sound of your voice.

What's an Alexa skill?

These are apps that give to Alexa devices more abilities that the mentioned before. Absolutely of all kinds. Through the Alexa application, you can incorporate or disable these skills.

What's AWS Lambda?

AWS Lambda is a compute service that lets you run code without provisioning or managing servers. You pay only for the compute time you consume - there is no charge when your code is not running. This would be our backend that processes the request and returns the data back as a JSON.

Entities involved in the flow

The user who speaks a command
The Echo device, which receives the initial voice input
The Amazon Alexa service, which receives the data from the devices
The backend service which contains the business logic for the skill itself

Well, now that you have all the material needed to start with the development, I invite you to install my latest skill called "Dollar Price". That was an experiment with a public API to obtain the official price of exchange between the dollar and Argentine peso.