Gets all hosts from the orchestrator

/api/v1/orchestrator/hosts Authorized

This endpoint returns all hosts from the orchestrator

Request examples

      
      /v1/orchestrator/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Gets a host from the orchestrator

/api/v1/orchestrator/hosts/{id} Authorized

This endpoint returns a host from the orchestrator

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Gets a host hardware info from the orchestrator

/api/v1/orchestrator/hosts/{id}/hardware Authorized

This endpoint returns a host hardware info from the orchestrator

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/hardware
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/hardware' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/hardware");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/hardware"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Register a Host in the orchestrator

/api/v1/orchestrator/hosts Authorized

This endpoint register a host in the orchestrator

Parameters

Name	Type	In	Required	Description
`hostRequest`	`object`	body	optional	Host Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Unregister a host from the orchestrator

/api/v1/orchestrator/hosts/{id} Authorized

This endpoint unregister a host from the orchestrator

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Enable a host in the orchestrator

/api/v1/orchestrator/hosts/{id}/enable Authorized

This endpoint will enable an existing host in the orchestrator

Request examples

      
      /v1/orchestrator/hosts/{id}/enable
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/enable' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/enable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/enable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Disable a host in the orchestrator

/api/v1/orchestrator/hosts/{id}/disable Authorized

This endpoint will disable an existing host in the orchestrator

Request examples

      
      /v1/orchestrator/hosts/{id}/disable
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/disable' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/disable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/disable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Update a Host in the orchestrator

/api/v1/orchestrator/hosts Authorized

This endpoint updates a host in the orchestrator

Parameters

Name	Type	In	Required	Description
`hostRequest`	`object`	body	optional	Host Update Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Get orchestrator resource overview

/api/v1/orchestrator/overview/resources Authorized

This endpoint returns orchestrator resource overview

Request examples

      
      /v1/orchestrator/overview/resources
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/overview/resources' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/overview/resources");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/overview/resources"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Get orchestrator host resources

/api/v1/orchestrator/overview/{id}/resources Authorized

This endpoint returns orchestrator host resources

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/overview/{id}/resources
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/overview/{id}/resources' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/overview/{id}/resources");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/overview/{id}/resources"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Get orchestrator Virtual Machines

/api/v1/orchestrator/machines Authorized

This endpoint returns orchestrator Virtual Machines

Request examples

      
      /v1/orchestrator/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Get orchestrator Virtual Machine

/api/v1/orchestrator/machines/{id} Authorized

This endpoint returns orchestrator Virtual Machine by its ID

Request examples

      
      /v1/orchestrator/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deletes orchestrator virtual machine

/api/v1/orchestrator/machines/{id} Authorized

This endpoint deletes orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID
`force`	`query`	query	optional	-

Request examples

      
      /v1/orchestrator/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/machines/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Get orchestrator virtual machine status

/api/v1/orchestrator/machines/{id}/status Authorized

This endpoint returns orchestrator virtual machine status

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/status
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/status' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{id}/status");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/status"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Renames orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/rename Authorized

This endpoint renames orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/rename
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/rename' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/rename");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/rename"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Configures orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/set Authorized

This endpoint configures orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/set
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/set' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/set");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/set"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Starts orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/start Authorized

This endpoint starts orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/start
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/start' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/start");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/start"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Stops orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/stop Authorized

This endpoint sops orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID
`force`	`query`	query	optional	-

Request examples

      
      /v1/orchestrator/machines/{id}/stop
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/stop' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/stop");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/stop"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Restarts orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/restart Authorized

This endpoint restarts orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/restart
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/restart' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/restart"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Suspends orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/suspend Authorized

This endpoint suspends orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/suspend
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/suspend' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/suspend");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/suspend"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Resumes orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/resume Authorized

This endpoint resumes orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/resume
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/resume' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/resume");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/resume"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Resets orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/reset Authorized

This endpoint resets orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/reset
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/reset' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/reset");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/reset"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Pauses orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/pause Authorized

This endpoint pauses orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/pause
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/pause' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/pause");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/pause"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Clones orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/clone Authorized

