Doc AWS SDK 예제 GitHub 리포지토리에서 더 많은 SDK 예제를 사용할 수 있습니다. [AWS](https://github.com/awsdocs/aws-doc-sdk-examples)
기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# SDK for Rust를 사용한 DynamoDB 예제
다음 코드 예제에서는 DynamoDB와 함께 AWS SDK for Rust를 사용하여 작업을 수행하고 일반적인 시나리오를 구현하는 방법을 보여줍니다.
*작업*은 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 작업은 개별 서비스 함수를 직접 호출하는 방법을 보여주며, 관련 시나리오의 컨텍스트에 맞는 작업을 볼 수 있습니다.
*시나리오*는 동일한 서비스 내에서 또는 다른 AWS 서비스와 결합된 상태에서 여러 함수를 직접적으로 호출하여 특정 태스크를 수행하는 방법을 보여주는 코드 예제입니다.
*AWS 커뮤니티 기여*는 여러 팀이 생성하고 유지 관리하는 예입니다 AWS. 피드백을 제공하려면 연결된 리포지토리에 제공된 메커니즘을 사용합니다.
각 예시에는 전체 소스 코드에 대한 링크가 포함되어 있으며, 여기에서 컨텍스트에 맞춰 코드를 설정하고 실행하는 방법에 대한 지침을 찾을 수 있습니다.
**Topics**
+ [작업](#actions)
+ [시나리오](#scenarios)
+ [서버리스 예제](#serverless_examples)
+ [AWS 커뮤니티 기여](#aws_community_contributions)
## 작업
### `CreateTable`
다음 코드 예시는 `CreateTable`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
pub async fn create_table(
client: &Client,
table: &str,
key: &str,
) -> Result {
let a_name: String = key.into();
let table_name: String = table.into();
let ad = AttributeDefinition::builder()
.attribute_name(&a_name)
.attribute_type(ScalarAttributeType::S)
.build()
.map_err(Error::BuildError)?;
let ks = KeySchemaElement::builder()
.attribute_name(&a_name)
.key_type(KeyType::Hash)
.build()
.map_err(Error::BuildError)?;
let create_table_response = client
.create_table()
.table_name(table_name)
.key_schema(ks)
.attribute_definitions(ad)
.billing_mode(BillingMode::PayPerRequest)
.send()
.await;
match create_table_response {
Ok(out) => {
println!("Added table {} with key {}", table, key);
Ok(out)
}
Err(e) => {
eprintln!("Got an error creating table:");
eprintln!("{}", e);
Err(Error::unhandled(e))
}
}
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [CreateTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.create_table)을 참조하세요.
### `DeleteItem`
다음 코드 예시는 `DeleteItem`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
pub async fn delete_item(
client: &Client,
table: &str,
key: &str,
value: &str,
) -> Result {
match client
.delete_item()
.table_name(table)
.key(key, AttributeValue::S(value.into()))
.send()
.await
{
Ok(out) => {
println!("Deleted item from table");
Ok(out)
}
Err(e) => Err(Error::unhandled(e)),
}
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [DeleteItem](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.delete_item)을 참조하세요.
### `DeleteTable`
다음 코드 예시는 `DeleteTable`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
pub async fn delete_table(client: &Client, table: &str) -> Result {
let resp = client.delete_table().table_name(table).send().await;
match resp {
Ok(out) => {
println!("Deleted table");
Ok(out)
}
Err(e) => Err(Error::Unhandled(e.into())),
}
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [DeleteTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.delete_table)을 참조하세요.
### `ListTables`
다음 코드 예시는 `ListTables`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
pub async fn list_tables(client: &Client) -> Result, Error> {
let paginator = client.list_tables().into_paginator().items().send();
let table_names = paginator.collect::, _>>().await?;
println!("Tables:");
for name in &table_names {
println!(" {}", name);
}
println!("Found {} tables", table_names.len());
Ok(table_names)
}
```
테이블이 존재하는지 확인합니다.
```
pub async fn table_exists(client: &Client, table: &str) -> Result {
debug!("Checking for table: {table}");
let table_list = client.list_tables().send().await;
match table_list {
Ok(list) => Ok(list.table_names().contains(&table.into())),
Err(e) => Err(e.into()),
}
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [ListTables](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.list_tables)을 참조하세요.
### `PutItem`
다음 코드 예시는 `PutItem`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
pub async fn add_item(client: &Client, item: Item, table: &String) -> Result {
let user_av = AttributeValue::S(item.username);
let type_av = AttributeValue::S(item.p_type);
let age_av = AttributeValue::S(item.age);
let first_av = AttributeValue::S(item.first);
let last_av = AttributeValue::S(item.last);
let request = client
.put_item()
.table_name(table)
.item("username", user_av)
.item("account_type", type_av)
.item("age", age_av)
.item("first_name", first_av)
.item("last_name", last_av);
println!("Executing request [{request:?}] to add item...");
let resp = request.send().await?;
let attributes = resp.attributes().unwrap();
let username = attributes.get("username").cloned();
let first_name = attributes.get("first_name").cloned();
let last_name = attributes.get("last_name").cloned();
let age = attributes.get("age").cloned();
let p_type = attributes.get("p_type").cloned();
println!(
"Added user {:?}, {:?} {:?}, age {:?} as {:?} user",
username, first_name, last_name, age, p_type
);
Ok(ItemOut {
p_type,
age,
username,
first_name,
last_name,
})
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [PutItem](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.put_item)을 참조하세요.
### `Query`
다음 코드 예시는 `Query`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
지정된 연도에 제작된 영화를 찾습니다.
```
pub async fn movies_in_year(
client: &Client,
table_name: &str,
year: u16,
) -> Result, MovieError> {
let results = client
.query()
.table_name(table_name)
.key_condition_expression("#yr = :yyyy")
.expression_attribute_names("#yr", "year")
.expression_attribute_values(":yyyy", AttributeValue::N(year.to_string()))
.send()
.await?;
if let Some(items) = results.items {
let movies = items.iter().map(|v| v.into()).collect();
Ok(movies)
} else {
Ok(vec![])
}
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [Query](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.query)를 참조하세요.
### `Scan`
다음 코드 예시는 `Scan`의 사용 방법을 보여줍니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
pub async fn list_items(client: &Client, table: &str, page_size: Option) -> Result<(), Error> {
let page_size = page_size.unwrap_or(10);
let items: Result, _> = client
.scan()
.table_name(table)
.limit(page_size)
.into_paginator()
.items()
.send()
.collect()
.await;
println!("Items in table (up to {page_size}):");
for item in items? {
println!(" {:?}", item);
}
Ok(())
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [Scan](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.scan)을 참조하세요.
## 시나리오
### 로컬 인스턴스에 연결
다음 코드 예제에서는 엔드포인트 URL을 재정의하여 DynamoDB 및 AWS SDK의 로컬 개발 배포에 연결하는 방법을 보여줍니다.
자세한 내용은 [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html)을 참조하세요.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
/// Lists your tables from a local DynamoDB instance by setting the SDK Config's
/// endpoint_url and test_credentials.
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
.test_credentials()
// DynamoDB run locally uses port 8000 by default.
.endpoint_url("http://localhost:8000")
.load()
.await;
let dynamodb_local_config = aws_sdk_dynamodb::config::Builder::from(&config).build();
let client = aws_sdk_dynamodb::Client::from_conf(dynamodb_local_config);
let list_resp = client.list_tables().send().await;
match list_resp {
Ok(resp) => {
println!("Found {} tables", resp.table_names().len());
for name in resp.table_names() {
println!(" {}", name);
}
}
Err(err) => eprintln!("Failed to list local dynamodb tables: {err:?}"),
}
}
```
### 사진을 관리하기 위한 서버리스 애플리케이션 만들기
다음 코드 예시에서는 사용자가 레이블을 사용하여 사진을 관리할 수 있는 서버리스 애플리케이션을 생성하는 방법을 보여줍니다.
**SDK for Rust**
Amazon Rekognition을 사용하여 이미지에서 레이블을 감지하고 나중에 검색할 수 있도록 저장하는 사진 자산 관리 애플리케이션을 개발하는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/cross_service/photo_asset_management)에서 전체 예제를 참조하세요.
이 예제의 출처에 대한 자세한 내용은 [AWS 커뮤니티](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)의 게시물을 참조하세요.
**이 예제에서 사용되는 서비스**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### PartiQL을 사용하여 테이블 쿼리
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ SELECT 문을 실행하여 항목을 가져옵니다.
+ INSERT 문을 실행하여 항목을 추가합니다.
+ UPDATE 문을 실행하여 항목을 업데이트합니다.
+ DELETE 문을 실행하여 항목을 삭제합니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
async fn make_table(
client: &Client,
table: &str,
key: &str,
) -> Result<(), SdkError> {
let ad = AttributeDefinition::builder()
.attribute_name(key)
.attribute_type(ScalarAttributeType::S)
.build()
.expect("creating AttributeDefinition");
let ks = KeySchemaElement::builder()
.attribute_name(key)
.key_type(KeyType::Hash)
.build()
.expect("creating KeySchemaElement");
match client
.create_table()
.table_name(table)
.key_schema(ks)
.attribute_definitions(ad)
.billing_mode(BillingMode::PayPerRequest)
.send()
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
async fn add_item(client: &Client, item: Item) -> Result<(), SdkError> {
match client
.execute_statement()
.statement(format!(
r#"INSERT INTO "{}" VALUE {{
"{}": ?,
"acount_type": ?,
"age": ?,
"first_name": ?,
"last_name": ?
}} "#,
item.table, item.key
))
.set_parameters(Some(vec![
AttributeValue::S(item.utype),
AttributeValue::S(item.age),
AttributeValue::S(item.first_name),
AttributeValue::S(item.last_name),
]))
.send()
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
async fn query_item(client: &Client, item: Item) -> bool {
match client
.execute_statement()
.statement(format!(
r#"SELECT * FROM "{}" WHERE "{}" = ?"#,
item.table, item.key
))
.set_parameters(Some(vec![AttributeValue::S(item.value)]))
.send()
.await
{
Ok(resp) => {
if !resp.items().is_empty() {
println!("Found a matching entry in the table:");
println!("{:?}", resp.items.unwrap_or_default().pop());
true
} else {
println!("Did not find a match.");
false
}
}
Err(e) => {
println!("Got an error querying table:");
println!("{}", e);
process::exit(1);
}
}
}
async fn remove_item(client: &Client, table: &str, key: &str, value: String) -> Result<(), Error> {
client
.execute_statement()
.statement(format!(r#"DELETE FROM "{table}" WHERE "{key}" = ?"#))
.set_parameters(Some(vec![AttributeValue::S(value)]))
.send()
.await?;
println!("Deleted item.");
Ok(())
}
async fn remove_table(client: &Client, table: &str) -> Result<(), Error> {
client.delete_table().table_name(table).send().await?;
Ok(())
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [ExecuteStatement](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.execute_statement)을 참조하세요.
### EXIF 및 기타 이미지 정보 저장
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ JPG, JPEG 또는 PNG 파일에서 EXIF 정보를 가져옵니다.
+ Amazon S3 버킷에 이미지 파일을 업로드합니다.
+ Amazon Rekognition을 사용하여 파일에서 3가지 주요 속성(레이블)을 파악합니다.
+ EXIF 및 레이블 정보를 리전의 Amazon DynamoDB 테이블에 추가합니다.
**SDK for Rust**
JPG, JPEG 또는 PNG 파일에서 EXIF 정보를 가져오고, 이미지 파일을 Amazon S3 버킷에 업로드하며, Amazon Rekognition을 사용하여 파일에서 3가지 주요 속성(Amazon Rekognition의 *레이블*)을 파악한 후 EXIF 및 레이블 정보를 리전의 Amazon DynamoDB 테이블에 추가합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/rustv1/cross_service/detect_labels/src/main.rs)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon Rekognition
+ Amazon S3
## 서버리스 예제
### DynamoDB 트리거에서 간접적으로 Lambda 함수 간접 호출
다음 코드 예제에서는 DynamoDB 스트림에서 레코드를 받아 트리거된 이벤트를 수신하는 Lambda 함수를 구현하는 방법을 보여줍니다. 이 함수는 DynamoDB 페이로드를 검색하고 레코드 콘텐츠를 로깅합니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Rust를 사용하여 Lambda로 DynamoDB 이벤트 사용.
```
use lambda_runtime::{service_fn, tracing, Error, LambdaEvent};
use aws_lambda_events::{
event::dynamodb::{Event, EventRecord},
};
// Built with the following dependencies:
//lambda_runtime = "0.11.1"
//serde_json = "1.0"
//tokio = { version = "1", features = ["macros"] }
//tracing = { version = "0.1", features = ["log"] }
//tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
//aws_lambda_events = "0.15.0"
async fn function_handler(event: LambdaEvent) ->Result<(), Error> {
let records = &event.payload.records;
tracing::info!("event payload: {:?}",records);
if records.is_empty() {
tracing::info!("No records found. Exiting.");
return Ok(());
}
for record in records{
log_dynamo_dbrecord(record);
}
tracing::info!("Dynamo db records processed");
// Prepare the response
Ok(())
}
fn log_dynamo_dbrecord(record: &EventRecord)-> Result<(), Error>{
tracing::info!("EventId: {}", record.event_id);
tracing::info!("EventName: {}", record.event_name);
tracing::info!("DynamoDB Record: {:?}", record.change );
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
let func = service_fn(function_handler);
lambda_runtime::run(func).await?;
Ok(())
}
```
### DynamoDB 트리거로 Lambda 함수에 대한 배치 항목 실패 보고
다음 코드 예제에서는 DynamoDB 스트림에서 이벤트를 수신하는 Lambda 함수에 대한 부분 배치 응답을 구현하는 방법을 보여줍니다. 이 함수는 응답으로 배치 항목 실패를 보고하고 나중에 해당 메시지를 다시 시도하도록 Lambda에 신호를 보냅니다.
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Rust를 사용하여 Lambda로 DynamoDB 배치 항목 실패 보고.
```
use aws_lambda_events::{
event::dynamodb::{Event, EventRecord, StreamRecord},
streams::{DynamoDbBatchItemFailure, DynamoDbEventResponse},
};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
/// Process the stream record
fn process_record(record: &EventRecord) -> Result<(), Error> {
let stream_record: &StreamRecord = &record.change;
// process your stream record here...
tracing::info!("Data: {:?}", stream_record);
Ok(())
}
/// Main Lambda handler here...
async fn function_handler(event: LambdaEvent) -> Result {
let mut response = DynamoDbEventResponse {
batch_item_failures: vec![],
};
let records = &event.payload.records;
if records.is_empty() {
tracing::info!("No records found. Exiting.");
return Ok(response);
}
for record in records {
tracing::info!("EventId: {}", record.event_id);
// Couldn't find a sequence number
if record.change.sequence_number.is_none() {
response.batch_item_failures.push(DynamoDbBatchItemFailure {
item_identifier: Some("".to_string()),
});
return Ok(response);
}
// Process your record here...
if process_record(record).is_err() {
response.batch_item_failures.push(DynamoDbBatchItemFailure {
item_identifier: record.change.sequence_number.clone(),
});
/* Since we are working with streams, we can return the failed item immediately.
Lambda will immediately begin to retry processing from this failed item onwards. */
return Ok(response);
}
}
tracing::info!("Successfully processed {} record(s)", records.len());
Ok(response)
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
// disable printing the name of the module in every log line.
.with_target(false)
// disabling time is handy because CloudWatch will add the ingestion time.
.without_time()
.init();
run(service_fn(function_handler)).await
}
```
## AWS 커뮤니티 기여
### 서버리스 애플리케이션 빌드 및 테스트
다음 코드 예제에서는 Lambda 및 DynamoDB와 함께 API 게이트웨이를 사용하여 서버리스 애플리케이션을 빌드하고 테스트하는 방법을 보여줍니다.
**SDK for Rust**
Rust SDK를 사용하여 Lambda 및 DynamoDB가 포함된 API 게이트웨이로 구성된 서버리스 애플리케이션을 빌드하고 테스트하는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/aws-samples/serverless-rust-demo)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ API Gateway
+ DynamoDB
+ Lambda