Du kan selvfølgelig også bruge DynamoDB Streams til at udløse downstream-processerne og AWS Lambda-funktioner. Lambda er per definition en serverløs computertjeneste, der kører din kode som svar på hændelser og automatisk administrerer computerressourcerne for dig.
Du kan bruge Lambda til at skrive koden i Node.js, Python, Java eller C# til at behandle stream-posterne og foretage passende handlinger. Den største fordel ved at integrere DynamoDB Streams med Lambda er, at Lambda giver dig mulighed for at køre de understøttede tjenester eller applikationskoder uden behov for administration.
Sådan bruger du AWS DynamoDB-streams med Lambda
Selvom det er muligt at oprette en Lambda-funktion, der bruger hændelser og hændelser fra en DynamoDB-stream, kan processen være ret besværlig, især ved dit første forsøg. Følgende trin vil hjælpe:
Trin 1: Sørg for, at dit system opfylder forudsætningerne
Denne procedure vil kun lykkes, hvis du kender de grundlæggende Lambda-operationer og -processer. Derfor bør dette være din første til at sikre, at din forståelse af Lambda er over gennemsnittet.
Den anden forudsætning, der er værd at overveje, er at bekræfte dit systems AWS-version. Du kan bruge følgende kommando:
aws –version
Resultatet for den angivne kommando skulle se sådan ud:
aws-cli/ 2 .x.x Python/ 3 .x.x Linux/ 4 .x.x-xxx-std botocore/ 2 .x.xDet givne eksempelsvar indeholder den installerede version af AWS CLI ( aws-cli/2.x.x ), Python-versionen ( Python/3.x.x ), og operativsystemet ( Linux/4.x.x-xxx-std ). Den sidste del af svaret definerer Botocore-biblioteksversionen, som din AWS CLI kører på ( botocore/2.x.x ).
Du vil derfor ende med noget som dette:
Trin 2: Opret en eksekveringsrolle
Det næste trin er at oprette en eksekveringsrolle i AWS CLI. En eksekveringsrolle er en AWS Identity and Access Management-rolle (IAM) påtaget af en AWS-tjeneste for at udføre opgaverne på dine vegne. Det giver dig adgang til AWS-ressourcer, som du får brug for undervejs.
Du kan oprette en rolle ved hjælp af følgende kommando:
aws iam oprette-rolle \--rollenavn LambdaDynamoDBExecutionRole \
--assume-role-policy-document file://assume-role-policy.json \
--beskrivelse 'AWSLambdaDynamoDBExecutionRole' \
--tjenestenavn lambda.amazonaws.com
Den forrige kommando er en AWS CLI-kommando til at oprette en rolle. Du kan også bruge Amazon Management Console til at oprette en rolle. Når du er ved IAM-konsollen, skal du åbne Roller side og klik på Opret rolle knap.
Fortsæt for at indtaste følgende:
- Trusted Entity: Lambda
- Rollenavn: lambda-dynamodb-rolle
- Tilladelser: AWSLambdaDynamoDBExecutionRole
Du kan også bruge Python ved først at installere AWS SDK til Python:
pip installer boto3Trin 3: Aktiver DynamoDB-streams på dit bord
Du skal aktivere DynamoDB Streams på dit bord. Til denne illustration bruger vi Boto3, AWS SDK til Python. Følgende kommando vil hjælpe:
importer boto3# Opret forbindelse til DynamoDB-tjenesten
dynamodb = boto3.client( 'dynamodb' )
# Aktiver DynamoDB-streams på 'mit-bord'-tabellen
respons = dynamodb.update_table(
Tabelnavn= 'mytabel' ,
StreamSpecification={
'StreamEnabled' : Sand,
'StreamViewType' : 'NEW_AND_OLD_IMAGES'
}
)
# Tjek svaret for at sikre, at streamen blev aktiveret
hvis svar[ 'StreamSpecification' ][ 'StreamEnabled' ]:
Print( 'DynamoDB-stream blev aktiveret' )
andet:
Print( 'Fejl ved aktivering af DynamoDB-stream' )
Denne kode aktiverer DynamoDB-strømmen på 'mytable'-tabellen, der streamer både de nye og gamle billeder af elementer, så snart der sker ændringer. Du kan vælge kun at streame de nye billeder, så snart StreamViewType til 'NEW_IMAGE'.
Bemærk at kørsel af denne kode muligvis først aktiverer streams på dine borde efter et stykke tid. I stedet kan processen tage lidt tid. Du kan bruge describe_table-metoden til at kontrollere status for streamen.
Trin 4: Opret Lambda-funktionen
Det næste trin er at oprette en Lambda-funktion, der udløser DynamoDB-strømmen. Følgende trin bør hjælpe:
- Åbn AWS Lambda-konsollen, og klik på fanen 'Opret funktion'. På siden 'Opret funktion' skal du vælge 'Forfatter fra bunden' og indtaste et navn til din funktion. Du skal også indtaste din runtime på dette tidspunkt. Vi valgte Python til denne illustration.
- Under 'Vælg eller opret en udførelsesrolle', vælg 'Opret en ny rolle med grundlæggende Lambda-tilladelser' for at oprette en IAM-rolle med de nødvendige tilladelser til din Lambda-funktion.
- Klik på knappen 'Opret funktion' for at oprette din Lambda-funktion.
- På siden 'Konfiguration' for din funktion skal du rulle ned til sektionen 'Designer' og klikke på fanen 'Tilføj trigger'.
- I boksen 'Trigger-konfiguration', der vises, skal du vælge 'DynamoDB' fra rullemenuen 'Trigger'.
- Vælg den DynamoDB-tabel, du vil bruge til at udløse funktionen. Når du er færdig, skal du vælge, om du vil have funktionen udløst på alle opdateringer til tabellen eller kun på specifikke opdateringer (såsom opdateringer til bestemte kolonner).
- Klik på knappen 'Tilføj' for at oprette triggeren.
- I 'Funktionskode'-editoren skal du skrive Python-koden til din funktion. Du kan bruge hændelsesobjektet, der sendes til din funktion, til at få adgang til de data, der udløser funktionen.
- Klik på knappen 'Gem' for at få funktionen gemt.
Det er alt, hvad der sker, når du opretter en Lambda-funktion! Din funktion udløses nu, hver gang der er opdateringer til den angivne DynamoDB-tabel.
Her er et eksempel på en simpel Python-funktion, som DynamoDB-strømmen kan udløse:
def lambda_handler(hændelse, kontekst):til registrering i begivenhed[ 'Records' ]:
print(rekord[ 'dynamodb' ][ 'Nyt billede' ])
Denne funktion itererer gennem posterne i hændelsesobjektet og udskriver det nye billede af elementet i DynamoDB-tabellen, der udløser funktionen.
Trin 5: Test Lambda-funktionen
For at teste en Lambda-funktion, som en DynamoDB-stream kan udløse, kan du bruge boto3 bibliotek for at få adgang til DynamoDB API og påberåbe sig metoden til Lambda klient for at udløse funktionen.
Her er et eksempel på, hvordan du gør det:
importer boto3# Opret forbindelse til DynamoDB-tjenesten
dynamodb = boto3.client( 'dynamodb' )
# Opret forbindelse til Lambda-tjenesten
lambda_client = boto3.client( 'lambda' )
# Indsæt et element i 'mit-bord'-tabellen
respons = dynamodb.put_item(
Tabelnavn= 'mytabel' ,
Vare={
'id' :{ 'N' : '123' },
'navn' :{ 'S' : 'Joel Austin},
' alder ':{' N ':' 3. 4 '}
}
)
# Tjek svaret for at sikre, at elementet blev indsat korrekt
hvis svar[' ResponseMetadata '][' HTTPStatuskode '] == 200:
print('Vare indsat')
andet:
print('Fejl ved indsættelse af element')
# Udløs Lambda-funktionen, der abonnerer på ' mit-bord ' bord
respons = lambda_client.invoke(
Funktionsnavn=' min funktion ',
InvocationType=' Begivenhed ',
LogType=' Hale ',
Nyttelast =' { 'Records' :[{ 'dynamodb' :{ 'Nyt billede' :{ 'id' :{ 'N' : '123' }, 'navn' :{ 'S' : 'Joel Austin' }, 'alder' :{ 'N' : '3. 4' }}}}]} '
)
# Kontroller svaret for at sikre, at funktionen blev udløst korrekt
hvis svar[' Statuskode '] == 202:
print('Lambda-funktionen blev udløst')
andet:
print('Fejl ved udløsning af Lambda-funktion')
Denne kode indsætter først et element i mytabel tabel og udløser derefter min funktion Lambda-funktion ved at sende en prøvehændelsesnyttelast til funktionen ved hjælp af påberåbe sig metode. Begivenhedsnyttelasten simulerer en DynamoDB-streambegivenhed, der inkluderer det nye billede af elementet, der lige blev indsat.
Du kan derefter tjekke logfilerne for Lambda-funktionen for at se, om den har udløst og behandlet hændelsesdataene.
Konklusion
Det er vigtigt at bemærke, at du kan påberåbe dig flere gange for den samme stream-record, som en DynamoDB-stream kan udløse en Lambda-funktion. Den primære årsag til dette er, at stream-registreringerne til sidst er konsistente, og det er muligt at behandle den samme post flere gange med Lambda-funktionen. Det er afgørende at designe din Lambda-funktion til at håndtere denne sag korrekt.