Felsökning av serverless-applikationer
Upptäck tekniker för effektiv felsökning av Lambda-funktioner, inklusive lokal testning, fjärrfelsökning och tolkning av CloudWatch-loggar för att lösa problem
Felsökning av serverless-applikationer är en gratis lektion i Serverlös utveckling med AWS Lambda på CoddyKit. Detta är lektion 3 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.
Introduktion till felsökning av Lambda
Felsökning av serverlösa applikationer, särskilt AWS Lambda-funktioner, innebär unika utmaningar. Till skillnad från traditionella applikationer är Lambda-funktioner tillståndslösa och kortlivade.
I den här lektionen utforskar vi praktiska tekniker för att effektivt identifiera och lösa problem i era Lambda-funktioner, från lokal testning till tolkning av loggar.
Varför felsökning av serverlösa system är unik
Traditionell felsökning innebär ofta att stegvis gå igenom koden rad för rad med hjälp av en IDE. Med Lambda är detta inte alltid enkelt, eftersom:
- Transient natur: Funktioner körs endast när de anropas och försvinner sedan.
- Tillståndslöshet: Det finns inget beständigt minne mellan anrop.
- Distribuerade system: Problem kan uppstå genom samspel mellan många tjänster.
Vi förlitar oss i hög grad på loggar, mätvärden och tracing för att förstå vad som händer.
Lokal testning med SAM CLI
Ett av de mest effektiva sätten att felsöka är att testa Lambda-funktionerna lokalt innan ni distribuerar dem till AWS.
AWS Serverless Application Model (SAM) CLI låter er anropa Lambda-funktionerna på den lokala datorn och simulera körningsmiljön i AWS Lambda.
- Snabbare återkopplingsloop.
- Använd era välbekanta lokala felsökningsverktyg.
Demo: lokalt anrop med SAM CLI
Här är en enkel Python-Lambda-funktion. Vid lokal testning kan ni simulera en händelse och en kontext. Prova att köra 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 för felsökning
När Lambda har distribuerats blir Amazon CloudWatch Logs ert främsta verktyg för att förstå funktionens beteende och felsöka problem.
Varje gång Lambda-funktionen anropas skickas loggar till en särskild logggrupp. Varje anrop får ett unikt Request ID, som hjälper till att spåra körningen.
- Log Groups: Innehåller loggar för en specifik funktion.
- Log Streams: Specifika instanser av funktionens loggar.
Hitta problem i loggar
När ett fel uppstår är CloudWatch Logs den första platsen ni bör kontrollera. Ni kan:
- Filter Logs: Söka efter nyckelord som "ERROR", "Exception" eller specifika meddelanden.
- Log Insights: Använda ett kraftfullt frågespråk för att analysera loggar, gruppera fel och identifiera trender.
- Request ID: Använda Request ID från anropet för att hitta alla loggar som hör till en specifik körning.
Kontrollera alltid hela stackspårningen för detaljerad information om felet.
Felsökning med loggmeddelanden
Den enklaste men samtidigt mest kraftfulla felsökningstekniken för Lambda är att använda satser med print() (Python) eller console.log() (Node.js).
Genom att lägga till loggmeddelanden på strategiska platser kan ni följa variabelvärden, körningsvägar och funktionens tillstånd vid olika tidpunkter i koden. Här är ett exempel:
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))
Förstå anropsfel
Lambda-funktioner kan misslyckas av flera olika orsaker. Det är viktigt att skilja mellan olika feltyper:
- Function Errors: Koden kastade ett ohanterat undantag. Dessa fel visas i CloudWatch Logs med en stackspårning.
- Invocation Errors: Problem som uppstår innan koden ens körs, till exempel behörighetsfel eller gränser för nyttolastens storlek. De kanske inte ens visas direkt i funktionens loggar.
- Timeout Errors: Funktionen överskred den konfigurerade körtiden.
CloudWatch-mätvärden och X-Ray (i en annan lektion!) hjälper till att identifiera dessa problem.
Spåra anropsflödet
I komplexa serverlösa applikationer kan ett enda anrop involvera flera Lambda-funktioner, API Gateway, SQS, DynamoDB med mera.
Att förstå hur ett anrop flödar genom dessa tjänster är avgörande för felsökning. Använd Request ID (som ofta vidarebefordras som x-amzn-RequestId eller liknande) för att korrelera loggar mellan olika komponenter.
AWS X-Ray (som behandlas i en senare lektion) tillhandahåller visuell spårning för detta.
Metodtips för felsökning
Följ dessa metoder för att minska problemen med felsökning:
- Omfattande loggning: Logga indata, utdata och viktiga variabeltillstånd.
- Strukturerad loggning: Använd JSON-loggar för enklare tolkning och frågningar.
- Idempotens: Utforma funktioner så att de ger samma resultat även om de anropas flera gånger.
- Små funktioner: De är enklare att isolera och testa.
- Automatiserade tester: Enhets- och integrationstester upptäcker problem tidigt.
Felsökningsutmaning
Ni har en Lambda-funktion som behandlar användarregistrering. Användare rapporterar att registreringen ibland misslyckas, men ni ser inga meddelanden med "ERROR" i CloudWatch Logs för Lambda-funktionen.
Vad är den mest sannolika orsaken, och var bör ni undersöka först?
Sammanfattning: Felsökning av serverlösa system
Vi har gått igenom viktiga tekniker för felsökning av era serverlösa applikationer:
- Lokal testning med SAM CLI för snabb iteration.
- Användning av CloudWatch Logs för att analysera funktioners beteende och identifiera fel.
- Användning av loggmeddelanden för att följa körningsflödet.
- Förståelse för olika typer av Lambda-fel.
- Bästa praxis för att bygga serverlösa funktioner som är enkla att felsöka.
När ni behärskar detta förbättras er förmåga att bygga robusta serverlösa applikationer avsevärt.
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
Vanliga frågor
Är lektionen ”Felsökning av serverless-applikationer” gratis?
Ja – hela texten till ”Felsökning av serverless-applikationer” 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 ”Felsökning av serverless-applikationer”?
Upptäck tekniker för effektiv felsökning av Lambda-funktioner, inklusive lokal testning, fjärrfelsökning och tolkning av CloudWatch-loggar för att lösa problem 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 3 av 4.
Hur lång tid tar lektionen ”Felsökning av serverless-applikationer”?
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
- CloudWatch-loggar och mätvärden
- Felhantering och nya försök
- Felsökning av serverless-applikationer
- Anpassade mätvärden och CloudWatch-aviseringar