Cloud & IT Cert Prep · Lektion

Integrationer: Lambda, HTTP och Mock

Koppla API Gateway-metoder till Lambda-proxyintegrationer, uppströms-HTTP-slutpunkter och mock-integrationer för testning.

Lektion 2 av 413 steg

Integrationer: Lambda, HTTP och Mock är en gratis lektion i Cloud & IT Cert Prep 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 Cloud & IT Cert Prep, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Cloud & IT Cert Prep innehåller totalt 4 lektioner.

Översikt över integrationstyper i API Gateway

Varje API Gateway-metod behöver en backendintegration—det system som bearbetar begäran och returnerar ett svar. API Gateway stöder fem integrationstyper: Lambda Proxy, Lambda Custom, HTTP Proxy, HTTP Custom och Mock. HTTP API:er stöder endast Lambda Proxy och HTTP Proxy. REST API:er stöder alla fem. Valet av integration avgör hur mycket kontroll ni har över transformeringen av begäran och svaret.

Lambda Proxy-integration

Med integrationen Lambda Proxy skickar API Gateway hela HTTP-begäran till Lambda som ett strukturerat händelseobjekt med bland annat headers, frågesträngar, sökvägsparametrar, brödtext och kontext. Er Lambda-funktion ansvarar för att returnera ett korrekt formaterat svarsobjekt med statusCode, headers och body. Detta är det enklaste och vanligaste mönstret—inga mappningsmallar behövs och Lambda styr hela svaret.

def lambda_handler(event, context):
    # event.httpMethod, event.path, event.queryStringParameters
    # event.headers, event.body
    user_id = event['pathParameters']['userId']
    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': '{"userId": "' + user_id + '", "name": "Alice"}'
    }

Lambda Non-Proxy (anpassad) integration

Med Lambda Non-Proxy (anpassad integration) använder API Gateway mappningsmallar (Apache Velocity Template Language, VTL) för att transformera begäran innan den skickas till Lambda och transformerar Lambdas svar innan det returneras till klienten. Er Lambda-funktion tar emot en ren, anpassad nyttolast—inte det råa API Gateway-händelseobjektet. Detta separerar transportrelaterade aspekter från affärslogiken, men kräver att VTL-mallar underhålls. Använd anpassad integration när ni vill ha en strikt separering mellan API- och backendkontrakt.

## Integration Request Mapping Template (VTL)
#set($inputRoot = $input.path('$'))
{
  'userId': '$input.params('userId')',
  'action': '$inputRoot.action',
  'timestamp': '$context.requestTime'
}

HTTP Proxy-integration

Integrationen HTTP Proxy vidarebefordrar begäranden direkt till en extern HTTP-endpoint (det kan vara en EC2-instans, en ALB, en lokal server eller valfri offentlig URL) utan transformering. API Gateway skickar begäran vidare och returnerar backendens svar till klienten. Detta passar bra när ni vill migrera befintliga REST-backendservrar bakom API Gateway för att lägga till throttling, övervakning och API-nycklar utan att ändra backendkoden. HTTPS-backendservrar med certifikatverifiering stöds.

# Create HTTP proxy integration via REST API
aws apigateway put-integration \
  --rest-api-id 'abc123' \
  --resource-id 'xyz789' \
  --http-method GET \
  --type HTTP_PROXY \
  --integration-http-method GET \
  --uri 'https://my-backend.example.com/api/users/{userId}'

HTTP Custom (Non-Proxy)-integration

Integrationen HTTP Custom vidarebefordrar också begäranden till en extern HTTP-endpoint, men använder mappningsmallar för att transformera både begäran till backendservern och svaret därifrån. Detta är användbart när API Gateway-gränssnittet och backend-API:t har olika kontrakt—ni kan översätta ett REST API-anrop till ett äldre SOAP-format eller ett anpassat format och transformera backendsvaret till en ren JSON-struktur för klienten. Detta ökar komplexiteten men ger störst kontroll vid integrationer med äldre system.

AWS-tjänsteintegration

Integrationen AWS Service ansluter API Gateway direkt till AWS-tjänster utan en mellanliggande Lambda-funktion. Ni kan till exempel konfigurera en POST-endpoint som direkt skriver ett meddelande till SQS, publicerar till SNS eller startar en Step Functions-körning. Detta minskar latensen och eliminerar kostnader för Lambda-funktioner vid enkla routningsåtgärder. Integrationen kräver IAM-rollkonfiguration och mappningsmallar för att formatera AWS API-anropet korrekt.

# Direct API Gateway → SQS integration
# Integration Request URI:
https://sqs.us-east-1.amazonaws.com/123456789012/MyQueue

# Integration Request Body Mapping Template:
Action=SendMessage&MessageBody=$input.body

Mockintegration för utveckling och testning

Mockintegration konfigurerar API Gateway så att en fördefinierad respons returneras utan att någon backend anropas. Du definierar responsen i mallen för integrationsresponsens mappning. Mockintegrationer passar perfekt för: API-utveckling innan backend är byggd (frontendteamen kan börja direkt), enhetstestning av API-konfigurationer, returnering av standardiserade CORS-rubriker eller tillhandahållande av en stub för tredjepartspartner under utvecklingen. Mockendpoints kan också användas för att blockera utfasade API-versioner genom att returnera 410 Gone.

