Ori Global Cloud

https://docs.ori.co
Admin
Ori Global Cloud (OGC) is a platform designed to run AI/ML workloads, offering virtual machines,...
Tokens:189,139
Snippets:1,094
Trust Score:8.8
Update:10 months ago
Show doc for...
Tokens:
Raw
### Create Endpoint

Source: https://docs.ori.co/endpoints/get-started

Guide on creating an inference endpoint, including model selection, compute resource configuration, and autoscaling options.

```APIDOC
## Step 1: Create an endpoint

### Description
This section outlines the process of creating an inference endpoint.

### Configuration Options

1.  **Select a Model:** Choose from a list of pre-trained models.
2.  **Configure Compute Resources:**
    *   **GPU Selection:** Select the GPU type based on performance and cost requirements. OGC may recommend an optimal GPU.
    *   **Location:** Choose the geographical hosting location for the endpoint.
3.  **Autoscaling (Optional):**
    *   **Replicas:** Define the minimum and maximum number of replicas for scaling.
    *   **Zero to Scale Policy:** If minimum replicas are set to zero, the endpoint scales down based on a defined policy.
```

--------------------------------

### Verify Ori CLI Installation

Source: https://docs.ori.co/cli/installation

Executes a command to list available SKUs, verifying that the Ori CLI has been installed correctly and is accessible in the system's PATH.

```bash
> ogc vm list-sku
```

--------------------------------

### Install Ori CLI on MacOS/Linux

Source: https://docs.ori.co/cli/installation/index

Installs the Ori CLI using a curl command to download and execute the installation script. It also shows how to set the OGC_ACCESS_TOKEN environment variable.

```shell
curl https://raw.githubusercontent.com/ori-edge/ogc-cli-releases/main/install.sh | sh
```

```shell
export OGC_ACCESS_TOKEN="api|xxxxxxxxx"
```

--------------------------------

### Install Ori CLI on MacOS and Linux

Source: https://docs.ori.co/cli/installation

Installs the Ori CLI using a curl command to download and execute an installation script from GitHub. This method is suitable for Unix-like systems.

```bash
curl https://raw.githubusercontent.com/ori-edge/ogc-cli-releases/main/install.sh | sh
```

--------------------------------

### Accessing Endpoints (Example cURL)

Source: https://docs.ori.co/endpoints/get-started/index

Example cURL command demonstrating how to access a deployed model endpoint using an authorization token.

```APIDOC
## POST /openai/v1/chat/completions

### Description
Sends a request to the model endpoint for chat completions.

### Method
POST

### Endpoint
{endpoint-url}/openai/v1/chat/completions

### Parameters
#### Query Parameters
- **ACCESS_TOKEN** (string) - Required - The authorization token for accessing the endpoint. This is typically set as an environment variable.
- **ACCESS_URL** (string) - Required - The base URL of the deployed endpoint. This is typically set as an environment variable.

#### Request Body
- **model** (string) - Required - The model identifier.
- **messages** (array) - Required - An array of message objects for the conversation.
  - **role** (string) - Required - The role of the message sender (e.g., 'system', 'user').
  - **content** (string) - Required - The content of the message.
- **max_tokens** (integer) - Optional - The maximum number of tokens to generate.
- **stream** (boolean) - Optional - Whether to stream the response.

### Request Example
```bash
export ACCESS_TOKEN='<authorization-token>'
export ACCESS_URL='<endpoint-url>'

curl -H "Content-Type: application/json" \
-H "Authorization: Bearer $ACCESS_TOKEN" \
-d '{"model": "model","messages":[{"role": "system", "content": "You are an assistant that speaks in pirate speak."},{"role": "user", "content": "Write a poem about colors"}],"max_tokens": 50,"stream": false}' \
"$ACCESS_URL/openai/v1/chat/completions"
```

### Response
#### Success Response (200)
- **choices** (array) - An array of completion choices.
  - **message** (object) - The generated message.
    - **role** (string) - The role of the sender.
    - **content** (string) - The content of the message.

#### Response Example
```json
{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "Ahoy, matey! Colors be like treasure, each with its own gleam!"
      }
    }
  ]
}
```
```

--------------------------------

### Setup Virtual Environment for Qdrant Client

Source: https://docs.ori.co/integrations/vectors/qdrant/index

Installs Python's virtual environment package, creates a new virtual environment, and activates it. This isolates project dependencies.

```bash
sudo apt install python3-venv  

python3 -m venv <virtual-env-name>  

source <v-env-name>/bin/activate
```

--------------------------------

### Setup Python Virtual Environment

Source: https://docs.ori.co/integrations/vectors/qdrant

