GNU/Linux >> Znalost Linux > >> Linux

Jak kopírovat položky z jedné DynamoDB do jiné tabulky DynamoDB pomocí Pythonu na AWS

Python můžete použít ke kopírování položek z jedné tabulky DynamoDB do druhé. Stejný skript lze použít ke kopírování položek mezi tabulkami DynamoDB v různých účtech. Než budeme pokračovat v tomto článku, předpokládáme, že máte základní znalosti jazyka Python. Nemusíte nic psát sami, stačí spustit skript, abyste dokončili operaci kopírování. Pokud potřebujete rozumět skriptu a kódu v něm napsanému, pak musíte mít základní znalosti o Pythonu.

Tento skript můžete spustit z libovolného počítače s přístupem k internetu a nainstalovaným Pythonem. V systému musíte mít nainstalovaný Python a Boto3. Tento skript je testován v Pythonu 2.7.16, můžete jej vyzkoušet s různými verzemi dostupnými v Pythonu 2.7.

Službu AWS Data Pipeline lze také použít ke kopírování položek z jedné tabulky DynamoDB do druhé, ale to je trochu zdlouhavý proces. Tento skript jsem tedy napsal sám, abych tento úkol zjednodušil.

Nyní začněme.

Předpoklady

Základní porozumění Pythonu.
Python 2.7.16 a Boto3 nainstalované na serveru Linux.
Účet AWS (vytvořte si jej, pokud jej nemáte).
'access_key' a 'secret_key' uživatele AWS IAM s dostatečnými/úplnými oprávněními pro DynamoDB. (Kliknutím sem se dozvíte, jak vytvořit uživatele IAM pomocí 'access_key' a 'secret_key' na AWS, )

Co uděláme

Zkontrolujte Předpoklady.
Vytvořte skript.
Spusťte skript.

Zkontrolovat předpoklady

Zkontrolujte Python

python --version

Zkontrolujte Pip

pip --version

Zkontrolujte Boto3

pip show boto3

Vytvořit skript

Vytvořte ve svém místním systému nový soubor s následujícím kódem. Kód je také k dispozici na mém Github Repo. Níže je uveden odkaz na kód na Github.

Odkaz na Github: https://github.com/shivalkarrahul/DevOps/blob/master/aws/python/aws-copy-dynamo-db-table/copy-dynamodb-table.py

Soubor: copy-dynamodb-table.py

import boto3
import os
import sys
import argparse
import datetime


global args
parser = argparse.ArgumentParser()

parser.add_argument('-sa', '--source_aws_access_key_id', required=True, action="store", dest="source_aws_access_key_id",
                    help="Source AWS Account aws_access_key_id", default=None)
parser.add_argument('-ss', '--source_aws_secret_access_key', required=True, action="store", dest="source_aws_secret_access_key",
                    help="Source AWS Account aws_secret_access_key", default=None)
parser.add_argument('-da', '--destination_aws_access_key_id', required=True, action="store", dest="destination_aws_access_key_id",
                    help="Destination AWS Account aws_access_key_id", default=None)
parser.add_argument('-ds', '--destination_aws_secret_access_key', required=True, action="store", dest="destination_aws_secret_access_key",
                    help="Destination AWS Account aws_secret_access_key", default=None)
parser.add_argument('-st', '--sourceTableName', required=True, action="store", dest="sourceTableName",
                    help="Source AWS Account DyanamoDB Table", default=None)
parser.add_argument('-dt', '--destinationTableName', required=True, action="store", dest="destinationTableName",
                    help="Destination AWS Account DyanamoDB Table", default=None) 
args = parser.parse_args()                                                                                                                       

source_aws_access_key_id = args.source_aws_access_key_id
source_aws_secret_access_key = args.source_aws_secret_access_key

destination_aws_access_key_id = args.destination_aws_access_key_id
destination_aws_secret_access_key = args.destination_aws_secret_access_key


sourceTableName=args.sourceTableName 
destinationTableName=args.destinationTableName 

sourceTableExists = "false" 
destinationTableExists = "false" 

print("Printing values")
print("source_aws_access_key_id", source_aws_access_key_id)
print("source_aws_secret_access_key", source_aws_secret_access_key)
print("destination_aws_access_key_id", destination_aws_access_key_id)
print("destination_aws_secret_access_key", destination_aws_secret_access_key)
print("sourceTableName", sourceTableName)
print("destinationTableName", destinationTableName)


timeStamp = datetime.datetime.now()
backupName = destinationTableName + str(timeStamp.strftime("-%Y_%m_%d_%H_%M_%S"))

