Serverløs udvikling med AWS Lambda · Lektion

Fejlfinding af serverless-applikationer

Opdag teknikker til effektiv fejlfinding af Lambda-funktioner, herunder lokal test, fjernfejlfinding og fortolkning af CloudWatch-logge for at løse problemer.

Lektion 3 af 412 trin

Fejlfinding af serverless-applikationer 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.

Introduktion til fejlfinding af Lambda

Fejlfinding af serverløse applikationer, især AWS Lambda-funktioner, giver særlige udfordringer. I modsætning til traditionelle applikationer er Lambda-funktioner tilstandsløse og kortlivede.

I denne lektion gennemgår vi praktiske teknikker til effektivt at identificere og løse problemer i dine Lambda-funktioner, fra lokal test til fortolkning af logfiler.

Derfor er fejlfinding af serverløse systemer anderledes

Traditionel fejlfinding indebærer ofte, at man gennemgår kode linje for linje ved hjælp af et IDE. Med Lambda er det ikke altid lige enkelt, fordi:

Kortvarighed: Funktioner kører kun, når de bliver påkaldt, og forsvinder derefter.
Tilstandsløshed: Der er ingen vedvarende hukommelse mellem påkaldelser.
Distribuerede systemer: Problemer kan opstå gennem samspillet mellem mange tjenester.

Vi er i høj grad afhængige af logfiler, målepunkter og sporing for at forstå, hvad der sker.

Lokal test med SAM CLI

En af de mest effektive måder at finde fejl på er at teste dine Lambda-funktioner lokalt, før du implementerer dem i AWS.

AWS Serverless Application Model (SAM) CLI giver dig mulighed for at påkalde dine Lambda-funktioner på din lokale maskine, hvor AWS Lambda-kørselmiljøet simuleres.

Hurtigere tilbagemeldinger.
Brug dine velkendte lokale fejlfindingsværktøjer.

Demo af lokal påkaldelse med SAM CLI

Her er en enkel Python-Lambda-funktion. Til lokal test kan du simulere en hændelse og en kontekst. Prøv at køre den!

import json

def lambda_handler(event, context):
    message = event.get('message', 'Hello from Lambda!')
    print(f"Received event: {json.dumps(event)}")
    print(f"Processing message: {message}")
    return {
        'statusCode': 200,
        'body': json.dumps({'response': message})
    }

# This block allows local execution
if __name__ == '__main__':
    # Simulate an event
    test_event = {'message': 'Local debug test'}
    # Simulate a context object
    test_context = type('obj', (object,), {'invoked_function_arn': 'local'})()

    response = lambda_handler(test_event, test_context)
    print("\n--- Lambda Response ---")
    print(json.dumps(response, indent=2))

CloudWatch Logs til fejlfinding

Når din Lambda er implementeret, bliver Amazon CloudWatch Logs dit primære værktøj til at forstå dens adfærd og finde fejl.

Hver gang din Lambda-funktion påkaldes, sendes logfiler til en dedikeret loggruppe. Hver påkaldelse får et unikt Request ID, som hjælper med at spore udførelsen.

Loggrupper: Indeholder logfiler for en bestemt funktion.
Logstrømme: Indeholder bestemte forekomster af din funktions logfiler.

Sådan finder du problemer i logfiler

Når der opstår en fejl, er CloudWatch Logs det første sted, du bør kigge. Du kan:

Filtrere logfiler: Søge efter nøgleord som "ERROR", "Exception" eller bestemte meddelelser.
Log Insights: Bruge et avanceret forespørgselssprog til at analysere logfiler, gruppere fejl og identificere tendenser.
Request ID: Bruge Request ID'et fra påkaldelsen til at finde alle logfiler, der vedrører en bestemt udførelse.

Kontrollér altid hele stacktracen for detaljerede oplysninger om fejlen.

Fejlfinding med logmeddelelser

Den enkleste, men samtidig mest effektive, fejlfindingsmetode til Lambda er at bruge meddelelser med print() (Python) eller console.log() (Node.js).

Ved strategisk at tilføje logmeddelelser kan du følge variabelværdier, udførelsesforløb og funktionens tilstand på forskellige tidspunkter i din kode. Lad os se et eksempel:

import json

def calculate_discount(price, discount_percentage):
    print(f"DEBUG: Initial price: {price}")
    if not isinstance(price, (int, float)) or price < 0:
        raise ValueError("Price must be non-negative.")
    if not isinstance(discount_percentage, (int, float)) or not (0 <= discount_percentage <= 100):
        raise ValueError("Discount must be between 0 and 100.")

    discount_amount = price * (discount_percentage / 100)
    final_price = price - discount_amount
    print(f"DEBUG: Final price: {final_price}")
    return final_price

