Contents show

Overview

The ColdFusion Backup & Restore Runbook (PDF) is a practical, field-tested guide that documents exactly how to safeguard, export, and recover your Adobe ColdFusion or Lucee servers—covering code, Configuration, datasources, packages, SSL keystores, and Scheduled tasks. It bundles standardized procedures, checklists, and scripts so your team can meet reliability targets, reduce downtime, and pass audits with confidence. Whether you manage a single production host or a multi-node cluster, this runbook helps you achieve a repeatable, automated, and verifiable backup strategy.

What You’ll Get

A comprehensive PDF runbook outlining:
- Step-by-step backup and restore workflows for Adobe ColdFusion and Lucee.
- Environment-specific guidance for Windows, Linux, Docker/containers, and cloud VMs.
- Disaster recovery (DR) planning tips for RPO/RTO, offsite storage, and encryption.
Reusable templates:
- Backup policy template (retention, frequency, scope).
- DR validation Checklist and quarterly test plan.
- Change log and runbook acceptance forms for auditors.
Code examples and scripts:
- Linux Bash scripts for filesystem, config, and database backups.
- Windows PowerShell scripts for archives and integrity checks.
- Optional integrations for cfsetup (Adobe CF 2021/2023), CAR files (older Adobe CF), and cfconfig (Lucee/CommandBox).
Quick-reference diagrams:
- What to back up in CFAdmin/Lucee.
- Data flow from webroot to offsite object storage (S3/Azure Blob/GCS).
Troubleshooting section:
- Common restore pitfalls and how to verify integrity post-restore.

Supported Environments

Adobe ColdFusion

Adobe ColdFusion 2018, 2021, 2023
Install types: Standalone, JEE, Docker images
Configuration options: cfsetup (2021/2023), CAR files (2018+), Admin API

Lucee

Lucee 5 and 6
Lucee server and web contexts (server.xml, lucee-server, lucee-web)
Optional: cfconfig for export/import

Operating Systems

Windows Server 2016/2019/2022
RHEL/CentOS/AlmaLinux/Rocky Linux, Ubuntu/Debian, Amazon Linux

Databases (examples)

MySQL/MariaDB, PostgreSQL, Microsoft SQL Server, Oracle

How to Download

Locate the “Download PDF” button or link provided with this article.
Click to download and save the file to a secure folder (e.g., a team SharePoint or versioned documentation repository).
Optional but recommended: verify the file’s integrity with a provided checksum (SHA-256) if available.
Distribute to your operations, DevOps, and development teams; store a copy in your DR documentation portal.

If you cannot find the download option, contact your platform admin or request access via your internal documentation channel.

How to Use the Runbook

Prerequisites

Administrative access to your ColdFusion or Lucee servers.
Access to your database servers and credentials with backup privileges.
Storage target for backups (NAS, S3, Azure Blob, GCS, or secure file share).
Scheduled task capability (Windows Task Scheduler, systemd timers, Jenkins, GitLab CI, or similar).

Quick Start

Read the Scope and Policy section to define your backup frequency, retention, and encryption Standards.
Customize the included templates (Backup Policy, DR Checklist) with your environment details.
Implement the provided scripts, adjusting paths, service names, and DB tools for your stack.
Schedule backups and test an initial restore to validate the full path end-to-end.
Document the results, sign off the runbook, and set quarterly restore drills.

Step-by-Step Backup Procedures

1) Filesystem and Code

Back up the webroot, Custom tags, CFML libraries, and application config files.
Include JVM options (jvm.config), ColdFusion instance directories, logs, and keystores.

Example directories:

Adobe CF: cfusion/bin, cfusion/lib, cfusion/wwwroot (if used), ColdFusionHome/cfusion/jetty etc.
Lucee: lucee-server/context, lucee-web context folders, webroot(s).

2) ColdFusion/Lucee Configuration

Adobe CF 2021/2023: use cfsetup to export Admin config.
Adobe CF 2018+: create CAR files from CFAdmin or use Admin API.
Lucee: export server/web context (and optionally use cfconfig for structured exports).

3) Database Backups

