Skip to content

API Usage Cookbook

This guide shows how to call REST API using Bash (curl), Python, and JavaScript.

Authentication: All API requests must include your API key in the X-API-KEY header.

API Documentation: For interactive API exploration and full endpoint reference, visit the SharonAI API Documentation.

Table of contents

Quickstart in 2 Minutes

If you already have an API key, this flow creates and publishes one compute instance, then fetches its connection details.

export API_KEY="ra2.your-api-key"
export BASE_URL="https://console.compute.sharonai.cloud"
export PROJECT_NAME="defaultproject"
export WORKSPACE_NAME="my-workspace"
export INSTANCE_NAME="my-instance"
export COMPUTE_PROFILE_NAME="od-ssd-l40s-vm-1"

cat > payload.json <<JSON
{
  "apiVersion": "paas.envmgmt.io/v1",
  "kind": "ComputeInstance",
  "metadata": {
    "name": "${INSTANCE_NAME}",
    "workspace": "${WORKSPACE_NAME}",
    "project": "${PROJECT_NAME}"
  },
  "spec": {
    "computeProfile": {
      "name": "${COMPUTE_PROFILE_NAME}",
      "systemCatalog": true
    },
    "variables": [
      {
        "name": "Assign Public IP to Guest",
        "value": "True"
      },
      {
        "name": "Guest Disk Size",
        "value": "32"
      },
      {
        "name": "Guest Password",
        "value": "my-secure-password"
      }
    ]
  }
}
JSON

# 1) Create compute instance
curl -sS -X POST "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances" \
  -H "X-API-KEY: $API_KEY" \
  -H "Content-Type: application/json" \
  -d @payload.json

# 2) Publish compute instance (start provisioning)
curl -sS -X POST "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/publish" \
  -H "accept: application/json" \
  -H "X-API-KEY: $API_KEY"

# 3) Wait briefly, then fetch connection details
sleep 20
curl -sS -X GET "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}" \
  -H "accept: application/json" \
  -H "X-API-KEY: $API_KEY"

Tip: If you do not have an API key yet, complete the steps in the next section first.

Compute Instance Lifecycle Flow

flowchart LR
    A[Get API key] --> B[List compute profiles]
    B --> C[Create compute instance]
    C --> D[Publish instance]
    D --> E[Get connection details]
    E --> F{Operate instance}
    F --> G[Start]
    F --> H[Stop]
    F --> I[Reboot]
    G --> E
    H --> E
    I --> E
    E --> J[Destroy instance]

Copy-Ready Examples

Use this block as your default shell setup, then copy any API command below.

export API_KEY="ra2.your-api-key"
export BASE_URL="https://console.compute.sharonai.cloud"
export PROJECT_NAME="defaultproject"
export WORKSPACE_NAME="my-workspace"
export INSTANCE_NAME="my-instance"
export COMPUTE_PROFILE_NAME="od-ssd-l40s-vm-1"

# List compute profiles
curl -X GET "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/computeprofiles" \
  -H "accept: application/json" \
  -H "X-API-KEY: $API_KEY"

# Create instance (expects payload.json in current directory)
curl -X POST "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances" \
  -H "X-API-KEY: $API_KEY" \
  -H "Content-Type: application/json" \
  -d @payload.json

# Publish existing instance
curl -X POST "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/publish" \
  -H "accept: application/json" \
  -H "X-API-KEY: $API_KEY"

# Get connection details
curl -X GET "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}" \
  -H "accept: application/json" \
  -H "X-API-KEY: $API_KEY"

# Destroy instance
curl -X POST "${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/destroy" \
  -H "accept: application/json" \
  -H "X-API-KEY: $API_KEY"

Get your X-API-KEY from the portal

Before calling the API, you need an API key.

  1. Log in to the https://portal.sharonai.cloud
  2. Go to Compute or Infrastructure from App launcher Icon
  3. Go to My Tools -> API & Registry Keys click on Manage keys
  4. Create New API key, copy and store it securely for usage
  5. API key starts with ra2.

Bash — set the key in your shell (use a config file or env for real use):

# Replace with the key you got from the portal
export API_KEY="your-api-key-from-portal"
# Set base URL (optional, defaults to production)
export BASE_URL="https://console.compute.sharonai.cloud"
# Set your project and workspace names
export PROJECT_NAME="defaultproject"
export WORKSPACE_NAME="my-workspace"
export INSTANCE_NAME="my-instance"
export COMPUTE_PROFILE_NAME="od-ssd-l40s-vm-1"