Installs Python's virtual environment package and provides commands to create and activate a new virtual environment. This isolates project dependencies.

```bash
sudo apt install python3-venv

python3 -m venv <virtual-env-name>
source <v-env-name>/bin/activate
```

--------------------------------

### Get Supercomputer Template by Name (Go)

Source: https://docs.ori.co/api/get-supercomputer-template

This Go code example illustrates how to call the OGC API to get a supercomputer template. It includes setting up the request headers for authorization and content type, and handles the JSON response.

```go
package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"strings"
)

func main() {
	apiKey := "<API_KEY_VALUE>"
	baseURL := "https://api.ogc.ori.co/public/v1"
	templateName := ":templateName"

	url := fmt.Sprintf("%s/supercomputers/templates/%s", baseURL, templateName)

	client := &http.Client{}
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Printf("Error creating request: %s\n", err)
		return
	}

	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", "Bearer "+apiKey)

	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("Error sending request: %s\n", err)
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %s\n", err)
		return
	}

	if resp.StatusCode == 200 {
		fmt.Println(string(body))
	} else {
		fmt.Printf("Error: %s\n", resp.Status)
		fmt.Println(string(body))
	}
}
```

--------------------------------

### Get VM by ID using C#

Source: https://docs.ori.co/api/get-vm

This C# example uses `HttpClient` to fetch VM instance data. It constructs the request, adds the necessary headers like `Accept` and `Authorization`, and deserializes the JSON response. Remember to replace `:id` and `<API_KEY_VALUE>`.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class VmApiClient
{
    public static async Task GetVmAsync(string vmId, string apiKey)
    {
        using (var client = new HttpClient())
        {
            client.BaseAddress = new Uri("https://api.ogc.ori.co/public/v1/");
            client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKey);

            HttpResponseMessage response = await client.GetAsync($"vms/instances/{vmId}");

            if (response.IsSuccessStatusCode)
            {
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine(responseBody);
            }
            else
            {
                Console.WriteLine($"Error: {response.StatusCode} - {await response.Content.ReadAsStringAsync()}");
            }
        }
    }

    public static async Task Main(string[] args)
    {
        string vmId = ":id"; // Replace with actual VM ID
        string apiKey = "<API_KEY_VALUE>"; // Replace with your API Key
        await GetVmAsync(vmId, apiKey);
    }
}
```

--------------------------------

### Create Model Endpoint

Source: https://docs.ori.co/endpoints/get-started/index

Steps to create a model deployment endpoint, including model selection, compute resource configuration, and optional autoscaling.

```APIDOC
## POST /websites/ori_co/endpoints

### Description
Creates a new model deployment endpoint.

### Method
POST

### Endpoint
/websites/ori_co/endpoints

### Parameters
#### Request Body
- **model_name** (string) - Required - The name of the pre-trained model to deploy.
- **gpu_selection** (string) - Required - The type of GPU to use for the endpoint.
- **location** (string) - Required - The geographical location for hosting the endpoint.
- **autoscaling** (object) - Optional - Configuration for autoscaling.
  - **min_replicas** (integer) - Optional - Minimum number of replicas.
  - **max_replicas** (integer) - Optional - Maximum number of replicas.
  - **zero_to_scale_policy** (string) - Optional - Policy for scaling down to zero replicas.
```

--------------------------------

### List Supercomputer Templates Availability (Go)

Source: https://docs.ori.co/api/list-supercomputer-templates-availability/index

Fetches supercomputer template availability using Go. This example demonstrates making an HTTP GET request with custom headers for acceptance and authorization.

```go
package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://api.ogc.ori.co/public/v1/supercomputers/templates/availability"

	client := &http.Client{}

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Printf("Error creating request: %s\n", err)
		return
	}

	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", "<API_KEY_VALUE>")

	res, err := client.Do(req)
	if err != nil {
		fmt.Printf("Error sending request: %s\n", err)
		return
	}

	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %s\n", err)
		return
	}

	if res.StatusCode == 200 {
		fmt.Println(string(body))
	} else {
		fmt.Printf("Error: %d\n%s\n", res.StatusCode, string(body))
	}
}
```

--------------------------------

### Create VM via CLI

Source: https://docs.ori.co/virtual-machines/get-started

This command demonstrates how to create a Virtual Machine using the OGC CLI tool. It specifies the VM name, SSH public key ID, GPU SKU, OS image, and region. Ensure you replace placeholder values with your actual configuration.

```bash
ogc vm create test-vm --public-key-id <ssh-key-id> --sku ogx-h100-80 --os-image Ubuntu-20.04 --region gravelines-4
```

--------------------------------

### Create a Virtual Machine using OGC CLI

Source: https://docs.ori.co/cli/examples/index

Demonstrates how to create a new virtual machine instance on OGC. This command requires specifying the public key ID for access, the desired SKU, the OS image, and the region. Note that creating a VM incurs costs.

```bash
user@machine ~ % ogc vm create test-vm --public-key-id <id> --sku ogx-l40s-48 --os-image Ubuntu-20.04 --region gravelines-4
```

--------------------------------

### Create a VM with Specific Configuration (CLI)

Source: https://docs.ori.co/cli/commands/ogc_vm_create/index

This command creates a new virtual machine instance with specified SKU, region, OS image, public key, and an initialization script. Ensure all required parameters such as SKU, region, and OS image are correctly provided. The output format can be controlled using the '-x' flag.

```bash
ogc vm create my-vm --sku ogx-h100-80 --region us-east --os-image ubuntu-22.04 --public-key-id ID --init-script '#!/bin/bash example'
```

--------------------------------

### Instantiate Qdrant Client

Source: https://docs.ori.co/integrations/vectors/qdrant/index

Initializes the QdrantClient by providing the URL of the Qdrant server. This establishes the connection to interact with the Qdrant database.

```python
from qdrant_client import QdrantClient  

