Reboot Single Instance

Reboot Single Instance - Overview

The X-Series Reboot API allows authenticated users to initiate a reboot of a specific virtual machine using its Instance ID or IP address.

This endpoint is useful for remotely restarting an instance through API integrations, automation scripts, or custom infrastructure management tools without manually accessing the Dataoorts dashboard.

When a reboot request is accepted, the API returns a confirmation message indicating that the reboot has been initiated. The instance may take a few minutes to come back online.

Important: Rebooting an instance may temporarily interrupt running applications, active connections, and workloads. Save important work before initiating a reboot.

Endpoint

Property	Value
HTTP Method	`POST`
Endpoint	`/xseries/reboot`
Full URL	`https://cloud.dataoorts.com/api/v1/xseries/reboot`
Authentication	Bearer Token
Content Type	`application/json`
Response Format	JSON

Authentication

This endpoint requires a valid Dataoorts Unify API key.

Include your API key in the Authorization header using the Bearer authentication scheme.

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
Accept: application/json

Generate or manage your API key through the Dataoorts Unify API.

Keep your API key secure and never expose it in public repositories or client-side applications.

Request Parameters

The request body must be sent as JSON.

Parameter	Type	Required	Description
`id_or_ip`	String	Yes	The Instance ID or IP address of the virtual machine you want to reboot.

Provide the identifier of the intended instance. Ensure that it is correct before submitting the request, as rebooting an instance can interrupt its current workloads.

Request Examples

cURL - use the following command to initiate a reboot using an Instance ID:

curl --request POST \
  --url "https://cloud.dataoorts.com/api/v1/xseries/reboot" \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data '{
    "id_or_ip": "1373"
  }'

You can also identify the instance using its IP address:

curl --request POST \
  --url "https://cloud.dataoorts.com/api/v1/xseries/reboot" \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data '{
    "id_or_ip": "38.128.233.51"
  }'

Replace YOUR_API_KEY and the sample instance identifier with your actual values.

Python Example Implementation:

import os
import requests


API_URL = "https://cloud.dataoorts.com/api/v1/xseries/reboot"


def reboot_xseries_instance(api_key: str, id_or_ip: str) -> dict:
    """
    Initiate a reboot of an X-Series virtual machine.

    Args:
        api_key: Your Dataoorts Unify API key.
        id_or_ip: The instance ID or IP address.

    Returns:
        dict: The JSON response returned by the API.

    Raises:
        requests.exceptions.RequestException:
            If the HTTP request fails or returns an unsuccessful
            HTTP status code.
        ValueError:
            If the response cannot be decoded as JSON.
    """
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
        "Accept": "application/json",
    }

    payload = {
        "id_or_ip": id_or_ip,
    }

    response = requests.post(
        API_URL,
        headers=headers,
        json=payload,
        timeout=30,
    )

    response.raise_for_status()

    try:
        return response.json()
    except requests.exceptions.JSONDecodeError as exc:
        raise ValueError(
            "The API returned an invalid JSON response."
        ) from exc


if __name__ == "__main__":
    api_key = os.getenv("DATAOORTS_API_KEY")

    if not api_key:
        raise RuntimeError(
            "Set the DATAOORTS_API_KEY environment variable."
        )

    try:
        result = reboot_xseries_instance(
            api_key=api_key,
            id_or_ip="1373",
        )

        print("Status:", result.get("status"))
        print("Message:", result.get("message"))

    except requests.exceptions.RequestException as exc:
        print(f"API request failed: {exc}.")

    except ValueError as exc:
        print(f"Invalid API response: {exc}.")

Set your API key before running the script.

Linux / macOS

export DATAOORTS_API_KEY="YOUR_API_KEY"
python reboot_instance.py

Windows PowerShell

$env:DATAOORTS_API_KEY="YOUR_API_KEY"
python reboot_instance.py

To reboot instance using its IP address, replace "1373" with appropriate IP address in id_or_ip argument.

Example Success Response

When the reboot request is accepted, the API returns a JSON response similar to the following:

HTTP Status: Successful response

{
  "message": "Reboot initiated for instance <ID>, It takes few minutes to come back online.",
  "status": "success"
}

The instance identifier and message may differ depending on the request.

Response Fields

Field	Type	Description
`status`	String	Indicates result of the reboot request. Successful response returns `success`.
`message`	String	Provides information confirming that the reboot has been initiated and that the instance may take a few minutes to come back online.

Understanding the Reboot Process

A successful API response confirms that the hard reboot request has been accepted or initiated. It does not necessarily mean that the instance has completed rebooting or is already accessible.

After the request:

Dataoorts processes the hard reboot request.
The instance restarts and may temporarily become unreachable.
The instance may take a few minutes to come back online.
You can use the Get Single Instance Info endpoint to check the instance status, or use an appropriate connectivity check to verify that it is accessible again.

The actual recovery time depends on the instance and its operating environment.

Important Notes

Service interruption: A reboot can interrupt active workloads, application processes, and SSH sessions. So plan the reboots accordingly.

Correct instance identification: Verify the Instance ID or IP address before sending the request.

Reboot completion: Do not treat the successful API response as confirmation that the instance is fully operational again. Check its status or connectivity separately.

Error handling: If a request times out or returns an error, inspect response before retrying. A timeout does not always establish whether the server initiated the reboot, so repeated requests may trigger additional reboots.

Error Handling

If request fails, API may return unsuccessful HTTP status code and JSON response containing error message.

Your application should handle authentication failures, invalid instance identifiers, network errors, timeouts, and unexpected response formats. The exact error codes and response messages depend on the API response.

Do not assume that every response contains the same fields as the successful response shown above.

Get Help and Support

For assistance with instance reboots or API integration, contact the Dataoorts support team.

Support Email: [email protected]