Ir para o conteúdo
Ao usar o AWS re:Post, você concorda com os AWS re:Post Termos de uso
AWS re:Postre:Post
sobre o re:Post

Como altero o modo de capacidade de várias tabelas do Amazon DynamoDB ao mesmo tempo?

13 minuto de leitura
0

Quero alterar o modo de capacidade de várias tabelas do Amazon DynamoDB ao mesmo tempo.

Breve descrição

Ao alterar o modo de capacidade de várias tabelas do DynamoDB, você deve especificar o modo de capacidade provisionada ou o modo de capacidade sob demanda. Antes de alterar o modo de capacidade, consulte Considerações ao alternar os modos de capacidade no DynamoDB.

Para alterar o modo de capacidade de várias tabelas do DynamoDB ao mesmo tempo, use um dos seguintes métodos:

  • AWS Command Line Interface (AWS CLI)
  • AWS CloudFormation
  • Python

Resolução

Práticas recomendadas

Ao alterar o modo de capacidade de várias tabelas do DynamoDB, use as seguintes práticas recomendadas:

  • Antes de iniciar a alteração, configure as credenciais apropriadas da AWS CLI.
  • Certifique-se de ter as permissões apropriadas do AWS Identity and Access Management (AWS IAM).
  • Implante suas alterações primeiro em um ambiente que não seja de produção.
  • Aguarde alguns minutos para que cada tabela conclua a troca.
  • Alterne os modos de capacidade somente uma vez a cada 24 horas para cada tabela.
  • Analise os padrões de uso para selecionar o modo de capacidade apropriado e ajuste-os aos requisitos da região da AWS.
  • Monitore os custos após a mudança para garantir que você tenha a capacidade provisionada adequada.

AWS CLI

Observação: se você receber erros ao executar comandos da AWS Command Line Interface (AWS CLI), consulte Solução de problemas da AWS CLI. Além disso, verifique se você está usando a versão mais recente da AWS CLI.

Modo provisionado

Para usar a AWS CLI para alterar o modo de capacidade de várias tabelas do DynamoDB para o modo provisionado, conclua as seguintes etapas:

  1. Abra seu editor de texto e insira o código a seguir para criar um novo script de shell:

    #!/bin/bash

# Set the AWS region
AWS_REGION=[REGION] # Change this to your desired region

# OPTION1: List of table names you want to switch
TABLES=("table1" "table2" "table3")

# OPTION2: Get all table names in the account
TABLES=$(aws dynamodb list-tables —region $AWS_REGION —query 'TableNames[]' —output text)

# Default provisioned capacity units
READ_CAPACITY=READ_CAPACITY_VALUE
WRITE_CAPACITY=WRITE_CAPACITY_VALUE

echo "Using AWS Region: $AWS_REGION"

for TABLE_NAME in $TABLES
do
# Check current billing mode
CURRENT_MODE=$(aws dynamodb describe-table —region $AWS_REGION —table-name $TABLE_NAME —query 'Table.BillingModeSummary.BillingMode' —output text)

if [ "$CURRENT_MODE" = "PAY_PER_REQUEST" ]; then
echo "Processing table: $TABLE_NAME"

# Get GSI configurations
GSI_CONFIG=""
GSI_LIST=$(aws dynamodb describe-table —region $AWS_REGION —table-name $TABLE_NAME —query 'Table.GlobalSecondaryIndexes[*].IndexName' —output text)

if [ ! -z "$GSI_LIST" ]; then
echo "Found GSIs: $GSI_LIST"

# Build GSI provisioned throughput configuration
GSI_CONFIG="—global-secondary-index-updates“
for GSI_NAME in $GSI_LIST
do
if [ -z "$FIRST_GSI" ]; then
GSI_CONFIG="$GSI_CONFIG [{\"Update\":{\"IndexName\":\"$GSI_NAME\",\"ProvisionedThroughput\":{\"ReadCapacityUnits\":$READ_CAPACITY,\"WriteCapacityUnits\":$WRITE_CAPACITY}}}"
FIRST_GSI="false"
else
GSI_CONFIG="$GSI_CONFIG,{\"Update\":{\"IndexName\":\"$GSI_NAME\",\"ProvisionedThroughput\":{\"ReadCapacityUnits\":$READ_CAPACITY,\"WriteCapacityUnits\":$WRITE_CAPACITY}}}"
fi
done
GSI_CONFIG="$GSI_CONFIG]"
fi

