Railway: Platform App Hosting Modern

# Install Railway CLI (macOS/Linux/Windows via npm)
npm install -g @railway/cli

# Atau gunakan npx
npx @railway/cli --version

# Install via Homebrew (macOS)
brew install railway

# Install via script (Linux/macOS)
curl -fsSL https://railway.app/install.sh | sh

# Login ke Railway
railway login

# Atau login via token (untuk CI/CD)
railway login --token "my-railway-token"

# Verifikasi login
railway whoami

# Inisialisasi project baru
railway init

# Link ke project yang sudah ada
railway link

# Buat project baru dari CLI
railway init

# Atau buat dari template
railway init --template "express-postgres"

# Deploy langsung
railway up

# Cek status
railway status

# Lihat logs
railway logs

# Buka di browser
railway open

// server.js — Simple Express app
const express = require('express');
const app = express();

const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.json({
    message: 'Hello from Railway!',
    env: process.env.NODE_ENV || 'development',
    timestamp: new Date().toISOString(),
  });
});

app.get('/health', (req, res) => {
  res.json({ status: 'healthy' });
});

app.listen(PORT, '0.0.0.0', () => {
  console.log(`Server running on port ${PORT}`);
});

{
  "name": "my-railway-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "dependencies": {
    "express": "^4.18.2",
    "pg": "^8.12.0"
  },
  "engines": {
    "node": ">=18.0.0"
  }
}

# app.py — Flask app
import os
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({
        'message': 'Hello from Railway!',
        'python_version': os.sys.version,
        'env': os.environ.get('FLASK_ENV', 'development'),
    })

@app.route('/health')
def health():
    return jsonify({'status': 'healthy'})

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port)

# requirements.txt
flask==3.0.0
gunicorn==21.2.0
psycopg2-binary==2.9.9

# Procfile (opsional — Railway detect dari start script)
# web: gunicorn app:app --bind 0.0.0.0:$PORT

# Dockerfile untuk Railway
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine
WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force
COPY --from=builder /app/dist ./dist

ENV NODE_ENV=production
EXPOSE ${PORT:-3000}

# Railway akan set PORT secara otomatis
CMD ["node", "dist/server.js"]

# railway.toml — Konfigurasi Railway (opsional)
[build]
builder = "DOCKERFILE"
dockerfilePath = "Dockerfile"

[deploy]
startCommand = "node dist/server.js"
healthcheckPath = "/health"
healthcheckTimeout = 300
restartPolicyType = "ON_FAILURE"
restartPolicyMaxRetries = 3

# === DEPLOY DATABASE VIA CLI ===

# Deploy PostgreSQL
railway add --database postgres

# Deploy MySQL
railway add --database mysql

# Deploy Redis
railway add --database redis

# Deploy MongoDB
railway add --database mongodb

# Railway akan otomatis:
# 1. Provision database
# 2. Set environment variables:
#    - DATABASE_URL (untuk PostgreSQL)
#    - MYSQL_URL (untuk MySQL)
#    - REDIS_URL (untuk Redis)
#    - MONGO_URL (untuk MongoDB)
# 3. Buat private networking antara services

# Connect ke database via Railway CLI
railway connect postgres

# Lihat environment variables yang ter-set
railway variables

// Koneksi PostgreSQL di Node.js
const { Pool } = require('pg');

// Railway otomatis set DATABASE_URL
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  ssl: process.env.NODE_ENV === 'production'
    ? { rejectUnauthorized: false }
    : false,
});

// Contoh penggunaan
async function getUsers() {
  const result = await pool.query('SELECT * FROM users');
  return result.rows;
}

async function createUser(name, email) {
  const result = await pool.query(
    'INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *',
    [name, email]
  );
  return result.rows[0];
}

// Koneksi Redis
const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);

async function getCachedUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);

  const user = await getUserFromDB(id);
  await redis.set(`user:${id}`, JSON.stringify(user), 'EX', 3600);
  return user;
}

# === ENVIRONMENT VARIABLES VIA CLI ===

# Set variabel untuk service saat ini
railway variables set NODE_ENV=production
railway variables set API_KEY=my-secret-key
railway variables set CORS_ORIGIN=https://mydomain.com

# Set beberapa sekaligus
railway variables set \
  NODE_ENV=production \
  LOG_LEVEL=info \
  SESSION_SECRET=my-session-secret

# List semua variabel
railway variables

# Get nilai variabel spesifik
railway variables get NODE_ENV

# Delete variabel
railway variables delete API_KEY

# Set variabel untuk service tertentu (jika multi-service)
railway variables set REDIS_URL=redis://... --service my-redis-service

# Import dari .env file
railway variables set --from-dotenv .env.production

