Comment copier des éléments d'une table DynamoDB vers une autre table DynamoDB à l'aide de Python sur AWS

Vous pouvez utiliser Python pour copier des éléments d'une table DynamoDB vers une autre. Le même script peut être utilisé pour copier des éléments entre des tables DynamoDB dans différents comptes. Avant de poursuivre cet article, nous supposons que vous avez une compréhension de base de Python. Vous n'avez pas besoin d'écrire quoi que ce soit par vous-même, il vous suffirait d'exécuter le script pour terminer l'opération de copie. Si vous avez besoin de comprendre le script et le code qui y est écrit, vous devez avoir une compréhension de base de Python.

Vous pouvez exécuter ce script à partir de n'importe quelle machine ayant accès à Internet et Python installé dessus. Vous devez avoir Python et Boto3 installés sur votre système. Ce script est testé avec Python 2.7.16, vous pouvez essayer avec différentes versions disponibles dans Python 2.7.

Le service AWS Data Pipeline peut également être utilisé pour copier des éléments d'une table DynamoDB à une autre, mais c'est un processus un peu fastidieux. J'ai donc écrit ce script moi-même pour simplifier la tâche.

Maintenant, commençons.

Prérequis

1. Compréhension de base de Python.
2. Python 2.7.16 et Boto3 installés sur le serveur Linux.
3. Compte AWS (créez-le si vous n'en avez pas).
4. 'access_key' &'secret_key' d'un utilisateur AWS IAM avec des autorisations suffisantes/complètes sur DynamoDB. (Cliquez ici pour apprendre à créer un utilisateur IAM avec 'access_key' &'secret_key' sur AWS, )

Qu'allons-nous faire

1. Vérifier les prérequis.
2. Créer un script.
3. Exécuter le script.

Vérifier les prérequis

Vérifier Python

python --version

Vérifier le pip

pip --version

Vérifiez Boto3

pip montrer boto3

Créer un script

Créez un nouveau fichier avec le code suivant sur votre système local. Le code est également disponible sur mon Github Repo. Voici le lien vers le code sur Github.

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

Fichier : 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

Exécuter le script.

Vous pouvez vous référer à la syntaxe ci-dessus et transmettre les arguments au script.

Commande :

python copy-dynamodb-table.py -sa AKI12345IA5XJXFLMTQR -ss ihiHd8 + NzLJ567890z4i6EwcN6hbV2A5cMfurscg -da AKI12345IA5XJXFLMTQR -ds ihiHd8 + NzLJ567890z4i6EwcN6hbV2A5cMfurscg -St -dt my-table de destination ma source table

Ici,

• -sa =Clé d'accès au compte AWS source = AKIAQ6GAIA5XJXFLMTQR
• -ss = Clé secrète du compte AWS source = ihiHd8+NzLJK5DFfTz4i6EwcN6hbV2A5cMfurscg
• -da = Clé d'accès au compte AWS de destination = AKIAQ6GAIA5XJXFLMTQR
• -ds = Clé secrète de compte AWS de destination = ihiHd8+NzLJK5DFfTz4i6EwcN6hbV2A5cMfurscg
• -st = Table source = ma-table-source
• -dt = Table de destination = ma-table-de-destination

Vous devez utiliser vos clés, les clés ici m'appartiennent.

Le script couvre 4 cas d'utilisation différents

1. Cas d'utilisation 1 :les tables Source et Destination n'existent pas.
2. Cas d'utilisation 2 : la table source n'existe pas, mais la table de destination existe.
3. Cas d'utilisation 3 : la table source existe mais la table de destination n'existe pas.
4. Cas d'utilisation 4 :les deux tables, Source et Destination, existent.

Voyons ces cas d'utilisation un par un.

Cas d'utilisation 1 :les tables Source et Destination n'existent pas.

Si vous n'avez pas de tables DynamoDB dans votre compte et que vous essayez toujours d'exécuter le script, le script se fermera avec le message "Les deux tables n'existent pas".

Cas d'utilisation 2 : la table source n'existe pas mais la table de destination existe.

Si vous essayez de passer la table qui n'existe pas comme table source, le script se terminera avec le message "La table source n'existe pas".

Cas d'utilisation 3 : la table source existe mais la table de destination n'existe pas.

Dans les deux cas d'utilisation ci-dessus, aucune opération n'est effectuée. Maintenant, si vous transmettez la table source qui existe mais que la table de destination n'existe pas, le script créera une table avec le nom que vous spécifiez comme table de destination et copiera les éléments de la table source vers la table de destination nouvellement créée.

Cas d'utilisation 4 :les deux tables, Source et Destination, existent.

Dans ce scénario, une sauvegarde de la table de destination est effectuée avant de copier les éléments de la table source, puis la table de destination est supprimée. Une fois la table supprimée, une nouvelle table portant le nom que vous spécifiez dans le paramètre de destination est créée, puis les éléments de la table source sont copiés dans la table de destination nouvellement créée.

Conclusion

Dans cet article, nous avons vu le script Python pour copier des éléments d'une table DynamoDB vers une autre table DynamoDB. Le script couvre quatre cas d'utilisation différents qui peuvent survenir lors de la copie d'éléments d'une table à une autre. Vous pouvez désormais utiliser ce script pour copier des éléments d'une table DynamoDB vers une autre dans le même compte AWS ou dans un compte AWS différent.