Coding  Life

Coding Life

1661833374

Serverless Architecture using AWS Lambda, API Gateway and DynamoDB

This tutorial will show you implementation of N-Tier Serverless Architecture on Amazon Web Services utilizing DynamoDB for backend, Lambda for DAO, API Gateway for integration and S3 for website hosting.

AWS Lambda is a serverless compute service that lets you run code without provisioning or managing servers, creating workload-aware cluster scaling logic, maintaining event integrations, or managing runtimes. With Lambda, you can run code for virtually any type of application or backend service - all with zero administration. Just upload your code as a ZIP file or container image, and Lambda automatically and precisely allocates compute execution power and runs your code based on the incoming request or event, for any scale of traffic. You can set up your code to automatically trigger from 140 AWS services or call it directly from any web or mobile app. You can write Lambda functions in your favorite language (Node.js, Python, Go, Java, and more) and use both serverless and container tools, such as AWS SAM or Docker CLI, to build, test, and deploy your functions.

Amazon API Gateway is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale. APIs act as the "front door" for applications to access data, business logic, or functionality from your backend services. Using API Gateway, you can create RESTful APIs and WebSocket APIs that enable real-time two-way communication applications. API Gateway supports containerized and serverless workloads, as well as web applications.

Amazon DynamoDB is a fully managed, serverless, key-value NoSQL database designed to run high-performance applications at any scale. DynamoDB offers built-in security, continuous backups, automated multi-region replication, in-memory caching, and data export tools.

Reference Link: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html

Subscribe: https://www.youtube.com/c/CloudGurus/featured 

#serverless #awslambda #apigateway #dynamodb

Serverless Architecture using AWS Lambda, API Gateway and DynamoDB

Dynastore: AWS DynamoDB Store for Gorilla toolkit using AWS Library

Dynastore

AWS DynamoDB store for Gorilla Toolkit using AWS library. Includes support for DynamoDB's TTL feature.

Installation

go get github.com/savaki/dynastore/...

Environment Variables

dynastore uses the common AWS environment variables:

  • AWS_DEFAULT_REGION or AWS_REGION
  • AWS_ACCESS_KEY_ID
  • AWS_SECRET_ACCESS_KEY

dynastore will also use AWS roles if they are available. In that case, only AWS_DEFAULT_REGION or AWS_REGION need be set.

Alternately, AWS settings can be specified using Options:

  • dynastore.AWSConfig(*aws.Config)
  • dynastore.DynamoDB(*dynamodb.DynamoDB)

Tables

dynastore provides a utility to create/delete the dynamodb table.

Create Table

dynastore -table your-table-name -read 5 -write 5 

Delete Table

Use the -delete flag to indicate the tables should be deleted instead.

dynastore -table your-table-name -delete 

Example

// Create Store
store, err := dynastore.New(dynastore.Path("/"), dynastore.HTTPOnly())
if err != nil {
  log.Fatalln(err)
}

// Get Session
session, err := store.Get(req, "session-key")
if err != nil {
  log.Fatalln(err)
}

// Add a Value
session.Values["hello"] = "world"

// Save Session
err := session.Save(req, w)
if err != nil {
  log.Fatalln(err)
}

// Delete Session
session.Options.MaxAge = -1
err := session.Save(req, w)
if err != nil {
  log.Fatalln(err)
}

Uses the official AWS library, github.com/aws/aws-sdk-go/aws

Download Details:

Author: Savaki
Source Code: https://github.com/savaki/dynastore 
License: Apache-2.0 license

#go #golang #aws #dynamodb 

Dynastore: AWS DynamoDB Store for Gorilla toolkit using AWS Library
Awesome  Rust

Awesome Rust

1661261820

A DynamoDB library for Rust

Examples

get_item example

#[derive(Raiden)]
#[raiden(table_name = "user")]
pub struct User {
    #[raiden(partition_key)]
    id: String,
    name: String,
}

#[tokio::main]
async fn main() {
    let client = User::client(Region::UsEast1);
    let _res = client.get("user_primary_key").run().await;
}

put_item example

#[derive(Raiden)]
#[raiden(table_name = "user")]
pub struct User {
    #[raiden(partition_key)]
    id: String,
    name: String,
}

#[tokio::main]
async fn main() {
    let client = User::client(Region::UsEast1);
    let input = User::put_item_builder()
        .id("foo".to_owned())
        .name("bokuweb".to_owned())
        .build();
    let res = client.put(&input).run().await;
}

batch_get_item example

#[derive(Raiden, Debug, PartialEq)]
pub struct User {
    #[raiden(partition_key)]
    id: String,
    #[raiden(sort_key)]
    year: usize,
}

#[tokio::main]
async fn main() {
    let client = User::client(Region::UsEast1);
    let keys: Vec<(&str, usize)> = vec![("Alice", 1992), ("Bob", 1976), ("Charlie", 2002)];
    let res = client.batch_get(keys).run().await;
}

Development

Requirements

  • Rust
  • Deno (1.13.2+)
  • GNU Make
  • Docker Engine

Setup

AWS_ACCESS_KEY_ID=awsdummy AWS_SECRET_ACCESS_KEY=awsdummy make dynamo

This starts up DynamoDB on Docker container, and then arranges test fixtures.

Test

AWS_ACCESS_KEY_ID=awsdummy AWS_SECRET_ACCESS_KEY=awsdummy make test

NOTE: Don't recommend to use cargo test because our test suite doesn't support running tests in parallel. Use cargo test -- --test-threads=1 instead of it.

Example

AWS_ACCESS_KEY_ID=awsdummy AWS_SECRET_ACCESS_KEY=awsdummy  cargo run --example EXAMPLE_NAME

Utility

dynamodb-admin is useful to check data in DynamoDB Local.

npx dynamodb-admin

Then open http://localhost:8001 in browser.

Supported APIs

Item

  •  BatchGetItem
  •  BatchWriteItem
  •  DeleteItem
  •  GetItem
  •  PutItem
  •  Query
  •  Scan
  •  TransactGetItems
  •  TransactWriteItems
  •  UpdateItem

Known limitations

Here is a list of unsupported features/behaviors in the actual implementation. We have a plan to resolve these issues in a future release.

Download details:

Author: raiden-rs
Source code: https://github.com/raiden-rs/raiden-dynamo

#rust #rustlang #dynamodb #database

A DynamoDB library for Rust

Dynago: A DynamoDB Client for Go

Dynago

Dynago is a DynamoDB client API for Go.

Key design tenets of Dynago:

  • Most actions are done via chaining to build filters and conditions
  • objects are completely safe for passing between goroutines (even queries and the like)
  • To make understanding easier via docs, we use Amazon's naming wherever possible.

Installation

Install using go get:

go get gopkg.in/underarmour/dynago.v1

Docs are at http://godoc.org/gopkg.in/underarmour/dynago.v1

Example

Run a query:

client := dynago.NewAwsClient(region, accessKey, secretKey)
// or you can use below if you have AWS credential values in ENV,
// in case of running on AWS Lambda, etc.
// client := dynago.NewAwsClientFromEnv()

query := client.Query(table).
    KeyConditionExpression("UserId = :uid", dynago.P(":uid", 42)).
    FilterExpression("NumViews > :views").
    Param(":views", 50).
    Desc()

result, err := query.Execute()
if err != nil {
    // do something
}
for _, row := range result.Items {
    fmt.Printf("Name: %s, Views: %d", row["Name"], row["NumViews"])
}

Type Marshaling

Dynago lets you use go types instead of having to understand a whole lot about dynamo's internal type system.

Example:

doc := dynago.Document{
    "name": "Bob",
    "age": 45,
    "height": 2.1,
    "address": dynago.Document{
        "city": "Boston",
    },
    "tags": dynago.StringSet{"male", "middle_aged"},
}
client.PutItem("person", doc).Execute()
  • Strings use golang string
  • Numbers can be input as int (int64, uint64, etc) or float64 but always are returned as dynago.Number to not lose precision.
  • Maps can be either map[string]interface{} or dynago.Document
  • Opaque binary data can be put in []byte
  • String sets, number sets, binary sets are supported using dynago.StringSet dynago.NumberSet dynago.BinarySet
  • Lists are supported using dynago.List
  • time.Time is only accepted if it's a UTC time, and is marshaled to a dynamo string in iso8601 compact format. It comes back as a string, an can be got back using GetTime() on Document.

Debugging

Dynago can dump request or response information for you to use in debugging. Simply set dynago.Debug with the necessary flags:

dynago.Debug = dynago.DebugRequests | dynago.DebugResponses

If you would like to change how the debugging is printed, please set dynago.DebugFunc to your preference.

Version Compatibility

Dynago follows Semantic Versioning via the gopkg.in interface, and within the v1 chain, we will not break the existing API or behaviour of existing code using Dynago. We will add new methods and features, but it again should not break code.

Additional resources

The past, and the future

Dynago currently implements all of its support for the underlying DynamoDB API encoding, AWS signing/authentication, etc. This happened in part because the existing libraries out there at the time of writing used deprecated API's and complicated methods, and it was actually cleaner at the time to support the API by fresh implementation.

AWS-SDK-Go exists as of June 2015 and has a very up to date API, but the API is via bare structs which minimally wrap protocol-level details of DynamoDB, resulting in it being very verbose for writing applications (dealing with DynamoDB's internal type system is boilerplatey). Once Amazon has brought it out of developer preview, the plan is to have Dynago use it as the underlying protocol and signature implementation, but keep providing Dynago's clean and simple API for building queries and marshaling datatypes in DynamoDB.

Download Details:

Author: underarmour
Source Code: https://github.com/underarmour/dynago 
License: MIT license

#go #golang #dynamodb 

Dynago: A DynamoDB Client for Go
曾 俊

曾 俊

1658832360

使用 TypeScript 更新 DynamoDB 项目

我的应用程序有一个包含用户的表,并且要使用给定的 id 更新用户,我有这个updateUser功能。第二个参数接受一个包含更新字段的对象。

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

为了简化与 DynamoDB 的交互,我提供了一些帮助程序。

getUpdateParams函数接受一个带有字段的对象并返回UpdateExpressionExpressionAttributeNamesExpressionAttributeValues,我们需要将其传递给文档客户端以更新项目。

export const getUpdateParams = (params: { [key: string]: any }) => ({
  UpdateExpression: `set ${Object.entries(params)
    .map(([key]) => `#${key} = :${key}, `)
    .reduce((acc, str) => acc + str)
    .slice(0, -2)}`,

  ExpressionAttributeNames: Object.keys(params).reduce(
    (acc, key) => ({
      ...acc,
      [`#${key}`]: key,
    }),
    {}
  ),

  ExpressionAttributeValues: Object.entries(params).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [`:${key}`]: value,
    }),
    {}
  ),
})