Python — set the key in your script (use an env var or config in production):

import os

# Replace with the key you got from the portal, or use an env var:
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")
# Set base URL (optional, defaults to production)
BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
# Set your project and workspace names
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
COMPUTE_PROFILE_NAME = os.environ.get("COMPUTE_PROFILE_NAME", "od-ssd-l40s-vm-1")

JavaScript — set the key in your script (use an env var or config in production):

// Replace with the key you got from the portal, or use an env var:
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";
// Set base URL (optional, defaults to production)
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
// Set your project and workspace names
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const COMPUTE_PROFILE_NAME = process.env.COMPUTE_PROFILE_NAME || "od-ssd-l40s-vm-1";

List available compute profiles

List available compute profiles To discover what compute profiles are available for your project, make a GET request to the `/apis/paas.envmgmt.io/v1/projects/{project-name}/computeprofiles` endpoint. This is useful to determine which `computeProfile.name` you can use in the compute instance payload. 
curl -X 'GET' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/computeprofiles" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY"
*Python* — using requests: 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/computeprofiles"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
}

response = requests.get(url, headers=headers)
print(response.json())
*JavaScript* — using fetch: 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/computeprofiles`;

fetch(url, {
  method: "GET",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Expected Output - HTTP status: `200 OK` - Response kind: `ComputeProfileList` - One or more entries under `items[]` - Use `items[].metadata.name` as `computeProfile.name` in create payload ### Example Response The API returns a list of available compute profiles. The profile names (e.g., `"od-ssd-l40s-vm-8"`) are located in `items[].metadata.name`. Use these names in the `computeProfile.name` field when creating a compute instance. 
{
  "apiVersion": "paas.envmgmt.io/v1",
  "kind": "ComputeProfileList",
  "metadata": {
    "count": 1,
    "limit": 10
  },
  "items": [
    {
      "apiVersion": "paas.envmgmt.io/v1",
      "kind": "ComputeProfile",
      "metadata": {
        "name": "od-ssd-l40s-vm-8",
        "description": "High-performance Ubuntu GPU VM with 8× NVIDIA L40S, 720 GB RAM, and 112 vCPUs, available on Ubuntu 22.04 or 24.04 with optional GPU-ready images for fast AI and ML workloads."
      }
    }
  ]
}

Compute Instance Payload

Compute Instance Payload To avoid repeating the same request body for every language, store the JSON payload in one file (e.g. `payload.json`) and reference it from your client of choice. The rest of this section shows a canonical **cURL** example (portable across platforms). The **Python** and **JavaScript** snippets that follow are optional versions for developers already working in those languages. Create `payload.json` with the following content and replace the placeholder values where indicated: 
{
  "apiVersion": "paas.envmgmt.io/v1",
  "kind": "ComputeInstance",
  "metadata": {
    "name": "{{INSTANCE_NAME}}",
    "workspace": "{{WORKSPACE_NAME}}",
    "project": "{{PROJECT_NAME}}"
  },
  "spec": {
    "computeProfile": {
      "name": "{{COMPUTE_PROFILE_NAME}}",
      "systemCatalog": true
    },
    "variables": [
      {
        "name": "Assign Public IP to Guest",
        "value": "True"
      },
      {
        "name": "Guest Disk Size",
        "value": "32"
      },
      {
        "name": "Guest Password",
        "value": "my-secure-password"
      },
      {
        "name": "Guest SSH Public Keys",
        "value": "ssh-rsa AAAAB3NzaC1yc..."
      }
    ]
  }
}
> **Tip:** You can update the values directly in `payload.json` or use a simple templating step (e.g. `envsubst`, a small Python script, or a Node script) to substitute `{{INSTANCE_NAME}}`, `{{WORKSPACE_NAME}}`, `{{PROJECT_NAME}}`, and `{{COMPUTE_PROFILE_NAME}}`. Choose one of the following clients to execute the request; you only need to run one of them. *Bash* — using curl (reads `payload.json`): 
# Render payload.json with environment variables (requires envsubst)
envsubst < payload.json > payload.rendered.json

curl -X POST "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances" \
  -H "X-API-KEY: $API_KEY" \
  -H "Content-Type: application/json" \
  -d @payload.rendered.json
*Python* — using requests (reads `payload.json`): 
import json
import os
import requests

# Replace with your actual values or set via environment variables
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
COMPUTE_PROFILE_NAME = os.environ.get("COMPUTE_PROFILE_NAME", "od-ssd-l40s-vm-1")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances"
headers = {
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json"
}

with open("payload.json", "r", encoding="utf-8") as f:
    payload = json.load(f)

# Override placeholders as needed
payload["metadata"]["name"] = INSTANCE_NAME
payload["metadata"]["workspace"] = WORKSPACE_NAME
payload["metadata"]["project"] = PROJECT_NAME
payload["spec"]["computeProfile"]["name"] = COMPUTE_PROFILE_NAME

response = requests.post(url, headers=headers, json=payload)
print(response.json())
*JavaScript* — using fetch (reads `payload.json`): 
import fs from "fs";

const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const COMPUTE_PROFILE_NAME = process.env.COMPUTE_PROFILE_NAME || "od-ssd-l40s-vm-1";

const payload = JSON.parse(fs.readFileSync("payload.json", "utf8"));

// Override placeholders with runtime values
payload.metadata.name = INSTANCE_NAME;
payload.metadata.workspace = WORKSPACE_NAME;
payload.metadata.project = PROJECT_NAME;
payload.spec.computeProfile.name = COMPUTE_PROFILE_NAME;

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances`;
const headers = {
  "X-API-KEY": API_KEY,
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers,
  body: JSON.stringify(payload)
})
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error("Error:", error));
### Expected Output - HTTP status: `200` or `201` - Response includes instance metadata (`name`, `workspace`, `project`) - Instance is created and ready to be published

