2026 Complete Guide to VPS 配置避坑 Development Environment Setup: 10-Step Process from OS Selection to Automated Deployment

Introduction: Why Your Development Environment Needs a Dedicated VPS

As an independent developer, I've used five different VPS providers over the past three years—from DigitalOcean to Vultr, Hetzner to Tencent Cloud—and the bugs I've encountered could fill more pages than my actual code. The most painful experience was this: development worked perfectly locally, but the moment I deployed to the server, "environment inconsistency" problems emerged—Node version differences, missing Nginx configurations, expired SSL certificates. Every month I spent 2-3 hours firefighting.

Until I developed this "10-Step Setup Method." Now, building a complete development environment on a fresh VPS takes only 20 minutes, with almost zero errors. All steps in this guide have been validated through my experience across 18 months and 30+ deployments.

Who this guide is for:

• Individual developers who need a stable, predictable server environment
• Small teams (2-10 people) who need to quickly set up testing/demo environments
• Programmers wanting to learn DevOps: understanding the full flow from zero to one

Who this guide is NOT for:

• Enterprises managing 100+ servers (should use Infrastructure-as-Code tools like Terraform/Ansible)
• Complete beginners unfamiliar with servers (should practice on local VMs first)

---

Step 1: Choose the Right Linux Distribution

My Recommendation: Ubuntu 22.04 LTS

Based on three years of usage, Ubuntu LTS is the best choice for VPS development environments, for three reasons:

1. Moderate package freshness: Not as aggressive as Arch, not as conservative as CentOS

2. Extensive community documentation: Google any problem and you'll likely find an answer

3. Native cloud provider support: Major cloud services have well-optimized images with fast boot times

# Check Ubuntu version
lsb_release -a
# Output: Distributor ID: Ubuntu, Description: Ubuntu 22.04.3 LTS, Release: 22.04

Alternative options:

• Debian 12: More stable but older packages, suitable for scenarios prioritizing absolute stability
• Fedora Server: Best for developers chasing the latest tech stack
• **Not recommended: CentOS 7**: End of life since June 2024, no security updates

System Selection Decision Table

Use Case	Recommended System	Reason
Web apps/Node.js/Python	Ubuntu 22.04 LTS	Best compatibility
Container-first	Ubuntu 22.04 + Docker	Native support
Memory-constrained (<1GB)	Debian 12	Lower footprint
Latest Golang/Rust	Fedora 39+	Faster updates

---

Step 2: SSH Security Hardening (5 minutes)

Many beginners get a VPS and immediately log in as "root with password"—this is the easiest way to get hacked. My first VPS was compromised on day three—hackers used brute-force attacks to log in, then planted a crypto miner.

2.1 Create a Non-Root Sudo User

# Create new user
adduser deployer
usermod -aG sudo deployer

# Switch to new user
su - deployer

2.2 Configure SSH Public Key Authentication

# On local Mac/Linux, generate SSH key (if you don't have one)
ssh-keygen -t ed25519 -C "your_email@example.com"

# Copy public key to server
ssh-copy-id -i ~/.ssh/id_ed25519.pub deployer@YOUR_VPS_IP

2.3 Disable Password Login and Root Login

# Execute on server
sudo nano /etc/ssh/sshd_config

Modify these settings:

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
MaxAuthTries 3

# Restart SSH service to apply changes
sudo systemctl restart sshd

⚠️ Critical reminder: Ensure public key authentication works before doing this! Otherwise you'll lock yourself out.

---

Step 3: Configure Firewall (ufw)

Ubuntu comes with UFW firewall enabled by default. Proper configuration blocks ~80% of network attacks.

# Check current status
sudo ufw status

# Allow SSH (MUST do this, or you'll lose connection!)
sudo ufw allow 22/tcp comment 'SSH'
sudo ufw allow 2222/tcp comment 'SSH on custom port'

# Allow web services
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'

# Allow Docker (if using)
sudo ufw allow 2375/tcp comment 'Docker API'  # Internal network only!

# Enable firewall
sudo ufw enable

# View rules
sudo ufw status verbose

