Care este diferența dintre arhitectura microserviciilor și cea monolitică?

Arhitectură monolitică:

• O aplicație unică și autosuficientă.
• Toți componentii sunt strâns legați.
• Implementarea se face ca un singur bloc.
• Scalarea este de obicei orizontală (creșterea numărului de instanțe ale întregii aplicații).
• Dezvoltarea, testarea și depanarea sunt mai simple pentru proiecte mici.
• Dificultăți în scalarea părților individuale, actualizarea și refactorizarea unui monolit mare.

Arhitectură de microservicii:

• Un set de servicii mici și independente.
• Fiecare serviciu îndeplinește o funcție de afaceri specifică.
• Serviciile comunică între ele (de exemplu, prin HTTP, printr-o coadă de mesaje).
• Serviciile sunt implementate independent.
• Este posibil să scalezi fiecare serviciu separat.
• Stiva tehnologică poate varia pentru diferite servicii.
• Complexitatea gestionării unui sistem distribuit, asigurarea coerenței datelor, monitorizarea și testarea.

Diferențe cheie:

Caracteristică	Arhitectură monolitică	Arhitectură de microservicii
Dimensiune	Mare	Mic
Independență	Scăzută	Ridicată
Implementare	Unică	Independentă
Scalare	Orizontală (toate)	Pe serviciu
Rezistență la defecte	Scăzută (defecțiune parțială - defecțiune totală)	Ridicată (defecțiunea unui serviciu nu duce la eșecul întregului sistem)
Tehnologii	Stivă unică	Stive diferite
Complexitatea gestionării	Scăzută (pentru proiecte mici)	Ridicată (pentru sisteme distribuite)

# Exemplu de structură a unei aplicații monolitice
# Aplicația conține toate modulele într-un singur loc
class UserManagement:
    def create_user(self):
        pass

class OrderProcessing:
    def process_order(self):
        pass

class PaymentGateway:
    def process_payment(self):
        pass

class MonolithicApp:
    def __init__(self):
        self.user_management = UserManagement()
        self.order_processing = OrderProcessing()
        self.payment_gateway = PaymentGateway()

    def run(self):
        # Toate funcționalitățile funcționează într-un singur proces
        pass

# Exemplu de structură a arhitecturii microservicii
# Servicii separate pentru utilizator, comenzi și plăți
# Aceste servicii sunt implementate și funcționează independent
class UserServiceClient:
    def create_user(self):
        # Apel la serviciul remote de utilizatori
        pass

class OrderService:
    def process_order(self):
        # Logica de procesare a comenzii
        pass

class PaymentServiceClient:
    def process_payment(self):
        # Apel la serviciul remote de plăți
        pass

# Procese sau containere separate pentru fiecare serviciu
# UserService.run()
# OrderService.run()
# PaymentService.run()