The Project | About Us | Contribute | Donations | License

HOME

In this section, we will provide a series of practical exercises designed to reinforce the concepts learned throughout the course. Each exercise will focus on different aspects of system architecture, from design principles to scalability and security. Solutions and explanations will be provided to help you understand the correct approach and common pitfalls.

Exercise 1: Designing a Layered Architecture

Problem Statement

Design a layered architecture for a simple online bookstore. The system should include the following functionalities:

User registration and login
Browsing books by category
Adding books to a shopping cart
Checking out and processing payments

Steps

Identify the Layers: Determine the different layers that your architecture will have (e.g., Presentation, Business Logic, Data Access).
Define Components: Identify the main components within each layer.
Draw the Architecture Diagram: Create a diagram that visually represents the layers and components.

Solution

Identify the Layers:
- Presentation Layer: Handles user interface and user interactions.
- Business Logic Layer: Contains the core functionality and business rules.
- Data Access Layer: Manages data storage and retrieval.
Define Components:
- Presentation Layer:
  - User Interface (UI)
  - Controllers
- Business Logic Layer:
  - User Management Service
  - Book Catalog Service
  - Shopping Cart Service
  - Payment Processing Service
- Data Access Layer:
  - User Repository
  - Book Repository
  - Order Repository
Draw the Architecture Diagram:

+---------------------+
|  Presentation Layer |
+---------------------+
|  - User Interface   |
|  - Controllers      |
+---------------------+
          |
          v
+---------------------+
| Business Logic Layer|
+---------------------+
|  - User Management  |
|  - Book Catalog     |
|  - Shopping Cart    |
|  - Payment Processing|
+---------------------+
          |
          v
+---------------------+
|  Data Access Layer  |
+---------------------+
|  - User Repository  |
|  - Book Repository  |
|  - Order Repository |
+---------------------+

Explanation

Presentation Layer: This layer is responsible for handling user interactions. It includes the UI components and controllers that manage user input and output.
Business Logic Layer: This layer contains the core business logic and services that implement the system's functionalities. Each service is responsible for a specific domain (e.g., user management, book catalog).
Data Access Layer: This layer manages the data storage and retrieval operations. Repositories are used to abstract the data access logic.

Exercise 2: Implementing a Microservice for User Management

Problem Statement

Implement a microservice for user management that includes the following functionalities:

User registration
User login
Fetching user details

Steps

Define the API Endpoints: List the API endpoints required for the functionalities.
Implement the Microservice: Write the code for the microservice.
Test the Microservice: Ensure the microservice works as expected.

Solution

Define the API Endpoints:
- POST /users/register: Register a new user.
- POST /users/login: Login a user.
- GET /users/{id}: Fetch user details by ID.
Implement the Microservice:

from flask import Flask, request, jsonify
import uuid

app = Flask(__name__)

# In-memory storage for users
users = {}

@app.route('/users/register', methods=['POST'])
def register_user():
    data = request.get_json()
    user_id = str(uuid.uuid4())
    users[user_id] = {
        'id': user_id,
        'username': data['username'],
        'password': data['password']  # Note: In a real system, passwords should be hashed
    }
    return jsonify({'id': user_id}), 201

@app.route('/users/login', methods=['POST'])
def login_user():
    data = request.get_json()
    for user in users.values():
        if user['username'] == data['username'] and user['password'] == data['password']:
            return jsonify({'message': 'Login successful'}), 200
    return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/users/<user_id>', methods=['GET'])
def get_user(user_id):
    user = users.get(user_id)
    if user:
        return jsonify(user), 200
    return jsonify({'message': 'User not found'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Test the Microservice:
- Use tools like Postman or curl to test the API endpoints.
- Ensure that user registration, login, and fetching user details work as expected.

Explanation

API Endpoints: The microservice exposes three endpoints for user registration, login, and fetching user details.
In-memory Storage: For simplicity, an in-memory dictionary is used to store user data. In a real system, a database would be used.
Flask Framework: Flask is used to create the microservice. It provides a simple way to define routes and handle HTTP requests.

Exercise 3: Implementing Load Balancing

Problem Statement

Implement a load balancer for a web application with multiple instances. The load balancer should distribute incoming requests evenly across the instances.

Steps

Set Up Multiple Instances: Create multiple instances of the web application.
Configure the Load Balancer: Set up a load balancer to distribute requests.
Test the Load Balancer: Ensure that requests are distributed evenly.

Solution

Set Up Multiple Instances:
- Assume you have three instances of a web application running on ports 5000, 5001, and 5002.
Configure the Load Balancer:
- Use Nginx as the load balancer.

http {
    upstream backend {
        server localhost:5000;
        server localhost:5001;
        server localhost:5002;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://backend;
        }
    }
}

Test the Load Balancer:
- Use a tool like Apache JMeter to send multiple requests to the load balancer.
- Verify that the requests are distributed evenly across the instances.

Explanation

Multiple Instances: Running multiple instances of the web application ensures high availability and scalability.
Nginx Configuration: Nginx is configured to act as a load balancer, distributing requests to the backend instances.
Testing: Tools like Apache JMeter can simulate multiple users and help verify the load distribution.

Conclusion

These practical exercises cover various aspects of system architecture, from designing layered architectures to implementing microservices and load balancing. By completing these exercises, you will gain hands-on experience and a deeper understanding of the principles and practices of designing robust and scalable technological architectures.

System Architectures: Principles and Practices for Designing Robust and Scalable Technological Architectures

Practical Exercises

Exercise 1: Designing a Layered Architecture

Problem Statement

Steps

Solution

Explanation

Exercise 2: Implementing a Microservice for User Management

Problem Statement

Steps

Solution

Explanation

Exercise 3: Implementing Load Balancing

Problem Statement

Steps

Solution

Explanation

Conclusion

System Architectures: Principles and Practices for Designing Robust and Scalable Technological Architectures

Module 1: Introduction to System Architectures

Module 2: Design Principles of Architectures

Module 3: Components of a System Architecture

Module 4: Scalability and Performance

Module 5: Security in System Architectures

Module 6: Tools and Technologies

Module 7: Case Studies and Practical Examples

Module 8: Trends and Future of System Architectures