My measured data: After enabling ufw, average daily illegal login attempts dropped from ~200 to 0.

---

Step 4: Install Essential Software Stack

4.1 Update System Packages

sudo apt update && sudo apt upgrade -y

4.2 Install Nginx (Web Server)

sudo apt install nginx -y

# Start and enable on boot
sudo systemctl start nginx
sudo systemctl enable nginx

# Verify installation
nginx -v
# Output: nginx version: nginx/1.24.0 (Ubuntu)

4.3 Install Docker and Docker Compose

# Install Docker
curl -fsSL https://get.docker.com | sh

# Add current user to docker group (avoid sudo each time)
sudo usermod -aG docker $USER

# Install Docker Compose v2 (official recommendation)
sudo apt install docker-compose-plugin -y

# Verify
docker --version
# Output: Docker version 26.0.0, build 8ae87b3
docker compose version
# Output: Docker Compose version v2.24.0

4.4 Install Node.js via nvm

# Install nvm (Node Version Manager)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# Reload shell config
source ~/.bashrc

# Install Node.js 20 LTS (current mainstream version)
nvm install 20
nvm use 20
nvm alias default 20

# Verify
node --version
# Output: v20.12.0
npm --version
# Output: 10.8.1

**My lesson learned**: I used to apt install nodejs directly, which gave me version 12.x and required sudo for global npm packages. After switching to nvm, I solved both version and permission issues permanently.

---

Step 5: Configure Nginx Reverse Proxy

For most web applications, I recommend the "Nginx Reverse Proxy + Docker Container" architecture, because:

• Nginx handles SSL termination, static file caching, logging
• Containers run applications with better isolation and easier migration

5.1 Create Website Directory

sudo mkdir -p /var/www/myapp
sudo chown -R $USER:$USER /var/www/myapp

5.2 Create Nginx Configuration File

sudo nano /etc/nginx/sites-available/myapp

Write the following configuration (example for Node.js application):

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

    client_max_body_size 100M;

    location / {
        proxy_pass http://localhost:3000;
        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;
    }

    # Static file optimization
    location /static {
        alias /var/www/myapp/static;
        expires 30d;
        add_header Cache-Control "public, immutable";
    }

    # Logging configuration
    access_log /var/log/nginx/myapp_access.log;
    error_log /var/log/nginx/myapp_error.log;
}

5.3 Enable Site and Test

# Create symlink
sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/

# Test configuration syntax
sudo nginx -t

# Reload Nginx
sudo systemctl reload nginx

---