def lambda_handler(event, context):
    try:
        data = json.loads(event['body'])
        price = data['price']
        discount = data['discount']
        
        final_price = calculate_discount(price, discount)
        
        return {
            'statusCode': 200,
            'body': json.dumps({'originalPrice': price, 'finalPrice': final_price})
        }
    except Exception as e:
        print(f"ERROR: An error occurred: {e}")
        return {
            'statusCode': 400,
            'body': json.dumps({'error': str(e)})
        }

if __name__ == '__main__':
    # Test case 1: Valid input
    test_event_1 = {'body': json.dumps({'price': 100, 'discount': 10})}
    response_1 = lambda_handler(test_event_1, None)
    print("\n--- Test Case 1 Response ---")
    print(json.dumps(response_1, indent=2))

    # Test case 2: Invalid discount
    test_event_2 = {'body': json.dumps({'price': 50, 'discount': 110})}
    response_2 = lambda_handler(test_event_2, None)
    print("\n--- Test Case 2 Response ---")
    print(json.dumps(response_2, indent=2))

Forståelse af påkaldelsesfejl

Lambda-funktioner kan mislykkes af forskellige årsager. Det er afgørende at skelne mellem forskellige fejltyper:

Funktionsfejl: Din kode kastede en uhåndteret undtagelse. Disse vises i CloudWatch Logs med en stacktrace.
Påkaldelsesfejl: Problemer, der opstår, før din kode overhovedet kører, f.eks. tilladelsesfejl eller grænser for størrelsen på nyttedata. De vises måske ikke direkte i din funktions logfiler.
Fejl på grund af tidsudløb: Din funktion overskred den konfigurerede udførelsestid.

CloudWatch-målepunkter og X-Ray (i en anden lektion!) hjælper med at identificere disse.

Sporing af anmodningsforløb

I komplekse serverløse applikationer kan en enkelt anmodning involvere flere Lambda-funktioner, API Gateway, SQS, DynamoDB og meget mere.

Det er afgørende for fejlfindingen at forstå en anmodnings forløb på tværs af disse tjenester. Brug Request ID (som ofte videresendes som x-amzn-RequestId eller tilsvarende) til at sammenkæde logfiler på tværs af forskellige komponenter.

AWS X-Ray (som gennemgås i en senere lektion) giver visuel sporing til dette formål.

Bedste praksis for fejlfinding

For at minimere besværet med fejlfinding bør du følge disse fremgangsmåder:

Omfattende logføring: Log input, output og vigtige variabeltilstande.
Struktureret logføring: Brug JSON-logfiler, så de er nemmere at fortolke og forespørge på.
Idempotens: Design funktioner, så de giver det samme resultat, selv hvis de påkaldes flere gange.
Små funktioner: De er nemmere at isolere og teste.
Automatiserede tests: Enheds- og integrationstests fanger problemer tidligt.

Fejlfindingsudfordring

Du har en Lambda-funktion, der behandler brugerregistrering. Brugere fortæller, at deres registrering sommetider mislykkes, men du kan ikke se nogen "ERROR"-meddelelser i CloudWatch Logs for din Lambda-funktion.

Hvad er den mest sandsynlige årsag til dette, og hvor bør du undersøge først?

Besvar den i den interaktive lektion

Opsamling: Fejlfinding af serverløse systemer

Vi har gennemgået vigtige teknikker til fejlfinding i dine serverløse applikationer:

Lokal test med SAM CLI, så du hurtigt kan iterere.
Brug af CloudWatch Logs til at analysere funktioners adfærd og identificere fejl.
Brug af logmeddelelser til at spore udførelsesforløbet.
Forståelse af forskellige typer Lambda-fejl.
Bedste praksis til at bygge serverløse funktioner, der er nemme at fejlfinde.

Når du mestrer disse teknikker, bliver du markant bedre til at bygge robuste serverløse applikationer.

Gratis at komme i gang

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Fejlfinding af serverless-applikationer” gratis?

Ja — hele teksten til “Fejlfinding af serverless-applikationer” 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 “Fejlfinding af serverless-applikationer”?

Opdag teknikker til effektiv fejlfinding af Lambda-funktioner, herunder lokal test, fjernfejlfinding og fortolkning af CloudWatch-logge for at løse problemer. 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 “Fejlfinding af serverless-applikationer”?

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

CloudWatch-logge og -målepunkter
Fejlhåndtering og gentagelser
Fejlfinding af serverless-applikationer
Brugerdefinerede målinger og CloudWatch-alarmer

← Tilbage til Serverløs udvikling med AWS Lambda