getUserItemParams对每张桌子都有一个功能。它返回一个我们需要获取、更新或删除项目的对象。

export const getUserItemParams = (id: string) => ({
  TableName: tableName.users,
  Key: { id },
})

来源:https ://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

使用 TypeScript 更新 DynamoDB 项目
渚  直樹

渚 直樹

1658832300

TypeScriptでDynamoDBアイテムを更新する

私のアプリにはユーザーのテーブルがあり、特定のIDでユーザーを更新するためのupdateUser関数があります。2番目のパラメーターは、更新用のフィールドを持つオブジェクトを取ります。

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

DynamoDBとのやり取りを簡素化するために、私には少数のヘルパーがいます。

このgetUpdateParams関数は、フィールドを持つオブジェクトを受け取り、、、、およびを返しますUpdateExpressionExpressionAttributeNamesこれらExpressionAttributeValuesは、アイテムを更新するためにドキュメントクライアントに渡す必要があります。

export const getUpdateParams = (params: { [key: string]: any }) => ({
  UpdateExpression: `set ${Object.entries(params)
    .map(([key]) => `#${key} = :${key}, `)
    .reduce((acc, str) => acc + str)
    .slice(0, -2)}`,

  ExpressionAttributeNames: Object.keys(params).reduce(
    (acc, key) => ({
      ...acc,
      [`#${key}`]: key,
    }),
    {}
  ),

  ExpressionAttributeValues: Object.entries(params).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [`:${key}`]: value,
    }),
    {}
  ),
})

getUserItemParams私はすべてのテーブルのような機能を持っています。アイテムを取得、更新、または削除するために必要なオブジェクトを返します。

export const getUserItemParams = (id: string) => ({
  TableName: tableName.users,
  Key: { id },
})

ソース:https ://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

TypeScriptでDynamoDBアイテムを更新する

Mettre à Jour L'élément DynamoDB Avec TypeScript

Mon application a une table avec les utilisateurs, et pour mettre à jour un utilisateur avec un identifiant donné, j'ai la updateUserfonction. Le deuxième paramètre prend un objet avec des champs pour la mise à jour.

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

Pour simplifier les interactions avec DynamoDB, j'ai une poignée d'assistants.

La getUpdateParamsfonction prend un objet avec des champs et renvoie UpdateExpression, ExpressionAttributeNames, et ExpressionAttributeValues, que nous devons transmettre au client du document pour mettre à jour l'élément.

export const getUpdateParams = (params: { [key: string]: any }) => ({
  UpdateExpression: `set ${Object.entries(params)
    .map(([key]) => `#${key} = :${key}, `)
    .reduce((acc, str) => acc + str)
    .slice(0, -2)}`,

  ExpressionAttributeNames: Object.keys(params).reduce(
    (acc, key) => ({
      ...acc,
      [`#${key}`]: key,
    }),
    {}
  ),

  ExpressionAttributeValues: Object.entries(params).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [`:${key}`]: value,
    }),
    {}
  ),
})

J'ai une fonction comme getUserItemParamspour chaque table. Il renvoie un objet dont nous avons besoin pour obtenir, mettre à jour ou supprimer un élément.

export const getUserItemParams = (id: string) => ({
  TableName: tableName.users,
  Key: { id },
})

Source : https://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

Mettre à Jour L'élément DynamoDB Avec TypeScript
Saul  Alaniz

Saul Alaniz

1658828640

Actualizar Elemento De DynamoDB Con TypeScript

Mi aplicación tiene una tabla con usuarios, y para actualizar un usuario con una identificación dada, tengo la updateUserfunción. El segundo parámetro toma un objeto con campos para la actualización.

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

Para simplificar las interacciones con DynamoDB, tengo un puñado de ayudantes.

La getUpdateParamsfunción toma un objeto con campos y devuelve UpdateExpression, ExpressionAttributeNamesy ExpressionAttributeValues, que debemos pasar al cliente de documentos para actualizar el elemento.

export const getUpdateParams = (params: { [key: string]: any }) => ({
  UpdateExpression: `set ${Object.entries(params)
    .map(([key]) => `#${key} = :${key}, `)
    .reduce((acc, str) => acc + str)
    .slice(0, -2)}`,

  ExpressionAttributeNames: Object.keys(params).reduce(
    (acc, key) => ({
      ...acc,
      [`#${key}`]: key,
    }),
    {}
  ),

  ExpressionAttributeValues: Object.entries(params).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [`:${key}`]: value,
    }),
    {}
  ),
})

Tengo una función como getUserItemParamspara cada tabla. Devuelve un objeto que necesitamos obtener, actualizar o eliminar un elemento.

export const getUserItemParams = (id: string) => ({
  TableName: tableName.users,
  Key: { id },
})

Fuente: https://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

Actualizar Elemento De DynamoDB Con TypeScript
Thai  Son

Thai Son

1658824800

Cập Nhật Mục DynamoDB Với TypeScript

Ứng dụng của tôi có một bảng với người dùng và để cập nhật người dùng với một id nhất định, tôi có updateUserchức năng này. Tham số thứ hai nhận một đối tượng với các trường cho bản cập nhật.

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

Để đơn giản hóa các tương tác với DynamoDB, tôi có một số người trợ giúp.

Hàm getUpdateParamsnhận một đối tượng với các trường và trả về UpdateExpression, ExpressionAttributeNamesExpressionAttributeValueschúng ta cần chuyển đối tượng này đến ứng dụng khách tài liệu để cập nhật mục.

export const getUpdateParams = (params: { [key: string]: any }) => ({
  UpdateExpression: `set ${Object.entries(params)
    .map(([key]) => `#${key} = :${key}, `)
    .reduce((acc, str) => acc + str)
    .slice(0, -2)}`,

  ExpressionAttributeNames: Object.keys(params).reduce(
    (acc, key) => ({
      ...acc,
      [`#${key}`]: key,
    }),
    {}
  ),

  ExpressionAttributeValues: Object.entries(params).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [`:${key}`]: value,
    }),
    {}
  ),
})

Tôi có một chức năng giống như getUserItemParamscho mọi bảng. Nó trả về một đối tượng mà chúng ta cần lấy, cập nhật hoặc xóa một mục.

export const getUserItemParams = (id: string) => ({
  TableName: tableName.users,
  Key: { id },
})

Nguồn: https://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

Cập Nhật Mục DynamoDB Với TypeScript

Atualizar Item Do DynamoDB Com TypeScript

Meu aplicativo tem uma tabela com usuários, e para atualizar um usuário com um determinado id, tenho a updateUserfunção. O segundo parâmetro pega um objeto com campos para atualização.

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

Para simplificar as interações com o DynamoDB, tenho vários auxiliares.

A getUpdateParamsfunção pega um objeto com campos e retorna UpdateExpression, ExpressionAttributeNames, e ExpressionAttributeValues, que precisamos passar para o cliente do documento para atualizar o item.

export const getUpdateParams = (params: { [key: string]: any }) => ({
  UpdateExpression: `set ${Object.entries(params)
    .map(([key]) => `#${key} = :${key}, `)
    .reduce((acc, str) => acc + str)
    .slice(0, -2)}`,

  ExpressionAttributeNames: Object.keys(params).reduce(
    (acc, key) => ({
      ...acc,
      [`#${key}`]: key,
    }),
    {}
  ),

  ExpressionAttributeValues: Object.entries(params).reduce(
    (acc, [key, value]) => ({
      ...acc,
      [`:${key}`]: value,
    }),
    {}
  ),
})

Eu tenho uma função como getUserItemParamspara cada tabela. Ele retorna um objeto que precisamos para obter, atualizar ou excluir um item.

export const getUserItemParams = (id: string) => ({
  TableName: tableName.users,
  Key: { id },
})

Fonte: https://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

Atualizar Item Do DynamoDB Com TypeScript

Update DynamoDB Item with TypeScript

My app has a table with users, and to update a user with a given id, I have the updateUser function. The second parameter takes an object with fields for the update.

export const updateUser = (id: string, params: Partial<User>) => {
  return documentClient
    .update({
      ...getUserItemParams(id),
      ...getUpdateParams(params),
    })
    .promise()
}

 

See more at: https://radzion.com/blog/update-dynamodb

#dynamodb #typescript 

Update DynamoDB Item with TypeScript
Thai  Son

Thai Son

1657902600

Triển Khai CRUD với DynamoDB trong ASP.NET Core

Trong bài viết này, chúng ta sẽ tìm hiểu về cách triển khai CRUD với DynamoDB trong ASP.NET Core Web API. Bài viết này là một phần không thể thiếu của toàn bộ “Ứng dụng không máy chủ với AWS” mà tôi đã viết trên blog của mình. Trong một bài viết trước, chúng tôi đã đề cập đến AWS Lamba bằng cách sử dụng .NET 6 Runtime và hơn thế nữa. Hôm nay, chúng ta sẽ tìm hiểu cơ bản về DynamoDB, tạo bảng và khóa phân vùng thông qua Bảng điều khiển AWS, sử dụng gói AWS DynamoDB Nuget và kết nối với các bảng từ ứng dụng .NET 6 của chúng tôi, thực hiện các thao tác CRUD cơ bản, v.v.

Bạn có thể tìm thấy mã nguồn hoàn chỉnh của việc triển khai tại đây .

Giới thiệu về AWS DynamoDB

AWS Dynamo DB là một dịch vụ cơ sở dữ liệu được quản lý đầy đủ, có tính khả dụng cao do Amazon Web Services cung cấp. Đó là Cơ sở dữ liệu NoSQL, có nghĩa là nó không phải là cơ sở dữ liệu quan hệ. Nó cũng là một phần quan trọng và chủ đạo của toàn bộ Mô hình ứng dụng không máy chủ của AWS. Vì nó có thể tự động mở rộng, nó có thể xử lý hàng triệu yêu cầu mỗi giây và lưu trữ TB dữ liệu trong các hàng của nó. Khá thú vị, phải không? Tốc độ truy xuất dữ liệu diễn ra cũng khá ấn tượng, độ trễ khá nhỏ. Ngoài ra, nó được tích hợp với AWS IAM để bảo mật (giống như mọi Dịch vụ AWS khác).

