管道
- 作者仓库星标 0
- 作者仓库 skills-registry
- 领域
- 运维部署
- 作者声明的智能体
- 未找到明确声明;不据此推断已兼容或已测试
- 静态检查
- 88 / 100 · 启发式扫描,不代表运行安全
- 运行环境证据
- 未执行;当前没有隔离运行测试证据
- 作者 / 版本 / 许可证
- @tomevault-io · 未声明许可证
- 上下文用量评级
- 低消耗
- 接入复杂程度
- 需手动接入
- 是否需要外部接口密钥
- 需要 · Vendor-specific
- 兼容的系统
- Linux · Windows · Docker
- 运行环境要求
- Node.js · Docker
- 检测到的文件与系统行为
-
- 只读
- 允许写入 / 修改
- 网络行为
- 允许外网请求
- 安装命令数
- 无(仅作为资料)
需要注意: 未声明工具权限范围;实际权限由运行环境决定。
# CI/CD Pipeline Design: From Commit to Production
## Overview
CI/CD pipelines are the backbone of modern software delivery — the automated assembly line that transforms source code into running software. A well-designed pipeline catches bugs early, enforces quality gates, deploys with confidence, and gives developers fast feedback. This skill covers the full spectrum from GitHub Actions workflow authoring and matrix build strategies to multi-environment deployment patterns, secret management, and pipeline security.
---
## Core Principles
1. **Fast Feedback** — The pipeline must surface failures within minutes. Slow pipelines encourage developers to work around them. Optimize for speed at every stage.
2. **Fail Fast, Fail Early** — Order testing stages from fastest/cheapest to slowest/costliest. Reject a bad commit at the lint stage before running an expensive e2e suite.
3. **Reproducibility** — Pipelines must produce identical results given the same commit. Pin action versions, use lockfiles, and avoid environment drift.
4. **Security by Design** — Secrets must never appear in logs, artifacts, or output. Use short-lived credentials, OIDC, and minimal IAM permissions.
5. **Immutable Deployments** — Build artifacts once, promote them through environments. Never rebuild for staging or production — the artifact that passed tests in staging is the artifact deployed to production.
6. **Self-Service** — Developers should be able to create, modify, and understand pipelines without DevOps intervention. Use reusable workflows and composable actions.
---
## Pipeline Maturity Model
### 🟢 Beginner
- Single monolithic workflow file
- All tests run sequentially on every push
- Hardcoded secrets stored in workflow YAML or plaintext
- Manual deployments via `git push` and SSH
- No environment separation — CI runs in the same context as everything else
- Build artifacts recreated per environment
- No caching — every run downloads dependencies fresh
- Pipeline run time: 20–60 minutes
- No approval gates — pushes go directly to production
**Typical Beginner Workflow:**
```yaml
name: Deploy
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- run: npm install
- run: npm run build
- run: npm test
- run: scp -r dist/ user@server:/var/www/
```
### 🟡 Proficient
- Separate lint, test, build, and deploy jobs
- Matrix builds for multi-version and multi-platform testing
- Dependency caching with `actions/cache` or `setup-node --cache`
- Environments with protection rules (e.g., `production` requires approval)
- OIDC-based cloud authentication (no long-lived secrets)
- Layered testing: lint → unit → integration → e2e
- Build once, deploy to multiple environments
- Pipeline run time: 5–15 minutes
- Automated rollback on failure
**Proficient Structure:**
```yaml
name: CI/CD
on:
push:
branches: [main, develop]
pull_request:
branches: [main]
jobs:
lint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 20
cache: npm
- run: npm ci
- run: npm run lint
test:
needs: lint
strategy:
matrix:
node: [18, 20, 22]
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: ${{ matrix.node }}
cache: npm
- run: npm ci
- run: npm run test:unit
- run: npm run test:integration
build:
needs: test
runs-on: ubuntu-latest
outputs:
image: ${{ steps.docker.outputs.image }}
steps:
- uses: actions/checkout@v4
- run: npm ci && npm run build
- id: docker
run: |
docker build -t app:${{ github.sha }} .
echo "image=app:${{ github.sha }}" >> $GITHUB_OUTPUT
deploy-staging:
needs: build
environment: staging
runs-on: ubuntu-latest
steps:
- run: echo "Deploy ${{ needs.build.outputs.image }} to staging"
deploy-production:
needs: deploy-staging
environment: production
runs-on: ubuntu-latest
steps:
- run: echo "Deploy ${{ needs.build.outputs.image }} to production"
```
### 🔴 Expert
- Reusable workflows called from a central orchestrator
- Dynamic matrix generation based on changed files (monorepo-aware)
- Parallelized test sharding with intelligent test splitting
- BuildKit cache mounts and remote caching (Docker Registry, Buildx)
- Canary deployments with progressive traffic shifting
- Automated rollback with health-check verification
- SBOM generation and vulnerability scanning as quality gates
- SLSA provenance attestation for supply chain security
- Pipeline telemetry dashboards with DORA metrics tracking
- Pipeline run time: 2–8 minutes
- Self-hosted runners with auto-scaling for cost optimization
**Expert Pattern — Reusable Deploy Workflow:**
```yaml
# .github/workflows/deploy.yml — reusable
name: Deploy to Environment
on:
workflow_call:
inputs:
environment:
required: true
type: string
image-tag:
required: true
type: string
secrets:
cloud-role-arn:
required: true
jobs:
deploy:
runs-on: ubuntu-latest
environment: ${{ inputs.environment }}
concurrency: deploy-${{ inputs.environment }}
steps:
- uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ secrets.cloud-role-arn }}
aws-region: us-east-1
- run: |
aws eks update-kubeconfig --name cluster-${{ inputs.environment }}
kubectl set image deployment/app app=${{ inputs.image-tag }}
- run: |
kubectl rollout status deployment/app --timeout=5m
```
**Calling the reusable workflow:**
```yaml
jobs:
deploy-staging:
uses: ./.github/workflows/deploy.yml
with:
environment: staging
image-tag: ${{ needs.build.outputs.image-tag }}
secrets:
cloud-role-arn: ${{ secrets.STAGING_ROLE_ARN }}
```
---
## Actionable Guidance
### 1. GitHub Actions Workflow Design
**Workflow Structure Best Practices:**
- Name workflows clearly: `CI - Lint & Test`, `CD - Deploy Production`
- Use `concurrency` to cancel redundant runs on the same branch
- Pin action versions to full-length SHAs for supply chain security
- Use `actions/checkout` with `fetch-depth: 0` only when needed (default `fetch-depth: 1` is faster)
```yaml
name: CI
on:
pull_request:
branches: [main]
push:
branches: [main]
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
```
**Path Triggers for Monorepos:**
```yaml
on:
push:
paths:
- "services/api/**"
- "packages/shared/**"
- ".github/workflows/api-ci.yml"
```
### 2. Matrix Builds
Matrix builds test across multiple versions, platforms, and configurations simultaneously.
```yaml
strategy:
matrix:
os: [ubuntu-latest, windows-latest]
node: [18, 20, 22]
include:
- os: ubuntu-latest
node: 20
coverage: true
exclude:
- os: windows-latest
node: 18
```
**Dynamic Matrix from Changed Files:**
```yaml
jobs:
detect:
runs-on: ubuntu-latest
outputs:
services: ${{ steps.filter.outputs.changes }}
steps:
- uses: dorny/paths-filter@v3
id: filter
with:
filters: |
api: services/api/**
web: services/web/**
worker: services/worker/**
test:
needs: detect
strategy:
matrix:
service: ${{ fromJson(needs.detect.outputs.services) }}
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: cd services/${{ matrix.service }} && npm ci && npm test
```
### 3. Caching Strategies
**Dependency Caching:**
```yaml
- uses: actions/setup-node@v4
with:
node-version: 20
cache: npm
cache-dependency-path: services/api/package-lock.json
- uses: actions/cache@v4
with:
path: |
~/.cache/pip
.venv
key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
restore-keys: |
${{ runner.os }}-pip-
```
**Docker Layer Caching:**
```yaml
- uses: docker/setup-buildx-action@v3
- uses: docker/build-push-action@v5
with:
cache-from: type=gha
cache-to: type=gha,mode=max
push: true
tags: app:${{ github.sha }}
```
### 4. Testing Stages — The Testing Pyramid
Organize tests from fastest to slowest. The pipeline should fail as early as possible.
| Stage | Tools | Time Budget | Fail Behavior |
|-------|-------|-------------|---------------|
| **Lint** | ESLint, Prettier, Ruff, hadolint | <30s | Immediate block |
| **Type Check** | TypeScript, mypy, Pyright | <1m | Block |
| **Unit Tests** | Vitest, Jest, pytest, Go test | <3m | Block |
| **Integration Tests** | Supertest, Testcontainers, Docker Compose | <5m | Block |
| **Security Scan** | Trivy, Snyk, CodeQL | <3m | Block on critical |
| **E2E Tests** | Playwright, Cypress, Selenium | <15m | Block |
```yaml
jobs:
lint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 20
cache: npm
- run: npm ci
- run: npm run lint
- run: npx tsc --noEmit
unit:
needs: lint
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 20
cache: npm
- run: npm ci
- run: npm run test:unit -- --coverage
- uses: codecov/codecov-action@v4
with:
files: coverage/lcov.info
integration:
needs: unit
runs-on: ubuntu-latest
services:
postgres:
image: postgres:16-alpine
env:
POSTGRES_DB: testdb
POSTGRES_PASSWORD: testpass
options: >-
--health-cmd pg_isready
--health-interval 5s
redis:
image: redis:7-alpine
steps:
- uses: actions/checkout@v4
- run: npm ci && npm run test:integration
e2e:
needs: integration
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: |
docker compose -f compose.ci.yml up -d
npx playwright test
```
### 5. Deployment Environments
Use GitHub Environments to enforce protection rules and track deployments.
```yaml
environment:
name: production
url: https://app.example.com
```
**Configure protection rules in GitHub UI:**
- Required reviewers (1–2 approvers)
- Wait timer (optional)
- Deployment branches restriction (only `main`)
**Environment-Specific Secrets:**
```yaml
jobs:
deploy:
environment: production
runs-on: ubuntu-latest
steps:
- run: deploy.sh
env:
API_KEY: ${{ secrets.PRODUCTION_API_KEY }}
```
### 6. Secret Management
**Bad — Secrets in plaintext:**
```yaml
- run: curl -H "Authorization: Bearer supersecret123"
```
**Good — GitHub Secrets:**
```yaml
- run: deploy.sh
env:
API_KEY: ${{ secrets.API_KEY }}
```
**Best — OIDC Authentication (no static secrets):**
```yaml
- uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: arn:aws:iam::123456:role/github-actions-deploy
aws-region: us-east-1
```
**Secret Detection in CI:**
```yaml
- uses: trufflesecurity/trufflehog@v3
with:
extra-args: --results=verified,failed
```
### 7. Approval Gates
```yaml
jobs:
deploy-staging:
environment: staging
runs-on: ubuntu-latest
steps:
- run: echo "Deploying to staging..."
deploy-production:
needs: deploy-staging
environment:
name: production
runs-on: ubuntu-latest
steps:
- run: echo "Deploying to production..."
```
With manual approval configured on the `production` environment in GitHub UI, the pipeline pauses before the `deploy-production` job until an authorized user approves.
### 8. Build Once, Deploy Many
Never rebuild for each environment. Build the artifact once, store it, and promote it.
```yaml
jobs:
build:
runs-on: ubuntu-latest
steps:
- run: docker build -t app:${{ github.sha }} .
- run: docker push registry.example.com/app:${{ github.sha }}
deploy-staging:
needs: build
steps:
- run: docker pull registry.example.com/app:${{ github.sha }}
- run: deploy-to-staging.sh ${{ github.sha }}
deploy-production:
needs: deploy-staging
environment: production
steps:
- run: docker pull registry.example.com/app:${{ github.sha }}
- run: deploy-to-production.sh ${{ github.sha }}
```
---
## Common Mistakes
1. **Running all tests sequentially** — Use job parallelism and matrix builds. Slow pipelines discourage developer adoption.
2. **Rebuilding for each environment** — Different builds for staging and production means what you tested isn't what you deploy. Always build once and promote artifacts.
3. **Hardcoding secrets** — Secrets in workflow files, scripts, or logs are a security incident waiting to happen. Use GitHub Actions secrets, OIDC, or external secret stores (Vault, AWS Secrets Manager).
4. **No caching** — Every pipeline downloading dependencies from scratch wastes minutes per run. Use `actions/cache` or built-in caching for package managers.
5. **Wrong testing order** — Running slow e2e tests before fast unit tests means developers wait 15 minutes to learn about a lint error. Order tests fastest-first (lint → unit → integration → e2e).
6. **Ignoring pipeline security** — Unpinned actions (`uses: actions/checkout@v3` instead of `@v3.0.0`) can be compromised. Use full version tags or SHAs.
7. **No concurrency control** — Without `concurrency`, pushing three commits in quick succession creates three simultaneous deployments to the same environment, causing race conditions.
8. **Overly permissive triggers** — Running production deployments on every push to any branch is dangerous. Restrict production deployments to protected branches with required reviews.
9. **Single environment, no staging** — Deploying directly to production without staging means bugs reach users. Use at least one pre-production environment that mirrors production.
10. **No rollback strategy** — Deployments fail. Without an automated rollback mechanism (blue/green, canary, or direct rollback), a bad deployment becomes an incident.
---
> Source: [cosmicstack-labs/mercury-agent-skills](https://github.com/cosmicstack-labs/mercury-agent-skills) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-22 -->
章节与文件索引
按说明文件中的顺序排列。
概述
核心原则
🟢初学者
🟡熟练
🔴专家
文件/命令 -> git push · actions/cache · setup-node --cache · production · CI - Lint & Test · CD - Deploy Production · concurrency · actions/checkout
内容校验值 -> b44224e18611
当前原文的自动摘译,尚未人工审校。
概述
CI/CD 管道是现代软件交付的支柱——将源代码转换为运行软件的自动化装配线。精心设计的管道可以尽早发现错误,实施质量关卡,充满信心地部署,并为开发人员提供快速反馈。该技能涵盖了从 GitHub Actions 工作流创作和矩阵构建策略到多环境部署模式、秘密管理和管道安全的全方位。
核心原则
快速反馈——管道必须在几分钟内发现故障。缓慢的管道鼓励开发人员绕过它们。优化每个阶段的速度。快速失败、早期失败——将测试阶段从最快/最便宜到最慢/最昂贵进行排序。在运行昂贵的 e2e 套件之前,在 lint 阶段拒绝错误的提交。可重复性——在相同的提交下,管道必须产生相同的结果。固定操作版本、使用锁定文件并避免环境漂移。
🟢初学者
单个整体工作流程文件 所有测试在每次推送时按顺序运行 硬编码机密存储在工作流程 YAML 或纯文本中 通过
git push和 SSH 进行手动部署 无环境隔离 — CI 与其他所有内容在相同的上下文中运行🟡熟练
单独的 lint、测试、构建和部署作业 矩阵构建用于多版本和多平台测试 使用
actions/cache或setup-node --cache进行依赖项缓存 具有保护规则的环境(例如,production需要批准) 基于 OIDC 的云身份验证(无长期秘密)🔴专家
从中央编排器调用的可重用工作流程 基于更改的文件(monorepo 感知)的动态矩阵生成 具有智能测试分割的并行测试分片 BuildKit 缓存安装和远程缓存(Docker 注册表、Buildx) 具有渐进式流量转移的金丝雀部署