第52集私有化部署MinIO集群搭建与运维管理实战

/**
 * MinIO部署配置
 */
@Configuration
public class MinIODeploymentConfig {
    
    @Value("${minio.deployment.mode}")
    private String deploymentMode;
    
    @Value("${minio.deployment.nodes}")
    private String nodes;
    
    @Value("${minio.deployment.access-key}")
    private String accessKey;
    
    @Value("${minio.deployment.secret-key}")
    private String secretKey;
    
    @Value("${minio.deployment.console-port}")
    private int consolePort;
    
    @Value("${minio.deployment.api-port}")
    private int apiPort;
    
    /**
     * MinIO部署配置
     */
    @Bean
    public MinIODeploymentProperties deploymentProperties() {
        return MinIODeploymentProperties.builder()
            .mode(deploymentMode)
            .nodes(Arrays.asList(nodes.split(",")))
            .accessKey(accessKey)
            .secretKey(secretKey)
            .consolePort(consolePort)
            .apiPort(apiPort)
            .build();
    }
    
    /**
     * MinIO集群管理服务
     */
    @Bean
    public MinIOClusterService clusterService() {
        return new MinIOClusterService(deploymentProperties());
    }
    
    /**
     * MinIO运维服务
     */
    @Bean
    public MinIOOperationService operationService() {
        return new MinIOOperationService(deploymentProperties());
    }
}

/**
 * MinIO部署配置属性
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MinIODeploymentProperties {
    private String mode; // standalone, distributed
    private List<String> nodes;
    private String accessKey;
    private String secretKey;
    private int consolePort;
    private int apiPort;
    private Map<String, Object> additionalConfig = new HashMap<>();
}

/**
 * MinIO集群管理服务
 */
@Service
public class MinIOClusterService {
    
    private final MinIODeploymentProperties deploymentProperties;
    private final Map<String, MinioClient> clients = new ConcurrentHashMap<>();
    
    public MinIOClusterService(MinIODeploymentProperties deploymentProperties) {
        this.deploymentProperties = deploymentProperties;
        initializeClients();
    }
    
    /**
     * 初始化MinIO客户端
     */
    private void initializeClients() {
        try {
            for (String node : deploymentProperties.getNodes()) {
                String[] parts = node.split(":");
                String host = parts[0];
                int port = Integer.parseInt(parts[1]);
                
                MinioClient client = MinioClient.builder()
                    .endpoint("http://" + host + ":" + port)
                    .credentials(deploymentProperties.getAccessKey(), deploymentProperties.getSecretKey())
                    .build();
                
                clients.put(node, client);
                
                log.info("初始化MinIO客户端成功: {}", node);
            }
            
        } catch (Exception e) {
            log.error("初始化MinIO客户端失败", e);
            throw new RuntimeException("初始化MinIO客户端失败", e);
        }
    }
    
    /**
     * 检查集群状态
     * @return 集群状态
     */
    public ClusterStatus checkClusterStatus() {
        ClusterStatus status = new ClusterStatus();
        status.setMode(deploymentProperties.getMode());
        status.setTotalNodes(deploymentProperties.getNodes().size());
        
        List<NodeStatus> nodeStatuses = new ArrayList<>();
        int healthyNodes = 0;
        
        for (String node : deploymentProperties.getNodes()) {
            NodeStatus nodeStatus = checkNodeStatus(node);
            nodeStatuses.add(nodeStatus);
            
            if (nodeStatus.isHealthy()) {
                healthyNodes++;
            }
        }
        
        status.setNodeStatuses(nodeStatuses);
        status.setHealthyNodes(healthyNodes);
        status.setClusterHealthy(healthyNodes >= deploymentProperties.getNodes().size() / 2 + 1);
        
        return status;
    }
    
    /**
     * 检查节点状态
     * @param node 节点
     * @return 节点状态
     */
    private NodeStatus checkNodeStatus(String node) {
        NodeStatus status = new NodeStatus();
        status.setNode(node);
        
        try {
            MinioClient client = clients.get(node);
            if (client == null) {
                status.setHealthy(false);
                status.setErrorMessage("客户端未初始化");
                return status;
            }
            
            // 检查服务是否可用
            client.listBuckets();
            
            status.setHealthy(true);
            status.setLastCheckTime(LocalDateTime.now());
            
        } catch (Exception e) {
            status.setHealthy(false);
            status.setErrorMessage(e.getMessage());
            status.setLastCheckTime(LocalDateTime.now());
            
            log.warn("节点状态检查失败: node={}, error={}", node, e.getMessage());
        }
        
        return status;
    }
    