client = QdrantClient(url="http://<your-qdrant-server-VM-IP>:6333/dashboard")
```

--------------------------------

### Initialize Google Cloud SDK (Bash)

Source: https://docs.ori.co/virtual-machines/transfer-cloud-storage

Installs and initializes the Google Cloud SDK, which includes `gcloud`, `gsutil`, and `bq` command-line tools. It downloads the SDK, executes the installation script, and prompts for initialization.

```bash
curl https://sdk.cloud.google.com | bash
exec -l $SHELL
gcloud init
```

--------------------------------

### Get Supercomputer Template Example Response (JSON)

Source: https://docs.ori.co/api/get-supercomputer-template/index

This is an example JSON response for the 'Get Supercomputer Template' API endpoint. It outlines the structure of a supercomputer template, including details about CPU and GPU counts and types, memory, disk space, and display names. This schema is used to describe the available supercomputer configurations.

```json
[
  {
    "cpuCount": 1,
    "cpuTypeName": "NVIDIA H200",
    "diskNvme": 1,
    "diskSas": 1,
    "displayName": "Great Supercomputer",
    "gpuCount": 3,
    "gpuMemory": 2000,
    "gpuTypeName": "h200",
    "memory": 2000,
    "name": "great-supercomputer"
  }
]
```

--------------------------------

### Create and List Virtual Machines using OGC CLI

Source: https://docs.ori.co/cli/examples

Provides the command to create a Virtual Machine with specified parameters such as public key ID, SKU, OS image, and region. It also shows how to list created VMs and their current status. Note that creating a VM incurs costs.

```bash
user@machine ~ % ogc vm create test-vm --public-key-id <id> --sku ogx-l40s-48 --os-image Ubuntu-20.04 --region gravelines-4  
0cc1d7ca-88df-41ba-8713-b4214bf12f0c  

user@machine ~ % ogc vm list  
ID                                   | Name    | Status  
0cc1d7ca-88df-41ba-8713-b4214bf12f0c | test-vm | Available  
```

--------------------------------

### Get API Version (C#)

Source: https://docs.ori.co/api/get-version

This C# example shows how to retrieve the Ori API version using HttpClient. It sends a GET request and deserializes the JSON response.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ApiVersionFetcher
{
    public static async Task GetVersionAsync()
    {
        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Accept", "application/json");
            HttpResponseMessage response = await client.GetAsync("https://api.ogc.ori.co/public/version");

            if (response.IsSuccessStatusCode)
            {
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine(responseBody);
            }
            else
            {
                Console.WriteLine($"Error: {response.StatusCode}");
            }
        }
    }

    public static void Main(string[] args)
    {
        GetVersionAsync().Wait();
    }
}
```

--------------------------------

### Get API Version (Java)

Source: https://docs.ori.co/api/get-version

This Java example shows how to retrieve the Ori API version using the built-in HttpClient. It sends a GET request and prints the response body.

