Deployment Strategies

# netlify.toml
[build]
  publish = "dist"
  command = "npm run build"

[build.environment]
  NODE_VERSION = "18"

[[redirects]]
  from = "/*"
  to = "/index.html"
  status = 200

# Build script
npm run build
netlify deploy --prod --dir=dist

// vercel.json
{
  "builds": [
    {
      "src": "package.json",
      "use": "@vercel/static-build",
      "config": {
        "distDir": "dist"
      }
    }
  ],
  "routes": [
    {
      "src": "/(.*)",
      "dest": "/index.html"
    }
  ]
}

# Deploy
vercel --prod

# Dockerfile
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# nginx.conf
server {
    listen 80;
    server_name localhost;
    root /usr/share/nginx/html;
    index index.html;
    
    location / {
        try_files $uri $uri/ /index.html;
    }
}

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: js-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: js-app
  template:
    metadata:
      labels:
        app: js-app
    spec:
      containers:
      - name: js-app
        image: js-app:latest
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"

---
apiVersion: v1
kind: Service
metadata:
  name: js-app-service
spec:
  selector:
    app: js-app
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

// deployment-pipeline.js
const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');

class DeploymentPipeline {
    constructor(config) {
        this.config = config;
        this.stages = ['build', 'test', 'deploy'];
    }
    
    async run() {
        console.log('🚀 Starting deployment pipeline...');
        
        for (const stage of this.stages) {
            try {
                await this.executeStage(stage);
                console.log(`✅ ${stage} completed successfully`);
            } catch (error) {
                console.error(`❌ ${stage} failed:`, error.message);
                throw error;
            }
        }
        
        console.log('🎉 Deployment completed successfully!');
    }
    
    async executeStage(stage) {
        switch (stage) {
            case 'build':
                await this.build();
                break;
            case 'test':
                await this.test();
                break;
            case 'deploy':
                await this.deploy();
                break;
        }
    }
    
    async build() {
        console.log('🔨 Building application...');
        execSync('npm run build', { stdio: 'inherit' });
        
        // Verify build output
        const distPath = path.join(process.cwd(), 'dist');
        if (!fs.existsSync(distPath)) {
            throw new Error('Build output not found');
        }
    }
    
    async test() {
        console.log('🧪 Running tests...');
        execSync('npm test', { stdio: 'inherit' });
    }
    
    async deploy() {
        console.log('🚀 Deploying application...');
        
        switch (this.config.deployment.target) {
            case 'netlify':
                await this.deployToNetlify();
                break;
            case 'vercel':
                await this.deployToVercel();
                break;
            case 'docker':
                await this.deployWithDocker();
                break;
            default:
                throw new Error('Unknown deployment target');
        }
    }
    
    async deployToNetlify() {
        execSync('netlify deploy --prod --dir=dist', { stdio: 'inherit' });
    }
    
    async deployToVercel() {
        execSync('vercel --prod', { stdio: 'inherit' });
    }
    
    async deployWithDocker() {
        execSync('docker build -t js-app .', { stdio: 'inherit' });
        execSync('docker run -d -p 3000:80 js-app', { stdio: 'inherit' });
    }
}

// Usage
const config = {
    deployment: {
        target: 'netlify'
    }
};

const pipeline = new DeploymentPipeline(config);
pipeline.run().catch(console.error);