Gcore

https://docs.gcore.com/
Admin
Gcore is a comprehensive edge computing platform offering AI, cloud, networking, security, hosting,...
Tokens:3,076,016
Snippets:18,683
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Set environment variables for Quickstart examples

Source: https://gcore.com/docs/cloud/networking/ip-address/create-and-configure-a-reserved-ip-address

Set these environment variables for the quickstart examples, including API credentials, project, region, image, and flavor IDs.

```bash
export GCORE_API_KEY="{YOUR_API_KEY}"
export GCORE_CLOUD_PROJECT_ID="{YOUR_PROJECT_ID}"
export GCORE_CLOUD_REGION_ID="{YOUR_REGION_ID}"
export IMAGE_ID="{YOUR_IMAGE_ID}"
export FLAVOR_ID="{YOUR_FLAVOR_ID}"
```

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

### Start Graphical Interface

Source: https://gcore.com/docs/hosting/virtual-servers/manage/install-gui-desktop-environment-on-ubuntu-centos-and-debian

If you installed 'xinit' during the setup, use this command to manually start the graphical interface.

```bash
startx
```

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

### Volume Management Quickstart (Python SDK)

Source: https://gcore.com/docs/cloud/virtual-instances/volumes/create-and-configure-volumes

A Python SDK quickstart guide demonstrating the creation of a 10 GiB standard volume, attaching it to a VM, resizing it to 20 GiB, detaching it, and finally deleting it.

```APIDOC
## Quickstart (Python SDK)

<p>The scripts below create a 10 GiB standard volume, attach it to the VM identified by <code>INSTANCE_ID</code>, resize it to 20 GiB, then detach and delete it.</p>

```python theme={null}
import os
from gcore import Gcore

# Step 1. Initialize the client.
client = Gcore()

# Step 2. Create a 10 GiB standard volume.
volume = client.cloud.volumes.create_and_poll(
    name="data-volume",
    source="new-volume",
    size=10,
    type_name="standard",
)
volume_id = volume.id
print(f"Volume: {volume_id}")

# Step 3. Attach the volume to an existing VM.
instance_id = os.environ["INSTANCE_ID"]
client.cloud.volumes.attach_to_instance_and_poll(
    volume_id,
    instance_id=instance_id,
)
print(f"Attached to {instance_id}")

# Step 4. Resize the volume to 20 GiB (works while attached).
volume = client.cloud.volumes.resize_and_poll(volume_id, size=20)
print(f"Resized to {volume.size} GiB")

# Step 5. Detach the volume from the VM.
client.cloud.volumes.detach_from_instance_and_poll(
    volume_id,
    instance_id=instance_id,
)
print("Detached")

# Step 6. Delete the volume.
client.cloud.volumes.delete_and_poll(volume_id)
print("Deleted")
```
```

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

### Instant Clip Example Configuration

Source: https://gcore.com/docs/api-reference/streaming/streams/get-clips

Provides an example of how to configure the start time, duration, and expiration for an instant clip.

```yaml
start: 1716559200
duration: 60
expiration: 1716562860
```

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

### Install Gcore Go SDK

Source: https://gcore.com/docs/developer-tools/sdks/go

Use `go get` to install the Gcore Go module. To pin a specific version, append `@vX.Y.Z` to the module path.

```bash
go get github.com/G-Core/gcore-go
```

```bash
go get -u 'github.com/G-Core/gcore-go@v0.48.0'
```

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

### Install Gcore SDK

Source: https://gcore.com/docs/developer-tools/rest-api/api-basics

Install the Gcore Python SDK using pip. This is required for using the Python SDK examples.

```bash
pip install gcore
```

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

### Start Claude Code

Source: https://gcore.com/docs/developer-tools/mcp-server/connect-claude-code-to-gcore-mcp-server

Launch Claude Code in any directory. This command initiates the client, prompting for initial setup like theme selection.

```bash
claude
```

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

### Quickstart: Manage volumes with Python SDK