Là cơ sở dữ liệu Tuân thủ NoSQL, đó là cơ sở dữ liệu khóa / giá trị. Khóa chính thường được tạo thành từ 1 hoặc 2 khóa. Các thuộc tính (cột) khác của bảng DynamoDB được gọi là thuộc tính nội bộ.

Một tính năng rất quan trọng khác là Amazon cung cấp gần 25 GB dung lượng lưu trữ và lên đến 200 Triệu yêu cầu đọc / ghi mỗi tháng với Bậc miễn phí, quá đủ nếu bạn muốn bắt đầu hành trình AWS của mình. Nhận tài khoản cấp MIỄN PHÍ của bạn tại đây nếu bạn chưa có - https://aws.amazon.com/free/

CRUD với DynamoDB trong ASP.NET Core

Đọc thêm về Dynamo DB tại đây - https://aws.amazon.com/dynamodb/

Chúng tôi sẽ xây dựng những gì?

Vì vậy, chúng tôi sẽ xây dựng một API WEB .NET 6 đơn giản có thể kết nối với AWS DynamoDB của chúng tôi dựa trên các cấu hình nhất định mà chúng tôi thiết lập thông qua AWS CLI cục bộ và thực hiện một số hoạt động CRUD cơ bản trên một thực thể. Trong phần trình diễn này, thực thể của chúng ta sẽ là Sinh viên, với các thuộc tính như Id, Tên, Lớp, Quốc gia, chỉ là những thuộc tính cơ bản. Và, chúng tôi sẽ viết mã để Tạo, Nhận một học sinh, Nhận tất cả học sinh, Xóa và cập nhật học sinh.

Với điều đó rõ ràng, chúng ta hãy bắt đầu!

Bảng điều khiển AWS - Dynamo DB

Tôi giả sử rằng bạn đã có tài khoản AWS (tốt nhất là tài khoản MIỄN PHÍ là quá đủ cho việc học của chúng tôi). Hãy cùng Amazon DynamoDB thực hiện một số bài tập thực hành để biết rõ hơn nhé!

Đăng nhập vào Bảng điều khiển AWS của bạn, tìm kiếm DynamoDB trong thanh tìm kiếm Dịch vụ trên cùng và mở nó lên.

Tiếp theo, nhấp vào Bảng hoặc Tạo bảng.

image 2 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Tạo một Bảng mới trong DynamoDB thông qua Bảng điều khiển

Như đã thảo luận trước đó, chúng ta sẽ phải tạo một bảng mới có tên là sinh viên . Nhấp vào "Tạo bảng".

image 3 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Ở đây, đặt tên bảng thành “ sinh viên ” và Khóa phân vùng là “id” (số). Vì vậy, đây sẽ là khóa chính của bảng " sinh viên" . Cũng lưu ý rằng, bằng cách sử dụng Khóa sắp xếp, chúng ta có thể linh hoạt hơn nữa việc hình thành khóa chính. Điều này giống như một Sơ cấp tổng hợp được hình thành bằng cách kết hợp Khóa phân vùng và Khóa sắp xếp.

Hiện tại, chúng tôi không đặt bất kỳ Khóa sắp xếp nào. Giữ nguyên các trường khác và Tạo bảng.

image 11 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Đó là tất cả mọi thứ. Có thể mất vài giây để cung cấp hoàn toàn bảng của bạn cho DynamoDB. Sau khi hoàn thành, trạng thái của bảng của bạn chuyển sang Hoạt động.

image 12 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Thêm dữ liệu vào AWS DynamoDB qua Bảng điều khiển

Khi bảng được cấp phép, hãy thêm một số dữ liệu vào bảng thông qua bảng điều khiển. Nhấp vào bảng và nhấn “Khám phá các mục trong bảng”.

image 13 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Vì vậy, đây là nơi bạn có thể truy vấn dữ liệu từ bảng này (nếu có dữ liệu tồn tại). Giao diện người dùng có vẻ khá trực quan để làm việc với dữ liệu. Nhấp vào “Tạo mục”.

image 7 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Bây giờ, tại đây AWS DynamoDB cho phép bạn xác định dữ liệu ở các định dạng JSON hoặc thêm dữ liệu dưới dạng các trường biểu mẫu. Nhấp vào tab JSON để chuyển sang chế độ xem sau. Ở đây, tôi thêm các thuộc tính như Id, First Name, Last Name, Class và Country.

image 14 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Bạn có thể chuyển trở lại chế độ xem Biểu mẫu cho giao diện bên dưới. Tôi thích sử dụng chế độ xem JSON hơn.

image 15 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Sau khi bạn nhập các giá trị và nhấp vào tạo, AWS DynamoDB sẽ chèn mục vào bảng sinh viên như bạn có thể thấy bên dưới.

image 16 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Đó là cách giao diện DynamoDB hoạt động. Bây giờ chúng ta hãy viết một số mã.

Bắt đầu - CRUD với DynamoDB trong ASP.NET Core

Bây giờ chúng ta đã thực hành cơ bản với AWS DynamoDB, hãy xây dựng một API Web có thể sử dụng dịch vụ AWS này.

Mở IDE Visual Studio của bạn (Tôi đang sử dụng Cộng đồng Visual Studio 2022 với phiên bản .NET SDK mới nhất được cài đặt, là 6.0.2). Đảm bảo rằng môi trường phát triển của bạn đã được thiết lập.

Tạo một dự án ASP.NET Core Web API mới và đặt tên nó giống như bên dưới.

image CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Đảm bảo rằng bạn chọn .NET 6 và chọn hộp kiểm “ Sử dụng bộ điều khiển ”. Ngoài ra, hãy đảm bảo rằng bạn đã bật hỗ trợ OpenAPI vì chúng tôi sẽ thử nghiệm ứng dụng của mình thông qua Swagger.

image 1 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Bây giờ bạn đã hoàn thành dự án, hãy nói về việc định cấu hình thông tin đăng nhập AWS.

Cấu hình AWS CLI

Vì vậy, đối với mọi dịch vụ AWS mà bạn làm việc cục bộ, bạn cần một bộ thông tin xác thực để truy cập các điểm cuối AWS, phải không? Nếu bạn đã đọc các bài viết trước của tôi trên AWS ( S3 hoặc Lambda ), tôi đã chỉ ra một cách để lưu trữ thông tin đăng nhập AWS một cách an toàn vào máy cục bộ của bạn và tránh đưa những chi tiết này vào dự án của bạn.

Điều hướng đến AWS IAM để tạo người dùng của bạn có quyền truy cập vào Dynamo DB. Để tạo người dùng mới trên AWS IAM, bạn có thể theo dõi phần này trong bài viết trước của tôi . Sự khác biệt duy nhất là, thay vì chọn Chính sách AmazonS3FullAccess, bạn sẽ phải chọn một chính sách liên quan đến Dynamo DB. Đảm bảo rằng bạn có quyền đọc, ghi và xóa được bao gồm trong chính sách đã chọn. Dưới đây là các chính sách liên quan đến DynamoDB.

image 19 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Bạn có thể chọn AmazonDynamoDBFullAccess vào lúc này. Nhưng hãy luôn nhớ chỉ chọn những gì thực sự cần thiết cho ứng dụng của bạn.

Khi bạn đã tạo người dùng của mình, một tập hợp thông tin xác thực sẽ được tạo. Đảm bảo rằng bạn tải xuống CSV đã tạo này để lưu giữ an toàn.

Tiếp theo, để cấu hình các thông tin đăng nhập này trên máy cục bộ của bạn, hãy làm theo phần này của bài viết trước của tôi .

Tôi đặt tên hồ sơ của mình là aws-admin. Đây là cách nó trông cho tôi.

image 18 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Điều quan trọng cần lưu ý là bạn phải đặt vùng AWS thích hợp. Ví dụ: tôi đã đặt vùng của mình thành ap-nam-1 là Mumbai, Ấn Độ. Phải chọn cùng một khu vực trong khi điều hướng Bảng điều khiển AWS. Nếu có sự không khớp về tên của các khu vực, hầu hết có thể bạn sẽ không thể thấy bảng được cung cấp của mình trên DDB.

Vì vậy, bây giờ chúng ta đã định cấu hình thông tin đăng nhập AWS, hãy mở appsettings.json của chúng ta trong dự án và thực hiện các sửa đổi như bên dưới.

Lưu ý rằng tên hồ sơ của tôi là aws-admin và khu vực AWS gần nhất với tôi là ap-south-1. Thực hiện các thay đổi cho phù hợp.

{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"AWS": {
"Profile": "aws-admin",
"Region": "ap-south-1"
}
}

Sau khi hoàn tất, AWS SDK sẽ có thể đọc tên hồ sơ từ appsettings.json và trích xuất chi tiết thông tin xác thực được định cấu hình và sử dụng nó trong thời gian chạy ứng dụng của chúng tôi.

Tạo mô hình sinh viên

Hãy nhớ chúng tôi tạo một bảng trên AWS DynamoDB với một số thuộc tính nhất định? Chúng ta cũng cần phải xây dựng cùng một lớp mô hình trên dự án .NET của chúng ta.

Tạo một thư mục mới có tên là Mô hình và tạo một lớp trong đó có tên là Student.cs

using Amazon.DynamoDBv2.DataModel;
namespace DynamoStudentManager.Models
{
[DynamoDBTable("students")]
public class Student
{
[DynamoDBHashKey("id")]
public int? Id { get; set; }

[DynamoDBProperty("first_name")]
public string? FirstName { get; set; }

[DynamoDBProperty("last_name")]
public string? LastName { get; set; }

[DynamoDBProperty("class")]
public int Class { get; set; }

[DynamoDBProperty("country")]
public string? Country { get; set; }
}
}

Lưu ý rằng chúng tôi đã đặt tên bảng DynamoDB của chúng tôi là "sinh viên", nhưng tên của lớp của chúng tôi là "Sinh viên" (thậm chí nó có thể là một cái gì đó hoàn toàn khác). Vì vậy, để AWS SDK hiểu rằng cả hai về cơ bản đều là các mô hình giống nhau, chúng ta cần phải ánh xạ nó.

