Custom Script "Rebuild Device From Device Type"

[jatelomark]

Hi team,I am currently using a NetBox Custom Script named "Rebuild Device From Device Type" (similar to the standard Rebuild_device_from_type pattern) to push template updates down to deployed device instances.Right now, the script works perfectly, but I have to manually run it one-by-one for every single device.What is the preferred method or community best practice to scale this behavior so I can execute it all at once?Should I refactor the Custom Script to accept a DeviceType model variable and use a Python loop (Device.objects.filter) to update them all in a single execution task, or is there a native NetBox bulk-operation trick I am missing? I'd love to hear how others handle mass-syncing templates without hitting timeouts. Thanks!

[jatelomark]

class RebuildDeviceFromType(Script):
class Meta:
name = "Rebuild Device From Device Type"
description = "Recreate all components (module bays, power ports, outlets, console, interfaces) from the device type templates."

device = ObjectVar(
    model=Device,
    description="Select the device to rebuild from its current Device Type"
)

def run(self, data, commit):
    device = data["device"]
    dtype = device.device_type

    if not dtype:
        self.log_failure(f"Device {device.name} has no assigned device type.")
        return

    self.log_info(f"Rebuilding {device.name} from device type {dtype.model} ...")

    # Delete all existing components
    for model in [ModuleBay, DeviceBay, PowerPort, PowerOutlet, ConsolePort, ConsoleServerPort, Interface]:
        deleted = model.objects.filter(device=device).delete()
        self.log_info(f"Deleted {deleted[0]} {model.__name__}(s)")

    # --- Recreate components from templates ---
    # Module Bays
    for tmpl in ModuleBayTemplate.objects.filter(device_type=dtype):
        ModuleBay.objects.create(
            device=device,
            name=tmpl.name,
            position=tmpl.position
        )

    # Power Ports
    for tmpl in PowerPortTemplate.objects.filter(device_type=dtype):
        PowerPort.objects.create(
            device=device,
            name=tmpl.name,
            type=tmpl.type
        )

    # Power Outlets
    for tmpl in PowerOutletTemplate.objects.filter(device_type=dtype):
        PowerOutlet.objects.create(
            device=device,
            name=tmpl.name,
            type=tmpl.type
        )

    # Console Ports
    for tmpl in ConsolePortTemplate.objects.filter(device_type=dtype):
        ConsolePort.objects.create(
            device=device,
            name=tmpl.name,
            type=tmpl.type
        )

    # Console Server Ports
    for tmpl in ConsoleServerPortTemplate.objects.filter(device_type=dtype):
        ConsoleServerPort.objects.create(
            device=device,
            name=tmpl.name,
            type=tmpl.type
        )

    # Interfaces
    for tmpl in InterfaceTemplate.objects.filter(device_type=dtype):
        Interface.objects.create(
            device=device,
            name=tmpl.name,
            type=tmpl.type,
            mgmt_only=tmpl.mgmt_only,
        )

    self.log_success(f"Rebuilt {device.name} from Device Type {dtype.model}")
    return f"Device {device.name} now matches Device Type {dtype.model}"

[mmaxjr]

I would not expect a native bulk-operation shortcut for this, because rebuilding from a device type is not just a field update: it can delete and recreate related objects, and that can affect interfaces, cables, IP assignments, inventory items, etc.

I would keep it as a Custom Script / Job, but change the input from one Device to either:

• a DeviceType plus optional filters such as site/status/role, or
• a MultiObjectVar(Device) if you want the operator to explicitly select the targets.

For a DeviceType-driven run, the shape would be:

class RebuildDevicesFromType(Script):
    device_type = ObjectVar(model=DeviceType)
    site = ObjectVar(model=Site, required=False)
    batch_size = IntegerVar(default=25, min_value=1, max_value=200)

    def run(self, data, commit):
        qs = Device.objects.filter(device_type=data["device_type"])
        if data.get("site"):
            qs = qs.filter(site=data["site"])

        for device in qs.iterator(chunk_size=data["batch_size"]):
            self.log_info(f"Would rebuild {device.name}")
            if commit:
                rebuild_one_device(device)

The important parts I would add before running it broadly:

1. Keep the single-device logic in a helper (rebuild_one_device(device)) and call that from both the one-device script and the bulk script. That reduces the chance that the two paths drift.
2. Use NetBox's commit flag as a dry run. In dry run, log the devices and the component counts that would be deleted/created.
3. Process in small batches with iterator(chunk_size=...) and clear logging. If you are touching hundreds/thousands of devices, I would run by site/role/status rather than all at once.
4. Be very careful deleting existing components. Deleting interfaces can remove or break related state such as cables, IP assignments, MAC addresses, VRFs, tags/custom fields, and any local deviations from the template. In many environments I would only create missing template components and optionally report extra components, instead of deleting everything blindly.
5. Make it idempotent. Prefer update-or-create by component name/type where possible, and log conflicts instead of recreating components unnecessarily.

So yes: refactoring the script to accept a DeviceType and loop over Device.objects.filter(device_type=...) is the normal direction. I would not treat it as a simple bulk edit, and I would avoid one giant all-devices run until the dry-run output looks boring.