Source: https://gcore.com/docs/cloud/virtual-instances/volumes/create-and-configure-volumes

This script demonstrates creating a 10 GiB standard volume, attaching it to a VM, resizing it to 20 GiB, detaching it, and finally deleting it. Ensure INSTANCE_ID is set as an environment variable.

```python
import os
from gcore import Gcore

# Step 1. Initialize the client.
client = Gcore()

# Step 2. Create a 10 GiB standard volume.
volume = client.cloud.volumes.create_and_poll(
    name="data-volume",
    source="new-volume",
    size=10,
    type_name="standard",
)
volume_id = volume.id
print(f"Volume: {volume_id}")

# Step 3. Attach the volume to an existing VM.
instance_id = os.environ["INSTANCE_ID"]
client.cloud.volumes.attach_to_instance_and_poll(
    volume_id,
    instance_id=instance_id,
)
print(f"Attached to {instance_id}")

# Step 4. Resize the volume to 20 GiB (works while attached).
volume = client.cloud.volumes.resize_and_poll(volume_id, size=20)
print(f"Resized to {volume.size} GiB")

# Step 5. Detach the volume from the VM.
client.cloud.volumes.detach_from_instance_and_poll(
    volume_id,
    instance_id=instance_id,
)
print("Detached")

# Step 6. Delete the volume.
client.cloud.volumes.delete_and_poll(volume_id)
print("Deleted")
```

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

### Quickstart: Reserve IP, create VM, and clean up using Python SDK

Source: https://gcore.com/docs/cloud/networking/ip-address/create-and-configure-a-reserved-ip-address

This Python script demonstrates reserving a public IPv4 address, creating a VM using its port ID, and then deleting all created resources. It requires environment variables for API credentials and resource IDs.

```python
import os
from gcore import Gcore

PROJECT_ID = int(os.environ["GCORE_CLOUD_PROJECT_ID"])
REGION_ID = int(os.environ["GCORE_CLOUD_REGION_ID"])

client = Gcore(api_key=os.environ["GCORE_API_KEY"])

# Step 1. Reserve a public IP address
ip = client.cloud.reserved_fixed_ips.create_and_poll(
    type="external",
    ip_family="ipv4",
    project_id=PROJECT_ID,
    region_id=REGION_ID,
)
print(f"Reserved: {rip.fixed_ip_address}  port_id: {rip.port_id}")

# Step 2. Create a VM using the reserved IP's port_id
volume = client.cloud.volumes.create_and_poll(
    name="boot",
    source="image",
    image_id=os.environ["IMAGE_ID"],
    size=20,
    type_name="ssd_hiiops",
    project_id=PROJECT_ID,
    region_id=REGION_ID,
)
instance = client.cloud.instances.create_and_poll(
    name="my-vm",
    flavor=os.environ["FLAVOR_ID"],
    interfaces=[{"type": "reserved_fixed_ip", "port_id": rip.port_id}],
    volumes=[{"volume_id": volume.id}],
    project_id=PROJECT_ID,
    region_id=REGION_ID,
)
print(f"Instance: {instance.id}  IP: {rip.fixed_ip_address}")

# Step 3. Delete the VM, volume, and reserved IP
client.cloud.instances.delete_and_poll(instance.id, project_id=PROJECT_ID, region_id=REGION_ID)
client.cloud.volumes.delete_and_poll(volume.id, project_id=PROJECT_ID, region_id=REGION_ID)
client.cloud.reserved_fixed_ips.delete_and_poll(rip.port_id, project_id=PROJECT_ID, region_id=REGION_ID)
print("Cleaned up.")
```

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

### Python Basic Hello World Function

Source: https://gcore.com/docs/cloud/faas/code-examples-for-supported-faas-runtimes

A straightforward 'hello world' function in Python. This is a fundamental example for getting started.

```python
def handler(event, context):
    return "hello world"
```

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

### Install gcore-go

Source: https://gcore.com/docs/developer-tools/sdks/go

Install the gcore-go module using go get. You can install the latest version or pin a specific version.

