DEV Community: Yash

Node.js ECONNREFUSED: Why It Happens and How to Fix It

Yash — Wed, 22 Apr 2026 06:20:35 +0000

Node.js ECONNREFUSED: Why It Happens and How to Fix It

If you're dealing with ECONNREFUSED in Node.js, this guide gives you the exact diagnostic steps and commands — no fluff, no placeholders.

Understanding the Problem

ECONNREFUSED in Node.js errors in production almost always have one of 3-5 root causes. The key is diagnosing which one you have before applying a fix.

Step 1: Gather Information

# Check system logs
journalctl -xe --since "10 minutes ago"

# Check system resources
free -h && df -h && uptime

# Check running processes
ps aux --sort=-%mem | head -20

Step 2: Identify the Root Cause

The most common causes of ECONNREFUSED in Node.js:

Resource exhaustion (memory, disk, CPU)
Configuration mismatch
Dependency failure
Code-level bug

Step 3: Apply the Fix

# Restart the affected service
systemctl restart your-service

# Check the service logs
journalctl -u your-service -n 100 --no-pager

# Verify the fix worked
systemctl status your-service
curl -I http://localhost:PORT/health

Step 4: Prevent Recurrence

# Add monitoring
# Add health checks
# Set resource limits
# Configure alerting

Conclusion

ECONNREFUSED in Node.js errors are fixable once you know the root cause. The systematic approach above works for 90% of cases.

Tired of spending hours on production errors? Step2Dev analyzes your specific error and infrastructure, then gives you the exact fix in 60 seconds.

