Amazon Cognito の新機能「Provisioned Limit API」を実際に試してみた

{
    "RequestedQuota": {
        "Id": "9e1e8001-example-request-id",
        "ServiceCode": "cognito-idp",
        "ServiceName": "Amazon Cognito User Pools",
        "QuotaCode": "L-5987B8A0",
        "QuotaName": "Rate of UserCreation requests",
        "DesiredValue": 75.0,
        "Status": "PENDING",
        "Created": "2026-07-03T16:54:34+09:00",
        "Requester": "{\"accountId\":\"123456789012\",\"callerArn\":\"arn:aws:sts::123456789012:assumed-role/example-role/example-user\"}",
        "QuotaArn": "arn:aws:servicequotas:ap-northeast-1:123456789012:cognito-idp/L-5987B8A0",
        "GlobalQuota": false,
        "Unit": "None",
        "QuotaRequestedAtLevel": "ACCOUNT"
    }
}

package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"os"
	"sync"
	"sync/atomic"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/aws/retry"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider"
	"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider/types"
)

func main() {
	concurrency := flag.Int("concurrency", 10, "Number of concurrent goroutines")
	totalUsers := flag.Int("users", 1000, "Total number of users to create")
	userPoolID := flag.String("user-pool-id", "", "Cognito User Pool ID")
	region := flag.String("region", "ap-northeast-1", "AWS Region")
	flag.Parse()

	prefix := fmt.Sprintf("loadtest-%d", time.Now().Unix())

	// Load AWS config with NO retries (we want to measure throttling directly)
	cfg, err := config.LoadDefaultConfig(context.Background(),
		config.WithRegion(*region),
		config.WithRetryer(func() aws.Retryer {
			return retry.AddWithMaxAttempts(retry.NewStandard(), 1)
		}),
	)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to load AWS config: %v\n", err)
		os.Exit(1)
	}

	client := cognitoidentityprovider.NewFromConfig(cfg)

	var (
		successCount  int64
		throttleCount int64
		latencies     []time.Duration
		latencyMu     sync.Mutex
	)

	sem := make(chan struct{}, *concurrency)
	var wg sync.WaitGroup

	startTime := time.Now()

	for i := 0; i < *totalUsers; i++ {
		wg.Add(1)
		sem <- struct{}{}

		go func(seq int) {
			defer wg.Done()
			defer func() { <-sem }()

			username := fmt.Sprintf("%s-%04d", prefix, seq)
			reqStart := time.Now()

			_, createErr := client.AdminCreateUser(context.Background(),
				&cognitoidentityprovider.AdminCreateUserInput{
					UserPoolId:    userPoolID,
					Username:      aws.String(username),
					MessageAction: types.MessageActionTypeSuppress,
				})

			elapsed := time.Since(reqStart)

			if createErr != nil {
				var tooMany *types.TooManyRequestsException
				if errors.As(createErr, &tooMany) {
					atomic.AddInt64(&throttleCount, 1)
				}
			} else {
				atomic.AddInt64(&successCount, 1)
				latencyMu.Lock()
				latencies = append(latencies, elapsed)
				latencyMu.Unlock()
			}
		}(i)
	}

	wg.Wait()
	totalDuration := time.Since(startTime)

	// Calculate percentiles and output results...
}