```bash
go get github.com/G-Core/gcore-go

# To pin a specific version:
go get -u 'github.com/G-Core/gcore-go@v0.48.0'
```

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

### List Projects Example

Source: https://gcore.com/docs/developer-tools/rest-api/api-basics

This example shows how to retrieve a list of projects using a GET request.

```APIDOC
## GET /cloud/v1/projects

### Description
Retrieves a list of all projects associated with the API key.

### Method
GET

### Endpoint
/cloud/v1/projects

### Request Example
```bash
curl "https://api.gcore.com/cloud/v1/projects" \
  -H "Authorization: APIKey $GCORE_API_KEY"
```
```

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

### Quickstart: Manage volumes with Go SDK

Source: https://gcore.com/docs/cloud/virtual-instances/volumes/create-and-configure-volumes

This Go code snippet initializes the Gcore client and sets up the context for managing cloud resources. It is the starting point for volume management operations using the Go SDK.

```go
package main

import (
    "context"
    "fmt"
    "log"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cloud"
)

func main() {
    // Step 1. Initialize the client.
    client := gcore.NewClient()
    ctx := context.Background()

```

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

### Install ifenslave package

Source: https://gcore.com/docs/hosting/other-services/link-aggreagtion/activate-link-aggregation

Install the ifenslave package on Ubuntu before contacting support for link aggregation setup.

```sh
apt-get install ifenslave
```

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

### Quickstart: Manage placement group and VM with Python SDK

Source: https://gcore.com/docs/cloud/virtual-instances/placement-groups/configure-a-placement-group

This script demonstrates creating an anti-affinity placement group, launching a VM within it, verifying membership, removing the VM, and finally deleting the group.

```python
import os
from gcore import Gcore

client = Gcore()

# Step 1. Create an anti-affinity placement group.
group = client.cloud.placement_groups.create(
    name="my-group",
    policy="anti-affinity",
)
group_id = group.servergroup_id
print(f"Group: {group_id}")

# Step 2. Create a VM in the group.
instance = client.cloud.instances.create_and_poll(
    flavor=os.environ["FLAVOR_ID"],
    name="my-vm",
    volumes=[{
        "source": "image",
        "image_id": os.environ["IMAGE_ID"],
        "boot_index": 0,
        "size": 20,
        "type_name": "standard",
    }],
    interfaces=[{"type": "external"}],
    servergroup_id=group_id,
)
instance_id = instance.id
print(f"VM: {instance_id}")

# Step 3. Verify group membership.
details = client.cloud.placement_groups.get(group_id=group_id)
print(f"Members: {[vm.instance_id for vm in details.instances]}")

# Step 4. Remove the VM from the group.
client.cloud.instances.remove_from_placement_group_and_poll(
    instance_id=instance_id,
)
print("VM removed from group")

# Step 5. Delete the placement group.
task = client.cloud.placement_groups.delete(group_id=group_id)
client.cloud.tasks.poll(task.tasks[0])
print(f"Deleted group {group_id}")
```

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

### Start Instance

Source: https://gcore.com/docs/api-reference/cloud/instances/start-instance

Initiates the startup process for a specified cloud instance.

```APIDOC
## POST /instances/{instance_id}/start

### Description
Starts a specified instance.

### Method
POST

### Endpoint
/instances/{instance_id}/start

### Parameters
#### Path Parameters
- **instance_id** (string) - Required - The unique identifier of the instance to start.
```

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

### Create and configure a volume in Go

Source: https://gcore.com/docs/cloud/virtual-instances/volumes/create-and-configure-volumes