```java
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ApiVersionFetcher {

    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.ogc.ori.co/public/version"))
                .header("Accept", "application/json")
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Install Qdrant Client and Dependencies

Source: https://docs.ori.co/integrations/vectors/qdrant/index

Installs the qdrant-client library along with pandas, numpy, and faker for data manipulation and generation. This command is typically run within an activated virtual environment.

```bash
pip install qdrant-client pandas numpy faker
```

--------------------------------

### Get Endpoint Response Example (JSON)

Source: https://docs.ori.co/api/get-endpoint/index

An example of the JSON response received when successfully fetching an inference endpoint's details. It includes properties such as current replicas, GPU type, pricing, model name, and current status.

```json
{
  "currentReplicas": 1,
  "exampleCommand": "curl -X POST -H 'Content-Type: application/json' -d '{\"data\": [1, 2, 3]}' https://example.com",
  "gpuCount": 1,
  "gpuType": "L4",
  "hourlyPrice": 0.5,
  "id": "1190bae6-12ab-4e6e-b7bc-3d9e6ef3cf6f",
  "locationName": "lille-4",
  "maxReplicas": 1,
  "minReplicas": 1,
  "modelName": "some-sku",
  "name": "my-endpoint",
  "replicas": [
    {
      "gpus": 1,
      "status": "Running"
    }
  ],
  "scaleToZeroRetentionPeriodSeconds": 1800,
  "status": "Available",
  "url": "https://example.com"
}
```

--------------------------------

### POST /public/v1/vms/instances

Source: https://docs.ori.co/api/create-vm

Creates a new virtual machine instance with specified configuration.

```APIDOC
## POST /public/v1/vms/instances

### Description
Creates a new virtual machine instance with the provided configuration details.

### Method
POST

### Endpoint
https://api.ogc.ori.co/public/v1/vms/instances

### Parameters
#### Request Body
- **displayName** (string) - Required - The desired name for the virtual machine.
- **initScript** (string) - Optional - A script to be executed upon initialization of the VM.
- **locationName** (string) - Required - The name of the location where the VM will be deployed.
- **osName** (string) - Required - The name of the operating system to install on the VM.
- **sshKeyId** (string) - Required - The ID of the SSH key to associate with the VM for access.
- **templateName** (string) - Required - The name of the VM template to use for creation.

### Request Example
```json
{
  "displayName": "my-vm",
  "initScript": "echo 'Hello World!'",
  "locationName": "lille-4",
  "osName": "Debian-11",
  "sshKeyId": "5272e090-a595-4d6a-8587-cfe78214739f",
  "templateName": "ogc-h100sxm-80"
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier of the newly created virtual machine.

#### Response Example
```json
{
  "id": "5272e090-a595-4d6a-8587-cfe78214739f"
}
```
```

--------------------------------

### Get API Version (Node.js)

Source: https://docs.ori.co/api/get-version

This Node.js example shows how to fetch the Ori API version using the built-in 'https' module. It makes a GET request and processes the JSON response.

```javascript
const https = require('https');

const options = {
  hostname: 'api.ogc.ori.co',
  path: '/public/version',
  method: 'GET',
  headers: {
    'Accept': 'application/json'
  }
};

const req = https.request(options, (res) => {
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    console.log(JSON.parse(data));
  });
});

req.on('error', (error) => {
  console.error(error);
});

req.end();
```

--------------------------------

### Get Supercomputer Template by Name (C#)

Source: https://docs.ori.co/api/get-supercomputer-template

This C# code example demonstrates how to call the OGC API to get supercomputer template details. It uses `HttpClient` to make the GET request and includes the necessary authorization and accept headers.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ApiClient
{
    public static async Task GetSupercomputerTemplateAsync(string apiKey, string templateName)
    {
        using (var client = new HttpClient())
        {
            client.BaseAddress = new Uri("https://api.ogc.ori.co/public/v1/");
            client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKey);

            var response = await client.GetAsync($"supercomputers/templates/{templateName}");

            if (response.IsSuccessStatusCode)
            {
                var json = await response.Content.ReadAsStringAsync();
                Console.WriteLine(json);
            }
            else
            {
                Console.WriteLine($"Error: {response.StatusCode}");
                var errorContent = await response.Content.ReadAsStringAsync();
                Console.WriteLine(errorContent);
            }
        }
    }

    public static async Task Main(string[] args)
    {
        string apiKey = "<API_KEY_VALUE>";
        string templateName = ":templateName"; // Replace with actual template name
        await GetSupercomputerTemplateAsync(apiKey, templateName);
    }
}
```

--------------------------------

### Create a Bucket with JSON Output

Source: https://docs.ori.co/cli/commands/ogc_bucket_create/index

This example demonstrates creating a bucket and specifying 'json' as the output format using the '-x' or '--output' flag. This is useful for programmatic consumption of the command's output.

```bash
ogc bucket create my-new-bucket --location ap-south-1 --type archival -x json
```

--------------------------------

### Create a Bucket with Human-Readable Output

Source: https://docs.ori.co/cli/commands/ogc_bucket_create/index

This example shows how to create a bucket, defaulting to human-readable output. The '-x' or '--output' flag is not specified, which is the default behavior for human-readable output.

```bash
ogc bucket create NAME --location us-east-1 --type temporary
```

--------------------------------

### Get Supercomputer Template by Name (Java)

Source: https://docs.ori.co/api/get-supercomputer-template

This Java code example demonstrates fetching supercomputer template details using Apache HttpClient. It includes setting the authorization token and accept headers for the GET request to the OGC API.

```java
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;

