[AWS] AWS CLI와 SDK를 이용한 DynamoDB CRUD

✔️ AWS CLI를 사용해 DynamoDB 테이블 생성하기 

DynamoDB 테이블을 생성하려면 다음 명령을 실행한다.

aws dynamodb create-table \
> --table-name [테이블명] \
> --attribute-definitions \
> AttributeName=year,AttributeType=N \
> AttributeName=title,AttributeType=S \
> --key-schema \
> AttributeName=year,KeyType=HASH \
> AttributeName=title,KeyType=RANGE \
> --billing-mode PROVISIONED \
> --provisioned-throughput \
> ReadCapacityUnits=10,WriteCapacityUnits=10

• aws dynamodb create-table : 새 테이블을 만드는 기본 명령 
• --table-name : 테이블 이름 지정
• --attribute-definitions : 생성할 초기 속성 지정, 테이블의 pk로 사용하려는 속성을 반드시 포함해야 한다.
  • AttributeName=year,AttributeType=N : year라는 숫자 유형 속성 지정
  • AttributeName=title,AttributeType=S : title이라는 문자열 유형 속성 지정 
• --key-schema : 기본 키에 사용되는 속성 지정
  • AttributeName=year, KeyType=HASH : 파티션(HASH) 키로 사용할 속성 지정
  • AttributeName=title, KeyType=RANGE : 정렬(RANGE) 키로 사용할 속성 지정
• --billing-mode : 읽기 및 쓰기 처리량에 대해 요금이 부과되는 방식을 지정한다.
• --provisioned-throughput : 테이블에 대해 프로비저닝된 처리량 설정을 지정한다.

명령을 실행하면 다음과 같은 JSON 형식의 테이블 세부 정보를 표시한다.

{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "title",
                "AttributeType": "S"
            },
            {
                "AttributeName": "year",
                "AttributeType": "N"
            }
        ],
        "TableName": "movies",
        "KeySchema": [
            {
                "AttributeName": "year",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "title",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-11-21T01:53:20.080000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:012345678901:table/movies",
        "TableId": "03bcd8c5-7d31-4c45-ba41-11e9e4487c00"
    }
}

✔️ 테이블 상태 확인 

테이블에 항목을 추가하려면 우선 테이블이 활성 상태여야 한다.

테이블의 상태를 확인하기 위해 다음 명령을 실행한다.

테이블이 활성화 상태라면 "ACTIVE" 라고 출력된다.

aws dynamodb describe-table \
--table-name [테이블명] \
--query "Table.TableStatus"
"ACTIVE"

✔️ DynamoDB 테이블에 항목 추가하기

테이블에 항목을 추가하려면 다음 명령을 입력한다.

aws dynamodb put-Item \
--table-name [사용 테이블명] \
--item '{
     "속성1": {"속성 타입": "속성 값"},
     "속성2": {"속성 타입": "속성 값"},
     "속성3": {"속성 타입": ["속성 값1", "속성 값2", "속성 값3"]}
     }'

✔️ 테이블 scan 및 필터를 이용해 항목 가져오기

테이블에 값이 있으므로 get-item, batch-get-item, 쿼리 및 스캔과 같은 다양한 명령을 사용해 데이터를 가져올 수 있다.

테이블의 모든 값 목록을 반환하는 전체 테이블을 스캔하기

aws dynamodb scan \
--table-name [테이블명]

✔️ scan 결과에 filter 적용하기

전체 테이블을 스캔하되 특정 속성 값만을 가진 항목을 반환하기 

aws dynamodb scan \
--table-name [테이블명] \
--filter-expression "[속성] = :name" \
--expression-attribute-values '{":name": {"속성타입": "속성값"}}'

 

✔️ 쿼리 작업으로 항목 가져오기

쿼리 작업은 pk를 기반으로 항목을 가져온다. 쿼리를 수행할 때 최소한 파티션 키 값을 제공해야 한다.

aws dynamodb query \
--table-name [테이블명] \
--projection-expression "속성명" \
--key-condition-expression "#y = :yr" \
--expression-attribute-names '{"#y":"year"}' \
--expression-attribute-values '{":yr":{"N":"속성값"}}'

• aws dynamodb query : 테이블을 쿼리하는 기본 명령
• --table-name : 테이블의 이름을 지정한다.
• --projection-expression : 명령의 출력에 표시할 속성을 지정한다. 
• --key-condition-expression : 검색할 파티션 키 속성을 지정한다.
• --expression-attribute-names : 속성 이름 대신 사용할 값을 지정한다. 이때 year는 DynamoDB의 예약어이므로 어떤 표현식에서도 사용할 수 없다. year 대신 #y로 표현식 속성 이름을 사용할 수 있다. 테이블에 예약어 목록에 있는 속성 이름이 포함되어 있으면 표현식 속성 이름을 사용할 수 있다. 
• --expression-attribute-values : 쿼리할 키 조건 표현식의 속성 값을 지정한다.