This snippet demonstrates creating a 10 GiB standard volume, attaching it to an instance, resizing it, detaching it, and finally deleting it. Ensure the INSTANCE_ID environment variable is set.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "os"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cloud"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()

    // Step 2. Create a 10 GiB standard volume.
    volume, err := client.Cloud.Volumes.NewAndPoll(ctx, cloud.VolumeNewParams{
        OfNewVolume: &cloud.VolumeNewParamsBodyNewVolume{
            Name:     "data-volume",
            Size:     10,
            TypeName: "standard",
        },
    })
    if err != nil {
        log.Fatalf("create volume: %v", err)
    }
    volumeID := volume.ID
    fmt.Printf("Volume: %s\n", volumeID)

    // Step 3. Attach the volume to an existing VM.
    instanceID := os.Getenv("INSTANCE_ID")
    if err = client.Cloud.Volumes.AttachToInstanceAndPoll(ctx, volumeID, cloud.VolumeAttachToInstanceParams{
        InstanceID: instanceID,
    }); err != nil {
        log.Fatalf("attach volume: %v", err)
    }
    fmt.Printf("Attached to %s\n", instanceID)

    // Step 4. Resize the volume to 20 GiB (works while attached).
    resized, err := client.Cloud.Volumes.ResizeAndPoll(ctx, volumeID, cloud.VolumeResizeParams{
        Size: 20,
    })
    if err != nil {
        log.Fatalf("resize volume: %v", err)
    }
    fmt.Printf("Resized to %d GiB\n", resized.Size)

    // Step 5. Detach the volume from the VM.
    if err = client.Cloud.Volumes.DetachFromInstanceAndPoll(ctx, volumeID, cloud.VolumeDetachFromInstanceParams{
        InstanceID: instanceID,
    }); err != nil {
        log.Fatalf("detach volume: %v", err)
    }
    fmt.Println("Detached")

    // Step 6. Delete the volume.
    if err = client.Cloud.Volumes.DeleteAndPoll(ctx, volumeID, cloud.VolumeDeleteParams{}); err != nil {
        log.Fatalf("delete volume: %v", err)
    }
    fmt.Println("Deleted")
}

```

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

### Get Cluster Details Response Example

Source: https://gcore.com/docs/edge-ai/ai-infrastructure/manage-a-bare-metal-gpu-cluster

Example JSON response when retrieving details for a specific GPU bare metal cluster.

```json
{
  "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
}
```

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

### Create Instance from Image with Volume

Source: https://gcore.com/docs/api-reference/cloud/instances/create-instance

This example shows how to create a new instance from an existing image, attaching a new volume to it. This is useful for setting up instances with specific boot or data volumes.

```APIDOC
## POST /instances

### Description
Creates a new instance from a specified image and attaches a new volume.

### Method
POST

### Endpoint
/instances

### Parameters
#### Request Body
- **name** (string) - Required - The name of the instance.
- **type_name** (string) - Required - The type of the instance.
- **region** (string) - Required - The region where the instance will be created.
- **image_id** (string) - Required - The ID of the image to use for the instance.
- **volumes** (array) - Required - A list of volume configurations.
  - **CreateInstanceCreateVolumeFromImageSerializer** (object) - Required if volumes are specified and a volume is created from an image.
    - **source** (string) - Required - Must be `image` to create a volume from an image.
    - **image_id** (string) - Required - The ID of the image to use for the volume.
    - **tags** (object) - Optional - Key-value tags to associate with the volume.
    - **type_name** (string) - Optional - Volume type name. Defaults to `standard`.

### Request Example
```json
{
  "name": "instance-from-image",
  "type_name": "general_purpose",
  "region": "nyc-1",
  "image_id": "ami-0123456789abcdef0",
  "volumes": [
    {
      "source": "image",
      "image_id": "ami-0123456789abcdef0",
      "tags": {
        "environment": "production"
      },
      "type_name": "ssd_hiiops"
    }
  ]
}
```

### Response
#### Success Response (201)
- **id** (string) - The unique identifier of the created instance.
- **name** (string) - The name of the instance.
- **status** (string) - The current status of the instance.
- **volumes** (array) - A list of volumes attached to the instance.

