Using the RouterOS API to Bulk Reboot MikroTik Router Devices Remotely

Managing network devices can sometimes require direct intervention, such as remotely rebooting a router. In this guide, we’ll explore how to use the RouterOS API to accomplish this task efficiently and securely. By the end, you’ll have a clear understanding of the steps needed to connect to a RouterOS device, send a reboot command, and safely disconnect from the session.

Why Reboot a Router Remotely?

Routers occasionally require reboots for reasons such as firmware updates, resolving connectivity issues, or applying new configurations. Manually rebooting a device is straightforward when it’s physically accessible. However, remote management provides the flexibility to control devices from afar, saving time and enabling swift responses to network problems.

Using the RouterOS API, a powerful interface provided by MikroTik, network administrators can automate tasks like reboots, backups, and configuration changes.

Setting Up the Environment

Before diving into the code, ensure you have the following:

1. A MikroTik RouterOS device with API access enabled.
2. Python installed on your system, along with the routeros_api library. Install it by running:
3. Basic Python knowledge to understand and execute the script.

pip install routeros-api

Key Components of the Script

Our Python script is structured around a custom RouterOS class. This class encapsulates essential functionalities, including connecting to the router, sending a reboot command, and disconnecting securely.

Building the RouterOS API Script

Step 1: Initializing the RouterOS Class

The RouterOS class begins with an __init__ method to store connection details like the router’s IP address, username, password, and API port. The default API port for RouterOS is 8728.

class RouterOS:
    def __init__(self, host, username, password, port=8728):
        self.host = host
        self.username = username
        self.password = password
        self.port = port
        self.api = None
        self.connection = None

Step 2: Establishing a Connection

To interact with the router, a secure connection is essential. The connect method handles this using the RouterOsApiPool class. It manages exceptions like incorrect credentials or communication errors, ensuring robust error handling.

def connect(self):
    try:
        self.api = RouterOsApiPool(self.host, username=self.username, password=self.password, port=self.port, plaintext_login=True)
        self.connection = self.api.get_api()
        print(f"Connected to {self.host}")
    except ros_exceptions.RouterOsApiCommunicationError:
        print("Failed to connect: Invalid username or password.")
        sys.exit(1)
    except ros_exceptions.RouterOsApiConnectionError as e:
        print(f"Connection error: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"Unexpected error: {e}")
        sys.exit(1)

Step 3: Sending the Reboot Command

The reboot method interacts with the /system API resource to trigger a reboot. It also prompts the user for confirmation to prevent accidental commands.

def reboot(self):
    if not self.connection:
        print("Not connected to the router.")
        return

    confirmation = input("Are you sure you want to reboot the router? (yes/no): ")
    if confirmation.lower() != 'yes':
        print("Reboot cancelled.")
        return

    try:
        system_resource = self.connection.get_resource('/system')
        system_resource.call('reboot')
        print("Reboot command sent.")
    except ros_exceptions.RouterOsApiError as e:
        print(f"Failed to send reboot command: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Step 4: Disconnecting Safely

The disconnect method ensures that the API session is properly closed, freeing up resources and maintaining security.

def disconnect(self):
    if self.api:
        try:
            self.api.disconnect()
            print(f"Disconnected from {self.host}.")
        except Exception as e:
            print(f"Failed to disconnect: {e}")
    else:
        print("No active connection to close.")

Running the Script

The script’s main function integrates all the steps into a seamless workflow. Users can specify their router’s details via command-line arguments.

def main():
    parser = argparse.ArgumentParser(description='Manage RouterOS device.')
    parser.add_argument('-H', '--host', required=True, help='IP address of the RouterOS device')
    parser.add_argument('-u', '--username', required=True, help='Username for the RouterOS device')
    parser.add_argument('-p', '--password', required=True, help='Password for the RouterOS device')
    parser.add_argument('--port', type=int, default=8728, help='Port number for the RouterOS API (default is 8728)')

    args = parser.parse_args()

    router = RouterOS(host=args.host, username=args.username, password=args.password, port=args.port)

    try:
        router.connect()
        router.reboot()
    finally:
        router.disconnect()

if __name__ == "__main__":
    main()

To execute the script, use the following command:

python router_reboot.py --host 192.168.1.1 -u api-user -p api-password
python router_reboot.py --host 192.168.2.1 -u api-user -p api-password
python router_reboot.py --host 192.168.3.1 -u api-user -p api-password
python router_reboot.py --host 192.168.4.1 -u api-user -p api-password
python router_reboot.py --host 192.168.5.1 -u api-user -p api-password

Best Practices for Remote Router Management

1. Use Strong Passwords: Ensure your RouterOS API credentials are secure to prevent unauthorized access.
2. Enable Encryption: When possible, use encrypted API connections (e.g., via TLS).
3. Regular Backups: Always back up your router configuration before making significant changes.
4. Access Control: Restrict API access to trusted IP addresses.

Conclusion

Using the RouterOS API, rebooting a MikroTik router remotely becomes a straightforward and efficient process. This script not only simplifies the task but also highlights the importance of secure and structured coding practices. By following this guide, network administrators can enhance their ability to manage devices remotely, saving time and ensuring reliable network operations.

As technology advances, remote management tools like the RouterOS API will continue to play a crucial role in maintaining seamless connectivity. So, why not give it a try and streamline your router management today?