Serverløse arkitekturmønstre
Utforsk og bruk vanlige serverløse arkitekturmønstre som fan-out, scatter-gather og hendelseskildring for å løse komplekse forretningsproblemer effektivt.
Serverløse arkitekturmønstre er en gratis leksjon i Serverløs utvikling med AWS Lambda på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Serverløs utvikling med AWS Lambda, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Serverløs utvikling med AWS Lambda inneholder totalt 4 leksjoner.
Hva er serverløse mønstre?
I serverløs utvikling møter vi ofte lignende utfordringer. Arkitekturmønstre er utprøvde og gjenbrukbare løsninger på disse vanlige problemene.
De hjelper oss med å utforme skalerbare, robuste og vedlikeholdbare serverløse applikasjoner ved å gi en plan for samhandlingen mellom ulike tjenester.
Fan-Out-mønsteret
Fan-Out-mønsteret innebærer at én enkelt inndatah endelse utløser flere parallelle prosesser eller handlinger. Tenk på det som ringvirkningene etter en stein som kastes i vannet.
Dette mønsteret egner seg godt til å koble tjenester fra hverandre og utføre samtidige oppgaver. En ny filopplasting kan for eksempel måtte behandles på flere ulike måter samtidig.
Fan-Out: Eksempel på bildebehandling
Se for deg at du laster opp et bilde. En Lambda-funksjon kan «spre» denne hendelsen og utløse separate prosesser for å lage et miniatyrbilde, legge til et vannmerke og hente ut metadata – alt parallelt.
Her er et konseptuelt Python-eksempel som simulerer denne Fan-Out-logikken:
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ønsteret
Scatter-Gather-mønsteret innebærer å sende en forespørsel til flere mottakere (scatter), samle inn alle svarene deres og deretter slå dem sammen til ett svar (gather).
Dette brukes ofte til operasjoner som søk i flere datakilder eller sammenligning av priser fra ulike leverandører.
Scatter-Gather: Eksempel på produktsøk
Når du søker etter et produkt, kan en Lambda «spre» spørringen til ulike leverandør-API-er og deretter «samle» og kombinere resultatene for å vise deg de beste alternativene.
Dette eksempelet simulerer spørringer mot ulike leverandører og finner det billigste produktet:
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ønsteret
Event Sourcing er et arkitekturmønster der alle endringer i applikasjonens tilstand lagres som en sekvens av uforanderlige hendelser. I stedet for bare å lagre den gjeldende tilstanden lagrer du hvordan du kom frem til denne tilstanden.
Dette gir et komplett revisjonsspor, gjør det mulig å bygge opp tidligere tilstander på nytt og er grunnleggende for komplekse hendelsesdrevne systemer.
Event Sourcing: Eksempel på ordrebehandling
I et e-handelssystem oppdaterer du ikke en Order-post. I stedet registrerer du hendelser som OrderCreated, ItemAdded og OrderShipped. Den gjeldende tilstanden utledes deretter ved å bruke disse hendelsene i riktig rekkefølge.
Her er en simulering av registrering av hendelser 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()Fordeler med serverløse mønstre
Disse mønstrene gir betydelige fordeler for serverløse applikasjoner:
- Skalerbarhet: Håndter enkelt økt belastning ved å legge til flere parallelle prosesser.
- Dekobling: Tjenestene fungerer uavhengig av hverandre, noe som reduserer avhengigheter og forbedrer robustheten.
- Robusthet: Feil i én del av en fan-out- eller scatter-gather-arbeidsflyt stopper ikke nødvendigvis hele prosessen.
- Etterprøvbarhet (Event Sourcing): En komplett endringshistorikk er uvurderlig for feilsøking, samsvarskrav og analyse.
Velge riktig mønster
Valget av riktig mønster avhenger av det spesifikke problemet:
- Bruk Fan-Out når én hendelse skal utløse flere uavhengige, parallelle handlinger.
- Bruk Scatter-Gather når De må spørre flere kilder og samle svarene deres.
- Bruk Event Sourcing når De trenger en komplett, uforanderlig historikk over endringer eller komplekse tidsrelaterte spørringer.
Disse mønstrene kan ofte kombineres i en større serverløs arkitektur.
Mønsterutfordring
En ny e-handelsplattform må behandle kundeordrer. Når en ordre legges inn, må systemet:
- Oppdatere lagerbeholdningen.
- Sende en bekreftelses-e-post.
- Generere en fraktetikett.
- Behandle betalingen.
Hvilket serverløst arkitekturmønster egner seg best for å koordinere disse uavhengige oppgavene etter at en ordre er lagt inn?
Oppsummering av mønstre
Vi har utforsket viktige serverløse arkitekturmønstre: Fan-Out for parallell behandling fra én hendelse, Scatter-Gather for å samle svar fra flere kilder og Event Sourcing for å opprettholde en uforanderlig historikk over tilstandsendringer.
Ved å forstå disse mønstrene kan De utforme robuste, skalerbare og motstandsdyktige serverløse applikasjoner og velge riktig verktøy for hvert komplekse problem.
Lær deg Serverløs utvikling med AWS Lambda med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Serverløse arkitekturmønstre» gratis?
Ja – hele teksten i «Serverløse arkitekturmønstre» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Serverløs utvikling med AWS Lambda-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Serverløs utvikling med AWS Lambda inneholder totalt 4 leksjoner.
Hva lærer jeg i «Serverløse arkitekturmønstre»?
Utforsk og bruk vanlige serverløse arkitekturmønstre som fan-out, scatter-gather og hendelseskildring for å løse komplekse forretningsproblemer effektivt. Du øver på Serverløs utvikling med AWS Lambda med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Serverløs utvikling med AWS Lambda?
Ingen tidligere erfaring er nødvendig. Serverløs utvikling med AWS Lambda på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Serverløse arkitekturmønstre»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Serverløs utvikling med AWS Lambda-leksjonen?
Ja. Alle Serverløs utvikling med AWS Lambda-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Canary- og blue/green-distribusjoner
- Bygge robuste serverløse systemer
- Serverløse arkitekturmønstre
- Kostnadsoptimalisering i serverless-arkitekturer