Serverloze backend met AWS Lambda en API Gateway · Les

API- en bedrijfslogica implementeren

Ontwikkel de Lambda-functies en API Gateway-configuraties die de kernbedrijfslogica van uw serverless microservice aandrijven.

Les 2 van 411 stappen

API- en bedrijfslogica implementeren is een gratis Serverloze backend met AWS Lambda en API Gateway-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Serverloze backend met AWS Lambda en API Gateway. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Serverloze backend met AWS Lambda en API Gateway bevat in totaal 4 lessen.

Van ontwerp naar implementatie

In de vorige les hebben we een serverloze microservice ontworpen. Nu is het tijd om dat ontwerp tot leven te brengen!

In deze les ligt de nadruk op het ontwikkelen van de daadwerkelijke Lambda-functies en het configureren van API Gateway om de kernlogica van je microservice uit te voeren.

API Gateway: de voordeur van de microservice

API Gateway fungeert als het beveiligde toegangspunt voor je serverloze microservice. Het ontvangt HTTP-aanvragen en stuurt deze door naar de juiste backendservice, meestal een AWS Lambda-functie.

Het definieert de eindpunten van je API (paden en methoden).
Het handelt aanvraagvalidatie en routering af.
Het integreert rechtstreeks met Lambda-functies.

Lambda: de kern van de bedrijfslogica

Je Lambda-functies bevatten de daadwerkelijke bedrijfslogica van je microservice. Elke functie handelt doorgaans een specifiek API-eindpunt en een specifieke bewerking af (bijvoorbeeld GET /products/{id} of POST /products).

Wanneer API Gateway een Lambda-functie activeert, geeft het alle aanvraaggegevens door in een event-object.

Het Lambda-gebeurtenisobject begrijpen

Wanneer je Lambda Proxy Integration met API Gateway gebruikt, bevat het event-object dat aan je Lambda-functie wordt doorgegeven uitgebreide details over de binnenkomende HTTP-aanvraag.

httpMethod: De HTTP-methode (GET, POST, PUT, DELETE).
pathParameters: Eventuele variabelen uit het URL-pad.
queryStringParameters: Parameters uit de querytekenreeks van de URL.
body: De hoofdtekst van de aanvraag (als JSON-tekenreeks).

Een GET-API-eindpunt implementeren

Laten we een eenvoudige Lambda-functie maken om een GET-aanvraag af te handelen, bijvoorbeeld om een product op basis van zijn ID op te halen. We halen de product_id uit pathParameters.

Probeer dit voorbeeld uit te voeren:

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"})
        }

API-antwoorden samenstellen

Je Lambda-functie moet een specifieke JSON-structuur retourneren, zodat API Gateway het antwoord correct kan verwerken en naar de client kan terugsturen. Dit is cruciaal voor consistent API-gedrag.

statusCode: De HTTP-statuscode (bijvoorbeeld 200 voor succes en 400 voor een ongeldige aanvraag).
headers: Een woordenboek met HTTP-headers (bijvoorbeeld 'Content-Type': 'application/json').
body: De daadwerkelijke antwoordgegevens, die een JSON-tekenreeks moeten zijn.

Een POST-API-eindpunt implementeren

Laten we nu kijken hoe je een POST-aanvraag afhandelt, die doorgaans wordt gebruikt om nieuwe resources te maken. Hier parseren we de body van de aanvraag om de gegevens van het nieuwe product op te halen.

Probeer dit voorbeeld uit te voeren (stel je een POST-aanvraag voor met {"name": "New Item", "price": 10.50} als hoofdtekst):

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"})
        }

Robuuste foutafhandeling in Lambda

Goede API’s geven duidelijke foutmeldingen. In Lambda moet je mogelijke problemen opvangen en passende HTTP-statuscodes en gedetailleerde foutgegevens retourneren.

Clientfouten (4xx): Ongeldige invoer of ontbrekende parameters.
Serverfouten (5xx): Onverwachte problemen in je Lambda-functie of downstreamservices.

Retourneer altijd een consistente foutstructuur, zodat fouten eenvoudiger aan de clientzijde kunnen worden afgehandeld.

API Gateway configureren voor integratie

Nadat je je Lambda-functies hebt geschreven, moet je API Gateway configureren om ze te activeren. Dit houdt het volgende in:

Een API Gateway-resource maken (bijvoorbeeld /products).
Een HTTP-methode (bijvoorbeeld GET of POST) aan die resource toevoegen.
Het integratietype instellen op Lambda Proxy.
De ARN van de doel-Lambda-functie opgeven.

Hiermee maak je de verbinding tussen je API-eindpunt en de bedrijfslogica van je functie.

Uitdaging: API-logica

Stel je een Lambda-functie voor die het profiel van een gebruiker bijwerkt. Als de hoofdtekst van de aanvraag leeg is, welke HTTP-statuscode moet de Lambda-functie dan retourneren om een fout aan de clientzijde aan te geven?

Beantwoord dit in de interactieve les

Samenvatting van de les

Je hebt geleerd hoe je de kern van de API en de bedrijfslogica voor een serverloze microservice implementeert! We hebben het volgende behandeld:

De rollen van API Gateway en Lambda in een microservice.
Gegevens uit het Lambda-event-object halen voor verschillende HTTP-methoden.
Correcte antwoorden samenstellen die compatibel zijn met API Gateway.
Het belang van robuuste foutafhandeling.
Een korte uitleg van het configureren van API Gateway om je Lambda-functies te activeren.

Je bent nu klaar om functionele serverloze API-eindpunten te bouwen!

Gratis beginnen

Leer Serverloze backend met AWS Lambda en API Gateway met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “API- en bedrijfslogica implementeren” gratis?

Ja — de volledige tekst van “API- en bedrijfslogica implementeren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Serverloze backend met AWS Lambda en API Gateway wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Serverloze backend met AWS Lambda en API Gateway bevat in totaal 4 lessen.

Wat leer ik in “API- en bedrijfslogica implementeren”?

Ontwikkel de Lambda-functies en API Gateway-configuraties die de kernbedrijfslogica van uw serverless microservice aandrijven. Je oefent met Serverloze backend met AWS Lambda en API Gateway door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Serverloze backend met AWS Lambda en API Gateway te beginnen?

Ervaring vooraf is niet nodig. Serverloze backend met AWS Lambda en API Gateway op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “API- en bedrijfslogica implementeren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Serverloze backend met AWS Lambda en API Gateway?

Ja. Elke les over Serverloze backend met AWS Lambda en API Gateway bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Serverloze backend met AWS Lambda en API Gateway