Instance Clone Management Pattern for…

advancedTested on Xanadu

The Instance Clone Management Pattern provides a comprehensive approach to safely managing ServiceNow instance clones across development, test, and production environments. It addresses critical challenges like protecting sensitive credentials during clones, maintaining integration configurations, and automating post-clone cleanup tasks.

This pattern combines clone target exclusions to prevent overwriting sensitive data, automated post-clone scripts to restore environment-specific configurations, and intelligent scheduling that aligns clone operations with development sprint cycles. The pattern ensures that clones maintain data integrity while preserving the unique characteristics each environment requires for proper operation.

The implementation uses ServiceNow's Clone API, scheduled jobs, and configuration management utilities to create a robust, repeatable process. It includes safeguards against accidental production overwrites, validation checks for clone completion, and rollback mechanisms for failed operations.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Use This When

Use this pattern when managing multiple ServiceNow environments that require regular data refreshes while maintaining environment-specific configurations like integrations, credentials, and custom properties. This is essential for enterprise implementations with complex development workflows, strict security requirements, and coordinated release schedules.

Avoid When

Avoid this pattern for simple single-environment instances or when you need real-time data synchronization rather than periodic refreshes. The overhead of managing exclusions and post-clone scripts may not be justified for small teams with minimal customizations or when using ServiceNow's basic development practices.

Implementation

Server-side

// Clone Management Script Include
var CloneManager = Class.create();
CloneManager.prototype = {
    initialize: function() {
        this.exclusionTables = [
            'sys_properties',
            'sys_email_account',
            'oauth_entity',
            'discovery_credentials',
            'ldap_server_config'
        ];
        this.cloneLogTable = 'x_custom_clone_log';
    },
    
    initiateClone: function(sourceInstance, targetInstance, cloneOptions) {
        try {
            // Validate clone request
            if (!this._validateCloneRequest(sourceInstance, targetInstance)) {
                gs.error('Clone validation failed');
                return false;
            }
            
            // Log clone initiation
            var cloneId = this._logCloneStart(sourceInstance, targetInstance);
            
            // Setup exclusion list
            var exclusions = this._buildExclusionList(cloneOptions);
            
            // Use REST API to initiate clone
            var request = new sn_ws.RESTMessageV2();
            request.setHttpMethod('POST');
            request.setEndpoint('https://' + sourceInstance + '.service-now.com/api/now/clone');
            request.setBasicAuth(gs.getProperty('clone.user'), gs.getProperty('clone.password'));
            
            var body = {
                target_instance: targetInstance,
                exclude_tables: exclusions,
                clone_profile: cloneOptions.profile || 'data_preserving',
                email_when_complete: true
            };
            
            request.setRequestBody(JSON.stringify(body));
            request.setRequestHeader('Content-Type', 'application/json');
            
            var response = request.execute();
            
            if (response.getStatusCode() == 200) {
                this._updateCloneLog(cloneId, 'INITIATED', response.getBody());
                this._schedulePostCloneValidation(cloneId, targetInstance);
                gs.info('Clone initiated successfully: ' + cloneId);
                return cloneId;
            } else {
                this._updateCloneLog(cloneId, 'FAILED', response.getErrorMessage());
                return false;
            }
        } catch (ex) {
            gs.error('Clone initiation failed: ' + ex.message);
            return false;
        }
    },
    
    executePostCloneScript: function(targetInstance) {
        // Restore environment-specific configurations
        this._restoreIntegrationConfigs(targetInstance);
        this._updateSystemProperties(targetInstance);
        this._refreshCertificates(targetInstance);
        this._validateDataIntegrity(targetInstance);
        
        gs.info('Post-clone scripts completed for: ' + targetInstance);
    },
    
    _validateCloneRequest: function(source, target) {
        // Prevent accidental production overwrites
        if (target.indexOf('prod') > -1 && source.indexOf('prod') == -1) {
            gs.error('Attempted to clone non-prod to production: blocked');
            return false;
        }
        
        // Check if target is in maintenance window
        if (!this._isMaintenanceWindow()) {
            gs.warn('Clone requested outside maintenance window');
        }
        
        return true;
    },
    
    _buildExclusionList: function(options) {
        var exclusions = this.exclusionTables.slice(); // Copy default exclusions
        
        if (options && options.additionalExclusions) {
            exclusions = exclusions.concat(options.additionalExclusions);
        }
        
        // Add dynamic exclusions based on environment
        var envSpecificTables = new GlideRecord('sys_db_object');
        envSpecificTables.addQuery('name', 'STARTSWITH', 'x_env_');
        envSpecificTables.query();
        
        while (envSpecificTables.next()) {
            exclusions.push(envSpecificTables.getValue('name'));
        }
        
        return exclusions;
    },
    
    _logCloneStart: function(source, target) {
        var cloneLog = new GlideRecord(this.cloneLogTable);
        cloneLog.initialize();
        cloneLog.setValue('source_instance', source);
        cloneLog.setValue('target_instance', target);
        cloneLog.setValue('status', 'REQUESTED');
        cloneLog.setValue('requested_by', gs.getUserID());
        cloneLog.setValue('requested_on', new GlideDateTime());
        return cloneLog.insert();
    },
    
    _restoreIntegrationConfigs: function(targetInstance) {
        // Restore environment-specific integration endpoints
        var configs = new GlideRecord('sys_properties');
        configs.addQuery('name', 'STARTSWITH', 'integration.');
        configs.addQuery('name', 'ENDSWITH', '.endpoint');
        configs.query();
        
        while (configs.next()) {
            var envValue = this._getEnvironmentSpecificValue(configs.getValue('name'), targetInstance);
            if (envValue) {
                configs.setValue('value', envValue);
                configs.update();
            }
        }
    },
    
    type: 'CloneManager'
};