Dòng 4: Ở đây chúng tôi cho SDK biết rằng Bảng DynamoDB “sinh viên” phải ánh xạ tới lớp C # “ Sinh viên ”.

Dòng 7: DynamoDBHashKey xác định khóa chính của bảng. Ở đây, chúng tôi chỉ ra rằng Id sẽ là khóa chính của chúng tôi với tên thuộc tính là "id" trong bảng DDB.

Dòng 10,13,16,19: Chúng tôi xác định các thuộc tính khác của bảng cùng với tên thuộc tính DDB tương ứng của chúng.

Đăng ký dịch vụ

Với các mô hình được thiết lập, hãy đăng ký Dịch vụ AWS và cấu hình trong vùng chứa ASP.NET Core. Mở Program.cs và các dòng được đánh dấu sau.

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var awsOptions = builder.Configuration.GetAWSOptions();
builder.Services.AddDefaultAWSOptions(awsOptions);
builder.Services.AddAWSService<IAmazonDynamoDB>();
builder.Services.AddScoped<IDynamoDBContext, DynamoDBContext>();
var app = builder.Build();

Về cơ bản, điều này sẽ tải cấu hình AWS từ tệp appsettings.json và đăng ký Dịch vụ AWS liên quan đến DynamoDB vào vùng chứa của ứng dụng.

Kiểm soát sinh viên

Tiếp theo, hãy viết bộ điều khiển API sẽ thực sự thực hiện các hoạt động liên quan đến CRUD với DynamoDB trong ASP.NET Core. Tạo Bộ điều khiển API trống mới trong thư mục Bộ điều khiển và đặt tên là StudentController.

namespace DynamoStudentManager.Controllers;

[Route("api/[controller]")]
[ApiController]
public class StudentsController : ControllerBase
{
private readonly IDynamoDBContext _context;
public StudentsController(IDynamoDBContext context)
{
_context = context;
}
[HttpGet("{studentId}")]
public async Task<IActionResult> GetById(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
return Ok(student);
}
[HttpGet]
public async Task<IActionResult> GetAllStudents()
{
var student = await _context.ScanAsync<Student>(default).GetRemainingAsync();
return Ok(student);
}
[HttpPost]
public async Task<IActionResult> CreateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student != null) return BadRequest($"Student with Id {studentRequest.Id} Already Exists");
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
[HttpDelete("{studentId}")]
public async Task<IActionResult> DeleteStudent(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
await _context.DeleteAsync(student);
return NoContent();
}
[HttpPut]
public async Task<IActionResult> UpdateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student == null) return NotFound();
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
}

Dòng 7-11: Ở đây, chúng tôi đưa IDynamoDBContext vào hàm tạo của bộ điều khiển. Sử dụng giao diện này, chúng tôi sẽ có thể truy cập AWS DynamoDB.

Dòng 13-18: Nhận các mục theo Id (là khóa chính của chúng tôi ở đây). Trong Dòng 15, chúng tôi tải bảng Sinh viên (bảng này được ánh xạ tới “sinh viên”) và chuyển StudentId nhận được dưới dạng HashKey đến DynamoDB. Điều này trả về cho chúng tôi bản ghi Sinh viên được ánh xạ nếu nó tồn tại.

Dòng 20-24: Lấy tất cả hồ sơ học sinh từ bảng DDB.

Dòng 26-32: Ở đây, chúng tôi chuyển một bản ghi Sinh viên đến điểm cuối, sau đó cố gắng tạo một bản ghi mới trong DDB với các chi tiết được truyền. Đầu tiên, nó sẽ kiểm tra xem ID được chuyển đã tồn tại trong cơ sở dữ liệu hay chưa. Nếu được tìm thấy, nó sẽ trả về một Ngoại lệ Yêu cầu Không hợp lệ. Khác, hồ sơ học sinh được tạo như mong đợi.

Dòng 34-40: Chúng tôi chuyển một Id sinh viên đến điểm cuối Xóa này. Đầu tiên, nó kiểm tra xem bản ghi như vậy có tồn tại với Id được chuyển hay không. Nếu không tìm thấy, ứng dụng sẽ ném ngoại lệ NotFound và ngắt. Nếu không, nó sẽ tiến hành xóa mục khỏi bảng DynamoDB của chúng tôi.

Dòng 42-48: Ở đây, chúng tôi cố gắng cập nhật hồ sơ sinh viên, bằng cách chuyển toàn bộ thuộc tính như vậy đến điểm cuối. Trước tiên, chúng tôi kiểm tra xem Id sinh viên có tồn tại hay không, sau đó tiếp tục cập nhật mặt hàng. Đơn giản vậy thôi.

Thử nghiệm

Với các bộ điều khiển có dây, hãy thử nghiệm ứng dụng của chúng tôi. Vì chúng tôi đã bật hỗ trợ OpenAPI cho API của mình, Swagger sẽ hoạt động hiệu quả mà không cần bất kỳ cấu hình bổ sung nào.

Chạy ứng dụng và điều hướng đến localhost: xxxx / swagger trên trình duyệt web của bạn. Điều này sẽ mở ra giao diện người dùng Swagger.

image 20 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Hãy nhớ rằng chúng tôi đã tạo một bản ghi mới trước đó trực tiếp thông qua AWS Console DynamoDB. Tôi đã cấp cho nó một Id là 1. Hãy truy vấn với Id này dựa trên điểm cuối GET / api / Students / 1.

image 21 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Bạn đi rồi, đúng như chúng tôi mong đợi. Tiếp theo, hãy tạo một sinh viên mới bằng cách sử dụng điểm cuối POST. Đây là dữ liệu JSON của tôi sẽ trông như thế nào đối với sinh viên mới có ID 2.

{
"id": 2,
"firstName": "John",
"lastName": "Musk",
"class": 10,
"country": "USA"
}

Bạn có thể thấy rằng có 200 phản hồi Ok từ API của chúng tôi, có nghĩa là dữ liệu được chèn vào bảng DDB của chúng tôi. Hãy kiểm tra bảng điều khiển của chúng tôi.

image 22 CRUD với DynamoDB trong ASP.NET Core - Bắt đầu với AWS DynamoDB được đơn giản hóa

Vậy là xong, học sinh mới của chúng ta đã được tạo ra. Tương tự, tôi để lại các điểm cuối API còn lại để bạn kiểm tra. Bạn có thể tìm thấy toàn bộ mã nguồn của việc triển khai này tại đây . Hãy làm theo tay cầm Github của tôi . Bây giờ chúng ta hãy kết thúc bài viết này.

Trong phần tiếp theo của loạt bài này, chúng ta sẽ tìm hiểu về các cổng API và tạo các API Serverless Rest (API HTTP) bằng cách gắn Lambdas vào cổng.

Bản tóm tắt

Trong bài viết này, chúng ta đã tìm hiểu về Thực hiện CRUD với DynamoDB trong ASP.NET Core, một số thực hành với giao diện AWS DynamoDB, Khóa phân vùng, Cài đặt AWS CLI và định cấu hình nó, Xây dựng API Web có thể giao tiếp với DDB và làm việc với dữ liệu, v.v.

Hãy chia sẻ bài viết này với đồng nghiệp và vòng kết nối nhà phát triển của bạn nếu bạn thấy điều này thú vị. Bạn có thể tìm thấy  mã nguồn của dự án  tại đây. Cảm ơn!

Nguồn: https://codewithmukesh.com/blog/crud-with-dynamodb-in-aspnet-core/

#crud #dynamodb #aspdotnet #csharp #database #aws 

Triển Khai CRUD với DynamoDB trong ASP.NET Core
Diego  Elizondo

Diego Elizondo

1657900800

Implementar CRUD con DynamoDB en ASP.NET Core

En este artículo, aprenderemos a implementar CRUD con DynamoDB en ASP.NET Core Web API. Este artículo es una parte integral de la totalidad de "Aplicaciones sin servidor con AWS" que he estado escribiendo en mi blog. En un artículo anterior, cubrimos AWS Lamba usando .NET 6 Runtime y mucho más. Hoy, repasaremos los aspectos básicos de DynamoDB, la creación de tablas y claves de partición a través de la consola de AWS, el uso del paquete AWS DynamoDB Nuget y la conexión a las tablas desde nuestra aplicación .NET 6, la realización de operaciones CRUD básicas, etc.

Puede encontrar el código fuente completo de la implementación aquí .

Acerca de AWS DynamoDB

AWS Dynamo DB es un servicio de base de datos totalmente administrado y de alta disponibilidad proporcionado por Amazon Web Services. Es una base de datos NoSQL, lo que significa que no es una base de datos relacional. También es una parte importante y emblemática de todo el modelo de aplicaciones sin servidor de AWS. Dado que es escalable automáticamente, puede manejar millones de solicitudes por segundo y almacenar TB de datos en sus filas. Bastante interesante, ¿verdad? La velocidad con la que ocurre la recuperación de datos también es bastante impresionante, la latencia es bastante pequeña. Aparte de eso, está integrado con AWS IAM por seguridad (como cualquier otro servicio de AWS).

Al ser una base de datos compatible con NoSQL, es una base de datos clave/valor. Las claves primarias generalmente se componen de 1 o 2 claves. Otras propiedades (columnas) de la tabla de DynamoDB se conocen internamente como atributos.

Otra característica muy importante es que Amazon ofrece casi 25 GB de almacenamiento y hasta 200 millones de solicitudes de lectura/escritura al mes con la capa gratuita, que es más que suficiente si desea comenzar su viaje a AWS. Obtenga su cuenta de nivel GRATUITA aquí si aún no la tiene: https://aws.amazon.com/free/

CRUD con DynamoDB en ASP.NET Core

Lea más sobre Dynamo DB aquí: https://aws.amazon.com/dynamodb/

¿Qué construiremos?

Por lo tanto, construiremos una API WEB .NET 6 simple que puede conectarse a nuestro AWS DynamoDB en función de ciertas configuraciones que configuramos a través de la AWS CLI local y realizar algunas operaciones CRUD básicas sobre una entidad. En esta demostración, nuestra entidad será Student, con propiedades como Id, Name, Class, Country, solo las básicas. Y escribiremos código para crear, obtener un solo estudiante, obtener todos los estudiantes, eliminar y actualizar estudiantes.

Con eso claro, ¡comencemos!

Consola de AWS: base de datos de Dynamo

