logo
Menu
Implementing an Hexagonal Architecture for serverless apps in less than 10 minutes

Implementing an Hexagonal Architecture for serverless apps in less than 10 minutes

In this article, we're diving deep into how hexagonal architecture can transform your AWS serverless applications. We'll explore the core concepts, uncover the benefits, and walk through a practical example that shows hexagonal architecture in action.

Published Feb 14, 2024
Welcome to the world where serverless architecture meets hexagonal bliss. When we talk about serverless applications we are all aware of its benefits: no server management, cost-efficiency, and scalability that seems almost magical. But even in this wonderland, how do we ensure our applications are not just scalable but also resilient and maintainable? Enter hexagonal architecture, our knight in shining armor.
Hexagonal architecture, also known as the ports and adapters pattern, is not just another buzzword to toss around in tech meetings. It's a strategic approach to application design that fundamentally changes how we build, test, and think about our applications. By emphasizing the separation of concerns, it ensures that our business logic remains untouched by external changes, making our applications as resilient as they are scalable.
In this article, we're diving deep into how hexagonal architecture can transform your AWS serverless applications. We'll explore the core concepts, uncover the benefits, and walk through a practical example that shows hexagonal architecture in action. So grab your favorite Python IDE, I used Visual code 🙂, and let's get started on a journey to serverless application bliss.

Understanding Hexagonal Architecture

If you’ve ever found yourself lost in the spaghetti of code that merges business logic with user interface and database access, you’re not alone. This is the very maze that hexagonal architecture aims to navigate us out of. But what exactly is this architecture, and why does it sound like it belongs more in a geometry class than in application development?

What is Hexagonal Architecture?

At its core, hexagonal architecture is a pattern that promotes the separation of the core logic of an application from its external interactions. Think of your application as the center of a hexagon. Each side of the hexagon represents a port that interacts with the outside world through an adapter. These ports could be for a web interface, a database, or even a test script. The beauty of this design is that it allows changes to be made to any external component like swapping out a database or changing the user interface without having to rewrite the business logic.
Hexagonal Architecture
Hexagonal Architecture

Core Principles

  • Separation of Concerns: By keeping the application's core logic isolated, developers can focus on business rules without getting entangled in external dependencies. (Domain part in the image above)
  • Interchangeability: Adapters make it easy to change how the application interacts with the outside world, facilitating testing and evolution. (Adapters part in the image above)
  • Simplicity: Despite the complex-sounding name, hexagonal architecture simplifies application development and maintenance by clearly delineating responsibilities.

How It Differs

Traditional architectures, like the layered or monolithic models, often merge business logic with data access and presentation layers, making it challenging to modify or scale one aspect without affecting others. Hexagonal architecture, on the other hand, treats these interactions as plug-and play components that can be easily replaced or updated without disrupting the core functionality.

Benefits of Using Hexagonal Architecture for Application Development

  • Enhanced Testability: With business logic decoupled from external components, testing becomes a breeze. You can use mock adapters for your ports, allowing for comprehensive and isolated unit tests.
  • Flexibility in Development and Deployment: Want to shift from a monolithic database to microservices? Or perhaps switch your user interface from a web to a mobile platform? Hexagonal architecture makes these transitions smoother, without the need to overhaul your application's core.
  • Easier Maintenance and Scalability: As your application grows, maintaining a clean separation between the core logic and external interfaces means you can scale or update parts of your system independently. This architectural style naturally leads to more maintainable and scalable applications.
In essence, hexagonal architecture isn’t just about keeping your codebase neat and tidy; it’s a strategic approach to building software that’s ready to evolve with your needs. By adopting this pattern, developers can ensure their applications are robust, adaptable, and future-proof, no matter how the technological landscape changes.

Why Hexagonal Architecture Rocks for Serverless

Serverless computing has been a game-changer for developers and businesses alike, offering the ability to build and deploy applications without the hassle of managing servers. AWS, with its comprehensive suite of serverless services, has been at the forefront of this revolution. But with great power comes great responsibility—the responsibility to design applications that are not only scalable but also resilient and easy to maintain. This is where hexagonal architecture shines.

Perfect Alignment with Serverless Principles

Serverless architecture promotes the idea of building applications as a collection of functions that respond to events. This model naturally complements the hexagonal architecture's emphasis on separation of concerns and adaptability:
  • Decoupling: Just as serverless functions are decoupled from the underlying infrastructure, hexagonal architecture decouples application logic from its external interactions. This synergy allows for more resilient and flexible applications that can easily adapt to changes in the environment or requirements.
  • Event-Driven: Serverless is inherently event-driven, and hexagonal architecture supports this by treating interactions with the outside world as events coming through ports. This makes it easier to design applications that react to a variety of triggers, from HTTP requests to database updates.

Enhanced Flexibility, Scalability, and Maintainability

  • Flexibility: Hexagonal architecture allows for easy swapping of external components and interfaces. In a serverless context, this means you can change your data storage from DynamoDB to another service, or modify your API Gateway setup, without rewriting your core business logic. This flexibility is invaluable in the fast-paced, ever-changing cloud ecosystem.
  • Scalability: Serverless architectures excel at scaling automatically in response to demand. Hexagonal architecture complements this by ensuring that your application's core logic remains isolated and unaffected by scaling operations. This isolation means that as AWS scales your functions up or down, the integrity of your application logic remains intact, free from the scalability complexities of the infrastructure.
  • Maintainability: The clear boundaries established by hexagonal architecture make serverless applications easier to maintain and update. Since the business logic is decoupled from external interfaces, updates or fixes can often be applied to adapters without impacting the core application. This separation simplifies maintenance tasks and reduces the risk of introducing errors into the core logic during updates.

A Gateway to Innovation