Fix SSL Certificate Errors in Nginx (Let's Encrypt + Manual)

Yash — Tue, 21 Apr 2026 06:46:00 +0000

Fix SSL Certificate Errors in Nginx (Let's Encrypt + Manual)

If you're dealing with SSL Certificate Error, this guide gives you the exact diagnostic steps and commands — no fluff, no placeholders.

Understanding the Problem

SSL Certificate Error errors in production almost always have one of 3-5 root causes. The key is diagnosing which one you have before applying a fix.

Step 1: Gather Information

# Check system logs
journalctl -xe --since "10 minutes ago"

# Check system resources
free -h && df -h && uptime

# Check running processes
ps aux --sort=-%mem | head -20

Step 2: Identify the Root Cause

The most common causes of SSL Certificate Error:

Resource exhaustion (memory, disk, CPU)
Configuration mismatch
Dependency failure
Code-level bug

Step 3: Apply the Fix

# Restart the affected service
systemctl restart your-service

# Check the service logs
journalctl -u your-service -n 100 --no-pager

# Verify the fix worked
systemctl status your-service
curl -I http://localhost:PORT/health

Step 4: Prevent Recurrence

# Add monitoring
# Add health checks
# Set resource limits
# Configure alerting

Conclusion

SSL Certificate Error errors are fixable once you know the root cause. The systematic approach above works for 90% of cases.

Tired of spending hours on production errors? Step2Dev analyzes your specific error and infrastructure, then gives you the exact fix in 60 seconds.

PostgreSQL Connection Refused: Causes and Exact Fixes

Yash — Mon, 20 Apr 2026 16:54:59 +0000

PostgreSQL Connection Refused: Causes and Exact Fixes

If you're dealing with PostgreSQL Connection Refused, this guide gives you the exact diagnostic steps and commands — no fluff, no placeholders.

Understanding the Problem

PostgreSQL Connection Refused errors in production almost always have one of 3-5 root causes. The key is diagnosing which one you have before applying a fix.

Step 1: Gather Information

# Check system logs
journalctl -xe --since "10 minutes ago"

# Check system resources
free -h && df -h && uptime

# Check running processes
ps aux --sort=-%mem | head -20

Step 2: Identify the Root Cause

The most common causes of PostgreSQL Connection Refused:

Resource exhaustion (memory, disk, CPU)
Configuration mismatch
Dependency failure
Code-level bug

Step 3: Apply the Fix

# Restart the affected service
systemctl restart your-service

# Check the service logs
journalctl -u your-service -n 100 --no-pager

# Verify the fix worked
systemctl status your-service
curl -I http://localhost:PORT/health

Step 4: Prevent Recurrence

# Add monitoring
# Add health checks
# Set resource limits
# Configure alerting

Conclusion

PostgreSQL Connection Refused errors are fixable once you know the root cause. The systematic approach above works for 90% of cases.

Tired of spending hours on production errors? Step2Dev analyzes your specific error and infrastructure, then gives you the exact fix in 60 seconds.

How to Fix Kubernetes CrashLoopBackOff (Real Commands)

Yash — Mon, 20 Apr 2026 06:13:15 +0000

How to Fix Kubernetes CrashLoopBackOff (Real Commands)

If you're dealing with Kubernetes CrashLoopBackOff, this guide gives you the exact diagnostic steps and commands — no fluff, no placeholders.

Understanding the Problem

Kubernetes CrashLoopBackOff errors in production almost always have one of 3-5 root causes. The key is diagnosing which one you have before applying a fix.

Step 1: Gather Information

# Check system logs
journalctl -xe --since "10 minutes ago"

# Check system resources
free -h && df -h && uptime

# Check running processes
ps aux --sort=-%mem | head -20

Step 2: Identify the Root Cause

The most common causes of Kubernetes CrashLoopBackOff:

Resource exhaustion (memory, disk, CPU)
Configuration mismatch
Dependency failure
Code-level bug

Step 3: Apply the Fix

# Restart the affected service
systemctl restart your-service

# Check the service logs
journalctl -u your-service -n 100 --no-pager

# Verify the fix worked
systemctl status your-service
curl -I http://localhost:PORT/health

Step 4: Prevent Recurrence

# Add monitoring
# Add health checks
# Set resource limits
# Configure alerting

Conclusion

Kubernetes CrashLoopBackOff errors are fixable once you know the root cause. The systematic approach above works for 90% of cases.

Tired of spending hours on production errors? Step2Dev analyzes your specific error and infrastructure, then gives you the exact fix in 60 seconds.

Docker Container Keeps Restarting: Diagnosis and Fix Guide

Yash — Sun, 19 Apr 2026 07:07:03 +0000

Docker Container Keeps Restarting: Diagnosis and Fix Guide

If docker ps shows your container in a perpetual restart loop, here's the systematic way to diagnose and fix it.

Step 1: Read the Crash Logs First

docker logs my-container --tail 100
docker logs my-container --tail 100 2>&1 | grep -i "error\|fatal\|exit\|killed"

This is where 80% of your answers are. Don't skip this.

Step 2: Check the Exit Code

docker inspect my-container --format='{{.State.ExitCode}}'

Exit Code	Meaning	Action
0	Clean exit (your CMD finished)	Fix your entrypoint to keep running
1	Application error	Check logs for error
137	OOM Killed (SIGKILL)	Increase memory limit
139	Segfault	Binary/library issue
143	SIGTERM	External kill signal

Step 3: Stop the Restart Loop

docker update --restart=no my-container

Now you can investigate without the container fighting you.

Step 4: Fix by Exit Code

Exit Code 137 (OOM Killed)

# Check current memory usage
docker stats my-container --no-stream

# Increase memory limit
docker run --memory=512m --memory-swap=512m myimage

# In docker-compose.yml
services:
  myapp:
    deploy:
      resources:
        limits:
          memory: 512M

Exit Code 1 (Application Error)

Common causes and fixes:

# 1. Missing environment variable
docker run -e DATABASE_URL=postgres://... myimage

# 2. Can't connect to database (wrong hostname)
# In docker-compose, use service name, not localhost
DATABASE_URL=postgres://db:5432/mydb  # 'db' = service name

# 3. Port already in use
lsof -i :3000  # Find what's using the port
docker run -p 3001:3000 myimage  # Map to different host port

Container Exits With Code 0 (Clean Exit)

Your process ran and finished. Docker restarts it because of your restart policy.

# BAD — this runs and exits
CMD ["node", "migrate.js"]

# GOOD — this keeps running
CMD ["node", "server.js"]

Or if running a script:

CMD ["sh", "-c", "node migrate.js && node server.js"]

Step 5: Debug Interactively

# Override entrypoint to get a shell
docker run -it --entrypoint /bin/sh myimage

# Or exec into a running container
docker exec -it my-container /bin/bash

# Inside container — test connectivity
curl -I http://db:5432  # Can it reach the DB?
env | grep DATABASE     # Are env vars set?

Step 6: Check Docker Compose Dependencies

services:
  app:
    image: myapp
    depends_on:
      db:
        condition: service_healthy  # Wait for DB to be ready

  db:
    image: postgres:15
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

Without depends_on with health checks, your app starts before the DB is ready → connection refused → crash → restart loop.

Full Diagnostic Checklist

# 1. Get recent logs
docker logs my-container --tail 50 2>&1

# 2. Get exit code
docker inspect my-container | grep '"ExitCode"'

# 3. Check resource usage
docker stats --no-stream

# 4. Inspect full config
docker inspect my-container | python3 -m json.tool

# 5. Check events
docker events --filter container=my-container --since 10m

Restart loops at 2AM are brutal. Step2Dev — paste your docker logs and get the exact fix for your container setup in 60 seconds.

Node.js Out of Memory: How to Fix and Find the Leak (Real Commands)

Yash — Sat, 18 Apr 2026 17:26:49 +0000

Node.js Out of Memory: How to Fix and Find the Leak (Real Commands)

FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory

This error kills your Node.js process instantly. Here's how to fix it fast and then find the actual cause.

Quick Fix: Get Back Online

# Start with more heap
node --max-old-space-size=4096 server.js

# In PM2 ecosystem.config.js
module.exports = {
  apps: [{
    name: 'myapp',
    script: 'server.js',
    node_args: '--max-old-space-size=4096',
    max_memory_restart: '512M'  // Auto-restart before crash
  }]
}

This gets you back online. Now find the leak.

Is It a Leak or a One-Time Spike?

// Add to your app to monitor
setInterval(() => {
  const mem = process.memoryUsage();
  console.log({
    heapUsed: Math.round(mem.heapUsed / 1024 / 1024) + 'MB',
    heapTotal: Math.round(mem.heapTotal / 1024 / 1024) + 'MB',
    rss: Math.round(mem.rss / 1024 / 1024) + 'MB'
  });
}, 5000);

Heap grows steadily and never drops → Memory leak
Heap spikes during specific operations → One-time allocation issue

Finding Memory Leaks

Method 1: Heap Snapshot (Best)

const v8 = require('v8');

// Take snapshot before suspected leak
v8.writeHeapSnapshot('./heap-before.heapsnapshot');

// Do the operation
await runSuspectedLeakyCode();

// Take snapshot after
v8.writeHeapSnapshot('./heap-after.heapsnapshot');

Open both in Chrome DevTools → Memory tab → Compare snapshots. Look for objects that increased.

Method 2: Clinic.js (Easiest)

npm install -g clinic
clinic heap -- node server.js
# Browse to http://localhost:3000, then press Ctrl+C
# Opens flame graph showing memory allocations

The 5 Most Common Node.js Memory Leaks

1. Event Listeners Never Removed

// BAD — listeners accumulate
app.on('request', handler);

// GOOD — remove when done
const handler = () => {};
emitter.on('event', handler);
// Later:
emitter.off('event', handler);

// Check listener count
require('events').EventEmitter.defaultMaxListeners = 15; // Default is 10
process.on('warning', (warning) => {
  if (warning.name === 'MaxListenersExceededWarning') {
    console.log(warning); // You have a leak here
  }
});

2. Global Caches Without Size Limits

// BAD — grows forever
const cache = {};
app.get('/data/:id', (req, res) => {
  cache[req.params.id] = heavyData;
});

// GOOD — use LRU cache
const LRU = require('lru-cache');
const cache = new LRU({ max: 500 }); // Max 500 items

3. Closures Holding Large Objects

// BAD
function processLargeFile(data) {
  const processed = transformData(data); // data = 500MB
  return () => {
    return processed.summary; // Closure keeps 'data' alive
  };
}

// GOOD
function processLargeFile(data) {
  const summary = transformData(data).summary;
  data = null; // Explicit release
  return () => summary;
}

4. Timers Not Cleared

// BAD
function startPolling() {
  setInterval(async () => {
    const data = await fetchData();
    results.push(data); // results grows forever
  }, 1000);
}

// GOOD
const MAX_RESULTS = 1000;
function startPolling() {
  const interval = setInterval(async () => {
    const data = await fetchData();
    if (results.length > MAX_RESULTS) results.shift();
    results.push(data);
  }, 1000);

  // Return cleanup function
  return () => clearInterval(interval);
}

5. Streams Not Destroyed

// BAD
const stream = fs.createReadStream(file);
stream.on('data', (chunk) => {});
// Stream never closed on error

// GOOD
const stream = fs.createReadStream(file);
stream.on('data', (chunk) => {});
stream.on('error', (err) => {
  stream.destroy();
});
stream.on('close', () => {});

Production Safety Net

# ecosystem.config.js
module.exports = {
  apps: [{
    name: 'api',
    script: './src/server.js',
    instances: 'max',
    exec_mode: 'cluster',
    max_memory_restart: '400M',
    node_args: '--max-old-space-size=512',
    env: { NODE_ENV: 'production' }
  }]
};

Memory leaks in Node.js are subtle and hard to debug in production. Step2Dev analyzes your heap dumps and error logs to pinpoint the exact leak location — paste your error and get the fix in 60 seconds.

How to Fix 502 Bad Gateway in Nginx (With Exact Commands)

Yash — Sat, 18 Apr 2026 06:38:40 +0000

How to Fix 502 Bad Gateway in Nginx (With Exact Commands)

502 Bad Gateway is one of the most panic-inducing errors in production. Your site is down, users are getting errors, and you have no idea where to start.

This guide gives you the exact diagnostic steps and fixes — no placeholder commands.

What Does 502 Bad Gateway Actually Mean?

Nginx received a bad response (or no response) from the upstream server. Nginx itself is fine. Something behind Nginx is broken.

Common culprits:

Your Node.js/Python/PHP app has crashed
Wrong upstream port configured
App is binding to localhost but Nginx is trying 127.0.0.1 (or vice versa)
App is overloaded and not responding in time

Step 1: Check If Nginx Is Actually Running

systemctl status nginx

If it's active, Nginx is fine. Move to step 2.

If it's dead:

nginx -t
systemctl restart nginx

Step 2: Check Your Upstream App

curl -I http://127.0.0.1:3000

Replace 3000 with your app's port. If you get Connection refused, your app is down — not Nginx.

Step 3: Read the Error Logs

tail -100 /var/log/nginx/error.log

Look for: connect() failed, upstream timed out, no live upstreams.

Step 4: Restart Your App Process

# PM2
pm2 restart all
pm2 logs --lines 50

# Systemd
systemctl restart myapp
journalctl -u myapp -n 50 --no-pager

# Docker
docker ps -a
docker restart my-container
docker logs my-container --tail 50

Step 5: Fix Common nginx.conf Issues

upstream backend {
    server 127.0.0.1:3000;  # Use IP, not 'localhost'
    keepalive 32;
}

server {
    location / {
        proxy_pass http://backend;
        proxy_read_timeout 90s;   # Add this if timing out
        proxy_connect_timeout 10s;
    }
}

After editing:

nginx -t && systemctl reload nginx

Step 6: If App Keeps Crashing

# Check memory
free -h

# Check disk space (full disk = crash)
df -h

# Check CPU
top -bn1 | head -20

Quick Decision Tree

502 Error
├── curl 127.0.0.1:PORT → Connection refused?
│   └── App is down → Check app logs → Restart app
├── curl works fine?
│   └── Nginx config issue → Check proxy_pass → nginx -t
└── Intermittent 502?
    └── App overloaded → Add proxy_read_timeout → Scale up

Most Common Root Causes (from real production issues)

App crashed due to unhandled promise rejection — add process.on('unhandledRejection')
Port mismatch — app on 3001 but Nginx pointing to 3000
App bound to 0.0.0.0 but Nginx using localhost — use 127.0.0.1 everywhere
Memory exhaustion — app OOM killed, use pm2 restart --max-memory-restart 512M

Debugging production errors at 3AM shouldn't take hours. Step2Dev — paste your error, get the exact fix for your infra in 60 seconds. No generic answers.

Kubernetes Deployment Strategies: Rolling, Blue-Green, and Canary Explained

Yash — Fri, 17 Apr 2026 14:13:45 +0000

Kubernetes Deployment Strategies: Rolling, Blue-Green, and Canary Explained

When you push a new version of your app, how it gets deployed matters. The wrong strategy means downtime, or worse — breaking production for all users.

Here are the three main strategies and when to use each.

1. Rolling Deployment (Kubernetes Default)

Gradually replaces old pods with new ones. At any point, some pods run the old version and some run the new.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 4
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1    # At most 1 pod down at a time
      maxSurge: 1          # At most 1 extra pod during update
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:v2
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 10
          periodSeconds: 5

Pros: Simple, zero downtime, built-in
Cons: Both versions run simultaneously (can cause issues if DB schema changes are incompatible)
Use when: Backward-compatible changes, standard deploys

2. Blue-Green Deployment

Run two identical environments (blue = current, green = new). Switch traffic atomically when green is ready.

# Blue deployment (current)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
      version: blue
  template:
    metadata:
      labels:
        app: my-app
        version: blue
    spec:
      containers:
      - name: my-app
        image: my-app:v1
---
# Service points to blue initially
apiVersion: v1
kind: Service
metadata:
  name: my-app
spec:
  selector:
    app: my-app
    version: blue   # Switch to "green" to cut over
  ports:
  - port: 80
    targetPort: 3000

Deploy green:

kubectl apply -f green-deployment.yaml
# Wait for green to be healthy
kubectl wait --for=condition=available deployment/my-app-green --timeout=120s

# Switch traffic (edit service selector)
kubectl patch service my-app -p '{"spec":{"selector":{"version":"green"}}}'

# Verify
kubectl rollout status deployment/my-app-green

# If good: delete blue
# If bad: switch back immediately
kubectl patch service my-app -p '{"spec":{"selector":{"version":"blue"}}}'

Pros: Instant cutover, instant rollback, no mixed versions
Cons: Requires double the resources during transition
Use when: Major changes, DB migrations, when you need instant rollback

3. Canary Deployment

Route a small percentage of traffic to the new version. Gradually increase if metrics look good.

# Canary: 1 replica vs 9 stable = 10% canary traffic
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-canary
spec:
  replicas: 1   # 1 out of 10 total = 10%
  selector:
    matchLabels:
      app: my-app
      track: canary
  template:
    metadata:
      labels:
        app: my-app
        track: canary
    spec:
      containers:
      - name: my-app
        image: my-app:v2   # New version
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-stable
spec:
  replicas: 9   # 9 out of 10 = 90%
  selector:
    matchLabels:
      app: my-app
      track: stable

# Monitor canary error rate
kubectl logs -l track=canary --since=10m | grep ERROR | wc -l

# If good, increase canary replicas
kubectl scale deployment my-app-canary --replicas=5
kubectl scale deployment my-app-stable --replicas=5

# When confident: full rollout
kubectl scale deployment my-app-canary --replicas=10
kubectl scale deployment my-app-stable --replicas=0

Pros: Real production traffic testing, limits blast radius
Cons: Complex, both versions must coexist
Use when: High-risk changes, performance-sensitive updates

Quick Decision Guide

Scenario	Strategy
Normal feature deploy	Rolling
DB schema change	Blue-Green
Performance-sensitive change	Canary
Emergency hotfix	Blue-Green (fast rollback)
A/B testing	Canary

I built ARIA to solve exactly this.
Try it free at step2dev.com — no credit card needed.

How to Run a Node.js App in Production with PM2 (Complete Guide)

Yash — Fri, 03 Apr 2026 07:37:45 +0000

How to Run a Node.js App in Production with PM2 (Complete Guide)

Most Node.js tutorials end at node server.js. That's fine for development. In production, you need process management: auto-restart, logging, monitoring, and zero-downtime deploys.

PM2 handles all of this.

Install PM2

npm install -g pm2

Basic Usage

# Start your app
pm2 start server.js --name my-app

# Start with specific Node version
pm2 start server.js --name my-app --interpreter /usr/bin/node

# List running processes
pm2 list

# Monitor live
pm2 monit

# View logs
pm2 logs my-app
pm2 logs my-app --lines 100

# Restart / reload (reload = zero downtime)
pm2 restart my-app
pm2 reload my-app

# Stop / delete
pm2 stop my-app
pm2 delete my-app

The ecosystem.config.js (Use This Always)

Running PM2 from the command line works, but an ecosystem config is more powerful and reproducible:

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'api',
    script: './src/server.js',

    // Process management
    instances: 'max',           // One per CPU core (cluster mode)
    exec_mode: 'cluster',       // Enable load balancing

    // Memory management
    max_memory_restart: '512M', // Restart if memory exceeds 512MB

    // Crash recovery
    min_uptime: '30s',          // Must stay up 30s to be considered healthy
    max_restarts: 10,           // Max restarts before giving up
    restart_delay: 4000,        // Wait 4s between restarts

    // Zero-downtime deploys
    wait_ready: true,           // Wait for process.send('ready')
    listen_timeout: 10000,      // 10s to emit ready signal
    kill_timeout: 5000,         // 5s to gracefully shut down

    // Logging
    log_file: '/var/log/pm2/api.log',
    out_file: '/var/log/pm2/api-out.log',
    error_file: '/var/log/pm2/api-error.log',
    log_date_format: 'YYYY-MM-DD HH:mm:ss',
    merge_logs: true,

    // Environment
    env: {
      NODE_ENV: 'development',
      PORT: 3000
    },
    env_production: {
      NODE_ENV: 'production',
      PORT: 3000
    }
  }]
};

