Siyempre, maaari mo ring gamitin ang DynamoDB Stream upang ma-trigger ang mga downstream na proseso at AWS Lambda function. Ang Lambda, ayon sa kahulugan, ay isang serverless compute service na nagpapatakbo ng iyong code bilang tugon sa mga kaganapan at awtomatikong pinamamahalaan ang mga mapagkukunan ng pagkalkula para sa iyo.
Magagamit mo ang Lambda para isulat ang code sa Node.js, Python, Java, o C# para iproseso ang mga stream record at magsagawa ng mga naaangkop na aksyon. Ang pangunahing benepisyo ng pagsasama ng DynamoDB Stream sa Lambda ay ang Lambda ay nagbibigay-daan sa iyo na patakbuhin ang mga naka-back na serbisyo o mga code ng application nang hindi nangangailangan ng pangangasiwa.
Paano Gamitin ang AWS DynamoDB Stream sa Lambda
Bagama't posibleng gumawa ng Lambda function na kumukonsumo ng mga kaganapan at mga pangyayari mula sa isang DynamoDB Stream, ang proseso ay maaaring maging napakahirap, lalo na sa iyong unang pagsubok. Makakatulong ang mga sumusunod na hakbang:
Hakbang 1: Tiyaking Natutugunan ng Iyong System ang Mga Kinakailangan
Magiging matagumpay lamang ang pamamaraang ito kung alam mo ang mga pangunahing operasyon at proseso ng Lambda. Kaya, ito dapat ang una mong matiyak na ang iyong pag-unawa sa Lambda ay higit sa karaniwan.
Ang pangalawang kinakailangan na dapat isaalang-alang ay ang pagkumpirma sa bersyon ng AWS ng iyong system. Maaari mong gamitin ang sumusunod na command:
aws –bersyon
Ang resulta para sa ibinigay na utos ay dapat magmukhang ganito:
aws-cli/ 2 .x.x Python/ 3 .x.x Linux/ 4 .x.x-xxx-std botocore/ 2 .x.xAng ibinigay na sample na tugon ay naglalaman ng naka-install na bersyon ng AWS CLI ( aws-cli/2.x.x ), ang bersyon ng Python ( Python/3.x.x ), at ang operating system ( Linux/4.x.x-xxx-std ). Ang huling bahagi ng tugon ay tumutukoy sa bersyon ng library ng Botocore kung saan tumatakbo ang iyong AWS CLI ( botocore/2.x.x ).
Ikaw, samakatuwid, ay magtatapos sa isang bagay na tulad nito:
Hakbang 2: Gumawa ng Tungkulin sa Pagpapatupad
Ang susunod na hakbang ay lumikha ng tungkulin sa pagpapatupad sa AWS CLI. Ang tungkulin sa pagpapatupad ay isang tungkulin ng AWS Identity and Access Management (IAM) na inaako ng isang serbisyo ng AWS upang maisagawa ang mga gawain sa ngalan mo. Nagbibigay ito sa iyo ng access sa mga mapagkukunan ng AWS na kakailanganin mo sa daan.
Maaari kang lumikha ng isang tungkulin gamit ang sumusunod na command:
aws iam create-role \--role-name LambdaDynamoDBExecutionRole \
--assume-role-policy-document file://assume-role-policy.json \
--paglalarawan ' AWSLambdaDynamoDBExecutionRole' \
--service-name lambda.amazonaws.com
Ang nakaraang command ay isang AWS CLI command para gumawa ng role. Maaari mo ring gamitin ang Amazon Management Console upang lumikha ng isang tungkulin. Kapag nasa IAM console ka na, buksan ang Mga tungkulin pahina at i-click ang Lumikha ng tungkulin pindutan.
Magpatuloy upang ipasok ang sumusunod:
- Pinagkakatiwalaang Entity: Lambda
- Pangalan ng Tungkulin: lambda-dynamodb-role
- Mga Pahintulot: AWSLambdaDynamoDBExecutionRole
Maaari mo ring gamitin ang Python sa pamamagitan ng unang pag-install ng AWS SDK para sa Python:
pip install boto3Hakbang 3: I-enable ang DynamoDB Stream sa Iyong Table
Kailangan mong paganahin ang DynamoDB Stream sa iyong talahanayan. Para sa paglalarawang ito, ginagamit namin ang Boto3, AWS SDK para sa Python. Ang sumusunod na utos ay makakatulong:
import boto3# Kumonekta sa serbisyo ng DynamoDB
dynamodb = boto3.client( 'dynamodb' )
# Paganahin ang mga stream ng DynamoDB sa 'my-table' table
tugon = dynamodb.update_table(
TableName= 'mytable' ,
StreamSpecification={
'StreamEnabled' : Totoo,
'StreamViewType' : 'NEW_AND_OLD_IMAGES'
}
)
# Suriin ang tugon upang matiyak na matagumpay na pinagana ang stream
kung tugon [ 'StreamSpecification' ][ 'StreamEnabled' ]:
print( 'Matagumpay na pinagana ang stream ng DynamoDB' )
iba pa:
print( 'Error sa pagpapagana ng DynamoDB stream' )
Ang code na ito ay nagbibigay-daan sa DynamoDB stream sa 'mytable' na talahanayan na nag-stream ng pareho ng bago at lumang mga larawan ng mga item sa sandaling mangyari ang anumang mga pagbabago. Maaari mong piliing i-stream lang ang mga bagong larawan sa sandaling ang StreamViewType sa “NEW_IMAGE”.
Kapansin-pansin, ang pagpapatakbo ng code na ito ay maaari lamang paganahin ang mga stream sa iyong mga talahanayan pagkaraan ng ilang sandali. Sa halip, ang proseso ay maaaring tumagal ng ilang oras. Maaari mong gamitin ang paraan ng describe_table upang suriin ang status ng stream.
Hakbang 4: Gumawa ng Lambda Function
Ang susunod na hakbang ay ang paggawa ng Lambda function na nagti-trigger sa DynamoDB stream. Ang mga sumusunod na hakbang ay dapat makatulong:
- Buksan ang AWS Lambda console at i-click ang tab na 'Gumawa ng function'. Sa page na 'Gumawa ng function,' piliin ang 'May-akda mula sa simula' at maglagay ng pangalan para sa iyong function. Kailangan mo ring ipasok ang iyong runtime sa puntong ito. Pinili namin ang Python para sa paglalarawang ito.
- Sa ilalim ng 'Pumili o gumawa ng tungkulin sa pagpapatupad', piliin ang 'Gumawa ng bagong tungkulin na may mga pangunahing pahintulot sa Lambda' upang lumikha ng tungkulin ng IAM na may mga kinakailangang pahintulot para sa iyong function ng Lambda.
- I-click ang button na “Gumawa ng function” para gawin ang iyong Lambda function.
- Sa pahina ng 'Configuration' para sa iyong function, mag-scroll pababa sa seksyong 'Designer' at i-click ang tab na 'Magdagdag ng trigger'.
- Sa lalabas na kahon ng 'Configuration ng trigger,' piliin ang 'DynamoDB' mula sa dropdown na menu na 'Trigger.'
- Piliin ang talahanayan ng DynamoDB na gusto mong gamitin upang ma-trigger ang function. Kapag tapos na, piliin kung gusto mong ma-trigger ang function sa lahat ng update sa talahanayan o sa mga partikular na update lang (gaya ng mga update sa partikular na column).
- I-click ang button na “Magdagdag” para gawin ang trigger.
- Sa editor ng 'Function code', isulat ang Python code para sa iyong function. Maaari mong gamitin ang event object na ipinapasa sa iyong function para ma-access ang data na nagti-trigger sa function.
- I-click ang pindutang 'I-save' upang mai-save ang function.
Iyon lang ang nangyayari kapag gumagawa ng Lambda function! Nati-trigger na ngayon ang iyong function sa tuwing may mga update sa tinukoy na talahanayan ng DynamoDB.
Narito ang isang halimbawa ng isang simpleng Python function na maaaring ma-trigger ng DynamoDB stream:
def lambda_handler(kaganapan, konteksto):para sa talaan sa kaganapan[ 'Mga Tala' ]:
print(record[ 'dynamodb' ][ 'Bagong larawan' ])
Ang function na ito ay umuulit sa pamamagitan ng mga tala sa event object at nagpi-print ng bagong imahe ng item sa DynamoDB table na nagti-trigger sa function.
Hakbang 5: Subukan ang Lambda Function
Upang subukan ang isang Lambda function na maaaring ma-trigger ng isang DynamoDB stream, maaari mong gamitin ang boto3 library upang ma-access ang DynamoDB API at ang panawagan paraan ng Lambda client upang ma-trigger ang function.
Narito ang isang halimbawa kung paano ito gawin:
import boto3# Kumonekta sa serbisyo ng DynamoDB
dynamodb = boto3.client( 'dynamodb' )
# Kumonekta sa serbisyo ng Lambda
lambda_client = boto3.client( 'lambda' )
# Magsingit ng item sa 'my-table' table
tugon = dynamodb.put_item(
TableName= 'mytable' ,
Item={
'id' :{ 'N' : '123' },
'pangalan' :{ 'S' : 'Joel Austin},
' edad ':{' N ':' 3. 4 '}
}
)
# Suriin ang tugon upang matiyak na matagumpay na naipasok ang item
kung tugon [' ResponseMetadata '][' HTTPStatusCode '] == 200:
print('Matagumpay na naipasok ang item')
iba pa:
print('Error sa pagpasok ng item')
# I-trigger ang Lambda function na naka-subscribe sa ' aking-mesa ' mesa
tugon = lambda_client.invoke(
Function,
InvocationType=' Kaganapan ',
LogType=' buntot ',
Payload=' { 'Mga Tala' :[{ 'dynamodb' :{ 'Bagong larawan' :{ 'id' :{ 'N' : '123' }, 'pangalan' :{ 'S' : 'Joel Austin' }, 'edad' :{ 'N' : '3. 4' }}}}]} '
)
# Suriin ang tugon upang matiyak na matagumpay na na-trigger ang function
kung tugon [' StatusCode '] == 202:
print('Matagumpay na na-trigger ang function ng Lambda')
iba pa:
print('Error sa pag-trigger ng Lambda function')
Ang code na ito ay unang nagpasok ng isang item sa mytable talahanayan at pagkatapos ay i-trigger ang my function Lambda function sa pamamagitan ng pagpapadala ng sample na event payload sa function gamit ang panawagan paraan. Ginagaya ng payload ng kaganapan ang isang kaganapan ng stream ng DynamoDB na kinabibilangan ng bagong larawan ng item na kakapasok lang.
Pagkatapos ay maaari mong suriin ang mga log ng Lambda function upang makita kung matagumpay nitong na-trigger at naproseso ang data ng kaganapan.
Konklusyon
Mahalagang tandaan na maaari kang mag-invoke ng maraming beses para sa parehong stream record na ang isang DynamoDB stream ay maaaring mag-trigger ng isang Lambda function. Ang pangunahing dahilan sa likod nito ay ang mga stream record ay pare-pareho sa kalaunan, at posibleng iproseso ang parehong record nang maraming beses sa pamamagitan ng Lambda function. Napakahalaga na idisenyo ang iyong function ng Lambda upang mahawakan nang tama ang kasong ito.