✔️ 항목 업데이트 

각 항목에 속성을 추가하기 

aws dynamodb update-item \
--table-name [테이블명] \
--key '{
  "속성1": {"속성타입": "속성값"},
  "속성2": {"속성타입" :"속성값"}
  }' \
--update-expression 'SET #rating = :rate' \
--expression-attribute-names '{
  "#rating": "rating"
  }' \
--expression-attribute-values '{":rate": {"N": "9.2"}}'

예시

aws dynamodb get-item --table-name movies --key '{"속성1": {"속성타입": "속성값"}, "속성2": {"속성타입": "속성값"}}'

✔️ 항목 삭제

aws dynamodb delete-item \
--table-name movies\
--key '{
  "속성1": {"속성타입" : "속성값"},
  "속성2": {"속성타입" : "속성값"},
  }'

✔️ 항목 삭제 후 확인

aws dynamodb scan \
--table-name [테이블명]

✔️ 테이블 삭제 

aws dynamodb delete-table \
--table-name [테이블명]

✔️ 테이블 확인

aws dynamodb list-tables
{
    "TableNames": []
}

---

✔️ Python용 AWS SDK를 사용해 DynamoDB 테이블 생성 및 관리하기

Python 프로그래밍을 통해 스크립트를 작성하여 DynamoDB의 CRUD를 수행 할 수 있다.

 

우선 다음 명령을 실행해 Python용 AWS SDK인 Boto3을 설치한다. 

sudo pip install boto3

실습 환경은 cloud9이며 [File] → [New File]을 클릭해 새로운 python 파일을 CRUD 할 수 있다. 

✔️ AWS SDK를 사용해 DynamoDB 테이블 생성

DynamoDB를 생성하기 위한 예제 python 파일 

import boto3


def create_movie_table():

    region=boto3.session.Session().region_name

    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.create_table(
        TableName='movies',
        KeySchema=[
            {
                'AttributeName': 'year',
                'KeyType': 'HASH'  # Partition key
            },
            {
                'AttributeName': 'title',
                'KeyType': 'RANGE'  # Sort key
            }
        ],
        AttributeDefinitions=[
            {
                'AttributeName': 'year',
                'AttributeType': 'N'
            },
            {
                'AttributeName': 'title',
                'AttributeType': 'S'
            },

        ],
        ProvisionedThroughput={
            'ReadCapacityUnits': 10,
            'WriteCapacityUnits': 10
        },
        BillingMode='PROVISIONED'
    )
    return table


if __name__ == '__main__':
    movie_table = create_movie_table()
    print("Table status:", movie_table.table_status)

테이블을 생성하려면 python 파일을 실행한다.

python [파일명 ex. CreateTable.py]

정상적으로 테이블이 생성되었으면 Table status: CREATING 이 출력된다.

 

모든 DynamoDB 테이블을 나열하고 테이블이 생성되었는지 확인하기 위해 다음 명령을 실행한다.

aws dynamodb describe-table --table-name [테이블명]

테이블이 성공적으로 생성되었다면 TableStatus 값이 Active일 것이다.

 

✔️ AWS SDK를 사용해 DynamoDB 테이블에 항목 추가

항목 추가 예제 python 파일

from pprint import pprint
import boto3


def put_movie(title, year, actors):

    region=boto3.session.Session().region_name

    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.Table('movies')
    response = table.put_item(
       Item={
            'year': year,
            'title': title,
            'info': {
                'actors': actors
            }
        }
    )
    return response


if __name__ == '__main__':

    movie_title = "The Godfather"
    movie_year =  1972
    movie_actors = {"Marlon Brando", "Al Pacino", "James Caan"}

    movie_resp = put_movie(movie_title, movie_year, movie_actors)
    print("Put movie succeeded:")
    pprint(movie_resp)

✔️ AWS SDK를 사용해 스캔 작업 및 필터로 항목 가져오기

from pprint import pprint
import boto3
from boto3.dynamodb.conditions import Key
import argparse


def scan_movies(year_range, display_movies):

    region=boto3.session.Session().region_name

    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.Table('movies')
    scan_kwargs = {
        'FilterExpression': Key('year').between(*year_range),
        'ProjectionExpression': "#yr, title, info.actors",
        'ExpressionAttributeNames': {"#yr": "year"}
    }

    done = False
    start_key = None
    while not done:
        if start_key:
            scan_kwargs['ExclusiveStartKey'] = start_key
        response = table.scan(**scan_kwargs)
        display_movies(response.get('Items', []))
        start_key = response.get('LastEvaluatedKey', None)
        done = start_key is None


