After creating a GPU cluster, use the cluster details page to monitor nodes, manage cluster and node lifecycle, configure network interfaces, and access administration tools.
Cluster management operates at two levels: cluster-wide operations (resize, reconfigure, delete) that affect all nodes at once, and per-node operations (rebuild, replace, power, apply settings) that target individual nodes independently.
## Access cluster details
1. In the [Gcore Customer Portal](https://portal.gcore.com), navigate to **GPU Cloud**.
2. In the sidebar, expand **GPU Clusters** and select **Bare Metal GPU Clusters**.
3. Click on a cluster name to open the details page.
The cluster details page shows the cluster name, current status badge, and cluster ID at the top. Below that, a header panel displays the following fields:
| Field | Description |
| --------- | ------------------------------------------------------------------------------------------------------------ |
| Pkey ID | InfiniBand Partition Key ID. Displayed as "-" if InfiniBand is not configured or during cluster provisioning |
| OS Distro | Operating system image installed on all nodes |
| Region | Data center location |
| Plan | Monthly pricing plan for the cluster |
The page is organized into tabs: **Overview**, **Power**, **Networking**, **Tags**, **User Actions**, and **Delete**.
## View cluster nodes
The **Overview** tab lists all nodes (servers) in the cluster. Each node entry shows the node name, flavor, assigned IP addresses, status, timestamps, cost, and other metadata. The table supports filtering by name, date range, and status.
Each node inherits its **cluster configuration** — image, SSH key, and user data — from the cluster. Network interfaces and file shares cannot be changed at the node level after creation. To update the cluster configuration, use **Reconfigure Cluster**; to sync a specific outdated node, use **Apply settings**.
## Cluster lifecycle
Cluster lifecycle operations control the cluster as a whole — adjusting its size, updating the shared configuration, and deleting it when no longer needed.
### Manage cluster size
Cluster size can be adjusted after creation by adding or removing nodes.
1. On the **Overview** tab, click **Resize Cluster**.
2. Adjust the instance count using the **+** and **-** buttons.
3. Click **Resize**.
New nodes inherit the current cluster configuration. While resizing, most management actions are unavailable; Bare Metal H100 nodes may take 15–40 minutes to provision.
Scaling down to zero nodes is not allowed. When scaling down, the system removes a random node — to target a specific node, use **Delete node** in [Node management](#node-management) instead.
### Reconfigure cluster
The **Reconfigure Cluster** button in the top-right corner of the cluster details page opens a two-step flow for changing the cluster configuration and choosing how to apply it.
**Step 1 — Update settings**
The form shows the current **Image**, **SSH Key**, and **User data**, each with a dropdown labeled **Current**. Use the dropdown to select a new value, or leave it unchanged to keep the current setting. Click **Next** to proceed.
**Step 2 — Choose update method**
| Option | Description |
| ---------------------- | ----------------------------------------------------------------------------------------------------------- |
| **Save only** | The new configuration will be used for future scale-ups or the next rebuild. Existing nodes are unaffected. |
| **Apply settings now** | Apply changes immediately to selected nodes or the entire cluster. |
| **Schedule for later** | Apply updates automatically at a specific time. Coming soon. |
When **Apply settings now** is selected, select **All Instances in Cluster** or **Selected Instances** under **Apply to**. Click **Reconfigure** to confirm.
Changes that require a node rebuild permanently delete all data on the system volume of affected nodes. IP addresses, hostname, and attached volumes are preserved.
### Delete cluster
When a cluster is deleted, local NVMe storage is permanently erased; file shares and object storage remain intact.
1. Navigate to the **Delete** tab on the cluster details page.
2. Click **Delete Cluster**.
3. Confirm the deletion.
Cluster deletion is irreversible. Data on local NVMe storage cannot be recovered.
## Node management
Node management operations target individual servers in the cluster independently — controlling power state, reinstalling the OS, swapping out failed nodes, and syncing updated cluster configuration to specific nodes.
### Power actions
To control a single node:
1. Locate the node in the cluster list.
2. Click the actions menu (three dots) on the node row.
3. Select the desired action: **Power on**, **Power off**, **Soft reboot**, or **Hard reboot**.
To apply power actions to multiple nodes at once, select them using the checkboxes, click **Group actions**, and choose the action. Alternatively, use the **Power** tab to soft or hard reboot all cluster nodes simultaneously.
### Rebuild node
Rebuild reinstalls the OS on a node. The dialog shows the current **Image**, **SSH Key**, and **User data**. Use the dropdown next to any field to select a new value for this rebuild, or leave it unchanged to keep the current setting. All data on local storage is deleted.
1. Click the actions menu (three dots) on the node row.
2. Select **Rebuild**.
3. In the dialog, change **Image**, **SSH Key**, or **User data** as needed, or leave them to keep current values.
4. Type `Rebuild` to confirm and click **Rebuild**.
To rebuild multiple nodes at once, select them using checkboxes, click **Group actions**, and select **Rebuild**. The dialog offers two modes: **Apply same settings to all Instances** or **Per Instance configuration**.
Rebuild deletes all data on the node's local storage. Node identity is preserved — IP addresses, hostname, and attached volumes remain unchanged.
### Replace node
Replace deletes the current node and provisions a new one with the same configuration (flavor, image, network settings). Use this to recover a node stuck in a failed state without changing the cluster setup.
1. Click the actions menu (three dots) on the node row.
2. Select **Replace**.
3. Confirm the operation.
### Delete node
To permanently remove a single node from the cluster:
1. Locate the node in the cluster list.
2. Click the actions menu (three dots) on the node row.
3. Select **Delete**.
4. Confirm the deletion.
Deleting the last node in a cluster automatically deletes the entire cluster. This applies to both UI and API/Terraform operations. When using the API or Terraform to delete nodes, no warning is displayed before the cluster is removed. Leave at least one node in the cluster to preserve it.
### Apply settings
When a node's cluster configuration is outdated — because the cluster was reconfigured but that node was not yet updated — a warning appears in the node details panel.
1. Click a node name in the **Overview** tab to open its details panel.
2. Click **Apply settings**.
3. Review the diff table: each row shows the **Setting**, **Current** value, and **After Apply** value.
4. Select or deselect nodes to include.
5. Type `Apply` and click **Apply**.
To apply settings to multiple outdated nodes at once, select them using checkboxes in the **Overview** tab, click **Group actions**, and select **Apply settings**.
## Networking
Network interfaces are assigned to each node at cluster creation. The Networking tab provides visibility into each node's interfaces and supports adding new ones after creation.
### View interfaces
The **Networking** tab displays network interfaces for each node. Click a node name to expand its interface details.
| Type | Description |
| ---------- | ----------------------------------------------------------------------- |
| Public | External IP address for internet access |
| Private | Internal network for communication with other cloud resources |
| InfiniBand | High-speed, low-latency inter-node network for GPU-to-GPU communication |
For flavors with InfiniBand, multiple InfiniBand interfaces are created automatically (by default, 8 for H100 configurations). These appear as "GPU-cluster ib-subnet" entries in the interface list. Click on an interface to expand its details, including IP address and network configuration.
### Modify interfaces
To add network interfaces on a specific node:
1. Navigate to the **Networking** tab.
2. Click a node to expand its details.
3. Click **Add Interface** or **Add Sub-Interface**.
4. Configure the interface type (public or private) and IP allocation settings as supported by the service.
Only network interfaces can be modified on individual nodes after cluster creation. Image and storage configuration cannot be changed independently at the node level. InfiniBand interfaces are managed automatically and cannot be modified or deleted.
## Administration
Administrative tools for organizing clusters with tags, tracking operations through the audit log, and accessing nodes for troubleshooting via the browser console.
### Tags
Tags are applied at the cluster level and inherited by all nodes.
1. Navigate to the **Tags** tab on the cluster details page.
2. Enable the **Add custom tags** checkbox.
3. Enter the key and value for each tag.
4. Click **Save changes**.
Tags can be modified even while the cluster is in the Resizing state.
### User actions
The **User Actions** tab displays a log of all operations performed on the cluster — creation, deletion, resize, power, and network actions. Use the date and action type filters to narrow results.
### Console
For troubleshooting or when SSH access is unavailable, use the browser-based console.
1. In the **Overview** tab, locate the target node.
2. Click **Open Console** in the node row.
3. The console opens in a new browser tab using noVNC.
4. Log in with the same credentials used for SSH access.
The Customer Portal is suitable for managing individual clusters. For automated workflows — CI/CD pipelines, infrastructure-as-code, or batch provisioning — use the [GPU Bare Metal API](/api-reference/cloud/gpu-bare-metal) instead.
Use the REST API to inspect clusters, resize them, manage node lifecycle operations, and automate cluster administration workflows.
An [API token](/account-settings/api-tokens) is required, along with a
[project ID](/api-reference/cloud/projects/list-projects)
and a [region ID](/api-reference/cloud/regions/list-regions).
Open a terminal and set these environment variables before running the examples:
```bash theme={null}
export GCORE_API_KEY="{YOUR_API_KEY}"
export GCORE_CLOUD_PROJECT_ID="{YOUR_PROJECT_ID}"
export GCORE_CLOUD_REGION_ID="{YOUR_REGION_ID}"
```
Most write operations are asynchronous and return `{ "tasks": ["task-uuid"] }`. Poll GET /cloud/v1/tasks/\{task\_id} every 5 seconds until `state` is `FINISHED`. Bare Metal H100 nodes may take 15–40 minutes for provisioning operations.
## List bare metal GPU clusters
The list endpoint returns all clusters in a project and region. Use query filters to narrow results — multiple filters are ANDed, so a cluster must match all specified conditions.
Available filters:
| Filter | Operators | Description |
| --------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `ids` | — | Return clusters with specific IDs. Repeat the parameter for multiple values: `ids=uuid1&ids=uuid2` |
| `name` | `contains`, `exact`, `prefix`, `suffix` | Match cluster name (case-insensitive) |
| `flavor` | `contains`, `exact`, `prefix`, `suffix` | Match flavor name (case-insensitive) |
| `image_ids` | — | Return clusters provisioned with specific image IDs. Repeat for multiple values |
| `servers_count` | `gte`, `lte`, `gt`, `lt` | Filter by node count |
| `managed_by` | — | Return clusters by management type. Accepted values: `user` (directly managed) or `k8s` (managed by Kubernetes) |
| `created_at` | `gt`, `gte`, `lt`, `lte` | Filter by creation time (UTC ISO 8601) |
| `updated_at` | `gt`, `gte`, `lt`, `lte` | Filter by last-update time (UTC ISO 8601) |
| `tags` | `[key]=value` | Exact tag key-value pair. Multiple pairs are ANDed; values match case-insensitively |
| `tag_key` | `contains`, `exact`, `prefix`, `suffix` | Match tag key regardless of value |
| `tag_value` | `contains`, `exact`, `prefix`, `suffix` | Match tag value regardless of key |
The Python and Go SDKs support `limit` and `offset` for pagination only. Name, flavor, node count, tag, image, and date filters are available via curl only.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
page = client.cloud.gpu_baremetal.clusters.list(
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
)
for cluster in page.results:
print(cluster.id, cluster.name, cluster.servers_count, cluster.status)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
gcore "github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
page, err := client.Cloud.GPUBaremetal.Clusters.List(context.TODO(),
cloud.GPUBaremetalClusterListParams{
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
})
if err != nil {
panic(err)
}
fmt.Printf("Total: %d\n", len(page.Results))
for _, c := range page.Results {
fmt.Printf(" %s %s nodes=%d\n", c.ID, c.Name, c.ServersCount)
}
}
```
```bash theme={null}
curl -G "https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters" \
-H "Authorization: APIKey ${GCORE_API_KEY}" \
--data-urlencode "name[prefix]=prod-" \
--data-urlencode "flavor[prefix]=bm3-" \
--data-urlencode "servers_count[gte]=4" \
--data-urlencode "tags[env]=production"
```
Response:
```json theme={null}
{
"count": 1,
"results": [
{
"id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"name": "prod-bm-cluster-1",
"status": "active",
"flavor": "bm3-ai-1xlarge-h100-80-8",
"tags": [
{ "key": "env", "value": "production", "read_only": false },
{ "key": "team", "value": "ml", "read_only": false }
],
"servers_count": 4,
"created_at": "2026-06-10T12:00:00Z",
"updated_at": "2026-06-10T12:15:00Z",
"servers_ids": [
"server-uuid-1",
"server-uuid-2",
"server-uuid-3",
"server-uuid-4"
],
"has_pending_changes": false
}
]
}
```
Use `limit` and `offset` for pagination. The default page size is 10; the maximum is 1000.
## Get cluster details
Returns the full configuration and current status of a single cluster.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
cluster = client.cloud.gpu_baremetal.clusters.get(
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
)
print(cluster.id, cluster.name, cluster.status, cluster.servers_count)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
cluster, err := client.Cloud.GPUBaremetal.Clusters.Get(context.TODO(),
"{CLUSTER_ID}",
cloud.GPUBaremetalClusterGetParams{
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
})
if err != nil {
panic(err)
}
fmt.Printf("%s %s nodes=%d\n", cluster.ID, cluster.Name, cluster.ServersCount)
}
```
```bash theme={null}
curl "https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{
"id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"name": "prod-bm-cluster-1",
"status": "active",
"flavor": "bm3-ai-1xlarge-h100-80-8",
"servers_count": 4,
"servers_ids": ["server-uuid-1", "server-uuid-2", "server-uuid-3", "server-uuid-4"],
"tags": [{ "key": "env", "value": "production" }],
"created_at": "2026-06-10T12:00:00Z",
"updated_at": "2026-06-10T12:15:00Z",
"has_pending_changes": false
}
```
## Resize a cluster
Change the node count by specifying the new total number of nodes. Scaling down removes a random node; to delete a specific node, use the [Delete a specific node](#delete-a-specific-node) endpoint instead.
Scaling down to zero is not allowed. A cluster must contain at least one node at all times.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
task_id_list = client.cloud.gpu_baremetal.clusters.resize(
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
instances_count=4,
)
print(task_id_list.tasks)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
taskIDList, err := client.Cloud.GPUBaremetal.Clusters.Resize(context.TODO(),
"{CLUSTER_ID}",
cloud.GPUBaremetalClusterResizeParams{
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
InstancesCount: 4,
})
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", taskIDList.Tasks)
}
```
```bash theme={null}
curl -X POST \
"https://api.gcore.com/cloud/v1/ai/clusters/gpu/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/{CLUSTER_ID}/resize" \
-H "Authorization: APIKey ${GCORE_API_KEY}" \
-H "Content-Type: application/json" \
-d '{"instances_count": 4}'
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Control cluster power state
The `action` endpoint applies a power operation to all nodes in the cluster simultaneously.
| Action | Description |
| ------------- | ------------------------------------ |
| `start` | Power on all nodes |
| `stop` | Power off all nodes |
| `soft_reboot` | Send ACPI shutdown signal and reboot |
| `hard_reboot` | Force-reset all nodes immediately |
The Python and Go SDKs (v0.48.0) do not expose the cluster action endpoint directly. Use the curl tab below.
```bash theme={null}
# Replace "soft_reboot" with "start", "stop", or "hard_reboot"
curl -X POST \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}/action" \
-H "Authorization: APIKey ${GCORE_API_KEY}" \
-H "Content-Type: application/json" \
-d '{"action": "soft_reboot"}'
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Rebuild a cluster
Reinstalls the OS on all nodes in the cluster using the cluster's current image, SSH key, and user data. All local storage data is erased.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
task_id_list = client.cloud.gpu_baremetal.clusters.rebuild(
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
)
print(task_id_list.tasks)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
taskIDList, err := client.Cloud.GPUBaremetal.Clusters.Rebuild(context.TODO(),
"{CLUSTER_ID}",
cloud.GPUBaremetalClusterRebuildParams{
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
})
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", taskIDList.Tasks)
}
```
```bash theme={null}
curl -X POST \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}/rebuild" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Rebuild a specific node
Reinstalls the OS on a single node without affecting other nodes in the cluster. All local storage on the node is erased. The rebuild uses the image, SSH key, and user data currently configured in the cluster's server settings — to use different values, first update the server settings via PATCH /cloud/v3/gpu/baremetal/\{project\_id}/\{region\_id}/clusters/\{cluster\_id}/servers\_settings, then trigger the rebuild.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
task_id_list = client.cloud.gpu_baremetal.clusters.servers.rebuild(
server_id="{SERVER_ID}",
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
)
print(task_id_list.tasks)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
taskIDList, err := client.Cloud.GPUBaremetal.Clusters.Servers.Rebuild(context.TODO(),
"{SERVER_ID}",
cloud.GPUBaremetalClusterServerRebuildParams{
ClusterID: "{CLUSTER_ID}",
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
})
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", taskIDList.Tasks)
}
```
```bash theme={null}
curl -X POST \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}/servers/{SERVER_ID}/rebuild" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Replace a specific node
Deletes a node and provisions a new one with the same configuration. Use this to recover a node stuck in a failed state without changing the cluster setup.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
task_id_list = client.cloud.gpu_baremetal.clusters.servers.replace(
server_id="{SERVER_ID}",
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
)
print(task_id_list.tasks)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
taskIDList, err := client.Cloud.GPUBaremetal.Clusters.Servers.Replace(context.TODO(),
"{SERVER_ID}",
cloud.GPUBaremetalClusterServerReplaceParams{
ClusterID: "{CLUSTER_ID}",
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
})
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", taskIDList.Tasks)
}
```
```bash theme={null}
curl -X POST \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}/servers/{SERVER_ID}/replace" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Apply settings to a node
Syncs a specific node that has outdated cluster configuration. The node must have `has_pending_changes=true`. To apply settings to all nodes at once, use `POST /cloud/v3/gpu/baremetal/{project_id}/{region_id}/clusters/{cluster_id}/apply_settings` without specifying a server ID.
```bash theme={null}
# Apply to a specific node
curl -X POST \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}/servers/{SERVER_ID}/apply_settings" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
# Apply to all nodes in the cluster
curl -X POST \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}/apply_settings" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Delete a specific node
Removes a single node by ID. If deleting the last node in the cluster, the entire cluster is removed — no confirmation prompt is shown through the API.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
task_id_list = client.cloud.gpu_baremetal.clusters.servers.delete(
instance_id="{SERVER_ID}",
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
)
print(task_id_list.tasks)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
taskIDList, err := client.Cloud.GPUBaremetal.Clusters.Servers.Delete(context.TODO(),
"{SERVER_ID}",
cloud.GPUBaremetalClusterServerDeleteParams{
ClusterID: "{CLUSTER_ID}",
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
})
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", taskIDList.Tasks)
}
```
```bash theme={null}
curl -X DELETE \
"https://api.gcore.com/cloud/v1/ai/clusters/gpu/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/{CLUSTER_ID}/node/{SERVER_ID}" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```
## Delete a cluster
Deletes the cluster and all its nodes. Local NVMe storage is permanently erased. File shares and object storage remain intact. Pass `all_floating_ips=true` to release any floating IPs, and `all_reserved_fixed_ips=true` to release reserved fixed IPs.
Cluster deletion is irreversible. Data on local NVMe storage cannot be recovered.
```python theme={null}
import os
from gcore import Gcore
client = Gcore(api_key=os.environ.get("GCORE_API_KEY"))
task_id_list = client.cloud.gpu_baremetal.clusters.delete(
cluster_id="{CLUSTER_ID}",
project_id=int(os.environ["GCORE_CLOUD_PROJECT_ID"]),
region_id=int(os.environ["GCORE_CLOUD_REGION_ID"]),
all_floating_ips=True,
all_reserved_fixed_ips=True,
)
print(task_id_list.tasks)
```
```go theme={null}
package main
import (
"context"
"fmt"
"os"
"strconv"
"github.com/G-Core/gcore-go"
"github.com/G-Core/gcore-go/cloud"
"github.com/G-Core/gcore-go/option"
)
func main() {
projectID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_PROJECT_ID"), 10, 64)
regionID, _ := strconv.ParseInt(os.Getenv("GCORE_CLOUD_REGION_ID"), 10, 64)
client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
taskIDList, err := client.Cloud.GPUBaremetal.Clusters.Delete(context.TODO(),
"{CLUSTER_ID}",
cloud.GPUBaremetalClusterDeleteParams{
ProjectID: gcore.Int(projectID),
RegionID: gcore.Int(regionID),
AllFloatingIPs: gcore.Bool(true),
AllReservedFixedIPs: gcore.Bool(true),
})
if err != nil {
panic(err)
}
fmt.Printf("%+v\n", taskIDList.Tasks)
}
```
```bash theme={null}
curl -X DELETE \
"https://api.gcore.com/cloud/v3/gpu/baremetal/${GCORE_CLOUD_PROJECT_ID}/${GCORE_CLOUD_REGION_ID}/clusters/{CLUSTER_ID}?all_floating_ips=true&all_reserved_fixed_ips=true" \
-H "Authorization: APIKey ${GCORE_API_KEY}"
```
Response:
```json theme={null}
{ "tasks": ["task-uuid"] }
```