    /**
     * 创建存储桶
     * @param bucketName 存储桶名称
     * @return 创建结果
     */
    public BucketCreateResult createBucket(String bucketName) {
        try {
            // 选择健康的节点进行创建
            MinioClient client = getHealthyClient();
            if (client == null) {
                return BucketCreateResult.error("没有可用的健康节点");
            }
            
            boolean exists = client.bucketExists(BucketExistsArgs.builder()
                .bucket(bucketName)
                .build());
            
            if (exists) {
                return BucketCreateResult.error("存储桶已存在");
            }
            
            client.makeBucket(MakeBucketArgs.builder()
                .bucket(bucketName)
                .build());
            
            log.info("创建存储桶成功: bucketName={}", bucketName);
            
            return BucketCreateResult.success(bucketName);
            
        } catch (Exception e) {
            log.error("创建存储桶失败: bucketName={}", bucketName, e);
            return BucketCreateResult.error("创建存储桶失败: " + e.getMessage());
        }
    }
    
    /**
     * 删除存储桶
     * @param bucketName 存储桶名称
     * @return 删除结果
     */
    public BucketDeleteResult deleteBucket(String bucketName) {
        try {
            MinioClient client = getHealthyClient();
            if (client == null) {
                return BucketDeleteResult.error("没有可用的健康节点");
            }
            
            boolean exists = client.bucketExists(BucketExistsArgs.builder()
                .bucket(bucketName)
                .build());
            
            if (!exists) {
                return BucketDeleteResult.error("存储桶不存在");
            }
            
            client.removeBucket(RemoveBucketArgs.builder()
                .bucket(bucketName)
                .build());
            
            log.info("删除存储桶成功: bucketName={}", bucketName);
            
            return BucketDeleteResult.success(bucketName);
            
        } catch (Exception e) {
            log.error("删除存储桶失败: bucketName={}", bucketName, e);
            return BucketDeleteResult.error("删除存储桶失败: " + e.getMessage());
        }
    }
    
    /**
     * 获取存储桶列表
     * @return 存储桶列表
     */
    public List<BucketInfo> listBuckets() {
        try {
            MinioClient client = getHealthyClient();
            if (client == null) {
                return Collections.emptyList();
            }
            
            List<Bucket> buckets = client.listBuckets();
            
            return buckets.stream()
                .map(bucket -> BucketInfo.builder()
                    .name(bucket.name())
                    .creationDate(bucket.creationDate())
                    .build())
                .collect(Collectors.toList());
            
        } catch (Exception e) {
            log.error("获取存储桶列表失败", e);
            return Collections.emptyList();
        }
    }
    
    /**
     * 获取健康的客户端
     * @return MinIO客户端
     */
    private MinioClient getHealthyClient() {
        for (String node : deploymentProperties.getNodes()) {
            NodeStatus status = checkNodeStatus(node);
            if (status.isHealthy()) {
                return clients.get(node);
            }
        }
        return null;
    }
}

/**
 * 集群状态
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ClusterStatus {
    private String mode;
    private int totalNodes;
    private int healthyNodes;
    private boolean clusterHealthy;
    private List<NodeStatus> nodeStatuses;
    private LocalDateTime checkTime;
}

/**
 * 节点状态
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class NodeStatus {
    private String node;
    private boolean healthy;
    private String errorMessage;
    private LocalDateTime lastCheckTime;
}

/**
 * 存储桶信息
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BucketInfo {
    private String name;
    private LocalDateTime creationDate;
}

/**
 * 存储桶创建结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BucketCreateResult {
    private boolean success;
    private String bucketName;
    private String message;
    
    public static BucketCreateResult success(String bucketName) {
        return BucketCreateResult.builder()
            .success(true)
            .bucketName(bucketName)
            .build();
    }
    
    public static BucketCreateResult error(String message) {
        return BucketCreateResult.builder()
            .success(false)
            .message(message)
            .build();
    }
}

/**
 * 存储桶删除结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BucketDeleteResult {
    private boolean success;
    private String bucketName;
    private String message;
    
    public static BucketDeleteResult success(String bucketName) {
        return BucketDeleteResult.builder()
            .success(true)
            .bucketName(bucketName)
            .build();
    }
    
    public static BucketDeleteResult error(String message) {
        return BucketDeleteResult.builder()
            .success(false)
            .message(message)
            .build();
    }
}

/**
 * MinIO运维管理服务
 */