# Update table and GSIs
if [ ! -z "$GSI_CONFIG" ]; then
echo "Updating table and GSIs..."
aws dynamodb update-table \
--region $AWS_REGION \
--table-name $TABLE_NAME \
--billing-mode PROVISIONED \
--provisioned-throughput ReadCapacityUnits=$READ_CAPACITY,WriteCapacityUnits=$WRITE_CAPACITY \
$GSI_CONFIG
else
echo "Updating table (no GSIs)..."
aws dynamodb update-table \
--region $AWS_REGION \
--table-name $TABLE_NAME \
--billing-mode PROVISIONED \
--provisioned-throughput ReadCapacityUnits=$READ_CAPACITY,WriteCapacityUnits=$WRITE_CAPACITY
fi

echo "Request submitted for $TABLE_NAME"
else
echo "Skipping $TABLE_NAME - already in PROVISIONED mode"
fi

# Reset GSI tracking for next table
FIRST_GSI=""
echo "----------------------------------------"

done

    Para alterar o modo de capacidade de todas as tabelas do DynamoDB para o modo sob demanda, remova a seguinte seção do código:

    #OPTION1: List of table names you want to switch  
TABLES=("table1" "table2" "table3")

    Para alterar o modo de capacidade de tabelas específicas do DynamoDB para o modo sob demanda, substitua “tabela1” “tabela2” “tabela3” pelos nomes das tabelas. Em seguida, remova a seguinte seção do código:

    #OPTION2: Get all table names in the account  
TABLES=$(aws dynamodb list-tables —query 'TableNames[]' —output text)

    Observação: substitua READ_CAPACITY_VALUE e WRITE_CAPACITY_VALUE pelos seus valores de capacidade de leitura e gravação.

  2. Salve o arquivo com o nome switch-all-tables-with-gsi-to-provisioned.sh.

  3. Para tornar o arquivo executável, abra o terminal e execute o seguinte comando:

    chmod +x switch-all-tables-with-gsi-to-provisioned.sh

  4. Para executar o script de shell no terminal, execute o seguinte comando:

    ./switch-all-tables-with-gsi-to-provisioned.sh

Modo sob demanda

Para usar a AWS CLI para alterar o modo de capacidade de várias tabelas do DynamoDB para o modo sob demanda, conclua as seguintes etapas:

  1. Abra seu editor de texto e então insira o código a seguir para criar um novo script de shell:

    #!/bin/bash

# Set the AWS region
AWS_REGION=[REGION] # Change this to your desired region

# OPTION1: List of table names you want to switch
TABLES=("table1" "table2" "table3")

# OPTION2: Get all table names in the account
#TABLES=$(aws dynamodb list-tables --region $AWS_REGION --query 'TableNames[]' --output text)

for TABLE_NAME in $TABLES
do
    # Check current billing mode
    CURRENT_MODE=$(aws dynamodb describe-table --region $AWS_REGION --table-name $TABLE_NAME --query 'Table.BillingModeSummary.BillingMode' --output text)

    if [ "$CURRENT_MODE" = "PROVISIONED" ]; then
        echo "Processing table: $TABLE_NAME"
        # Check if table has any GSIs
        GSI_LIST=$(aws dynamodb describe-table --region $AWS_REGION --table-name $TABLE_NAME --query 'Table.GlobalSecondaryIndexes[*].IndexName' --output text)

        if [ ! -z "$GSI_LIST" ]; then
            echo "Table has GSIs: $GSI_LIST"
            echo "Note: GSIs will automatically switch to On-Demand with the table"
        fi

        # Update table to On-Demand
        echo "Switching $TABLE_NAME to PAY_PER_REQUEST mode..."
        aws dynamodb update-table \
            --region $AWS_REGION \
            --table-name $TABLE_NAME \
            --billing-mode PAY_PER_REQUEST

        echo "Request submitted for $TABLE_NAME"
    else
        echo "Skipping $TABLE_NAME - already in PAY_PER_REQUEST mode"
    fi
    echo "----------------------------------------"
