DEV Community: Mohamed Sweelam

A Thoughtful Approach to Databases in Cloud-Native Architectures

Mohamed Sweelam — Sat, 25 Jan 2025 18:15:43 +0000

Many engineers still confuse Single-Tenant Databases with Multi-Tenant Databases when discussing cloud-native systems like Microservices. They often think of a database as just a container they can request on-demand, forgetting that a database is a valuable asset that requires proper care—especially while keeping costs manageable. In this short article, I will tell you, how you should take care of your lovely database.

It is all about Performance

Youssif is a skilled software engineer who designs systems capable of supporting operations for many years. One day, he was discussing with his friend Alex the database design they needed to consider for a new system expected to scale rapidly.

Alex said, "We are building cloud-native systems, so we must follow the database-per-service pattern to avoid the known issues associated with shared databases in microservices."

Youssif replied, "That's a good idea. What do you think, Alex? What should we ask the DevOps team to prepare for us?"

Alex said, "Since we're using AWS, we should request multiple RDS instances. Let’s start with the initial design and provision nine RDS instances to serve nine microservices applications."

Youssif said, "I don't think that's the right approach. We should first talk to the team to understand more about the system's qualities and the performance they expect. If their operations aren't too demanding and they’re constrained by budget, I’d prefer starting with a single RDS instance but using multiple databases or schemas. What do you think?"

Alex: "That's a good idea!"

Various Methods for Constructing the Pattern

Thinking about design patterns is like teaching a student. You want to help them learn something from a book, but every teacher has their own unique way of teaching. In the end, all of them ensure that the student understands the concept presented in the book.

The High-Level Design (HLD) shown above represents the initial architecture for a ride-sharing application similar to Uber. The team decided to use an Oracle database for their needs, for whatever reason. Given that Oracle licensing costs are significantly high, does it make sense to ask the DevOps team to provision multiple Oracle servers for the application? No

But they need to build a feature to manage organization offers—something resembling multi-tenancy. Did you forget the pattern? No, I didn’t. But did you forget the teacher example I shared with you?

Of course, they can provide multi-tenant support without violating the pattern by leveraging Oracle's multi-database features. This approach offers several benefits:

Resource Optimization: Requires fewer hardware and infrastructure resources.
Cost Efficiency: Significantly reduces Oracle licensing and operational costs.
Improved Code Design: Encourages cleaner and more maintainable architecture.

All they need is to make every microservice accessing specific database. The setup might look something like this:

Microservice 1 → Database 1
Microservice 2 → Database 2
Microservice 3 → Database 3
...
Microservice N → Database N

They can also manage database creation dynamically with something like this:

