Deploy Express

This guide will help you deploy an Express.js application to Deployxa.

Overview

Express.js is a fast, unopinionated, minimalist web framework for Node.js. Deployxa provides optimized deployments for Express applications with automatic configuration.

Features:

• Automatic framework detection
• Node.js 18+ support
• MongoDB, PostgreSQL, MySQL support
• Automatic HTTPS
• Global CDN
• Zero configuration

Prerequisites

• An Express.js application
• A GitHub repository with your code
• A Deployxa account

Quick Start

1. Create Your Express App

If you don't have an Express app yet:

mkdir my-express-app
cd my-express-app
npm init -y
npm install express

Create server.js:

const express = require('express');
const app = express();
const port = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Hello, Deployxa!');
});

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

2. Update package.json

{
  "name": "my-express-app",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

3. Push to GitHub

git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/yourusername/my-express-app.git
git push -u origin main

4. Deploy to Deployxa

1. Go to Deployxa Dashboard
2. Click "New Project"
3. Select your GitHub repository
4. Deployxa will automatically detect Express
5. Click "Deploy"

Your app will be live in under 30 seconds!

Configuration

Detected Settings

Deployxa automatically detects these settings:

Setting	Value
Framework	Express
Build Command	npm install
Output Directory	.
Start Command	npm start
Port	3000

Custom Configuration

If you need to customize settings:

1. Go to Project → Settings → Build
2. Modify settings as needed
3. Save changes

Example Custom Settings:

{
  "buildCommand": "npm ci",
  "startCommand": "node server.js"
}

Environment Variables

Adding Environment Variables

1. Go to Project → Environment
2. Click "Add Variable"
3. Enter key and value
4. Click "Save"

Common Express Environment Variables:

NODE_ENV=production
PORT=3000
SECRET_KEY=your-secret-key-here

# Database (optional)
DATABASE_URL=mongodb://user:pass@host:27017/dbname
MONGODB_URI=mongodb://user:pass@host:27017/dbname

# API Keys
API_KEY=your-api-key
JWT_SECRET=your-jwt-secret

Using Environment Variables

In your Express app:

const express = require('express');
const app = express();

const port = process.env.PORT || 3000;
const secretKey = process.env.SECRET_KEY;

app.get('/', (req, res) => {
  res.send('Hello, Deployxa!');
});

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

Database Configuration

Using MongoDB

npm install mongoose

const mongoose = require('mongoose');

mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {
  console.log('Connected to MongoDB');
});

Using PostgreSQL

npm install pg

const { Pool } = require('pg');

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

pool.query('SELECT NOW()', (err, res) => {
  if (err) {
    console.error('Error connecting to PostgreSQL', err);
  } else {
    console.log('Connected to PostgreSQL');
  }
});

Using MySQL

npm install mysql2

const mysql = require('mysql2');

const connection = mysql.createConnection(process.env.DATABASE_URL);

connection.connect((err) => {
  if (err) {
    console.error('Error connecting to MySQL', err);
  } else {
    console.log('Connected to MySQL');
  }
});

Custom Domains

Adding a Custom Domain

1. Go to Project → Domains
2. Click "Add Domain"
3. Enter your domain (e.g., example.com)
4. Configure DNS records
5. Wait for verification

DNS Configuration

For Apex Domain (example.com):

Type: A
Name: @
Value: 76.76.21.21

For Subdomain (www.example.com):

Type: CNAME
Name: www
Value: cname.deployxa.com

Performance Optimization

Enable Clustering

Use Node.js clustering for better performance:

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  const express = require('express');
  const app = express();
  
  app.get('/', (req, res) => {
    res.send('Hello, Deployxa!');
  });
  
  app.listen(process.env.PORT || 3000);
}

Enable Compression

npm install compression

const compression = require('compression');
app.use(compression());

Enable Caching

Use Redis for caching:

npm install redis

const redis = require('redis');
const client = redis.createClient(process.env.REDIS_URL);

app.get('/data', async (req, res) => {
  const cachedData = await client.get('data');
  if (cachedData) {
    return res.json(JSON.parse(cachedData));
  }
  
  const data = await fetchData();
  await client.setEx('data', 3600, JSON.stringify(data));
  res.json(data);
});

Monitoring

Viewing Logs

1. Go to Project → Logs
2. Select log type:
   • Build Logs: Deployment process
   • Runtime Logs: Application output
   • Error Logs: Application errors

Express Logging

Use Morgan for HTTP logging:

npm install morgan

const morgan = require('morgan');
app.use(morgan('combined'));

Monitoring Metrics

