ColdFusion Migration Patterns

Code Analysis & Inventory

# Download Adobe Code Analyzer
wget https://example.com/code-analyzer.zip

# Run analysis on CF 11 codebase
./code-analyzer.sh --source /var/www/myapp --target CF2018

# Review report: compatibility issues, deprecated features
# Prioritize: Critical > High > Medium > Low

Fix Compatibility Issues

<!-- Replace deprecated tags -->
<!-- OLD: <cfchart> with Flash -->
<cfchart format="flash">

<!-- NEW: Use HTML5 charting -->
<cfchart format="html">

<!-- Update authentication -->
<!-- OLD: cflogin -->
<cflogin>

<!-- NEW: Use session management -->
<cfif NOT structKeyExists(session, "authenticated")>
  <cflocation url="login.cfm">
</cfif>

Environment Setup

# Install CF 2018 on test server
sudo ./ColdFusion_2018_WWEJ_linux64.bin

# Copy application code
rsync -av /var/www/myapp/ /opt/coldfusion2018/cfusion/wwwroot/myapp/

# Configure datasources in CF Admin
# Match production settings exactly

# Test web server connector
/opt/coldfusion2018/cfusion/runtime/bin/wsconfig.sh -ws apache

Testing & Validation

• Functional testing: All user workflows
• Integration testing: External systems, APIs
• Performance testing: Load test at 150% expected load
• Security testing: Run security scan, penetration test
• UAT: User acceptance testing with stakeholders

Production Deployment

# Deployment checklist:
1. Backup current CF 11 installation
2. Backup database (full backup + transaction logs)
3. Document rollback procedure
4. Schedule maintenance window (off-peak hours)
5. Deploy CF 2018 with blue-green deployment
6. Monitor logs, error rates, performance metrics
7. Keep CF 11 running for 24h rollback window
8. Gradual traffic shift: 10% → 50% → 100%

Domain Analysis & Service Identification

• Map business capabilities and bounded contexts
• Identify loosely coupled domains (auth, payments, inventory)
• Analyze data dependencies and shared database tables
• Prioritize services: high value + low coupling first

Extract First Service (Example: Authentication)

// 1. Create REST API in monolith
component rest="true" restpath="/auth" {
  remote struct function login(required string email, required string password)
    httpmethod="POST" restpath="/login" {
    // Authentication logic
    var user = userService.authenticate(email, password);
    return {success: true, token: createJWT(user)};
  }
}

// 2. Deploy as separate CF instance on different port
// 3. Configure API Gateway routing
location /api/auth {
  proxy_pass http://auth-service:8501;
}

// 4. Update monolith to call auth service
var authResult = httpService.post("/api/auth/login", {
  email: form.email,
  password: form.password
});

Database Decomposition

-- Strategy 1: Database per Service (Preferred)
-- Extract auth tables to separate database
CREATE DATABASE auth_service;
-- Migrate users, roles, permissions tables

-- Strategy 2: Shared Database with Views (Interim)
-- Create views for service-specific data
CREATE VIEW auth_users AS
  SELECT id, email, password_hash FROM users;

-- Strategy 3: Event Sourcing for Data Sync
-- Publish events when data changes
component {
  function createUser(userData) {
    transaction {
      queryExecute("INSERT INTO users...");
      eventBus.publish("user.created", userData);
    }
  }
}

Implement Service Communication

// Synchronous REST calls
component {
  function getOrderDetails(orderId) {
    // Call inventory service
    var inventory = http.get("http://inventory-svc/api/stock/" & orderId);

    // Call payment service
    var payment = http.get("http://payment-svc/api/payment/" & orderId);

    return {order: orderData, inventory: inventory, payment: payment};
  }
}

// Asynchronous messaging (RabbitMQ)
component {
  function processOrder(orderData) {
    // Save order
    var orderId = saveOrder(orderData);

    // Publish event
    rabbitMQ.publish("orders.created", {
      orderId: orderId,
      items: orderData.items,
      customerId: orderData.customerId
    });
  }
}