#### Response Example
```json
{
  "id": "inst-0123456789abcdef1",
  "name": "instance-from-image",
  "status": "creating",
  "volumes": [
    {
      "id": "vol-0123456789abcdef1",
      "source": "image",
      "image_id": "ami-0123456789abcdef0",
      "type_name": "ssd_hiiops",
      "status": "creating"
    }
  ]
}
```
```

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

### Restream Starts Webhook Example

Source: https://gcore.com/docs/streaming/extra-features/get-webhooks-from-the-streaming-platform

This JSON payload indicates that a restream has started. It includes information about the restream and its linked live stream.

```json
{
  "type": "restream",
  "message": {
    "restream": {
      "id": 3001,
      "name": "RTMP from Brodcast#1 to Youtube",
      "stream_id": 1001,
      "live": true
    }
  }
}
```

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

### Get Cost Report Totals Request Example

Source: https://gcore.com/docs/api-reference/cloud/cost-reports/get-cost-report-totals-pay-as-you-go-only

This example demonstrates how to structure a request to get cost report totals. It includes filtering by projects, regions, response format, schema filters, tags, and time range. Ensure the requested period does not exceed 31 days.

```yaml
projects:
  - 16
  - 17
  - 18
  - 19
  - 20
regions:
  - 18
  - 76
response_format: json
schema_filter:
  field: flavor
  type: instance
  values:
    - g1-standard-1-2
tags:
  condition_type: OR
  conditions:
    - key: os_version
      strict: true
      value: '22.04'
    - key: os_version
      strict: true
      value: '23.04'
time_from: '2024-08-01T00:00:00'
time_to: '2024-09-01T00:00:00'
types:
  - egress_traffic
  - instance
```

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

### List VMs using Go SDK

Source: https://gcore.com/docs/developer-tools/rest-api/first-api-call

This Go example demonstrates listing instances with the Gcore SDK. It uses predefined project and region IDs and handles potential errors during the API call.

```go
import (
    "context"
    "fmt"

    "github.com/gcorelabs/gcore-sdk-go/gcore"
    "github.com/gcorelabs/gcore-sdk-go/gcore/cloud"
)

var projectID int64 = 1234567
var regionID  int64 = 148
instances, err := client.Cloud.Instances.List(context.TODO(), cloud.InstanceListParams{
    ProjectID: gcore.Int(projectID),
    RegionID:  gcore.Int(regionID),
})
if err != nil { panic(err) }
fmt.Printf("%d instances\n", instances.Count)
```

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

### Install Diffusers on PyTorch Base Image

Source: https://gcore.com/docs/edge-ai/everywhere-inference/ai-models/prepare-a-custom-ai-model-for-deployment

Starts with a PyTorch base image and installs the Diffusers library. Ensure CUDA, cuDNN, and PyTorch are compatible with your environment.

```docker
FROM pytorch/pytorch:2.6.0-cuda11.8-cudnn9-devel 
RUN pip install diffusers 
```

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

### Create Instance

Source: https://gcore.com/docs/cloud/virtual-instances/create-an-instance

This section provides instructions on how to create a virtual machine instance using different methods. It includes examples for Python SDK, Go SDK, and a direct curl request to the API.

```APIDOC
## POST /cloud/v2/instances/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID

### Description
Creates a new virtual machine instance with specified configurations.

### Method
POST

### Endpoint
`https://api.gcore.com/cloud/v2/instances/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID`

### Parameters
#### Path Parameters
- **GCORE_CLOUD_PROJECT_ID** (string) - Required - The ID of the Gcore cloud project.
- **GCORE_CLOUD_REGION_ID** (string) - Required - The ID of the Gcore cloud region.

#### Headers
- **Authorization** (string) - Required - APIKey $GCORE_API_KEY
- **Content-Type** (string) - Required - application/json

#### Request Body
- **name** (string) - Required - The name of the virtual machine.
- **flavor** (string) - Required - The ID of the flavor to use for the instance.
- **ssh_key_name** (string) - Required - The name of the SSH key to associate with the instance.
- **interfaces** (array) - Required - A list of network interfaces for the instance. Example: `[{"type": "external"}]`.
- **volumes** (array) - Required - A list of volumes to attach to the instance. Each volume object should contain:
  - **source** (string) - Required - The source of the volume, e.g., "image".
  - **image_id** (string) - Required - The ID of the image to use for the volume.
  - **size** (integer) - Required - The size of the volume in GB.
  - **boot_index** (integer) - Required - The boot index for the volume.

