Install and configure Deno for web development with systemd and reverse proxy

#!/usr/bin/env bash
set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Default values
DOMAIN="${1:-localhost}"
APP_USER="deno-app"
APP_DIR="/opt/deno-app"
SERVICE_NAME="deno-app"

# Usage
usage() {
    echo "Usage: $0 [domain]"
    echo "Example: $0 example.com"
    exit 1
}

# Error handling
cleanup() {
    echo -e "${RED}[ERROR] Installation failed. Cleaning up...${NC}"
    systemctl stop "$SERVICE_NAME" 2>/dev/null || true
    systemctl disable "$SERVICE_NAME" 2>/dev/null || true
    rm -f "/etc/systemd/system/$SERVICE_NAME.service"
    userdel "$APP_USER" 2>/dev/null || true
    rm -rf "$APP_DIR"
    rm -f /usr/local/bin/deno
}

trap cleanup ERR

log() {
    echo -e "${GREEN}$1${NC}"
}

warn() {
    echo -e "${YELLOW}$1${NC}"
}

error() {
    echo -e "${RED}$1${NC}"
    exit 1
}

# Check if running as root or with sudo
if [[ $EUID -ne 0 ]]; then
    error "This script must be run as root or with sudo"
fi

# Detect OS
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update && apt upgrade -y"
            PKG_INSTALL="apt install -y"
            NGINX_CONF_DIR="/etc/nginx/sites-available"
            NGINX_ENABLED_DIR="/etc/nginx/sites-enabled"
            FIREWALL_CMD="ufw"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            NGINX_CONF_DIR="/etc/nginx/conf.d"
            NGINX_ENABLED_DIR=""
            FIREWALL_CMD="firewall-cmd"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            NGINX_CONF_DIR="/etc/nginx/conf.d"
            NGINX_ENABLED_DIR=""
            FIREWALL_CMD="firewall-cmd"
            ;;
        *)
            error "Unsupported distribution: $ID"
            ;;
    esac
else
    error "Cannot detect OS distribution"
fi

log "[1/12] Updating system packages..."
$PKG_UPDATE

log "[2/12] Installing required dependencies..."
$PKG_INSTALL curl unzip nginx

log "[3/12] Installing Deno runtime..."
# Install Deno to temporary location first
export DENO_INSTALL="/tmp/deno_install"
curl -fsSL https://deno.land/x/install/install.sh | sh

# Copy to system location
cp "$DENO_INSTALL/bin/deno" /usr/local/bin/
chmod 755 /usr/local/bin/deno
rm -rf "$DENO_INSTALL"

log "[4/12] Verifying Deno installation..."
/usr/local/bin/deno --version

log "[5/12] Creating application user..."
if ! id "$APP_USER" &>/dev/null; then
    useradd --system --shell /usr/sbin/nologin --home "$APP_DIR" --create-home "$APP_USER"
fi

log "[6/12] Setting up application directory..."
mkdir -p "$APP_DIR"
chown -R "$APP_USER:$APP_USER" "$APP_DIR"
chmod 755 "$APP_DIR"

log "[7/12] Creating Deno web application..."
cat > "$APP_DIR/server.ts" << 'EOF'
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

const port = parseInt(Deno.env.get("PORT") || "8000");
const hostname = Deno.env.get("HOSTNAME") || "127.0.0.1";

const handler = (request: Request): Response => {
  const url = new URL(request.url);
  
  if (url.pathname === "/") {
    return new Response(JSON.stringify({
      message: "Hello from Deno!",
      timestamp: new Date().toISOString(),
      version: Deno.version.deno
    }), {
      headers: { "content-type": "application/json" },
    });
  }
  
  if (url.pathname === "/health") {
    return new Response(JSON.stringify({ status: "healthy" }), {
      headers: { "content-type": "application/json" },
    });
  }
  
  return new Response("Not Found", { status: 404 });
};

console.log(`HTTP server running on http://${hostname}:${port}`);
await serve(handler, { hostname, port });
EOF

chown "$APP_USER:$APP_USER" "$APP_DIR/server.ts"
chmod 644 "$APP_DIR/server.ts"

log "[8/12] Creating systemd service..."
cat > "/etc/systemd/system/$SERVICE_NAME.service" << EOF
[Unit]
Description=Deno Web Application
After=network.target
Wants=network.target

[Service]
Type=simple
User=$APP_USER
Group=$APP_USER
WorkingDirectory=$APP_DIR
ExecStart=/usr/local/bin/deno run --allow-net --allow-env server.ts
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal
Environment=PORT=8000
Environment=HOSTNAME=127.0.0.1

[Install]
WantedBy=multi-user.target
EOF

chmod 644 "/etc/systemd/system/$SERVICE_NAME.service"

log "[9/12] Starting and enabling Deno service..."
systemctl daemon-reload
systemctl enable "$SERVICE_NAME"
systemctl start "$SERVICE_NAME"

log "[10/12] Configuring Nginx reverse proxy..."
if [ "$NGINX_ENABLED_DIR" ]; then
    # Debian/Ubuntu style
    NGINX_CONF="$NGINX_CONF_DIR/$DOMAIN"
    cat > "$NGINX_CONF" << EOF
server {
    listen 80;
    server_name $DOMAIN;

    location / {
        proxy_pass http://127.0.0.1:8000;
        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;
    }
}
EOF
    ln -sf "$NGINX_CONF" "$NGINX_ENABLED_DIR/"
else
    # RHEL/CentOS style
    cat > "$NGINX_CONF_DIR/$DOMAIN.conf" << EOF
server {
    listen 80;
    server_name $DOMAIN;

    location / {
        proxy_pass http://127.0.0.1:8000;
        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;
    }
}
EOF
fi

# Test and start Nginx
nginx -t
systemctl enable nginx
systemctl restart nginx

log "[11/12] Configuring firewall..."
case "$FIREWALL_CMD" in
    "ufw")
        ufw --force enable
        ufw allow 'Nginx Full'
        ufw allow ssh
        ;;
    "firewall-cmd")
        systemctl enable firewalld
        systemctl start firewalld
        firewall-cmd --permanent --add-service=http
        firewall-cmd --permanent --add-service=https
        firewall-cmd --reload
        ;;
esac

log "[12/12] Verifying installation..."
sleep 5

if systemctl is-active --quiet "$SERVICE_NAME"; then
    log "✓ Deno service is running"
else
    error "✗ Deno service is not running"
fi

if systemctl is-active --quiet nginx; then
    log "✓ Nginx is running"
else
    error "✗ Nginx is not running"
fi

# Test application
if curl -f -s http://127.0.0.1:8000/health > /dev/null; then
    log "✓ Deno application is responding"
else
    error "✗ Deno application is not responding"
fi

trap - ERR

log ""
log "🎉 Installation completed successfully!"
log ""
log "Your Deno application is now running at:"
log "  Local: http://127.0.0.1:8000"
log "  Domain: http://$DOMAIN"
log ""
log "Service management commands:"
log "  sudo systemctl status $SERVICE_NAME"
log "  sudo systemctl restart $SERVICE_NAME"
log "  sudo journalctl -f -u $SERVICE_NAME"
log ""
warn "Next steps:"
warn "1. Configure your DNS to point $DOMAIN to this server"
warn "2. Install SSL certificate (recommend using certbot)"
warn "3. Update your application code in $APP_DIR/server.ts"