# Integration Response for Mock
# Integration Response Mapping Template:
{
  'statusCode': 200,
  'message': 'This is a mock response',
  'timestamp': '$context.requestTime'
}

# Method Response: map status code 200 to this template

CORS-konfiguration i API Gateway

CORS (Cross-Origin Resource Sharing) måste aktiveras när en webbläsarklient på en domän anropar ditt API på en annan domän. HTTP API har en CORS-konfiguration med ett klick; för REST API måste du skapa en OPTIONS-metod med en Mock-integration som returnerar de CORS-rubriker som krävs (Access-Control-Allow-Origin, Access-Control-Allow-Methods, Access-Control-Allow-Headers). Lambda-proxyintegration kräver också att din Lambda-funktion returnerar CORS-rubriker i sin respons.

# HTTP API CORS config (simple)
aws apigatewayv2 update-api \
  --api-id 'abc123' \
  --cors-configuration '{
    "AllowOrigins": ["https://myapp.example.com"],
    "AllowMethods": ["GET", "POST", "OPTIONS"],
    "AllowHeaders": ["Content-Type", "Authorization"]
  }'

Validering av begäranden i REST API

REST API stöder validering av begäranden: API Gateway kan kontrollera att obligatoriska frågesträngsparametrar, rubriker och schemat för begärandekroppen finns och har korrekt format – innan backend anropas. Detta minskar onödiga Lambda-anrop till följd av felaktigt formaterade begäranden och returnerar automatiskt standardiserade 400-fel. Definiera en begärandemodell med JSON Schema och koppla den till metoden för att aktivera validering av begärandekroppen. Validering av begäranden är inte tillgänglig i HTTP API.

Tidsgränser för integrationer

API Gateway har en standardtidgräns för integrationer på 29 sekunder för REST API och HTTP API (maximalt värde för REST API, fast värde för HTTP API-proxy). Om din backend tar längre tid än 29 sekunder returnerar API Gateway felet 504 Gateway Timeout. Det innebär att Lambda-funktioner som anropas synkront via API Gateway måste slutföras inom 29 sekunder – även om Lambda i sig stöder tidsgränser på 15 minuter. För långvariga åtgärder använder du ett asynkront mönster: API Gateway utlöser Lambda, som startar ett asynkront jobb och omedelbart returnerar ett jobb-ID.

Välja rätt integrationstyp

Vägledning för val av integrationstyp: Lambda Proxy: vanligast och enklast, med full kontroll över begäran i Lambda; Lambda Custom: när du behöver transformera begäran eller responsen i gatewaylagret; HTTP Proxy: för befintliga HTTP-backendservrar och migreringsscenarier; HTTP Custom: för översättning av äldre API-format; AWS Service: för att eliminera Lambda vid enkel dirigering till SQS/SNS/DynamoDB; Mock: för utvecklingsstubbar och CORS-förfrågningar före kontroll. För SAA-C03-provet är Lambda Proxy och HTTP Proxy de vanligaste mönstren som testas.

Snabbtest

Testa dina kunskaper om AWS Solutions Architect-koncepten (SAA-C03) från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen lärde du dig följande: Integrationen Lambda Proxy skickar hela begäran till Lambda, som styr responsen – den enklaste och vanligaste integrationen. HTTP Proxy vidarebefordrar begäranden till befintliga HTTP-backendservrar så att du kan lägga till API Gateway-funktioner utan att ändra backend. Mockintegration returnerar fördefinierade responser för frontendutveckling och testning utan någon backendinfrastruktur. Nästa gång utforskar vi auktorisering i API Gateway med IAM, Lambda-auktoriserare och Cognito.

Gratis att börja

Lär dig Cloud & IT Cert Prep 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: 150
Lektioner: 600

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Integrationer: Lambda, HTTP och Mock” gratis?

Ja – hela texten till ”Integrationer: Lambda, HTTP och Mock” 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 Cloud & IT Cert Prep, kan Ni uppgradera till CoddyKit PRO. Kursen i Cloud & IT Cert Prep innehåller totalt 4 lektioner.

Vad lär jag mig i ”Integrationer: Lambda, HTTP och Mock”?

Koppla API Gateway-metoder till Lambda-proxyintegrationer, uppströms-HTTP-slutpunkter och mock-integrationer för testning. Ni övar på Cloud & IT Cert Prep 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 Cloud & IT Cert Prep?

Du behöver inga förkunskaper. Utbildningen i Cloud & IT Cert Prep 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 ”Integrationer: Lambda, HTTP och Mock”?

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 Cloud & IT Cert Prep-lektionen?

Ja. Varje Cloud & IT Cert Prep-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

REST API jämfört med HTTP API och WebSocket API
Integrationer: Lambda, HTTP och Mock
Auktorisering: IAM, Lambda Authorizers och Cognito
Strypning, cachning och användningsplaner

← Tillbaka till Cloud & IT Cert Prep