DEV Community: FeliDrummond

AWS Lambda e API Gateway

FeliDrummond — Mon, 13 Apr 2026 21:53:26 +0000

In this post, I will show you a tutorial on how you can easily combine these two services to build various applications.

I’ll present to you an initial project I built—very simple—just to explore the AWS console, understand the services, and see how we can use them together to build APIs easily.

The project is a serverless API using AWS Lambda and API Gateway, capable of receiving HTTP requests and processing different types of tasks based on JSON payloads.

At the end, I will answer the following question: What are the advantages of building serverless applications using AWS Lambda and API Gateway?

We will divide the process into phases, and each phase may have subphases:

Phase 1 – Create the Lambda function
Phase 2 – Test the function
Phase 3 – Create the API Gateway and connect it to Lambda
Phase 4 – Test the integration
Phase 1 – Create the Lambda Function

To start this phase, we define a permission policy.

1.1 Permission Policy:
This policy will grant your function permission to access the necessary AWS resources. In my project, since it is very basic, I used a default policy provided by AWS: AWSLambdaBasicExecutionRole. It grants the minimum essential permissions for a Lambda function to run and write logs to Amazon CloudWatch Logs.

1.2 Execution Role:
Here, you will create an execution role. In this role, you attach the permission policy created earlier and specify the service to which you want to grant these permissions.
This is where you associate the policy with the service.

1.3 Finally, Create the Lambda Function:

import json

def lambda_handler(event, context):
body = json.loads(event.get("body", "{}"))

tarefa = body.get("tarefa", "none")
mensagem = body.get("mensagem", "")

if tarefa == "log":
    resposta = f"Log received: {mensagem}"

elif tarefa == "processar":
    resposta = "Processing data..."

else:
    resposta = "Task not recognized"

return {
    "statusCode": 200,
    "body": resposta
}

My function acts as a simple “router” that decides what to do based on the data it receives (the event parameter).

Data extraction: It looks inside the event (a Python dictionary) for the keys "tarefa" and "mensagem". If not found, it uses "none" and an empty string as default values.
Decision logic:
If the task is "log", it returns a confirmation message.
If it is "processar", it returns a fixed processing message.
Otherwise, it informs that the task was not recognized.
Standard response: It always returns a dictionary with statusCode: 200 (HTTP success) and the response text in the body.

In summary: it is a mini task router that responds differently depending on the command sent in the input JSON.

Phase 2 – Test the Function

Create a new test and send a JSON in the expected format. In my case:

{
"tarefa": "log",
"mensagem": "Final test"
}

Note: The function looks for "tarefa" and "mensagem" inside the event. If not found, it uses default values.

Phase 3 – Create the API Gateway

Here, we will create a public URL that acts as the trigger for our Lambda function.

3.1 Create API
When creating an API in API Gateway, you will see options such as:

REST API
WebSocket API
HTTP API
REST API Private

I built an HTTP API, which is a more modern, faster, and cheaper option compared to REST API.

3.2 Configure API
After choosing, define the name and integrations. I added my Lambda function.

3.3 Configure Routes
Routes consist of an HTTP method and a resource path (e.g., GET /pets). You can define methods like GET, POST, PUT, PATCH, HEAD, OPTIONS, and DELETE.

3.4 Define Stages
Stages are environments where your API is deployed. You must deploy to a stage for changes to take effect, unless auto-deploy is enabled. By default, HTTP APIs have a $default stage with automatic deployment.

Summary of Phase 3:

Create the API
Configure it
Configure routes
Define the stage
Click “Create”

Phase 4 – Testing the Integration between API Gateway and Lambda

Now, what you need to do is send requests to the created routes and check if the response is as expected. Remember, the requests are the trigger of the Lambda function, so when you send a request, it should invoke the function and return the result to us.

For this test, we can use curl and/or Postman. I tested with both—it’s the best way to make sure everything is working correctly.

Note:

Curl:

URL of your API
-H (header)
-d (body)

My example:

curl -X POST https://k07qfvf9ye.execute-api.sa-east-1.amazonaws.com/dev/executar-tarefas \
-H "Content-Type: application/json" \
-d "{\"tarefa\":\"log\",\"mensagem\":\"Final test\"}"

Expected result:
Log received: Final test

If it returns the expected result, congratulations—you have successfully completed your application.

Answering the initial question:
What is the advantage of building serverless applications with AWS Lambda and API Gateway?

