AWS re:Post Knowledge Center Feedback Survey

Help us improve the AWS re:Post Knowledge Center by sharing your feedback in a brief survey. Your input can influence how we create and update our content to better support your AWS journey.

Comment modifier le mode de capacité pour plusieurs tables Amazon DynamoDB simultanément ?

Lecture de 13 minute(s)

Je souhaite modifier le mode de capacité pour plusieurs tables Amazon DynamoDB simultanément.

Brève description

Lorsque vous modifiez le mode de capacité de plusieurs tables DynamoDB, vous devez spécifier le mode de capacité provisionné ou le mode de capacité à la demande. Avant de modifier le mode de capacité, consultez la section Considérations relatives au changement de mode de capacité dans DynamoDB.

Pour modifier le mode de capacité de plusieurs tables DynamoDB simultanément, appliquez l'une des méthodes suivantes :

Interface de la ligne de commande AWS (AWS CLI)
AWS CloudFormation
Python

Résolution

Bonnes pratiques

Lorsque vous modifiez le mode de capacité de plusieurs tables DynamoDB, appliquez les bonnes pratiques suivantes :

Avant de lancer la modification, configurez les informations d'identification de l’AWS CLI appropriées.
Assurez-vous que vous disposez des autorisations de Gestion des identités et des accès AWS (AWS IAM) appropriées.
Déployez d'abord vos modifications dans un environnement hors production.
Prévoyez quelques minutes pour que chaque table effectue le changement.
Changez de mode de capacité une seule fois toutes les 24 heures pour chaque table.
Analysez les modèles d'utilisation pour sélectionner le mode de capacité approprié et ajustez-le aux exigences régionales d'AWS.
Surveillez les coûts après le changement pour vous assurer que vous disposez de la capacité provisionnée appropriée.

AWS CLI

Remarque : Si des erreurs surviennent lorsque vous exécutez des commandes de l'interface de la ligne de commande AWS (AWS CLI), consultez la section Résoudre des erreurs liées à l’AWS CLI. Vérifiez également que vous utilisez bien la version la plus récente de l’AWS CLI.

Mode provisionné

Pour changer le mode de capacité de plusieurs tables DynamoDB en mode provisionné dans l'interface de ligne de commande AWS, procédez comme suit :

Ouvrez votre éditeur de texte, et saisissez le code suivant pour créer un nouveau script 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

Pour changer le mode de capacité de toutes les tables DynamoDB en mode à la demande, supprimez la section de code suivante :

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

Pour changer le mode de capacité de certaines tables DynamoDB en mode à la demande, remplacez « table1 », « table2 », « table3 » par le nom de vos tables. Puis, supprimez la section de code suivante :

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

Remarque : Remplacez READ_CAPACITY_VALUE et WRITE_CAPACITY_VALUE par vos valeurs de capacité de lecture et d'écriture.

Enregistrez le fichier sous le nom switch-all-tables-with-gsi-to-provisioned.sh.

Pour rendre le fichier exécutable, ouvrez le terminal et exécutez la commande suivante :

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

Pour exécuter le script shell dans le terminal, exécutez la commande suivante :

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

Mode à la demande

Pour utiliser l'interface de ligne de commande AWS afin de changer le mode de capacité de plusieurs tables DynamoDB en mode à la demande, procédez comme suit :

Ouvrez votre éditeur de texte, puis saisissez le code suivant pour créer un nouveau script 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

Pour changer le mode de capacité de toutes les tables DynamoDB en mode à la demande, supprimez la section de code suivante :

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

Remarque : Remplacez REGION par votre région. Utilisez le code de la région, tel que us-east-1.

Pour rendre le fichier exécutable, ouvrez le terminal et exécutez la commande :

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

Pour exécuter le script shell dans le terminal, exécutez la commande suivante :

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

CloudFormation

Utilisez les bonnes pratiques suivantes :

Configurez les modèles AWS Lambda pour utiliser le moteur d'exécution Python 3.9.
Surveillez Amazon CloudWatch Logs pour suivre la progression de la fonction Lambda.

Remarque : Avant de commencer, configurez vos informations d'identification AWS. Exécutez la commande configure de l’AWS CLI suivante :