### Request Example
```bash
curl -X POST "https://api.gcore.com/cloud/v2/instances/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d 
    {
      "name": "my-vm",
      "flavor": "$FLAVOR_ID",
      "ssh_key_name": "my-key",
      "interfaces": [{"type": "external"}],
      "volumes": [
        {
          "source": "image",
          "image_id": "$IMAGE_ID",
          "size": 20,
          "boot_index": 0
        }
      ]
    }
```

### Response
#### Success Response (200)
- **tasks** (array) - A list of task IDs associated with the creation process. Example: `["d4a4b10e-5d22-4c23-8e09-f7a3e1c1a999"]`.
```

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

### Interactive Gcore Player Example

Source: https://gcore.com/docs/streaming/player/player-api-tutorial

This is an interactive example demonstrating the Gcore JS Video Player. It requires no specific setup beyond including the player library.

```javascript
<GcorePlayerExample />
```

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

### Set up JavaScript Project and SDK

Source: https://gcore.com/docs/fastedge/getting-started/call-external-api-rust

Initializes a JavaScript project directory and installs the FastEdge SDK for making external API calls.

```sh
mkdir outbound-fetch
cd outbound-fetch
npm init -y
npm pkg set type=module
npm install @gcoredev/fastedge-sdk-js
mkdir src wasm
```

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

### Get AI ASR Task Result Sample

Source: https://gcore.com/docs/streaming/ai-video-service/generate-ai-subtitles-and-add-them-to-video/generate-captions-via-api

Example of a GET request to retrieve AI ASR task results, including a sample JSON response structure.

```sh
GET https://api.gcore.com/streaming/ai/tasks/34d0ba5a-23f6-4462-85ff-fe343b0cdb2d
```

```json
{
    "task_data": {
        "url": "https://demo-public.gvideo.io/videos/2675_G8EuYJFTsvIyWmKt/qid96v1_200_240.mp4"
    },
    "task_id": "34d0ba5a-23f6-4462-85ff-fe343b0cdb2d",
    "processing_time": {
        "completed_at": "2024-03-13T08:15:19Z",
        "started_at": "2024-03-13T08:13:27Z",
        "total_time_sec": 112
    },
    "progress": 100,
    "status": "SUCCESS",
    "result": {
        "subtitles": [
            {
                "start_time": "00:00:17.648",
                "end_time": "00:00:18.868",
                "text": "Hello, Mr. Snail."
            },
            ...
            {
                "start_time": "00:10:00.551",
                "end_time": "00:10:00.891",
                "text": "Did it, kid."
            }
        ],
        "vttContent": "WEBVTT\n\n1\n00:00:17.648 --> 00:00:18.868\nHello, Mr. Snail...00:10:00.551 --> 00:10:00.891\nDid it, kid.\n\n",
        "concatenated_text": "Hello, Mr. Snail. Oh, you cute little corny wasp-assum. Latin name, bonus points...You made it, kids. Did it, kid. "
    }
}
```

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

### HTTPie GET Request Example

Source: https://gcore.com/docs/developer-tools/rest-api/tools

Make a GET request to the Gcore API. HTTPie simplifies syntax compared to curl, automatically formatting JSON responses and handling headers.

```bash
# curl
curl "https://api.gcore.com/iam/clients/me" \
  -H "Authorization: APIKey $GCORE_API_KEY"

# HTTPie equivalent
http GET https://api.gcore.com/iam/clients/me \
  "Authorization:APIKey $GCORE_API_KEY"
