deployment-engineer

Deployment automation specialist for CI/CD pipelines and infrastructure. Use when setting up deployment, configuring CI/CD, or managing releases.

16 stars

Best use case

deployment-engineer is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Deployment automation specialist for CI/CD pipelines and infrastructure. Use when setting up deployment, configuring CI/CD, or managing releases.

Teams using deployment-engineer should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/deployment-engineer/SKILL.md --create-dirs "https://raw.githubusercontent.com/diegosouzapw/awesome-omni-skill/main/skills/devops/deployment-engineer/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/deployment-engineer/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How deployment-engineer Compares

Feature / Agentdeployment-engineerStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Deployment automation specialist for CI/CD pipelines and infrastructure. Use when setting up deployment, configuring CI/CD, or managing releases.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Deployment Engineer

Specialist in deployment automation, CI/CD pipelines, and infrastructure management.

## When This Skill Activates

Activates when you:
- Set up deployment pipeline
- Configure CI/CD
- Manage releases
- Automate infrastructure

## CI/CD Pipeline

### Pipeline Stages

```yaml
stages:
  - lint
  - test
  - build
  - security
  - deploy-dev
  - deploy-staging
  - deploy-production
```

### GitHub Actions Example

```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'
      - run: npm ci
      - run: npm run lint

  test:
    runs-on: ubuntu-latest
    needs: lint
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npm test

  build:
    runs-on: ubuntu-latest
    needs: test
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npm run build
      - uses: actions/upload-artifact@v4
        with:
          name: build
          path: dist/

  deploy-production:
    runs-on: ubuntu-latest
    needs: build
    if: github.ref == 'refs/heads/main'
    environment: production
    steps:
      - uses: actions/checkout@v4
      - uses: actions/download-artifact@v4
        with:
          name: build
          path: dist/
      - run: npm run deploy
```

## Deployment Strategies

### 1. Blue-Green Deployment

```
         ┌─────────┐
         │  Load   │
         │ Balancer│
         └────┬────┘
              │
     ┌────────┴────────┐
     │    Switch       │
     ├────────┬────────┤
     ▼        ▼        ▼
  ┌─────┐ ┌─────┐ ┌─────┐
  │Blue │ │Green│ │     │
  └─────┘ └─────┘ └─────┘
```

### 2. Rolling Deployment

```
┌─────────────────────────────────────┐
│ v1  v1  v1  v1  v1  v1  v1  v1  v1 │ → Old
│ v2  v2  v2  v2  v2  v2  v2  v2  v2 │ → New
└─────────────────────────────────────┘
    ▲                       ▲
    │                       │
  Start                  End
```

### 3. Canary Deployment

```
┌──────────────────────────────────────┐
│ v1  v1  v1  v1  v1  v1  v1  v1  v1  v1 │ → Old
│ v2  v2  v2  v2                        │ → Canary (5%)
└──────────────────────────────────────┘

Monitor metrics, then:
│ v1  v1  v1  v1                        │ → Old (50%)
│ v2  v2  v2  v2  v2  v2  v2  v2  v2  v2 │ → New (50%)
```

## Environment Configuration

### Environment Variables

```bash
# Production
NODE_ENV=production
DATABASE_URL=postgresql://...
API_KEY=sk-...
SENTRY_DSN=https://example.com/123

# Development
NODE_ENV=development
DATABASE_URL=postgresql://localhost:5432/dev
```

### Configuration Management

```typescript
// config/production.ts
export default {
  database: {
    url: process.env.DATABASE_URL,
    poolSize: 20,
  },
  redis: {
    url: process.env.REDIS_URL,
  },
};
```

## Health Checks

```typescript
// GET /health
app.get('/health', (req, res) => {
  const health = {
    status: 'ok',
    timestamp: new Date().toISOString(),
    checks: {
      database: 'ok',
      redis: 'ok',
      external_api: 'ok',
    },
  };

  if (Object.values(health.checks).some(v => v !== 'ok')) {
    health.status = 'degraded';
    return res.status(503).json(health);
  }

  res.json(health);
});
```

## Rollback Strategy

```bash
# Kubernetes
kubectl rollout undo deployment/app

# Docker
docker-compose down
docker-compose up -d --scale app=<previous-version>

# Git
git revert HEAD
git push
```

## Monitoring & Logging

### Metrics to Track

- Deployment frequency
- Lead time for changes
- Mean time to recovery (MTTR)
- Change failure rate

### Logging

```typescript
// Structured logging
logger.info('Deployment started', {
  version: process.env.VERSION,
  environment: process.env.NODE_ENV,
  timestamp: new Date().toISOString(),
});
```

## Scripts

Generate deployment config:
```bash
python scripts/generate_deploy.py <environment>
```

Validate deployment:
```bash
python scripts/validate_deploy.py
```

## References

- `references/pipelines.md` - CI/CD pipeline examples
- `references/kubernetes.md` - K8s deployment configs
- `references/monitoring.md` - Monitoring setup

Related Skills

dotnet-container-deployment

16
from diegosouzapw/awesome-omni-skill

Deploys .NET containers. Kubernetes probes, Docker Compose for local dev, CI/CD integration.

docker-deployment

16
from diegosouzapw/awesome-omni-skill

Docker containerization and deployment for Java/Spring Boot applications. Multi-stage builds, docker-compose, health checks, and CI/CD with GitHub Actions.

devops-engineer

16
from diegosouzapw/awesome-omni-skill

Expert DevOps engineer bridging development and operations with comprehensive automation, monitoring, and infrastructure management. Masters CI/CD, containerization, and cloud platforms with focus on culture, collaboration, and continuous improvement.

DevOps & Deployment

16
from diegosouzapw/awesome-omni-skill

Use when setting up CI/CD pipelines, containerizing applications, deploying to Kubernetes, or writing infrastructure as code. DevOps & Deployment covers GitHub Actions, Docker, Helm, and Terraform patterns.

deployment-wizard

16
from diegosouzapw/awesome-omni-skill

Deploy local websites to the internet instantly via Cloudflare Tunnel. Zero hosting, zero domain needed.

deployment-validation-config-validate

16
from diegosouzapw/awesome-omni-skill

You are a configuration management expert specializing in validating, testing, and ensuring the correctness of application configurations. Create comprehensive validation schemas, implement configurat

deployment-safety

16
from diegosouzapw/awesome-omni-skill

Pre-deployment checklists, rollback strategies, and post-deploy verification. Use this skill when preparing to deploy code, reviewing deployment processes, or setting up CI/CD pipelines.

deployment-procedures

16
from diegosouzapw/awesome-omni-skill

Production deployment principles and decision-making.

deployment-playbook

16
from diegosouzapw/awesome-omni-skill

Safe deployment steps and verification.

deployment-pipeline-design

16
from diegosouzapw/awesome-omni-skill

Design multi-stage CI/CD pipelines with approval gates, security checks, and deployment orchestration. Use when architecting deployment workflows, setting up continuous delivery, or implementing GitOps practices.

deployment-patterns

16
from diegosouzapw/awesome-omni-skill

Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.

deployment-infrastructure

16
from diegosouzapw/awesome-omni-skill

Kubernetes deployment and infrastructure patterns