Java应用自动扩缩容的三种实现方案

// 传统模式：手动扩容（地狱级）
if (CPU爆表) {
    System.out.println("啊！快启动新实例！");
    startNewInstance(); // 拼命按按钮...
}

// 自动扩缩容：智能决策（天堂级）
public class CostAwareScaler {
    private final CloudCostCalculator costCalculator;
    private final AutoscalingPolicy policy;

    public ScalingDecision decideScalingAction(ResourceMetrics metrics) {
        double currentCost = costCalculator.calculateCurrentCost();
        if (metrics.getCpuUsage() > policy.getCpuThreshold() || 
            metrics.getMemoryUsage() > policy.getMemoryThreshold()) {
            return new ScalingDecision(ScalingAction.EXPAND, 
                                       selectOptimalInstanceType(currentCost), 
                                       calculateReplicas(metrics.getRequestRate()));
        } else if (currentCost > policy.getCostThreshold()) {
            return new ScalingDecision(ScalingAction.SHRINK, 
                                       CloudInstanceType.SPOT, // 优先缩容竞价实例
                                       1);
        }
        return ScalingDecision.NO_ACTION;
    }

    private CloudInstanceType selectOptimalInstanceType(double currentCost) {
        // 选择成本最低的可用实例类型
        return resourcePool.getInsta...; // 实际需结合云厂商API
    }
}

// AWS扩缩容：调用API动态切换实例类型
public class AWSScaler {
    private final AutoScalingClient client;

    public void scale(String groupName, int desiredCapacity, CloudInstanceType type) {
        SetDesiredCapacityRequest request = SetDesiredCapacityRequest.builder()
            .autoScalingGroupName(groupName)
            .desiredCapacity(desiredCapacity)
            .instanceType(type.toString()) // 动态指定实例类型
            .build();
        client.execute(request);
    }
}

// 冷热分离：自动迁移冷数据到对象存储
public class ObjectStorageManager {
    public void migrateColdData() {
        List<StorageObject> allObjects = listAllObjects();
        for (StorageObject obj : allObjects) {
            if (obj.getLastAccessTime() < THRESHOLD) { // 180天未访问
                moveToColdStorage(obj); // 迁移至对象存储（如AWS S3 Glacier）
            }
        }
    }

    private void moveToColdStorage(StorageObject obj) {
        // 调用云厂商API迁移数据
        storageClient.move(obj.getId(), "cold-bucket");
    }
}

// 监控指标：CPU、内存、请求延迟
@EnableActuator
@SpringBootApplication
public class MonitoringApp {
    public static void main(String[] args) {
        SpringApplication.run(MonitoringApp.class, args);
    }
}

// 自定义指标：数据库连接数
public class CustomMetrics {
    private static final Gauge<Integer> DB_CONNECTIONS = Gauge.builder("db_connections", 
        () -> dataSource.getConnectionCount())
        .register();
}

// 决策算法：基于CPU/内存/请求量动态扩缩容
public class DecisionEngine {
    public boolean needScaleUp(double cpuUsage, double memoryUsage, long requestRate) {
        return cpuUsage > 0.8 || memoryUsage > 0.9 || requestRate > 1000;
    }

    public boolean needScaleDown(double cpuUsage, long requestRate) {
        return cpuUsage < 0.3 && requestRate < 500;
    }
}

# Kubernetes HPA配置示例
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-java-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-java-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          averageUtilization: 70