Copiar tabelas do Amazon DynamoDB entre contas usando uma implementação personalizada

Criado por Ramkumar Ramanujam () AWS

Resumo

Ao trabalhar com o Amazon DynamoDB no Amazon Web Services AWS (), um caso de uso comum é copiar ou sincronizar tabelas do DynamoDB em ambientes de desenvolvimento, teste ou preparação com os dados da tabela que estão no ambiente de produção. Como prática padrão, cada ambiente usa uma AWS conta diferente.

O DynamoDB agora oferece suporte ao backup entre contas usando o Backup. AWS Para obter informações sobre os custos de armazenamento associados ao uso do AWS Backup, consulte Preços de AWS backup. Quando você usa o AWS Backup para copiar entre contas, as contas de origem e de destino devem fazer parte de uma organização da AWS Organizations. Existem outras soluções para backup e restauração entre contas usando AWS serviços como o AWS Glue. O uso dessas soluções, no entanto, aumenta o espaço ocupado pelo aplicativo, porque há mais AWS serviços para implantar e manter. 

Você também pode usar o Amazon DynamoDB Streams para registrar alterações na tabela na conta de origem. Em seguida, você pode iniciar uma função AWS Lambda e fazer as alterações correspondentes na tabela de destino na conta de destino. Mas essa solução se aplica a casos de uso nos quais as tabelas de origem e destino devem sempre ser mantidas em sincronia. Isso talvez não se aplique a ambientes de desenvolvimento, teste e preparação em que os dados são atualizados com frequência.

Esse padrão fornece etapas para implementar uma solução personalizada para copiar uma tabela do Amazon DynamoDB de uma conta para outra. Esse padrão pode ser implementado usando linguagens de programação comuns, como C#, Java e Python. Recomendamos usar uma linguagem que seja compatível com um AWSSDK.

Pré-requisitos e limitações

Pré-requisitos

Limitações

Esse padrão se aplica às tabelas do DynamoDB com cerca de 2 GB ou menos. Com lógica adicional para lidar com interrupções de conexão ou sessão, controle de utilização, falhas e novas tentativas, ele pode ser usado para tabelas maiores.

A operação de verificação do DynamoDB, que lê itens da tabela de origem, pode buscar somente até 1 MB de dados em uma única chamada. Para tabelas maiores, superiores a 2 GB, essa limitação pode aumentar o tempo total para a realização de uma cópia completa.

Arquitetura

O diagrama a seguir mostra a implementação personalizada entre as AWS contas de origem e de destino. IAMpolíticas e tokens de segurança são usados com a implementação personalizada. Os dados são lidos do Amazon DynamoDB na conta de origem e gravados no DynamoDB na conta de destino.

Automação e escala

Esse padrão se aplica às tabelas do DynamoDB com cerca de 2 GB ou menos. 

Para aplicar esse padrão a tabelas maiores, resolva os seguintes problemas:

Ferramentas

Ferramentas

Código

O trecho de código Python a seguir exclui e recria uma tabela do DynamoDB usando a biblioteca do Boto3.

Não use o AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY de um IAM usuário porque essas são credenciais de longo prazo, que devem ser evitadas para acesso programático aos AWS serviços. Para obter mais informações sobre as credenciais temporárias, consulte a seção Práticas recomendadas.

O AWS_ACCESS_KEY_IDAWS_SECRET_ACCESS_KEY, e TEMPORARY_SESSION_TOKEN usado no trecho de código a seguir são credenciais temporárias obtidas do AWS Security Token Service (). AWS STS

import boto3
import sys
import json

#args = input-parameters = GLOBAL_SEC_INDEXES_JSON_COLLECTION, ATTRIBUTES_JSON_COLLECTION, TARGET_DYNAMODB_NAME, TARGET_REGION, ...

#Input param: GLOBAL_SEC_INDEXES_JSON_COLLECTION
#[{"IndexName":"Test-index","KeySchema":[{"AttributeName":"AppId","KeyType":"HASH"},{"AttributeName":"AppType","KeyType":"RANGE"}],"Projection":{"ProjectionType":"INCLUDE","NonKeyAttributes":["PK","SK","OwnerName","AppVersion"]}}]

