Integracja Lambda i DynamoDB
Twórz funkcje Lambda współpracujące z DynamoDB w celu wykonywania operacji CRUD i budowania bezserwerowych backendów opartych na danych.
Integracja Lambda i DynamoDB to bezpłatna lekcja Serverless Backend with AWS Lambda & API Gateway na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Serverless Backend with AWS Lambda & API Gateway, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Serverless Backend with AWS Lambda & API Gateway zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Lambda & DynamoDB: The Power Duo
Welcome to integrating AWS Lambda with DynamoDB! This combination is a cornerstone for building powerful, serverless backends.
AWS Lambda provides the compute power to run your code without managing servers, while DynamoDB offers a fast, flexible NoSQL database that scales automatically.
Together, they allow you to create data-driven applications that handle create, read, update, and delete (CRUD) operations efficiently.
Granting Lambda DynamoDB Access
Before your Lambda function can interact with DynamoDB, it needs permission. This is managed through an IAM Role attached to your Lambda function.
The IAM role must have a policy that grants specific DynamoDB actions, such as:
dynamodb:PutItem(for creating/updating)dynamodb:GetItem(for reading)dynamodb:UpdateItem(for modifying parts of an item)dynamodb:DeleteItem(for removing items)
Always follow the principle of least privilege: grant only the permissions necessary.
Connecting from Lambda with Boto3
In a Python Lambda function, you'll use the AWS SDK for Python, Boto3, to interact with DynamoDB. First, you need to initialize a DynamoDB client or resource.
The boto3.resource('dynamodb') approach is often preferred as it provides a higher-level, object-oriented interface.
Try running this example to see how to initialize the client:
import boto3
import json
def lambda_handler(event, context):
# Initialize DynamoDB resource
dynamodb = boto3.resource('dynamodb')
table_name = 'my-coddykit-table' # Placeholder
table = dynamodb.Table(table_name)
print(f"Connected to table: {table_name}")
return {
'statusCode': 200,
'body': json.dumps('DynamoDB client initialized!')
}
# For local testing/runnable snippet
if __name__ == '__main__':
print("Running handler locally...")
lambda_handler({}, {})Creating & Replacing Items (PutItem)
The put_item() method is used to create a new item or completely replace an existing item in a DynamoDB table.
- If an item with the same primary key already exists,
put_item()will overwrite it entirely. - If no item with that primary key exists, it will create a new one.
This operation is useful when you want to ensure an item exists with specific attributes, or you need to replace all its attributes.
PutItem in Action
Here's a Lambda function demonstrating how to use put_item() to add or update an item. We'll use a placeholder table name and item details from the event.
Run the code to see the simulated item creation!
import boto3
import json
def lambda_handler(event, context):
dynamodb = boto3.resource('dynamodb')
# Use a placeholder table name
table = dynamodb.Table('my-coddykit-table')
item_id = event.get('itemId', 'P001')
item_name = event.get('itemName', 'New Product')
table.put_item(
Item={
'itemId': item_id,
'itemName': item_name,
'category': 'Electronics'
}
)
print(f"Added/updated item: {item_id}")
return {
'statusCode': 200,
'body': json.dumps(f'Item {item_id} processed!')
}
# For local testing/runnable snippet
if __name__ == '__main__':
mock_event = {'itemId': 'P002', 'itemName': 'Coddy Phone'}
lambda_handler(mock_event, {})Reading Items (GetItem)
To retrieve a single item from a DynamoDB table, you use the get_item() method. This operation requires you to provide the full primary key of the item.
If your table has a simple primary key (only a Partition Key), you'll provide just that value. If it has a composite primary key (Partition Key and Sort Key), you must provide both.
get_item() is highly efficient for direct lookups.
GetItem in Action
This Lambda function shows how to retrieve an item using its itemId (assuming it's our primary key). The response will contain the item's attributes if found.
Run this example to see how get_item() works.
import boto3
import json
def lambda_handler(event, context):
dynamodb = boto3.resource('dynamodb')
# Use a placeholder table name
table = dynamodb.Table('my-coddykit-table')
item_id = event.get('itemId', 'P001') # Assume 'itemId' is the primary key
response = table.get_item(
Key={'itemId': item_id}
)
item = response.get('Item')
if item:
print(f"Found item: {item}")
return {
'statusCode': 200,
'body': json.dumps(item)
}
else:
print(f"Item {item_id} not found.")
return {
'statusCode': 404,
'body': json.dumps(f'Item {item_id} not found.')
}
# For local testing/runnable snippet
if __name__ == '__main__':
mock_event = {'itemId': 'P002'} # Try to get an item
lambda_handler(mock_event, {})Modifying Parts of an Item (UpdateItem)
The update_item() method allows you to modify specific attributes of an existing item without replacing the entire item.
This is more efficient than put_item() if you only need to change a few attributes. It requires an UpdateExpression to specify which attributes to modify and how.
Update expressions can add, set, remove, or delete attributes.
Removing Items (DeleteItem)
To delete an item from a DynamoDB table, you use the delete_item() method. Similar to get_item(), you must provide the full primary key of the item you wish to remove.
Once an item is deleted, it cannot be recovered through this operation. Be cautious when using delete_item(), especially in production environments.
Quick Check: DynamoDB Operations
You need to create a new user profile in your DynamoDB Users table. If a user with the same ID already exists, you want to completely overwrite their old profile with the new data. Which Boto3 method should your Lambda function use?
Recap: Lambda & DynamoDB Integration
Great job! You've learned how to integrate AWS Lambda with DynamoDB to build data-driven serverless applications.
- We covered the importance of IAM permissions for secure access.
- You saw how to use the Boto3 SDK to connect from Python Lambda.
- We explored the core CRUD operations:
put_item()(create/replace),get_item()(read),update_item()(modify), anddelete_item()(remove).
This knowledge is crucial for developing robust serverless backends!
Ucz się Serverless Backend with AWS Lambda & API Gateway dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 12
- Lekcje
- 48
Często zadawane pytania
Czy lekcja „Integracja Lambda i DynamoDB” jest bezpłatna?
Tak — pełny tekst „Integracja Lambda i DynamoDB” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Serverless Backend with AWS Lambda & API Gateway, przejdź na CoddyKit PRO. Kurs Serverless Backend with AWS Lambda & API Gateway zawiera 4 lekcji w sumie.
Co nauczysz się w „Integracja Lambda i DynamoDB”?
Twórz funkcje Lambda współpracujące z DynamoDB w celu wykonywania operacji CRUD i budowania bezserwerowych backendów opartych na danych. Ćwiczysz Serverless Backend with AWS Lambda & API Gateway z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Serverless Backend with AWS Lambda & API Gateway?
Nie wymagamy żadnego doświadczenia. Serverless Backend with AWS Lambda & API Gateway w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Integracja Lambda i DynamoDB”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Serverless Backend with AWS Lambda & API Gateway?
Tak. Każda lekcja Serverless Backend with AWS Lambda & API Gateway zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Wprowadzenie do DynamoDB
- Projektowanie tabel DynamoDB
- Integracja Lambda i DynamoDB
- Odpytywanie za pomocą indeksów dodatkowych: GSI i LSI