done

    Para alterar o modo de capacidade de todas as tabelas do DynamoDB para o modo sob demanda, remova a seguinte seção do código:

    #OPTION1: List of table names you want to switch  
TABLES=("table1" "table2" "table3")

    Para alterar o modo de capacidade de tabelas específicas do DynamoDB para o modo sob demanda, substitua “tabela1” “tabela2” “tabela3” pelos nomes das tabelas. Em seguida, remova a seguinte seção do código:

    `#OPTION2: Get all table names in the account`  
TABLES=$(aws dynamodb list-tables —region $AWS\_REGION —query 'TableNames\[\]' —output text)

    Observação: substitua REGION pela sua Região. Use o código da região, como us-east-1.

  2. Para tornar o arquivo executável, abra o terminal e execute o comando:

    chmod +x switch-all-tables-with-gsi-to-ondemand.sh

  3. Para executar o shell script no terminal, execute o comando:

    ./switch-all-tables-with-gsi-to-ondemand.sh

CloudFormation

Use as seguintes práticas recomendadas:

  • Defina modelos do AWS Lambda para usar o runtime do Python 3.9.
  • Monitore os Amazon CloudWatch Logs para acompanhar o progresso da função do Lambda.

Observação: antes de começar, configure suas credenciais da AWS. Execute o seguinte comando configure AWS CLI:

aws configure

Modo provisionado

Para usar o CloudFormation para alterar o modo de capacidade de várias tabelas do DynamoDB para o modo provisionado, conclua as seguintes etapas:

  1. Abra seu editor de texto e insira o código a seguir para criar um novo arquivo YAML:

    AWSTemplateFormatVersion: '2010-09-09'
Description: 'Switch specific DynamoDB tables from On-Demand to Provisioned capacity mode'

Parameters:
  ReadCapacityUnits:
    Type: Number
    Default: 5
    Description: Read Capacity Units for tables and GSIs

  WriteCapacityUnits:
    Type: Number
    Default: 5
    Description: Write Capacity Units for tables and GSIs

  TableNames:
    Type: CommaDelimitedList
    Description: Comma-separated list of DynamoDB table names to update

