Deployment Guide

Production deployment strategies and infrastructure configuration

Deployment Options

🖥️

Local Server

On-premise deployment with local infrastructure

• Windows/Linux server deployment
• Microsoft Dynamic SL integration
• Standalone Power BI Desktop/Pro
• Local PostgreSQL database
• AI Engine Server (GPU optional)
• Full data sovereignty & control

☁️

Microsoft Azure

Cloud deployment on Microsoft Azure for Dynamics 365 integration

• Azure App Service for RPA platform
• Native Dynamics 365 connectivity
• Azure SQL Database / PostgreSQL
• Azure Cache for Redis
• Power BI Premium integration

▲

Vercel

Fast deployment for Next.js RPA platform frontend

• Instant deployment from GitHub
• Global CDN with edge functions
• Automatic HTTPS and SSL
• Preview deployments for testing
• Zero-config Next.js optimization

🔶

Oracle Cloud

Alternative deployment for Oracle Finance integration

• Oracle Cloud Infrastructure (OCI)
• Native Oracle Finance connectivity
• Oracle Autonomous Database
• OCI Container Engine
• Oracle Analytics Cloud

Local Server Deployment Architecture

On-premise deployment option for organizations requiring full data sovereignty, air-gapped environments, or integration with existing local infrastructure.

Server Components

• RPA Application Server - Node.js runtime
• PostgreSQL Database - Transactional data storage
• Redis Server - Queue management & caching
• Microsoft Dynamic SL - ERP integration
• AI Engine Server - Computer vision & NLP processing

Analytics & Reporting

• Power BI Desktop - Local report development
• Power BI Pro - Team collaboration (optional)
• Direct Query - Connect to PostgreSQL
• Scheduled Refresh - Automated data updates
• Custom Dashboards - Tailored analytics

AI Engine Server Specifications

CPU-Based (Budget Option)

• Intel Xeon or AMD EPYC processor
• 16+ CPU cores recommended
• 32GB+ RAM for TensorFlow.js
• Suitable for light workloads

GPU-Accelerated (Performance)

• NVIDIA GPU with CUDA support
• 8GB+ VRAM (e.g., RTX 3060, A4000)
• 10x faster AI processing
• Recommended for production

Minimum Hardware Requirements

Starter Tier

• 4 CPU cores
• 16GB RAM
• 500GB SSD
• 1Gbps network

Professional Tier

• 8 CPU cores
• 32GB RAM
• 1TB SSD
• 10Gbps network

Enterprise Tier

• 16+ CPU cores
• 64GB+ RAM
• 2TB+ NVMe SSD
• 10Gbps+ network

Docker Deployment

Dockerfile

# Multi-stage build for optimization
FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./
COPY tsconfig.json ./

# Install dependencies
RUN npm ci --only=production

# Copy source code
COPY . .

# Build Next.js application
RUN npm run build

# Production image
FROM node:18-alpine AS runner

WORKDIR /app

# Create non-root user
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

# Copy built application
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static

# Set ownership
RUN chown -R nextjs:nodejs /app

# Switch to non-root user
USER nextjs

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js || exit 1

# Start application
CMD ["node", "server.js"]

docker-compose.yml

version: '3.8'

services:
  # Next.js Application
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - ENCRYPTION_MASTER_KEY=${ENCRYPTION_MASTER_KEY}
    depends_on:
      - postgres
      - redis
    restart: unless-stopped
    networks:
      - rpa-network

  # WebSocket Server
  websocket:
    build:
      context: .
      dockerfile: Dockerfile.websocket
    ports:
      - "3001:3001"
    environment:
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    depends_on:
      - redis
    restart: unless-stopped
    networks:
      - rpa-network

  # Extraction Worker
  worker:
    build:
      context: .
      dockerfile: Dockerfile.worker
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - ENCRYPTION_MASTER_KEY=${ENCRYPTION_MASTER_KEY}
    depends_on:
      - postgres
      - redis
    restart: unless-stopped
    deploy:
      replicas: 3
    networks:
      - rpa-network

  # PostgreSQL Database
  postgres:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=rpa_user
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=rpa_platform
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - rpa-network

  # Redis Cache & Queue
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    restart: unless-stopped
    networks:
      - rpa-network

volumes:
  postgres-data:
  redis-data:

networks:
  rpa-network:
    driver: bridge

Build & Run

# Build images
docker-compose build

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f app

# Scale workers
docker-compose up -d --scale worker=5

# Stop all services
docker-compose down

# Clean up volumes
docker-compose down -v

Kubernetes Deployment

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rpa-platform
  labels:
    app: rpa-platform
spec:
  replicas: 3
  selector:
    matchLabels:
      app: rpa-platform
  template:
    metadata:
      labels:
        app: rpa-platform
    spec:
      containers:
      - name: app
        image: gcr.io/project-id/rpa-platform:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: rpa-secrets
              key: database-url
        - name: REDIS_HOST
          value: "redis-service"
        - name: ENCRYPTION_MASTER_KEY
          valueFrom:
            secretKeyRef:
              name: rpa-secrets
              key: encryption-key
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"
        livenessProbe:
          httpGet:
            path: /api/health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /api/ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: rpa-platform-service
spec:
  selector:
    app: rpa-platform
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: rpa-platform-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: rpa-platform
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Deploy to Kubernetes

# Create namespace
kubectl create namespace rpa-platform

# Create secrets
kubectl create secret generic rpa-secrets \
  --from-literal=database-url="postgresql://..." \
  --from-literal=encryption-key="..." \
  -n rpa-platform

# Apply configurations
kubectl apply -f k8s/deployment.yaml -n rpa-platform
kubectl apply -f k8s/service.yaml -n rpa-platform
kubectl apply -f k8s/ingress.yaml -n rpa-platform

# Check deployment status
kubectl get pods -n rpa-platform
kubectl get services -n rpa-platform

# View logs
kubectl logs -f deployment/rpa-platform -n rpa-platform

# Scale deployment
kubectl scale deployment/rpa-platform --replicas=5 -n rpa-platform

# Rolling update
kubectl set image deployment/rpa-platform \
  app=gcr.io/project-id/rpa-platform:v2.0.0 \
  -n rpa-platform

# Rollback if needed
kubectl rollout undo deployment/rpa-platform -n rpa-platform

Monitoring & Observability

Application Monitoring

• Request/response times
• Error rates and stack traces
• API endpoint performance
• WebSocket connection metrics
• Job execution statistics

Infrastructure Metrics

• CPU and memory utilization
• Disk I/O and storage usage
• Network throughput
• Database connection pools
• Redis queue depths

Business Metrics

• Jobs scheduled/completed
• Data extraction volumes
• Pipeline success rates
• SLA compliance tracking
• Cost per transaction

Recommended Tools

• Datadog

• New Relic

• Sentry

• Prometheus

• Grafana

• ELK Stack

• CloudWatch

• PagerDuty

🤖 RPA Automation Platform