基于 GitHub Actions 为 Whisper-large-v3 语音识别服务搭建持续集成与灰度发布系统的方案。通过自动化工作流实现代码提交后的自动测试，包括单元测试、集成测试及性能测试。采用版本管理器支持多模型共存，结合流量分配策略实现平滑的模型灰度发布与回滚。此外，还包含服务健康监控与性能指标收集机制，确保系统稳定性与服务质量。该方案帮助开发者减少手动测试时间，运维人员可控可回退更新流程，最终提升用户服务体验。
语音识别服务上线后，最头疼的问题是什么？是每次更新代码后，需要手动测试十几个音频样本，还是担心新模型版本上线会搞砸已有的稳定服务？如果你也遇到过这些问题，那么今天分享的这套自动化方案，或许能帮你省下不少时间。
Whisper-large-v3 语音识别服务，支持 99 种语言的自动检测与转录，已经成为了很多开发者和团队的工具。但如何确保每次代码提交、每次模型更新都能稳定运行，同时又能平滑地让用户体验新版本，这需要一套可靠的工程化流程。
本文将带你搭建一套完整的持续集成与灰度发布系统，用 GitHub Actions 实现自动测试，用巧妙的版本管理实现模型灰度发布。即使你不是 DevOps 专家，也能跟着步骤一步步实现。
我们先快速回顾一下 Whisper-large-v3 项目的核心架构：
/root/Whisper-large-v3/
├── app.py # Web 服务主程序（Gradio 界面）
├── requirements.txt # Python 依赖
├── configuration.json # 模型配置
├── config.yaml # Whisper 参数配置
└── example/ # 测试音频样本
这个服务基于 OpenAI Whisper Large v3 模型（1.5B 参数），使用 Gradio 构建 Web 界面，支持音频文件上传和实时录音，能够自动检测 99 种语言并进行转录或翻译。
在没有自动化之前，每次更新都会遇到这些问题：
我们要实现的自动化系统包含两个核心部分：
这样做的直接好处是：开发更放心、上线更平滑、问题发现更及时。
在项目根目录创建 .github/workflows/test.yml 文件，这是 GitHub Actions 的配置文件：
name: Whisper Model CI/CD
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
test:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: [3.9, 3.10]
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v4
with:
python-version: ${{ matrix.python-version }}
- name: Install system dependencies
run: |
sudo apt-get update
sudo apt-get install -y ffmpeg
- name: Install Python dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
pip install pytest pytest-asyncio
- name: Run unit tests
run: |
python -m pytest tests/unit/ -v
- name: Run integration tests
run: |
python -m pytest tests/integration/ -v
env:
TEST_MODE: "true"
- name: Upload test results
if: always()
uses: actions/upload-artifact@v3
with:
name: test-results-${{ matrix.python-version }}
path: test-reports/
这个配置做了几件事：在代码推送到 main 或 develop 分支时触发，在 Ubuntu 系统上运行，测试 Python 3.9 和 3.10 两个版本，安装必要的系统依赖和 Python 包，然后运行单元测试和集成测试。
测试用例是自动化的核心。我们创建 tests/ 目录，里面包含不同类型的测试：
# tests/unit/test_audio_processing.py
import pytest
from app import AudioProcessor
class TestAudioProcessor:
def test_audio_format_support(self):
"""测试支持的音频格式"""
processor = AudioProcessor()
supported_formats = processor.get_supported_formats()
assert 'wav' in supported_formats
assert 'mp3' in supported_formats
assert 'm4a' in supported_formats
def test_audio_duration_calculation(self):
"""测试音频时长计算"""
processor = AudioProcessor()
# 使用测试音频文件
duration = processor.get_audio_duration('tests/data/sample.wav')
assert duration > 0
assert duration < 60 # 测试音频应小于 60 秒
# tests/integration/test_model_inference.py
class TestModelInference:
@pytest.fixture
def model(self):
"""测试用的轻量级模型"""
# 在测试中使用 small 模型，避免下载大模型
from app import load_test_model
return load_test_model('small')
def test_transcribe_english(self, model):
"""测试英文转录"""
result = model.transcribe('tests/data/english_sample.wav', language='en')
assert 'text' in result
assert len(result['text']) > 0
# 检查转录结果包含预期关键词
assert 'hello' in result['text'].lower() or 'test' in result['text'].lower()
def test_language_detection(self, model):
"""测试语言检测"""
result = model.detect_language('tests/data/multilingual_sample.wav')
assert 'language' in result
assert result['confidence'] > 0.5
除了功能测试，我们还需要性能测试来确保服务质量：
# tests/performance/test_response_time.py
import time
import pytest
class TestPerformance:
def test_transcription_response_time(self):
"""测试转录响应时间应在合理范围内"""
from app import transcribe_audio
start_time = time.time()
result = transcribe_audio('tests/data/short_sample.wav')
end_time = time.time()
response_time = end_time - start_time
# 短音频（<30 秒）应在 10 秒内完成
assert response_time < 10.0
assert result['success'] is True
def test_concurrent_requests(self):
"""测试并发请求处理能力"""
import concurrent.futures
from app import transcribe_audio
test_files = ['tests/data/sample1.wav', 'tests/data/sample2.wav']
start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
futures = [executor.submit(transcribe_audio, file) for file in test_files]
results = [future.result() for future in concurrent.futures.as_completed(futures)]
end_time = time.time()
total_time = end_time - start_time
# 两个并发请求的总时间应小于串行时间的 1.5 倍
assert total_time < 15.0
assert all(r['success'] for r in results)
为了测试，我们需要一些测试音频文件。创建 tests/data/ 目录，并准备不同场景的测试音频：
tests/data/
├── short_sample.wav # 短音频，5 秒，用于快速测试
├── english_sample.wav # 英文音频，测试基本功能
├── chinese_sample.wav # 中文音频，测试中文识别
├── multilingual_sample.wav # 多语言混合音频
├── noisy_sample.wav # 带背景噪音的音频
└── long_sample.wav # 长音频，测试内存管理
这些测试文件应该足够小（几秒到几十秒），避免测试过程过长。
传统的做法是直接替换模型文件，但这样无法回退。我们改为版本化存储：
# model_version_manager.py
import os
import json
import shutil
from datetime import datetime
class ModelVersionManager:
def __init__(self, model_dir='/root/.cache/whisper/versions/'):
self.model_dir = model_dir
os.makedirs(model_dir, exist_ok=True)
# 版本元数据文件
self.metadata_file = os.path.join(self.model_dir, 'versions.json')
self.load_metadata()
def load_metadata(self):
"""加载版本元数据"""
if os.path.exists(self.metadata_file):
with open(self.metadata_file, 'r') as f:
self.versions = json.load(f)
else:
self.versions = {}
def save_metadata(self):
"""保存版本元数据"""
with open(self.metadata_file, 'w') as f:
json.dump(self.versions, f, indent=2)
def add_version(self, model_path, version_name=None, description=''):
"""添加新模型版本"""
if version_name is None:
version_name = f"v{len(self.versions) + 1}"
version_dir = os.path.join(self.model_dir, version_name)
os.makedirs(version_dir, exist_ok=True)
# 复制模型文件到版本目录
if os.path.isdir(model_path):
shutil.copytree(model_path, version_dir, dirs_exist_ok=True)
else:
shutil.copy2(model_path, os.path.join(version_dir, 'model.pt'))
# 记录版本信息
self.versions[version_name] = {
'path': version_dir,
'created_at': datetime.now().isoformat(),
'description': description,
'active': False,
'traffic_percentage': 0
}
self.save_metadata()
return version_name
def activate_version(self, version_name, traffic_percentage=100):
"""激活指定版本并设置流量比例"""
# 先重置所有版本状态
for v in self.versions.values():
v['active'] = False
v['traffic_percentage'] = 0
# 激活指定版本
if version_name in self.versions:
self.versions[version_name]['active'] = True
self.versions[version_name]['traffic_percentage'] = traffic_percentage
self.save_metadata()
return True
return False
def get_active_model_path(self):
"""获取当前活跃模型的路径"""
for version_name, info in self.versions.items():
if info['active']:
return info['path']
return None
def list_versions(self):
"""列出所有版本"""
return self.versions
修改原来的模型加载逻辑，支持按版本加载：
# model_loader.py
import os
import random
from model_version_manager import ModelVersionManager
class MultiVersionModelLoader:
def __init__(self):
self.version_manager = ModelVersionManager()
self.models = {} # 缓存已加载的模型
def load_model(self, version_name=None):
"""加载指定版本的模型，如果不指定则按流量比例随机选择"""
if version_name:
# 加载指定版本
if version_name not in self.models:
model_path = self.version_manager.versions[version_name]['path']
model = self._load_model_from_path(model_path)
self.models[version_name] = model
return self.models[version_name]
else:
# 按流量比例选择版本
active_versions = [
(vname, info) for vname, info in self.version_manager.versions.items()
if info['active'] and info['traffic_percentage'] > 0
]
if not active_versions:
# 没有活跃版本，使用默认
return self.load_model('v1.0')
# 按流量比例随机选择
versions = []
weights = []
for vname, info in active_versions:
versions.append(vname)
weights.append(info['traffic_percentage'])
selected_version = random.choices(versions, weights=weights, k=1)[0]
return self.load_model(selected_version)
def _load_model_from_path(self, model_path):
"""从指定路径加载模型"""
import whisper
if os.path.isdir(model_path):
# 如果是目录，查找模型文件
model_files = [f for f in os.listdir(model_path) if f.endswith('.pt')]
if model_files:
model_file = os.path.join(model_path, model_files[0])
return whisper.load_model(model_file, device="cuda")
# 直接加载 pt 文件
return whisper.load_model(model_path, device="cuda")
def transcribe_with_version(self, audio_path, version_name=None, **kwargs):
"""使用指定版本进行转录"""
model = self.load_model(version_name)
result = model.transcribe(audio_path, **kwargs)
# 添加版本信息到结果
result['model_version'] = version_name or 'auto-selected'
return result
在 Web 服务中添加版本管理 API：
# app.py 中添加
from flask import Flask, request, jsonify
import json
app = Flask(__name__)
model_loader = MultiVersionModelLoader()
@app.route('/api/versions', methods=['GET'])
def list_versions():
"""获取所有模型版本信息"""
versions = model_loader.version_manager.list_versions()
return jsonify({'versions': versions})
@app.route('/api/versions/<version_name>/activate', methods=['POST'])
def activate_version(version_name):
"""激活指定版本"""
data = request.json
traffic_percentage = data.get('traffic_percentage', 100)
success = model_loader.version_manager.activate_version(
version_name, traffic_percentage
)
if success:
return jsonify({
'success': True,
'message': f'Version {version_name} activated with {traffic_percentage}% traffic'
})
else:
return jsonify({
'success': False,
'message': f'Version {version_name} not found'
}), 404
@app.route('/api/transcribe', methods=['POST'])
def transcribe_audio():
"""转录音频，支持指定版本"""
audio_file = request.files.get('audio')
version_name = request.form.get('version')
if not audio_file:
return jsonify({'error': 'No audio file provided'}), 400
# 保存临时文件
temp_path = f"/tmp/{audio_file.filename}"
audio_file.save(temp_path)
try:
# 转录
result = model_loader.transcribe_with_version(
temp_path, version_name=version_name, language=request.form.get('language')
)
# 清理临时文件
os.remove(temp_path)
return jsonify(result)
except Exception as e:
# 清理临时文件
if os.path.exists(temp_path):
os.remove(temp_path)
return jsonify({'error': str(e)}), 500
创建部署工作流文件 .github/workflows/deploy.yml：
name: Deploy Whisper Service
on:
workflow_dispatch: # 手动触发
push:
branches: [ main ]
paths:
- 'app.py'
- 'requirements.txt'
- 'model/**'
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Setup SSH
uses: webfactory/[email protected]
with:
ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }}
- name: Deploy to Server
run: |
ssh -o StrictHostKeyChecking=no ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }} << 'EOF'
cd /root/Whisper-large-v3
git pull origin main
# 备份当前版本
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
cp -r app.py app.py.backup_$TIMESTAMP
# 安装依赖
pip install -r requirements.txt --upgrade
# 重启服务
if pgrep -f "python3 app.py"; then pkill -f "python3 app.py" fi
# 启动新版本
nohup python3 app.py > app.log 2>&1 &
# 等待服务启动
sleep 10
# 健康检查
curl -f http://localhost:7860 || exit 1
echo "Deployment completed successfully"
EOF
- name: Verify Deployment
run: |
sleep 30 # 给服务一些启动时间
curl -f ${{ secrets.SERVER_URL }}/health || exit 1
- name: Notify Success
if: success()
run: |
echo "Deployment successful!"
# 这里可以添加 Slack、钉钉等通知
- name: Rollback on Failure
if: failure()
run: |
ssh -o StrictHostKeyChecking=no ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }} << 'EOF'
cd /root/Whisper-large-v3
# 查找最新的备份文件
LATEST_BACKUP=$(ls -t app.py.backup_* | head -1)
if [ -n "$LATEST_BACKUP" ]; then
# 恢复备份
cp $LATEST_BACKUP app.py
# 重启服务
pkill -f "python3 app.py"
nohup python3 app.py > app.log 2>&1 &
echo "Rollback to backup: $LATEST_BACKUP"
else
echo "No backup found for rollback"
fi
EOF
专门处理模型更新的工作流：
name: Update Whisper Model
on:
schedule:
- cron: '0 2 * * *' # 每天凌晨 2 点检查更新
workflow_dispatch: # 手动触发
jobs:
check-and-update-model:
runs-on: ubuntu-latest
steps:
- name: Check for new model version
id: check
run: |
# 检查 HuggingFace 是否有新版本
LATEST_VERSION=$(curl -s https://huggingface.co/api/models/openai/whisper-large-v3 | jq -r '.siblings[] | select(.rfilename == "pytorch_model.bin") | .lastModified')
CURRENT_VERSION=$(cat model_version.txt 2>/dev/null || echo "")
if [ "$LATEST_VERSION" != "$CURRENT_VERSION" ]; then
echo "New model version available: $LATEST_VERSION"
echo "new_version=true" >> $GITHUB_OUTPUT
echo "version=$LATEST_VERSION" >> $GITHUB_OUTPUT
else
echo "Model is up to date"
echo "new_version=false" >> $GITHUB_OUTPUT
fi
- name: Download new model
if: steps.check.outputs.new_version == 'true'
run: |
# 下载新模型到临时位置
wget -O /tmp/whisper-large-v3-new.pt \
https://huggingface.co/openai/whisper-large-v3/resolve/main/pytorch_model.bin
# 计算文件 hash
MODEL_HASH=$(sha256sum /tmp/whisper-large-v3-new.pt | cut -d' ' -f1)
echo "Downloaded model hash: $MODEL_HASH"
echo "model_hash=$MODEL_HASH" >> $GITHUB_OUTPUT
- name: Test new model
if: steps.check.outputs.new_version == 'true'
run: |
# 使用测试脚本验证新模型
python tests/model_test.py /tmp/whisper-large-v3-new.pt
if [ $? -eq 0 ]; then
echo "model_test_passed=true" >> $GITHUB_OUTPUT
else
echo "model_test_passed=false" >> $GITHUB_OUTPUT
fi
- name: Deploy new model with canary
if: steps.check.outputs.new_version == 'true' && steps.model_test.outputs.model_test_passed == 'true'
run: |
# 部署新模型，先分配 10% 流量
ssh ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }} << 'EOF'
cd /root/Whisper-large-v3
# 添加新版本
python model_version_manager.py add \
--model-path /tmp/whisper-large-v3-new.pt \
--version-name "v$(date +%Y%m%d)" \
--description "Auto-updated on $(date)"
# 激活新版本，分配 10% 流量
python model_version_manager.py activate \
--version "v$(date +%Y%m%d)" \
--traffic 10
# 更新版本记录
echo "${{ steps.check.outputs.version }}" > model_version.txt
echo "New model deployed with 10% traffic"
EOF
- name: Monitor canary performance
if: steps.check.outputs.new_version == 'true' && steps.model_test.outputs.model_test_passed == 'true'
run: |
# 监控新版本性能 24 小时
echo "Starting 24-hour canary monitoring..."
# 这里可以添加详细的监控逻辑
添加健康检查端点：
# monitoring.py
import time
import psutil
import GPUtil
from datetime import datetime
class ServiceMonitor:
def __init__(self):
self.start_time = time.time()
self.request_count = 0
self.error_count = 0
def get_health_status(self):
"""获取服务健康状态"""
status = {
'status': 'healthy',
'timestamp': datetime.now().isoformat(),
'uptime': time.time() - self.start_time,
'requests': self.request_count,
'error_rate': self.error_count / max(self.request_count, 1),
'system': self.get_system_metrics(),
'model': self.get_model_status()
}
# 检查是否健康
if status['error_rate'] > 0.1: # 错误率超过 10%
status['status'] = 'degraded'
if status['system']['memory_percent'] > 90:
status['status'] = 'degraded'
return status
def get_system_metrics(self):
"""获取系统指标"""
memory = psutil.virtual_memory()
gpus = GPUtil.getGPUs()
metrics = {
'cpu_percent': psutil.cpu_percent(interval=1),
'memory_percent': memory.percent,
'memory_used_gb': memory.used / 1024**3,
'gpus': []
}
for gpu in gpus:
metrics['gpus'].append({
'id': gpu.id,
'name': gpu.name,
'load': gpu.load * 100,
'memory_used': gpu.memoryUsed,
'memory_total': gpu.memoryTotal,
'temperature': gpu.temperature
})
return metrics
def get_model_status(self):
"""获取模型状态"""
# 这里可以添加模型特定的监控指标
return {
'loaded_versions': list(model_loader.models.keys()),
'active_traffic': model_loader.version_manager.get_traffic_distribution()
}
def record_request(self, success=True):
"""记录请求"""
self.request_count += 1
if not success:
self.error_count += 1
def should_alert(self):
"""判断是否需要告警"""
status = self.get_health_status()
alerts = []
if status['error_rate'] > 0.2:
alerts.append(f"High error rate: {status['error_rate']:.1%}")
if status['system']['memory_percent'] > 95:
alerts.append(f"High memory usage: {status['system']['memory_percent']}%")
# 检查 GPU 状态
for gpu in status['system']['gpus']:
if gpu['temperature'] > 85:
alerts.append(f"GPU {gpu['id']} temperature high: {gpu['temperature']}°C")
if gpu['memory_used'] / gpu['memory_total'] > 0.95:
alerts.append(f"GPU {gpu['id']} memory almost full")
return alerts
# 在 app.py 中使用
monitor = ServiceMonitor()
@app.route('/health', methods=['GET'])
def health_check():
"""健康检查端点"""
status = monitor.get_health_status()
return jsonify(status)
@app.route('/metrics', methods=['GET'])
def metrics():
"""Prometheus 格式的指标"""
from prometheus_client import generate_latest, Counter, Gauge
# 定义指标
REQUEST_COUNT = Counter('whisper_requests_total', 'Total requests')
ERROR_COUNT = Counter('whisper_errors_total', 'Total errors')
RESPONSE_TIME = Gauge('whisper_response_time_seconds', 'Response time')
GPU_MEMORY = Gauge('gpu_memory_usage_percent', 'GPU memory usage', ['gpu_id'])
# 更新指标值
status = monitor.get_health_status()
REQUEST_COUNT.inc(monitor.request_count)
ERROR_COUNT.inc(monitor.error_count)
for gpu in status['system']['gpus']:
GPU_MEMORY.labels(gpu_id=str(gpu['id'])).set(
gpu['memory_used'] / gpu['memory_total'] * 100
)
return generate_latest(), 200, {'Content-Type': 'text/plain'}
添加性能监控中间件：
# middleware.py
import time
from functools import wraps
def monitor_performance(func):
"""性能监控装饰器"""
@wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
try:
result = func(*args, **kwargs)
elapsed = time.time() - start_time
# 记录成功请求
monitor.record_request(success=True)
# 记录响应时间（如果结果是字典）
if isinstance(result, dict):
result['response_time'] = elapsed
result['model_version'] = getattr(args[0], 'model_version', 'unknown')
# 检查是否需要告警
alerts = monitor.should_alert()
if alerts:
# 这里可以发送告警到 Slack、邮件等
print(f"ALERT: {alerts}")
return result
except Exception as e:
# 记录失败请求
monitor.record_request(success=False)
elapsed = time.time() - start_time
# 重新抛出异常
raise e
return wrapper
# 在转录函数上使用装饰器
@app.route('/api/transcribe', methods=['POST'])
@monitor_performance
def transcribe_audio():
# ... 原有代码 ...
并行测试：
# 在 GitHub Actions 中配置并行测试
test:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: [3.9, 3.10]
test-type: [unit, integration, performance]
steps:
- name: Run ${{ matrix.test-type }} tests
run: |
python -m pytest tests/${{ matrix.test-type }}/ /
测试数据管理：
# 使用工厂模式创建测试数据
class AudioTestFactory:
@staticmethod
def create_english_sample(duration=5):
"""生成英文测试音频"""
# 实现音频生成逻辑
pass
@staticmethod
def create_noisy_sample(clean_audio, noise_level=0.1):
"""添加噪音到音频"""
pass
A/B 测试支持：
def ab_test_transcribe(audio_path, user_id):
"""A/B 测试不同模型版本"""
# 根据用户 ID 哈希决定使用哪个版本
user_hash = hash(user_id) % 100
if user_hash < 10: # 10% 流量使用新版本
version = "v2.0"
else:
version = "v1.0"
return model_loader.transcribe_with_version(audio_path, version)
回滚机制：
def auto_rollback_if_needed():
"""自动回滚检查"""
status = monitor.get_health_status()
if status['error_rate'] > 0.3: # 错误率超过 30%
print("High error rate detected, initiating rollback...")
# 回滚到上一个稳定版本
stable_version = find_stable_version()
model_loader.version_manager.activate_version(stable_version, 100)
# 发送告警
send_alert(f"Auto-rolled back to {stable_version} due to high error rate")
按需加载：
class LazyModelLoader:
def __init__(self):
self.loaded_models = {}
def get_model(self, version):
if version not in self.loaded_models:
# 只有需要时才加载
self.loaded_models[version] = self._load_model(version)
return self.loaded_models[version]
模型缓存优化：
class SmartModelCache:
def __init__(self, max_size_gb=10):
self.max_size = max_size_gb * 1024**3
self.cache = {}
self.access_times = {}
def get_model(self, version):
if version in self.cache:
# 更新时间
self.access_times[version] = time.time()
return self.cache[version]
return None
def cleanup(self):
"""清理最少使用的模型"""
if self.current_size() > self.max_size:
# 找到最久未使用的版本
oldest = min(self.access_times.items(), key=lambda x: x[1])
del self.cache[oldest[0]]
del self.access_times[oldest[0]]
通过 GitHub Actions 自动测试和模型版本灰度发布，我们为 Whisper-large-v3 语音识别服务构建了一套完整的持续集成与部署系统。这套系统带来的好处是实实在在的：
对于开发者来说，每次提交代码都能自动测试，发现问题的时间从小时级缩短到分钟级。不用再手动测试各种音频格式和语言组合，省下的时间可以用来优化模型效果。
对于运维来说，模型更新变得可控可回退。新版本可以先给 10% 的用户使用，观察效果没问题再逐步扩大范围。如果发现问题，可以立即切回稳定版本，用户几乎无感知。
对于用户来说，服务更加稳定可靠。错误率有监控，性能有保障，即使更新也是平滑过渡，不会出现服务中断或者效果大幅波动的情况。
实现这套系统并不复杂，核心就是几个关键点：用 GitHub Actions 自动化测试流程，用版本管理器支持多模型共存，用流量分配实现灰度发布，用监控系统确保服务质量。
你可以从最基本的自动测试开始，先确保每次代码提交都能跑通测试用例。然后逐步添加模型版本管理，最后实现完整的灰度发布流程。每一步都能带来明显的效率提升和质量保障。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online