public class ApiClient {

    public static void getSupercomputerTemplate(String apiKey, String templateName) {
        try (CloseableHttpClient client = HttpClients.createDefault()) {
            String url = String.format("https://api.ogc.ori.co/public/v1/supercomputers/templates/%s", templateName);
            HttpGet request = new HttpGet(url);

            request.setHeader("Accept", "application/json");
            request.setHeader("Authorization", "Bearer " + apiKey);

            try (CloseableHttpResponse response = client.execute(request)) {
                if (response.getStatusLine().getStatusCode() == 200) {
                    String jsonResponse = EntityUtils.toString(response.getEntity());
                    System.out.println(jsonResponse);
                } else {
                    System.err.println("Error: " + response.getStatusLine().getStatusCode());
                    String errorResponse = EntityUtils.toString(response.getEntity());
                    System.err.println(errorResponse);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String apiKey = "<API_KEY_VALUE>";
        String templateName = ":templateName"; // Replace with actual template name
        getSupercomputerTemplate(apiKey, templateName);
    }
}
```

--------------------------------

### VM Create Command Options

Source: https://docs.ori.co/cli/commands/ogc_vm_create

Lists the available options for the 'ogc vm create' command. These flags allow customization of the VM, such as setting the initialization script, OS image, public key ID, region, and VM SKU.

```bash
ogc vm create [flags] 

Flags:
  -h, --help                   help for create
  -n, --init-script string     Init script
  -i, --os-image string        OS Image SKU
  -k, --public-key-id string   Public Key ID
  -r, --region string          Region
  -s, --sku string             VM Template SKU
```

--------------------------------

### Get VM Template by Name (Node.js)

Source: https://docs.ori.co/api/get-template

This Node.js example uses the 'axios' library to make an HTTP GET request to fetch VM template details. It includes setting the appropriate headers for authentication and content type.

```javascript
const axios = require('axios');

const templateName = 'your_template_name';
const apiKey = '<API_KEY_VALUE>';

const url = `https://api.ogc.ori.co/public/v1/vms/templates/${templateName}`;

axios.get(url, {
  headers: {
    'Accept': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(`Error: ${error.response.status}`);
  console.error(error.response.data);
});
```

--------------------------------

### OGC VM Create Command Options (CLI)

Source: https://docs.ori.co/cli/commands/ogc_vm_create/index

This displays the available options for the 'ogc vm create' command. These options allow customization of the VM, including its name, SKU, region, OS image, public key ID, and initialization script. Inherited options like output format are also listed.

```bash
ogc vm create [flags]

Flags:
  -h, --help                   help for create
  -n, --init-script string     Init script
  -i, --os-image string        OS Image SKU
  -k, --public-key-id string   Public Key ID
  -r, --region string          Region
  -s, --sku string             VM Template SKU

Options inherited from parent commands:
  -x, --output string   Output format. Empty for human-readable, 'json', 'json-line' or 'yaml'
```

--------------------------------

### Get VM Template by Name (C#)

Source: https://docs.ori.co/api/get-template/index

This C# example uses `HttpClient` to make a GET request to the Ori.co API for VM template data. It includes setting the `Accept` and `Authorization` headers. The response is deserialized from JSON into a dictionary.

```csharp
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Collections.Generic;

public class TemplateFetcher
{
    public static async Task Main(string[] args)
    {
        var templateName = "ogc-h100sxm-80"; // Example template name
        var apiKey = "<API_KEY_VALUE>";
        var client = new HttpClient();

        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

        try
        {
            var response = await client.GetAsync($"https://api.ogc.ori.co/public/v1/vms/templates/{templateName}");
            response.EnsureSuccessStatusCode(); // Throw an exception if the status code is not successful

            var responseBody = await response.Content.ReadAsStringAsync();
            // Deserialize JSON to a dictionary or a specific class
            var templateData = System.Text.Json.JsonSerializer.Deserialize<Dictionary<string, object>>(responseBody);
            
            // Print the data (or process it as needed)
            foreach (var kvp in templateData)
            {
                Console.WriteLine($"{kvp.Key}: {kvp.Value}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Error fetching template: {e.Message}");
        }
    }
}
```

--------------------------------

### Create and List SSH Keys using OGC CLI

Source: https://docs.ori.co/cli/examples

Demonstrates the process of creating an SSH key pair and then registering the public key as an OGC SSH key resource. The `create` command requires a public key, and the `list` command retrieves the details of the created SSH keys.

```bash
user@machine ~ % ogc ssh create personal-key --public-key <public-key>  
5272e090-a595-4d6a-8587-cfe78214739e  

user@machine ~ % ogc ssh list  
ID                                   | Name            | Description  
5272e090-a595-4d6a-8587-cfe78214739e | personal-key    |  
```

--------------------------------

### Get VM Template by Name (Node.js)

Source: https://docs.ori.co/api/get-template/index

This Node.js example utilizes the built-in `https` module to make a GET request to the Ori.co API for VM template data. It sets the necessary headers, including the API key for authorization, and handles the JSON response.

```javascript
const https = require('https');

const templateName = 'ogc-h100sxm-80'; // Example template name
const apiKey = '<API_KEY_VALUE>';
const options = {
  hostname: 'api.ogc.ori.co',
  port: 443,
  path: `/public/v1/vms/templates/${templateName}`,
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  }
};

const req = https.request(options, (res) => {
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    if (res.statusCode >= 200 && res.statusCode < 300) {
      try {
        const templateData = JSON.parse(data);
        console.log(templateData);
      } catch (e) {
        console.error('Error parsing JSON:', e);
      }
    } else {
      console.error(`API request failed with status ${res.statusCode}: ${data}`);
    }
  });
}).on('error', (e) => {
  console.error(`Error making API request: ${e.message}`);
});

req.end();
```

--------------------------------

### Accessing Endpoints

Source: https://docs.ori.co/endpoints/get-started

Instructions on how to securely access your created inference endpoints using an authorization token.

```APIDOC
## Step 2: Accessing your Endpoints

### Description
After creation, you receive an Authorization Token required for secure access to inference endpoints via the `Authorization` header.

### Authentication Token

The Authentication Token is displayed only once upon creation. A new token can be obtained under the `Request Access Token` option for your endpoint.

A sample cURL command is provided under the endpoint details for accessing inference.

### Example cURL Command (Llama 3.1 8B model)

```bash
export ACCESS_TOKEN='<authorization-token>'
export ACCESS_URL='<endpoint-url>'

curl -H "Content-Type: application/json" \
-H "Authorization: Bearer $ACCESS_TOKEN" \
-d '{"model": "model","messages":[{"role": "system", "content": "You are an assistant that speaks in pirate speak."},{"role": "user", "content": "Write a poem about colors"}],"max_tokens": 50,"stream": false}' \
"$ACCESS_URL/openai/v1/chat/completions"
```

### Request Headers

*   **Content-Type**: `application/json`
*   **Authorization**: `Bearer <authorization-token>`

### Request Body Example

```json
{
  "model": "model",
  "messages": [
    {
      "role": "system",
      "content": "You are an assistant that speaks in pirate speak."
    },
    {
      "role": "user",
      "content": "Write a poem about colors"
    }
  ],
  "max_tokens": 50,
  "stream": false
}
```
```

--------------------------------

### Monitor Init Script Execution using tail

Source: https://docs.ori.co/virtual-machines/init-scripts

This command allows you to monitor the real-time progress of initialization scripts running on a virtual machine after it has been launched. It is useful for tracking package installations and custom configurations. Ensure you have sudo privileges to execute this command.

```bash
sudo tail -f /var/log/cloud-init-output.log
```

--------------------------------

### Get VM by ID using Java

Source: https://docs.ori.co/api/get-vm

This Java example utilizes Apache HttpClient to make a GET request for VM instance data. It configures the client, sets the request headers including authorization, and processes the JSON response. Replace `:id` and `<API_KEY_VALUE>` accordingly.

```java
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class VmApiClient {

    public static void main(String[] args) {
        String vmId = ":id"; // Replace with actual VM ID
        String apiKey = "<API_KEY_VALUE>"; // Replace with your API Key
        String apiUrl = "https://api.ogc.ori.co/public/v1/vms/instances/" + vmId;

        HttpClient client = HttpClients.createDefault();
        HttpGet request = new HttpGet(apiUrl);

        request.addHeader("Accept", "application/json");
        request.addHeader("Authorization", apiKey);

        try {
            HttpResponse response = client.execute(request);
            HttpEntity entity = response.getEntity();
            if (response.getStatusLine().getStatusCode() == 200) {
                String responseBody = EntityUtils.toString(entity);
                System.out.println(responseBody);
            } else {
                System.out.println("Error: " + response.getStatusLine().getStatusCode() + " - " + EntityUtils.toString(entity));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Get Kubernetes Cluster Information (Java)

Source: https://docs.ori.co/api/get-cluster

Java code example using Apache HttpClient to retrieve Kubernetes cluster details from the Ori.co API. It demonstrates setting headers and parsing the JSON response.

```java
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.json.JSONObject;

public class GetClusterInfo {

    public static void main(String[] args) {
        String apiKey = "<API_KEY_VALUE>";
        String clusterId = ":id";
        String url = "https://api.ogc.ori.co/public/v1/kubernetes/clusters/" + clusterId;

        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpGet request = new HttpGet(url);
            request.addHeader("Accept", "application/json");
            request.addHeader("Authorization", "Bearer " + apiKey);

            try (CloseableHttpResponse response = httpClient.execute(request)) {
                int statusCode = response.getStatusLine().getStatusCode();
                HttpEntity entity = response.getEntity();
                String responseBody = EntityUtils.toString(entity);

                if (statusCode >= 200 && statusCode < 300) {
                    JSONObject clusterJson = new JSONObject(responseBody);
                    System.out.println("Cluster Display Name: " + clusterJson.getString("displayName"));
                    System.out.println("Cluster ID: " + clusterJson.getString("id"));
                    System.out.println("Location: " + clusterJson.getString("locationName"));
                    System.out.println("Status: " + clusterJson.getString("status"));
                } else {
                    System.err.println("API Error: Status Code " + statusCode + ", Response: " + responseBody);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### ogc k8s create Command Help

Source: https://docs.ori.co/cli/commands/ogc_k8s_create/index

Displays help information for the 'ogc k8s create' command, outlining available options and their purpose.

```bash
ogc k8s create --help
```

--------------------------------

### Get VM Template by Name (Java)

Source: https://docs.ori.co/api/get-template

This Java example demonstrates retrieving VM template details using the OkHttp client. It configures the request with the correct URL, headers, and handles the response.

```java
import okhttp3.*; 
import java.io.IOException;

public class OGCClient {

    public static void getTemplate(String templateName, String apiKey) {
        OkHttpClient client = new OkHttpClient();

        String url = "https://api.ogc.ori.co/public/v1/vms/templates/" + templateName;

        Request request = new Request.Builder()
            .url(url)
            .addHeader("Accept", "application/json")
            .addHeader("Authorization", "Bearer " + apiKey)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }

            System.out.println(response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String templateName = "your_template_name";
        String apiKey = "<API_KEY_VALUE>";
        getTemplate(templateName, apiKey);
    }
}
```

--------------------------------

### List and Manage Virtual Machines using OGC CLI

Source: https://docs.ori.co/cli/examples/index

Provides commands for listing all created virtual machines and their current status. It also includes essential administrative actions for managing a VM once it's in an 'Available' state, such as restarting, suspending, resuming, and deleting the instance.

```bash
# List VMs
user@machine ~ % ogc vm list

# Restart VM
user@machine ~ % ogc vm restart 0cc1d7ca-88df-41ba-8713-b4214bf12f0c

# Suspend VM
user@machine ~ % ogc vm suspend 0cc1d7ca-88df-41ba-8713-b4214bf12f0c

# Resume VM
user@machine ~ % ogc vm resume 0cc1d7ca-88df-41ba-8713-b4214bf12f0c

# Delete VM
user@machine ~ % ogc vm delete 0cc1d7ca-88df-41ba-8713-b4214bf12f0c
```

--------------------------------

### Get SSH Key by ID using PowerShell

Source: https://docs.ori.co/api/get-ssh-key/index

Shows a PowerShell script to retrieve an SSH key using its ID. This example utilizes Invoke-RestMethod for API interaction and requires an API key.

```powershell
# PowerShell example not provided in the input text.
```

--------------------------------

### List Available GPU Locations - PowerShell Example

Source: https://docs.ori.co/api/list-endpoint-gpu-locations/index

Example of how to call the list GPU locations endpoint using PowerShell. This script uses Invoke-RestMethod to send the GET request and includes authorization.

```powershell
# PowerShell example would go here
# $apiUrl = "https://api.ogc.ori.co/public/v1/inference/models/availability"
# $apiKey = "<API_KEY_VALUE>"
# 
# $headers = @{
#     "Accept" = "application/json"
#     "Authorization" = $apiKey
# }
# 
# Invoke-RestMethod -Uri $apiUrl -Method Get -Headers $headers
```

--------------------------------

### Health Check Request Examples

Source: https://docs.ori.co/api/health-check/index

Examples of how to perform the health check request using cURL and various programming languages. These snippets demonstrate making a GET request to the health check endpoint and handling the JSON response.

```curl
curl -L 'https://api.ogc.ori.co/public/health' \
-H 'Accept: application/json'
```

```python
import requests

response = requests.get('https://api.ogc.ori.co/public/health', headers={'Accept': 'application/json'})
print(response.json())
```

```go
package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {
	res, err := http.Get("https://api.ogc.ori.co/public/health")
	if err != nil {
		fmt.Printf("Error: %s\n", err)
		return
	}
	defer res.Body.Close()
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %s\n", err)
		return
	}
	fmt.Println(string(body))
}
```

```nodejs
const https = require('https');

https.get('https://api.ogc.ori.co/public/health', (res) => {
  let data = '';
  res.on('data', (chunk) => {
    data += chunk;
  });
  res.on('end', () => {
    console.log(JSON.parse(data));
  });
}).on('error', (err) => {
  console.error('Error:', err);
});
```

```ruby
require 'net/http'
require 'uri'

uri = URI.parse('https://api.ogc.ori.co/public/health')
response = Net::HTTP.get_response(uri)
puts JSON.parse(response.body)
```

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class HealthCheck
{
    public static async Task Main(string[] args)
    {
        using (var client = new HttpClient())
        {
            var response = await client.GetAsync("https://api.ogc.ori.co/public/health");
            var responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}
```

```php
<?php

$response = file_get_contents('https://api.ogc.ori.co/public/health');
$data = json_decode($response, true);
print_r($data);

?>
```

```java
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class HealthCheck {

    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.ogc.ori.co/public/health"))
                .header("Accept", "application/json")
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
```

```powershell
Invoke-WebRequest -Uri "https://api.ogc.ori.co/public/health" -Headers @{"Accept"="application/json"}
```

--------------------------------

### POST /vms/instances

Source: https://docs.ori.co/api/create-vm/index

Creates a new virtual machine instance. Requires specifying display name, location, OS, SSH key, and template. An optional initialization script can also be provided.

```APIDOC
## POST /vms/instances

### Description
Creates a new virtual machine instance. Requires specifying display name, location, OS, SSH key, and template. An optional initialization script can also be provided.

### Method
POST

### Endpoint
https://api.ogc.ori.co/public/v1/vms/instances

### Parameters
#### Query Parameters
None

#### Request Body
- **displayName** (string) - Required - The desired display name for the VM.
- **initScript** (string) - Optional - A script to run on VM initialization.
- **locationName** (string) - Required - The name of the location where the VM will be created.
- **osName** (string) - Required - The name of the operating system for the VM.
- **sshKeyId** (string) - Required - The ID of the SSH key to associate with the VM.
- **templateName** (string) - Required - The name of the VM template to use.

### Request Example
```json
{
  "displayName": "my-vm",
  "initScript": "echo 'Hello World!'",
  "locationName": "lille-4",
  "osName": "Debian-11",
  "sshKeyId": "5272e090-a595-4d6a-8587-cfe78214739f",
  "templateName": "ogc-h100sxm-80"
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier of the newly created VM.

#### Response Example
```json
{
  "id": "5272e090-a595-4d6a-8587-cfe78214739f"
}
```
```

--------------------------------

### OGC Bucket Create Command Syntax and Options

Source: https://docs.ori.co/cli/commands/ogc_bucket_create

This section outlines the basic syntax for creating a bucket using the 'ogc bucket create' command, including available flags for specifying bucket location and type. It also lists inherited options for output formatting.

```shell
ogc bucket create [flags]

### Options
  -h, --help              help for create  
  -r, --location string   Bucket location  
  -t, --type string       Bucket type  

### Options inherited from parent commands
  -x, --output string   Output format. Empty for human-readable, 'json', 'json-line' or 'yaml'
```

--------------------------------

### Get VM Instance by ID (PowerShell)

Source: https://docs.ori.co/api/get-vm/index

Provides a PowerShell script to retrieve a virtual machine instance by its ID. This example uses the `Invoke-RestMethod` cmdlet to send the GET request to the Ori.co API, handling authentication and response parsing.

```powershell
# PowerShell example not provided in the source text.
```

--------------------------------

### Help for 'ogc vm resume' command

Source: https://docs.ori.co/cli/commands/ogc_vm_resume

Displays help information for the 'ogc vm resume' command, including its options and inherited flags.

```bash
ogc vm resume --help
```

--------------------------------

### Get SSH Key by ID using PHP

Source: https://docs.ori.co/api/get-ssh-key/index

Demonstrates retrieving an SSH key by ID in PHP. This example would utilize PHP's cURL or other HTTP client functions to interact with the API.

```php
// PHP example not provided in the input text.
```
Tokens:
Raw