Resources:
  DynamoDBTableUpdates:
    Type: Custom::DynamoDBTableUpdates
    Properties:
      ServiceToken: !GetAtt UpdateTablesFunction.Arn
      ReadCapacityUnits: !Ref ReadCapacityUnits
      WriteCapacityUnits: !Ref WriteCapacityUnits
      TableNames: !Ref TableNames

  UpdateTablesFunction:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: python3.9
      Handler: index.handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile: |
          import boto3
          import cfnresponse

          def handler(event, context):
              try:
                  if event['RequestType'] in ['Create', 'Update']:
                      dynamodb = boto3.client('dynamodb')

                      # Get parameters
                      read_capacity = event['ResourceProperties']['ReadCapacityUnits']
                      write_capacity = event['ResourceProperties']['WriteCapacityUnits']
                      table_names = event['ResourceProperties']['TableNames']

                      for table_name in table_names:
                          try:
                              # Get table details
                              table = dynamodb.describe_table(TableName=table_name)['Table']
                              current_mode = table.get('BillingModeSummary', {}).get('BillingMode', '')

                              if current_mode == 'PAY_PER_REQUEST':
                                  # Prepare GSI updates if any
                                  gsi_updates = []
                                  if 'GlobalSecondaryIndexes' in table:
                                      for gsi in table['GlobalSecondaryIndexes']:
                                          gsi_updates.append({
                                              'Update': {
                                                  'IndexName': gsi['IndexName'],
                                                  'ProvisionedThroughput': {
                                                      'ReadCapacityUnits': int(read_capacity),
                                                      'WriteCapacityUnits': int(write_capacity)
                                                  }
                                              }
                                          })

                                  # Update table
                                  update_params = {
                                      'TableName': table_name,
                                      'BillingMode': 'PROVISIONED',
                                      'ProvisionedThroughput': {
                                          'ReadCapacityUnits': int(read_capacity),
                                          'WriteCapacityUnits': int(write_capacity)
                                      }
                                  }

                                  if gsi_updates:
                                      update_params['GlobalSecondaryIndexUpdates'] = gsi_updates

                                  dynamodb.update_table(**update_params)
                                  print(f"Switching {table_name} to PROVISIONED mode")
                              else:
                                  print(f"Table {table_name} is not in PAY_PER_REQUEST mode. Skipping.")

                          except Exception as e:
                              print(f"Error processing table {table_name}: {str(e)}")
                              continue

                      cfnresponse.send(event, context, cfnresponse.SUCCESS, {})
                  else:
                      cfnresponse.send(event, context, cfnresponse.SUCCESS, {})

              except Exception as e:
                  print(f"Error: {str(e)}")
                  cfnresponse.send(event, context, cfnresponse.FAILED, {})

  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: DynamoDBAccess
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - dynamodb:DescribeTable
                  - dynamodb:UpdateTable
                Resource: '*'

  2. Salve o arquivo com o nome switch-to-provisioned.yaml.

  3. Execute o seguinte comando create-stack da AWS CLI:

    # For Provisioned mode
aws cloudformation create-stack \
  --stack-name switch-to-provisioned \
  --template-body file://switch-to-provisioned.yaml \
  --capabilities CAPABILITY_IAM \
  --region [REGION] \
  --parameters  ParameterKey=TableNames,ParameterValue="Table1,Table2,Table3" \
              ParameterKey=ReadCapacityUnits,ParameterValue=[RCU_VALUE] \
              ParameterKey=WriteCapacityUnits,ParameterValue=[WCU_VALUE]

    Observação: substitua “Tabela1, Tabela2, Tabela3” pelos nomes das tabelas, RCU_VALUE e WCU_VALUE pelos valores RCU e WCU e REGION pela sua Região, como us-east-1.

Modo sob demanda

Para usar o CloudFormation para alterar o modo de capacidade de várias tabelas do DynamoDB para o modo sob demanda, conclua as seguintes etapas:

  1. Abra seu editor de texto e insira o código a seguir para criar um novo arquivo YAML:

    AWSTemplateFormatVersion: '2010-09-09'
Description: 'Switch specific DynamoDB tables from Provisioned to On-Demand capacity mode'

Parameters:
  TableNames:
    Type: CommaDelimitedList
    Description: Comma-separated list of DynamoDB table names to update

Resources:
  DynamoDBTableUpdates:
    Type: Custom::DynamoDBTableUpdates
    Properties:
      ServiceToken: !GetAtt UpdateTablesFunction.Arn
      TableNames: !Ref TableNames

  UpdateTablesFunction:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: python3.9
      Handler: index.handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile: |
          import boto3
          import cfnresponse

          def handler(event, context):
              try:
                  if event['RequestType'] in ['Create', 'Update']:
                      dynamodb = boto3.client('dynamodb')

                      # Get table names from the event
                      table_names = event['ResourceProperties']['TableNames']

                      for table_name in table_names:
                          try:
                              # Get table details
                              table = dynamodb.describe_table(TableName=table_name)['Table']
                              current_mode = table.get('BillingModeSummary', {}).get('BillingMode', '')

                              if current_mode == 'PROVISIONED':
                                  # Update table to On-Demand
                                  dynamodb.update_table(
                                      TableName=table_name,
                                      BillingMode='PAY_PER_REQUEST'
                                  )
                                  print(f"Switching {table_name} to PAY_PER_REQUEST mode")
                              else:
                                  print(f"Table {table_name} is not in PROVISIONED mode. Skipping.")

                          except Exception as e:
                              print(f"Error processing table {table_name}: {str(e)}")
                              continue

                      cfnresponse.send(event, context, cfnresponse.SUCCESS, {})
                  else:
                      cfnresponse.send(event, context, cfnresponse.SUCCESS, {})

              except Exception as e:
                  print(f"Error: {str(e)}")
                  cfnresponse.send(event, context, cfnresponse.FAILED, {})

  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: DynamoDBAccess
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - dynamodb:DescribeTable
                  - dynamodb:UpdateTable
                Resource: '*'

  2. Salve o arquivo com o nome switch-to-ondemand.yaml.

  3. Execute o seguinte comando create-stack da AWS CLI:

    # For On-Demand mode
