Salta al contenuto
Usando AWS re:Post, accetti AWS re:Post Termini di utilizzo
AWS re:Postre:Post
Informazioni su re:Post

Come posso modificare la modalità di capacità per più tabelle Amazon DynamoDB contemporaneamente?

13 minuti di lettura
0

Desidero modificare la modalità di capacità per più tabelle Amazon DynamoDB contemporaneamente.

Breve descrizione

Quando modifichi la modalità di capacità di più tabelle DynamoDB, devi specificare la modalità di capacità con provisioning o la modalità di capacità on demand. Prima di modificare la modalità di capacità, consulta Considerazioni sulla commutazione delle modalità di capacità in DynamoDB.

Per modificare la modalità di capacità di più tabelle DynamoDB contemporaneamente, utilizza uno dei seguenti metodi:

  • Interfaccia della linea di comando AWS (AWS CLI)
  • AWS CloudFormation
  • Python

Risoluzione

Best practice

Quando modifichi la modalità di capacità di più tabelle DynamoDB, utilizza le seguenti best practice:

  • Prima di iniziare la modifica, configura le credenziali AWS CLI appropriate.
  • Assicurati di avere le autorizzazioni AWS Identity and Access Management (AWS IAM) appropriate.
  • Distribuisci prima le modifiche in un ambiente non di produzione.
  • Attendi alcuni minuti affinché ogni tabella completi la commutazione.
  • Modifica modalità di capacità solo una volta ogni 24 ore per ogni tabella.
  • Analizza i modelli di utilizzo per selezionare la modalità di capacità appropriata e adattarla ai requisiti Regionali di AWS.
  • Monitora i costi dopo la commutazione per assicurarti di disporre della capacità con provisioning appropriata.

AWS CLI

Nota: se ricevi errori quando esegui i comandi dell'Interfaccia della linea di comando AWS (AWS CLI), consulta Risoluzione degli errori per AWS CLI. Inoltre, assicurati di utilizzare la versione più recente di AWS CLI.

Modalità con provisioning

Per modificare la modalità di capacità di più tabelle DynamoDB in modalità con provisioning utilizzando AWS CLI, completa i seguenti passaggi:

  1. Apri l'editor di testo e inserisci il seguente codice per creare un nuovo script di 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

    Per modificare la modalità di capacità di tutte le tabelle DynamoDB in modalità on demand, rimuovi la seguente sezione di codice:

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

    Per modificare la modalità di capacità di specifiche tabelle DynamoDB in modalità on demand, sostituisci "table1" "table2" "table3" con i nomi delle tue tabelle. Quindi rimuovi la seguente sezione di codice:

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

    Nota: sostituisci READ_CAPACITY_VALUE e WRITE_CAPACITY_VALUE con i valori della capacità di lettura e scrittura.

  2. Salva il file con il nome switch-all-tables-with-gsi-to-provisioned.sh.

  3. Per rendere eseguibile il file, apri il terminale ed esegui questo comando:

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

  4. Per eseguire lo script di shell nel terminale, esegui questo comando:

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

Modalità on demand

Per modificare la modalità di capacità di più tabelle DynamoDB in modalità on demand utilizzando AWS CLI, completa i seguenti passaggi:

  1. Apri l'editor di testo, quindi inserisci il seguente codice per creare un nuovo script di 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

    Per modificare la modalità di capacità di tutte le tabelle DynamoDB in modalità on demand, rimuovi la seguente sezione di codice:

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

    Per modificare la modalità di capacità di specifiche tabelle DynamoDB in modalità on demand, sostituisci "table1" "table2" "table3" con i nomi delle tue tabelle. Quindi rimuovi la seguente sezione di codice:

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

    Nota: sostituisci REGION con la tua Regione. Utilizza il codice della Regione, ad esempio us-east-1.

  2. Per rendere eseguibile il file, apri il terminale ed esegui il comando:

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

  3. Per eseguire lo script di shell nel terminale, esegui il comando:

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

CloudFormation

Applica le seguenti best practice:

  • Imposta i modelli AWS Lambda per utilizzare il runtime Python 3.9.
  • Monitora Amazon CloudWatch Logs per tenere traccia dei progressi della funzione Lambda.

Nota: prima di iniziare, configura le credenziali AWS. Esegui questo comando AWS CLI configure:

aws configure

Modalità con provisioning

Per modificare la modalità di capacità di più tabelle DynamoDB in modalità con provisioning utilizzando CloudFormation, completa i seguenti passaggi:

  1. Apri l'editor di testo e inserisci il seguente codice per creare un nuovo file 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. Salva il file con il nome switch-to-provisioned.yaml.

  3. Esegui questo comando AWS CLI create-stack:

    # 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]

    Nota: sostituisci "Table1,Table2,Table3" con i nomi delle tue tabelle, RCU_VALUE e WCU_VALUE con i tuoi valori RCU e WCU e REGION con la tua Regione, ad esempio us-east-1.

Modalità on demand

Per modificare la modalità di capacità di più tabelle DynamoDB in modalità on demand utilizzando CloudFormation, completa i seguenti passaggi:

  1. Apri l'editor di testo e inserisci il seguente codice per creare un nuovo file 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. Salva il file, con il nome switch-to-ondemand.yaml.

  3. Esegui questo comando AWS CLI create-stack:

    # 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"

    Nota: sostituisci "Table1,Table2,Table3" con i nomi delle tue tabelle e REGION con la tua Regione.

Python

Puoi utilizzare un'istanza Amazon Elastic Compute Cloud (EC2), Lambda o il desktop per eseguire uno script Python. Prima di modificare la modalità di capacità, assicurati di aver installato Python, pip e boto3.

Prima di iniziare, configura le credenziali AWS. Esegui questo comando AWS CLI configure:

aws configure

Modalità con provisioning

Per modificare la modalità di capacità di tutte le tabelle DynamoDB di una Regione specifica in modalità con provisioning utilizzando uno script Python, completa i seguenti passaggi:

  1. Apri Python e inserisci il seguente codice per creare un nuovo file:

    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
    )

    Nota: sostituisci RCU_VALUE e WCU_VALUE con i tuoi valori RCU E WCU e REGION con la tua Regione, ad esempio us-east-1.

  2. Salva il file con il nome switch_to_provisioned.py.

  3. Apri il terminale ed esegui questo comando per eseguire lo script Python:

    python switch_to_provisioned.py

Modalità on demand

Per modificare la modalità di capacità di tutte le tabelle DynamoDB di una Regione specifica in modalità on demand utilizzando uno script Python, completa i seguenti passaggi:

  1. Apri Python e inserisci il seguente codice per creare un nuovo file:

    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)

    Nota: sostituisci REGION con la tua Regione.

  2. Salva il file con il nome switch_to_ondemand.py.

  3. Apri il terminale ed esegui questo comando per eseguire lo script Python:

    python switch_to_ondemand.py

Informazioni correlate

Capacità di throughput di DynamoDB

Argomenti
Database
Tag
Amazon DynamoDB
Lingua
Italiano
AWS UFFICIALEAggiornata un anno fa

Contenuto pertinente