Build & Deploy

Comprehensive build and deployment skill for validation, CI/CD patterns, and deployment strategies.

Core Capabilities

Build Validation

Validate builds before deployment:

Pre-build checks:

• Dependencies installed correctly

• Environment variables set

• Required services available

• Configuration files valid

Build process:

Python project

pip install -r requirements.txt python -m pytest python -m mypy src/ python -m build

Node.js project

npm ci npm run lint npm run test npm run build

Post-build validation:

• Build artifacts exist

• Artifact sizes reasonable

• Version numbers correct

• No development dependencies in production

CI/CD Patterns

Common continuous integration/deployment patterns:

GitHub Actions:

name: CI/CD Pipeline

on: push: branches: [main] pull_request: branches: [main]

jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: '3.11' - run: pip install -r requirements.txt - run: pytest --cov=src

build: needs: test runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - run: docker build -t app:${{ github.sha }} .

deploy: needs: build if: github.ref == 'refs/heads/main' runs-on: ubuntu-latest steps: - run: echo "Deploy to production"

Pipeline stages:

• Lint: Code style and quality

• Test: Unit and integration tests

• Build: Create artifacts

• Security: Scan for vulnerabilities

• Deploy: Push to environment

Deployment Strategies

Choose appropriate deployment approach:

Rolling Deployment:

• Gradual replacement of instances

• Zero downtime

• Easy rollback

• Best for: Stateless services

Blue-Green Deployment:

• Two identical environments

• Instant switch between versions

• Simple rollback

• Best for: Critical services

Canary Deployment:

• Small percentage gets new version

• Gradual traffic increase

• Risk mitigation

• Best for: High-traffic services

Feature Flags:

• Deploy code, enable separately

• Gradual rollout to users

• Quick disable if issues

• Best for: New features

Pre-flight Checks

Validation before deployment:

Checklist:

[ ] All tests pass [ ] Security scan clean [ ] Build artifacts valid [ ] Configuration correct [ ] Database migrations ready [ ] Dependencies compatible [ ] Rollback plan documented [ ] Monitoring configured [ ] Team notified

Automated checks:

Environment validation

./scripts/check-env.sh

Database connectivity

./scripts/check-db.sh

External service health

./scripts/check-services.sh

Configuration validation

./scripts/validate-config.sh

Build Workflows

Local Build

For development and testing:

Create virtual environment

python -m venv venv source venv/bin/activate

Install dependencies

pip install -r requirements-dev.txt

Run tests

pytest

Build package

python -m build

Production Build

For deployment:

Install production dependencies only

pip install -r requirements.txt

Run production build

python -m build --wheel

Verify artifact

ls dist/

Container Build

For containerized deployments:

Multi-stage Dockerfile

FROM python:3.11-slim as builder

WORKDIR /app COPY requirements.txt . RUN pip wheel --no-cache-dir --wheel-dir /wheels -r requirements.txt

FROM python:3.11-slim WORKDIR /app COPY --from=builder /wheels /wheels RUN pip install --no-cache /wheels/* COPY src/ ./src/ CMD ["python", "-m", "src.main"]

Deployment Workflows

GCP Cloud Run

Build and push image

gcloud builds submit --tag gcr.io/PROJECT/APP

Deploy to Cloud Run

gcloud run deploy APP
--image gcr.io/PROJECT/APP
--platform managed
--region us-central1
--allow-unauthenticated

GCP Compute Engine

Create instance template

gcloud compute instance-templates create APP-template
--machine-type=e2-medium
--image-family=debian-11
--metadata-from-file=startup-script=startup.sh

Update managed instance group

gcloud compute instance-groups managed rolling-action start-update APP-group
--version=template=APP-template

GCP Cloud Functions

Deploy function

gcloud functions deploy FUNCTION_NAME
--runtime python311
--trigger-http
--entry-point main
--source ./src

Environment Management

Environment Variables

Required variables:

Application

APP_ENV=production APP_DEBUG=false APP_SECRET_KEY=<secret>

Database

DATABASE_URL=postgresql://... REDIS_URL=redis://...

External Services

API_KEY=<key>

Validation:

required_vars = [ 'DATABASE_URL', 'APP_SECRET_KEY', 'API_KEY', ]

missing = [v for v in required_vars if not os.getenv(v)] if missing: raise ValueError(f"Missing env vars: {missing}")

Configuration Management

Environment-specific configs:

config/ ├── base.py # Shared settings ├── development.py ├── staging.py └── production.py

Loading pattern:

import os env = os.getenv('APP_ENV', 'development') config = importlib.import_module(f'config.{env}')

Rollback Procedures

Quick Rollback

GCP Cloud Run

gcloud run services update-traffic APP
--to-revisions=PREVIOUS_REVISION=100

Docker/Kubernetes

kubectl rollout undo deployment/APP

Database (if migration failed)

python manage.py migrate APP PREVIOUS_MIGRATION

Rollback Checklist

[ ] Identify the issue [ ] Notify stakeholders [ ] Execute rollback command [ ] Verify service health [ ] Investigate root cause [ ] Document incident

Monitoring Integration

Health Checks

@app.get("/health") def health_check(): return { "status": "healthy", "version": APP_VERSION, "timestamp": datetime.utcnow().isoformat() }

@app.get("/ready") def readiness_check(): # Check dependencies db_ok = check_database() cache_ok = check_redis() return { "ready": db_ok and cache_ok, "checks": { "database": db_ok, "cache": cache_ok } }

Deployment Metrics

Track after deployment:

• Response times

• Error rates

• Resource utilization

• Business metrics

Integration

Coordinate with other skills:

• security-scanning skill: Pre-deploy security checks

• test-coverage skill: Ensure adequate coverage

• git-workflows skill: Tag releases, update changelog