aws cloudformation create-stack \
  --stack-name switch-to-ondemand \
  --template-body file://switch-to-ondemand.yaml \
  --capabilities CAPABILITY_IAM \
  --region [REGION] \
  --parameters ParameterKey=TableNames,ParameterValue="Table1,Table2,Table3"

    Observação: substitua “Tabela1, Tabela2, Tabela3” pelos nomes das tabelas e REGION pela sua Região.

Python

É possível usar uma instância do Amazon Elastic Compute Cloud (EC2), o Lambda ou seu próprio desktop para executar um script Python. Antes de alterar o modo de capacidade, certifique-se de ter instalado Python, pip e boto3.

Antes de começar, configure suas credenciais da AWS. Execute o seguinte comando configure AWS CLI:

aws configure

Modo provisionado

Para usar um script Python para alterar o modo de capacidade de todas as tabelas do DynamoDB em uma região específica para o modo provisionado, conclua as seguintes etapas:

  1. Abra o Python e digite o código a seguir para criar um novo arquivo:

    import boto3
import time
from botocore.exceptions import ClientError

def switch_to_provisioned(read_capacity=5, write_capacity=5, region=None):
    """
    Switch all DynamoDB tables from On-Demand to Provisioned capacity mode
    """
    # Initialize DynamoDB client
    dynamodb = boto3.client('dynamodb', region_name=region)

    # Get all table names
    tables = []
    paginator = dynamodb.get_paginator('list_tables')
    for page in paginator.paginate():
        tables.extend(page['TableNames'])

    print(f"Found {len(tables)} tables")

    for table_name in tables:
        try:
            # Get table details
            response = dynamodb.describe_table(TableName=table_name)
            table = response['Table']
            current_mode = table.get('BillingModeSummary', {}).get('BillingMode', '')

            if current_mode == 'PAY_PER_REQUEST':
                print(f"\nProcessing table: {table_name}")

                # Prepare GSI updates if any
                gsi_updates = []
                if 'GlobalSecondaryIndexes' in table:
                    print(f"Found GSIs for table {table_name}")
                    for gsi in table['GlobalSecondaryIndexes']:
                        gsi_updates.append({
                            'Update': {
                                'IndexName': gsi['IndexName'],
                                'ProvisionedThroughput': {
                                    'ReadCapacityUnits': read_capacity,
                                    'WriteCapacityUnits': write_capacity
                                }
                            }
                        })

                # Prepare update parameters
                update_params = {
                    'TableName': table_name,
                    'BillingMode': 'PROVISIONED',
                    'ProvisionedThroughput': {
                        'ReadCapacityUnits': read_capacity,
                        'WriteCapacityUnits': write_capacity
                    }
                }

                if gsi_updates:
                    update_params['GlobalSecondaryIndexUpdates'] = gsi_updates

                # Update table
                print(f"Switching {table_name} to PROVISIONED mode...")
                dynamodb.update_table(**update_params)
                print(f"Update request submitted for {table_name}")

            else:
                print(f"\nSkipping {table_name} - already in PROVISIONED mode")

        except ClientError as e:
            if e.response['Error']['Code'] == 'LimitExceededException':
                print(f"\nError: Cannot update {table_name}. You can only switch between billing modes once per 24 hours.")
            else:
                print(f"\nError processing table {table_name}: {str(e)}")
            continue
        except Exception as e:
            print(f"\nUnexpected error processing table {table_name}: {str(e)}")
            continue

        # Small delay to avoid API throttling
        time.sleep(1)

