Posted 5 days ago by Vanessa

Leap.New has revolutionized the way we build and deploy modern web applications with its AI-powered development platform. In this comprehensive guide, we’ll walk through the process of deploying a Leap.New application on a Ramnode VPS running Ubuntu 24 or higher, ensuring optimal performance and security.

Prerequisites

Before we begin, make sure you have:

  • A Ramnode VPS with Ubuntu 24.04 LTS or higher
  • SSH access to your server with sudo privileges
  • A domain name pointed to your VPS IP address
  • A Leap.New application ready for deployment
  • Basic familiarity with command line operations

Initial Server Setup

Connect to Your VPS

First, connect to your Ramnode VPS via SSH:

ssh root@your-server-ip

Update the System

Always start by updating your Ubuntu system:

apt update && apt upgrade -y

Create a Non-Root User

For security purposes, create a dedicated user for your application:

adduser leapapp
usermod -aG sudo leapapp

Switch to the new user:

su - leapapp

Install Required Dependencies

Install Node.js and npm

Leap.New applications typically require Node.js. Install the latest LTS version:

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

Verify the installation:

node --version
npm --version

Install Git

If not already installed:

sudo apt install git -y

Install PM2 (Process Manager)

PM2 will help manage your application processes:

sudo npm install -g pm2

Configure Firewall

Set up UFW (Uncomplicated Firewall) to secure your server:

sudo ufw enable
sudo ufw allow ssh
sudo ufw allow 80
sudo ufw allow 443
sudo ufw status

Install and Configure Nginx

Install Nginx

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

Create Nginx Configuration

Create a new configuration file for your Leap.New application:

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

Add the following configuration (replace your-domain.com with your actual domain):

server {
    listen 80;
    server_name your-domain.com www.your-domain.com;

    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;
    }
}

Enable the site:

sudo ln -s /etc/nginx/sites-available/leapapp /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Deploy Your Leap.New Application

Clone Your Application

Navigate to your home directory and clone your Leap.New application:

cd ~
git clone https://github.com/yourusername/your-leap-app.git
cd your-leap-app

Install Dependencies

Install all required npm packages:

npm install

Configure Environment Variables

Create a .env file with your production environment variables:

nano .env

Add your environment variables:

NODE_ENV=production
PORT=3000
DATABASE_URL=your_database_url
API_KEY=your_api_key
# Add other Leap.New specific variables

Build the Application

If your Leap.New application requires a build step:

npm run build

Set Up SSL with Let’s Encrypt

Install Certbot

sudo apt install certbot python3-certbot-nginx -y

Obtain SSL Certificate

sudo certbot --nginx -d your-domain.com -d www.your-domain.com

Follow the prompts to complete the SSL setup. Certbot will automatically update your Nginx configuration.

Start Your Application with PM2

Create PM2 Ecosystem File

Create a PM2 configuration file:

nano ecosystem.config.js

Add the following configuration:

module.exports = {
  apps: [{
    name: 'leap-app',
    script: 'npm',
    args: 'start',
    cwd: '/home/leapapp/your-leap-app',
    env: {
      NODE_ENV: 'production',
      PORT: 3000
    },
    instances: 'max',
    exec_mode: 'cluster',
    watch: false,
    max_memory_restart: '1G',
    error_file: './logs/err.log',
    out_file: './logs/out.log',
    log_file: './logs/combined.log',
    time: true
  }]
}

Start the Application

mkdir logs
pm2 start ecosystem.config.js
pm2 save
pm2 startup

Follow the instructions provided by the startup command to enable PM2 to start on system boot.

Database Setup (if required)

If your Leap.New application requires a database, install and configure it:

For PostgreSQL:

sudo apt install postgresql postgresql-contrib -y
sudo systemctl start postgresql
sudo systemctl enable postgresql

# Create database and user
sudo -u postgres psql
CREATE DATABASE leapapp_db;
CREATE USER leapapp_user WITH PASSWORD 'secure_password';
GRANT ALL PRIVILEGES ON DATABASE leapapp_db TO leapapp_user;
\q

For MongoDB:

wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo apt-key add -
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
sudo apt update
sudo apt install -y mongodb-org
sudo systemctl start mongod
sudo systemctl enable mongod

Monitoring and Maintenance

Set Up Log Rotation

Create a logrotate configuration:

sudo nano /etc/logrotate.d/leapapp

Add:

/home/leapapp/your-leap-app/logs/*.log {
    daily
    missingok
    rotate 52
    compress
    notifempty
    create 644 leapapp leapapp
    postrotate
        pm2 reloadLogs
    endscript
}

Monitor Application Health

Use PM2’s monitoring features:

pm2 monit
pm2 logs leap-app
pm2 status

Set Up Automated Backups

Create a backup script:

nano ~/backup.sh

Add:

#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/home/leapapp/backups"
APP_DIR="/home/leapapp/your-leap-app"

mkdir -p $BACKUP_DIR

# Backup application files
tar -czf $BACKUP_DIR/app_backup_$DATE.tar.gz -C $APP_DIR .

# If using PostgreSQL
pg_dump -U leapapp_user -h localhost leapapp_db > $BACKUP_DIR/db_backup_$DATE.sql

# Keep only last 7 backups
find $BACKUP_DIR -name "*.tar.gz" -mtime +7 -delete
find $BACKUP_DIR -name "*.sql" -mtime +7 -delete

Make it executable and add to crontab:

chmod +x ~/backup.sh
crontab -e
# Add: 0 2 * * * /home/leapapp/backup.sh

Performance Optimization

Enable Gzip Compression in Nginx

Edit your Nginx configuration:

sudo nano /etc/nginx/nginx.conf

Uncomment and configure gzip settings:

gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_proxied expired no-cache no-store private must-revalidate auth;
gzip_types text/plain text/css text/xml text/javascript application/javascript application/xml+rss application/json;

Configure Nginx Caching

Add caching headers to your server block:

location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
    expires 1M;
    add_header Cache-Control "public, immutable";
}

Optimize Node.js Performance

Set NODE_ENV to production in your PM2 configuration and consider using:

// In your ecosystem.config.js
node_args: ['--max-old-space-size=2048']

Troubleshooting Common Issues

Application Not Starting

  1. Check PM2 logs: pm2 logs leap-app
  2. Verify environment variables are set correctly
  3. Ensure all dependencies are installed: npm install
  4. Check file permissions

Nginx 502 Bad Gateway

  1. Verify your application is running: pm2 status
  2. Check if the correct port is specified in Nginx config
  3. Review Nginx error logs: sudo tail -f /var/log/nginx/error.log

SSL Certificate Issues

  1. Verify domain DNS records
  2. Check firewall allows ports 80 and 443
  3. Renew certificate if expired: sudo certbot renew

Security Best Practices

  1. Regular Updates: Keep Ubuntu, Node.js, and all packages updated
  2. Fail2Ban: Install fail2ban to prevent brute force attacks
  3. SSH Key Authentication: Disable password authentication for SSH
  4. Firewall Rules: Only allow necessary ports
  5. Regular Backups: Automate backups and test restore procedures
  6. Monitor Logs: Set up log monitoring and alerts

Conclusion

Deploying a Leap.New application on a Ramnode VPS with Ubuntu 24+ provides you with full control over your hosting environment while leveraging the power of AI-driven development. This setup ensures your application runs efficiently, securely, and can scale as your needs grow.

Remember to regularly monitor your application’s performance, keep your system updated, and maintain proper backups. With this foundation in place, your Leap.New application will be well-positioned to serve your users reliably.

For additional support, consult the Leap.New documentation and the vibrant community forums where developers share their deployment experiences and solutions to common challenges.