Containerize Application

# Dockerfile for ColdFusion 2025
FROM adobecoldfusion/coldfusion2025:latest

# Copy application code
COPY ./app /app

# Copy custom configuration
COPY ./config/server.xml /opt/coldfusion/cfusion/runtime/conf/server.xml

# Environment variables
ENV JAVA_OPTS="-Xms4g -Xmx4g -XX:+UseG1GC"

# Expose ports
EXPOSE 8500

# Health check
HEALTHCHECK --interval=30s --timeout=10s \
  CMD curl -f http://localhost:8500/healthcheck.cfm || exit 1

# Start ColdFusion
CMD ["/opt/coldfusion/cfusion/bin/coldfusion", "start"]

Kubernetes Deployment

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: coldfusion-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: coldfusion
  template:
    metadata:
      labels:
        app: coldfusion
    spec:
      containers:
      - name: coldfusion
        image: myregistry/coldfusion-app:latest
        ports:
        - containerPort: 8500
        resources:
          requests:
            memory: "4Gi"
            cpu: "2"
          limits:
            memory: "8Gi"
            cpu: "4"
        env:
        - name: DB_HOST
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: host

Database Migration

• Option 1: AWS RDS/Azure SQL - Managed database service
• Option 2: Database containers in Kubernetes with persistent volumes
• Option 3: Hybrid - Keep on-prem DB initially, VPN connection

# Database migration steps
1. Create RDS instance matching on-prem version
2. Setup read replica from on-prem to RDS
3. Monitor replication lag (should be <1 second)
4. Cutover: Promote RDS to primary
5. Update application datasources to RDS endpoint

Session Management for Cloud

// Use Redis for distributed sessions
// Application.cfc
this.sessionManagement = true;
this.sessionStorage = "redis";
this.redis = {
  server: "redis-cluster.default.svc.cluster.local",
  port: 6379,
  password: getEnv("REDIS_PASSWORD"),
  database: 0,
  connectionPoolSize: 50
};

// Or use sticky sessions in load balancer
// NGINX Ingress annotation
metadata:
  annotations:
    nginx.ingress.kubernetes.io/affinity: "cookie"
    nginx.ingress.kubernetes.io/session-cookie-name: "cf-sticky"

Pre-Migration Audit

# Find hardcoded Windows paths
grep -r "C:\\" /var/www/myapp/
grep -r "D:\\" /var/www/myapp/

# Find case-sensitivity issues
find /var/www/myapp -name "*.cfm" | sort | uniq -di

# Check for Windows-specific functions
grep -r "createObject.*WScript" /var/www/myapp/
grep -r "COM|ActiveX" /var/www/myapp/

Code Modifications

// BAD: Hardcoded paths
filePath = "C:\uploads\files\";

// GOOD: Cross-platform
filePath = expandPath("/uploads/files/");

// BAD: Case-insensitive include
<cfinclude template="MyTemplate.cfm">

// GOOD: Match exact filename case
<cfinclude template="mytemplate.cfm">

// Replace Windows-specific COM
// OLD:
fileSystem = createObject("COM", "Scripting.FileSystemObject");

// NEW: Use CF native functions
directoryList(path, true, "query");

Linux Server Setup

# Install ColdFusion 2025 on Ubuntu 22.04
sudo ./ColdFusion_2025_WWEJ_linux64.bin

# Set proper permissions
sudo chown -R cfuser:cfuser /opt/coldfusion2025
sudo chmod -R 755 /opt/coldfusion2025/cfusion/wwwroot

# Configure Apache connector
cd /opt/coldfusion2025/cfusion/runtime/bin
sudo ./wsconfig.sh -ws apache -dir /etc/apache2 -v

# Start ColdFusion
sudo systemctl start coldfusion
sudo systemctl enable coldfusion