This endpoint clones orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID
`configRequest`	`object`	body	optional	Machine Clone Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/machines/{id}/clone
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/clone' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/clone");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/clone"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Executes a command in a orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/execute Authorized

This endpoint executes a command in a orchestrator virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/execute
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/execute' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/execute");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/execute"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Get orchestrator host virtual machines

/api/v1/orchestrator/hosts/{id}/machines Authorized

This endpoint returns orchestrator host virtual machines

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Get orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized

This endpoint returns orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deletes orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized

This endpoint deletes orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`force`	`query`	query	optional	-

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Get orchestrator host virtual machine status

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status Authorized

This endpoint returns orchestrator host virtual machine status

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/status
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Renames orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename Authorized

This endpoint renames orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/rename
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Configures orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set Authorized

This endpoint configures orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/set
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Starts orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start Authorized

This endpoint starts orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/start
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Stops orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop Authorized

This endpoint stops orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`force`	`query`	query	optional	-

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/stop
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Restarts orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/restart Authorized

This endpoint restarts orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/restart
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/restart' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/restart"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Suspends orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/suspend Authorized

This endpoint suspends orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/suspend
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/suspend' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/suspend");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/suspend"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Resumes orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/resume Authorized

This endpoint resumes orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/resume
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/resume' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/resume");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/resume"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Resets orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/reset Authorized

This endpoint resets orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/reset
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/reset' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/reset");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/reset"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Pauses orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/pause Authorized

This endpoint pauses orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/pause
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/pause' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/pause");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/pause"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Clones orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/clone Authorized

This endpoint clones orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`configRequest`	`object`	body	optional	Machine Clone Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/clone
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/clone' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/clone");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/clone"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Executes a command in a orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute Authorized

This endpoint executes a command in a orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/execute
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Lists snapshots of orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots Authorized

This endpoint lists snapshots of orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a snapshot for orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots Authorized

This endpoint creates a snapshot for orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`createRequest`	`object`	body	optional	Create Snapshot Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deletes all snapshots of orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots Authorized

This endpoint deletes all snapshots of orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Deletes a snapshot of orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id} Authorized

This endpoint deletes a snapshot of orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`snapshot_id`	`string`	path	required	Snapshot ID

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Reverts orchestrator host virtual machine to a snapshot

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}/revert Authorized

This endpoint reverts orchestrator host virtual machine to a snapshot

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`snapshot_id`	`string`	path	required	Snapshot ID
`revertRequest`	`object`	body	optional	Revert Snapshot Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}/revert
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}/revert' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}/revert");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/snapshots/{snapshot_id}/revert"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Lists snapshots of an orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/snapshots Authorized

This endpoint lists snapshots of an orchestrator virtual machine (host resolved automatically)

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/snapshots' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{id}/snapshots");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/snapshots"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a snapshot for an orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/snapshots Authorized

This endpoint creates a snapshot for an orchestrator virtual machine (host resolved automatically)

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID
`createRequest`	`object`	body	optional	Create Snapshot Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/machines/{id}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/snapshots' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/machines/{id}/snapshots");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/snapshots"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deletes all snapshots of an orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/snapshots Authorized

This endpoint deletes all snapshots of an orchestrator virtual machine (host resolved automatically)

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID

Request examples

      
      /v1/orchestrator/machines/{id}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/snapshots' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/machines/{id}/snapshots");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/snapshots"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Deletes a snapshot of an orchestrator virtual machine

/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id} Authorized

This endpoint deletes a snapshot of an orchestrator virtual machine (host resolved automatically)

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID
`snapshot_id`	`string`	path	required	Snapshot ID

Request examples

      
      /v1/orchestrator/machines/{id}/snapshots/{snapshot_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Reverts an orchestrator virtual machine to a snapshot

/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}/revert Authorized

This endpoint reverts an orchestrator virtual machine to a snapshot (host resolved automatically)

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Virtual Machine ID
`snapshot_id`	`string`	path	required	Snapshot ID
`revertRequest`	`object`	body	optional	Revert Snapshot Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/machines/{id}/snapshots/{snapshot_id}/revert
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}/revert' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}/revert");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/{id}/snapshots/{snapshot_id}/revert"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Register a virtual machine in a orchestrator host

