Serverløse arkitekturmønstre
Udforsk og anvend almindelige serverløse arkitekturmønstre som fan-out, scatter-gather og event sourcing til effektivt at løse komplekse forretningsproblemer.
Serverløse arkitekturmønstre er en gratis Serverløs udvikling med AWS Lambda-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Serverløs udvikling med AWS Lambda, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Serverløs udvikling med AWS Lambda-kurset indeholder 4 lektioner i alt.
Hvad er serverløse mønstre?
Under serverløs udvikling støder vi ofte på lignende udfordringer. Arkitekturmønstre er gennemprøvede, genanvendelige løsninger på disse almindelige problemer.
De hjælper os med at designe skalerbare, modstandsdygtige og vedligeholdelsesvenlige serverløse applikationer ved at give os en model for interaktionen mellem forskellige tjenester.
Fan-out-mønstret
Fan-out-mønstret opstår, når en enkelt inputhændelse udløser flere parallelle processer eller handlinger. Tænk på det som ringe i vandet fra en sten, der kastes i en sø.
Dette mønster er fremragende til at afkoble tjenester og udføre samtidige opgaver. En ny filupload kan f.eks. skulle behandles på flere forskellige måder på samme tid.
Fan-out: Eksempel med billedbehandling
Forestil dig, at du uploader et billede. En Lambda-funktion kan udføre fan-out på denne hændelse og udløse separate processer til at oprette en miniature, tilføje et vandmærke og udtrække metadata – alt sammen parallelt.
Her er et konceptuelt Python-eksempel, der simulerer denne fan-out-logik:
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()Scatter-gather-mønstret
Scatter-gather-mønstret indebærer, at en forespørgsel sendes til flere modtagere (scatter), at alle deres svar indsamles, og at de derefter samles i ét svar (gather).
Det bruges ofte til operationer som søgning på tværs af flere datakilder eller sammenligning af priser fra forskellige leverandører.
Scatter-gather: Eksempel med produktsøgning
Når du søger efter et produkt, kan en Lambda-funktion sprede forespørgslen ud til forskellige leverandørers API'er og derefter samle og kombinere deres resultater, så du får vist de bedste muligheder.
Dette eksempel simulerer forespørgsler til forskellige leverandører og finder det billigste produkt:
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()Event Sourcing-mønstret
Event Sourcing er et arkitekturmønster, hvor alle ændringer af applikationens tilstand gemmes som en sekvens af uforanderlige hændelser. I stedet for kun at gemme den aktuelle tilstand gemmer du hvordan du nåede frem til den.
Det giver et komplet revisionsspor, gør det muligt at genskabe tidligere tilstande og danner grundlag for komplekse hændelsesdrevne systemer.
Event Sourcing: Eksempel med ordrebehandling
I et e-handelssystem opdaterer du ikke en Order-post. I stedet registrerer du hændelser som OrderCreated, ItemAdded og OrderShipped. Den aktuelle tilstand udledes derefter ved at anvende disse hændelser i rækkefølge.
Her er en simulering af registrering af hændelser for en ordre:
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()Fordele ved serverløse mønstre
Disse mønstre giver betydelige fordele for serverløse applikationer:
- Skalerbarhed: Håndtér nemt øget belastning ved at tilføje flere parallelle processer.
- Afkobling: Tjenester fungerer uafhængigt af hinanden, hvilket reducerer afhængighederne og forbedrer robustheden.
- Robusthed: Fejl i én del af et fan-out- eller scatter-gather-arbejdsforløb behøver ikke nødvendigvis at stoppe hele processen.
- Revisionsspor (Event Sourcing): En komplet historik over ændringer er uvurderlig til fejlfinding, overholdelse af krav og analyse.
Valg af det rigtige mønster
Valget af det korrekte mønster afhænger af dit konkrete problem:
- Brug Fan-Out, når én hændelse skal udløse flere uafhængige, parallelle handlinger.
- Brug Scatter-Gather, når du skal forespørge flere kilder og samle deres svar.
- Brug Event Sourcing, når du har brug for en komplet, uforanderlig historik over ændringer eller komplekse tidsmæssige forespørgsler.
Ofte kan disse mønstre kombineres i en større serverløs arkitektur.
Udfordring: mønstre
En ny e-handelsplatform skal behandle kundeordrer. Når en ordre afgives, skal systemet:
- Opdatere lagerbeholdningen.
- Sende en bekræftelsesmail.
- Generere en forsendelsesetiket.
- Behandle betalingen.
Hvilket serverløst arkitekturmønster er bedst egnet til at koordinere disse uafhængige opgaver, efter at en ordre er afgivet?
Opsummering af mønstre
Vi har gennemgået vigtige serverløse arkitekturmønstre: Fan-Out til parallel behandling fra én hændelse, Scatter-Gather til samling af svar fra flere kilder og Event Sourcing til vedligeholdelse af en uforanderlig historik over tilstandsændringer.
En forståelse af disse mønstre hjælper dig med at designe robuste, skalerbare og modstandsdygtige serverløse applikationer, hvor du vælger det rigtige værktøj til hvert komplekst problem.
Lær Serverløs udvikling med AWS Lambda med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Serverløse arkitekturmønstre” gratis?
Ja — hele teksten til “Serverløse arkitekturmønstre” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Serverløs udvikling med AWS Lambda-kurset, skal du opgradere til CoddyKit PRO. Serverløs udvikling med AWS Lambda-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Serverløse arkitekturmønstre”?
Udforsk og anvend almindelige serverløse arkitekturmønstre som fan-out, scatter-gather og event sourcing til effektivt at løse komplekse forretningsproblemer. Du øver dig i Serverløs udvikling med AWS Lambda med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Serverløs udvikling med AWS Lambda?
Der kræves ingen tidligere erfaring. Serverløs udvikling med AWS Lambda på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Serverløse arkitekturmønstre”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Serverløs udvikling med AWS Lambda-lektion?
Ja. Alle Serverløs udvikling med AWS Lambda-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Canary- og blue/green-deployments
- Opbygning af robuste serverløse systemer
- Serverløse arkitekturmønstre
- Omkostningsoptimering i serverless-arkitekturer