1. Go to Project → Analytics
2. View metrics:
   • Request count
   • Response times
   • Error rates
   • Bandwidth usage
   • CPU/RAM usage

Health Checks

Deployxa automatically monitors your application:

• HTTP health checks every 30 seconds
• Automatic restart on failure
• Alerts on consecutive failures

Add a health check endpoint:

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

Troubleshooting

Application Crashes on Start

Problem: Application crashes immediately

Solution:

1. Check runtime logs for errors
2. Verify environment variables
3. Check for missing dependencies
4. Ensure server.js exists and is correct
5. Check PORT configuration

Database Connection Failed

Problem: Cannot connect to database

Solution:

1. Verify DATABASE_URL is correct
2. Check database host and port
3. Ensure database exists
4. Check firewall rules
5. Verify database credentials

Module Not Found

Problem: Cannot find module 'express'

Solution:

1. Check package.json has the dependency
2. Run npm install locally
3. Commit and push changes
4. Redeploy

Slow Response Times

Problem: Application responds slowly

Solution:

1. Enable clustering
2. Enable compression
3. Use caching
4. Optimize database queries
5. Upgrade plan for more resources

Port Already in Use

Problem: Error: listen EADDRINUSE

Solution:

• Deployxa automatically handles port configuration
• Ensure your code uses process.env.PORT or defaults to 3000

Best Practices

Project Structure

my-express-app/
├── server.js
├── package.json
├── .env.example
├── routes/
│   └── index.js
├── models/
│   └── user.js
├── middleware/
│   └── auth.js
└── README.md

Environment Variables

• Never commit .env file
• Use .env.example as template
• Rotate secrets regularly
• Use different values per environment

Security

• Keep dependencies updated
• Use HTTPS only
• Validate all inputs
• Use parameterized queries
• Enable CORS properly
• Use helmet for security headers
• Implement rate limiting

Performance

• Enable clustering
• Use compression
• Implement caching
• Optimize database queries
• Use connection pooling
• Enable keep-alive

Database

• Use connection pooling
• Index frequently queried columns
• Use transactions for complex operations
• Backup database regularly
• Use ORM for complex queries

Advanced Configuration

Custom Server Configuration

const express = require('express');
const helmet = require('helmet');
const cors = require('cors');
const rateLimit = require('express-rate-limit');

const app = express();

// Security
app.use(helmet());
app.use(cors());

// Rate limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100
});
app.use(limiter);

// Body parsing
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api', require('./routes'));

// Error handling
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something broke!' });
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

RESTful API Structure

// routes/users.js
const express = require('express');
const router = express.Router();
const User = require('../models/user');

router.get('/', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

router.get('/:id', async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);
});

router.post('/', async (req, res) => {
  const user = new User(req.body);
  await user.save();
  res.status(201).json(user);
});

router.put('/:id', async (req, res) => {
  const user = await User.findByIdAndUpdate(req.params.id, req.body);
  res.json(user);
});

router.delete('/:id', async (req, res) => {
  await User.findByIdAndDelete(req.params.id);
  res.status(204).send();
});

module.exports = router;

Middleware

// middleware/auth.js
const jwt = require('jsonwebtoken');

module.exports = function(req, res, next) {
  const token = req.header('Authorization')?.replace('Bearer ', '');
  
  if (!token) {
    return res.status(401).json({ error: 'No token provided' });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

Examples

Basic Express App

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello, Deployxa!');
});

app.listen(process.env.PORT || 3000);

REST API

const express = require('express');
const app = express();

app.use(express.json());

let items = [];

app.get('/api/items', (req, res) => {
  res.json(items);
});

app.post('/api/items', (req, res) => {
  const item = req.body;
  items.push(item);
  res.status(201).json(item);
});

app.listen(process.env.PORT || 3000);

With Database

const express = require('express');
const mongoose = require('express');
const app = express();

app.use(express.json());

const UserSchema = new mongoose.Schema({
  name: String,
  email: String
});

const User = mongoose.model('User', UserSchema);

app.get('/users', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

app.post('/users', async (req, res) => {
  const user = new User(req.body);
  await user.save();
  res.status(201).json(user);
});

mongoose.connect(process.env.MONGODB_URI);
app.listen(process.env.PORT || 3000);

Related Topics

• Deploy NestJS
• Deploy Next.js
• Deploy Node.js
• Environment Variables
• Custom Domains
• Monitoring

Resources

• Express Documentation
• Node.js Documentation
• Deployxa CLI
• API Reference
• Community Discord

---

Need Help? Contact support@deployxa.com or join our community Discord.