if __name__ == "__main__":
    # You can modify these values
    READ_CAPACITY = [RCU_VALUE]
    WRITE_CAPACITY = [WCU_VALUE]
    REGION = [REGION]  # Change to your desired region

    switch_to_provisioned(
        read_capacity=READ_CAPACITY,
        write_capacity=WRITE_CAPACITY,
        region=REGION
    )

    Observação: substitua RCU_VALUE e WCU_VALUE pelos valores RCU E WCU e REGION pela sua região, como us-east-1.

  2. Salve o arquivo com o nome do switch_to_provisioned.py.

  3. Abra o terminal e execute o seguinte comando para executar o script Python:

    python switch_to_provisioned.py

Modo sob demanda

Para usar um script Python para alterar o modo de capacidade de todas as tabelas do DynamoDB em uma região específica para o modo sob demanda, conclua as seguintes etapas:

  1. Abra o Python e digite o código a seguir para criar um novo arquivo:

    import boto3
import time
from botocore.exceptions import ClientError

def switch_to_ondemand(region=None):
    """
    Switch all DynamoDB tables from Provisioned to On-Demand capacity mode
    """
    # Initialize DynamoDB client
    dynamodb = boto3.client('dynamodb', region_name=region)

    # Get all table names
    tables = []
    paginator = dynamodb.get_paginator('list_tables')
    for page in paginator.paginate():
        tables.extend(page['TableNames'])

    print(f"Found {len(tables)} tables")

    for table_name in tables:
        try:
            # Get table details
            response = dynamodb.describe_table(TableName=table_name)
            table = response['Table']
            current_mode = table.get('BillingModeSummary', {}).get('BillingMode', '')

            if current_mode == 'PROVISIONED':
                print(f"\nProcessing table: {table_name}")

                # Check for GSIs
                if 'GlobalSecondaryIndexes' in table:
                    print(f"Table {table_name} has GSIs - they will automatically switch to On-Demand")

                # Update table
                print(f"Switching {table_name} to PAY_PER_REQUEST mode...")
                dynamodb.update_table(
                    TableName=table_name,
                    BillingMode='PAY_PER_REQUEST'
                )
                print(f"Update request submitted for {table_name}")

            else:
                print(f"\nSkipping {table_name} - already in PAY_PER_REQUEST mode")

        except ClientError as e:
            if e.response['Error']['Code'] == 'LimitExceededException':
                print(f"\nError: Cannot update {table_name}. You can only switch between billing modes once per 24 hours.")
            else:
                print(f"\nError processing table {table_name}: {str(e)}")
            continue
        except Exception as e:
            print(f"\nUnexpected error processing table {table_name}: {str(e)}")
            continue

        # Small delay to avoid API throttling
        time.sleep(1)

def check_table_status(table_name, region=None):
    """
    Check the current billing mode of a specific table
    """
    dynamodb = boto3.client('dynamodb', region_name=region)
    try:
        response = dynamodb.describe_table(TableName=table_name)
        mode = response['Table'].get('BillingModeSummary', {}).get('BillingMode', 'Unknown')
        print(f"Table {table_name} is in {mode} mode")
        return mode
    except Exception as e:
        print(f"Error checking table {table_name}: {str(e)}")
        return None

if __name__ == "__main__":
    REGION = [REGION]   # Change to your desired region

    switch_to_ondemand(region=REGION)

    Observação: substitua REGION pela sua Região.

  2. Salve o arquivo com o nome, switch_to_ondemand.py.

  3. Abra o terminal e execute o seguinte comando para executar o script Python:

    python switch_to_ondemand.py

Informações relacionadas

Capacidade de throughput do DynamoDB

Tópicos
Database
Tags
Amazon DynamoDB
Idioma
Português
AWS OFICIALAtualizada há 6 meses
Sem comentários

Conteúdo relevante