The term “serverless” means that your code runs on servers, but you do not need to provision or manage these servers. With serverless computing, you can focus more on building and innovating new products and features instead of maintaining servers.

Another benefit of serverless computing is the ability to automatically scale applications. It adjusts the application’s capacity by modifying units of consumption, such as throughput and memory.

Let’s make the real advantages of serverless computing with AWS Lambda and API Gateway very clear:

1. Real Cost Savings (Pay-as-you-go)

Zero Cost When Idle: Unlike a server running 24/7, you only pay when someone uses your API. If no one uses it, you pay nothing.

Granular Billing: AWS Lambda charges per millisecond of execution and based on the amount of memory used.

Low-cost API Gateway: Amazon API Gateway offers competitive pricing, charging only for the number of requests received.

2. Infinite and Automatic Scalability

No Management: You don’t need to configure Auto Scaling Groups or Load Balancers manually.

Traffic Spikes: If your application goes viral, AWS instantly provisions thousands of Lambda executions to handle the demand and then scales everything back down automatically.

3. Reduced Complexity (Focus on Code)

Zero Maintenance: No need to worry about OS updates, kernel patches, or hardware issues.

Built-in Security: API Gateway handles complex tasks like DDoS protection, authentication (e.g., Cognito), access control, and SSL/TLS encryption natively.

4. Development Agility

Fast Deployment: You can deploy a new version of your business logic in seconds by simply uploading your code.

Modular Architecture: It makes it easier to build microservices, where each Lambda function solves a small, isolated problem, making the system easier to maintain.

And as shown above, AWS Lambda and API Gateway are easy to use, so you can quickly deploy your code. In summary, what we did was basically:

1 - Upload the code to Lambda and test it (Phase 1 and 2)
2 - Configure a trigger, meaning an event that will start the execution of your Lambda function (Phase 3), and test the integration of the services (Phase 4)
3 - The code runs only when the trigger is detected
4 - Pay only for the compute time you use

Finally, I swear I won't say anything more after this, I'll leave you with some examples of real-world uses of lambda to help you understand in which situations it's welcome and how it makes our lives easier.

Real-time image processing for a social media application
A social media company uses Lambda to process images uploaded by users. When a photo is uploaded, Lambda is triggered to resize the image, apply filters, and save it in an optimized format to storage. This event-driven, serverless approach makes sure that the application can handle high volumes of uploads without needing to manage infrastructure.

Why Lambda: It automatically scales based on uploads and charges only for the time spent processing each image.

Personalized content delivery for a news aggregator
A news aggregator uses Lambda to fetch and process news articles from multiple sources, then it tailors recommendations based on user preferences. When a user opens the application or performs a search, Lambda functions are triggered to retrieve data, run personalization logic, and return relevant content.

Why Lambda: It automatically scales with user traffic and reduces costs by running code only when users interact.

Real-time event handling for an online game
A gaming company uses Lambda to handle in-game events like player actions, game state changes, and real-time leader board updates. Each event (like scoring a point or unlocking an achievement) triggers a Lambda function that updates player data and game status.

Why Lambda: It handles thousands of events, in real-time, with no need to manage servers. Costs scale with usage, which is ideal for peak gaming times.

Thank you for your attention, and I hope I was able to help!

Network and Tracert

FeliDrummond — Wed, 08 Apr 2026 23:26:14 +0000

These days, I’m reading somethings about network. I started playing with the command *Tracert *(in Linux, Traceroute) in the CMD. I’ve figured out some things and I’m learning more about network.

So today, I’m going to talk about network, specifically the command Tracert. We will make an analysis based on two examples.

First, let’s understand what the Tracert command does:
It traces the path that a data packet takes from your computer to a specific destination on the network or the internet.
Example: Open your CMD and type: tracert 8.8.8.8
This route will take you to 8.8.8.8 (dns.google).

Second, let’s understand how Tracert works:

It identifies the “hops”: it lists each router or intermediate server that the information passes through until it reaches the final destination.

For each hop, the command performs three tests and shows the response time in milliseconds (ms). This helps identify points of slowness in the connection.

If the connection drops at some point, Tracert will show where the signal stopped (usually displaying asterisks *), allowing you to know whether the problem is in your internal network, your ISP, or the destination server.

Now try: tracert amazon.com
Compare it with the previous result.

When I made this comparison, I noticed a big difference in the number of hops and latency. While for Google the latency ranged from 6 ms to 51 ms, for Amazon, starting from hop 7, the latency increased to 140 ms, 168 ms, and 185 ms. For Google, there were only 9 hops, while for Amazon there were 30, which is the maximum number of hops that Tracert shows.

