Replace EC2 API vCPU lookup with static instance size parsing

Drop the aws-sdk-go-v2/service/ec2 dependency entirely. Instead of
calling DescribeInstanceTypes (which required ec2:DescribeInstanceTypes
IAM permission and added ~5s IMDS timeout in tests), parse vCPU count
from the RDS instance class size suffix using a static map of standard
AWS size-to-vCPU mappings. Unlisted NUMxlarge sizes are handled via
multiplier parsing.

https://claude.ai/code/session_01AhnBVCBWjk24T7BBQtmkbq

Author: claude

engine/go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/aws/aws-sdk-go v1.55.8
 	github.com/aws/aws-sdk-go-v2 v1.41.5
 	github.com/aws/aws-sdk-go-v2/config v1.32.14
-	github.com/aws/aws-sdk-go-v2/service/ec2 v1.297.0
 	github.com/aws/aws-sdk-go-v2/service/rds v1.117.1
 	github.com/containerd/errdefs v1.0.0
 	github.com/docker/cli v28.5.2+incompatible

engine/go.sum

@@ -28,8 +28,6 @@ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 h1:PEgGVtPoB6NTpPrBgq
 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21/go.mod h1:p+hz+PRAYlY3zcpJhPwXlLC4C+kqn70WIHwnzAfs6ps=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 h1:qYQ4pzQ2Oz6WpQ8T3HvGHnZydA72MnLuFK9tJwmrbHw=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6/go.mod h1:O3h0IK87yXci+kg6flUKzJnWeziQUKciKrLjcatSNcY=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.297.0 h1:A+7NViqbMUCoTQFWjbSXdbzE4K5Ziu2zWJtZzAusm+A=
-github.com/aws/aws-sdk-go-v2/service/ec2 v1.297.0/go.mod h1:R+2BNtUfTfhPY0RH18oL02q116bakeBWjanrbnVBqkM=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 h1:5EniKhLZe4xzL7a+fU3C2tfUN4nWIqlLesfrjkuPFTY=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 h1:c31//R3xgIJMSC8S6hEVq+38DcvUlgFY0FM6mSI5oto=

engine/internal/rdsrefresh/parallelism.go

@@ -5,30 +5,45 @@
 package rdsrefresh
 
 import (
-	"context"
 	"fmt"
 	"runtime"
+	"strconv"
 	"strings"
 
-	"github.com/aws/aws-sdk-go-v2/aws"
-	awsconfig "github.com/aws/aws-sdk-go-v2/config"
-	"github.com/aws/aws-sdk-go-v2/service/ec2"
-	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
-
 	"gitlab.com/postgres-ai/database-lab/v3/pkg/log"
 )
 
 const (
-	// rdsInstanceClassPrefix is stripped to derive the EC2 instance type.
+	// rdsInstanceClassPrefix is stripped to derive the instance size.
 	rdsInstanceClassPrefix = "db."
 
 	// minParallelJobs is the minimum parallelism level.
 	minParallelJobs = 1
 )
 