Supongo que ya tienes una cuenta de AWS (preferiblemente una cuenta GRATUITA que es más que suficiente para nuestro aprendizaje). ¡Hagamos algunos ejercicios prácticos con Amazon DynamoDB para conocerlo mejor!

Inicie sesión en su consola de AWS, busque DynamoDB en la barra de búsqueda superior de Servicios y ábralo.

A continuación, haga clic en Tablas o Crear tabla.

imagen 2 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Creación de una nueva tabla en DynamoDB a través de la consola

Como se discutió anteriormente, tendremos que crear una nueva tabla llamada estudiantes . Haga clic en "Crear tabla".

imagen 3 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Aquí, establezca el nombre de la tabla en " estudiantes " y la clave de partición como "id" (número). Entonces, esta será la clave principal de la tabla " estudiantes" . También tenga en cuenta que, al usar la clave de ordenación, podemos flexibilizar aún más la formación de la clave principal. Esto es más como un primario compuesto que se forma golpeando la clave de partición y la clave de ordenación.

Por ahora, no estamos configurando ninguna clave de ordenación. Deje los demás campos como están y cree la tabla.

imagen 11 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Eso es todo. Puede llevar un par de segundos aprovisionar completamente su tabla en DynamoDB. Una vez completado, el estado de su mesa cambia a Activo.

imagen 12 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Adición de datos a AWS DynamoDB a través de la consola

Una vez que se aprovisiona la tabla, agreguemos algunos datos a través de la consola. Haga clic en la mesa y presione "Explorar elementos de la mesa".

imagen 13 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Entonces, aquí es donde puede consultar los datos de esta tabla (si existe algún dato). La interfaz de usuario parece bastante intuitiva para trabajar con datos. Haga clic en "Crear elemento".

imagen 7 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Ahora, aquí AWS DynamoDB le permite definir datos en formatos JSON o agregar datos como campos de formulario. Haga clic en la pestaña JSON para cambiar a la siguiente vista. Aquí, agrego propiedades como Id, Nombre, Apellido, Clase y País.

imagen 14 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Puede volver a la vista de formulario para la apariencia a continuación. Sin embargo, prefiero usar la vista JSON.

imagen 15 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Una vez que ingresa los valores y hace clic en crear, AWS DynamoDB inserta el elemento en la tabla de estudiantes como puede ver a continuación.

imagen 16 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Así es como funciona la interfaz de DynamoDB. Escribamos algo de código ahora.

Primeros pasos: CRUD con DynamoDB en ASP.NET Core

Ahora que tenemos una práctica básica con AWS DynamoDB, construyamos una API web que pueda consumir este servicio de AWS.

Abra su IDE de Visual Studio (estoy usando Visual Studio 2022 Community con la última versión de .NET SDK instalada, que es 6.0.2). Asegúrese de que su entorno de desarrollo esté configurado.

Cree un nuevo proyecto de API web de ASP.NET Core y asígnele un nombre similar al siguiente.

imagen CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Asegúrese de seleccionar .NET 6 y marque la casilla de verificación " Usar controladores ". Además, asegúrese de haber habilitado la compatibilidad con OpenAPI, ya que probaremos nuestra aplicación a través de Swagger.

imagen 1 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Ahora que tiene el proyecto listo, hablemos sobre la configuración de las credenciales de AWS.

Configuración de la CLI de AWS

Entonces, para cada servicio de AWS con el que trabaja localmente, necesita un conjunto de credenciales para acceder a los puntos finales de AWS, ¿verdad? Si leyó mis artículos anteriores sobre AWS ( S3 o Lambda ), le mostré una forma de almacenar las credenciales de AWS de forma segura en su máquina local y evitar incluir estos detalles en su proyecto.

Navegue a AWS IAM para crear su usuario que tenga acceso a Dynamo DB. Para crear un nuevo usuario en AWS IAM, puede seguir esta sección de mi artículo anterior . La única diferencia es que, en lugar de seleccionar AmazonS3FullAccess Policy, deberá seleccionar una política relacionada con Dynamo DB. Asegúrese de tener los permisos de lectura, escritura y eliminación incluidos en la política seleccionada. Estas son las políticas relacionadas con DynamoDB.

imagen 19 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Puede elegir AmazonDynamoDBFullAccess por el momento. Pero recuerde siempre seleccionar solo lo que realmente necesita su aplicación.

Una vez que haya creado su usuario, se generará un conjunto de credenciales. Asegúrese de descargar este CSV generado para su custodia.

A continuación, para configurar estas credenciales en su máquina local, siga esta sección de mi artículo anterior .

Llamé a mi perfil aws-admin. Así es como se ve para mí.

imagen 18 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Es importante tener en cuenta que debe configurar la región de AWS adecuada. Por ejemplo, configuré mi región en ap-sur-1, que es Mumbai, India. Se debe seleccionar la misma región mientras se navega por la consola de AWS. Si hay una discrepancia en los nombres de las regiones, lo más probable es que no pueda ver su tabla aprovisionada en DDB.

Entonces, ahora que hemos configurado las credenciales de AWS, abramos nuestro appsettings.json en el proyecto y hagamos las modificaciones como se muestra a continuación.

Tenga en cuenta que mi nombre de perfil es aws-admin y la región de AWS más cercana a mí es ap-south-1. Realice los cambios correspondientes.

{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"AWS": {
"Profile": "aws-admin",
"Region": "ap-south-1"
}
}

Una vez hecho esto, AWS SDK podrá leer el nombre del perfil de appsettings.json y extraer los detalles de la credencial configurados y usarlos durante el tiempo de ejecución de nuestra aplicación.

Crear el modelo de estudiante

¿Recuerdas que creamos una tabla en AWS DynamoDB con ciertas propiedades? También necesitamos construir la misma clase de modelo en nuestro proyecto .NET.

Cree una nueva carpeta llamada Modelos y cree una clase debajo llamada Student.cs

using Amazon.DynamoDBv2.DataModel;
namespace DynamoStudentManager.Models
{
[DynamoDBTable("students")]
public class Student
{
[DynamoDBHashKey("id")]
public int? Id { get; set; }

[DynamoDBProperty("first_name")]
public string? FirstName { get; set; }

[DynamoDBProperty("last_name")]
public string? LastName { get; set; }

[DynamoDBProperty("class")]
public int Class { get; set; }

[DynamoDBProperty("country")]
public string? Country { get; set; }
}
}

Tenga en cuenta que hemos llamado a nuestra tabla de DynamoDB "estudiantes", pero el nombre de nuestra clase es "Estudiante" (incluso puede ser algo totalmente diferente). Entonces, para que el SDK de AWS comprenda que ambos son esencialmente los mismos modelos, debemos mapearlo.

Línea 4: Aquí le decimos al SDK que la tabla de DynamoDB " estudiantes" debe asignarse a la clase C# " Estudiante ".

Línea 7: DynamoDBHashKey define la clave principal de la tabla. Aquí, indicamos que Id será nuestra clave principal con el nombre de propiedad como "id" en la tabla DDB.

Línea 10,13,16,19: Definimos otras propiedades de la tabla junto con sus respectivos nombres de propiedad DDB.

Registro de servicio

Con los modelos configurados, registremos los servicios y la configuración de AWS dentro del contenedor de ASP.NET Core. Abra Program.cs y las siguientes líneas resaltadas.

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var awsOptions = builder.Configuration.GetAWSOptions();
builder.Services.AddDefaultAWSOptions(awsOptions);
builder.Services.AddAWSService<IAmazonDynamoDB>();
builder.Services.AddScoped<IDynamoDBContext, DynamoDBContext>();
var app = builder.Build();

Básicamente, esto carga la configuración de AWS desde el archivo appsettings.json y registra los servicios de AWS relacionados con DynamoDB en el contenedor de la aplicación.

Controlador de estudiantes

A continuación, escribamos el controlador API que realmente realizará las operaciones relacionadas con CRUD con DynamoDB en ASP.NET Core. Cree un nuevo Controlador API en blanco en la carpeta Controladores y el nombre es StudentController.

namespace DynamoStudentManager.Controllers;

[Route("api/[controller]")]
[ApiController]
public class StudentsController : ControllerBase
{
private readonly IDynamoDBContext _context;
public StudentsController(IDynamoDBContext context)
{
_context = context;
}
[HttpGet("{studentId}")]
public async Task<IActionResult> GetById(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
return Ok(student);
}
[HttpGet]
public async Task<IActionResult> GetAllStudents()
{
var student = await _context.ScanAsync<Student>(default).GetRemainingAsync();
return Ok(student);
}
[HttpPost]
public async Task<IActionResult> CreateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student != null) return BadRequest($"Student with Id {studentRequest.Id} Already Exists");
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
[HttpDelete("{studentId}")]
public async Task<IActionResult> DeleteStudent(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
await _context.DeleteAsync(student);
return NoContent();
}
[HttpPut]
public async Task<IActionResult> UpdateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student == null) return NotFound();
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
}

Línea 7-11: aquí, inyectamos IDynamoDBContext en el constructor del controlador. Mediante esta interfaz podremos acceder a AWS DynamoDB.

Línea 13-18: Obtiene elementos por Id (que es nuestra clave principal aquí). En la línea 15, cargamos la tabla Student (que se asigna a "students") y pasamos el StudentId recibido como HashKey a DynamoDB. Esto nos devuelve el registro del estudiante mapeado si existe.

Línea 20-24: Obtenga todos los registros de los estudiantes de la tabla DDB.

Línea 26-32: Aquí, pasamos un registro de Estudiante al punto final que luego intenta crear un nuevo registro en DDB con los detalles pasados. Primero verifica si la ID pasada ya existe en la base de datos. Si se encuentra, devuelve una excepción de solicitud incorrecta. De lo contrario, el registro del estudiante se crea como se esperaba.

Línea 34-40: Pasamos una identificación de estudiante a este punto final de eliminación. Primero comprueba si existe dicho registro con el Id pasado. Si no se encuentra, la aplicación genera una excepción NotFound y se interrumpe. De lo contrario, procede a eliminar el elemento de nuestra tabla de DynamoDB.

Línea 42-48: Aquí, tratamos de actualizar el registro del estudiante, pasando todas las propiedades como tales al punto final. Primero verificamos si existe la identificación del estudiante y luego continuamos actualizando el elemento. Tan simple como eso.

Pruebas