I also paid attention to the change in IP addresses.
In the Amazon route, I reached the following IP address at hop 6: 213.140.39.8. After this hop, the latency changed drastically, going from
15 ms, 12 ms, 18 ms to 140 ms, 168 ms, 185 ms.

In addition, there was a network change, and the ranges 213.140.39.8 (hop 6) and 94.142.98.43 (hop 7) are not common in Brazil.

This high variation in latency and this change to those IP addresses is already enough to indicate that the traffic is going through an international route (backbones).

If you want to confirm who owns the IP, use the WHOIS command (Linux), which allows you to see the owner of the address, or access the website who.is and enter the IP address.

Another thing that caught my attention is that from hop 9 onwards, several * appeared in the latency tests and the IP addresses stopped being shown. After researching, I understood that this was not a failure, but rather that Amazon blocks Tracert responses, probably for security reasons.

Some conclusions we can draw from this comparison are:

On the route to Google, we have a more direct connection between my ISP and Google, going from the address 152-255-190-66.user.vivozap.com.br at hop 5 to the address 72.14.243.38 (Google) at hop 6. We are accessing Google through an edge location.

On the route to Amazon, we go through an international route, with higher latency, and the destination blocks ICMP.

From this, we can see that Google services often use local edge infrastructure, while some AWS endpoints follow international routes.

You might be wondering why it is important to know the route to a destination and the latency to each router.

I’ll explain: understanding the Tracert command, routes, latencies, and IPs helps you understand how the internet really works. You don’t connect directly to Google — you go through multiple routers before reaching it.

By understanding this, you become able to identify bottlenecks, network failures, and locate where the slowdown is happening. For example, if you notice high latency in the first hops, it may indicate a problem inside your home network or with your ISP. If everything is fine at the beginning and latency spikes near the final destination, it may be a problem with the server or the cloud infrastructure.

This way, you start to better understand the “behind the scenes” of the internet and, over time, become more capable of diagnosing and solving network-related problems.

I wanted to share some of the knowledge I’ve gained, and I hope it can help someone. I love studying network and understanding how the “fuel” of our modern world (the internet) works.

Please don’t hesitate to comment, ask questions, or give feedback. We are here to exchange ideas and knowledge.

Thank you, and see you next time!

AWS Cloud Praticttioner #02

FeliDrummond — Thu, 19 Mar 2026 22:07:06 +0000

Hello guys, continuing our AWS Cloud Practitioner series, today we are going to study a specific case and explain how we can solve it using AWS resources.

According to the following case:
A software development company needs to notify the engineering team whenever a new bug is reported in their bug tracking system. Some team members need to be notified immediately, while others can process the bug reports later.

How can this be solved in AWS Cloud?

Simple: you can use Amazon SNS. With Amazon SNS, it is possible to subscribe different endpoints to SNS topics and ensure that the right people or services receive information in real time.

What is an example of a service that can receive information from an SNS topic?

One example is Amazon SQS queues. SQS is a message queue service that allows systems to communicate in a decoupled way by storing messages in a queue until they are processed.

SQS queues can be configured as standard queues or First-In-First-Out (FIFO) queues. For example, you can create:

Queue 1 (SQS) → sends email
Queue 2 (SQS) → saves data to a database
Queue 3 (SQS) → sends data to analytics

And then subscribe each of these three queues to an SNS topic called "New user registered".

Every time a message is published to this topic, all three subscribed queues will receive the information and execute their specific tasks at the same time, in a decoupled way. If one queue fails to process the message, it will not affect the others.

This way, actions like sending emails, saving data to a database, and sending analytics events are triggered automatically at the right time.

Thank you everyone for more one day with me!

My roadmap (2025 - 2027)

FeliDrummond — Wed, 18 Mar 2026 23:07:20 +0000

Well, I’m here to say that I’m following the same journey as @maame-codes. I’m also a “Class of '27” student (thank you Maame for encouraging me to share my Infrastructure journey). So my roadmap is very similar to hers, with some differences in the order of execution and in the posting format. For each topic, I’m going to start a new series.

So if my roadmap includes Linux Foundation, Cloud Infrastructure, and Networking and Protocols, then each one of these topics will have its own series.