@Service
public class MinIOOperationService {
    
    private final MinIODeploymentProperties deploymentProperties;
    private final MinIOClusterService clusterService;
    
    public MinIOOperationService(MinIODeploymentProperties deploymentProperties) {
        this.deploymentProperties = deploymentProperties;
        this.clusterService = new MinIOClusterService(deploymentProperties);
    }
    
    /**
     * 获取集群信息
     * @return 集群信息
     */
    public ClusterInfo getClusterInfo() {
        try {
            ClusterStatus status = clusterService.checkClusterStatus();
            
            ClusterInfo info = ClusterInfo.builder()
                .mode(status.getMode())
                .totalNodes(status.getTotalNodes())
                .healthyNodes(status.getHealthyNodes())
                .clusterHealthy(status.isClusterHealthy())
                .nodeStatuses(status.getNodeStatuses())
                .buckets(clusterService.listBuckets())
                .checkTime(LocalDateTime.now())
                .build();
            
            return info;
            
        } catch (Exception e) {
            log.error("获取集群信息失败", e);
            return ClusterInfo.builder()
                .clusterHealthy(false)
                .errorMessage(e.getMessage())
                .build();
        }
    }
    
    /**
     * 执行集群健康检查
     * @return 健康检查结果
     */
    public HealthCheckResult performHealthCheck() {
        try {
            HealthCheckResult result = new HealthCheckResult();
            result.setCheckTime(LocalDateTime.now());
            
            // 1. 检查集群状态
            ClusterStatus clusterStatus = clusterService.checkClusterStatus();
            result.setClusterHealthy(clusterStatus.isClusterHealthy());
            result.setHealthyNodes(clusterStatus.getHealthyNodes());
            result.setTotalNodes(clusterStatus.getTotalNodes());
            
            // 2. 检查存储桶
            List<BucketInfo> buckets = clusterService.listBuckets();
            result.setBucketCount(buckets.size());
            
            // 3. 检查磁盘空间
            DiskUsage diskUsage = checkDiskUsage();
            result.setDiskUsage(diskUsage);
            
            // 4. 检查网络连接
            NetworkStatus networkStatus = checkNetworkStatus();
            result.setNetworkStatus(networkStatus);
            
            // 5. 综合健康状态
            boolean overallHealthy = clusterStatus.isClusterHealthy() 
                && diskUsage.getUsagePercent() < 90 
                && networkStatus.isHealthy();
            result.setOverallHealthy(overallHealthy);
            
            log.info("集群健康检查完成: overallHealthy={}", overallHealthy);
            
            return result;
            
        } catch (Exception e) {
            log.error("执行健康检查失败", e);
            return HealthCheckResult.builder()
                .overallHealthy(false)
                .errorMessage(e.getMessage())
                .checkTime(LocalDateTime.now())
                .build();
        }
    }
    
    /**
     * 检查磁盘使用情况
     * @return 磁盘使用情况
     */
    private DiskUsage checkDiskUsage() {
        try {
            // 这里可以实现具体的磁盘使用情况检查逻辑
            // 例如：通过SSH连接到各个节点检查磁盘使用情况
            
            DiskUsage usage = new DiskUsage();
            usage.setTotalSpace(1000L * 1024 * 1024 * 1024); // 1TB
            usage.setUsedSpace(500L * 1024 * 1024 * 1024);    // 500GB
            usage.setAvailableSpace(500L * 1024 * 1024 * 1024); // 500GB
            usage.setUsagePercent(50.0);
            
            return usage;
            
        } catch (Exception e) {
            log.error("检查磁盘使用情况失败", e);
            return DiskUsage.builder()
                .usagePercent(100.0)
                .build();
        }
    }
    
    /**
     * 检查网络状态
     * @return 网络状态
     */
    private NetworkStatus checkNetworkStatus() {
        try {
            NetworkStatus status = new NetworkStatus();
            status.setHealthy(true);
            
            // 检查节点间网络连接
            for (String node : deploymentProperties.getNodes()) {
                boolean reachable = checkNodeReachability(node);
                if (!reachable) {
                    status.setHealthy(false);
                    status.addUnreachableNode(node);
                }
            }
            
            return status;
            
        } catch (Exception e) {
            log.error("检查网络状态失败", e);
            return NetworkStatus.builder()
                .healthy(false)
                .errorMessage(e.getMessage())
                .build();
        }
    }
    
    /**
     * 检查节点可达性
     * @param node 节点
     * @return 是否可达
     */
    private boolean checkNodeReachability(String node) {
        try {
            String[] parts = node.split(":");
            String host = parts[0];
            int port = Integer.parseInt(parts[1]);
            
            Socket socket = new Socket();
            socket.connect(new InetSocketAddress(host, port), 5000);
            socket.close();
            
            return true;
            
        } catch (Exception e) {
            log.warn("节点不可达: node={}", node);
            return false;
        }
    }
    
    /**
     * 执行备份
     * @param bucketName 存储桶名称
     * @param backupPath 备份路径
     * @return 备份结果
     */
    public BackupResult performBackup(String bucketName, String backupPath) {
        try {
            log.info("开始执行备份: bucketName={}, backupPath={}", bucketName, backupPath);
            
            // 1. 检查存储桶是否存在
            List<BucketInfo> buckets = clusterService.listBuckets();
            boolean bucketExists = buckets.stream()
                .anyMatch(bucket -> bucket.getName().equals(bucketName));
            
            if (!bucketExists) {
                return BackupResult.error("存储桶不存在: " + bucketName);
            }
            
            // 2. 创建备份目录
            Path backupDir = Paths.get(backupPath);
            Files.createDirectories(backupDir);
            
            // 3. 执行备份逻辑
            // 这里可以实现具体的备份逻辑
            // 例如：使用MinIO客户端下载所有对象到本地
            
            BackupResult result = BackupResult.builder()
                .success(true)
                .bucketName(bucketName)
                .backupPath(backupPath)
                .backupTime(LocalDateTime.now())
                .message("备份完成")
                .build();
            
            log.info("备份执行完成: bucketName={}", bucketName);
            
            return result;
            
        } catch (Exception e) {
            log.error("执行备份失败: bucketName={}", bucketName, e);
            return BackupResult.error("备份失败: " + e.getMessage());
        }
    }
    
    /**
     * 执行恢复
     * @param bucketName 存储桶名称
     * @param backupPath 备份路径
     * @return 恢复结果
     */
    public RestoreResult performRestore(String bucketName, String backupPath) {
        try {
            log.info("开始执行恢复: bucketName={}, backupPath={}", bucketName, backupPath);
            
            // 1. 检查备份路径是否存在
            Path backupDir = Paths.get(backupPath);
            if (!Files.exists(backupDir)) {
                return RestoreResult.error("备份路径不存在: " + backupPath);
            }
            
            // 2. 创建存储桶（如果不存在）
            BucketCreateResult createResult = clusterService.createBucket(bucketName);
            if (!createResult.isSuccess() && !createResult.getMessage().contains("已存在")) {
                return RestoreResult.error("创建存储桶失败: " + createResult.getMessage());
            }
            
            // 3. 执行恢复逻辑
            // 这里可以实现具体的恢复逻辑
            // 例如：将备份文件上传到MinIO存储桶
            
            RestoreResult result = RestoreResult.builder()
                .success(true)
                .bucketName(bucketName)
                .backupPath(backupPath)
                .restoreTime(LocalDateTime.now())
                .message("恢复完成")
                .build();
            
            log.info("恢复执行完成: bucketName={}", bucketName);
            
            return result;
            
        } catch (Exception e) {
            log.error("执行恢复失败: bucketName={}", bucketName, e);
            return RestoreResult.error("恢复失败: " + e.getMessage());
        }
    }
}

/**
 * 集群信息
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ClusterInfo {
    private String mode;
    private int totalNodes;
    private int healthyNodes;
    private boolean clusterHealthy;
    private List<NodeStatus> nodeStatuses;
    private List<BucketInfo> buckets;
    private LocalDateTime checkTime;
    private String errorMessage;
}

/**
 * 健康检查结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class HealthCheckResult {
    private boolean overallHealthy;
    private boolean clusterHealthy;
    private int healthyNodes;
    private int totalNodes;
    private int bucketCount;
    private DiskUsage diskUsage;
    private NetworkStatus networkStatus;
    private LocalDateTime checkTime;
    private String errorMessage;
}

/**
 * 磁盘使用情况
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DiskUsage {
    private long totalSpace;
    private long usedSpace;
    private long availableSpace;
    private double usagePercent;
}

/**
 * 网络状态
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class NetworkStatus {
    private boolean healthy;
    private List<String> unreachableNodes = new ArrayList<>();
    private String errorMessage;
    
    public void addUnreachableNode(String node) {
        unreachableNodes.add(node);
    }
}

/**
 * 备份结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BackupResult {
    private boolean success;
    private String bucketName;
    private String backupPath;
    private LocalDateTime backupTime;
    private String message;
    
    public static BackupResult error(String message) {
        return BackupResult.builder()
            .success(false)
            .message(message)
            .backupTime(LocalDateTime.now())
            .build();
    }
}

/**
 * 恢复结果
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RestoreResult {
    private boolean success;
    private String bucketName;
    private String backupPath;
    private LocalDateTime restoreTime;
    private String message;
    
    public static RestoreResult error(String message) {
        return RestoreResult.builder()
            .success(false)
            .message(message)
            .restoreTime(LocalDateTime.now())
            .build();
    }
}

/**
 * MinIO运维管理控制器
 */
@RestController
@RequestMapping("/api/minio")
public class MinIOOperationController {
    
    @Autowired
    private MinIOOperationService operationService;
    
    @Autowired
    private MinIOClusterService clusterService;
    
    /**
     * 获取集群信息
     */
    @GetMapping("/cluster/info")
    public ResponseEntity<ClusterInfo> getClusterInfo() {
        try {
            ClusterInfo info = operationService.getClusterInfo();
            return ResponseEntity.ok(info);
            
        } catch (Exception e) {
            log.error("获取集群信息失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 执行健康检查
     */
    @PostMapping("/health/check")
    public ResponseEntity<HealthCheckResult> performHealthCheck() {
        try {
            HealthCheckResult result = operationService.performHealthCheck();
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("执行健康检查失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 创建存储桶
     */
    @PostMapping("/bucket/create")
    public ResponseEntity<BucketCreateResult> createBucket(@RequestParam String bucketName) {
        try {
            BucketCreateResult result = clusterService.createBucket(bucketName);
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("创建存储桶失败: bucketName={}", bucketName, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 删除存储桶
     */
    @DeleteMapping("/bucket/{bucketName}")
    public ResponseEntity<BucketDeleteResult> deleteBucket(@PathVariable String bucketName) {
        try {
            BucketDeleteResult result = clusterService.deleteBucket(bucketName);
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("删除存储桶失败: bucketName={}", bucketName, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 获取存储桶列表
     */
    @GetMapping("/bucket/list")
    public ResponseEntity<List<BucketInfo>> listBuckets() {
        try {
            List<BucketInfo> buckets = clusterService.listBuckets();
            return ResponseEntity.ok(buckets);
            
        } catch (Exception e) {
            log.error("获取存储桶列表失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 执行备份
     */
    @PostMapping("/backup")
    public ResponseEntity<BackupResult> performBackup(
            @RequestParam String bucketName,
            @RequestParam String backupPath) {
        
        try {
            BackupResult result = operationService.performBackup(bucketName, backupPath);
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("执行备份失败: bucketName={}, backupPath={}", bucketName, backupPath, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
    
    /**
     * 执行恢复
     */
    @PostMapping("/restore")
    public ResponseEntity<RestoreResult> performRestore(
            @RequestParam String bucketName,
            @RequestParam String backupPath) {
        
        try {
            RestoreResult result = operationService.performRestore(bucketName, backupPath);
            return ResponseEntity.ok(result);
            
        } catch (Exception e) {
            log.error("执行恢复失败: bucketName={}, backupPath={}", bucketName, backupPath, e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
}