How to fix LimitExceededException: Subscriber limit exceeded in DynamoDB

resource "aws_dynamodb_table" "table1" {
  name           = "users-table"
  billing_mode   = "PAY_PER_REQUEST"
  hash_key       = "userId"

  attribute {
    name = "userId"
    type = "S"
  }
}

resource "aws_dynamodb_table" "table2" {
  name           = "orders-table"
  billing_mode   = "PAY_PER_REQUEST"
  hash_key       = "orderId"

  attribute {
    name = "orderId"
    type = "S"
  }

  # Force sequential creation
  depends_on = [aws_dynamodb_table.table1]
}

resource "aws_dynamodb_table" "table3" {
  name           = "products-table"
  billing_mode   = "PAY_PER_REQUEST"
  hash_key       = "productId"

  attribute {
    name = "productId"
    type = "S"
  }

  depends_on = [aws_dynamodb_table.table2]
}

Resources:
  UsersTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: users-table
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: userId
          AttributeType: S
      KeySchema:
        - AttributeName: userId
          KeyType: HASH

  OrdersTable:
    Type: AWS::DynamoDB::Table
    DependsOn: UsersTable  # Sequential dependency
    Properties:
      TableName: orders-table
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: orderId
          AttributeType: S
      KeySchema:
        - AttributeName: orderId
          KeyType: HASH

// AWS SDK v3 example with batching
import { DynamoDBClient, CreateTableCommand } from '@aws-sdk/client-dynamodb';

const client = new DynamoDBClient({ region: 'us-east-1' });
const CONCURRENT_LIMIT = 8; // Stay below 10 to be safe
const BATCH_DELAY_MS = 30000; // 30 seconds between batches

async function createTablesInBatches(tableConfigs) {
  const batches = [];
  for (let i = 0; i < tableConfigs.length; i += CONCURRENT_LIMIT) {
    batches.push(tableConfigs.slice(i, i + CONCURRENT_LIMIT));
  }

  for (const [index, batch] of batches.entries()) {
    console.log(`Creating batch ${index + 1}/${batches.length} (${batch.length} tables)...`);

    const promises = batch.map(config =>
      client.send(new CreateTableCommand(config))
        .catch(err => {
          console.error(`Failed to create ${config.TableName}:`, err.message);
          return null;
        })
    );

    await Promise.all(promises);

    // Wait before next batch
    if (index < batches.length - 1) {
      console.log(`Waiting ${BATCH_DELAY_MS / 1000}s before next batch...`);
      await new Promise(resolve => setTimeout(resolve, BATCH_DELAY_MS));
    }
  }
}

// Usage
const tables = [
  { TableName: 'table1', /* ... config ... */ },
  { TableName: 'table2', /* ... config ... */ },
  // ... 20 more tables
];

await createTablesInBatches(tables);

import { DynamoDBClient, DescribeTableCommand } from '@aws-sdk/client-dynamodb';

const client = new DynamoDBClient({ region: 'us-east-1' });

async function waitForTableActive(tableName, maxWaitSeconds = 300) {
  const startTime = Date.now();
  const maxWaitMs = maxWaitSeconds * 1000;

  while (Date.now() - startTime < maxWaitMs) {
    try {
      const response = await client.send(
        new DescribeTableCommand({ TableName: tableName })
      );

      const status = response.Table?.TableStatus;
      console.log(`Table ${tableName} status: ${status}`);

      if (status === 'ACTIVE') {
        return true;
      }

      if (status === 'DELETING') {
        throw new Error(`Table ${tableName} is being deleted`);
      }

      // Wait 5 seconds before next check
      await new Promise(resolve => setTimeout(resolve, 5000));

    } catch (err) {
      if (err.name === 'ResourceNotFoundException') {
        throw new Error(`Table ${tableName} not found`);
      }
      throw err;
    }
  }

  throw new Error(`Timeout waiting for table ${tableName} to become ACTIVE`);
}

// Example usage in sequential deployment
async function deployTablesSequentially(tableConfigs) {
  for (const config of tableConfigs) {
    console.log(`Creating table: ${config.TableName}`);

    await client.send(new CreateTableCommand(config));

    console.log(`Waiting for ${config.TableName} to become ACTIVE...`);
    await waitForTableActive(config.TableName);

    console.log(`Table ${config.TableName} is ready`);
  }
}

# main.tf - Deploy in stages
module "core_tables" {
  source = "./modules/core-tables"
  # 8 tables maximum
}

module "analytics_tables" {
  source = "./modules/analytics-tables"
  depends_on = [module.core_tables]
  # Another 8 tables
}

module "archive_tables" {
  source = "./modules/archive-tables"
  depends_on = [module.analytics_tables]
  # Remaining tables
}

# master-stack.yaml
Resources:
  CoreTablesStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/my-bucket/core-tables.yaml

  AnalyticsTablesStack:
    Type: AWS::CloudFormation::Stack
    DependsOn: CoreTablesStack
    Properties:
      TemplateURL: https://s3.amazonaws.com/my-bucket/analytics-tables.yaml

  ArchiveTablesStack:
    Type: AWS::CloudFormation::Stack
    DependsOn: AnalyticsTablesStack
    Properties:
      TemplateURL: https://s3.amazonaws.com/my-bucket/archive-tables.yaml

# Deploy in stages
serverless deploy --config serverless.core.yml
serverless deploy --config serverless.analytics.yml
serverless deploy --config serverless.archive.yml

# Check current service quotas
aws service-quotas list-service-quotas \
  --service-code dynamodb \
  --query 'Quotas[?QuotaName==`Concurrent control plane operations`]'

# Request quota increase (via AWS Console or Support ticket)
# Note: Not all quotas are adjustable

import { DynamoDBClient, ListTablesCommand, DescribeTableCommand } from '@aws-sdk/client-dynamodb';

const client = new DynamoDBClient({ region: 'us-east-1' });

async function countActiveOperations() {
  const listResponse = await client.send(new ListTablesCommand({}));
  const tableNames = listResponse.TableNames || [];

  const statuses = await Promise.all(
    tableNames.map(async (tableName) => {
      try {
        const response = await client.send(
          new DescribeTableCommand({ TableName: tableName })
        );
        return {
          name: tableName,
          status: response.Table?.TableStatus,
          gsiStatuses: response.Table?.GlobalSecondaryIndexes?.map(gsi => ({
            name: gsi.IndexName,
            status: gsi.IndexStatus
          })) || []
        };
      } catch (err) {
        return { name: tableName, status: 'ERROR', error: err.message };
      }
    })
  );

  const transitionalStates = ['CREATING', 'UPDATING', 'DELETING'];
  const activeOps = statuses.filter(table =>
    transitionalStates.includes(table.status) ||
    table.gsiStatuses?.some(gsi => transitionalStates.includes(gsi.status))
  );

  console.log(`Active control plane operations: ${activeOps.length}`);
  console.log('Tables in transitional states:', activeOps);

  return activeOps.length;
}

// Check before starting new operations
const activeCount = await countActiveOperations();
if (activeCount >= 8) {
  console.log('Too many active operations, waiting...');
  await new Promise(resolve => setTimeout(resolve, 60000));
}