Use native tools:
- MySQL/MariaDB: mysqldump
- PostgreSQL: pg_dump
- SQL Server: sqlcmd/Backup-SqlDatabase
- Oracle: expdp/impdp
Store DB dumps alongside app backups; encrypt when containing sensitive data.

4) Certificates and Keystores

Export or copy JVM keystore (cacerts or custom keystore), truststores, and any PFX/JKS files used by HTTPS or outbound TLS.

5) Integrity and Offsite Copy

Compute checksum (SHA-256) for each archive.
Copy to offsite storage with lifecycle policies and versioning enabled.

Example Scripts

Linux Bash – Backup (Adobe CF or Lucee)

Note: run as a user with appropriate read permissions and DB backup privileges.

!/usr/bin/env bash

set -euo pipefail

TS=”$(date +%Y%m%d-%H%M%S)”
BACKUP_ROOT=”/var/backups/coldfusion”
CF_HOME=”/opt/coldfusion/cfusion” # adjust for your install
WEBROOT=”/var/www/myapp” # adjust for your app
DB_TYPE=”mysql” # mysql|postgres|mssql|oracle
DB_NAME=”mydb”
DB_USER=”backup_user”
DB_HOST=”127.0.0.1″
DB_PORT=”3306″

mkdir -p “${BACKUP_ROOT}/${TS}”

1) Filesystem

tar -czf “${BACKUP_ROOT}/${TS}/webroot.tgz” -C “${WEBROOT}” .
tar -czf “${BACKUP_ROOT}/${TS}/cf_home.tgz” -C “${CF_HOME}” .

2) Config export (Adobe CF 2021/2023 example with cfsetup)

if command -v cfsetup >/dev/null 2>&1; then
cfsetup export “${BACKUP_ROOT}/${TS}/cf-admin-export.json” || echo “cfsetup export skipped”
fi

3) Database

case “${DB_TYPE}” in
mysql)
mysqldump -h “${DB_HOST}” -P “${DB_PORT}” -u “${DB_USER}” -p”${DB_PASS:-}” –routines –triggers “${DB_NAME}” \

“${BACKUP_ROOT}/${TS}/db-${DB_NAME}.sql”
;;
postgres)
PGPASSWORD=”${DB_PASS:-}” pg_dump -h “${DB_HOST}” -p “${DB_PORT}” -U “${DB_USER}” -F p “${DB_NAME}” \
“${BACKUP_ROOT}/${TS}/db-${DB_NAME}.sql”
;;
esac

4) Checksums

(cd “${BACKUP_ROOT}/${TS}” && sha256sum * > SHA256SUMS.txt)

echo “Backup complete: ${BACKUP_ROOT}/${TS}”

Security tip: provide DB_PASS via environment variables or a secure secrets manager; avoid hardcoding.

Windows PowerShell – Backup (Zip + Checksum)

$ts = Get-Date -Format “yyyyMMdd-HHmmss”
$backupRoot = “D:\Backups\ColdFusion\$ts”
$cfHome = “C:\ColdFusion\cfusion”
$webroot = “C:\inetpub\wwwroot\myapp”

New-Item -ItemType Directory -Force -Path $backupRoot | Out-Null

Compress-Archive -Path “$webroot*” -DestinationPath “$backupRoot\webroot.zip”
Compress-Archive -Path “$cfHome*” -DestinationPath “$backupRoot\cf_home.zip”

Optional: cfsetup export (Adobe CF 2021/2023) if installed and in PATH

try { cfsetup export “$backupRoot\cf-admin-export.json” } catch { Write-Host “cfsetup export skipped” }

Checksums

Get-ChildItem $backupRoot | ForEach-Object {
$hash = Get-FileHash $.FullName -Algorithm SHA256
“$($hash.Hash) $($.Name)” | Out-File -FilePath “$backupRoot\SHA256SUMS.txt” -Append -Encoding ascii
}

Write-Host “Backup complete: $backupRoot”

Step-by-Step Restore Procedures