aws configure

Mode provisionné

Pour utiliser CloudFormation afin de changer le mode de capacité de plusieurs tables DynamoDB en mode provisionné, procédez comme suit :

Ouvrez votre éditeur de texte et saisissez le code suivant pour créer un nouveau fichier 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: '*'

Enregistrez le fichier sous le nom switch-to-provisioned.yaml.

Exécutez la commande create-stack de l’AWS CLI suivante :

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

Remarque : Remplacez « Table1, Table2, Table3 » par le nom de vos tables, RCU_VALUE et WCU_VALUE par vos valeurs RCU et WCU, et REGION par votre région, par exemple us-east-1.

Mode à la demande

Pour utiliser CloudFormation afin de changer le mode de capacité de plusieurs tables DynamoDB en mode à la demande, procédez comme suit :

Ouvrez votre éditeur de texte et saisissez le code suivant pour créer un nouveau fichier 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: '*'

Enregistrez le fichier sous le nom switch-to-ondemand.yaml.

Exécutez la commande create-stack de l’AWS CLI suivante :

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

Remarque : Remplacez « Table1, Table2, Table3 » par le nom de vos tables et REGION par votre région.

Python

Vous pouvez utiliser une instance Amazon Elastic Compute Cloud (EC2), Lambda ou votre propre bureau pour exécuter un script Python. Avant de modifier le mode de capacité, assurez-vous d'avoir installé Python, pip et boto3.

Avant de commencer, configurez vos informations d'identification AWS. Exécutez la commande configure de l’AWS CLI suivante :

aws configure

Mode provisionné

Pour utiliser un script Python afin de changer le mode de capacité de toutes les tables DynamoDB d'une région spécifique en mode provisionné, procédez comme suit :

Ouvrez Python et saisissez le code suivant pour créer un nouveau fichier :

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
    )

Remarque : Remplacez RCU_VALUE et WCU_VALUE par vos valeurs RCU ET WCU et REGION par votre région, par exemple us-east-1.

Enregistrez le fichier sous le nom switch_to_provisioned.py.

Ouvrez le terminal et exécutez la commande suivante pour exécuter le script Python :

python switch_to_provisioned.py

Mode à la demande

Pour changer le mode de capacité de toutes les tables DynamoDB d'une région spécifique en mode à la demande à l’aide d’un script Python, procédez comme suit :

Ouvrez Python et saisissez le code suivant pour créer un nouveau fichier :

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)

Remarque : Remplacez REGION par votre région.

Enregistrez le fichier sous le nom switch_to_ondemand.py.
Ouvrez le terminal et exécutez la commande suivante pour exécuter le script Python :
```
python switch_to_ondemand.py
```

Informations connexes

Capacité de débit de DynamoDB

Sujets: Database
Balises: Amazon DynamoDB
Langue: Français

AWS OFFICIELA mis à jour il y a un an

Aucun commentaire

Contenus pertinents

DynamoDB metrics sur la quantité d'item
rePost-User-0177378
demandé il y a 3 ans
"Error: Body must be a string. Received: undefined." à l'insertion dans DynamoDB react native
Mathieu Ridet
demandé il y a 2 ans
Augmenter la capacité de mon volume
Capt_Scoffi
demandé il y a un an
Création de tables SQL
yannick
demandé il y a 3 ans
configurer plusieurs régions dans le fichier de configuration de Textract
rePost-User-4710275
demandé il y a 2 ans
Comment puis-je modifier le mode de capacité de lecture et d'écriture de ma table DynamoDB ?
AWS OFFICIELA mis à jour il y a 2 ans
Pourquoi ma table Amazon DynamoDB est-elle bloquée avec le statut MISE À JOUR EN COURS ?
AWS OFFICIELA mis à jour il y a 2 ans
Pourquoi ma table provisionnée Amazon DynamoDB est-elle limitée ?
AWS OFFICIELA mis à jour il y a 2 ans
Comment optimiser mes applications AWS Glue ETL lors de la lecture ou de l'écriture dans Amazon DynamoDB ?
AWS OFFICIELA mis à jour il y a 5 ans