Client-side

// Clone Management UI Action Client Script
function initiateCloneFromUI() {
    // Collect clone parameters from form
    var sourceInstance = g_form.getValue('source_instance');
    var targetInstance = g_form.getValue('target_instance');
    var cloneProfile = g_form.getValue('clone_profile');
    
    // Validate inputs
    if (!sourceInstance || !targetInstance) {
        g_form.addErrorMessage('Source and target instances are required');
        return;
    }
    
    // Show confirmation dialog for production targets
    if (targetInstance.indexOf('prod') > -1) {
        var confirmed = confirm('WARNING: You are about to clone to a production instance. This action cannot be undone. Continue?');
        if (!confirmed) {
            return;
        }
    }
    
    // Call server-side clone manager
    var ga = new GlideAjax('CloneManager');
    ga.addParam('sysparm_name', 'initiateClone');
    ga.addParam('sysparm_source', sourceInstance);
    ga.addParam('sysparm_target', targetInstance);
    ga.addParam('sysparm_profile', cloneProfile);
    
    ga.getXML(function(response) {
        var answer = response.responseXML.documentElement.getAttribute('answer');
        if (answer && answer !== 'false') {
            g_form.addInfoMessage('Clone initiated successfully. Clone ID: ' + answer);
            // Refresh the clone status list
            g_list.refresh('x_custom_clone_log');
        } else {
            g_form.addErrorMessage('Clone initiation failed. Check system logs for details.');
        }
    });
}

The code implements a comprehensive clone management system using a Script Include that handles clone initiation, validation, and post-processing. Key features include table exclusion management to protect sensitive data, REST API integration for clone operations, and automated post-clone configuration restoration. The client-side component provides user-friendly clone initiation with safety confirmations and real-time status updates.

Alternatives

Manual Clone with Checklists

Simpler to implement and provides full control over each step, but requires manual intervention for each clone operation and is prone to human error. Best for small teams with infrequent clone needs.

Third-party Clone Orchestration Tools

Provides advanced scheduling and workflow capabilities with better integration to external systems, but adds licensing costs and complexity. Suitable for large enterprises with complex multi-platform environments.

ServiceNow Update Sets for Configuration

Eliminates the need for data cloning by managing configurations as code, providing better version control and faster deployments. However, doesn't address test data needs and requires disciplined development practices.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue