feat(deploy): 支持 RustFS TLS 证书自动部署与服务重载

- 新增配置项 rustFSPath，用于指定 RustFS TLS 证书目录
- 实现证书下载后自动部署到 RustFS 目录，自动命名证书和密钥文件
- 支持同时向 Nginx、Apache 和 RustFS 部署证书并自动重载相关服务
- 更新配置结构体及验证逻辑，兼容旧配置并支持新目录创建
- 使用统一的 Getter 方法访问各云服务认证字段，优化代码结构
- 在客户端实现 RustFS 证书部署业务处理逻辑与相应测试用例修改
- 更新 README 文档，新增说明支持 Apache 和 RustFS 自动部署和服务重载
- 修改 protobuf 协议，新增 RustFS 证书部署业务类型支持

Author: orange-juzipi

.gitignore

@@ -31,6 +31,7 @@ go.work.sum
 # .idea/
 # .vscode/
 
+.claude
 bin
 anssl
 certs

README.md

@@ -4,7 +4,7 @@
 
 ## 特性
 
-- 🚀 自动化部署证书并重载 Nginx
+- 🚀 自动化部署证书到 Nginx、Apache、RustFS 并自动重载服务
 - ✅ 内置 HTTP-01 验证服务，自动响应 ACME challenge
 - ☁️ 支持自动上传证书到云服务（阿里云、七牛云）
 - 🔧 守护进程模式，支持后台运行
@@ -36,24 +36,41 @@ server:
   port: 19000
 
 ssl:
-  # 证书存储目录（留空则使用 ./certs）
-  path: "/etc/nginx/ssl"
+  # Nginx 证书目录（可选）
+  nginxPath: "/etc/nginx/ssl"
+  # Apache 证书目录（可选）
+  apachePath: "/etc/apache2/ssl"
+  # RustFS TLS 证书目录（可选）
+  rustFSPath: "/etc/rustfs/tls"
 
 # 云服务配置（可选）
 provider:
   - name: "aliyun"
-    accessKeyId: "your_key"
-    accessKeySecret: "your_secret"
+    remark: "阿里云"
+    auth:
+      accessKeyId: "your-aliyun-access-key-id"
+      accessKeySecret: "your-aliyun-access-key-secret"
+
+  - name: "qiniu"
+    remark: "七牛云"
+    auth:
+      accessKey: "your-qiniu-access-key"
+      accessSecret: "your-qiniu-access-secret"
+
+  - name: "cloudTencent"
+    remark: "腾讯云"
+    auth:
+      secretId: "your-tencent-secret-id"
+      secretKey: "your-tencent-secret-key"
 ```
-> #### 已支持的CDN服务商
-> 关于`provider:`的`- name:`的值请看下表：
-
-| 配置项参数 | 英文 | 说明 |
-|:--------:|:------:|:------:|
-| `name` | `aliyun` | 阿里云 |
-| `name` | `qiniu` | 七牛云 |
-| `name` | 更多 | 敬请期待 |
 
+> #### 已支持的云服务商
+>
+> | 服务商 |    name 值     |           认证字段           |
+> | :----: | :------------: | :--------------------------: |
+> | 阿里云 |    `aliyun`    | accessKeyId, accessKeySecret |
+> | 七牛云 |    `qiniu`     |   accessKey, accessSecret    |
+> | 腾讯云 | `cloudTencent` |     secretId, secretKey      |
 
 ### 3. 配置 Nginx
 
@@ -92,8 +109,8 @@ sudo ./anssl daemon -c config.yaml
 2. 后端推送 ACME challenge token 到 CLI
 3. CLI 自动缓存并响应 Let's Encrypt 验证请求
 4. 验证成功，证书签发
-5. 自动下载并部署证书
-6. 自动重载 Nginx
+5. 自动下载并部署证书到配置的服务（Nginx/Apache/RustFS）
+6. 自动重载 Nginx 和 Apache 服务
 
 **全程自动化，无需手动操作。**
 
@@ -117,12 +134,14 @@ sudo ./anssl daemon -c config.yaml
 
 ## 配置说明
 
-| 配置项 | 必填 | 说明 |
-|--------|------|------|
-| `server.accessKey` | ✅ | 从 anssl.cn 获取的访问密钥 |
-| `server.port` | ❌ | HTTP-01 验证端口，默认 19000 |
-| `ssl.path` | ❌ | 证书存储目录，默认 `./certs` |
-| `provider` | ❌ | 云服务配置（阿里云/七牛云） |
+| 配置项             | 必填 | 说明                                         |
+| ------------------ | ---- | -------------------------------------------- |
+| `server.accessKey` | ✅   | 从 anssl.cn 获取的访问密钥                   |
+| `server.port`      | ❌   | HTTP-01 验证端口，默认 19000                 |
+| `ssl.nginxPath`    | ❌   | Nginx 证书目录，配置后自动部署并重载 Nginx   |
+| `ssl.apachePath`   | ❌   | Apache 证书目录，配置后自动部署并重载 Apache |
+| `ssl.rustFSPath`   | ❌   | RustFS TLS 证书目录，配置后自动部署证书      |
+| `provider`         | ❌   | 云服务配置（阿里云/七牛云）                  |
 
 ## 故障排除
 
@@ -184,10 +203,13 @@ sudo systemctl start anssl
 A: 登录 [anssl.cn](https://anssl.cn) → 设置 → 个人资料
 
 **Q: 支持哪些 Web 服务器？**
-A: 目前仅支持 Nginx 自动重载，其他服务器可使用本工具下载证书后手动配置
+A: 支持 Nginx、Apache 和 RustFS TLS 自动部署。只需在 `config.yaml` 中配置对应的证书目录，即可实现自动部署和服务重载（Nginx 和 Apache）
+
+**Q: 可以同时部署到多个服务吗？**
+A: 可以。在 `config.yaml` 中同时配置 `nginxPath`、`apachePath` 和 `rustFSPath`，证书更新时会自动部署到所有配置的服务
 
 **Q: 证书会同时部署到本地和云服务吗？**
-A: 不会。如果配置了云服务，会优先上传到云服务；否则部署到本地
+A: 在 [anssl.cn](https://anssl.cn) 控制台配置部署目标时，可以选择部署到本地 CLI（Nginx/Apache/RustFS）或云服务（阿里云/七牛云）。每个证书可以配置多个部署目标，实现同时部署
 
 **Q: HTTP-01 验证需要手动操作吗？**
 A: 不需要。配置好 Nginx 反向代理后，验证全程自动完成

internal/client/cert_deploy.go

@@ -72,8 +72,9 @@ func (cd *CertDeployer) DeployCertificate(domain, url string) error {
 	sslConfig := config.GetConfig().SSL
 	nginxPath := sslConfig.NginxPath
 	apachePath := sslConfig.ApachePath
+	rustFSPath := sslConfig.RustFSPath
 
-	if nginxPath == "" && apachePath == "" {
+	if nginxPath == "" && apachePath == "" && rustFSPath == "" {
 		logger.Info("未配置SSL目录，证书已下载", "file", zipFile)
 		return nil
 	}
@@ -106,7 +107,14 @@ func (cd *CertDeployer) DeployCertificate(domain, url string) error {
 		}
 	}
 
-	// 4. 检查nginx是否存在，如果存在则测试配置和重新加载
+	// 4. 部署到 RustFS 目录
+	if rustFSPath != "" {
+		if err := cd.deployToRustFS(extractDir, rustFSPath, safeDomain); err != nil {
+			return fmt.Errorf("部署到RustFS失败: %w", err)
+		}
+	}
+
+	// 5. 检查nginx是否存在，如果存在则测试配置和重新加载
 	if nginxPath != "" && cd.isNginxAvailable() {
 		// 测试nginx配置
 		if err := cd.testNginxConfig(); err != nil {
@@ -121,7 +129,7 @@ func (cd *CertDeployer) DeployCertificate(domain, url string) error {
 		logger.Info("nginx未安装或不在PATH中，跳过nginx相关操作")
 	}
 
-	// 5. 检查apache是否存在，如果存在则测试配置和重新加载
+	// 6. 检查apache是否存在，如果存在则测试配置和重新加载
 	if apachePath != "" && cd.isApacheAvailable() {
 		// 测试apache配置
 		if err := cd.testApacheConfig(); err != nil {
@@ -266,6 +274,55 @@ func (cd *CertDeployer) DeployCertificateToApache(domain, url string) error {
 	return nil
 }
 
+// DeployCertificateToRustFS 仅部署证书到 RustFS
+func (cd *CertDeployer) DeployCertificateToRustFS(domain, url string) error {
+	sslConfig := config.GetConfig().SSL
+	rustFSPath := sslConfig.RustFSPath
+
+	if rustFSPath == "" {
+		return fmt.Errorf("未配置 RustFS TLS 目录 (ssl.rustFSPath)")
+	}
+
+	// 创建certs目录
+	if err := os.MkdirAll(certsDir, 0755); err != nil {
+		return fmt.Errorf("创建证书目录失败: %w", err)
+	}
+
+	safeDomain := sanitizeDomain(domain)
+	fileName := fmt.Sprintf("%s_certificates.zip", safeDomain)
+	zipFile := filepath.Join(certsDir, fileName)
+
+	// 下载zip文件
+	if err := cd.client.downloadFile(url, zipFile); err != nil {
+		return fmt.Errorf("下载证书失败: %w", err)
+	}
+
+	logger.Info("证书下载完成", "file", zipFile)
+
+	defer func() {
+		if _, err := os.Stat(zipFile); err == nil {
+			os.Remove(zipFile)
+		}
+	}()
+
+	folderName := safeDomain + "_certificates"
+	extractDir := filepath.Join(certsDir, folderName)
+
+	if err := cd.extractZip(zipFile, extractDir); err != nil {
+		os.RemoveAll(extractDir)
+		return fmt.Errorf("解压证书失败: %w", err)
+	}
+	defer os.RemoveAll(extractDir)
+
+	// 部署到 RustFS 目录
+	if err := cd.deployToRustFS(extractDir, rustFSPath, safeDomain); err != nil {
+		return fmt.Errorf("部署到RustFS失败: %w", err)
+	}
+
+	logger.Info("RustFS证书部署完成", "domain", domain)
+	return nil
+}
+
 // deployToNginx 部署证书到 Nginx 目录并生成配置文件
 func (cd *CertDeployer) deployToNginx(sourceDir, nginxPath, folderName, safeDomain string) error {
 	// 移动证书文件
@@ -308,6 +365,43 @@ func (cd *CertDeployer) deployToApache(sourceDir, apachePath, folderName, safeDo
 	return nil
 }
 
+// deployToRustFS 部署证书到 RustFS 目录
+func (cd *CertDeployer) deployToRustFS(sourceDir, rustFSPath, safeDomain string) error {
+	// RustFS 目标目录（使用域名作为子目录）
+	targetDir := filepath.Join(rustFSPath, safeDomain)
+
+	// 如果目标目录已存在，先删除
+	if _, err := os.Stat(targetDir); err == nil {
+		if err := os.RemoveAll(targetDir); err != nil {
+			return fmt.Errorf("删除现有RustFS证书目录失败: %w", err)
+		}
+	}
+
+	// 创建目标目录
+	if err := os.MkdirAll(targetDir, 0755); err != nil {
+		return fmt.Errorf("创建RustFS证书目录失败: %w", err)
+	}
+
+	// 复制并重命名证书文件
+	// cert.pem -> rustfs_cert.pem
+	srcCert := filepath.Join(sourceDir, "cert.pem")
+	dstCert := filepath.Join(targetDir, "rustfs_cert.pem")
+	if err := copyFileWithMode(srcCert, dstCert, 0644); err != nil {
+		return fmt.Errorf("复制证书文件失败: %w", err)
+	}
+
+	// 复制并重命名私钥文件
+	// privateKey.key -> rustfs_key.pem
+	srcKey := filepath.Join(sourceDir, "privateKey.key")
+	dstKey := filepath.Join(targetDir, "rustfs_key.pem")
+	if err := copyFileWithMode(srcKey, dstKey, 0600); err != nil {
+		return fmt.Errorf("复制私钥文件失败: %w", err)
+	}
+
+	logger.Info("证书已部署到RustFS目录", "path", targetDir, "cert", "rustfs_cert.pem", "key", "rustfs_key.pem")
+	return nil
+}
+
 // generateNginxSSLConfig 生成 Nginx SSL 配置文件
 func (cd *CertDeployer) generateNginxSSLConfig(nginxPath, folderName, safeDomain string) error {
 	certDir := filepath.Join(nginxPath, folderName)

internal/client/connect.go

@@ -30,7 +30,7 @@ func (c *Client) handleConnect(stream *connect.BidiStreamForClientSimple[deployP
 			break
 		}
 
-		provider, err := aliyun.New(providerConfig.AccessKeyId, providerConfig.AccessKeySecret)
+		provider, err := aliyun.New(providerConfig.GetAccessKeyId(), providerConfig.GetAccessKeySecret())
 		if err != nil {
 			return err
 		}
@@ -49,7 +49,7 @@ func (c *Client) handleConnect(stream *connect.BidiStreamForClientSimple[deployP
 			break
 		}
 
-		provider := qiniu.New(providerConfig.AccessKey, providerConfig.AccessSecret)
+		provider := qiniu.New(providerConfig.GetAccessKey(), providerConfig.GetAccessSecret())
 
 		success, err = provider.TestConnection()
 		if err != nil {

internal/client/execute_busines.go

@@ -49,6 +49,9 @@ func (c *Client) executeBusines(stream *connect.BidiStreamForClientSimple[deploy
 		case deployPB.ExecuteBusinesType_EXECUTE_BUSINES_ANSSL_CLI_APACHE_CERT:
 			// 部署证书到本地 apache
 			result = c.handleApacheCertificateDeploy(domain, downloadURL)
+		case deployPB.ExecuteBusinesType_EXECUTE_BUSINES_ANSSL_CLI_RUSTFS_CERT:
+			// 部署证书到本地 RustFS
+			result = c.handleRustFSCertificateDeploy(domain, downloadURL)
 		default:
 			result = deployPB.ExecuteBusinesRequest_REQUEST_RESULT_NOT_SUPPORTED
 			logger.Warn("不支持的业务类型", "executeBusinesType", executeBusinesType)
@@ -100,6 +103,23 @@ func (c *Client) handleApacheCertificateDeploy(domain, downloadURL string) deplo
 	return deployPB.ExecuteBusinesRequest_REQUEST_RESULT_SUCCESS
 }
 
+// handleRustFSCertificateDeploy 处理证书部署到本地 RustFS
+func (c *Client) handleRustFSCertificateDeploy(domain, downloadURL string) deployPB.ExecuteBusinesRequest_RequestResult {
+	if domain == "" {
+		logger.Error("域名不能为空")
+		return deployPB.ExecuteBusinesRequest_REQUEST_RESULT_FAILED
+	}
+
+	deployer := NewCertDeployer(c)
+	if err := deployer.DeployCertificateToRustFS(domain, downloadURL); err != nil {
+		logger.Error("RustFS证书部署失败", "error", err, "domain", domain)
+		return deployPB.ExecuteBusinesRequest_REQUEST_RESULT_FAILED
+	}
+
+	logger.Info("RustFS 证书部署成功", "domain", domain)
+	return deployPB.ExecuteBusinesRequest_REQUEST_RESULT_SUCCESS
+}
+
 // handleCertificateProvider 处理证书提供商的上传操作
 func (c *Client) handleCertificateProvider(providerName string, executeBusinesType deployPB.ExecuteBusinesType, remark, cert, key string) deployPB.ExecuteBusinesRequest_RequestResult {
 	// 只支持上传证书操作
@@ -133,16 +153,20 @@ func (c *Client) getProviderHandler(providerName string) (providers.ProviderHand
 
 	switch providerName {
 	case "aliyun":
-		if providerConfig.AccessKeyId == "" || providerConfig.AccessKeySecret == "" {
+		accessKeyId := providerConfig.GetAccessKeyId()
+		accessKeySecret := providerConfig.GetAccessKeySecret()
+		if accessKeyId == "" || accessKeySecret == "" {
 			return nil, fmt.Errorf("阿里云配置不完整: accessKeyId 或 accessKeySecret 为空")
 		}
-		return aliyun.New(providerConfig.AccessKeyId, providerConfig.AccessKeySecret)
+		return aliyun.New(accessKeyId, accessKeySecret)
 
 	case "qiniu":
-		if providerConfig.AccessKey == "" || providerConfig.AccessSecret == "" {
+		accessKey := providerConfig.GetAccessKey()
+		accessSecret := providerConfig.GetAccessSecret()
+		if accessKey == "" || accessSecret == "" {
 			return nil, fmt.Errorf("七牛云配置不完整: accessKey 或 accessSecret 为空")
 		}
-		return qiniu.New(providerConfig.AccessKey, providerConfig.AccessSecret), nil
+		return qiniu.New(accessKey, accessSecret), nil
 
 	default:
 		return nil, fmt.Errorf("不支持的提供商: %s", providerName)

internal/client/providers/aliyun/aliyun_test.go

@@ -21,9 +21,11 @@ func TestMain(m *testing.M) {
 
 	for _, p := range cfg.Provider {
 		if p.Name == "aliyun" {
-			logger.Info("测试提供商上传证书", "provider", p.Name, "accessKeyId", p.AccessKeyId, "accessKeySecret", p.AccessKeySecret)
+			accessKeyId := p.GetAccessKeyId()
+			accessKeySecret := p.GetAccessKeySecret()
+			logger.Info("测试提供商上传证书", "provider", p.Name, "accessKeyId", accessKeyId, "accessKeySecret", accessKeySecret)
 			// 创建实例
-			provider, err = aliyun.New(p.AccessKeyId, p.AccessKeySecret)
+			provider, err = aliyun.New(accessKeyId, accessKeySecret)
 			if err != nil {
 				logger.Error("创建提供商实例失败", "error", err)
 				return

internal/client/providers/qiniu/qiniu_test.go

@@ -18,9 +18,11 @@ func TestMain(m *testing.M) {
 
 	for _, p := range cfg.Provider {
 		if p.Name == "qiniu" {
-			logger.Info("测试提供商上传证书", "provider", p.Name, "accessKey", p.AccessKey, "accessSecret", p.AccessSecret)
+			accessKey := p.GetAccessKey()
+			accessSecret := p.GetAccessSecret()
+			logger.Info("测试提供商上传证书", "provider", p.Name, "accessKey", accessKey, "accessSecret", accessSecret)
 			// 创建实例
-			provider = qiniu.New(p.AccessKey, p.AccessSecret)
+			provider = qiniu.New(accessKey, accessSecret)
 		}
 	}