Create a Compute Instance

Create a Compute Instance To create a compute instance, make a POST request to the `/apis/paas.envmgmt.io/v1/projects/{project-name}/workspaces/{workspace-name}/computeinstances` endpoint with your API key in the `X-API-KEY` header. **Note:** Replace `{project-name}` with your actual project name and `{workspace-name}` with your workspace name. You can also set `PROJECT_NAME` and `WORKSPACE_NAME` environment variables to avoid hardcoding these values. ### Commonly Customized Variables When creating a compute instance, you can customize these key variables: - **Assign Public IP to Guest**: Set to `"True"` or `"False"` for public IP assignment - **Guest Disk Size**: Disk size in GB (minimum 32GB, increments of 32GB) - **Guest Password**: VM password (leave empty for auto-generated secure password) - **Guest SSH Public Keys**: Your SSH public key for VM access ### Shared JSON Payload (single source of truth) To avoid repeating the same request body for every language, store the JSON payload in one file (e.g. `payload.json`) and reference it from your client of choice. The rest of this section shows a canonical **cURL** example (portable across platforms). The **Python** and **JavaScript** snippets that follow are optional versions for developers already working in those languages. Create `payload.json` with the following content and replace the placeholder values where indicated: 
{
  "apiVersion": "paas.envmgmt.io/v1",
  "kind": "ComputeInstance",
  "metadata": {
    "name": "{{INSTANCE_NAME}}",
    "workspace": "{{WORKSPACE_NAME}}",
    "project": "{{PROJECT_NAME}}"
  },
  "spec": {
    "computeProfile": {
      "name": "{{COMPUTE_PROFILE_NAME}}",
      "systemCatalog": true
    },
    "variables": [
      {
        "name": "Assign Public IP to Guest",
        "value": "True"
      },
      {
        "name": "Guest Disk Size",
        "value": "32"
      },
      {
        "name": "Guest Password",
        "value": "my-secure-password"
      },
      {
        "name": "Guest SSH Public Keys",
        "value": "ssh-rsa AAAAB3NzaC1yc..."
      }
    ]
  }
}
> **Tip:** You can update the values directly in `payload.json` or use a simple templating step (e.g. `envsubst`, a small Python script, or a Node script) to substitute `{{INSTANCE_NAME}}`, `{{WORKSPACE_NAME}}`, `{{PROJECT_NAME}}`, and `{{COMPUTE_PROFILE_NAME}}`. Choose one of the following clients to execute the request; you only need to run one of them. *Bash* — using curl (reads `payload.json`): 
# Render payload.json with environment variables (requires envsubst)
envsubst < payload.json > payload.rendered.json

curl -X POST "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances" \
  -H "X-API-KEY: $API_KEY" \
  -H "Content-Type: application/json" \
  -d @payload.rendered.json
