Microservices Full Course

🔷 What is Software Architecture?

Software architecture is the process of designing the overall structure of a software system.

It involves:

Breaking the system into smaller parts (components)
Deciding how these parts will talk to each other
Setting rules and guidelines for how the system is built and improved over time
Choosing the right tools, programming languages, and platforms
Planning how data moves through the system and how decisions are made
Making sure the system is fast, secure, reliable, and works well under pressure
Designing the system so it can grow easily in the future (scalability)
Helping everyone on the team understand how the system works
Preparing the system to handle problems or failures without crashing (fault tolerance)
Making the system easy to fix, update, or improve later (maintainability)
Reusing parts of the system in other projects to save time and effort
Making testing easier to ensure the system works correctly (quality assurance)

🔷 Why is Software Architecture Important?

Acts like a blueprint to guide how the system should be built
Helps manage complex systems by breaking them into smaller, organized parts
Improves communication between developers, designers, testers, and stakeholders
Supports scalability, so the system can handle more users or features in the future
Makes the system easier to maintain and extend with new features
Improves performance by designing systems that run efficiently
Lowers the risk of failure by identifying problems early in the design phase
Helps meet security, quality, and legal requirements

🔷 Example: Why Good Software Architecture Matters

Imagine a popular online shopping website used by millions every day. If the software is poorly designed:

The website might slow down or crash when many users visit at once.
Developers may find it hard to add new features like discounts or reviews without breaking something else.
Security issues could allow hackers to steal user data.
The team might get confused about how the system works, causing mistakes and delays.

But with a good software architecture:

The website stays fast and reliable even with many users (scalability).
Developers can easily add or fix features without causing problems (maintainability).
User data is protected with strong security measures.
Everyone on the team understands the system clearly, helping them work together better.

This is why designing software architecture carefully is so important—it saves time, money, and keeps users happy.

🔷 Types of Software Architecture

Here are some common software architecture styles used today:

1. Monolithic Architecture

What is Monolithic Architecture?

In Monolithic Architecture, the whole software system is built as one single application.
This means all parts of the system — like login, user interface, order processing, service logic, and catalog/shop UI — are combined and work together as one big program.
Imagine it like a big block where everything is connected tightly and depends on each other.

When to Use Monolithic Architecture?

When building small or medium-sized apps that don’t have too many features.
When the development team is small and communication is easy.
When you want to create and launch the app quickly without complex setups.
When you don’t expect the app to need big changes or to grow a lot soon.

Real-World Example: A Simple Online Store

Think about a small online store that sells handmade items.
The website has parts like login, product pages, shopping cart, and payment all built as one complete application.
Because the store is small with few users and features, it’s easier to build and manage this way.
If the owner wants to update the website, they just update the whole app at once.

When Not to Use Monolithic Architecture:

If the app will grow very big with many features.
If you need to grow or fix only some parts of the app separately (like just the payment system).
If many teams are working on different parts of the app at the same time.

What is Artillery?

Artillery is a tool that helps us test how well a website or app’s server performs when many users use it at the same time.

It sends lots of fake users (virtual users) to the server all at once.
It measures how fast the server responds and if it can handle many requests without breaking.
This helps find problems before real users experience slowdowns or crashes.

Testing a Server with Artillery

Artillery allows us to simulate multiple users making requests to a server for a specific time.

Why Test with Artillery?

To check how many users your server can handle at the same time.
To see if the server gets slow or crashes under heavy use.
To find bottlenecks and improve server performance.

What Happens When You Test?

Artillery creates virtual users that send requests to the server continuously.
The server responds to these requests, and Artillery records response times, error rates, and throughput.
At the end, you get a detailed report showing how well the server performed.

Example Artillery Test

artillery quick --count 50 -n 100 http://localhost:3000/add-to-cart

--count 50 means 50 virtual users will be simulated.
-n 100 means each user will send 100 requests.

The URL is the part of the server you want to test (like a product API).

Chech the https://www.artillery.io/docs doc to learn about post and put test

app.post('/add-to-cart', (req, res) => {
  // Pretend it takes a little time to add an item
  setTimeout(() => {
    res.send({ message: 'Item added to cart' });
  }, 50);
});

But the Real Problem Starts When...

We don’t just send a small message like { message: 'Item added to cart' } to the client.
Instead, we send a lot of data back to the client every time — like big lists of products, user data, images, or order details.
Sending this large amount of data makes the server work much harder.
The server’s CPU and memory get used up quickly, slowing down the whole system.
This causes the server to respond slower or even crash when many users send requests at the same time.

Why Does Sending Lots of Data Matter?

Bigger responses take more time to prepare and send over the network.
The server has to handle all the processing and data transfer at once, which can overload it.
This is especially true in a monolithic architecture where one server handles everything.

What Should We Do?

Optimize the data sent to clients (send only what’s necessary).
Use techniques like pagination to send data in smaller parts.
Consider moving to microservices or adding caching to reduce server load.
Use load testing tools to understand how much load your server can handle.

Client-Server Architecture
- The client (app or browser) sends requests to a server which processes and responds.
- Common for web and mobile applications.
Microservices Architecture
- The system is broken into small, independent services.
- Each service handles a specific function (e.g., login, messaging).
- Easier to scale, maintain, and update.

npm os , cluster

Event-Driven Architecture
- The system reacts to “events” like user actions or system changes.
- Ideal for real-time updates and notifications.
Serverless Architecture
- Developers write small functions that run in the cloud only when needed.
- Cost-effective and scalable.
Layered Architecture (N-Tier)
- Divides the system into layers such as presentation (UI), business logic, and database.
- Easier to manage and test layers separately.

🔷 Key Components in Software Architecture

Client: The app or web browser the user interacts with.
Server: A powerful computer that handles requests from clients and runs backend processes.
Database: Stores all data such as user info, posts, messages, etc.
API (Application Programming Interface): A set of rules that allows different parts of the system to communicate.
Load Balancer: Distributes incoming user traffic across multiple servers to prevent overload.
Content Delivery Network (CDN): Stores and delivers media files (images, videos) quickly by caching them near users.
Authentication System: Confirms the identity of users to keep accounts secure.
Containers & Orchestration (e.g., Docker, Kubernetes): Manage deployment and scaling of software services efficiently.