if __name__ == '__main__':

    parser = argparse.ArgumentParser()
    parser.add_argument("start_year", help="Starting year, ex: 1950")
    parser.add_argument("end_year", help="Ending year. ex: 1959")

    args = parser.parse_args()

    year1 = int(args.start_year)
    year2 = int(args.end_year)
    query_range = (year1, year2)

    def print_movies(movies):
        for movie in movies:
            print(f"\n{movie['year']} : {movie['title']}")
            if 'info' in movie:
                pprint(movie['info'])
            else:
                print("{'rating': NA}")

    print(f"Scanning for movies released from {query_range[0]} to {query_range[1]}...")
    scan_movies(query_range, print_movies)

스크립트를 사용해 특정 속성값 범위를 가지는 테이블을 쿼리할 수 있다.

python [python 파일명] 속성값1 속성값2

✔️ AWS SDK를 사용해 쿼리 작업으로 항목 가져오기

쿼리 작업을 사용해 특정 속성값에 매칭되는 값을 가져오기

쿼리 작업 예제 파일

from pprint import pprint
import boto3
from boto3.dynamodb.conditions import Key
import argparse


def query_movies(year):

    region=boto3.session.Session().region_name
    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.Table('movies')
    response = table.query(
        KeyConditionExpression=Key('year').eq(year)
    )
    return response['Items']


if __name__ == '__main__':


    parser = argparse.ArgumentParser()
    parser.add_argument("Year", help="Search year, ex: 1950")
    args = parser.parse_args()

    query_year = int(args.Year)

    print(f"Movies released in {query_year}")

    movies = query_movies(query_year)
    for movie in movies:
        print(movie['year'], ":", movie['title'])

속성값에 해당하는 모든 항목에 대한 테이블을 쿼리하기

python [python 파일명] 속성값

✔️ AWS SDK를 사용해 항목 업데이트

예제 파일

from decimal import Decimal
from pprint import pprint
from botocore.exceptions import ClientError
import boto3


def update_movie(title, year, rating, plot, actors):

    region=boto3.session.Session().region_name
    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.Table('movies')

    try:
        response = table.update_item(
            Key={
                'year': year,
                'title': title
            },
            UpdateExpression="set info.rating=:r, info.plot=:p, info.actors=:a",
            ExpressionAttributeValues={
                ':r': Decimal(rating),
                ':p': plot,
                ':a': actors
            },
            ReturnValues="UPDATED_NEW"
        )
    except ClientError as e:
            print("Update movie failed:",e.response['Error']['Message'])
    else:
        print("Update movie succeeded:","\n")
        pprint(response)
        return response


if __name__ == '__main__':

    movie_title = "The Godfather"
    movie_year =  1972
    movie_rating = Decimal('9.2')
    movie_plot = "The aging patriarch of an organized crime dynasty transfers control of his clandestine empire to his reluctant son."
    movie_actors = ["Marlon Brando", "Al Pacino", "James Caan"]

    print("\n","Updating...","\n")

    update_movie(movie_title, movie_year, movie_rating, movie_plot, movie_actors)

테이블을 쿼리하고 플롯이 성공적으로 추가되었는지 확인하기

aws dynamodb get-item --table-name [테이블명] --key '{"속성1": {"속성타입": "속성값"}, "속성2": {"속성타입": "속성값"}}'

✔️ AWS SDK를 사용해 항목 삭제

테이블에서 전체 항목 삭제하기

예제 파일

from decimal import Decimal
from pprint import pprint
from botocore.exceptions import ClientError

import boto3


def update_movie(title, year):

    region=boto3.session.Session().region_name
    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.Table('movies')

    try:
        response = table.delete_item(
            Key={
                'year': year,
                'title': title
            },
            ConditionExpression = "attribute_exists(info.actors)",
            ReturnValues="ALL_OLD"
        )
    except ClientError as e:
        if e.response['Error']['Code'] == "ConditionalCheckFailedException":
            print("Delete movie failed:",e.response['Error']['Message'])
        else:
            raise e
    else:
        if 'Attributes' in response:
            print("Delete movie succeeded:","\n")
            pprint(response['Attributes'])
        else:
            print("Movie not found")


if __name__ == '__main__':

    movie_title = "The Godfather"
    movie_year =  1972

    print("\n","Deleting...","\n")

    update_movie(movie_title, movie_year)

파일을 실행하면 항목이 성공적으로 삭제되었음을 출력한다. 

 

✔️ AWS SDK를 사용해 테이블 삭제

예제 파일

import boto3

def delete_movie_table():
    region=boto3.session.Session().region_name
    dynamodb = boto3.resource('dynamodb', region_name=region) # low-level client

    table = dynamodb.Table('movies')
    table.delete()


if __name__ == '__main__':
    delete_movie_table()
    print("movies table deleted.")

테이블이 정상적으로 삭제되었으면 다음을 출력한다.

movies table deleted.

모든 DynamoDB 테이블을 나열하고 테이블이 삭제되었는지 확인하기

aws dynamodb list-tables
{
    "TableNames": []
}