*Python* — using requests (reads `payload.json`): 
import json
import os
import requests

# Replace with your actual values or set via environment variables
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
COMPUTE_PROFILE_NAME = os.environ.get("COMPUTE_PROFILE_NAME", "od-ssd-l40s-vm-1")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances"
headers = {
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json"
}

with open("payload.json", "r", encoding="utf-8") as f:
    payload = json.load(f)

# Override placeholders as needed
payload["metadata"]["name"] = INSTANCE_NAME
payload["metadata"]["workspace"] = WORKSPACE_NAME
payload["metadata"]["project"] = PROJECT_NAME
payload["spec"]["computeProfile"]["name"] = COMPUTE_PROFILE_NAME

response = requests.post(url, headers=headers, json=payload)
print(response.json())
*JavaScript* — using fetch (reads `payload.json`): 
import fs from "fs";

const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const COMPUTE_PROFILE_NAME = process.env.COMPUTE_PROFILE_NAME || "od-ssd-l40s-vm-1";

const payload = JSON.parse(fs.readFileSync("payload.json", "utf8"));

// Override placeholders with runtime values
payload.metadata.name = INSTANCE_NAME;
payload.metadata.workspace = WORKSPACE_NAME;
payload.metadata.project = PROJECT_NAME;
payload.spec.computeProfile.name = COMPUTE_PROFILE_NAME;

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances`;
const headers = {
  "X-API-KEY": API_KEY,
  "Content-Type": "application/json"
};

fetch(url, {
  method: "POST",
  headers,
  body: JSON.stringify(payload)
})
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error("Error:", error));
### Expected Output - HTTP status: `200` or `201` - Response includes instance metadata (`name`, `workspace`, `project`) - Instance is created and ready to be published

Publish a Compute Instance

Publish a Compute Instance Once a compute instance exists, you can publish it (trigger provisioning) by calling the `publish` endpoint. 
curl -X 'POST' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances/${INSTANCE_NAME:-my-instance}/publish" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY"
*Python* — using requests: 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances/{INSTANCE_NAME}/publish"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
}

response = requests.post(url, headers=headers)
print(response.json())
*JavaScript* — using fetch: 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/publish`;