/api/v1/orchestrator/hosts/{id}/machines/register Authorized

This endpoint registers a virtual machine in a orchestrator host

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`request`	`object`	body	optional	Register Virtual Machine Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/register
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/register' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/register");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/register"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Unregister a virtual machine in a orchestrator host

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister Authorized

This endpoint unregister a virtual machine in a orchestrator host

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`vmId`	`string`	path	required	Virtual Machine ID
`request`	`object`	body	optional	Register Virtual Machine Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/{vmId}/unregister
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a orchestrator host virtual machine

/api/v1/orchestrator/hosts/{id}/machines Authorized

This endpoint creates a orchestrator host virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`request`	`object`	body	optional	Create Virtual Machine Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a virtual machine in one of the hosts for the orchestrator

/api/v1/orchestrator/machines Authorized

This endpoint creates a virtual machine in one of the hosts for the orchestrator

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Create Virtual Machine Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Gets orchestrator host reverse proxy configuration

/api/v1/orchestrator/hosts/{id}/reverse-proxy Authorized

This endpoint returns orchestrator host reverse proxy configuration

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Gets orchestrator host reverse proxy hosts

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized

This endpoint returns orchestrator host reverse proxy hosts

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Gets orchestrator host reverse proxy hosts

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint returns orchestrator host reverse proxy hosts

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a orchestrator host reverse proxy host

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized

This endpoint creates a orchestrator host reverse proxy host

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Create Host Reverse Proxy Host Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Updates an orchestrator host reverse proxy host

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint updates an orchestrator host reverse proxy host

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Update Host Reverse Proxy Host Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deletes an orchestrator host reverse proxy host

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint deletes an orchestrator host reverse proxy host

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`reverse_proxy_host_id`	`string`	path	required	Reverse Proxy Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Upserts an orchestrator host reverse proxy host http route

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes Authorized

This endpoint upserts an orchestrator host reverse proxy host http route

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Upsert Host Reverse Proxy Host Http Routes Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deletes an orchestrator host reverse proxy host http route

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id} Authorized

This endpoint deletes an orchestrator host reverse proxy host http route

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`reverse_proxy_host_id`	`string`	path	required	Reverse Proxy Host ID
`route_id`	`string`	path	required	Route ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Update an orchestrator host reverse proxy host tcp route

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route Authorized

This endpoint updates an orchestrator host reverse proxy host tcp route

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Update Host Reverse Proxy Host tcp Routes Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Restarts orchestrator host reverse proxy

/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart Authorized

This endpoint restarts orchestrator host reverse proxy

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/restart
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Enables orchestrator host reverse proxy

/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable Authorized

This endpoint enables orchestrator host reverse proxy

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/enable
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Disables orchestrator host reverse proxy

/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable Authorized

This endpoint disables orchestrator host reverse proxy

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/reverse-proxy/disable
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Gets orchestrator host catalog cache

/api/v1/orchestrator/hosts/{id}/catalog/cache Authorized

This endpoint returns orchestrator host catalog cache

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Deletes an orchestrator host cache items

/api/v1/orchestrator/hosts/{id}/catalog/cache Authorized

This endpoint deletes an orchestrator host cache items

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Deletes an orchestrator host cache item and all its children

/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id} Authorized

This endpoint deletes an orchestrator host cache item and all its children

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`catalog_id`	`string`	path	required	Catalog ID

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Deletes an orchestrator host cache item and all its children

/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version} Authorized

This endpoint deletes an orchestrator host cache item and all its children

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`catalog_id`	`string`	path	required	Catalog ID
`catalog_version`	`string`	path	required	Catalog Version

Request examples

      
      /v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

Create an enrollment token

/api/v1/orchestrator/enrollment-token Authorized

Generates a short-lived, single-use token that allows a freshly installed agent to register itself with the orchestrator without requiring a permanent credential.

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Enrollment token request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/enrollment-token
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/enrollment-token' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/enrollment-token");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/enrollment-token"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Validate an enrollment token

/api/v1/orchestrator/enrollment-token/{token}/validate Authorized

