Balancer Load 101: یک راهنمای عملی در صورتی که برنامه شما یک شبه ویروسی شود

  brew install nginx

  sudo apt update
  sudo apt install nginx

   mkdir load-balancer-lab
   cd load-balancer-lab

   const http = require('http');

   // Get port from environment or default to 3000
   const port = process.env.PORT || 3000;

   // Create our humble server
   const server = http.createServer((req, res) => {
       // Send a response that identifies which server instance responded
       res.writeHead(200, { 'Content-Type': 'text/plain' });
       res.end(`Hello! I'm the server running on port ${port}. At your service!\n`);
   });

   // Start listening for requests
   server.listen(port, () => {
       console.log(`Server #${port - 3000 + 1} is alive and listening on port ${port}`);
   });

   PORT=3000 node app.js
   # Open a new terminal window
   PORT=3001 node app.js
   # Open another terminal window
   PORT=3002 node app.js

   http {
       # Include mime types (important to keep this if it exists in your file)
       include       mime.types;
       default_type  application/octet-stream;

       # Define our group of application servers
       upstream application_servers {
           server 127.0.0.1:3000;  # Server #1
           server 127.0.0.1:3001;  # Server #2
           server 127.0.0.1:3002;  # Server #3

           # Using round robin by default - simple but effective!
       }

       # Configure our web server
       server {
           listen 80;  # Listen on the standard HTTP port

           location / {
               # Pass requests to our application servers
               proxy_pass http://application_servers;

               # Forward important headers
               proxy_set_header Host $host;
               proxy_set_header X-Real-IP $remote_addr;
               proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

               # Add a custom header to see load balancing in action
               add_header X-Load-Balanced "Yes, magic is happening!";
           }
       }
   }

   # Don't forget to keep the events block if it exists
   events {
       worker_connections 1024;
   }

   for i in {1..10}; do curl http://localhost; echo; done

# Start with a lightweight Node.js image
FROM node:16-alpine

# Set the working directory inside the container
WORKDIR /app

# Create a non-root user for security
RUN adduser -D nodeuser

# Create a package.json (not strictly needed for our simple app, but good practice)
RUN echo '{"name":"load-balanced-app","version":"1.0.0","main":"app.js"}' > package.json

# Copy our application code
COPY app.js .

# Switch to the non-root user
USER nodeuser

# Tell Docker which port the application uses
EXPOSE 3000

# Command to run when the container starts
CMD ["node", "app.js"]

version: '3.8'

services:
  # First application server
  app1:
    build: .
    environment:
      - PORT=3000
      - SERVER_NAME=Speedy
    restart: always
    networks:
      - loadbalancer-net

  # Second application server  
  app2:
    build: .
    environment:
      - PORT=3000
      - SERVER_NAME=Zippy
    restart: always
    networks:
      - loadbalancer-net

  # Third application server
  app3:
    build: .
    environment:
      - PORT=3000
      - SERVER_NAME=Nimble
    restart: always
    networks:
      - loadbalancer-net

  # Nginx load balancer
  loadbalancer:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    restart: always
    depends_on:
      - app1
      - app2
      - app3
    networks:
      - loadbalancer-net

networks:
  loadbalancer-net:
    driver: bridge

const http = require('http');

const port = process.env.PORT || 3000;
const serverName = process.env.SERVER_NAME || `Server-${port}`;

const server = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end(`Hello from ${serverName}!\nRequest handled at: ${new Date().toISOString()}\n`);
});

server.listen(port, () => {
    console.log(`${serverName} is running on port ${port}`);
});

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for" '
                      '"$upstream_addr" "$upstream_response_time"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    keepalive_timeout  65;

    # Load balancing configuration
    upstream app_servers {
        # Least connections algorithm - adapts better to varying load
        least_conn;

        server app1:3000;
        server app2:3000;
        server app3:3000;

        # Enable session persistence (optional)
        # ip_hash;

        # Health checks and slow-start for production
        # server app1:3000 max_fails=3 fail_timeout=30s slow_start=30s;
    }

    server {
        listen 80;
        server_name localhost;

        location / {
            proxy_pass http://app_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

            # Add useful headers for debugging
            add_header X-Load-Balanced "Yes";
            add_header X-Upstream-Server $upstream_addr;
            add_header X-Response-Time $upstream_response_time;
        }

        # Health check endpoint for monitoring tools
        location /health {
            return 200 'Load balancer is healthy!';
            add_header Content-Type text/plain;
        }
    }
}

# Build and start the containers
docker-compose up --build -d

# Watch the logs to see requests being distributed
docker-compose logs -f loadbalancer

for i in {1..20}; do curl http://localhost; sleep 0.5; done

# Log in to Docker Hub
docker login

# Tag your image
docker build -t yourusername/load-balanced-app:latest .

# Push to Docker Hub
docker push yourusername/load-balanced-app:latest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
  labels:
    app: load-balanced-app
spec:
  replicas: 5  # Start with 5 instances
  selector:
    matchLabels:
      app: load-balanced-app
  template:
    metadata:
      labels:
        app: load-balanced-app
    spec:
      containers:
      - name: app
        image: yourusername/load-balanced-app:latest
        ports:
        - containerPort: 3000
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 256Mi
        readinessProbe:
          httpGet:
            path: /
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /
            port: 3000
          initialDelaySeconds: 15
          periodSeconds: 20

apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: load-balanced-app
  ports:
  - port: 80
    targetPort: 3000
  type: LoadBalancer  # Exposes your app with a public IP

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-autoscaler
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app-deployment
  minReplicas: 5
  maxReplicas: 100  # Scale up to 100 pods if needed
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70  # Scale up when CPU usage reaches 70%
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80  # Scale up when memory usage reaches 80%

# Apply your configurations
kubectl apply -f k8s-deployment.yaml
kubectl apply -f k8s-service.yaml
kubectl apply -f k8s-autoscaler.yaml

# Check the status of your deployment
kubectl get deployments
kubectl get pods
kubectl get services

# Get the external IP to access your application
kubectl get service app-service

   upstream weighted_servers {
       server app1:3000 weight=5;  # This server gets 5x more traffic
       server app2:3000 weight=3;
       server app3:3000 weight=1;  # This server gets the least traffic
   }

   upstream sticky_servers {
       ip_hash;  # Routes based on client IP
       server app1:3000;
       server app2:3000;
       server app3:3000;
   }

   upstream smart_servers {
       server app1:3000 max_fails=3 fail_timeout=30s;
       server app2:3000 max_fails=3 fail_timeout=30s;
       server app3:3000 max_fails=3 fail_timeout=30s;
   }