Skip to content

use-cases.md

Latest commit

 

History

History
545 lines (442 loc) · 10.4 KB

use-cases.md

File metadata and controls

545 lines (442 loc) · 10.4 KB

🎯 Pin Use Cases

This document outlines real-world scenarios where Pin can be effectively used for development, testing, and deployment workflows.

🏢 Development Workflows

Local Development Environment

Scenario: Setting up a consistent development environment across team members.

# dev-setup.yaml
workflow:
  - setup-dependencies
  - start-services
  - run-tests

setup-dependencies:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm install
    - npm run build

start-services:
  image: node:18-alpine
  copyFiles: true
  port:
    - "3000:3000"
    - "127.0.0.1:8080:8080"
  script:
    - npm run start:dev

run-tests:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm run test:watch

Benefits:

  • Consistent environment across different machines
  • No need to install Node.js locally
  • Isolated dependencies

Code Quality Automation

Scenario: Running linting, formatting, and security checks before commits.

# quality-check.yaml
workflow:
  - lint
  - format-check
  - security-scan
  - type-check

lint:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm run lint
    - npm run lint:css

format-check:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm run prettier:check

security-scan:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm audit --audit-level=moderate
    - npx snyk test

type-check:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm run type-check

🧪 Testing Scenarios

Multi-Environment Testing

Scenario: Testing application against different database versions.

# multi-db-test.yaml
workflow:
  - test-postgres-13
  - test-postgres-14
  - test-postgres-15

test-postgres-13:
  image: golang:1.21-alpine
  copyFiles: true
  parallel: true
  env:
    - DB_HOST=postgres-13
    - DB_PORT=5432
    - DB_NAME=testdb
  script:
    - go test ./... -tags=integration

test-postgres-14:
  image: golang:1.21-alpine
  copyFiles: true
  parallel: true
  env:
    - DB_HOST=postgres-14
    - DB_PORT=5432
    - DB_NAME=testdb
  script:
    - go test ./... -tags=integration

test-postgres-15:
  image: golang:1.21-alpine
  copyFiles: true
  parallel: true
  env:
    - DB_HOST=postgres-15
    - DB_PORT=5432
    - DB_NAME=testdb
  script:
    - go test ./... -tags=integration

Load Testing

Scenario: Performance testing with different load patterns.

# load-test.yaml
workflow:
  - start-app
  - light-load
  - heavy-load
  - spike-test

start-app:
  image: myapp:latest
  port:
    - "8080:8080"
  script:
    - ./start-server.sh

light-load:
  image: alpine:latest
  script:
    - apk add --no-cache apache2-utils
    - ab -n 1000 -c 10 http://localhost:8080/api/test

heavy-load:
  image: alpine:latest
  script:
    - apk add --no-cache apache2-utils
    - ab -n 10000 -c 100 http://localhost:8080/api/test

spike-test:
  image: alpine:latest
  script:
    - apk add --no-cache apache2-utils
    - ab -n 5000 -c 500 http://localhost:8080/api/test

🚀 CI/CD Integration

Branch-Based Deployment Pipeline

Scenario: Different deployment strategies based on git branches.

# ci-pipeline.yaml
workflow:
  - build
  - test
  - security-check
  - deploy-dev
  - deploy-staging
  - deploy-prod

build:
  image: golang:1.21-alpine
  copyFiles: true
  script:
    - go build -o app .
    - docker build -t myapp:${COMMIT_SHA} .

test:
  image: golang:1.21-alpine
  copyFiles: true
  script:
    - go test ./...
    - go test -race ./...

security-check:
  image: aquasec/trivy:latest
  script:
    - trivy image myapp:${COMMIT_SHA}

deploy-dev:
  image: alpine:latest
  condition: $BRANCH != "main" && $BRANCH != "staging"
  script:
    - echo "Deploying to dev environment..."
    - kubectl apply -f k8s/dev/

deploy-staging:
  image: alpine:latest
  condition: $BRANCH == "staging"
  script:
    - echo "Deploying to staging environment..."
    - kubectl apply -f k8s/staging/

deploy-prod:
  image: alpine:latest
  condition: $BRANCH == "main"
  script:
    - echo "Deploying to production environment..."
    - kubectl apply -f k8s/prod/

Feature Flag Testing

Scenario: Testing different feature combinations.

# feature-test.yaml
workflow:
  - test-feature-a
  - test-feature-b
  - test-feature-combo

test-feature-a:
  image: myapp:latest
  env:
    - FEATURE_A=true
    - FEATURE_B=false
  script:
    - npm test -- --grep "Feature A"

test-feature-b:
  image: myapp:latest
  env:
    - FEATURE_A=false
    - FEATURE_B=true
  script:
    - npm test -- --grep "Feature B"

test-feature-combo:
  image: myapp:latest
  env:
    - FEATURE_A=true
    - FEATURE_B=true
  script:
    - npm test -- --grep "Feature Integration"

🐛 Debugging and Troubleshooting

Application Debugging

Scenario: Debugging with different logging levels and tools.

# debug.yaml
workflow:
  - debug-verbose
  - debug-profiling
  - debug-memory

debug-verbose:
  image: myapp:latest
  copyFiles: true
  env:
    - LOG_LEVEL=debug
    - DEBUG=*
  script:
    - npm start

debug-profiling:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm install -g clinic
    - clinic doctor -- node app.js

debug-memory:
  image: node:18-alpine
  copyFiles: true
  script:
    - node --inspect=0.0.0.0:9229 app.js