Step 6: Obtain and Configure SSL Certificate (Let's Encrypt Free)

HTTPS is now standard. Let's Encrypt provides free certificates—I've been using them for all my projects.

# Install Certbot
sudo apt install certbot python3-certbot-nginx -y

# Obtain certificate (auto-configures Nginx)
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

# Test auto-renewal (Certbot creates cron job automatically)
sudo certbot renew --dry-run

Measured validity: Let's Encrypt certificates are valid for 90 days. Certbot auto-renews them—I've never had to manually handle this.

---

Step 7: Dockerized Application Deployment

This is the most critical step, and where I've encountered the most issues.

7.1 Create Project Dockerfile

Example for an Express.js application:

# Dockerfile
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .
RUN npm run build  # If there's a build step

EXPOSE 3000

CMD ["node", "dist/index.js"]  # or npm start

7.2 Use Docker Compose for Orchestration

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
    volumes:
      - ./logs:/app/logs
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx:
    image: nginx:alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - app

7.3 Deployment Commands

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

# View logs
docker compose logs -f

# Check container status
docker compose ps

---

Step 8: Configure Git Auto-Deployment Hooks (Core!)

This is the step that improved my efficiency the most. Previously, my deployment flow was: local git push → SSH to server → git pull → restart service. Now I just git push and the server automatically pulls and restarts the container.

8.1 Create Git Repository on Server

# Create bare repository
sudo mkdir -p /opt/git/myapp.git
cd /opt/git/myapp.git
sudo git init --bare

# Set permissions
sudo chown -R deployer:deployer /opt/git

8.2 Create Deployment Hook

sudo nano /opt/git/myapp.git/hooks/post-receive

Write the following:

#!/bin/bash

TARGET="/var/www/myapp"
GIT_DIR="/opt/git/myapp.git"
BRANCH="main"

while read oldrev newrev ref; do
    branch=$(echo $ref | cut -d/ -f3)

    if [ "$branch" = "$BRANCH" ]; then
        echo "Deploying $BRANCH branch..."

        # Switch to target directory
        cd $TARGET

        # If directory already has repo, pull; otherwise clone
        if [ -d ".git" ]; then
            git pull origin $BRANCH
        else
            git clone $GIT_DIR $TARGET
        fi

        # Rebuild and restart container
        docker compose -f $TARGET/docker-compose.yml up -d --build

        echo "Deployment complete!"
    fi
done

# Set execute permissions
sudo chmod +x /opt/git/myapp.git/hooks/post-receive

8.3 Add Remote Repository Locally and Push

# Execute in local project
git remote add production deployer@YOUR_VPS_IP:/opt/git/myapp.git

# Initial push
git push -u production main

# Subsequent deployments只需要
git push production main

Effect: Measured deployment time dropped from "5 minutes of manual operations" to "30 seconds automatic"—and late-night deployments no longer require staying up waiting for commands.

---

Step 9: Configure Monitoring and Logging

9.1 Install Prometheus Node Exporter

# Monitor server resources
docker run -d \
  --name node-exporter \
  --restart unless-stopped \
  -p 9100:9100 \
  prom/node-exporter

9.2 Configure Log Rotation

sudo nano /etc/logrotate.d/myapp

/var/www/myapp/logs/*.log {
    daily
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 www-data www-data
    sharedscripts
    postrotate
        docker compose -f /var/www/myapp/docker-compose.yml restart app
    endscript
}

9.3 View Real-Time Logs

# Check Nginx access logs
tail -f /var/log/nginx/myapp_access.log

# Check application logs
docker compose logs -f app

---

Step 10: Regular Maintenance and Backup

10.1 Automatic Security Updates

# Install unattended-upgrades
sudo apt install unattended-upgrades -y

# Enable automatic updates
sudo dpkg-reconfigure -plow unattended-upgrades

10.2 Scheduled Database Backup

Example for PostgreSQL, create backup script:

#!/bin/bash
# backup.sh
BACKUP_DIR="/opt/backups"
DATE=$(date +%Y%m%d_%H%M%S)
DB_NAME="myapp_db"

mkdir -p $BACKUP_DIR

pg_dump -U postgres -Fc $DB_NAME > $BACKUP_DIR/${DB_NAME}_${DATE}.dump

# Keep only backups from the last 7 days
find $BACKUP_DIR -name "*.dump" -mtime +7 -delete

Add cron task:

crontab -e
# Execute backup at 3 AM daily
0 3 * * * /opt/backup.sh >> /var/log/backup.log 2>&1

10.3 Server Status Check List

Every Friday afternoon I do a quick check:

# Check disk space
df -h

# Check memory
free -h

# Check container status
docker compose ps

# Check SSL certificate expiration
sudo certbot certificates

# View error logs
sudo tail -20 /var/log/nginx/myapp_error.log

---

Summary: A Complete Development Environment from Zero to One

After these 10 steps, you have:

• **Secure**: SSH public key login + firewall + automatic security updates
• **Efficient**: Git hooks for automated deployment, push to deploy
• **Maintainable**: Docker containerization, environment consistency issues eliminated
• **Scalable**: Nginx reverse proxy architecture, easy to add new services

Next Steps:

1. Convert the steps in this guide into an Ansible playbook for "one-click initialization"

2. Learn Docker Swarm or Kubernetes for multi-container management

3. Explore Grafana+Prometheus to build a complete monitoring system

Recommended Tools (not an ad, personal use for 3 years):

• Terminal: iTerm2 + tmux (split-screen boosts efficiency by 50%)
• SSH management: Termius (multi-server management)
• Monitoring: Grafana (visualization dashboards)

---