Public endpoint that checks whether an enrollment token is valid, unused, and not expired. Used by agents before starting the registration flow.

Parameters

Name	Type	In	Required	Description
`token`	`string`	path	required	Enrollment token value

Request examples

      
      /v1/orchestrator/enrollment-token/{token}/validate
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/enrollment-token/{token}/validate' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/enrollment-token/{token}/validate");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/enrollment-token/{token}/validate"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Deploy and register an agent via SSH (synchronous)

/api/v1/orchestrator/hosts/deploy Authorized

SSHes into a remote host, installs the devops agent, and registers it with this orchestrator. Blocks until the operation completes.

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Deploy request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/deploy
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/deploy' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/deploy");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/deploy"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Deploy and register an agent via SSH (asynchronous)

/api/v1/orchestrator/hosts/deploy/async Authorized

SSHes into a remote host, installs the devops agent, and registers it with this orchestrator. Returns a job ID immediately; poll /jobs/{id} for status.

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Deploy request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/deploy/async
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/deploy/async' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/deploy/async");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/deploy/async"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a virtual machine in one of the orchestrator hosts asynchronously

/api/v1/orchestrator/machines/async Authorized

This endpoint creates a virtual machine in one of the orchestrator hosts in the background and returns a Job ID to track progress

Parameters

Name	Type	In	Required	Description
`request`	`object`	body	optional	Create Virtual Machine Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/machines/async
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/machines/async' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/machines/async");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/machines/async"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Creates a virtual machine in a specific orchestrator host asynchronously

/api/v1/orchestrator/hosts/{id}/machines/async Authorized

This endpoint creates a virtual machine in a specific orchestrator host in the background and returns a Job ID to track progress

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID
`request`	`object`	body	optional	Create Virtual Machine Request
Schema `{ object }`

Request examples

      
      /v1/orchestrator/hosts/{id}/machines/async
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/async' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/async");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();

package main

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

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/machines/async"
  method := "post"
  payload := strings.NewReader(`{ object }`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

Responses

{ object }

{ object }

{ object }

Orchestrator endpoints

Gets all hosts from the orchestrator

Gets a host from the orchestrator

Parameters

Gets a host hardware info from the orchestrator

Parameters

Register a Host in the orchestrator

Parameters

Unregister a host from the orchestrator

Parameters

Enable a host in the orchestrator

Disable a host in the orchestrator

Update a Host in the orchestrator

Parameters

Get orchestrator resource overview

Get orchestrator host resources

Parameters

Get orchestrator Virtual Machines

Get orchestrator Virtual Machine

Deletes orchestrator virtual machine

Parameters

Get orchestrator virtual machine status

Parameters

Renames orchestrator virtual machine

Parameters

Configures orchestrator virtual machine

Parameters

Starts orchestrator virtual machine

Parameters

Stops orchestrator virtual machine

Parameters

Restarts orchestrator virtual machine

Parameters

Suspends orchestrator virtual machine

Parameters

Resumes orchestrator virtual machine

Parameters

Resets orchestrator virtual machine

Parameters

Pauses orchestrator virtual machine

Parameters

Clones orchestrator virtual machine

Parameters

Executes a command in a orchestrator virtual machine

Parameters

Get orchestrator host virtual machines

Parameters

Get orchestrator host virtual machine

Parameters

Deletes orchestrator host virtual machine

Parameters

Get orchestrator host virtual machine status

Parameters

Renames orchestrator host virtual machine

Parameters

Configures orchestrator host virtual machine

Parameters

Starts orchestrator host virtual machine

Parameters

Stops orchestrator host virtual machine

Parameters

Restarts orchestrator host virtual machine

Parameters

Suspends orchestrator host virtual machine

Parameters

Resumes orchestrator host virtual machine

Parameters

Resets orchestrator host virtual machine

Parameters

Pauses orchestrator host virtual machine

Parameters

Clones orchestrator host virtual machine

Parameters

Executes a command in a orchestrator host virtual machine

Parameters

Lists snapshots of orchestrator host virtual machine

Parameters

Creates a snapshot for orchestrator host virtual machine

Parameters

Deletes all snapshots of orchestrator host virtual machine