# Start with production env
pm2 start ecosystem.config.js --env production

# Reload zero-downtime
pm2 reload ecosystem.config.js --env production

Survive Server Reboots

# Generate startup script (run as root or with sudo)
pm2 startup

# Follow the output — it gives you a command to run
# Example output:
# [PM2] To setup the Startup Script, copy/paste the following command:
# sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ubuntu --hp /home/ubuntu

# Save current process list
pm2 save

# Verify it will restart
sudo systemctl status pm2-ubuntu  # (or your username)

Useful PM2 Commands

# Real-time dashboard
pm2 monit

# Show detailed process info
pm2 describe my-app

# Flush logs
pm2 flush my-app

# Rotate logs (set up log rotation)
pm2 install pm2-logrotate
pm2 set pm2-logrotate:max_size 50M
pm2 set pm2-logrotate:retain 7

# Reset restart count
pm2 reset my-app

# Scale up/down instances
pm2 scale my-app 4   # Set to 4 instances
pm2 scale my-app +2  # Add 2 more instances

Graceful Shutdown in Your App

// server.js
const server = app.listen(PORT, () => {
  if (process.send) process.send('ready'); // Signal PM2 we're ready
});

const shutdown = () => {
  server.close(() => {
    // Close DB connections, etc.
    process.exit(0);
  });
  // Force exit if graceful shutdown takes too long
  setTimeout(() => process.exit(1), 5000);
};