For example, I’ve already started the Cloud Infrastructure series (link of this series: https://dev.to/fedrummond_/aws-cloud-praticttioner-01-3iae), which is about my journey to get the Cloud Practitioner certification. For the Networking and Protocols topic, for example, there will be a series like: “Networks: Networking and Protocols #01” and so on.

My Roadmap (2025 - 2027):

Linux Fundamentals - Becoming comfortable with the command line

Networking and Protocols - Understanding how the internet actually works behind the scenes.

Bash & Scripting - Making the terminal work for me

Containerization - Building, isolating, and running applications anywhere.

Cloud Infrastructure - Learning how to build and scale systems in the cloud.

CI/CD - Integrating, testing, and delivering code continuously

If you feel comfortable studying with me, you will be very welcome.
Come on to the Class of 27 with me.
Thank you everyone!

AWS Cloud Praticttioner #01

FeliDrummond — Mon, 16 Mar 2026 21:47:48 +0000

Well, when I decided to focus my career in the area of DevOps, I searched for a roadmap, a DevOps roadmap. Generally, the roadmap showed me that it is important to understand the following topics:

Programming Languages - Python | Go
Operating System - Linux
Networking and protocols
Docker
Git | GitHub
AWS
Terraform
Ansible
GitHub Actions

So, I decided to work on projects and get some certifications. One of the certifications I decided to focus on is the AWS Cloud Practitioner.

So I will post here a new AWS series that can help you and me understand better everything about cloud computing and specifically AWS Cloud.

My language here is very informal, and I don't know how to write very well in English, so there will be some grammar mistakes.

What is Cloud computing?
Cloud computing is essentialy the on-demand delivery of TI resources over the internet with pay-as-you-go pricing. You can access only the capacity and resources that you need.

Which are the benefits of the Cloud?

1. Global reach in minutes –
The global presence of AWS Cloud, with data centers in many parts of the world, allows you to deploy applications to customers around the world quickly while also providing low latency and enhances fault tolerance

2. Trade upfront expenses for variable expenses –
You don’t need to spend a fortune to build a data center. With AWS, you can start a resource and only pay for what you use and for the time you use it.

3. Benefit from economies of scale –
This topic explains how cloud computing can offer lower variable costs than if you managed the infrastructure on your own, such as physical servers or internal data centers. Let’s understand this in more detail:

Variable Costs
Variable costs are those that change according to the usage or the amount of resources consumed.
Economies of Scale in the Cloud
Economies of scale occur when the cost per unit of production (or usage) decreases as the quantity produced (or consumed) increases.

When you use the cloud, you are sharing resources with other users. This means that large cloud companies, such as AWS (Amazon Web Services), serve millions of customers simultaneously. Because of this, they can aggregate large volumes of usage and reduce the unit costs of operation.

How does this affect prices? Since cloud providers like AWS have this large customer base and can aggregate the demand of many users, they are able to purchase hardware and technology at a larger scale and operate more efficiently. This allows them to reduce maintenance and infrastructure costs.

As a result, pay-as-you-go prices — meaning the prices you pay for computing, storage, etc., based on how much you use — end up being lower compared to what you would have to pay if you were operating your own infrastructure.

4. Stop guessing capacity -
With cloud computing, you don’t have to predict how much infrastructure capacity you will need before deploying an application.

For example, you can launch Amazon EC2 instances when needed, and pay only for the compute time you use. Instead of paying for unused resources or having to deal with limited capacity, you can access only the capacity that you need. You can also scale in or scale out in response to demand.

_5. Stop spending money to run and maintain data centers - _
The AWS Cloud eliminates the need for businesses to invest in physical data centers. This means customers aren't required to spend time and money on utilities and ongoing maintenance. With AWS taking care of the physical infrastructure of the cloud, customer resources can be reallocated to more strategic initiatives.

6. Increase speed and agility. -
With the cloud, businesses can rapidly deploy applications and services, accelerating time to market and facilitating quicker responses to changing business needs and market conditions.

Define the AWS global infrastructure.

Define AWS Regions and Availability Zones.

A Region is a geographic area that contains AWS resources.

An Availability Zone is a single data center or a group of data centers within a Region. Availability Zones are located tens of miles apart from each other. This is close enough to have low latency (the time between when content requested and received) between Availability Zones. However, if a disaster occurs in one part of the Region, they are distant enough to reduce the chance that multiple Availability Zones are affected.

Each AWS Region consists of multiple Availability Zones that are isolated and physically separated from a geographic region.

Explain the benefits of high availability and fault tolerance.
With the concepts discussed above, we can understand the concepts of high availability and fault tolerance and explain their benefits. We already talked about how, if a disaster occurs in one part of the Region, you can failover to the other part. This is called High Availability. Because you ensure that if one zone fails, you won't lose your server and the jobs that are running, since there's another zone functioning.

We've already talked about AWS's Global Reach in Minutes. By having redundant systems in various locations, global infrastructure enhances Fault Tolerance

That’s it, guys. Today we saw 3 topics: Concepts of Cloud Computing, Benefits of the Cloud, and AWS Global Infrastructure (as part of the infrastructure, we haven't talked about edge locations yet).

If you have any questions or comments, please feel free to comment.

Thank you, everyone, and see you in the next post!

GitHub Copilot CLI Challenge: Music Idea Genarator

FeliDrummond — Wed, 11 Feb 2026 18:50:00 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

The Music Idea Genarator is a simple Python CLI tool that generates music ideas such as moods, themes, chord progressions, and song structures. This project was built as part of the GitHub Copilot CLI Challenge, using GitHub Copilot directly in the terminal to design and implement the application.

In this project, I combined two passions: music and technology. I built this project to help me compose new songs in a simple and quick way. The project doesn't give you a song, but rather themes, chords, structure, and vibes that you can use as a starting point for inspiration and creation.

Demo

Access my repository on GitHub and follow the Readme to better understand how it works. GitHub: https://github.com/Feli021/Music-Idea-Genarator

Once you've cloned the repository and created and activated the virtual environment, the commands are very simple:

In the terminal, just type 'python main.py' followed or not by what you already have. For example, you might have a sequence of chords in C major and want the program to suggest the rest, such as the song's theme, vibe, and structure.

My Experience with GitHub Copilot CLI

For my first time using the tool, I used it in a very simple way, only assisting me with the structuring of folders and with generating the contents of the data.py file (the file where the lists and dictionaries with the Moods, themes, chords, and structure options are located).

From the terminal, using natural language, I explained the project and directly asked it to help me with the points mentioned above. For example, in the data.py file, I asked it to fill in the themes and chords for each mood, freeing me from a very manual process of creating themes and chords for each mood.

What can I expand and/or improve in this project?
We can expand and improve this project in many ways, from increasing the options for Moods (melancholic, depressive, agitated, etc.), Chords (such as major, minor, seventh chords, etc.) and themes for each mood, to including GitHub Copilot more explicitly in the project, allowing you to generate suggestions from natural language using the GitHub Copilot CLI, unlike the current version where you generate them from terminal commands like "python main.py --mood happy".

Searcher of lyrics's musics

FeliDrummond — Tue, 03 Feb 2026 21:36:23 +0000

This application was developed to search for song lyrics based on the band/artist name and the song title.

The graphical interface was built using Streamlit, while HTTP requests to the external API are handled with the requests library.

Technologies used

Python
Streamlit
Requests
API Lyrics.ovh

How it works? And How to Run the Projec?
See the readme file in my repository on GitHub.
GitHub Repository: Searcher of lyrics musics

Screenshots of the functionality:
1 - Home Screen:

2 - Write the band name and the song title:

3 - Click on Search and wait for the response. If the lyrics are found, they will appear below.

4 - If the lyrics is not found, a message will appear informing you:

What I learned with this project:
I learned a lot while building this project. I got a much better understanding of how APIs and HTTP requests actually work, seeing how the communication happens between my app and an external service. I also figured out how to handle different status codes and implement user-friendly error messages when a letter is not found.
Another cool thing was learning about URL encoding and why it’s important when you’re working with names that have spaces, accents, or special characters. On top of that, I explored Streamlit and realized how fast and simple it is to create a clean interface without needing heavy frameworks.
Overall, this project helped me improve my coding style, keep things organized, and connect different tools together in a way that actually works for the user

What is a API?

FeliDrummond — Thu, 29 Jan 2026 20:17:22 +0000

Yesterday I was studying APIs, and I learned that an API connects the backend—where the data is stored—to the client, which is making the request.

When a request reaches the API (for example, when you type the URL of a website you want to access), the API receives it and sends it to the backend. The backend then returns the requested information to the API, and the API sends that information back to the client.

Concepts #API

Introducción a Linux

FeliDrummond — Mon, 26 Jan 2026 23:20:42 +0000

Voy a empezar a publicar todo lo que estoy aprendiendo con el curso “Introduction to Linux” de The Linux Foundation.
Nunca he publicado nada aquí, pero vi una publicación de @maame-codes que me motivó a usar este espacio para compartir mis estudios.