# Set variabel sebagai secret (tidak terlihat di dashboard)
railway variables set DATABASE_URL="postgres://..."

# Railway otomatis membuat variabel untuk setiap service:
# PRIVATE_URL — URL internal (tidak exposed ke internet)
# PUBLIC_URL  — URL publik (jika service punya public domain)

# Contoh environment variables otomatis:
# DATABASE_URL=postgres://postgres:password@postgres.railway.internal:5432/railway
# REDIS_URL=redis://default:password@redis.railway.internal:6379
# SERVICE_PRIVATE_URL=http://my-app.railway.internal:8080

# Menggunakan private URL di kode:
# PostgreSQL → process.env.DATABASE_URL
# Redis → process.env.REDIS_URL

# Variabel Railway yang tersedia otomatis:
# RAILWAY_STATIC_URL — Static URL
# RAILWAY_PUBLIC_DOMAIN — Custom domain (jika diset)
# RAILWAY_GIT_COMMIT_SHA — Commit hash
# RAILWAY_GIT_BRANCH — Branch name
# RAILWAY_ENVIRONMENT_NAME — Nama environment
# RAILWAY_PROJECT_NAME — Nama project
# RAILWAY_SERVICE_NAME — Nama service

# Deploy template via CLI
railway init --template "express-postgres"

# Atau deploy template tertentu
railway init --template "strapi"

# Di Railway Dashboard:
# 1. Klik "New Project"
# 2. Pilih "Templates"
# 3. Cari template yang diinginkan
# 4. Klik "Deploy"
# 5. Railway akan deploy semua services

{
  "$schema": "https://railway.app/template.schema.json",
  "name": "My Full Stack App",
  "description": "Full stack app dengan Next.js dan PostgreSQL",
  "keywords": ["nextjs", "postgres", "prisma"],
  "services": {
    "web": {
      "source": {
        "repo": "github.com/myuser/my-app"
      },
      "variables": {
        "NODE_ENV": "production",
        "DATABASE_URL": "${{Postgres.DATABASE_URL}}"
      },
      "startCommand": "npm start",
      "healthcheckPath": "/api/health"
    },
    "postgres": {
      "source": {
        "image": "postgres:16"
      },
      "variables": {
        "POSTGRES_PASSWORD": "${{generate(32)}}",
        "POSTGRES_DB": "myapp"
      }
    }
  }
}

# Railway mendukung horizontal scaling (replicas)
# Di Railway Dashboard:
# Service → Settings → Scaling → Replicas

# Set replicas via railway.toml
[deploy]
numReplicas = 3

# Atau di Railway Dashboard:
# Service → Settings → Horizontal Scaling → Instances: 3

# Railway akan:
# 1. Menjalankan 3 instances dari service Anda
# 2. Load balance traffic antar instances
# 3. Setiap instance mendapatkan environment variables yang sama

# railway.toml — Restart Policy
[deploy]
# Restart jika crash
restartPolicyType = "ON_FAILURE"
restartPolicyMaxRetries = 5

# Atau selalu restart
# restartPolicyType = "ALWAYS"

# Jangan restart (manual)
# restartPolicyType = "NEVER"

# Tambah custom domain via Railway Dashboard:
# Service → Settings → Domains → Custom Domain
# Masukkan domain: myapp.example.com

# DNS Configuration:
# Type  | Name  | Value
# CNAME | myapp | my-service-production.up.railway.app

# Atau untuk apex domain (root domain):
# Type  | Name | Value
# A     | @    | (IP dari Railway — lihat dashboard)
# AAAA  | @    | (IPv6 dari Railway)

# Atau gunakan railway domain (otomatis)
# Format: my-service-production.up.railway.app

# Atau generate random domain
# Service → Settings → Domains → Generate Domain

# HTTPS otomatis dikonfigurasi oleh Railway
# Let's Encrypt certificate di-provision otomatis

Struktur Monorepo:
├── apps/
│   ├── web/                    ← Frontend (Next.js)
│   │   ├── package.json
│   │   └── Dockerfile
│   ├── api/                    ← Backend (Express)
│   │   ├── package.json
│   │   └── Dockerfile
│   └── worker/                 ← Background Worker
│       ├── package.json
│       └── Dockerfile
├── packages/
│   └── shared/                 ← Shared library
├── railway.toml
└── package.json (root)

# Railway Configuration untuk monorepo:
# Di Railway Dashboard, set "Root Directory" untuk setiap service:
# Service "web"    → Root Directory: apps/web
# Service "api"    → Root Directory: apps/api
# Service "worker" → Root Directory: apps/worker

# Deploy monorepo services via CLI
# Link ke service tertentu
railway link --service web
railway up

# Switch ke service lain
railway link --service api
railway up

# Atau deploy dari subdirectory
cd apps/api && railway up