Production Deployment

Architecture Overview
Deployment Options
Container-Based Deployment
Platform-as-a-Service
Traditional VPS
Environment Variables
Database Configuration
Authentication (Auth0)
Cloudinary (Image Storage)
Email Configuration
Application Settings
Optional Configuration
Security Best Practices
1. Database Security
2. Application Security
3. API Security
4. Secrets Management
Database Setup
PostgreSQL with PostGIS
Database Migrations
Backend Deployment
Building the Application
Container Orchestration
Kubernetes Deployment Example
Docker Compose Production
Performance Optimization
JVM Tuning
Database Connection Pooling
Caching Strategy
Monitoring and Logging
Health Checks
Logging Configuration
Monitoring Tools
Backup and Recovery
Database Backups
Application State
Scaling Considerations
Horizontal Scaling
Database Scaling
Load Balancing
Deployment Checklist
Troubleshooting
Application Won’t Start
Database Connection Issues
Performance Issues
Next Steps

This guide covers production deployment considerations for the Hub platform, including infrastructure setup, security configurations, and performance optimizations.

Architecture Overview

The Hub platform consists of:

Backend: Spring Boot 3 application (Java 21)
Frontend: Next.js application
Database: PostgreSQL 16 with PostGIS extension
Auth: Auth0 OAuth2/JWT authentication
Storage: Cloudinary for image uploads
Email: SMTP-based email service

Deployment Options

Container-Based Deployment

Recommended for cloud platforms and Kubernetes:

AWS ECS/Fargate
Google Cloud Run
Azure Container Instances
Kubernetes (EKS, GKE, AKS)
Docker Swarm

Platform-as-a-Service

Managed platforms for simplified deployment:

Heroku
Render
Railway
Fly.io

Traditional VPS

For custom infrastructure:

DigitalOcean Droplets
AWS EC2
Linode
Hetzner Cloud

Environment Variables

All required environment variables for production:

Database Configuration

DB_HOST=your-database-host
DB_PORT=5432
DB_NAME=hub_production
DB_USER=hub_user
DB_PASSWORD=your-secure-password
DB_SSL_MODE=require

Always use DB_SSL_MODE=require in production to encrypt database connections.

Authentication (Auth0)

AUTH0_ISSUER=https://your-domain.auth0.com/
AUTH0_AUDIENCE=your-api-audience

Configure Auth0 callback URLs to match your production domain.

Cloudinary (Image Storage)

CLOUDINARY_CLOUD_NAME=your-cloud-name
CLOUDINARY_API_KEY=your-api-key
CLOUDINARY_API_SECRET=your-api-secret

Email Configuration

APP_ADMIN_EMAIL=admin@yourdomain.com
BREVO_API_KEY=your-brevo-api-key
APP_MAIL_FROM=noreply@yourdomain.com

Application Settings

APP_FRONTEND_URL=https://yourdomain.com
BACKEND_PORT=8080
SWAGGER_ENABLED=false

Disable Swagger in production by setting SWAGGER_ENABLED=false to prevent API documentation exposure.

Optional Configuration

# Booking settings
booking.payment-hold-duration=5m

# Database connection pooling
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5

Security Best Practices

1. Database Security

Enable SSL connections

Set DB_SSL_MODE=require to enforce encrypted connections.

application.yaml

spring:
  datasource:
    url: jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}?sslmode=require

Use strong credentials

Generate complex passwords (minimum 32 characters)
Use different credentials for each environment
Rotate passwords periodically

Restrict network access

Configure database firewall rules
Only allow connections from application servers
Use VPC or private networking when possible

2. Application Security

Never expose sensitive environment variables in logs or error messages.

Required configurations:

application.yaml

# Disable auto-commit for transaction control
spring:
  datasource:
    hikari:
      auto-commit: false

# Validate database schema
jpa:
  hibernate:
    ddl-auto: validate

# Minimal health endpoint exposure
management:
  endpoint:
    health:
      show-details: never

3. API Security

Disable Swagger: Set SWAGGER_ENABLED=false
Configure CORS: Restrict frontend origins
Rate limiting: Implement API rate limits
JWT validation: Verify Auth0 tokens properly

4. Secrets Management

Recommended approaches:

aws secretsmanager get-secret-value \
  --secret-id hub/production/db-password \
  --query SecretString \
  --output text

Database Setup

PostgreSQL with PostGIS

Provision managed database

Use a managed PostgreSQL service:

AWS RDS for PostgreSQL
Google Cloud SQL
Azure Database for PostgreSQL
DigitalOcean Managed Databases
Supabase

Enable PostGIS extension

CREATE EXTENSION IF NOT EXISTS postgis;

Create application user

CREATE USER hub_user WITH PASSWORD 'your-secure-password';
GRANT ALL PRIVILEGES ON DATABASE hub_production TO hub_user;

Configure connection pooling

Adjust Hikari pool settings based on your load:

spring:
  datasource:
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000

Database Migrations

The application uses Flyway for schema management:

application.yaml

spring:
  flyway:
    enabled: true
    locations: classpath:db/migration

Migrations run automatically on application startup. Ensure proper backup before deploying schema changes.

Backend Deployment

Building the Application

Build the JAR file

cd backend
./mvnw clean package -DskipTests

The compiled JAR will be in target/backend-*.jar

Build Docker image

docker build -t hub-backend:latest ./backend

Or with version tag:

docker build -t hub-backend:1.0.0 ./backend

