Serverlös backend med AWS Lambda & API Gateway · Lektion

Implementera API och affärslogik

Utveckla Lambda-funktionerna och API Gateway-konfigurationerna som utgör kärnan i Er serverless-mikrotjänsts affärslogik.

Lektion 2 av 411 steg

Implementera API och affärslogik är en gratis lektion i Serverlös backend med AWS Lambda & API Gateway på CoddyKit. Detta är lektion 2 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 backend med AWS Lambda & API Gateway, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Serverlös backend med AWS Lambda & API Gateway innehåller totalt 4 lektioner.

Från design till implementation

I föregående lektion utformade vi en serverlös mikrotjänst. Nu är det dags att förverkliga den designen!

Den här lektionen fokuserar på att utveckla de faktiska Lambda-funktionerna och konfigurera API Gateway för att driva mikrotjänstens centrala affärslogik.

API Gateway: mikrotjänstens ytterdörr

API Gateway fungerar som den säkra ingångspunkten för Er serverlösa mikrotjänst. Den tar emot HTTP-begäranden och dirigerar dem till rätt backend-tjänst, vanligtvis en AWS Lambda-funktion.

Den definierar API:ets slutpunkter (sökvägar och metoder).
Den hanterar validering och dirigering av begäranden.
Den integreras direkt med Lambda-funktioner.

Lambda: kärnan för affärslogiken

Era Lambda-funktioner innehåller mikrotjänstens faktiska affärslogik. Varje funktion hanterar vanligtvis en specifik API-slutpunkt och åtgärd (t.ex. GET /products/{id}, POST /products).

När API Gateway utlöser en Lambda-funktion skickar den alla detaljer om begäran i ett event-objekt.

Förstå Lambda-eventobjektet

När Ni använder Lambda Proxy Integration med API Gateway innehåller event-objektet som skickas till Er Lambda-funktion omfattande information om den inkommande HTTP-begäran.

httpMethod: HTTP-metoden (GET, POST, PUT, DELETE).
pathParameters: Variabler från URL-sökvägen.
queryStringParameters: Parametrar från URL:ens frågesträng.
body: Begärans body (som en JSON-sträng).

Implementera en GET-API-slutpunkt

Låt oss skapa en enkel Lambda-funktion som hanterar en GET-begäran, till exempel för att hämta en produkt efter dess ID. Vi extraherar product_id från pathParameters.

Prova att köra det här exemplet:

import json

def lambda_handler(event, context):
    product_id = None
    if event.get('pathParameters'):
        product_id = event['pathParameters'].get('id')

    if product_id:
        # In a real app, you'd fetch from a DB
        product_data = {
            "id": product_id,
            "name": f"Sample Product {product_id}",
            "price": 29.99
        }
        return {
            "statusCode": 200,
            "headers": { "Content-Type": "application/json" },
            "body": json.dumps(product_data)
        }
    else:
        return {
            "statusCode": 400,
            "headers": { "Content-Type": "application/json" },
            "body": json.dumps({"message": "Missing product ID"})
        }

Utforma API-svar

Er Lambda-funktion måste returnera en specifik JSON-struktur för att API Gateway ska kunna behandla svaret korrekt och skicka tillbaka det till klienten. Detta är avgörande för ett konsekvent API-beteende.

statusCode: HTTP-statuskoden (t.ex. 200 vid lyckat resultat och 400 vid en felaktig begäran).
headers: En ordlista med HTTP-headers (t.ex. 'Content-Type': 'application/json').
body: De faktiska svarsdata som måste vara en JSON-sträng.

Implementera en POST-API-slutpunkt

Nu ska vi titta på hur en POST-begäran hanteras, vilket vanligtvis används för att skapa nya resurser. Här tolkar vi begärans body för att hämta informationen om den nya produkten.

Prova att köra det här exemplet (föreställ Er en POST-begäran med {"name": "New Item", "price": 10.50} som body):

import json

def lambda_handler(event, context):
    if event.get('body'):
        try:
            request_body = json.loads(event['body'])
            product_name = request_body.get('name')
            product_price = request_body.get('price')

            # In a real app, you'd save to a DB and get an ID
            new_product = {
                "id": "new-prod-123",
                "name": product_name,
                "price": product_price
            }
            return {
                "statusCode": 201, # 201 Created
                "headers": { "Content-Type": "application/json" },
                "body": json.dumps(new_product)
            }
        except json.JSONDecodeError:
            return {
                "statusCode": 400,
                "headers": { "Content-Type": "application/json" },
                "body": json.dumps({"message": "Invalid JSON in body"})
            }
    else:
        return {
            "statusCode": 400,
            "headers": { "Content-Type": "application/json" },
            "body": json.dumps({"message": "Request body is empty"})
        }

Robust felhantering i Lambda

Bra API:er ger tydliga felmeddelanden. I Lambda bör Ni fånga potentiella problem och returnera lämpliga HTTP-statuskoder samt detaljerade felbeskrivningar.

Klientfel (4xx): Felaktiga indata eller saknade parametrar.
Serverfel (5xx): Oväntade problem i Er Lambda-funktion eller i nedströms tjänster.

Returnera alltid en konsekvent felstruktur för att förenkla hanteringen på klientsidan.

Konfigurera API Gateway för integration

När Ni har skrivit Era Lambda-funktioner behöver Ni konfigurera API Gateway så att funktionerna utlöses. Det innebär att:

Skapa en API Gateway-resource (t.ex. /products).
Lägga till en HTTP-method (t.ex. GET eller POST) för resursen.
Ställa in integrationstypen till Lambda Proxy.
Ange ARN:et för den Lambda-funktion som ska användas.

Detta skapar bron mellan Er API-slutpunkt och funktionens affärslogik.

Utmaning: API-logik

Föreställ Er en Lambda-funktion som är utformad för att uppdatera en användares profil. Om begärans body är tom, vilken HTTP-statuskod bör Lambda-funktionen returnera för att ange ett klientfel?

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning

Ni har lärt Er att implementera kärn-API:et och affärslogiken för en serverlös mikrotjänst! Vi gick igenom:

Rollerna som API Gateway och Lambda har i en mikrotjänst.
Hur data extraheras från Lambdas event-objekt för olika HTTP-metoder.
Hur korrekta svar som är kompatibla med API Gateway konstrueras.
Vikten av robust felhantering.
Kortfattat hur API Gateway konfigureras för att utlösa Era Lambda-funktioner.

Ni är nu redo att bygga fungerande serverlösa API-slutpunkter!

Gratis att börja

Lär dig Serverlös backend med AWS Lambda & API Gateway 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 ”Implementera API och affärslogik” gratis?

Ja – hela texten till ”Implementera API och affärslogik” 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 backend med AWS Lambda & API Gateway, kan Ni uppgradera till CoddyKit PRO. Kursen i Serverlös backend med AWS Lambda & API Gateway innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera API och affärslogik”?

Utveckla Lambda-funktionerna och API Gateway-konfigurationerna som utgör kärnan i Er serverless-mikrotjänsts affärslogik. Ni övar på Serverlös backend med AWS Lambda & API Gateway 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 backend med AWS Lambda & API Gateway?

Du behöver inga förkunskaper. Utbildningen i Serverlös backend med AWS Lambda & API Gateway 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 2 av 4.

Hur lång tid tar lektionen ”Implementera API och affärslogik”?

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 backend med AWS Lambda & API Gateway-lektionen?

Ja. Varje Serverlös backend med AWS Lambda & API Gateway-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

← Tillbaka till Serverlös backend med AWS Lambda & API Gateway