```

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

### Create Volume from Scratch

Source: https://gcore.com/docs/api-reference/cloud/volumes/create-volume

Use this example to create a new volume from scratch. Specify the volume name, size, type, and optionally an instance to attach it to.

```yaml
instance_id_to_attach_to: 88f3e0bd-ca86-4cf7-be8b-dd2988e23c2d
name: volume-1
size: 10
source: new-volume
type_name: ssd_hiiops
```

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

### Create Virtual Environment and Install SDK

Source: https://gcore.com/docs/developer-tools/sdks/python

Set up a Python virtual environment and activate it before installing the Gcore SDK. This isolates project dependencies.

```bash
python3 -m venv .venv
source .venv/bin/activate   # On Windows: .venv\Scripts\activate
pip install gcore
```

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

### Start MCP Inspector

Source: https://gcore.com/docs/developer-tools/mcp-server/test-tools-with-mcp-inspector

Run MCP Inspector using npx. Ensure Node.js 18 or later is installed. The inspector will start at http://localhost:6274 and open a browser window.

```bash
npx @modelcontextprotocol/inspector
```

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

### Go SDK - Get Domain

Source: https://gcore.com/docs/waap/getting-started/manage-domains

Example of how to retrieve domain details using the Go SDK.

```Go SDK
package main

import (
    "context"
    "fmt"
    "os"
    "strconv"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/option"
)

func main() {
    client := gcore.NewClient(option.WithAPIKey(os.Getenv("GCORE_API_KEY")))
    domainID, _ := strconv.ParseInt(os.Getenv("WAAP_DOMAIN_ID"), 10, 64)

    // ... rest of the Go code ...
}
```

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

### Create VM with Cloud-Init (Go SDK)

Source: https://gcore.com/docs/cloud/virtual-instances/customize-initial-setup-for-your-instance

Creates a VM with custom cloud-init configuration using the Go SDK. Ensure FLAVOR_ID and IMAGE_ID environment variables are set.

```go
package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "log"
    "os"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cloud"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()

    cloudInitYAML := "#cloud-config\n" +
        "write_files:\n" +
        "  - path: /tmp/cloud-init-ok.txt\n" +
        "    content: |\n" +
        "      cloud-init ran successfully\n" +
        "    permissions: '0644'\n"

    userDataB64 := base64.StdEncoding.EncodeToString([]byte(cloudInitYAML))

    instance, err := client.Cloud.Instances.NewAndPoll(ctx, cloud.InstanceNewParams{
        Flavor:   os.Getenv("FLAVOR_ID"),
        Name:     gcore.String("my-vm"),
        UserData: gcore.String(userDataB64),
        Interfaces: []cloud.InstanceNewParamsInterfaceUnion{{
            OfExternal: &cloud.InstanceNewParamsInterfaceExternal{},
        }},
        Volumes: []cloud.InstanceNewParamsVolumeUnion{{
            OfImage: &cloud.InstanceNewParamsVolumeImage{
                ImageID:   os.Getenv("IMAGE_ID"),
                Size:      gcore.Int(20),
                BootIndex: gcore.Int(0),
            },
        }},
    })
    if err != nil {
        log.Fatalf("create instance: %v", err)
    }
    fmt.Printf("Instance: %s  status: %s\n", instance.ID, instance.Status)
}
```

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

### Demo Token API Request Example

Source: https://gcore.com/docs/streaming/interaction-with-cdn/token-auto-refresh

This example shows how to make a GET request to the demo token API endpoint, specifying video details and token lifetime. Use this for testing and development purposes.

```http
GET https://video-token-102748.fastedge.app/
    ?video=iKbrdNMcS9ylGuw   # video slug (VOD) or stream ID (Live)
    &type=vod                # vod | live
    &expire=60               # token lifetime in seconds
```

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

### Go SDK Example

Source: https://gcore.com/docs/cloud/networking/create-and-configure-a-load-balancer

This snippet demonstrates how to create and configure a load balancer using the Gcore Go SDK. It covers listing flavors, creating the load balancer, setting up an HTTP listener, creating a round-robin pool, and adding backend VMs as pool members.

```APIDOC
## Create and Configure Load Balancer (Go SDK)