Adopting hexagonal architecture in serverless applications not only addresses current design and scalability challenges but also opens the door to future innovation. It enables teams to experiment with new AWS services or third-party integrations with minimal risk to the existing application. Whether it's integrating a new notification service or experimenting with different database technologies, hexagonal architecture ensures that your serverless application remains robust and adaptable.
In summary, hexagonal architecture and serverless computing are a powerful duo. Together, they provide a framework for building applications that are not just scalable and cost-effective but also resilient, adaptable, and easy to maintain.

Implementing Hexagonal Architecture in AWS Serverless with Python

When you first hear "Hexagonal Architecture" in the context of AWS serverless and Python, it might sound like we're about to perform some arcane ritual. But, in reality, it's more like organizing your digital LEGO blocks in a way that makes them easier to play with, swap out, and test without stepping on them in the middle of the night.
Before we get our hands dirty, let's lay out our tools. Services like Lambda for running code without provisioning servers, Amazon API Gateway for handling HTTP requests, and Amazon DynamoDB for a fully managed NoSQL database. These are our building blocks, the stars of our show, and they're going to play major roles as "ports" in our hexagonal world.

Structuring Your Application

The essence of Hexagonal Architecture is breaking down your application into a clear separation of concerns. You've got your core application logic, the heart and soul of your operation. This is where your business logic lives, written in Python, making decisions, processing data, and generally being smart. It's your application's saved from the chaos of the outside world.
Then, surrounding this core, we have ports and adapters. Ports are the predefined spots in your application where external services (like databases, message queues, or email services) can connect. Adapters are the translators, written in Python, that convert the external calls to the format your core logic understands and vice versa.

A Simple Example

Imagine we're building a system to handle user sign-ups for a new service. Our core logic includes functions to validate user data, create new user records, and send out welcome emails. Here's how we can organize this with Hexagonal Architecture:
  • Core Domain (Application Logic): A Python function 'register_user' that takes user data, validates it, and if everything checks out, prepares it for storage and notification sending.
  • Port for User Storage: We decide DynamoDB is our storage solution. The port here is the abstracted action of saving a user.
  • Adapter for DynamoDB: A Python function that takes the user data from the core logic and knows how to insert it into DynamoDB. This adapter speaks both Python (our application's language) and DynamoDB's API calls.
  • Port for Sending Emails: Another port is defined for sending out welcome emails to new users.
  • Adapter for AWS SES (Simple Email Service): A Python function that takes the instruction to send a welcome email and translates it into an API call to SES, filling in the email content, recipient, and other details.
Hexagonal Simple Example
Hexagonal Simple Example
This structure allows our core application logic to remain unaware of which database or email service we're using. If we decide to switch from DynamoDB to another database, we only need to replace the adapter, not rewrite the core logic.

How?

Let's break down the simple example of implementing Hexagonal Architecture in an AWS Serverless application with Python into a step-by-step guide.

Step 1: Set Up Your AWS Environment

  • Create a DynamoDB Table: Log into your AWS Management Console, navigate to the DynamoDB service, and create a new table named 'Users'. For the primary key, use 'userId' of type String.
  • Set Up AWS SES: Ensure that AWS SES is set up and verified in your AWS account. You'll need a verified email address from which to send welcome emails to new users.

Step 2: Define Your Core Application Logic

  • Create a Python Function for User Registration: This function ('register_user') will take user data (e.g., name, email), validate it, and if valid, proceed to save the user and send a welcome email.
1
2
3
4
5
def register_user(user_data):
user_data = event
user_id = save_user(user_data) # This will be implemented in an adapter
send_welcome_email(user_data['email']) # Also to be implemented in an adapter
return user_id

Step 3: Implement Adapters

  • DynamoDB Adapter for User Storage:
1
2
3
4
5
6
7
def save_user(user_data):
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Users')
user_id = str(uuid.uuid4())
user_data['userId'] = user_id
table.put_item(Item=user_data)
return user_id
  • SES Adapter for Sending Emails:
1
2
3
4
5
6
7
8
9
10
11
12
def send_welcome_email(email):
ses = boto3.client('ses')
ses.send_email(
Source='your_verified_email@domain.com',
Destination={'ToAddresses': [email]},
Message={
'Subject': {'Data': 'Welcome to Our Service!'},
'Body': {
'Text': {'Data': 'Thanks for signing up! We’re thrilled to have you on board.'}
}
}
)

Step 4: Create AWS Lambda Functions

  • Lambda for User Registration: Set up a new AWS Lambda function that uses the Python runtime. Use the code you've prepared for 'register_user', including the adapters. This function will be triggered by an API Gateway event or directly through the AWS console for testing purposes.

Step 5: Test Your Setup

  • Unit Testing: Write unit tests for your 'register_user' function by mocking the 'save_user' and 'send_welcome_email' functions. This ensures your core logic works as expected without needing to actually interact with DynamoDB or SES.
  • Integration Testing: Test the entire flow by invoking your Lambda function with a sample user data payload. Verify that the data is saved in DynamoDB and that a welcome email is sent.

Step 6: Deploy and Monitor

  • Deploy: Once testing is satisfactory, deploy your Lambda function and expose it via API Gateway if you want to trigger user registration through HTTP requests.
  • Monitor: Use AWS CloudWatch to monitor the logs for your Lambda function to ensure everything is running smoothly.

Wrapping Up

Congratulations! 🎉 You've now implemented a simple user registration system using Hexagonal Architecture in AWS Serverless with Python. This architecture makes your application more resilient and adaptable, allowing you to replace components easily without affecting the core logic. 
Remember, the keys to success with Hexagonal Architecture are clear separation of concerns and the proper use of adapters to communicate with external services. Happy coding!
 

Comments