Con los controladores conectados, probemos nuestra aplicación. Dado que hemos habilitado la compatibilidad con OpenAPI para nuestra API, Swagger estaría funcionando de forma inmediata sin necesidad de configuraciones adicionales.

Ejecute la aplicación y navegue hasta localhost:xxxx/swagger en su navegador web. Esto debería abrir la interfaz de usuario de Swagger.

imagen 20 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Recuerde, creamos un nuevo registro anteriormente directamente a través de la consola de AWS DynamoDB. Le había dado una identificación de 1. Consultemos con esta identificación contra el punto final GET /api/students/1.

imagen 21 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Ahí lo tienes, tal como esperábamos. A continuación, vamos a crear un nuevo estudiante usando el punto final POST. Así es como se verían mis datos JSON para el nuevo estudiante con ID 2.

{
"id": 2,
"firstName": "John",
"lastName": "Musk",
"class": 10,
"country": "USA"
}

Puede ver que hay una respuesta 200 Ok de nuestra API, lo que significa que los datos se insertan en nuestra tabla DDB. Revisemos nuestra consola.

imagen 22 CRUD con DynamoDB en ASP.NET Core - Primeros pasos con AWS DynamoDB simplificado

Ahí lo tienes, nuestro nuevo estudiante está creado. Del mismo modo, dejo los puntos finales de API restantes para que los pruebe. Puede encontrar el código fuente completo de esta implementación aquí . Siéntase libre de seguir mi identificador de Github . Terminemos este artículo por ahora.

En el próximo artículo de esta serie, aprenderemos sobre las puertas de enlace de API y la creación de API de descanso sin servidor (API HTTP) adjuntando Lambdas a la puerta de enlace.

Resumen

En este artículo, aprendimos sobre cómo realizar CRUD con DynamoDB en ASP.NET Core, algunas prácticas con la interfaz de AWS DynamoDB, claves de partición, instalación de AWS CLI y configuración, creación de una API web que puede comunicarse con DDB y trabajar con datos, y así sucesivamente.

Comparta este artículo con sus colegas y círculos de desarrollo si lo encuentra interesante. Puede encontrar el  código fuente del proyecto  aquí. ¡Gracias!

Fuente: https://codewithmukesh.com/blog/crud-with-dynamodb-in-aspnet-core/

#crud #dynamodb #aspdotnet #csharp #database #aws 

Implementar CRUD con DynamoDB en ASP.NET Core
郝 玉华

郝 玉华

1657897500

如何在 ASP.NET Core Web API 中使用 DynamoDB 实现 CRUD

在本文中,我们将学习如何在 ASP.NET Core Web API 中使用 DynamoDB 实现 CRUD。本文是我在博客上写的整个“使用 AWS 的无服务器应用程序”的一个组成部分。在之前的文章中,我们介绍了使用 .NET 6 运行时的 AWS Lamba等等。今天,我们将介绍 DynamoDB 的基础知识,通过 AWS 控制台创建表和分区键,使用 AWS DynamoDB Nuget 包,并从我们的 .NET 6 应用程序连接到表,执行基本的 CRUD 操作等等。

您可以在此处找到实现的完整源代码

关于 AWS DynamoDB

AWS Dynamo DB 是由 Amazon Web Services 提供的高度可用、完全托管的数据库服务。它是 NoSQL 数据库,这意味着它不是关系数据库。它也是整个 AWS 无服务器应用模型的重要和旗舰部分。由于它是可自动扩展的,它每秒可以处理数百万个请求并在其行中存储 TB 的数据。很有趣,对吧?数据检索发生的速度也非常令人印象深刻,延迟非常小。除此之外,它还与 AWS IAM 集成以提高安全性(就像所有其他 AWS 服务一样)。

作为符合 NoSQL 的数据库,它是一个键/值数据库。主键通常由 1 个或 2 个键组成。DynamoDB 表的其他属性(列)在内部称为属性。

另一个非常重要的功能是,Amazon 提供近 25 GB 的存储空间和每月多达 2 亿次读/写请求的免费套餐,如果您想开始 AWS 之旅,这已经绰绰有余了。如果您还没有,请在此处获取您的免费等级帐户 – https://aws.amazon.com/free/

CRUD 与 ASP.NET Core 中的 DynamoDB

在此处阅读有关 Dynamo DB 的更多信息 – https://aws.amazon.com/dynamodb/

我们将建造什么?

因此,我们将构建一个简单的 .NET 6 WEB API,它可以基于我们通过本地 AWS CLI 设置的某些配置连接到我们的 AWS DynamoDB,并对实体执行一些基本的 CRUD 操作。在此演示中,我们的实体将是 Student,具有 Id、Name、Class、Country 等属性,只是基本属性。而且,我们将编写代码来创建、获取单个学生、获取所有学生、删除和更新学生。

清楚了,让我们开始吧!

AWS 控制台 – Dynamo 数据库

我假设您已经有一个 AWS 帐户(最好是一个免费帐户,这对于我们的学习来说绰绰有余)。让我们使用 Amazon DynamoDB 进行一些动手练习以更好地了解它!

登录到您的 AWS 控制台,在顶部的服务搜索栏中搜索 DynamoDB,然后将其打开。

接下来,单击表或创建表。

图 2 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

通过控制台在 DynamoDB 中创建新表

如前所述,我们必须创建一个名为students的新表。点击“创建表”。

图 3 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

在这里,将表名设置为“ students ”,将分区键设置为“id”(数字)。因此,这将是“学生”表的主键。另请注意,通过使用排序键,我们可以进一步调整主键格式。这更像是一个复合 Primary,它是由 Partition Key 和 Sort Key 组合而成的。

目前,我们没有设置任何排序键。保持其他字段不变并创建表。

图 11 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

这就是一切。将您的表完全预置到 DynamoDB 可能需要几秒钟。完成后,您的表格状态将变为活动。

图 12 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

通过控制台将数据添加到 AWS DynamoDB

配置表后,让我们通过控制台向其中添加一些数据。单击表格并点击“探索表格项目”。

图 13 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

因此,您可以在此处查询该表中的数据(如果存在任何数据)。UI 对于处理数据似乎非常直观。点击“创建项目”。

图 7 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

现在,AWS DynamoDB 允许您以 JSON 格式定义数据或将数据添加为表单字段。单击 JSON 选项卡以切换到以下视图。在这里,我添加了 Id、First Name、Last Name、Class 和 Country 等属性。

图 14 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

您可以切换回表单视图以获得以下外观。不过我更喜欢使用 JSON 视图。

图 15 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

输入值并单击创建后,AWS DynamoDB 会将项目插入到学生表中,如下所示。

图 16 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

这就是 DynamoDB 界面的工作原理。现在让我们编写一些代码。

入门 - 在 ASP.NET Core 中使用 DynamoDB 进行 CRUD

现在我们已经对 AWS DynamoDB 进行了基本的实践,让我们构建一个可以使用此 AWS 服务的 Web API。

打开您的 Visual Studio IDE(我正在使用 Visual Studio 2022 社区并安装了最新版本的 .NET SDK,即 6.0.2)。确保您的开发环境已设置好。

创建一个新的 ASP.NET Core Web API 项目并将其命名如下。

在 ASP.NET Core 中使用 DynamoDB 的图像 CRUD - 简化 AWS DynamoDB 入门

确保选择 .NET 6 并选中“使用控制器”复选框。此外,请确保您已启用 OpenAPI 支持,因为我们将通过 Swagger 测试我们的应用程序。

图 1 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

现在您已经完成了项目,让我们来谈谈配置 AWS 凭证。

AWS CLI 配置

因此,对于您在本地使用的每项 AWS 服务,您都需要一组凭证来访问 AWS 端点,对吗?如果您阅读过我之前关于 AWS(S3Lambda)的文章,我已经展示了一种将 AWS 凭证安全地存储到您的本地计算机上并避免在您的项目中包含这些详细信息的方法。

导航到 AWS IAM 以创建有权访问 Dynamo DB 的用户。要在 AWS IAM 上创建新用户,您可以按照我之前文章的这一部分进行操作。唯一的区别是,您必须选择与 Dynamo DB 相关的策略,而不是选择 AmazonS3FullAccess Policy。确保您具有所选策略中包含的读取、写入和删除权限。以下是与 DynamoDB 相关的策略。

图 19 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

您可以暂时选择AmazonDynamoDBFullAccess。但请始终记住只选择您的应用程序实际需要的内容。

创建用户后,将生成一组凭据。确保下载此生成的 CSV 以妥善保管。

接下来,要在本地计算机上配置这些凭据,请按照我上一篇文章的这一部分进行操作。

我将我的个人资料命名为 aws-admin。这就是我的样子。

图 18 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

请务必注意,您必须设置正确的 AWS 区域。例如,我将我的区域设置为印度孟买的 ap-south-1。导航 AWS 控制台时必须选择相同的区域。如果区域名称不匹配,很可能您将无法在 DDB 上看到您配置的表。

所以,现在我们已经配置了 AWS 凭证,让我们在项目中打开我们的 appsettings.json 并进行如下修改。

请注意,我的个人资料名称是 aws-admin,离我最近的 AWS 区域是 ap-south-1。相应地进行更改。

{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"AWS": {
"Profile": "aws-admin",
"Region": "ap-south-1"
}
}

完成后,AWS SDK 将能够从 appsettings.json 读取配置文件名称并提取配置的凭证详细信息,并在我们的应用程序运行时使用它。

创建学生模型

还记得我们在 AWS DynamoDB 上创建具有某些属性的表吗?我们也需要在我们的 .NET 项目上构建相同的模型类。

创建一个名为 Models 的新文件夹,并在其下创建一个名为 Student.cs 的类

using Amazon.DynamoDBv2.DataModel;
namespace DynamoStudentManager.Models
{
[DynamoDBTable("students")]
public class Student
{
[DynamoDBHashKey("id")]
public int? Id { get; set; }

[DynamoDBProperty("first_name")]
public string? FirstName { get; set; }

[DynamoDBProperty("last_name")]
public string? LastName { get; set; }

[DynamoDBProperty("class")]
public int Class { get; set; }

[DynamoDBProperty("country")]
public string? Country { get; set; }
}
}

请注意,我们将 DynamoDB 表命名为“students”,但我们的班级名称是“Student”(甚至可以是完全不同的名称)。因此,为了让 AWS 开发工具包了解这两者本质上是相同的模型,我们需要对其进行映射。

