Modern Application Deployment Workflow 🚀

# Start with the official Node.js image
FROM node:18-alpine AS builder

# Set working directory
WORKDIR /app

# Install dependencies first (for better caching)
COPY package*.json ./
RUN npm ci

# Copy source code
COPY . .

# Build the application
RUN npm run build

# Production image
FROM node:18-alpine AS runner

WORKDIR /app

# Copy only necessary files from builder
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package*.json ./

# Install production dependencies only
RUN npm ci --only=production

# Configure environment
ENV NODE_ENV=production
ENV PORT=3000

# Expose port
EXPOSE 3000

# Start the application
CMD ["npm", "start"]

-- Create users table
CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Create posts table with foreign key relationship
CREATE TABLE IF NOT EXISTS posts (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    title VARCHAR(200) NOT NULL,
    content TEXT,
    published_at TIMESTAMP WITH TIME ZONE
);

-- Add indexes for common queries
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_posts_user_id ON posts(user_id);

#!/bin/bash
set -e

# Configuration
APP_NAME="myapp"
DOCKER_REGISTRY="registry.example.com"
TAG=$(git rev-parse --short HEAD)

# Colors for output
GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m'

# Function for logging with timestamp
log() {
    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] $1${NC}"
}

error() {
    echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
    exit 1
}

# Build Docker image
log "Building Docker image..."
docker build -t ${DOCKER_REGISTRY}/${APP_NAME}:${TAG} . || error "Docker build failed"

# Run tests
log "Running tests..."
docker run --rm ${DOCKER_REGISTRY}/${APP_NAME}:${TAG} npm test || error "Tests failed"

# Push to registry
log "Pushing to registry..."
docker push ${DOCKER_REGISTRY}/${APP_NAME}:${TAG} || error "Push failed"

# Update deployment
log "Updating Kubernetes deployment..."
kubectl set image deployment/${APP_NAME} ${APP_NAME}=${DOCKER_REGISTRY}/${APP_NAME}:${TAG}

log "Deployment completed successfully!"

interface Config {
    port: number;
    database: {
        host: string;
        port: number;
        name: string;
        user: string;
    };
    redis: {
        host: string;
        port: number;
    };
}

const getConfig = (): Config => {
    return {
        port: parseInt(process.env.PORT || '3000', 10),
        database: {
            host: process.env.DB_HOST || 'localhost',
            port: parseInt(process.env.DB_PORT || '5432', 10),
            name: process.env.DB_NAME || 'myapp',
            user: process.env.DB_USER || 'postgres'
        },
        redis: {
            host: process.env.REDIS_HOST || 'localhost',
            port: parseInt(process.env.REDIS_PORT || '6379', 10)
        }
    };
};

export default getConfig;

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'nodejs'
    static_configs:
      - targets: ['localhost:3000']
    metrics_path: '/metrics'
    scheme: 'http'

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['localhost:9100']

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

import asyncio
import aiohttp
import time
from typing import List, Dict
from dataclasses import dataclass

@dataclass
class TestResult:
    status: int
    response_time: float
    success: bool

async def make_request(session: aiohttp.ClientSession, url: str) -> TestResult:
    start_time = time.time()
    try:
        async with session.get(url) as response:
            await response.text()
            return TestResult(
                status=response.status,
                response_time=time.time() - start_time,
                success=response.status == 200
            )
    except Exception as e:
        print(f"Request failed: {e}")
        return TestResult(
            status=0,
            response_time=time.time() - start_time,
            success=False
        )

async def run_load_test(url: str, num_requests: int) -> List[TestResult]:
    async with aiohttp.ClientSession() as session:
        tasks = [make_request(session, url) for _ in range(num_requests)]
        return await asyncio.gather(*tasks)

if __name__ == "__main__":
    TEST_URL = "http://localhost:3000/api/health"
    NUM_REQUESTS = 1000

    results = asyncio.run(run_load_test(TEST_URL, NUM_REQUESTS))

    # Calculate statistics
    successful_requests = len([r for r in results if r.success])
    avg_response_time = sum(r.response_time for r in results) / len(results)

    print(f"Load test completed:")
    print(f"Success rate: {successful_requests/NUM_REQUESTS*100:.2f}%")
    print(f"Average response time: {avg_response_time*1000:.2f}ms")