Prepare Target
- Provision a clean server or instance with matching OS and CF/Lucee version and JVM version.
- Install required packages (mysqldump/pg_restore, java) as needed.
Stop Services
- Stop the ColdFusion/Lucee service to avoid file locks and partial restore.
Restore Filesystem
- Extract webroot and CF home archives to their original paths.
- Validate permissions and ownership (Linux: chown/chmod; Windows: NTFS ACLs).
Restore Configuration
- Adobe CF 2021/2023: cfsetup import json-file.
- Adobe CF (older): import CAR file via CFAdmin or use Admin API.
- Lucee: restore server/web context folders or import via cfconfig if used.
Restore Database
- MySQL/MariaDB: mysql < db.sql
- PostgreSQL: psql < db.sql or use pg_restore for custom formats
- SQL Server/Oracle: use platform-native restore tools.
Certificates
- Import keystores/truststores; update jvm.config if paths changed.
Start Services and Verify
- Start ColdFusion/Lucee; confirm instance starts without errors.
- Verify datasources, CFML endpoints, Scheduled tasks, mail, and external integrations.
- Compare checksums/logs; run smoke tests and a validation checklist.
Post-Restore Hardening
- Rotate passwords/keys if the restore crossed environments.
- Re-enable monitoring, APM agents, and scheduled jobs.

Automation and Scheduling

Windows Task Scheduler: run PowerShell backup script daily; enable “Run whether user is logged on or not” and “Run with highest privileges.”
Linux systemd timers or cron: schedule Bash backups; direct logs to journald or a log file with logrotate.
CI/CD: Jenkins or GitLab CI pipelines to trigger backups before deployments, and automated test restores on staging.
Cloud storage sync: rclone, AWS CLI, azcopy, or gsutil for encrypted, versioned offsite copies.

Best practices

Define clear RPO/RTO targets and align backup frequency accordingly.
Encrypt at rest and in transit; use KMS-managed keys wherever possible.
Keep secrets out of scripts; use environment variables or a secrets manager.
Apply retention and immutability (Object Lock/WORM) for Compliance.
Test restores quarterly; document outcomes and continuously improve.
Standardize naming: app-env-YYYYMMDD-HHMM, with checksums and metadata.
Monitor backups: alert on failures; verify integrity with periodic checksum audits.
Separate duties: back up from a service account with least privilege.
For containers: persist volumes for stateful data; rebuild images from Dockerfiles; back up mounted volumes and externalized configs.

Benefits and Use Cases

Faster recovery: a repeatable runbook reduces Mean Time To Restore and human error under pressure.
Compliance-ready: templates and checklists streamline audits (SOX, ISO 27001, SOC 2).
Portability: supports Adobe ColdFusion and Lucee, Windows and Linux, VMs and containers.
Team Onboarding: new engineers can follow clear procedures rather than tribal knowledge.
Use cases:
- Migrating to new servers or cloud regions with minimal risk.
- Pre-Deployment snapshots before major releases.
- Quarterly DR exercises for regulated environments.
- Hybrid setups where database and app nodes are backed up in tandem.

Key Takeaways

Back up code, configuration, datasources, keystores, and databases—don’t rely on any single layer.
Automate backups and test restores regularly to validate your entire recovery path.
Use cfsetup/CAR files (Adobe CF) or context exports/cfconfig (Lucee) for structured config backups.
Secure your backups with encryption, offsite replication, and integrity checks.
Keep the runbook current; treat it as a living document aligned to your RPO/RTO.

FAQ

How is this runbook different from a generic server backup guide?

It focuses specifically on ColdFusion and Lucee components—CFAdmin settings, datasources, scheduled tasks, JVM options, and CFML application areas—along with sample scripts and concrete restore validations that generic guides rarely cover.

Do I need downtime to perform backups?

File-level backups can often run online, but certain configuration exports or DB dumps may require brief Maintenance windows for consistency. For strict zero-downtime goals, consider replicas, snapshots, and application quiescing strategies documented in the runbook.

Can I use this with Dockerized ColdFusion/Lucee?

Yes. The runbook explains how to rebuild images from Dockerfiles and back up persistent volumes, environment configs, and externalized secrets. It also covers storing container manifests and versioned configuration exports.

What if I’m on Adobe ColdFusion 2018 or earlier?

Use CAR files via CFAdmin or Admin API for configuration captures. The runbook includes alternative steps when cfsetup is unavailable.

How often should I test restores?

Quarterly is a strong baseline. High-change or high-criticality systems may warrant monthly or even continuous verification in staging with automated pipelines.