Serverloze architectuurpatronen
Verken en pas gangbare serverloze architectuurpatronen toe, zoals fan-out, scatter-gather en event sourcing, om complexe bedrijfsproblemen efficiënt op te lossen.
Serverloze architectuurpatronen is een gratis Serverloze ontwikkeling met AWS Lambda-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Serverloze ontwikkeling met AWS Lambda. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Serverloze ontwikkeling met AWS Lambda bevat in totaal 4 lessen.
Wat zijn serverloze patronen
Bij serverloze ontwikkeling komen we vaak vergelijkbare uitdagingen tegen. Architectuurpatronen zijn beproefde, herbruikbare oplossingen voor deze veelvoorkomende problemen.
Ze helpen ons schaalbare, veerkrachtige en onderhoudbare serverloze toepassingen te ontwerpen door een blauwdruk te bieden voor de interactie tussen verschillende services.
Het Fan-Out-patroon
Het Fan-Out-patroon houdt in dat één invoergebeurtenis meerdere parallelle processen of acties activeert. U kunt het vergelijken met de rimpeling die ontstaat wanneer u een steen in het water gooit.
Dit patroon is zeer geschikt om services los te koppelen en gelijktijdige taken uit te voeren. Zo moet een nieuw geüpload bestand bijvoorbeeld op meerdere verschillende manieren tegelijk worden verwerkt.
Fan-Out: voorbeeld van beeldverwerking
Stel u voor dat u een afbeelding uploadt. Een Lambda-functie kan deze gebeurtenis 'fan-outen' en afzonderlijke processen activeren voor het maken van een miniatuur, het toevoegen van een watermerk en het extraheren van metagegevens—allemaal parallel.
Hier ziet u een conceptueel Python-voorbeeld dat deze Fan-Out-logica simuleert:
def process_image_event(image_id):
print(f"Processing image: {image_id}")
# Simulate publishing to different services
print(f" - Publishing to Thumbnail Service for {image_id}")
print(f" - Publishing to Watermark Service for {image_id}")
print(f" - Publishing to Metadata Service for {image_id}")
def main():
print("--- Fan-Out Simulation ---")
image_id = "img-12345.jpg"
process_image_event(image_id)
print("--- Simulation Complete ---")
if __name__ == "__main__":
main()Het Scatter-Gather-patroon
Bij het Scatter-Gather-patroon wordt een verzoek naar meerdere ontvangers gestuurd (scatter), worden al hun antwoorden verzameld en vervolgens samengevoegd tot één antwoord (gather).
Dit wordt vaak gebruikt voor bewerkingen zoals zoeken in meerdere gegevensbronnen of prijzen van verschillende leveranciers vergelijken.
Scatter-Gather: voorbeeld van product zoeken
Wanneer u naar een product zoekt, kan een Lambda de zoekopdracht naar verschillende API's van leveranciers 'scatteren' en hun resultaten vervolgens 'gatheren' en combineren om u de beste opties te tonen.
Dit voorbeeld simuleert het opvragen van verschillende leveranciers en het vinden van het goedkoopste product:
def get_product_info(vendor_name, product_id):
# Simulate calling a vendor API
print(f" - Querying {vendor_name} for product {product_id}...")
if vendor_name == "VendorA":
return {"vendor": "VendorA", "price": 100, "stock": 5}
elif vendor_name == "VendorB":
return {"vendor": "VendorB", "price": 95, "stock": 10}
elif vendor_name == "VendorC":
return {"vendor": "VendorC", "price": 110, "stock": 3}
return None
def main():
print("--- Scatter-Gather Simulation ---")
product_id = "PROD-XYZ"
vendors = ["VendorA", "VendorB", "VendorC"]
all_results = []
print(f"Searching for product {product_id} across vendors:")
for vendor in vendors:
result = get_product_info(vendor, product_id)
if result:
all_results.append(result)
print("\n--- Aggregated Results ---")
if all_results:
for res in all_results:
print(f" Vendor: {res['vendor']}, Price: ${res['price']}, Stock: {res['stock']}")
cheapest = min(all_results, key=lambda x: x['price'])
print(f"\nCheapest option: {cheapest['vendor']} at ${cheapest['price']}")
else:
print("No results found.")
print("--- Simulation Complete ---")
if __name__ == "__main__":
main()Het Event Sourcing-patroon
Event Sourcing is een architectuurpatroon waarbij alle wijzigingen in de status van een toepassing worden opgeslagen als een reeks onveranderlijke gebeurtenissen. In plaats van alleen de huidige status op te slaan, slaat u op hoe u die status hebt bereikt.
Dit biedt een volledige audittrail, maakt het mogelijk om eerdere statussen opnieuw op te bouwen en vormt de basis voor complexe gebeurtenisgestuurde systemen.
Event Sourcing: voorbeeld van orderbeheer
In een e-commercesysteem werkt u niet rechtstreeks een Order-record bij, maar registreert u gebeurtenissen zoals OrderCreated, ItemAdded en OrderShipped. De huidige status wordt vervolgens afgeleid door deze gebeurtenissen in volgorde toe te passen.
Hier ziet u een simulatie waarin gebeurtenissen voor een bestelling worden geregistreerd:
import datetime
def record_event(event_type, payload):
timestamp = datetime.datetime.now().isoformat()
event = {
"eventId": f"evt-{datetime.datetime.now().timestamp()}",
"eventType": event_type,
"timestamp": timestamp,
"payload": payload
}
# In a real system, this would write to a database stream (e.g., DynamoDB Streams, Kinesis)
print(f"Recorded Event: {event['eventType']} at {event['timestamp']}")
print(f" Payload: {event['payload']}")
return event
def main():
print("--- Event Sourcing Simulation ---")
# Simulate an order creation
order_id = "ORD-001"
record_event("OrderCreated", {"orderId": order_id, "customer": "Alice", "initialItems": []})
# Simulate adding an item
record_event("ItemAdded", {"orderId": order_id, "itemId": "SKU-A", "quantity": 1})
# Simulate updating an item quantity
record_event("ItemQuantityUpdated", {"orderId": order_id, "itemId": "SKU-A", "newQuantity": 2})
# Simulate shipping the order
record_event("OrderShipped", {"orderId": order_id, "shippingProvider": "UPS"})
print("\n--- Event Stream Recorded ---")
if __name__ == "__main__":
main()Voordelen van serverloze patronen
Deze patronen bieden aanzienlijke voordelen voor serverloze toepassingen:
- Schaalbaarheid: Verwerk een hogere belasting eenvoudig door meer parallelle processen toe te voegen.
- Ontkoppeling: Diensten werken onafhankelijk van elkaar, waardoor afhankelijkheden afnemen en de veerkracht verbetert.
- Veerkracht: Fouten in één deel van een fan-out- of scatter-gather-werkstroom stoppen niet noodzakelijk het hele proces.
- Controleerbaarheid (Event Sourcing): Een volledige geschiedenis van wijzigingen is onmisbaar voor foutopsporing, naleving van regelgeving en analyses.
Het juiste patroon kiezen
Welk patroon je kiest, hangt af van je specifieke probleem:
- Gebruik Fan-Out wanneer één gebeurtenis meerdere onafhankelijke, parallelle acties moet starten.
- Gebruik Scatter-Gather wanneer je meerdere bronnen moet bevragen en hun antwoorden moet samenvoegen.
- Gebruik Event Sourcing wanneer je een volledige, onveranderlijke geschiedenis van wijzigingen of complexe tijdsgebonden query's nodig hebt.
Vaak kun je deze patronen combineren binnen een grotere serverloze architectuur.
Patroonuitdaging
Een nieuw e-commerceplatform moet klantbestellingen verwerken. Wanneer een bestelling wordt geplaatst, moet het systeem:
- De voorraad bijwerken.
- Een bevestigingsmail verzenden.
- Een verzendlabel genereren.
- De betaling verwerken.
Welk serverloos architectuurpatroon is het meest geschikt om deze onafhankelijke taken te coördineren nadat een bestelling is geplaatst?
Samenvatting van patronen
We hebben belangrijke serverloze architectuurpatronen verkend: Fan-Out voor parallelle verwerking vanuit één gebeurtenis, Scatter-Gather voor het samenvoegen van antwoorden uit meerdere bronnen en Event Sourcing voor het bijhouden van een onveranderlijke geschiedenis van statuswijzigingen.
Als je deze patronen begrijpt, kun je robuuste, schaalbare en veerkrachtige serverloze toepassingen ontwerpen en voor elk complex probleem het juiste hulpmiddel kiezen.
Leer Serverloze ontwikkeling met AWS Lambda met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Serverloze architectuurpatronen” gratis?
Ja — de volledige tekst van “Serverloze architectuurpatronen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Serverloze ontwikkeling met AWS Lambda wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Serverloze ontwikkeling met AWS Lambda bevat in totaal 4 lessen.
Wat leer ik in “Serverloze architectuurpatronen”?
Verken en pas gangbare serverloze architectuurpatronen toe, zoals fan-out, scatter-gather en event sourcing, om complexe bedrijfsproblemen efficiënt op te lossen. Je oefent met Serverloze ontwikkeling met AWS Lambda door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Serverloze ontwikkeling met AWS Lambda te beginnen?
Ervaring vooraf is niet nodig. Serverloze ontwikkeling met AWS Lambda op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Serverloze architectuurpatronen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Serverloze ontwikkeling met AWS Lambda?
Ja. Elke les over Serverloze ontwikkeling met AWS Lambda bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Canary- en blue/green-deployments
- Veerkrachtige serverloze systemen bouwen
- Serverloze architectuurpatronen
- Kostenoptimalisatie in serverless-architecturen