### Description
This code example illustrates the creation and configuration of a load balancer using the Gcore Go SDK. It details the steps involved in selecting a flavor, provisioning the load balancer, establishing an HTTP listener, defining a backend pool with a round-robin algorithm, and registering backend virtual machine IPs as pool members.

### Steps
1. **List flavors and pick the smallest**: Fetches available load balancer flavors and selects the most economical one.
2. **Create load balancer**: Initializes a new load balancer with a given name and flavor. This process typically takes around one minute.
3. **Create HTTP listener**: Sets up an HTTP listener on port 80 for the newly created load balancer.
4. **Create round-robin pool**: Configures a backend pool using the ROUND_ROBIN load balancing strategy and links it to the listener.
5. **Add backend VMs as pool members**: Integrates the IP addresses of backend VMs into the pool to enable traffic distribution.

### Code Example
```go
package main

import (
    "context"
    "fmt"
    "os"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cloud"
)

func main() {
    client := gcore.NewClient()
    ctx := context.TODO()

    // Step 1. List flavors and pick the smallest
    flavors, err := client.Cloud.LoadBalancers.Flavors.List(ctx, cloud.LoadBalancerFlavorListParams{})
    if err != nil {
        panic(err.Error())
    }
    lbFlavor := flavors.Results[0].FlavorName
    fmt.Printf("Flavor: %s\n", lbFlavor)

    // Step 2. Create load balancer (takes about 1 minute)
    lb, err := client.Cloud.LoadBalancers.NewAndPoll(ctx, cloud.LoadBalancerNewParams{
        Name:   "my-lb",
        Flavor:    gcore.String(lbFlavor),
    })
    if err != nil {
        panic(err.Error())
    }
    fmt.Printf("LB VIP: %s\n", lb.VipAddress)

    // Step 3. Create HTTP listener on port 80
    listener, err := client.Cloud.LoadBalancers.Listeners.NewAndPoll(ctx, cloud.LoadBalancerListenerNewParams{
        LoadBalancerID: lb.ID,
        Name:           "http-listener",
        Protocol:       "HTTP",
        ProtocolPort:   80,
    })
    if err != nil {
        panic(err.Error())
    }

    // Step 4. Create round-robin pool
    pool, err := client.Cloud.LoadBalancers.Pools.NewAndPoll(ctx, cloud.LoadBalancerPoolNewParams{
        Name:           "http-pool",
        LbAlgorithm:    "ROUND_ROBIN",
        Protocol:       "HTTP",
        ListenerID:     gcore.String(listener.ID),
        LoadBalancerID: gcore.String(lb.ID),
    })
    if err != nil {
        panic(err.Error())
    }

    // Step 5. Add backend VMs as pool members
    for _, ip := range []string{os.Getenv("VM1_IP"), os.Getenv("VM2_IP")}: {
        t, err := client.Cloud.LoadBalancers.Pools.Members.New(ctx, pool.ID, cloud.LoadBalancerPoolMemberNewParams{
            Address:      ip,
            ProtocolPort: 80,
        })
        if err != nil {
            panic(err.Error())
        }
        if _, err = client.Cloud.Tasks.Poll(ctx, t.Tasks[0]); err != nil {
            panic(err.Error())
        }
    }
    fmt.Printf("Traffic on %s:80 is now distributed across both VMs\n", lb.VipAddress)
}
```
```

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

### Create Instance with User Data and Tags

Source: https://gcore.com/docs/cloud/virtual-instances/create-an-instance

Configure an instance with custom user data for first-boot scripts and attach tags for organization. The `user_data` should be base64 encoded.

```hcl
resource "gcore_cloud_instance" "example" {
  # ... required fields ...

  user_data = base64encode(<<-EOF
    #cloud-config
    password: your-password
    chpasswd: { expire: false }
    ssh_pwauth: true
  EOF
  )

  tags = {
    env  = "production"
    team = "backend"
  }
}
```
Tokens:
Raw