fetch(url, {
  method: "POST",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Expected Output - HTTP status: `200` - Publish request accepted for the instance - Provisioning starts; final connection details become available after completion > **Note:** Replace `INSTANCE_NAME` with the name of the instance you created (for example, `my-instance`). If you use the same env var setup shown earlier, this will work without additional changes.

Manage Compute Instance

Manage Compute Instance You can perform actions on an existing compute instance such as start, stop, or reboot by calling the `action` endpoint with the desired action. ### Stop a Compute Instance 
curl -X 'POST' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances/${INSTANCE_NAME:-my-instance}/action/stop" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY" \
  -H 'Content-Type: application/json'
*Python* — using requests: 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances/{INSTANCE_NAME}/action/stop"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
}

response = requests.post(url, headers=headers)
print(response.json())
*JavaScript* — using fetch: 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/action/stop`;

fetch(url, {
  method: "POST",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Start a Compute Instance Replace `stop` with `start` in the URL: 
curl -X 'POST' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances/${INSTANCE_NAME:-my-instance}/action/start" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY" \
  -H 'Content-Type: application/json'
*Python* — using requests (replace `stop` with `start` in the URL): 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances/{INSTANCE_NAME}/action/start"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
}

response = requests.post(url, headers=headers)
print(response.json())
*JavaScript* — using fetch (replace `stop` with `start` in the URL): 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/action/start`;

fetch(url, {
  method: "POST",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Reboot a Compute Instance Replace `stop` with `reboot` in the URL: 
curl -X 'POST' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances/${INSTANCE_NAME:-my-instance}/action/reboot" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY" \
  -H 'Content-Type: application/json'
*Python* — using requests (replace `stop` with `reboot` in the URL): 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances/{INSTANCE_NAME}/action/reboot"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
}

response = requests.post(url, headers=headers)
print(response.json())
*JavaScript* — using fetch (replace `stop` with `reboot` in the URL): 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/action/reboot`;

fetch(url, {
  method: "POST",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Expected Output - HTTP status: `200` - Requested action (`start`, `stop`, or `reboot`) is accepted - Instance state transitions can be verified by fetching instance details

Get Compute Instance Connection Details

Get Compute Instance Connection Details Use this API to fetch variables and network details for a provisioned compute instance. This is the endpoint to check values such as username, password, host, public IP, and private IP. 
curl -X 'GET' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances/${INSTANCE_NAME:-my-instance}" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY"
*Python* — using requests: 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances/{INSTANCE_NAME}"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
}

response = requests.get(url, headers=headers)
print(response.json())
*JavaScript* — using fetch: 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}`;

fetch(url, {
  method: "GET",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Expected Output - HTTP status: `200` - Response includes status fields such as host/IP details after provisioning - Use this response to retrieve Username, Password, Hostname, Public IP, and Private IP ### Where to find connection values Depending on the selected profile/image, connection values are typically returned under status fields and/or instance variables. - Username - Password - Host - Public IP - Private IP Example response fragment (partial snippet, not full JSON; responses can include additional key pairs such as `valueType`, `options`, and nested `DisplayMetadata`): 
{
  ...
  "Hostname": {
    "DisplayMetadata": {
      "label": "",
      "valueType": "text",
      "weight": null
    },
    "sensitive": false,
    "value": "test-vm"
  },
  "Password": {
    "DisplayMetadata": {
      "label": "",
      "valueType": "text",
      "weight": null
    },
    "sensitive": false,
    "value": "<redacted>"
  },
  "Private IP": {
    "DisplayMetadata": {
      "label": "",
      "valueType": "text",
      "weight": null
    },
    "sensitive": false,
    "value": "10.0.0.25"
  },
  "Public IP": {
    "DisplayMetadata": {
      "label": "",
      "valueType": "text",
      "weight": null
    },
    "sensitive": false,
    "value": "203.0.113.10"
  }
  ...
}
> **Note:** This is a partial response example. The leading/trailing `...` indicate omitted fields and are not valid JSON syntax. The full response can contain many additional objects and metadata key pairs. For connection details, read each field's `value` (and related metadata) for the keys you need. > **Tip:** Call this endpoint after publish/provision completes so the final IP and access values are available.

Destroy a Compute Instance

Destroy a Compute Instance To destroy (delete) an existing compute instance, call the `destroy` endpoint. 
curl -X 'POST' \
  "${BASE_URL:-https://console.compute.sharonai.cloud}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME:-defaultproject}/workspaces/${WORKSPACE_NAME:-my-workspace}/computeinstances/${INSTANCE_NAME:-my-instance}/destroy" \
  -H 'accept: application/json' \
  -H "X-API-KEY: $API_KEY"
*Python* — using requests: 
import os
import requests

BASE_URL = os.environ.get("BASE_URL", "https://console.compute.sharonai.cloud")
PROJECT_NAME = os.environ.get("PROJECT_NAME", "defaultproject")
WORKSPACE_NAME = os.environ.get("WORKSPACE_NAME", "my-workspace")
INSTANCE_NAME = os.environ.get("INSTANCE_NAME", "my-instance")
API_KEY = os.environ.get("API_KEY", "your-api-key-from-portal")

url = f"{BASE_URL}/apis/paas.envmgmt.io/v1/projects/{PROJECT_NAME}/workspaces/{WORKSPACE_NAME}/computeinstances/{INSTANCE_NAME}/destroy"
headers = {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
}

response = requests.post(url, headers=headers)
print(response.json())
*JavaScript* — using fetch: 
const BASE_URL = process.env.BASE_URL || "https://console.compute.sharonai.cloud";
const PROJECT_NAME = process.env.PROJECT_NAME || "defaultproject";
const WORKSPACE_NAME = process.env.WORKSPACE_NAME || "my-workspace";
const INSTANCE_NAME = process.env.INSTANCE_NAME || "my-instance";
const API_KEY = process.env.API_KEY || "your-api-key-from-portal";

const url = `${BASE_URL}/apis/paas.envmgmt.io/v1/projects/${PROJECT_NAME}/workspaces/${WORKSPACE_NAME}/computeinstances/${INSTANCE_NAME}/destroy`;

fetch(url, {
  method: "POST",
  headers: {
    "accept": "application/json",
    "X-API-KEY": API_KEY,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch((err) => console.error("Error:", err));
### Expected Output - HTTP status: `200` - Destroy request accepted - Instance is removed and no longer available for actions/details