item_count = 1000 #Specify total number of items to be copied here, this helps when a specified number of items need to be copied
counter = 1 # Don't not change this

source_session = boto3.Session(region_name='eu-west-3', aws_access_key_id=source_aws_access_key_id, aws_secret_access_key=source_aws_secret_access_key)
source_dynamo_client = source_session.client('dynamodb')

target_session = boto3.Session(region_name='eu-west-3', aws_access_key_id=destination_aws_access_key_id, aws_secret_access_key=destination_aws_secret_access_key)
target_dynamodb = target_session.resource('dynamodb')


dynamoclient = boto3.client('dynamodb', region_name='eu-west-3', #Specify the region here
    aws_access_key_id=source_aws_access_key_id,  #Add you source account's access key here
    aws_secret_access_key=source_aws_secret_access_key) #Add you source account's secret key here

dynamotargetclient = boto3.client('dynamodb', region_name='eu-west-3', #Specify the region here
    aws_access_key_id=destination_aws_access_key_id, #Add you destination account's access key here
    aws_secret_access_key=destination_aws_secret_access_key) #Add you destination account's secret key here
# response = dynamotargetclient.list_tables()
# print("List of tables", response)

dynamopaginator = dynamoclient.get_paginator('scan')

def validateTables(sourceTable, destinationTable):
    print("Inside validateTables")
    try:
        dynamoclient.describe_table(TableName=sourceTable)
        sourceTableExists = "true"
    except dynamotargetclient.exceptions.ResourceNotFoundException:
        sourceTableExists = "false"


    try:
        dynamotargetclient.describe_table(TableName=destinationTable)
        destinationTableExists = "true"
    except dynamotargetclient.exceptions.ResourceNotFoundException:
        destinationTableExists = "false"
    
    return {'sourceTableExists': sourceTableExists, 'destinationTableExists':destinationTableExists}        



def copyTable(sourceTable, destinationTable,item_count,counter):
    
    print("Inside copyTable")
    print("Coping", sourceTable, "to", destinationTable)

    print('Start Reading the Source Table')
    try:
            dynamoresponse = dynamopaginator.paginate(
            TableName=sourceTable,
            Select='ALL_ATTRIBUTES',
            ReturnConsumedCapacity='NONE',
            ConsistentRead=True
        )
    except dynamotargetclient.exceptions.ResourceNotFoundException:
        print("Table does not exist")
        print("Exiting")
        sys.exit()

    print('Finished Reading the Table')
    print('Proceed with writing to the Destination Table')
    print("Writing first", item_count , "items" )
    print(dynamoresponse)
    for page in dynamoresponse:
        for item in page['Items']:
            if (counter ==  item_count):
                print("exiting")
                sys.exit()
            else:      
                print('writing item no', counter)
                dynamotargetclient.put_item(
                    TableName=destinationTable,
                    Item=item
                    )   
            counter = counter + 1

def backupTable(destTableName, backupTimeStamp):
    print("Inside backupTable")
    print("Taking backup of = ", destTableName)
    print("Backup Name = ", backupTimeStamp)

    response = dynamotargetclient.create_backup(
        TableName=destTableName,
        BackupName=backupTimeStamp
    )
    print("Backup ARN =", response["BackupDetails"]["BackupArn"])

def deleteDestinationTable(destTableName):
    print("Inside deleteDestinationTable")
    try:
        dynamotargetclient.delete_table(TableName=destTableName)
        waiter = dynamotargetclient.get_waiter('table_not_exists')
        waiter.wait(TableName=destTableName)
        print("Table deleted")
    except dynamotargetclient.exceptions.ResourceNotFoundException:
        print("Table does not exist")


def doesNotExist():
    print("Inside doesNotExist")
    print("Destination table does not exist ")
    print("Exiting the execution")
    # sys.exit()

def createDestinationTable(sourceTable):
    print("Inside createDestinationTable")
    source_table = source_session.resource('dynamodb').Table(sourceTable)

    target_table = target_dynamodb.create_table(
    TableName=destinationTableName,
    KeySchema=source_table.key_schema,
    AttributeDefinitions=source_table.attribute_definitions,
    ProvisionedThroughput={
        'ReadCapacityUnits': 5,
        'WriteCapacityUnits': 5
    })

    target_table.wait_until_exists()
    target_table.reload()


result = validateTables(sourceTableName, destinationTableName)
print("value of sourceTableExists = ", result['sourceTableExists'])
print("value of destinationTableExists = ", result['destinationTableExists'])

if (result['sourceTableExists'] == "false" ) and (result['destinationTableExists'] == "false" ):
    print("Both the tables do not exist")

elif (result['sourceTableExists'] == "false" ) and (result['destinationTableExists'] == "true" ):
    print("Source Table does not exist")

elif (result['sourceTableExists'] == "true" ) and (result['destinationTableExists'] == "false" ):
    createDestinationTable(sourceTableName)
    copyTable(sourceTableName, destinationTableName, item_count, counter)

elif (result['sourceTableExists'] == "true" ) and (result['destinationTableExists'] == "true" ):
    backupTable(destinationTableName, backupName)
    deleteDestinationTable(destinationTableName)

    createDestinationTable(sourceTableName)
    copyTable(sourceTableName, destinationTableName, item_count, counter)

else:
    print("Something is wrong")

Syntaxe:

python copy-dynamodb-table.py -sa -ss -da -ds -st -dt

Spusťte skript.

Můžete použít výše uvedenou syntaxi a předat argumenty skriptu.

Příkaz:

python copy-dynamodb-table.py -SA AKI12345IA5XJXFLMTQR -p ihiHd8 + NzLJ567890z4i6EwcN6hbV2A5cMfurscg -da AKI12345IA5XJXFLMTQR -DS ihiHd8 + NzLJ567890z4i6EwcN6hbV2A5cMfurscg -ST my-source-table -dt mé-cílové stolu

Zde

-sa =Source AWS Account Access Key = AKIAQ6GAIA5XJXFLMTQR
-ss = Source AWS Account Secret key = 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
-da = Přístupový klíč k účtu AWS do cíle = AKIAQ6GAIA5XJXFLMTQR
-ds = Tajný klíč účtu AWS cíle = ihiHd8+NzLJK5DFfTz4i6EwcN6hbV2A5cMfurscg
-st = Source Table = my-source-table
-dt = Cílová tabulka = moje-cílová-tabulka

Musíte použít své klíče, klíče zde patří mně.

Skript pokrývá 4 různé případy použití

Případ použití 1:Obě tabulky, Zdroj i Cíl, neexistují.
Případ použití 2: Zdrojová tabulka neexistuje , ale cílová tabulka existuje.
Případ použití 3: Zdrojová tabulka existuje , ale cílová tabulka neexistuje.
Případ použití 4:Obě tabulky, Zdroj i Cíl, existují.

Podívejme se na tyto případy použití jeden po druhém.

Případ použití 1:Obě tabulky, Zdroj i Cíl, neexistují.

Pokud ve svém účtu nemáte tabulky DynamoDB a přesto se pokusíte skript spustit, skript se ukončí se zprávou „Obě tabulky neexistují“.

Případ použití 2:Zdrojová tabulka neexistuje, ale cílová tabulka existuje.

Pokud se pokusíte předat tabulku, která neexistuje, jako zdrojovou tabulku, skript se ukončí se zprávou "Zdrojová tabulka neexistuje".

Případ použití 3:Zdrojová tabulka existuje, ale cílová tabulka neexistuje.

V obou výše uvedených dvou případech použití není provedena žádná operace. Pokud nyní předáte zdrojovou tabulku, která existuje, ale cílová tabulka neexistuje, skript vytvoří tabulku s názvem, který zadáte jako cílovou tabulku, a zkopíruje položky ze zdrojové tabulky do nově vytvořené cílové tabulky.

Případ použití 4:Obě tabulky, Zdroj i Cíl, existují.

V tomto scénáři se před zkopírováním položek ze zdrojové tabulky vytvoří záloha cílové tabulky a poté se cílová tabulka odstraní. Po odstranění tabulky se vytvoří nová tabulka s názvem, který zadáte v parametru určení a poté se položky ze zdrojové tabulky zkopírují do nově vytvořené cílové tabulky.

Závěr

V tomto článku jsme viděli skript Python pro kopírování položek z jedné tabulky DynamoDB do jiné tabulky DynamoDB. Skript pokrývá čtyři různé případy použití, které mohou nastat při kopírování položek z jedné tabulky do druhé. Nyní můžete tento skript použít ke kopírování položek z jedné tabulky DynamoDB do druhé ve stejném nebo jiném účtu AWS.

Vysvětlení příkazu Linux md5sum pro začátečníky (5 příkladů) Jak přidat a odebrat Cronjobs z instancí Linux EC2 na AWS pomocí skriptů prostředí

Linux