> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cyberwave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# CloudNodeApi

# cyberwave.rest.CloudNodeApi

All URIs are relative to *[http://localhost](http://localhost)*

| Method                                                                                                                     | HTTP request                                                    | Description                  |
| -------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | ---------------------------- |
| [**src\_app\_api\_cloud\_nodes\_create\_instance**](#src_app_api_cloud_nodes_create_instance)                              | **POST** /api/v1/cloud-node                                     | Create Instance              |
| [**src\_app\_api\_cloud\_nodes\_get\_instance\_logs**](#src_app_api_cloud_nodes_get_instance_logs)                         | **GET** `/api/v1/cloud-node/instances/{instance_uuid}/logs`     | Get Instance Logs            |
| [**src\_app\_api\_cloud\_nodes\_get\_instance\_metadata**](#src_app_api_cloud_nodes_get_instance_metadata)                 | **GET** `/api/v1/cloud-node/instances/{instance_uuid}/metadata` | Get Instance Metadata        |
| [**src\_app\_api\_cloud\_nodes\_get\_instance\_status**](#src_app_api_cloud_nodes_get_instance_status)                     | **GET** `/api/v1/cloud-node/instances/{instance_uuid}/status`   | Get Instance Status          |
| [**src\_app\_api\_cloud\_nodes\_list\_instances**](#src_app_api_cloud_nodes_list_instances)                                | **GET** /api/v1/cloud-node/instances                            | List Instances               |
| [**src\_app\_api\_cloud\_nodes\_mark\_instance\_failed**](#src_app_api_cloud_nodes_mark_instance_failed)                   | **POST** `/api/v1/cloud-node/{uuid}/failed`                     | Mark Instance Failed         |
| [**src\_app\_api\_cloud\_nodes\_mark\_instance\_terminated**](#src_app_api_cloud_nodes_mark_instance_terminated)           | **POST** `/api/v1/cloud-node/{uuid}/terminated`                 | Mark Instance Terminated     |
| [**src\_app\_api\_cloud\_nodes\_record\_heartbeat**](#src_app_api_cloud_nodes_record_heartbeat)                            | **POST** `/api/v1/cloud-node/{uuid}/heartbeat`                  | Record Heartbeat             |
| [**src\_app\_api\_cloud\_nodes\_register\_gpu\_instance**](#src_app_api_cloud_nodes_register_gpu_instance)                 | **POST** `/api/v1/cloud-node/{uuid}/register`                   | Register Gpu Instance        |
| [**src\_app\_api\_cloud\_nodes\_save\_cloud\_node\_instance\_log**](#src_app_api_cloud_nodes_save_cloud_node_instance_log) | **POST** `/api/v1/cloud-node/{uuid}/log`                        | Save Cloud Node Instance Log |

# **src\_app\_api\_cloud\_nodes\_create\_instance**

> CloudNodeInstanceSchema src\_app\_api\_cloud\_nodes\_create\_instance(cloud\_node\_instance\_create\_request)

Create Instance

Create a new Cloud Node instance.

The backend is the owner of the UUID and slug:

* If slug is provided, it must be unique within the workspace
* If slug is not provided, an auto-generated slug will be created

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_instance_create_request import CloudNodeInstanceCreateRequest
from cyberwave.rest.models.cloud_node_instance_schema import CloudNodeInstanceSchema
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    cloud_node_instance_create_request = cyberwave.rest.CloudNodeInstanceCreateRequest() # CloudNodeInstanceCreateRequest | 

    try:
        # Create Instance
        api_response = api_instance.src_app_api_cloud_nodes_create_instance(cloud_node_instance_create_request)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_create_instance:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_create_instance: %s\n" % e)
```

### Parameters

| Name                                       | Type                                                                                     | Description | Notes |
| ------------------------------------------ | ---------------------------------------------------------------------------------------- | ----------- | ----- |
| **cloud\_node\_instance\_create\_request** | [**CloudNodeInstanceCreateRequest**](/api-reference/rest/CloudNodeInstanceCreateRequest) |             |       |

### Return type

[**CloudNodeInstanceSchema**](/api-reference/rest/CloudNodeInstanceSchema)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: application/json
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_get\_instance\_logs**

> CloudNodeInstanceLogsResponse src\_app\_api\_cloud\_nodes\_get\_instance\_logs(instance\_uuid, log\_type=log\_type, limit=limit)

Get Instance Logs

Retrieve logs for a Cloud Node (GPU) instance.

Returns log metadata and the combined content of the most recent log entries,
limited to the last N lines (default 100).

Args:
instance\_uuid: UUID of the Cloud Node instance
log\_type: Optional filter by log type ("stdout", "stderr", "system", "app")
limit: Maximum number of lines to return (default 100, max 1000)

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_instance_logs_response import CloudNodeInstanceLogsResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    instance_uuid = 'instance_uuid_example' # str | 
    log_type = 'log_type_example' # str |  (optional)
    limit = 100 # int |  (optional) (default to 100)

    try:
        # Get Instance Logs
        api_response = api_instance.src_app_api_cloud_nodes_get_instance_logs(instance_uuid, log_type=log_type, limit=limit)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_get_instance_logs:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_get_instance_logs: %s\n" % e)
```

### Parameters

| Name               | Type    | Description | Notes                         |
| ------------------ | ------- | ----------- | ----------------------------- |
| **instance\_uuid** | **str** |             |                               |
| **log\_type**      | **str** |             | \[optional]                   |
| **limit**          | **int** |             | \[optional] \[default to 100] |

### Return type

[**CloudNodeInstanceLogsResponse**](/api-reference/rest/CloudNodeInstanceLogsResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: Not defined
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_get\_instance\_metadata**

> Dict\[str, object] src\_app\_api\_cloud\_nodes\_get\_instance\_metadata(instance\_uuid)

Get Instance Metadata

Get the metadata for a Cloud Node instance.

Used by Cloud Node services to self-configure at startup by fetching
their instance-specific configuration (weights URLs, twin UUIDs, etc.)
without needing every field passed as environment variables.

Authentication: Requires CYBERWAVE\_API\_KEY (admin token or instance-specific token)

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    instance_uuid = 'instance_uuid_example' # str | 

    try:
        # Get Instance Metadata
        api_response = api_instance.src_app_api_cloud_nodes_get_instance_metadata(instance_uuid)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_get_instance_metadata:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_get_instance_metadata: %s\n" % e)
```

### Parameters

| Name               | Type    | Description | Notes |
| ------------------ | ------- | ----------- | ----- |
| **instance\_uuid** | **str** |             |       |

### Return type

**Dict\[str, object]**

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: Not defined
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_get\_instance\_status**

> CloudNodeInstanceStatusResponse src\_app\_api\_cloud\_nodes\_get\_instance\_status(instance\_uuid)

Get Instance Status

Get the current status of a Cloud Node (GPU) instance.

Used by Cloud Node (GPU) services to check their registration status and by
monitoring systems to verify instance health.

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_instance_status_response import CloudNodeInstanceStatusResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    instance_uuid = 'instance_uuid_example' # str | 

    try:
        # Get Instance Status
        api_response = api_instance.src_app_api_cloud_nodes_get_instance_status(instance_uuid)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_get_instance_status:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_get_instance_status: %s\n" % e)
```

### Parameters

| Name               | Type    | Description | Notes |
| ------------------ | ------- | ----------- | ----- |
| **instance\_uuid** | **str** |             |       |

### Return type

[**CloudNodeInstanceStatusResponse**](/api-reference/rest/CloudNodeInstanceStatusResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: Not defined
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_list\_instances**

> List\[CloudNodeInstanceSchema] src\_app\_api\_cloud\_nodes\_list\_instances(profile\_slug=profile\_slug, status=status, workspace\_slug=workspace\_slug)

List Instances

List Cloud Node instances for a workspace.

Optionally filter by profile\_slug or status.
If workspace\_slug is provided, uses that workspace; otherwise uses the user's default.

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_instance_schema import CloudNodeInstanceSchema
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    profile_slug = 'profile_slug_example' # str |  (optional)
    status = 'status_example' # str |  (optional)
    workspace_slug = 'workspace_slug_example' # str |  (optional)

    try:
        # List Instances
        api_response = api_instance.src_app_api_cloud_nodes_list_instances(profile_slug=profile_slug, status=status, workspace_slug=workspace_slug)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_list_instances:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_list_instances: %s\n" % e)
```

### Parameters

| Name                | Type    | Description | Notes       |
| ------------------- | ------- | ----------- | ----------- |
| **profile\_slug**   | **str** |             | \[optional] |
| **status**          | **str** |             | \[optional] |
| **workspace\_slug** | **str** |             | \[optional] |

### Return type

[**List\[CloudNodeInstanceSchema\]**](/api-reference/rest/CloudNodeInstanceSchema)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: Not defined
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_mark\_instance\_failed**

> CloudNodeFailedResponse src\_app\_api\_cloud\_nodes\_mark\_instance\_failed(uuid, cloud\_node\_failed\_request)

Mark Instance Failed

Mark a Cloud Node (GPU) instance as failed.

Called by the GitHub Actions workflow when provisioning fails or
the instance crashes unexpectedly. Any associated workloads will be re-queued.

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_failed_request import CloudNodeFailedRequest
from cyberwave.rest.models.cloud_node_failed_response import CloudNodeFailedResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    uuid = 'uuid_example' # str | 
    cloud_node_failed_request = cyberwave.rest.CloudNodeFailedRequest() # CloudNodeFailedRequest | 

    try:
        # Mark Instance Failed
        api_response = api_instance.src_app_api_cloud_nodes_mark_instance_failed(uuid, cloud_node_failed_request)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_mark_instance_failed:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_mark_instance_failed: %s\n" % e)
```

### Parameters

| Name                             | Type                                                                     | Description | Notes |
| -------------------------------- | ------------------------------------------------------------------------ | ----------- | ----- |
| **uuid**                         | **str**                                                                  |             |       |
| **cloud\_node\_failed\_request** | [**CloudNodeFailedRequest**](/api-reference/rest/CloudNodeFailedRequest) |             |       |

### Return type

[**CloudNodeFailedResponse**](/api-reference/rest/CloudNodeFailedResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: application/json
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_mark\_instance\_terminated**

> CloudNodeTerminatedResponse src\_app\_api\_cloud\_nodes\_mark\_instance\_terminated(uuid, cloud\_node\_terminated\_request)

Mark Instance Terminated

Mark a Cloud Node (GPU) instance as terminated.

Called by the package (cyberwave-cloud-node) once a termination is triggered OR by the GitHub Actions workflow after Terraform has successfully (when used by us)

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_terminated_request import CloudNodeTerminatedRequest
from cyberwave.rest.models.cloud_node_terminated_response import CloudNodeTerminatedResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    uuid = 'uuid_example' # str | 
    cloud_node_terminated_request = cyberwave.rest.CloudNodeTerminatedRequest() # CloudNodeTerminatedRequest | 

    try:
        # Mark Instance Terminated
        api_response = api_instance.src_app_api_cloud_nodes_mark_instance_terminated(uuid, cloud_node_terminated_request)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_mark_instance_terminated:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_mark_instance_terminated: %s\n" % e)
```

### Parameters

| Name                                 | Type                                                                             | Description | Notes |
| ------------------------------------ | -------------------------------------------------------------------------------- | ----------- | ----- |
| **uuid**                             | **str**                                                                          |             |       |
| **cloud\_node\_terminated\_request** | [**CloudNodeTerminatedRequest**](/api-reference/rest/CloudNodeTerminatedRequest) |             |       |

### Return type

[**CloudNodeTerminatedResponse**](/api-reference/rest/CloudNodeTerminatedResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: application/json
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_record\_heartbeat**

> CloudeNodeHeartbeatResponse src\_app\_api\_cloud\_nodes\_record\_heartbeat(uuid)

Record Heartbeat

Record a heartbeat from a Cloud Node (GPU) instance.

Called periodically by the Cloud Node (GPU) service to signal it is alive and healthy.
Missing heartbeats will cause the instance to be marked as stale and terminated.

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloude_node_heartbeat_response import CloudeNodeHeartbeatResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    uuid = 'uuid_example' # str | 

    try:
        # Record Heartbeat
        api_response = api_instance.src_app_api_cloud_nodes_record_heartbeat(uuid)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_record_heartbeat:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_record_heartbeat: %s\n" % e)
```

### Parameters

| Name     | Type    | Description | Notes |
| -------- | ------- | ----------- | ----- |
| **uuid** | **str** |             |       |

### Return type

[**CloudeNodeHeartbeatResponse**](/api-reference/rest/CloudeNodeHeartbeatResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: Not defined
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_register\_gpu\_instance**

> CloudeNodeInstanceRegisterResponse src\_app\_api\_cloud\_nodes\_register\_gpu\_instance(uuid, cloud\_node\_instance\_register\_request)

Register Gpu Instance

Register a Cloud Node (GPU) instance after it has booted and is ready to serve.

Called by the Cloud Node (GPU) service once its dependencies (e.g. CUDA, etc)
are available and the service is listening.

This endpoint only registers an existing instance. The instance must have been
created via the create endpoint first. The profile\_slug can be updated during
registration to reflect the actual running profile.

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_instance_register_request import CloudNodeInstanceRegisterRequest
from cyberwave.rest.models.cloude_node_instance_register_response import CloudeNodeInstanceRegisterResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    uuid = 'uuid_example' # str | 
    cloud_node_instance_register_request = cyberwave.rest.CloudNodeInstanceRegisterRequest() # CloudNodeInstanceRegisterRequest | 

    try:
        # Register Gpu Instance
        api_response = api_instance.src_app_api_cloud_nodes_register_gpu_instance(uuid, cloud_node_instance_register_request)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_register_gpu_instance:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_register_gpu_instance: %s\n" % e)
```

### Parameters

| Name                                         | Type                                                                                         | Description | Notes |
| -------------------------------------------- | -------------------------------------------------------------------------------------------- | ----------- | ----- |
| **uuid**                                     | **str**                                                                                      |             |       |
| **cloud\_node\_instance\_register\_request** | [**CloudNodeInstanceRegisterRequest**](/api-reference/rest/CloudNodeInstanceRegisterRequest) |             |       |

### Return type

[**CloudeNodeInstanceRegisterResponse**](/api-reference/rest/CloudeNodeInstanceRegisterResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: application/json
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |

# **src\_app\_api\_cloud\_nodes\_save\_cloud\_node\_instance\_log**

> CloudNodeLogResponse src\_app\_api\_cloud\_nodes\_save\_cloud\_node\_instance\_log(uuid, cloud\_node\_log\_request)

Save Cloud Node Instance Log

Save a log entry for a Cloud Node (GPU) instance.

Logs are stored asynchronously in GCS with metadata in the database.
This allows Cloud Node instances to stream logs without blocking.

### Example

* Api Key Authentication (CustomTokenAuthentication):

```python theme={null}
import cyberwave.rest
from cyberwave.rest.models.cloud_node_log_request import CloudNodeLogRequest
from cyberwave.rest.models.cloud_node_log_response import CloudNodeLogResponse
from cyberwave.rest.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = cyberwave.rest.Configuration(
    host = "http://localhost"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

# Configure API key authorization: CustomTokenAuthentication
configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"]

# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer'

# Enter a context with an instance of the API client
with cyberwave.rest.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cyberwave.rest.CloudNodeApi(api_client)
    uuid = 'uuid_example' # str | 
    cloud_node_log_request = cyberwave.rest.CloudNodeLogRequest() # CloudNodeLogRequest | 

    try:
        # Save Cloud Node Instance Log
        api_response = api_instance.src_app_api_cloud_nodes_save_cloud_node_instance_log(uuid, cloud_node_log_request)
        print("The response of CloudNodeApi->src_app_api_cloud_nodes_save_cloud_node_instance_log:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling CloudNodeApi->src_app_api_cloud_nodes_save_cloud_node_instance_log: %s\n" % e)
```

### Parameters

| Name                          | Type                                                               | Description | Notes |
| ----------------------------- | ------------------------------------------------------------------ | ----------- | ----- |
| **uuid**                      | **str**                                                            |             |       |
| **cloud\_node\_log\_request** | [**CloudNodeLogRequest**](/api-reference/rest/CloudNodeLogRequest) |             |       |

### Return type

[**CloudNodeLogResponse**](/api-reference/rest/CloudNodeLogResponse)

### Authorization

CustomTokenAuthentication

### HTTP request headers

* **Content-Type**: application/json
* **Accept**: application/json

### HTTP response details

| Status code | Description | Response headers |
| ----------- | ----------- | ---------------- |
| **200**     | OK          | -                |