process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);

I built ARIA to solve exactly this.
Try it free at step2dev.com — no credit card needed.

How to Set Up Log Aggregation for Multiple Servers (ELK Stack Basics)

Yash — Thu, 02 Apr 2026 17:00:24 +0000

How to Set Up Log Aggregation for Multiple Servers (ELK Stack Basics)

When you have one server, tail -f /var/log/app.log works fine. When you have three servers and something goes wrong, you need to search logs across all of them simultaneously.

That's what log aggregation solves.

The Lightweight Alternative First: Loki + Grafana

Before we go full ELK, consider Loki — it's significantly lighter and integrates with Grafana (which you may already have from monitoring):

# docker-compose.yml for Loki stack
version: '3.8'
services:
  loki:
    image: grafana/loki:2.9.0
    ports:
      - "3100:3100"
    volumes:
      - loki-data:/loki

  promtail:
    image: grafana/promtail:2.9.0
    volumes:
      - /var/log:/var/log:ro
      - ./promtail-config.yml:/etc/promtail/config.yml
    command: -config.file=/etc/promtail/config.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"

volumes:
  loki-data:

# promtail-config.yml
server:
  http_listen_port: 9080

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          host: server-1
          __path__: /var/log/*.log

  - job_name: app
    static_configs:
      - targets:
          - localhost
        labels:
          job: app
          host: server-1
          __path__: /var/log/myapp/*.log

ELK Stack Setup (More Powerful)

ELK = Elasticsearch + Logstash + Kibana

Install with Docker Compose

version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ports:
      - "9200:9200"
    volumes:
      - esdata:/usr/share/elasticsearch/data

  logstash:
    image: docker.elastic.co/logstash/logstash:8.12.0
    volumes:
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    ports:
      - "5044:5044"
    depends_on:
      - elasticsearch

  kibana:
    image: docker.elastic.co/kibana/kibana:8.12.0
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      - elasticsearch

volumes:
  esdata:

Logstash Pipeline Config

# logstash.conf
input {
  beats {
    port => 5044
  }
}

filter {
  if [fields][app] == "nodejs" {
    json {
      source => "message"
    }
    date {
      match => ["timestamp", "ISO8601"]
    }
  }

  grok {
    match => { "message" => "%{COMBINEDAPACHELOG}" }
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "logs-%{+YYYY.MM.dd}"
  }
}

Install Filebeat on Each Server

# Install on each server you want to collect logs from
curl -L -O https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-8.12.0-amd64.deb
sudo dpkg -i filebeat-8.12.0-amd64.deb

sudo nano /etc/filebeat/filebeat.yml

filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/myapp/*.log
    fields:
      app: nodejs
      server: production-1

output.logstash:
  hosts: ["your-elk-server:5044"]

sudo systemctl enable filebeat
sudo systemctl start filebeat

What to Search for in Kibana

Once data is flowing, useful queries:

# All errors in last hour
level:error

# Errors from specific server
level:error AND server:production-1

# 5xx responses
response:>499

# Slow requests (>1000ms)
duration:>1000

I built ARIA to solve exactly this.
Try it free at step2dev.com — no credit card needed.

How to Set Up a Reverse Proxy with nginx for Multiple Apps on One Server

Yash — Thu, 02 Apr 2026 08:22:24 +0000

How to Set Up a Reverse Proxy with nginx for Multiple Apps on One Server

Running multiple apps on a single $5/month VPS? nginx can route traffic to each one based on the domain name.

Here's the complete setup.

The Architecture

Internet
    ↓
nginx (port 80/443)
    ├── app1.yourdomain.com  → localhost:3001
    ├── app2.yourdomain.com  → localhost:3002
    └── api.yourdomain.com   → localhost:8080

Each app runs on a different local port. nginx routes incoming requests to the right one.

Step 1: Install nginx

sudo apt update && sudo apt install nginx -y
sudo systemctl enable nginx
sudo systemctl start nginx

Step 2: Create Server Blocks

# Create config for each app
sudo nano /etc/nginx/sites-available/app1.yourdomain.com

server {
    listen 80;
    server_name app1.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}

# Enable the site
sudo ln -s /etc/nginx/sites-available/app1.yourdomain.com /etc/nginx/sites-enabled/

# Repeat for app2
sudo nano /etc/nginx/sites-available/app2.yourdomain.com
sudo ln -s /etc/nginx/sites-available/app2.yourdomain.com /etc/nginx/sites-enabled/

# Test config
sudo nginx -t

# Reload
sudo systemctl reload nginx

Step 3: Add SSL with Certbot

sudo apt install certbot python3-certbot-nginx -y

# Get certs for all your domains at once
sudo certbot --nginx -d app1.yourdomain.com -d app2.yourdomain.com -d api.yourdomain.com

# Auto-renewal
sudo systemctl enable certbot.timer

Certbot automatically updates your nginx configs to handle HTTPS and redirect HTTP → HTTPS.

Step 4: Optimize the Shared nginx Config

sudo nano /etc/nginx/nginx.conf

Add inside the http {} block:

# Gzip compression (applies to all sites)
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_types text/plain text/css text/xml application/json application/javascript application/xml+rss;

# Rate limiting zone (use in server blocks)
limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;

# Security headers (apply to all)
add_header X-Frame-Options DENY always;
add_header X-Content-Type-Options nosniff always;

# Logging
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log warn;

Step 5: Handle WebSockets (if needed)

location /socket.io/ {
    proxy_pass http://127.0.0.1:3001;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_read_timeout 86400;  # Keep connection alive for 24h
}

Useful nginx Commands

sudo nginx -t                    # Test config
sudo systemctl reload nginx      # Reload without downtime
sudo systemctl restart nginx     # Full restart
sudo nginx -T                    # Print full parsed config
sudo tail -f /var/log/nginx/error.log  # Watch errors live

I built ARIA to solve exactly this.
Try it free at step2dev.com — no credit card needed.

Terraform Basics: Manage Your Infrastructure as Code in 30 Minutes

Yash — Wed, 01 Apr 2026 17:55:19 +0000

Terraform Basics: Manage Your Infrastructure as Code in 30 Minutes

If you're still managing servers by clicking through cloud consoles — this is for you.

Terraform lets you define your entire infrastructure in code. Reproducible, version-controlled, reviewable.

Why Infrastructure as Code

Without IaC:

"I'm not sure what settings I used on the production server"
Can't recreate your setup if the server dies
No audit trail for infrastructure changes

With Terraform:

Your entire infra is a git repo
Recreate production in 10 minutes
Review infrastructure changes like code reviews

Install Terraform

# Mac
brew tap hashicorp/tap && brew install hashicorp/tap/terraform

# Ubuntu/Debian
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform

terraform --version

Your First Terraform Config (DigitalOcean Droplet)

# main.tf
terraform {
  required_providers {
    digitalocean = {
      source  = "digitalocean/digitalocean"
      version = "~> 2.0"
    }
  }
}

provider "digitalocean" {
  token = var.do_token
}

variable "do_token" {
  description = "DigitalOcean API token"
  sensitive   = true
}

resource "digitalocean_droplet" "web" {
  name   = "web-server-1"
  region = "nyc3"
  size   = "s-1vcpu-1gb"
  image  = "ubuntu-22-04-x64"

  ssh_keys = [digitalocean_ssh_key.default.fingerprint]

  tags = ["web", "production"]
}

resource "digitalocean_ssh_key" "default" {
  name       = "my-key"
  public_key = file("~/.ssh/id_ed25519.pub")
}

output "droplet_ip" {
  value = digitalocean_droplet.web.ipv4_address
}

# Initialize (downloads provider plugins)
terraform init

# Preview what will be created
terraform plan

# Apply (creates the resources)
terraform apply

# Destroy when done
terraform destroy

State Management

Terraform tracks what it's created in a state file. For teams, store state remotely:

terraform {
  backend "s3" {
    bucket = "my-terraform-state"
    key    = "production/terraform.tfstate"
    region = "us-east-1"

    # Enable state locking
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

Practical Example: Full Stack (Droplet + Firewall + Domain)

resource "digitalocean_droplet" "app" {
  name   = "app-server"
  region = "nyc3"
  size   = "s-2vcpu-2gb"
  image  = "ubuntu-22-04-x64"
  ssh_keys = [digitalocean_ssh_key.default.fingerprint]
}

resource "digitalocean_firewall" "app" {
  name = "app-firewall"
  droplet_ids = [digitalocean_droplet.app.id]

  inbound_rule {
    protocol         = "tcp"
    port_range       = "22"
    source_addresses = ["YOUR_IP/32"]  # SSH only from your IP
  }

  inbound_rule {
    protocol         = "tcp"
    port_range       = "80"
    source_addresses = ["0.0.0.0/0", "::/0"]
  }

  inbound_rule {
    protocol         = "tcp"
    port_range       = "443"
    source_addresses = ["0.0.0.0/0", "::/0"]
  }

  outbound_rule {
    protocol              = "tcp"
    port_range            = "all"
    destination_addresses = ["0.0.0.0/0", "::/0"]
  }
}

resource "digitalocean_domain" "app" {
  name       = "yourdomain.com"
  ip_address = digitalocean_droplet.app.ipv4_address
}

Essential Terraform Commands

terraform init          # Initialize project
terraform plan          # Preview changes
terraform apply         # Apply changes
terraform destroy       # Destroy all resources
terraform show          # Show current state
terraform output        # Show outputs
terraform fmt           # Format .tf files
terraform validate      # Validate config syntax

I built ARIA to solve exactly this.
Try it free at step2dev.com — no credit card needed.