第 4 行:这里我们告诉 SDK“学生” DynamoDB 表必须映射到“学生”C# 类。

第 7 行:DynamoDBHashKey 定义表的主键。在这里,我们指出 Id 将是我们在 DDB 表中属性名称为“id”的主键。

第 10、13、16、19 行:我们定义了表的其他属性以及它们各自的 DDB 属性名称。

服务注册

设置好模型后,让我们在 ASP.NET Core 容器中注册 AWS 服务和配置。打开 Program.cs 和以下突出显示的行。

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var awsOptions = builder.Configuration.GetAWSOptions();
builder.Services.AddDefaultAWSOptions(awsOptions);
builder.Services.AddAWSService<IAmazonDynamoDB>();
builder.Services.AddScoped<IDynamoDBContext, DynamoDBContext>();
var app = builder.Build();

这实质上是从 appsettings.json 文件加载 AWS 配置,并将与 DynamoDB 相关的 AWS 服务注册到应用程序的容器中。

学生控制器

接下来,让我们编写 API 控制器,该控制器将在 ASP.NET Core 中使用 DynamoDB 实际执行与 CRUD 相关的操作。在 Controllers 文件夹下新建一个空白 API 控制器,名称为 StudentController。

namespace DynamoStudentManager.Controllers;

[Route("api/[controller]")]
[ApiController]
public class StudentsController : ControllerBase
{
private readonly IDynamoDBContext _context;
public StudentsController(IDynamoDBContext context)
{
_context = context;
}
[HttpGet("{studentId}")]
public async Task<IActionResult> GetById(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
return Ok(student);
}
[HttpGet]
public async Task<IActionResult> GetAllStudents()
{
var student = await _context.ScanAsync<Student>(default).GetRemainingAsync();
return Ok(student);
}
[HttpPost]
public async Task<IActionResult> CreateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student != null) return BadRequest($"Student with Id {studentRequest.Id} Already Exists");
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
[HttpDelete("{studentId}")]
public async Task<IActionResult> DeleteStudent(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
await _context.DeleteAsync(student);
return NoContent();
}
[HttpPut]
public async Task<IActionResult> UpdateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student == null) return NotFound();
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
}

第 7-11 行:在这里,我们将 IDynamoDBContext 注入到控制器的构造函数中。使用此界面,我们将能够访问 AWS DynamoDB。

第 13-18 行:通过 Id 获取项目(这里是我们的主键)。在第 15 行,我们加载 Student 表(它被映射到“students”)并将接收到的 StudentId 作为 HashKey 传递给 DynamoDB。这将返回我们映射的学生记录(如果存在)。

第 20-24 行:从 DDB 表中获取所有学生记录。

第 26-32 行:在这里,我们将一条 Student 记录传递给端点,然后端点尝试使用传递的详细信息在 DDB 中创建一条新记录。它首先检查传递的 ID 是否已存在于数据库中。如果找到它会返回错误请求异常。否则,将按预期创建学生记录。

第 34-40 行:我们将学生 ID 传递到此 Delete 端点。它首先检查是否存在具有传递的 ID 的此类记录。如果未找到,应用程序将引发 NotFound 异常并中断。否则,它将继续从我们的 DynamoDB 表中删除该项目。

第 42-48 行:在这里,我们尝试通过将整个属性传递给端点来更新学生记录。我们先检查studentId是否存在,然后继续更新item。就如此容易。

测试

连接好控制器后,让我们测试我们的应用程序。由于我们为我们的 API 启用了 OpenAPI 支持,因此 Swagger 可以开箱即用,无需任何额外配置。

运行应用程序并在 Web 浏览器上导航到 localhost:xxxx/swagger。这应该会打开 Swagger UI。

图 20 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

请记住,我们之前直接通过 AWS 控制台 DynamoDB 创建了一条新记录。我给它的 ID 为 1。让我们用这个 ID 查询 GET /api/students/1 端点。

图 21 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

就这样,正如我们预期的那样。接下来,让我们使用 POST 端点创建一个新学生。下面是我的 JSON 数据对于 ID 为 2 的新学生的样子。

{
"id": 2,
"firstName": "John",
"lastName": "Musk",
"class": 10,
"country": "USA"
}

您可以看到我们的 API 有一个 200 Ok 响应,这意味着数据已插入到我们的 DDB 表中。让我们检查一下我们的控制台。

图 22 在 ASP.NET Core 中使用 DynamoDB 的 CRUD - AWS DynamoDB Simplified 入门

好了,我们的新学生就创建好了。同样,我将剩余的 API 端点留给您进行测试。您可以在此处找到此实现的完整源代码。随意关注我的 Github 句柄。让我们暂时结束这篇文章。

在本系列的下一篇文章中,我们将了解 API 网关以及通过将 Lambda 附加到网关来创建无服务器 Rest API (HTTP API)。

概括

在本文中,我们了解了在 ASP.NET Core 中使用 DynamoDB 执行 CRUD、AWS DynamoDB 接口的一些实践、分区键、安装和配置 AWS CLI、构建可以与 DDB 通信并使用的 Web API数据等。

如果您觉得这篇文章很有趣,请与您的同事和开发人员圈子分享这篇文章。你可以在这里找到 项目的源代码 。谢谢!

来源:https ://codewithmukesh.com/blog/crud-with-dynamodb-in-aspnet-core/

#crud #dynamodb #aspdotnet #csharp #database #aws 

如何在 ASP.NET Core Web API 中使用 DynamoDB 实现 CRUD
Iara  Simões

Iara Simões

1657897500

Implementar O CRUD com DynamoDB no ASP.NET Core

Neste artigo, aprenderemos sobre como implementar o CRUD com o DynamoDB na API Web ASP.NET Core. Este artigo é parte integrante de todo o “Serverless Applications with AWS” que escrevi no meu blog. Em um artigo anterior, abordamos o AWS Lamba usando o .NET 6 Runtime e muito mais. Hoje, abordaremos o básico do DynamoDB, criando tabelas e chaves de partição por meio do Console AWS, usando o pacote AWS DynamoDB Nuget e conectando-se às tabelas do nosso aplicativo .NET 6, realizando operações básicas de CRUD e assim por diante.

Você pode encontrar o código-fonte completo da implementação aqui .

Sobre o AWS DynamoDB

O AWS Dynamo DB é um serviço de banco de dados totalmente gerenciado e altamente disponível fornecido pela Amazon Web Services. É um banco de dados NoSQL, o que significa que não é um banco de dados relacional. Também é uma parte importante e emblemática de todo o modelo de aplicativo sem servidor da AWS. Como é escalonável automaticamente, ele pode lidar com milhões de solicitações por segundo e armazenar TBs de dados em suas linhas. Bem interessante, certo? A velocidade com que a recuperação de dados acontece também é bastante impressionante, a latência é bem pequena. Fora isso, ele é integrado ao AWS IAM para segurança (como todos os outros serviços da AWS).

Sendo um banco de dados compatível com NoSQL, é um banco de dados de chave/valor. As Chaves Primárias são geralmente compostas por 1 ou 2 chaves. Outras propriedades (colunas) da tabela do DynamoDB são conhecidas internamente como atributos.

Outro recurso muito importante é que a Amazon oferece quase 25 GB de armazenamento e até 200 milhões de solicitações de leitura/gravação por mês com o nível gratuito, o que é mais do que suficiente se você deseja iniciar sua jornada na AWS. Obtenha sua conta de nível GRATUITO aqui se ainda não tiver uma – https://aws.amazon.com/free/

CRUD com DynamoDB no ASP.NET Core

Leia mais sobre o Dynamo DB aqui – https://aws.amazon.com/dynamodb/

O que vamos construir?

Portanto, construiremos uma API .NET 6 WEB simples que pode se conectar ao nosso AWS DynamoDB com base em determinadas configurações que configuramos por meio da AWS CLI local e realizar algumas operações CRUD básicas em uma entidade. Nesta demonstração, nossa entidade será Student, com propriedades como Id, Name, Class, Country, apenas as básicas. E estaremos escrevendo código para criar, obter um único aluno, obter todos os alunos, excluir e atualizar alunos.

Com isso claro, vamos começar!

Console AWS – Dynamo DB

Suponho que você já tenha uma conta AWS (de preferência uma conta GRATUITA que é mais que suficiente para nosso aprendizado). Vamos fazer alguns exercícios práticos com o Amazon DynamoDB para conhecê-lo melhor!

Faça login no seu Console AWS, procure DynamoDB na barra de pesquisa de serviços superior e abra-o.

Em seguida, clique em Tabelas ou Criar Tabela.

image 2 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Criando uma nova tabela no DynamoDB por meio do console

Conforme discutido anteriormente, teremos que criar uma nova tabela chamada students . Clique em “Criar Tabela”.

image 3 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Aqui, defina o nome da tabela para “ alunos ” e a Chave de Partição como “id” (número). Então, esta será a chave primária da tabela “alunos” . Observe também que, usando a chave de classificação, podemos flexibilizar ainda mais a formação da chave primária. Isso é mais como um Primário composto que é formado por baqueteamento da Chave de Partição e da Chave de Classificação.

Por enquanto, não estamos configurando nenhuma chave de classificação. Deixe os outros campos como estão e crie a tabela.

image 11 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Isso é tudo. Pode levar alguns segundos para provisionar completamente sua tabela para o DynamoDB. Depois de concluído, o status da sua mesa passa para Ativo.

image 12 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Adicionando dados ao AWS DynamoDB por meio do console

Depois que a tabela for provisionada, vamos adicionar alguns dados a ela por meio do console. Clique na mesa e clique em “Explorar Itens da Mesa”.

image 13 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Portanto, é aqui que você pode consultar dados dessa tabela (se houver algum dado). A interface do usuário parece bastante intuitiva para trabalhar com dados. Clique em “Criar item”.

image 7 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Agora, aqui, o AWS DynamoDB permite definir dados em formatos JSON ou adicionar dados como campos de formulário. Clique na guia JSON para alternar para a visualização a seguir. Aqui, adiciono propriedades como Id, First Name, Last Name, Class e Country.

image 14 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Você pode voltar para o modo de formulário para a aparência abaixo. Eu prefiro usar a visualização JSON.

image 15 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Depois de inserir os valores e clicar em criar, o AWS DynamoDB insere o item na tabela de alunos, como você pode ver abaixo.

image 16 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

