Serverlös utveckling med AWS Lambda · Lektion

Bygga händelsestyrda mikrotjänster

Utforma och implementera robusta mikrotjänstarkitekturer där Lambda-funktioner kommunicerar asynkront via händelser, vilket främjar lös koppling och skalbarhet.

Lektion 1 av 411 steg

Bygga händelsestyrda mikrotjänster är en gratis lektion i Serverlös utveckling med AWS Lambda på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Serverlös utveckling med AWS Lambda, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Serverlös utveckling med AWS Lambda innehåller totalt 4 lektioner.

Mikrotjänster och händelsekommunikation

Moderna applikationer delas ofta upp i mindre, oberoende tjänster som kallas mikrotjänster. Detta arbetssätt gör det lättare att hantera komplexitet och låter team arbeta självständigt.

Men hur kommunicerar dessa tjänster med varandra? Traditionella metoder, som direkta API-anrop, kan skapa täta beroenden. Det är här händelsedrivna arkitekturer kommer till sin rätt!

Kraften i händelsedrivning

Händelsedrivna mikrotjänster kommunicerar genom att skicka och reagera på händelser. Föreställ Er att en tjänst meddelar ”något har hänt!” utan att bry sig om vem som lyssnar.

Lös koppling: Tjänsterna behöver inte känna till varandra.
Skalbarhet: Varje tjänst kan skalas oberoende av de andra.
Resiliens: Fel i en tjänst påverkar mindre sannolikt de andra.
Flexibilitet: Nya konsumenter kan enkelt läggas till utan att befintliga producenter ändras.

Händelser och producenter förklarade

I centrum för detta mönster finns händelser och händelseproducenter.

En händelse är en registrering av något som har inträffat, till exempel ”OrderCreated” eller ”ProductUpdated”. Den är vanligtvis ett litet datapaket.
En händelseproducent är en tjänst som genererar och publicerar dessa händelser. Den utför en åtgärd och meddelar sedan om den.

Producenter väntar inte på ett svar; de publicerar händelsen och går vidare.

Konsumenter och händelsebussen

På andra sidan har vi händelsekonsumenter och en händelsebuss.

En händelsekonsument är en tjänst som prenumererar på och bearbetar specifika händelser. AWS Lambda-funktioner är perfekta händelsekonsumenter!
En händelsebuss (till exempel Amazon SNS eller EventBridge) fungerar som en central router. Producenter skickar händelser till bussen, som levererar dem till intresserade konsumenter.

Denna centrala hubb kopplar bort producenter från konsumenter.

Exempelflöde för mikrotjänster

Föreställ dig ett e-handelssystem:

En användare lägger en beställning (Order Service).
Order Service publicerar händelsen "OrderCreated" till en händelsebuss.
En Inventory Service (Lambda) tar emot "OrderCreated" för att uppdatera lagersaldot.
En Notification Service (Lambda) tar också emot "OrderCreated" för att skicka ett bekräftelsemejl.

Varje tjänst arbetar självständigt och reagerar på samma händelse.

Producerande Lambda i Python

Här är en enkel Python-Lambda-funktion som fungerar som en händelseproducent. Den publicerar händelsen "UserRegistered" till ett Amazon SNS-topic.

Kom ihåg att ersätta 'arn:aws:sns:REGION:ACCOUNT_ID:MyTopic' med ARN:en för ert faktiska SNS-topic.

import json
import boto3

sns_client = boto3.client('sns')
SNS_TOPIC_ARN = 'arn:aws:sns:REGION:ACCOUNT_ID:MyTopic' # Replace with your SNS Topic ARN

def lambda_handler(event, context):
    user_id = 'user123'
    username = 'Alice'
    
    event_payload = {
        'detail-type': 'UserRegistered',
        'source': 'com.coddykit.userservice',
        'detail': {
            'userId': user_id,
            'username': username
        }
    }
    
    try:
        response = sns_client.publish(
            TopicArn=SNS_TOPIC_ARN,
            Message=json.dumps(event_payload),
            MessageAttributes={
                'event_type': {
                    'DataType': 'String',
                    'StringValue': 'UserRegistered'
                }
            }
        )
        print(f"Published event: {event_payload}")
        return {
            'statusCode': 200,
            'body': json.dumps('Event published successfully!')
        }
    except Exception as e:
        print(f"Error publishing event: {e}")
        return {
            'statusCode': 500,
            'body': json.dumps(f'Error: {str(e)}')
        }