#Input param: ATTRIBUTES_JSON_COLLECTION
#[{"AttributeName":"PK","AttributeType":"S"},{"AttributeName":"SK","AttributeType":"S"},{"AttributeName":"AppId","AttributeType":"S"},{"AttributeName":"AppType","AttributeType":"N"}]

region = args['TARGET_REGION']
target_ddb_name = args['TARGET_DYNAMODB_NAME']

global_secondary_indexes = json.loads(args['GLOBAL_SEC_INDEXES_JSON_COLLECTION'])
attribute_definitions = json.loads(args['ATTRIBUTES_JSON_COLLECTION'])

# Drop and create target DynamoDB table
dynamodb_client = boto3.Session(
        aws_access_key_id=args['AWS_ACCESS_KEY_ID'],
        aws_secret_access_key=args['AWS_SECRET_ACCESS_KEY'],
        aws_session_token=args['TEMPORARY_SESSION_TOKEN'],
    ).client('dynamodb')
    
# Delete table
print('Deleting table: ' + target_ddb_name + ' ...')

try:
    dynamodb_client.delete_table(TableName=target_ddb_name)

    #Wait for table deletion to complete
    waiter = dynamodb_client.get_waiter('table_not_exists')
    waiter.wait(TableName=target_ddb_name)
    print('Table deleted.')
except dynamodb_client.exceptions.ResourceNotFoundException:
    print('Table already deleted / does not exist.')
    pass

print('Creating table: ' + target_ddb_name + ' ...')

table = dynamodb_client.create_table(
    TableName=target_ddb_name,
    KeySchema=[
        {
            'AttributeName': 'PK',
            'KeyType': 'HASH'  # Partition key
        },
        {
            'AttributeName': 'SK',
            'KeyType': 'RANGE'  # Sort key
        }
    ],
    AttributeDefinitions=attribute_definitions,
    GlobalSecondaryIndexes=global_secondary_indexes,
    BillingMode='PAY_PER_REQUEST'
)
    
waiter = dynamodb_client.get_waiter('table_exists')
waiter.wait(TableName=target_ddb_name)
    
print('Table created.')

Práticas recomendadas

Credenciais temporárias

Como prática recomendada de segurança, ao acessar AWS os serviços de forma programática, evite usar a AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY de um IAM usuário, pois essas são credenciais de longo prazo. Sempre tente usar credenciais temporárias para acessar os AWS serviços de forma programática.

Por exemplo, um desenvolvedor codifica o AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY de um IAM usuário no aplicativo durante o desenvolvimento, mas não consegue remover os valores codificados antes de enviar as alterações para o repositório de código. Essas credenciais expostas podem ser usadas por usuários mal-intencionados ou maliciosos, o que pode ter sérias implicações (principalmente se as credenciais expostas tiverem privilégios de administrador). Essas credenciais expostas devem ser desativadas ou excluídas imediatamente usando o IAM console ou a interface de linha de AWS comando () AWSCLI.

Para obter credenciais temporárias para acesso programático aos AWS serviços, use. AWS STS As credenciais temporárias são válidas somente pelo tempo especificado (de 15 minutos a 36 horas). A duração máxima permitida de credenciais temporárias varia de acordo com fatores como configurações de função e encadeamento de funções. Para obter mais informações sobre AWSSTS, consulte a documentação.

Épicos

aws sts assume-role --role-arn arn:aws:iam::<account-id>:role/<role-name> --role-session-name <session-name> --profile <profile-name>

Recursos relacionados

Mais informações

Esse padrão foi implementado usando C# para copiar uma tabela do DynamoDB com 200.000 itens (tamanho médio do item de 5 KB e tamanho da tabela de 250 MB). A tabela de destino do DynamoDB foi configurada com capacidade provisionada de 4000 e 4000. RCUs WCUs

A operação completa de cópia da tabela (da conta de origem para a conta de destino), incluindo a remoção e a recriação da tabela, levou cinco minutos. Total de unidades de capacidade consumidas: 30.000 RCUs e aproximadamente WCUs 400.000.

Para obter mais informações sobre os modos de capacidade do DynamoDB, consulte Modo de capacidade de leitura/gravação na documentação. AWS

Anexos

Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: attachment.zip