É assim que a interface do DynamoDB funciona. Vamos escrever algum código agora.

Introdução – CRUD com DynamoDB no ASP.NET Core

Agora que temos uma experiência prática básica com o AWS DynamoDB, vamos criar uma API da Web que possa consumir esse serviço da AWS.

Abra seu Visual Studio IDE (estou usando o Visual Studio 2022 Community com a iteração mais recente do .NET SDK instalado, que é 6.0.2). Certifique-se de que seu ambiente de desenvolvimento esteja configurado.

Crie um novo projeto de API Web ASP.NET Core e nomeie-o como o abaixo.

image CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Certifique-se de selecionar .NET 6 e marque a caixa de seleção “ Use Controllers ”. Além disso, verifique se você ativou o suporte OpenAPI, pois testaremos nosso aplicativo via Swagger.

image 1 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Agora que você tem o projeto pronto, vamos falar sobre como configurar as credenciais da AWS.

Configuração da AWS CLI

Portanto, para cada serviço da AWS com o qual você trabalha localmente, você precisa de um conjunto de credenciais para acessar os endpoints da AWS, certo? Se você leu meus artigos anteriores sobre AWS ( S3 ou Lambda ), mostrei uma maneira de armazenar as credenciais da AWS com segurança em sua máquina local e evitar incluir esses detalhes em seu projeto.

Navegue até o AWS IAM para criar seu usuário que tenha acesso ao Dynamo DB. Para criar um novo usuário no AWS IAM, você pode seguir esta seção do meu artigo anterior . A única diferença é que, em vez de selecionar a política AmazonS3FullAccess, você teria que selecionar uma política relacionada ao Dynamo DB. Certifique-se de ter as permissões de leitura, gravação e exclusão incluídas na política selecionada. Aqui estão as políticas relacionadas ao DynamoDB.

image 19 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Você pode escolher AmazonDynamoDBFullAccess por enquanto. Mas lembre-se sempre de selecionar apenas o que é realmente necessário para seu aplicativo.

Depois de criar seu usuário, um conjunto de credenciais será gerado. Certifique-se de baixar este CSV gerado por segurança.

Em seguida, para configurar essas credenciais em sua máquina local, siga esta seção do meu artigo anterior .

Eu nomeei meu perfil como aws-admin. Aqui está como parece para mim.

image 18 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

É importante observar que você precisa definir a região da AWS adequada. Por exemplo, defini minha região como ap-south-1, que é Mumbai, Índia. A mesma região deve ser selecionada durante a navegação no Console AWS. Se houver uma incompatibilidade nos nomes das regiões, provavelmente você não poderá ver sua tabela provisionada no DDB.

Então, agora que configuramos as credenciais da AWS, vamos abrir nosso appsettings.json no projeto e fazer as modificações conforme abaixo.

Observe que meu nome de perfil é aws-admin e a região da AWS mais próxima de mim é ap-south-1. Faça as alterações de acordo.

{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"AWS": {
"Profile": "aws-admin",
"Region": "ap-south-1"
}
}

Feito isso, o AWS SDK poderá ler o nome do perfil do appsettings.json e extrair os detalhes da credencial configurados, e usá-lo durante o tempo de execução do nosso aplicativo.

Criando o modelo do aluno

Lembre-se de criar uma tabela no AWS DynamoDB com determinadas propriedades? Precisamos construir a mesma classe de modelo em nosso projeto .NET também.

Crie uma nova pasta chamada Models e crie uma classe nela chamada Student.cs

using Amazon.DynamoDBv2.DataModel;
namespace DynamoStudentManager.Models
{
[DynamoDBTable("students")]
public class Student
{
[DynamoDBHashKey("id")]
public int? Id { get; set; }

[DynamoDBProperty("first_name")]
public string? FirstName { get; set; }

[DynamoDBProperty("last_name")]
public string? LastName { get; set; }

[DynamoDBProperty("class")]
public int Class { get; set; }

[DynamoDBProperty("country")]
public string? Country { get; set; }
}
}

Observe que nomeamos nossa tabela do DynamoDB como “alunos”, mas o nome da nossa classe é “Aluno” (pode até ser algo totalmente diferente). Portanto, para que o AWS SDK entenda que esses dois são essencialmente os mesmos modelos, precisamos mapeá-lo.

Linha 4: Aqui informamos ao SDK que a tabela do DynamoDB “alunos” deve ser mapeada para a classe C# “ Aluno ”.

Linha 7: DynamoDBashKey define a chave primária da tabela. Aqui, indicamos que Id será nossa chave primária com o nome da propriedade como “id” na tabela DDB.

Linha 10,13,16,19: Definimos outras propriedades da tabela junto com seus respectivos nomes de propriedade DDB.

Registro de serviço

Com os modelos configurados, vamos registrar os serviços da AWS e a configuração no contêiner ASP.NET Core. Abra o Program.cs e as seguintes linhas destacadas.

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var awsOptions = builder.Configuration.GetAWSOptions();
builder.Services.AddDefaultAWSOptions(awsOptions);
builder.Services.AddAWSService<IAmazonDynamoDB>();
builder.Services.AddScoped<IDynamoDBContext, DynamoDBContext>();
var app = builder.Build();

Isso basicamente carrega a configuração da AWS do arquivo appsettings.json e registra os serviços da AWS relacionados ao DynamoDB no contêiner do aplicativo.

Controlador Aluno

Em seguida, vamos escrever o controlador de API que realmente executará as operações relacionadas a CRUD com o DynamoDB no ASP.NET Core. Crie um novo controlador de API em branco na pasta Controllers e o nome seja StudentController.

namespace DynamoStudentManager.Controllers;

[Route("api/[controller]")]
[ApiController]
public class StudentsController : ControllerBase
{
private readonly IDynamoDBContext _context;
public StudentsController(IDynamoDBContext context)
{
_context = context;
}
[HttpGet("{studentId}")]
public async Task<IActionResult> GetById(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
return Ok(student);
}
[HttpGet]
public async Task<IActionResult> GetAllStudents()
{
var student = await _context.ScanAsync<Student>(default).GetRemainingAsync();
return Ok(student);
}
[HttpPost]
public async Task<IActionResult> CreateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student != null) return BadRequest($"Student with Id {studentRequest.Id} Already Exists");
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
[HttpDelete("{studentId}")]
public async Task<IActionResult> DeleteStudent(int studentId)
{
var student = await _context.LoadAsync<Student>(studentId);
if (student == null) return NotFound();
await _context.DeleteAsync(student);
return NoContent();
}
[HttpPut]
public async Task<IActionResult> UpdateStudent(Student studentRequest)
{
var student = await _context.LoadAsync<Student>(studentRequest.Id);
if (student == null) return NotFound();
await _context.SaveAsync(studentRequest);
return Ok(studentRequest);
}
}

Linha 7-11: Aqui, injetamos o IDynamoDBContext no construtor do controlador. Usando essa interface, poderemos acessar o AWS DynamoDB.

Linha 13-18: Obtém itens por Id (que é nossa chave primária aqui). Na linha 15, carregamos a tabela Student (que é mapeada para “students”) e passamos o StudentId recebido como HashKey para o DynamoDB. Isso nos retorna o registro do Aluno mapeado, se existir.

Linha 20-24: Obtenha todos os registros dos alunos da tabela DDB.

Linha 26-32: Aqui, passamos um registro Student para o endpoint que tenta criar um novo registro no DDB com os detalhes passados. Ele primeiro verifica se o ID passado já existe no banco de dados. Se encontrado, ele retorna uma exceção de solicitação incorreta. Caso contrário, o registro do aluno é criado conforme o esperado.

Linha 34-40: Passamos um ID de aluno para este ponto de extremidade Excluir. Ele primeiro verifica se tal registro existe com o Id passado. Se não for encontrado, o aplicativo lançará uma exceção NotFound e será interrompido. Caso contrário, ele exclui o item da nossa tabela do DynamoDB.

Linha 42-48: Aqui, tentamos atualizar o registro do aluno, passando todas as propriedades como tal para o terminal. Primeiro verificamos se o ID do aluno existe e, em seguida, continuamos a atualizar o item. Tão simples como isso.

Teste

Com os controladores conectados, vamos testar nossa aplicação. Como habilitamos o suporte OpenAPI para nossa API, o Swagger funcionaria imediatamente sem a necessidade de configurações adicionais.

Execute o aplicativo e navegue até localhost:xxxx/swagger em seu navegador da web. Isso deve abrir a interface do usuário do Swagger.

image 20 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Lembre-se de que criamos um novo registro anteriormente diretamente por meio do Console AWS DynamoDB. Eu dei a ele um Id de 1. Vamos consultar com este Id no endpoint GET /api/students/1.

image 21 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Pronto, como esperávamos. Em seguida, vamos criar um novo aluno usando o endpoint POST. Veja como seriam meus dados JSON para o novo aluno com ID 2.

{
"id": 2,
"firstName": "John",
"lastName": "Musk",
"class": 10,
"country": "USA"
}

Você pode ver que há uma resposta 200 Ok da nossa API, o que significa que os dados são inseridos em nossa tabela DDB. Vamos verificar nosso console.

image 22 CRUD com DynamoDB no ASP.NET Core - Conceitos básicos do AWS DynamoDB simplificado

Pronto, nosso novo aluno está criado. Da mesma forma, deixo os endpoints restantes da API para você testar. Você pode encontrar todo o código-fonte desta implementação aqui . Sinta-se à vontade para seguir meu handle do Github . Vamos encerrar este artigo por enquanto.

No próximo artigo desta série, aprenderemos sobre gateways de API e como criar APIs Serverless Rest (APIs HTTP) anexando Lambdas ao gateway.

Resumo

Neste artigo, aprendemos sobre a execução de CRUD com o DynamoDB no ASP.NET Core, algumas práticas com a interface do AWS DynamoDB, chaves de partição, instalação da AWS CLI e configuração, criação de uma API da Web que pode se comunicar com o DDB e trabalhar com dados, e assim por diante.

Compartilhe este artigo com seus colegas e círculos de desenvolvedores se você achou isso interessante. Você pode encontrar o  código-fonte do projeto  aqui. Obrigado!

Fonte: https://codewithmukesh.com/blog/crud-with-dynamodb-in-aspnet-core/

#crud #dynamodb #aspdotnet #csharp #database #aws 

 Implementar O CRUD com DynamoDB no ASP.NET Core