Konsumerande Lambda i Python

Nu skapar vi en Python-Lambda-funktion som fungerar som en händelsekonsument. Funktionen skulle prenumerera på SNS-topicet från föregående avsnitt.

Den loggar helt enkelt den mottagna händelsen, vilket simulerar att den bearbetas.

import json

def lambda_handler(event, context):
    print("Received event:")
    print(json.dumps(event, indent=2))
    
    # Extract message from SNS notification
    if 'Records' in event:
        for record in event['Records']:
            if 'Sns' in record:
                sns_message = json.loads(record['Sns']['Message'])
                print(f"Processing event of type: {sns_message.get('detail-type')}")
                print(f"User ID: {sns_message.get('detail', {}).get('userId')}")
                # Add your business logic here
    
    return {
        'statusCode': 200,
        'body': json.dumps('Event processed successfully!')
    }

Fördelar med lös koppling

Lägg märke till att den producerande Lambda-funktionen (User Service) inte vet något om den konsumerande Lambda-funktionen (till exempel en Welcome Email Service). Den publicerar bara händelsen "UserRegistered".

Om ni lägger till en ny tjänst (till exempel en Loyalty Points Service) som också behöver reagera på "UserRegistered", prenumererar ni helt enkelt på samma SNS-topic.
Inga ändringar behövs i User Service! Denna flexibilitet är central för mikrotjänstarkitekturer som utvecklas över tid.

Skalbarhet och motståndskraft

Händelsedrivna mönster förbättrar skalbarheten och motståndskraften avsevärt:

Skalbarhet: Varje konsument kan skalas självständigt utifrån sin arbetsbelastning. Om Notification Service är upptagen saktar den inte ned Inventory Service.
Motståndskraft: Om en konsument tillfälligt slutar fungera försöker händelsebussen ofta leverera händelsen igen (för vissa tjänster), eller så kan händelsen lagras i en Dead Letter Queue (DLQ) för senare bearbetning. På så sätt förhindras dataförlust.

Det gör hela systemet mer robust.

Test av händelsedrivna mikrotjänster

Låt oss testa er förståelse av händelsedrivna mikrotjänstarkitekturer.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Händelsedrivna mikrotjänster

Ni har lärt er hur händelsedrivna arkitekturer är grundläggande för att bygga robusta och skalbara mikrotjänster med AWS Lambda.

Tjänster kommunicerar asynkront via händelser.
Händelseproducenter publicerar händelser till en händelsebuss (som SNS).
Händelsekonsumenter (Lambda-funktioner) prenumererar på och reagerar på dessa händelser.
Detta mönster leder till lös koppling, oberoende skalbarhet och bättre motståndskraft i systemet.

Fortsätt bygga fantastiska, frikopplade tjänster!

Gratis att börja

Lär dig Serverlös utveckling med AWS Lambda med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Bygga händelsestyrda mikrotjänster” gratis?

Ja – hela texten till ”Bygga händelsestyrda mikrotjänster” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Serverlös utveckling med AWS Lambda, kan Ni uppgradera till CoddyKit PRO. Kursen i Serverlös utveckling med AWS Lambda innehåller totalt 4 lektioner.

Vad lär jag mig i ”Bygga händelsestyrda mikrotjänster”?

Utforma och implementera robusta mikrotjänstarkitekturer där Lambda-funktioner kommunicerar asynkront via händelser, vilket främjar lös koppling och skalbarhet. Ni övar på Serverlös utveckling med AWS Lambda med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Serverlös utveckling med AWS Lambda?

Du behöver inga förkunskaper. Utbildningen i Serverlös utveckling med AWS Lambda på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Bygga händelsestyrda mikrotjänster”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Serverlös utveckling med AWS Lambda-lektionen?

Ja. Varje Serverlös utveckling med AWS Lambda-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Bygga händelsestyrda mikrotjänster
Integrera med Amazon EventBridge
Realtidsbearbetning med Kinesis
Saga-mönstret för distribuerade transaktioner

← Tillbaka till Serverlös utveckling med AWS Lambda