CREATE TABLE tenants (
    tenant_id VARCHAR(50) PRIMARY KEY,
    db_url VARCHAR(255),
    db_username VARCHAR(50),
    db_password VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

And a nice dynamic code that manages tenants over DB

public class TenantService {

    private final JdbcTemplate adminJdbcTemplate;

    public TenantService(JdbcTemplate adminJdbcTemplate) {
        this.adminJdbcTemplate = adminJdbcTemplate;
    }

    public void createTenant(String tenantId) {
        String dbName = "tenant_" + tenantId;

        // Step 1: Create Database
        adminJdbcTemplate.execute("CREATE DATABASE " + dbName);

        // Step 2: Initialize Schema
        JdbcTemplate tenantJdbcTemplate = new JdbcTemplate(
            DataSourceBuilder.create()
                .url("jdbc:mysql://localhost/" + dbName)
                .username("root")
                .password("password")
                .build()
        );

        tenantJdbcTemplate.execute("CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(100), email VARCHAR(100));");

        // Step 3: Save Metadata to Admin DB
        adminJdbcTemplate.update(
            "INSERT INTO tenants (tenant_id, db_url, db_username, db_password) VALUES (?, ?, ?, ?)",
            tenantId, "jdbc:mysql://localhost/" + dbName, "root", "password"
        );
    }
}

Conclusion

Designing databases for cloud-native systems requires a careful balance between scalability, cost efficiency, and maintainability. While the database-per-service pattern is ideal for avoiding the pitfalls of shared databases in microservices, its implementation must consider the system’s performance requirements and budget constraints. Ultimately, the choice of database architecture should be guided by the system’s unique needs. By thoughtfully applying design patterns and leveraging features like dynamic provisioning, teams can build robust, scalable, and efficient cloud-native applications. Remember, the goal is not just to follow a pattern but to adapt it to ensure the system operates effectively within its constraints.

The Endless Journey: When Does Learning Really Stop?

Mohamed Sweelam — Thu, 18 Apr 2024 14:12:47 +0000

Know the Truth

The majority of industries are bustling with activity, but none are quite as frenetic as the software industry. This dynamic field is not only vast but constantly evolving, often introducing new developments even as we try to keep up with the existing ones.

Many engineers contemplate switching to other fields, sometimes even within the software industry itself, believing that a new field might offer greater comfort and better opportunities. However, they often overlook the harsh reality—a reality that weighs heavily on anyone who isn't careful.

It has always been acceptable to take a break, perhaps for a couple of years, especially if you enjoy routine work and are comfortable with it. However, in today's 'AI era', such complacency can be genuinely dangerous. You will face numerous doubts, fears, and anxieties; every day, you might hear about new developments in the field that could significantly impact you.

You aren't Alone

It can certainly feel overwhelming, given the ever-increasing amount of knowledge you need to acquire each day. However, remember, you are not alone in this journey. Try to see it from a different perspective: Why shouldn't we learn? What stops us? We are here to help and support each other, to uplift our communities. Isn't that truly exciting?

The great thing about this career is that it's genuinely exciting. It may feel frustrating when you can't get things right the first time, but the joy of finally succeeding is unmatched. You become the happiest person in the world, and you'll always cherish that triumphant moment when you can say, 'It works!'

Navigating Progress Together: Staying Updated

To stay updated, it’s crucial to understand how to collaborate and keep pace with others. Knowing where to go, how to stay informed, and finding answers to these essential questions are key components of maintaining relevance in your field.

I will try to help you with some tips and tricks that can enable you be always updated:

Book Rankings and Reviews
On platforms like Amazon, you can explore a wide selection of books, paying close attention to bestsellers and rankings. Book reviews are also invaluable, providing insights that can help you decide which book to purchase.
Utilizing GPTs
Today, tools like ChatGPT are reliable sources for obtaining trusted information. By upgrading to a GPT-4 account, you can use it not only to discover book recommendations but also to explore other essential resources, such as learning paths and course suggestions; by they way, the images attached in this article are all generated by AI.
Social Media Engagement
On Twitter, consider following engineers and company profiles from your industry of interest. These accounts often share updates about new developments and innovations, providing timely insights directly from the source.
Choosing Online Learning Platforms
The number of online learning platforms is rapidly increasing. It's advisable to focus on one or two platforms to avoid information overload. Conduct thorough research before making your choice. For instance, Coursera and LinkedIn Learning are excellent starting points for a wide range of educational content.

Balancing Learning and Well-being

While the pursuit of knowledge is commendable, overwhelming yourself with too many subjects simultaneously can be detrimental to your health. Implementing a strict scheduler can help you manage your learning pace effectively.

It’s great to stay informed about current trends, but remember, you don’t need to master every detail. Keeping yourself updated in a manageable way is the best approach in this fast-paced environment.

Conclusion

In conclusion, the journey through the software industry, or any field of rapid innovation such as the AI era, poses unique challenges and opportunities. The key to thriving is not just keeping pace with technological advancements but also managing our learning and well-being thoughtfully.

Embracing continuous learning, leveraging tools like GPT, engaging on social media, and selecting online platforms are all effective strategies to stay current and relevant. However, it is equally important to remember that we do not need to master every detail or chase every trend.

Setting realistic goals, using tools like scheduling for balance, and reminding ourselves that we are part of a supportive community can make this journey less overwhelming and more rewarding. Ultimately, the aim is not just to survive but to thrive, finding joy and satisfaction in our achievements and in the knowledge that we are moving forward together.

Beyond Code: Understanding the Value of Documentation

Mohamed Sweelam — Wed, 14 Jun 2023 02:43:20 +0000

Overview

Working as a software engineer in a team necessitates seamless collaboration, where teammates can easily find the information they need. To facilitate this, it is crucial to support your work with comprehensive documentation. This ensures that your teammates can readily access the required information in an effortless manner, fostering clear and efficient cooperation.

Use Case: Flight System

Assuming you are working with a team that is building distributed systems, specifically a microservices application. Let's consider an example of a flight system that consists of three microservices: customer-service, flight-service, and email-service. Additionally, the system includes various components such as databases, caching, and messaging.

Can you imagine? Of course, you can. However, in reality, imagination alone is not sufficient. It is crucial to have tangible resources at hand. That's why it is essential to prepare your first document called the 'High-Level Design' (HLD for short)

What did you feel after looking at the diagram? feeling better, no?

UML Diagrams

As a software engineer, you should be aware of UML digrams , you might be wondering, Isn't self-code doc enough? something like java-doc or maybe swagger! although it is perfectly fine to support your code with these docs, but it is not enough for your teammate to understand your "solution design".

Example

Assuming you have an API that's doing the actual flight booking.

The API is doing the followings:

validating the input
calling customer-service to get customer details
updating the database
send email via email-service

Now, the question is, How can your teammate know?

Your teammate, who is working with you on the same application, wants to utilize your code, potentially adding new features or integrating it. They need to review your solution design from a helicopter view before diving into the details and without having to contact you.

Here, the Sequence Diagram comes into play.

By providing a supporting diagram for your solution, you can greatly simplify your friend's understanding of the system. This approach ensures clarity for everyone, including new team members. Furthermore, when presenting your work to the team, you will be able to illustrate the solution efficiently, saving valuable time.

Conclusion

Documentation should be mandatory for any system you work on, rather than being optional. Treating documentation with the same level of importance as the code base is crucial. It allows for clear understanding, maintenance, and future development of the system. Moreover, it is essential to choose the appropriate location to store and maintain the documentation, ensuring easy accessibility for the entire team.