Wat is het verschil tussen microservices-architectuur en monolithische architectuur?

Monolithische architectuur:

• Een enkele, zelfvoorzienende applicatie.
• Alle componenten zijn nauw verbonden.
• Deployment gebeurt in één blok.
• Schaalvergroting is meestal horizontaal (het vergroten van het aantal exemplaren van de hele applicatie).
• Ontwikkeling, testen en debugging zijn eenvoudiger voor kleine projecten.
• Moeilijkheden bij het schalen van individuele onderdelen, bijwerken en refactoring van een grote monoliet.

Microservices-architectuur:

• Een verzameling van kleine, onafhankelijke services.
• Elke service voert een specifieke bedrijfsfunctie uit.
• Services communiceren met elkaar (bijvoorbeeld via HTTP, via een berichtenwachtrij).
• Services worden onafhankelijk uitgerold.
• Mogelijkheid om elke service afzonderlijk te schalen.
• De technologische stack kan verschillen tussen services.
• Complexiteit in het beheren van gedistribueerde systemen, het waarborgen van dataconsistentie, monitoring en testen.

Belangrijke verschillen:

Kenmerk	Monolithische architectuur	Microservices-architectuur
Grootte	Groot	Klein
Onafhankelijkheid	Laag	Hoog
Deployment	Geheel	Onafhankelijk
Schaalbaarheid	Horizontaal (alles)	Per service
Fouttolerantie	Laag (fout van een deel - fout van alles)	Hoog (fout van een service veroorzaakt niet de fout van het hele systeem)
Technologieën	Enkele stack	Verschillende stacks
Beheercomplexiteit	Laag (voor kleine projecten)	Hoog (voor gedistribueerde systemen)

# Voorbeeld van structuur van een monolithische applicatie
# De applicatie bevat alle modules op één plek
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):
        # Alle functionaliteiten werken binnen één proces
        pass

# Voorbeeld van structuur van een microservices-architectuur
# Gescheiden services voor gebruiker, bestellingen en betalingen
# Deze services worden onafhankelijk uitgerold en draaien
class UserServiceClient:
    def create_user(self):
        # Aanroep van de externe gebruikersservice
        pass

class OrderService:
    def process_order(self):
        # Logica voor orderverwerking
        pass

class PaymentServiceClient:
    def process_payment(self):
        # Aanroep van de externe betalingsservice
        pass

# Gescheiden processen of containers voor elke service
# UserService.run()
# OrderService.run()
# PaymentService.run()