Lambda-utløsere og integrasjoner
Koble Lambda-funksjoner til ulike AWS-tjenester som S3, DynamoDB og API Gateway for å lage effektive, hendelsesdrevne arbeidsflyter.
Lambda-utløsere og integrasjoner er en gratis leksjon i AWS for backendutviklere (EC2, S3, RDS, Lambda) på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AWS for backendutviklere (EC2, S3, RDS, Lambda), og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AWS for backendutviklere (EC2, S3, RDS, Lambda) inneholder totalt 4 leksjoner.
Hendelser gir Lambda liv
Velkommen til kjernen i serverless-arkitektur: Lambda-utløsere! Dette er hendelsene som forteller Lambda-funksjonen når den skal kjøre. I stedet for at en server kjører hele tiden, aktiveres funksjonen bare når det er behov for den.
Tenk på det som en ringeklokke for koden Deres. Noen trykker på knappen (en hendelse oppstår), og funksjonen svarer.
Slik fungerer utløsere: push kontra pull
Lambda-utløsere fungerer hovedsakelig på to måter:
- Push-basert: Hendelseskilden (for eksempel S3 eller SNS) kaller Lambda-funksjonen direkte når en hendelse oppstår. Lambda mottar hendelsen og kjører koden Deres.
- Pull-basert: Lambda spør selv en hendelseskilde (for eksempel SQS-køer eller DynamoDB Streams) etter nye elementer. Når nye data blir funnet, henter Lambda dem og kaller funksjonen Deres.
Dette hjelper Dem med å utforme effektive hendelsesdrevne arbeidsflyter.
S3-hendelsesutløsere: Reager på lagring
En av de vanligste og mest kraftige utløserne er Amazon S3. De kan konfigurere en S3-bøtte til automatisk å kalle en Lambda-funksjon når bestemte hendelser oppstår, for eksempel:
- Nytt objekt opprettet (for eksempel et opplastet bilde)
- Objekt slettet
- Objekt gjenopprettet
Dette passer perfekt til oppgaver som endring av bildestørrelse, datavalidering eller generering av miniatyrbilder så snart en fil lastes opp.
S3-utløserdemo: Loggføring av opplastinger
Her er en grunnleggende Python Lambda-funksjon som utløses av en hendelse der et S3-objekt opprettes. Den logger ganske enkelt bøtten og objektnøkkelen fra hendelsesdataene.
Prøv å kjøre den simulerte hendelsen:
import json
def lambda_handler(event, context):
"""
Simulated Lambda handler for S3 events.
Logs the details of the S3 event.
"""
print("--- S3 Event Received ---")
for record in event.get('Records', []):
bucket_name = record['s3']['bucket']['name']
object_key = record['s3']['object']['key']
event_name = record['eventName']
print(f"Bucket: {bucket_name}")
print(f"Object: {object_key}")
print(f"Event: {event_name}")
print("-------------------------")
return {
'statusCode': 200,
'body': json.dumps('S3 event logged!')
}
if __name__ == "__main__":
# Simulate an S3 PUT event
mock_event = {
"Records": [
{
"eventSource": "aws:s3",
"eventName": "ObjectCreated:Put",
"s3": {
"bucket": {"name": "my-cool-bucket"},
"object": {"key": "my-new-file.txt"}
}
}
]
}
lambda_handler(mock_event, None)DynamoDB Streams: Databaseendringer
Amazon DynamoDB Streams gir en tidsordnet sekvens av endringer på elementnivå i en DynamoDB-tabell. Når De aktiverer en stream, registreres alle opprettings-, oppdaterings- og sletteoperasjoner.
Lambda kan konfigureres til å lese fra disse streamene, slik at De kan reagere på databaseendringer i sanntid. Bruksområder omfatter:
- Datareplikering på tvers av tabeller
- Revisjon av endringer
- Utløsing av etterfølgende arbeidsflyter
DynamoDB Stream-demo: Behandle oppdateringer
Denne Python Lambda-funksjonen simulerer behandling av hendelser fra en DynamoDB Stream. Den logger hendelsestypen (INSERT, MODIFY, REMOVE) og nøklene eller det nye bildet av det berørte elementet.
Kjør den for å se hvordan en databaseendring ser ut:
import json
def lambda_handler(event, context):
"""
Simulated Lambda handler for DynamoDB Stream events.
Logs the details of the changed records.
"""
print("--- DynamoDB Stream Event Received ---")
for record in event.get('Records', []):
event_name = record['eventName']
keys = record['dynamodb']['Keys']
new_image = record['dynamodb'].get('NewImage', {})
print(f"Event: {event_name}")
print(f"Keys: {json.dumps(keys)}")
print(f"New Image: {json.dumps(new_image)}")
print("------------------------------------")
return {
'statusCode': 200,
'body': json.dumps('DynamoDB stream processed!')
}
if __name__ == "__main__":
# Simulate a DynamoDB INSERT event
mock_event = {
"Records": [
{
"eventID": "1",
"eventName": "INSERT",
"dynamodb": {
"Keys": {"id": {"S": "123"}},
"NewImage": {"id": {"S": "123"}, "name": {"S": "Alice"}},
"StreamViewType": "NEW_AND_OLD_IMAGES"
}
}
]
}
lambda_handler(mock_event, None)API Gateway: Serverless API-endepunkter
Amazon API Gateway fungerer som en «inngangsdør» for applikasjoner som skal få tilgang til backend-tjenester, inkludert Lambda-funksjoner. Den håndterer alle oppgavene som kreves for å ta imot og behandle opptil hundretusenvis av samtidige API-kall.
Ved å integrere API Gateway med Lambda kan De bygge kraftige, skalerbare og sikre RESTful API-er uten å administrere servere. Brukere sender en HTTP-forespørsel, API Gateway ruter den til Lambda, og Lambda returnerer et svar.
API Gateway-demo: Deres serverless-API
Denne Lambda-funksjonen viser hvordan De svarer på en API Gateway-forespørsel. Den mottar hendelsesdata om HTTP-forespørselen og returnerer et JSON-svar, som API Gateway deretter sender tilbake til klienten.
Kjør simuleringen for å se det forventede resultatet:
import json
def lambda_handler(event, context):
"""
Simulated Lambda handler for API Gateway events.
Returns a simple JSON response.
"""
print("--- API Gateway Event Received ---")
print(f"HTTP Method: {event.get('httpMethod')}")
print(f"Path: {event.get('path')}")
print("----------------------------------")
response_body = {
"message": "Hello from your serverless API!",
"input": event
}
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json'
},
'body': json.dumps(response_body)
}
if __name__ == "__main__":
# Simulate an API Gateway GET request event
mock_event = {
"resource": "/",
"path": "/",
"httpMethod": "GET",
"headers": {
"Accept": "text/html"
},
"queryStringParameters": None,
"pathParameters": None,
"body": None,
"isBase64Encoded": False
}
response = lambda_handler(mock_event, None)
print("\n--- API Response ---")
print(json.dumps(response, indent=2))Mer kraftfulle integrasjoner
Lambda kan integreres med mange andre AWS-tjenester for å bygge svært fleksible arkitekturer:
- Amazon SQS: Behandle meldinger fra en kø for asynkrone oppgaver.
- Amazon SNS: Svar på varsler (for eksempel ved å sende e-post eller SMS).
- CloudWatch Events/EventBridge: Utløs Lambda-funksjoner etter en tidsplan eller som svar på hendelser fra AWS-tjenester (for eksempel en endring i tilstanden til en EC2-instans).
- Kinesis: Behandle datastrømmer i sanntid.
Disse integrasjonene utgjør ryggraden i moderne, hendelsesdrevne applikasjoner.
Kunnskapssjekk
Test kunnskapen Deres om Lambda-utløsere!
Oppsummering: Hjertet i serverless-arbeidsflyter
De har lært at Lambda-funksjoner er kraftige, men at de trenger utløsere for å komme til liv! Disse utløserne er hendelser fra andre AWS-tjenester som automatisk kaller funksjonen Deres.
Vi utforsket hvordan S3, DynamoDB Streams og API Gateway kan fungere som direkte hendelseskilder, slik at De kan bygge responsive, hendelsesdrevne applikasjoner uten å administrere servere. Å forstå utløsere er avgjørende for å utnytte det fulle potensialet i serverless-arkitektur!
Lær deg AWS for backendutviklere (EC2, S3, RDS, Lambda) med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Lambda-utløsere og integrasjoner» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien AWS for backendutviklere (EC2, S3, RDS, Lambda), inkludert «Lambda-utløsere og integrasjoner», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i AWS for backendutviklere (EC2, S3, RDS, Lambda) inneholder totalt 4 leksjoner.
Hva lærer jeg i «Lambda-utløsere og integrasjoner»?
Koble Lambda-funksjoner til ulike AWS-tjenester som S3, DynamoDB og API Gateway for å lage effektive, hendelsesdrevne arbeidsflyter. Du øver på AWS for backendutviklere (EC2, S3, RDS, Lambda) med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med AWS for backendutviklere (EC2, S3, RDS, Lambda)?
Ingen tidligere erfaring er nødvendig. AWS for backendutviklere (EC2, S3, RDS, Lambda) på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Lambda-utløsere og integrasjoner»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne AWS for backendutviklere (EC2, S3, RDS, Lambda)-leksjonen?
Ja. Alle AWS for backendutviklere (EC2, S3, RDS, Lambda)-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Hva er AWS Lambda?
- Bygge din første Lambda-funksjon
- Lambda-utløsere og integrasjoner
- Overvåking og feilsøking av Lambda-funksjoner