-// EC2API defines the interface for EC2 client operations used for vCPU lookup.
-type EC2API interface {
-	DescribeInstanceTypes(ctx context.Context, params *ec2.DescribeInstanceTypesInput, optFns ...func(*ec2.Options)) (*ec2.DescribeInstanceTypesOutput, error)
+// instanceSizeVCPUs maps AWS instance size suffixes to their typical vCPU count.
+// this mapping is consistent across most instance families (m5, m6g, r5, r6g, c5, etc.).
+// graviton and intel/amd variants of the same size have the same vCPU count.
+var instanceSizeVCPUs = map[string]int{
+	"micro":    1,
+	"small":    1,
+	"medium":   2,
+	"large":    2,
+	"xlarge":   4,
+	"2xlarge":  8,
+	"3xlarge":  12,
+	"4xlarge":  16,
+	"6xlarge":  24,
+	"8xlarge":  32,
+	"9xlarge":  36,
+	"10xlarge": 40,
+	"12xlarge": 48,
+	"16xlarge": 64,
+	"18xlarge": 72,
+	"24xlarge": 96,
+	"32xlarge": 128,
+	"48xlarge": 192,
+	"metal":    96,
 }
 
 // ParallelismConfig holds the computed parallelism levels for dump and restore.
@@ -40,8 +55,10 @@ type ParallelismConfig struct {
 // ResolveParallelism determines the optimal parallelism levels for pg_dump and pg_restore.
 // dump parallelism is based on the vCPU count of the RDS clone instance class.
 // restore parallelism is based on the vCPU count of the local machine.
-func ResolveParallelism(ctx context.Context, cfg *Config) (*ParallelismConfig, error) {
-	dumpJobs, err := resolveRDSInstanceVCPUs(ctx, cfg)
+// local vCPU detection uses runtime.NumCPU(), which works on Linux
+// (the target platform for DBLab Engine).
+func ResolveParallelism(cfg *Config) (*ParallelismConfig, error) {
+	dumpJobs, err := resolveRDSInstanceVCPUs(cfg.RDSClone.InstanceClass)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve RDS instance vCPUs: %w", err)
 	}
@@ -56,79 +73,71 @@ func ResolveParallelism(ctx context.Context, cfg *Config) (*ParallelismConfig, e
 	}, nil
 }
 
-// resolveRDSInstanceVCPUs looks up the vCPU count for the configured RDS instance class
-// by querying the EC2 DescribeInstanceTypes API.
-func resolveRDSInstanceVCPUs(ctx context.Context, cfg *Config) (int, error) {
-	ec2Client, err := newEC2Client(ctx, cfg)
+// resolveRDSInstanceVCPUs estimates the vCPU count for the given RDS instance class
+// by parsing the instance size suffix (e.g. "xlarge" from "db.m5.xlarge").
+// the mapping covers standard AWS size naming used across RDS instance families.
+// if the size is not recognized, it attempts to parse a numeric multiplier prefix
+// (e.g. "2xlarge" → 8 vCPUs).
+func resolveRDSInstanceVCPUs(instanceClass string) (int, error) {
+	size, err := extractInstanceSize(instanceClass)
 	if err != nil {
-		return 0, fmt.Errorf("failed to create EC2 client: %w", err)
+		return 0, err
 	}
 
-	return lookupInstanceVCPUs(ctx, ec2Client, cfg.RDSClone.InstanceClass)
-}
-
-func newEC2Client(ctx context.Context, cfg *Config) (EC2API, error) {
-	awsCfg, err := awsconfig.LoadDefaultConfig(ctx, awsconfig.WithRegion(cfg.AWS.Region))
-	if err != nil {
-		return nil, fmt.Errorf("failed to load AWS config: %w", err)
+	if vcpus, ok := instanceSizeVCPUs[size]; ok {
+		return vcpus, nil
 	}
 
-	var opts []func(*ec2.Options)
-	if cfg.AWS.Endpoint != "" {
-		opts = append(opts, func(o *ec2.Options) {
-			o.BaseEndpoint = aws.String(cfg.AWS.Endpoint)
-		})
+	// handle unlisted NUMxlarge sizes by parsing the multiplier
+	vcpus, err := parseXlargeMultiplier(size)
+	if err != nil {
+		return 0, fmt.Errorf("unknown instance size %q in class %q", size, instanceClass)
 	}
 
-	return ec2.NewFromConfig(awsCfg, opts...), nil
+	return vcpus, nil
 }
 
-// lookupInstanceVCPUs queries EC2 for the vCPU count of the given RDS instance class.
-func lookupInstanceVCPUs(ctx context.Context, client EC2API, rdsInstanceClass string) (int, error) {
-	ec2InstanceType, err := rdsClassToEC2Type(rdsInstanceClass)
-	if err != nil {
-		return 0, err
+// extractInstanceSize extracts the size component from an RDS instance class.
+// for example, "db.m5.xlarge" → "xlarge", "db.r6g.2xlarge" → "2xlarge".
+func extractInstanceSize(instanceClass string) (string, error) {
+	if !strings.HasPrefix(instanceClass, rdsInstanceClassPrefix) {
+		return "", fmt.Errorf("invalid RDS instance class %q: expected %q prefix", instanceClass, rdsInstanceClassPrefix)
 	}
 
-	result, err := client.DescribeInstanceTypes(ctx, &ec2.DescribeInstanceTypesInput{
-		InstanceTypes: []ec2types.InstanceType{ec2types.InstanceType(ec2InstanceType)},
-	})
-	if err != nil {
-		return 0, fmt.Errorf("failed to describe EC2 instance type %q: %w", ec2InstanceType, err)
-	}
-
-	if len(result.InstanceTypes) == 0 {
-		return 0, fmt.Errorf("EC2 instance type %q not found", ec2InstanceType)
-	}
+	withoutPrefix := strings.TrimPrefix(instanceClass, rdsInstanceClassPrefix)
 
-	info := result.InstanceTypes[0]
-	if info.VCpuInfo == nil || info.VCpuInfo.DefaultVCpus == nil {
-		return 0, fmt.Errorf("vCPU info not available for instance type %q", ec2InstanceType)
-	}
+	// format is "family.size", e.g. "m5.xlarge" or "r6g.2xlarge"
+	parts := strings.SplitN(withoutPrefix, ".", 2)
 
-	vcpus := int(*info.VCpuInfo.DefaultVCpus)
-	if vcpus < minParallelJobs {
-		return minParallelJobs, nil
+	const expectedParts = 2
+	if len(parts) != expectedParts || parts[1] == "" {
+		return "", fmt.Errorf("invalid RDS instance class %q: expected format db.<family>.<size>", instanceClass)
 	}
 
-	return vcpus, nil
+	return parts[1], nil
 }
 
-// rdsClassToEC2Type converts an RDS instance class (e.g. "db.m5.xlarge") to an EC2 instance type ("m5.xlarge").
-func rdsClassToEC2Type(rdsClass string) (string, error) {
-	if !strings.HasPrefix(rdsClass, rdsInstanceClassPrefix) {
-		return "", fmt.Errorf("invalid RDS instance class %q: expected %q prefix", rdsClass, rdsInstanceClassPrefix)
+// parseXlargeMultiplier handles NUMxlarge patterns not in the static map.
+// for example, "5xlarge" → 5 * 4 = 20 vCPUs.
+func parseXlargeMultiplier(size string) (int, error) {
+	idx := strings.Index(size, "xlarge")
+	if idx <= 0 {
+		return 0, fmt.Errorf("not an xlarge variant: %q", size)
 	}
 
-	ec2Type := strings.TrimPrefix(rdsClass, rdsInstanceClassPrefix)
-	if ec2Type == "" {
-		return "", fmt.Errorf("invalid RDS instance class %q: empty after removing prefix", rdsClass)
+	multiplier, err := strconv.Atoi(size[:idx])
+	if err != nil {
+		return 0, fmt.Errorf("invalid multiplier in %q: %w", size, err)
 	}
 
-	return ec2Type, nil
+	const vcpusPerXlarge = 4
+
+	return multiplier * vcpusPerXlarge, nil
 }
 
 // resolveLocalVCPUs returns the number of logical CPUs available on the local machine.
+// uses runtime.NumCPU() which reads from /proc/cpuinfo on Linux
+// (the target platform for DBLab Engine).
 func resolveLocalVCPUs() int {
 	cpus := runtime.NumCPU()
 	if cpus < minParallelJobs {