Push to container registry

docker tag hub-backend:latest yourusername/hub-backend:latest
docker push yourusername/hub-backend:latest

Container Orchestration

Kubernetes Deployment Example

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hub-backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hub-backend
  template:
    metadata:
      labels:
        app: hub-backend
    spec:
      containers:
      - name: backend
        image: hub-backend:latest
        ports:
        - containerPort: 8080
        env:
        - name: DB_HOST
          valueFrom:
            secretKeyRef:
              name: hub-secrets
              key: db-host
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: hub-secrets
              key: db-password
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 5

Docker Compose Production

docker-compose.prod.yml

services:
  backend:
    image: hub-backend:latest
    restart: always
    environment:
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_NAME=${DB_NAME}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_SSL_MODE=require
      - SWAGGER_ENABLED=false
    ports:
      - "8080:8080"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

Performance Optimization

JVM Tuning

Optimize Java runtime for production:

ENTRYPOINT ["java", \
  "-XX:+UseG1GC", \
  "-XX:MaxRAMPercentage=75.0", \
  "-XX:+UseStringDeduplication", \
  "-Djava.security.egd=file:/dev/./urandom", \
  "-jar", "app.jar"]

Database Connection Pooling

spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 10
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      leak-detection-threshold: 60000

Caching Strategy

Consider implementing:

Redis for session storage
Application-level caching with Caffeine
HTTP caching headers for static resources

Monitoring and Logging

Health Checks

The application exposes health endpoints:

management:
  endpoints:
    web:
      exposure:
        include: health,info
  endpoint:
    health:
      show-details: never

Endpoints:

GET /actuator/health - Application health status
GET /actuator/info - Application information

Logging Configuration

Structured logging for production:

logging:
  level:
    root: INFO
    com.hub: INFO
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%X{traceId}] %logger{36} - %msg%n"

The application includes trace IDs in logs for distributed tracing.

Monitoring Tools

Backup and Recovery

Database Backups

Configure automated backups

Enable automated backups in your managed database service (daily recommended).

Test backup restoration

Regularly test backup restoration to a staging environment.

Implement point-in-time recovery

Enable transaction log backups for point-in-time recovery capability.

Application State

User uploads: Backed up automatically by Cloudinary
Configuration: Store in version control
Secrets: Backed up by secrets management service

Scaling Considerations

Horizontal Scaling

The backend is stateless and can be scaled horizontally:

Kubernetes

kubectl scale deployment hub-backend --replicas=5

Database Scaling

Options for database scaling:

Vertical: Increase instance size
Read replicas: For read-heavy workloads
Connection pooling: PgBouncer for connection management

Load Balancing

Recommended load balancers:

AWS Application Load Balancer
Google Cloud Load Balancing
Nginx
Traefik

Deployment Checklist

Before deploying to production:

Troubleshooting

Application Won’t Start

Check environment variables are set:
```
env | grep -E 'DB_|AUTH0_|CLOUDINARY_'
```

Verify database connectivity:

psql "postgresql://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}?sslmode=require"

Check application logs for specific errors

Database Connection Issues

Verify SSL mode matches database configuration
Check firewall rules allow application IP
Confirm credentials are correct
Test network connectivity to database host

Performance Issues

Review database query performance
Check connection pool settings
Monitor JVM memory usage
Analyze application logs for slow requests

Next Steps

Docker Setup

⌘I

Getting Started

Backend

Frontend

Deployment

​Architecture Overview

​Deployment Options

​Container-Based Deployment

​Platform-as-a-Service

​Traditional VPS

​Environment Variables

​Database Configuration

​Authentication (Auth0)

​Cloudinary (Image Storage)

​Email Configuration

​Application Settings

​Optional Configuration

​Security Best Practices

​1. Database Security

​2. Application Security

​3. API Security

​4. Secrets Management

​Database Setup

​PostgreSQL with PostGIS

​Database Migrations

​Backend Deployment

​Building the Application

​Container Orchestration

​Kubernetes Deployment Example

​Docker Compose Production

​Performance Optimization

​JVM Tuning

​Database Connection Pooling

​Caching Strategy

​Monitoring and Logging

​Health Checks

​Logging Configuration

​Monitoring Tools

​Backup and Recovery

​Database Backups

​Application State

​Scaling Considerations

​Horizontal Scaling

​Database Scaling

​Load Balancing

​Deployment Checklist

​Troubleshooting

​Application Won’t Start

​Database Connection Issues

​Performance Issues

​Next Steps

Architecture Overview

Deployment Options

Container-Based Deployment

Platform-as-a-Service

Traditional VPS

Environment Variables

Database Configuration

Authentication (Auth0)

Cloudinary (Image Storage)

Email Configuration

Application Settings

Optional Configuration

Security Best Practices

1. Database Security

2. Application Security

3. API Security

4. Secrets Management

Database Setup

PostgreSQL with PostGIS

Database Migrations

Backend Deployment

Building the Application

Container Orchestration

Kubernetes Deployment Example

Docker Compose Production

Performance Optimization

JVM Tuning

Database Connection Pooling

Caching Strategy

Monitoring and Logging

Health Checks

Logging Configuration

Monitoring Tools

Backup and Recovery

Database Backups

Application State

Scaling Considerations

Horizontal Scaling

Database Scaling

Load Balancing

Deployment Checklist

Troubleshooting

Application Won’t Start

Database Connection Issues

Performance Issues

Next Steps