Network Troubleshooting

Scenario: Testing network connectivity and API endpoints.

# network-debug.yaml
workflow:
  - connectivity-test
  - api-health-check
  - dns-resolution

connectivity-test:
  image: alpine:latest
  script:
    - ping -c 3 google.com
    - telnet database 5432 || echo "Database connection failed"

api-health-check:
  image: alpine:latest
  script:
    - apk add --no-cache curl jq
    - curl -v http://api:8080/health | jq .

dns-resolution:
  image: alpine:latest
  script:
    - nslookup api
    - nslookup database

📊 Data Processing

ETL Pipeline

Scenario: Extract, Transform, Load data processing.

# etl-pipeline.yaml
workflow:
  - extract-data
  - transform-data
  - validate-data
  - load-data

extract-data:
  image: python:3.11-alpine
  copyFiles: true
  env:
    - SOURCE_DB_URL=postgresql://user:pass@source:5432/db
  script:
    - python extract.py

transform-data:
  image: python:3.11-alpine
  copyFiles: true
  script:
    - python transform.py --input raw_data.csv --output clean_data.csv

validate-data:
  image: python:3.11-alpine
  copyFiles: true
  script:
    - python validate.py --data clean_data.csv

load-data:
  image: python:3.11-alpine
  copyFiles: true
  env:
    - TARGET_DB_URL=postgresql://user:pass@target:5432/db
  script:
    - python load.py --data clean_data.csv

Machine Learning Pipeline

Scenario: Training and evaluating ML models.

# ml-pipeline.yaml
workflow:
  - prepare-data
  - train-model
  - evaluate-model
  - deploy-model

prepare-data:
  image: python:3.11-slim
  copyFiles: true
  script:
    - pip install pandas scikit-learn
    - python prepare_data.py

train-model:
  image: tensorflow/tensorflow:latest
  copyFiles: true
  script:
    - python train_model.py --epochs 100

evaluate-model:
  image: python:3.11-slim
  copyFiles: true
  script:
    - pip install scikit-learn matplotlib
    - python evaluate_model.py

deploy-model:
  image: python:3.11-slim
  condition: $MODEL_ACCURACY > "0.9"
  script:
    - echo "Model meets accuracy threshold, deploying..."
    - python deploy_model.py

🌐 Infrastructure Testing

Multi-Cloud Deployment Testing

Scenario: Testing deployment across different cloud providers.

# multi-cloud.yaml
workflow:
  - test-aws
  - test-gcp
  - test-azure

test-aws:
  image: amazon/aws-cli:latest
  env:
    - AWS_REGION=us-east-1
  script:
    - aws s3 ls
    - aws ecs describe-clusters

test-gcp:
  image: google/cloud-sdk:alpine
  env:
    - GOOGLE_CLOUD_PROJECT=my-project
  script:
    - gcloud compute instances list
    - gcloud container clusters list

test-azure:
  image: mcr.microsoft.com/azure-cli:latest
  script:
    - az vm list
    - az aks list

Infrastructure as Code Validation

Scenario: Validating Terraform/CloudFormation templates.

# iac-validation.yaml
workflow:
  - terraform-validate
  - terraform-plan
  - cloudformation-validate

terraform-validate:
  image: hashicorp/terraform:latest
  copyFiles: true
  script:
    - terraform init
    - terraform validate
    - terraform fmt -check

terraform-plan:
  image: hashicorp/terraform:latest
  copyFiles: true
  script:
    - terraform plan -out=tfplan

cloudformation-validate:
  image: amazon/aws-cli:latest
  copyFiles: true
  script:
    - aws cloudformation validate-template --template-body file://template.yaml

🔐 Security Testing

Security Scanning Pipeline

Scenario: Comprehensive security analysis.

# security-scan.yaml
workflow:
  - dependency-scan
  - secret-scan
  - container-scan
  - static-analysis

dependency-scan:
  image: node:18-alpine
  copyFiles: true
  script:
    - npm audit --audit-level=moderate
    - npx snyk test

secret-scan:
  image: trufflesecurity/trufflehog:latest
  copyFiles: true
  script:
    - trufflehog filesystem .

container-scan:
  image: aquasec/trivy:latest
  script:
    - trivy image myapp:latest

static-analysis:
  image: sonarsource/sonar-scanner-cli:latest
  copyFiles: true
  script:
    - sonar-scanner -Dsonar.projectKey=myproject

🎯 When to Use Pin

✅ Ideal Use Cases

  • Local Development: Standardize development environments
  • CI/CD Pipelines: Build, test, and deploy workflows
  • Testing: Unit, integration, and performance testing
  • Code Quality: Linting, formatting, security scanning
  • Data Processing: ETL pipelines and batch jobs
  • Infrastructure Testing: IaC validation and multi-cloud testing
  • Debugging: Troubleshooting with different configurations

❌ Not Recommended For

  • Production Runtime: Use container orchestrators like Kubernetes
  • Long-running Services: Pin is designed for task execution
  • Complex Orchestration: For complex workflows, use dedicated orchestration tools
  • High Availability: Pin doesn't provide clustering or failover

🔄 Daemon Mode Benefits

  • Remote Monitoring: Monitor pipelines from anywhere
  • HTTP API: Trigger pipelines programmatically
  • Real-time Events: Get live updates via SSE
  • Production Ready: Graceful shutdown and error handling

This comprehensive guide shows how Pin can be integrated into various development and operational workflows, providing flexibility and consistency across different environments.