Nebius AI Cloud

https://docs.nebius.com/
Admin
Nebius AI Cloud is a cloud platform providing compute, storage, ML tools, and observability services...
Tokens:2,975,464
Snippets:17,480
Trust Score:10
Update:2 days ago
Show doc for...
Tokens:
Raw
### Start an endpoint example

Source: https://docs.nebius.com/cli/reference/ai/endpoint/start

Example command to start an endpoint by providing its ID.

```bash
nebius ai endpoint start --id <endpoint_ID>
```

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

### Install busybox package

Source: https://docs.nebius.com/tunnels/quickstart

Installs the busybox package on the VM, which provides the HTTP server used in this quickstart.

```bash
sudo apt-get update && sudo apt-get install -y busybox
```

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

### Full example: create gateway VM with boot disk (CLI)

Source: https://docs.nebius.com/vpc/routing/custom-nat-gateway

Complete example that creates a boot disk and then the gateway VM with cloud-init user data for SSH access.

```bash
VM_BOOT_DISK_ID=$(nebius compute disk create \
   --name gateway-boot-disk \
   --size-gibibytes 50 \
   --type network_ssd \
   --source-image-family-image-family ubuntu24.04-cuda13.0 \
   --block-size-bytes 4096 \
   --format jsonpath='{.metadata.id}')

nebius compute instance create \
   --name gateway-vm-example \
   --resources-platform cpu-d3 \
   --resources-preset 4vcpu-16gb \
   --boot-disk-existing-disk-id $VM_BOOT_DISK_ID \
   --boot-disk-attach-mode read_write \
   --boot-disk-device-id boot-disk \
   --network-interfaces "[{
     \"name\": \"eth0\",
     \"ip_address\": {
       \"allocation_id\": \"<gateway_allocation_ID>\"
     },
     \"subnet_id\": \"<gateway_subnet_ID>\",
     \"public_ip_address\": {}
   }]" \
   --cloud-init-user-data "users:
     - name: $USER
       sudo: ALL=(ALL) NOPASSWD:ALL
       shell: /bin/bash
       ssh_authorized_keys:
        - $(cat ~/.ssh/id_ed25519.pub)"
```

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

### Get user data

Source: https://docs.nebius.com/compute/virtual-machines/instance-metadata

Retrieves the user data provided when the VM was created. The example output shows a cloud-config file that updates packages and installs nginx.

```bash
curl http://metadata.nebius.internal/v1/user-data \
  -H "Metadata: true"
```

```yaml
#cloud-config
package_update: true
packages:
  - nginx
runcmd:
  - systemctl enable --now nginx
```

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

### Create a project example

Source: https://docs.nebius.com/cli/reference/iam/v2/project/create

Example command to create a project, specifying the parent tenant ID, project name, and region.

```bash
nebius iam v2 project create \
  --parent-id <tenant_ID> \
  --name <project_name> \
  --region <region_name>
```

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

### Create Gateway VM with Boot Disk and Cloud-init (full example)

Source: https://docs.nebius.com/vpc/routing/custom-nat-gateway

Full example that creates a boot disk using DiskService, then creates a gateway VM using that disk and adds a user via cloud-init. Set <username> and <SSH_public_key> for the user. The example uses platform cpu-d3 and preset 4vcpu-16gb. Requires gateway subnet and allocation IDs.

```typescript
const exampleDiskService = new DiskService(sdk);
const exampleDiskOperation = await exampleDiskService.create(
  CreateDiskRequest.create({
    metadata: {
      name: "gateway-boot-disk",
      parentId: "<project_ID>",
    },
    spec: {
      size: {
        "$case": "sizeGibibytes",
        "sizeGibibytes": 50,
      },
      blockSizeBytes: 4096,
      type: DiskSpec_DiskType.NETWORK_SSD,
      source: {
        "$case": "sourceImageFamily",
        "sourceImageFamily": {
          imageFamily: "ubuntu24.04-cuda13.0",
        },
      },
    },
  }),
).result;
await exampleDiskOperation.wait();
const exampleCloudInit = [
  "users:",
  "  - name: " + "<username>",
  "    sudo: ALL=(ALL) NOPASSWD:ALL",
  "    shell: /bin/bash",
  "    ssh_authorized_keys:",
  "      - " + "<SSH_public_key>",
].join("\n");
const exampleInstanceService = new InstanceService(sdk);
const exampleInstanceOperation = await exampleInstanceService.create(
  CreateInstanceRequest.create({
    metadata: {
      name: "gateway-vm-example",
      parentId: "<project_ID>",
    },
    spec: {
      resources: {
        platform: "cpu-d3",
        size: {
          "$case": "preset",
          "preset": "4vcpu-16gb",
        },
      },
      bootDisk: {
        attachMode: AttachedDiskSpec_AttachMode.READ_WRITE,
        type: {
          "$case": "existingDisk",
          "existingDisk": {
            id: exampleDiskOperation.resourceId(),
          },
        },
        deviceId: "boot-disk",
      },
      networkInterfaces: [
        {
          name: "eth0",
          subnetId: "<gateway_subnet_ID>",
          ipAddress: {
            allocationId: "<gateway_allocation_ID>",
          },
          publicIpAddress: {},
        },
      ],
      cloudInitUserData: exampleCloudInit,
    },
  }),
).result;
await exampleInstanceOperation.wait();
console.log(exampleInstanceOperation);
```

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

### Example: Get a log export operation

Source: https://docs.nebius.com/cli/reference/logging/export/get

Example command to get the status of a log export operation by its ID.

```bash
nebius logging export get --id <operation_ID>
```

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

### Go SDK example to create VM with boot and additional disks

Source: https://docs.nebius.com/compute/virtual-machines/create

Uses the Nebius SDK for Go to create a VM with a boot disk and an additional disk. The VM gets a dynamic public IPv4 address. Replace placeholders like <size>, <VM_name>, <platform>, and <preset> with actual values. The example waits for the operation to complete.

```go
additionalBootDisk := &compute.AttachedDiskSpec{
    AttachMode: compute.AttachedDiskSpec_READ_WRITE,
    Type: &compute.AttachedDiskSpec_ManagedDisk{
        ManagedDisk: &compute.ManagedDisk{
            Name: "managed-boot-disk",
            Spec: &compute.DiskSpec{
                Size: &compute.DiskSpec_SizeGibibytes{
                    SizeGibibytes: 10,
                },
                Type: compute.DiskSpec_NETWORK_SSD,
                Source: &compute.DiskSpec_SourceImageFamily{
                    SourceImageFamily: &compute.SourceImageFamily{
                        ImageFamily: "ubuntu24.04-driverless",
                    },
                },
            },
        },
    },
}
additionalDisk := &compute.AttachedDiskSpec{
    AttachMode: compute.AttachedDiskSpec_READ_WRITE,
    DeviceId:   "device-1",
    Type: &compute.AttachedDiskSpec_ManagedDisk{
        ManagedDisk: &compute.ManagedDisk{
            Name: "managed-secondary-disk",
            Spec: &compute.DiskSpec{
                Size: &compute.DiskSpec_SizeGibibytes{
                    SizeGibibytes: <size>,
                },
                Type: compute.DiskSpec_NETWORK_SSD,
            },
        },
    },
}
additionalNetwork := &compute.NetworkInterfaceSpec{
    Name:            "eth0",
    SubnetId:        subnetID,
    IpAddress:       &compute.IPAddress{},
    PublicIpAddress: &compute.PublicIPAddress{},
}
additionalVMOperation, err := sdk.Services().Compute().V1().
    Instance().Create(
        ctx,
        &compute.CreateInstanceRequest{
            Metadata: &common.ResourceMetadata{
                Name: "<VM_name>",
            },
            Spec: &compute.InstanceSpec{
                Resources: &compute.ResourcesSpec{
                    Platform: "<platform>",
                    Size: &compute.ResourcesSpec_Preset{
                        Preset: "<preset>",
                    },
                },
                BootDisk: additionalBootDisk,
                SecondaryDisks: []*compute.AttachedDiskSpec{
                    additionalDisk,
                },
                NetworkInterfaces: []*compute.NetworkInterfaceSpec{
                    additionalNetwork,
                },
            },
        },
    )
if err != nil {
    return err
}
if _, err = additionalVMOperation.Wait(ctx); err != nil {
    return err
}
```

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

### Example command with JSON input for cluster start

Source: https://docs.nebius.com/cli/reference/msp/mlflow/v1alpha1/cluster/start

Example command that passes a JSON object with an empty `id` to the cluster start command.

```bash
nebius msp mlflow v1alpha1 cluster start '
{          
  "id": "" 
}
'
```

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

### Create a Compute VM with the JavaScript SDK

Source: https://docs.nebius.com/sdk/javascript/send-request

This script initializes the SDK with a service account credentials file, creates a boot disk, and then creates a VM using that disk. It uses the `DiskService` and `InstanceService` clients, and waits for operations to complete with `wait()`. Replace the placeholders with your own values before running.

```javascript
import { SDK } from '@nebius/js-sdk';
import {
  AttachedDiskSpec_AttachMode,
  CreateDiskRequest,
  CreateInstanceRequest,
  DiskService as DiskServiceClient,
  DiskSpec_DiskType,
  InstanceService as InstanceServiceClient,
} from '@nebius/js-sdk/api/nebius/compute/v1/index';
import { CredentialsFileReader } from '@nebius/js-sdk/runtime/service_account/credentials_file';

async function createInstance() {
  const sdk = new SDK({
    userAgentPrefix: '<application_name>/<application_version_or_comment>',
    parentId: '<project_ID>',
    credentials: new CredentialsFileReader('<credentials_file_path>'),
  });

  try {
    const diskService = new DiskServiceClient(sdk);
    const instanceService = new InstanceServiceClient(sdk);

    // Create the boot disk.
    const diskOperation = await diskService.create(
      CreateDiskRequest.create({
        metadata: {
          parentId: '<project_ID>',
          name: 'my-boot-disk',
        },
        spec: {
          size: {
            $case: 'sizeGibibytes',
            sizeGibibytes: 93,
          },
          type: DiskSpec_DiskType.NETWORK_SSD,
          source: {
            $case: 'sourceImageFamily',
            sourceImageFamily: {
              imageFamily: '<image_family_name>',
            },
          },
        },
      }),
    ).result;

    await diskOperation.wait();
    console.log('Boot disk ID:', diskOperation.resourceId());

    // Create the VM that uses the boot disk.
    const instanceOperation = await instanceService.create(
      CreateInstanceRequest.create({
        metadata: {
          parentId: '<project_ID>',
          name: 'my-vm',
        },
        spec: {
          resources: {
            platform: '<platform_name>',
            size: {
              $case: 'preset',
              preset: '<preset_name>',
            },
          },
          networkInterfaces: [
            {
              name: 'eth0',
              subnetId: '<subnet_ID>',
              ipAddress: {},
            },
          ],
          bootDisk: {
            attachMode: AttachedDiskSpec_AttachMode.READ_WRITE,
            type: {
              $case: 'existingDisk',
              existingDisk: {
                id: diskOperation.resourceId(),
              },
            },
            deviceId: 'boot-disk',
          },
        },
      }),
    ).result;

    await instanceOperation.wait();
    console.log('VM ID:', instanceOperation.resourceId());
  } finally {
    await sdk.close();
  }
}

await createInstance();
```

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

### CopyPaste Friendly input example for nebius mk8s v1alpha1 cluster get

Source: https://docs.nebius.com/cli/reference/mk8s/v1alpha1/cluster/get

Example command with inline JSON input for the `get` command.

```bash
nebius mk8s v1alpha1 cluster get '
{                        
  "id": "",              
  "resource_version": "" 
}
'
```

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

### Create a bucket usage example

Source: https://docs.nebius.com/object-storage/interfaces/aws-cli

Example of creating a bucket named `example-bucket`. The output confirms the bucket was created.

```bash
aws s3 mb s3://example-bucket
```

```text
make_bucket: example-bucket
```

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

### Output example for get maintenance operation

Source: https://docs.nebius.com/mlflow/maintenance

Example output from the get command, showing metadata, spec, and status fields including state and reschedulable.

```yaml
metadata:
    id: maintenance_***
    parent_id: project-***
    created_at: "2025-09-22T14:40:59.845329Z"
spec:
    scheduled_at: "2025-10-01T14:28:20Z"
status:
    affected_resources:
      - id: mlflow-***
        parent_id: project-***
    started_at: "2025-10-01T14:28:21.162373Z"
    finished_at: "2025-10-01T14:34:38.363547Z"
    state: STATE_FINISHED
    reschedulable: true
```

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

### Create a Compute VM with the Go SDK

Source: https://docs.nebius.com/sdk/go/send-request

This Go script initializes the Nebius Go SDK with service account credentials, creates a boot disk, and then creates a VM that uses the disk. It demonstrates using the SDK's service clients and waiting for asynchronous operations with the Wait method. Replace placeholders like <project_ID>, <credentials_file_path>, and <image_family_name> with your actual values.

```go
package main

import (
   "context"
   "fmt"

   "github.com/nebius/gosdk"
   "github.com/nebius/gosdk/auth"
   common "github.com/nebius/gosdk/proto/nebius/common/v1"
   compute "github.com/nebius/gosdk/proto/nebius/compute/v1"
)

// Run the resource creation workflow.
func main() {
   if err := CreateInstance(context.Background()); err != nil {
      panic(err)
   }
}

// CreateInstance creates a boot disk and a VM that uses it.
func CreateInstance(ctx context.Context) error {
   // Initialize the SDK with service account credentials.
   sdk, err := gosdk.New(
      ctx,
      gosdk.WithUserAgentPrefix("<application_name>/<application_version_or_comment>"),
      gosdk.WithParentID("<project_ID>"),
      gosdk.WithCredentials(
         gosdk.ServiceAccountReader(
            auth.NewServiceAccountCredentialsFileParser(
               nil,
               "<credentials_file_path>",
            ),
         ),
      ),
   )
   if err != nil {
      return fmt.Errorf("create gosdk: %w", err)
   }
   defer sdk.Close()

   // Create the boot disk.
   diskOperation, err := sdk.Services().Compute().V1().Disk().Create(ctx, &compute.CreateDiskRequest{
      Metadata: &common.ResourceMetadata{
         ParentId: "<project_ID>",
         Name:     "my-boot-disk",
      },
      Spec: &compute.DiskSpec{
         Size: &compute.DiskSpec_SizeGibibytes{
            SizeGibibytes: 93,
         },
         Type: compute.DiskSpec_NETWORK_SSD,
         Source: &compute.DiskSpec_SourceImageFamily{
            SourceImageFamily: &compute.SourceImageFamily{
               ParentId:    "<project_ID>",
               ImageFamily: "<image_family_name>",
            },
         },
      },
   })
   if err != nil {
      return fmt.Errorf("create disk: %w", err)
   }

   diskOperation, err = diskOperation.Wait(ctx)
   if err != nil {
      return fmt.Errorf("wait for disk create: %w", err)
   }

   // Create the VM that uses the boot disk.
   instanceOperation, err := sdk.Services().Compute().V1().Instance().Create(ctx, &compute.CreateInstanceRequest{
      Metadata: &common.ResourceMetadata{
         ParentId: "<project_ID>",
         Name:     "my-vm",
      },
      Spec: &compute.InstanceSpec{
         Resources: &compute.ResourcesSpec{
            Platform: "<platform_name>",
            Size: &compute.ResourcesSpec_Preset{
               Preset: "<preset_name>",
            },
         },
         NetworkInterfaces: []*compute.NetworkInterfaceSpec{
            {
               Name:      "eth0",
               SubnetId:  "<subnet_ID>",
               IpAddress: &compute.IPAddress{},
            },
         },
         BootDisk: &compute.AttachedDiskSpec{
            AttachMode: compute.AttachedDiskSpec_READ_WRITE,
            Type: &compute.AttachedDiskSpec_ExistingDisk{
               ExistingDisk: &compute.ExistingDisk{
                  Id: diskOperation.ResourceID(),
               },
            },
            DeviceId: "boot-disk",
         },
      },
   })
   if err != nil {
      return fmt.Errorf("create VM: %w", err)
   }

   _, err = instanceOperation.Wait(ctx)
   if err != nil {
      return fmt.Errorf("wait for VM creation: %w", err)
   }

   return nil
}

```

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

### Copy-paste friendly input example for backup get

Source: https://docs.nebius.com/cli/reference/msp/postgresql/v1alpha1/backup/get

Example of passing the input JSON as a command-line argument to `nebius msp postgresql v1alpha1 backup get`.

```bash
nebius msp postgresql v1alpha1 backup get '
{                  
  "backup_id": "", 
  "cluster_id": "" 
}
'
```

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

### Create VM with local SSD disks (Go)

Source: https://docs.nebius.com/compute/virtual-machines/create

Go SDK example that creates a VM with a local SSD disk. It configures a boot disk from the 'ubuntu24.04-driverless' image family, a network interface with a private IP, and a passthrough group for local disks. The VM is created with the specified platform and preset, and the operation waits for completion.

```go
localBootDisk := &compute.AttachedDiskSpec{
    AttachMode: compute.AttachedDiskSpec_READ_WRITE,
    Type: &compute.AttachedDiskSpec_ManagedDisk{
        ManagedDisk: &compute.ManagedDisk{
            Name: "managed-boot-disk",
            Spec: &compute.DiskSpec{
                Size: &compute.DiskSpec_SizeGibibytes{
                    SizeGibibytes: 10,
                },
                Type: compute.DiskSpec_NETWORK_SSD,
                Source: &compute.DiskSpec_SourceImageFamily{
                    SourceImageFamily: &compute.SourceImageFamily{
                        ImageFamily: "ubuntu24.04-driverless",
                    },
                },
            },
        },
    },
}
localDiskNetwork := &compute.NetworkInterfaceSpec{
    Name:            "eth0",
    SubnetId:        subnetID,
    IpAddress:       &compute.IPAddress{},
    PublicIpAddress: &compute.PublicIPAddress{},
}
passthroughRequest := &compute.PassthroughGroupRequest{
    Requested: true,
}
localDiskRequest := &compute.LocalDisksSpec_PassthroughGroup{
    PassthroughGroup: passthroughRequest,
}
localDiskVMOperation, err := sdk.Services().Compute().V1().
    Instance().Create(
        ctx,
        &compute.CreateInstanceRequest{
            Metadata: &common.ResourceMetadata{
                Name: "<VM_name>",
            },
            Spec: &compute.InstanceSpec{
                Stopped: <true|false>,
                Resources: &compute.ResourcesSpec{
                    Platform: "<platform>",
                    Size: &compute.ResourcesSpec_Preset{
                        Preset: "<preset>",
                    },
                },
                BootDisk: localBootDisk,
                NetworkInterfaces: []*compute.NetworkInterfaceSpec{
                    localDiskNetwork,
                },
                LocalDisks: &compute.LocalDisksSpec{
                    Request: localDiskRequest,
                },
            },
        },
    )
if err != nil {
    return err
}
if _, err = localDiskVMOperation.Wait(ctx); err != nil {
    return err
}
```

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

### Copy-paste friendly example for nebius mk8s cluster get

Source: https://docs.nebius.com/cli/reference/mk8s/cluster/get

Example command with an inline JSON payload for the `nebius mk8s cluster get` command, ready for copy-paste.

```bash
nebius mk8s cluster get '
{                        
  "id": "",              
  "resource_version": "" 
}
'
```

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

### Create Gateway VM with InstanceService (minimal example)

Source: https://docs.nebius.com/vpc/routing/custom-nat-gateway

Creates a gateway VM using the InstanceService. Requires a pre-existing boot disk, gateway subnet, and gateway allocation. The publicIpAddress field assigns a public IP. Replace placeholders like <project_ID>, <boot_disk_ID>, <gateway_subnet_ID>, and <gateway_allocation_ID> with actual values. The platform and preset are example values and can be changed.

```typescript
const gatewayInstanceService = new InstanceService(sdk);
const gatewayInstanceOperation = await gatewayInstanceService.create(
  CreateInstanceRequest.create({
    metadata: {
      name: "gateway-vm",
      parentId: "<project_ID>",
    },
    spec: {
      resources: {
        platform: "cpu-e2",
        size: {
          "$case": "preset",
          "preset": "2vcpu-8gb",
        },
      },
      bootDisk: {
        attachMode: AttachedDiskSpec_AttachMode.READ_WRITE,
        type: {
          "$case": "existingDisk",
          "existingDisk": {
            id: "<boot_disk_ID>",
          },
        },
        deviceId: "boot-device-id",
      },
      networkInterfaces: [
        {
          name: "eth0",
          subnetId: "<gateway_subnet_ID>",
          ipAddress: {
            allocationId: "<gateway_allocation_ID>",
          },
          publicIpAddress: {},
        },
      ],
    },
  }),
).result;
await gatewayInstanceOperation.wait();
console.log(gatewayInstanceOperation);
```

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

### Example invocation with JSON input for nebius registry image get

Source: https://docs.nebius.com/cli/reference/registry/image/get

Example command that passes a JSON object with the `id` field to the `nebius registry image get` command.

```bash
nebius registry image get '
{          
  "id": "" 
}
'
```

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

### Example command with input file for nebius registry get

Source: https://docs.nebius.com/cli/reference/registry/get

Example of invoking `nebius registry get` with an inline JSON input file using the `-f` flag. The `id` is set to an empty string.

```bash
nebius registry get '
{          
  "id": "" 
}
'
```

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

### Create a filesystem example

Source: https://docs.nebius.com/cli/reference/compute/filesystem/create

Example command that creates a filesystem with a name, size of 10 GiB, type `network_ssd`, and block size 4096 bytes.

```bash
nebius compute filesystem create \
  --name <filesystem_name> \
  --size-gibibytes 10 \
  --type network_ssd \
  --block-size-bytes 4096
```

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

### Java Unirest GET to spot-price endpoint

Source: https://docs.nebius.com/rest-api/billing/v1alpha1/spot-price/list

Java example using Unirest to make a GET request to the spot-price endpoint and get the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.nebius.cloud/billing/v1alpha1/spot-price")
  .asString();
```

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

### Example: Copy hello-world image to GitHub Packages

Source: https://docs.nebius.com/container-registry/images/copy

Concrete example copying the hello-world:hello image from a Nebius AI Cloud registry to a GitHub Packages registry named octocat. Shows the exact pull, tag, and push commands.

```bash
docker pull cr.eu-north1.nebius.cloud/a00bcdefghe12xyz3f/hello-world:hello
docker tag \
  cr.eu-north1.nebius.cloud/a00bcdefghe12xyz3f/hello-world:hello \
  ghcr.io/octocat/hello-world:hello
docker push ghcr.io/octocat/hello-world:hello
```

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

### Get a subnet example

Source: https://docs.nebius.com/cli/reference/vpc/subnet/get

Example command to retrieve a subnet by its ID using the `--id` flag.

```bash
nebius vpc subnet get --id <subnet_ID>
```

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

### Create a Compute VM with the Python SDK

Source: https://docs.nebius.com/sdk/python/send-request

This script initializes the SDK with service account credentials, creates a boot disk, waits for the operation, then creates a VM using that disk and waits for the operation. It requires prior installation of the Python SDK and preparation of authentication credentials. Replace placeholders like <project_ID>, <private_key_file_path>, and <image_family_name> with your values.

```python
import asyncio

from nebius.api.nebius.common.v1 import ResourceMetadata
from nebius.api.nebius.compute.v1 import (
    AttachedDiskSpec,
    CreateDiskRequest,
    CreateInstanceRequest,
    DiskServiceClient,
    DiskSpec,
    ExistingDisk,
    InstanceServiceClient,
    InstanceSpec,
    IPAddress,
    NetworkInterfaceSpec,
    ResourcesSpec,
    SourceImageFamily,
)
from nebius.sdk import SDK


async def create_instance() -> None:
    # Initialize the SDK with the service account private key file.
    sdk = SDK(
        user_agent_prefix="<application_name>/<application_version_or_comment>",
        parent_id="<project_ID>",
        service_account_private_key_file_name="<private_key_file_path>",
        service_account_public_key_id="<public_key_ID>",
        service_account_id="<service_account_ID>",
    )

    async with sdk:
        disk_service = DiskServiceClient(sdk)
        instance_service = InstanceServiceClient(sdk)

        # Create the boot disk.
        disk_operation = await disk_service.create(
            CreateDiskRequest(
                metadata=ResourceMetadata(
                    parent_id="<project_ID>",
                    name="my-boot-disk",
                ),
                spec=DiskSpec(
                    size_gibibytes=93,
                    type=DiskSpec.DiskType.NETWORK_SSD,
                    source_image_family=SourceImageFamily(
                        image_family="<image_family_name>",
                    ),
                ),
            )
        )

        await disk_operation.wait()

        # Create the VM that uses the boot disk.
        instance_operation = await instance_service.create(
            CreateInstanceRequest(
                metadata=ResourceMetadata(
                    parent_id="<project_ID>",
                    name="my-vm",
                ),
                spec=InstanceSpec(
                    resources=ResourcesSpec(
                        platform="<platform_name>",
                        preset="<preset_name>",
                    ),
                    network_interfaces=[
                        NetworkInterfaceSpec(
                            name="eth0",
                            subnet_id="<subnet_ID>",
                            ip_address=IPAddress(),
                        ),
                    ],
                    boot_disk=AttachedDiskSpec(
                        attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE,
                        existing_disk=ExistingDisk(
                            id=disk_operation.resource_id,
                        ),
                        device_id="boot-disk",
                    ),
                ),
            )
        )

        await instance_operation.wait()


if __name__ == "__main__":
    asyncio.run(create_instance())
```

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

### Create a boot disk (Python async)

Source: https://docs.nebius.com/compute/quickstart

This Python async example creates a 50 GiB SSD boot disk with a 4 KiB block size and an Ubuntu 24.04 boot image with pre-installed NVIDIA GPU drivers. The disk is created using the DiskServiceClient.

```python
disk_service = DiskServiceClient(sdk)
training_disk_operation = await disk_service.create(
    CreateDiskRequest(
        metadata=ResourceMetadata(
            name="training-vm-disk-1",
        ),
        spec=DiskSpec(
            block_size_bytes=4096,
            type=DiskSpec.DiskType.NETWORK_SSD,
            source_image_family=SourceImageFamily(
                image_family="ubuntu24.04-cuda13.0",
            ),
            size_gibibytes=50,
        ),
    ),
)
await training_disk_operation.wait()
training_boot_disk_id = training_disk_operation.resource_id
```

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

### Example command using JSON input

Source: https://docs.nebius.com/cli/reference/applications/v1alpha1/vm-app-template/get

Example invocation of the get command with an inline JSON payload.

```bash
nebius applications v1alpha1 vm-app-template get '
{          
  "id": "" 
}
'
```

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

### GET /iam/v1/profiles

Source: https://docs.nebius.com/rest-api/authentication

Example API request using the access token to get the service account profile.

```APIDOC
## GET /iam/v1/profiles

### Description
Get the service account profile. This is an example of how to use the access token in an API request.

### Method
GET

### Endpoint
https://api.nebius.cloud/iam/v1/profiles

### Request Headers
- **Authorization** (string) - Required - Bearer <access_token>

### Request Example
```bash
curl --request GET \
   --url 'https://api.nebius.cloud/iam/v1/profiles' \
   --header 'Authorization: Bearer <access_token>'
```
```

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

### Create a VM with boot and additional disks (Python)

Source: https://docs.nebius.com/compute/virtual-machines/create

Creates a VM with a boot disk and an additional disk using the InstanceServiceClient. The VM gets a dynamic public IPv4 address. Replace placeholders like <VM_name>, <platform>, <preset>, <user_defined_ID>, boot_disk_id, additional_disk_id, and subnet_id with actual values.

```python
instance_service = InstanceServiceClient(sdk)
standalone_vm_operation = await instance_service.create(
    CreateInstanceRequest(
        metadata=ResourceMetadata(name="<VM_name>"),
        spec=InstanceSpec(
            resources=ResourcesSpec(
                platform="<platform>",
                preset="<preset>",
            ),
            boot_disk=AttachedDiskSpec(
                attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE,
                existing_disk=ExistingDisk(id=boot_disk_id),
                device_id="<user_defined_ID>",
            ),
            secondary_disks=[
                AttachedDiskSpec(
                    attach_mode=(
                        AttachedDiskSpec.AttachMode.READ_WRITE
                    ),
                    existing_disk=ExistingDisk(
                        id=additional_disk_id,
                    ),
                    device_id="<user_defined_ID>",
                ),
            ],
            network_interfaces=[
                NetworkInterfaceSpec(
                    name="eth0",
                    subnet_id=subnet_id,
                    ip_address=IPAddress(),
                    public_ip_address=PublicIPAddress(),
                ),
            ],
        ),
    ),
)
await standalone_vm_operation.wait()
```

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

### Create boot disk and VM instance with cloud-init

Source: https://docs.nebius.com/vpc/routing/custom-nat-gateway

Creates a boot disk and a VM instance for the gateway. The disk uses Ubuntu 24.04 with CUDA 13.0. The VM uses a cpu-d3 platform with 4 vCPU and 16 GB RAM. Cloud-init configures a user with SSH access.

```go
exampleDiskService := sdk.Services().Compute().V1().
    Disk()
exampleDiskOperation, err := exampleDiskService.Create(
    ctx,
    &compute.CreateDiskRequest{
        Metadata: &common.ResourceMetadata{
            Name: "gateway-boot-disk",
            ParentId: "<project_ID>",
        },
        Spec: &compute.DiskSpec{
            Size: &compute.DiskSpec_SizeGibibytes{
                SizeGibibytes: 50,
            },
            BlockSizeBytes: 4096,
            Type: compute.DiskSpec_NETWORK_SSD,
            Source: &compute.DiskSpec_SourceImageFamily{
                SourceImageFamily: &compute.SourceImageFamily{
                    ImageFamily: "ubuntu24.04-cuda13.0",
                },
            },
        },
    },
)
if err != nil {
    return err
}
if _, err = exampleDiskOperation.Wait(ctx); err != nil {
    return err
}
exampleCloudInit := fmt.Sprintf(
    "users:\n"+
        "  - name: %s\n"+
        "    sudo: ALL=(ALL) NOPASSWD:ALL\n"+
        "    shell: /bin/bash\n"+
        "    ssh_authorized_keys:\n"+
        "      - %s\n",
    "<username>",
    "<SSH_public_key>",
)
exampleInstanceService := sdk.Services().Compute().V1().
    Instance()
exampleInstanceOperation, err := exampleInstanceService.Create(
    ctx,
    &compute.CreateInstanceRequest{
        Metadata: &common.ResourceMetadata{
            Name: "gateway-vm-example",
            ParentId: "<project_ID>",
        },
        Spec: &compute.InstanceSpec{
            Resources: &compute.ResourcesSpec{
                Platform: "cpu-d3",
                Size: &compute.ResourcesSpec_Preset{
                    Preset: "4vcpu-16gb",
                },
            },
            BootDisk: &compute.AttachedDiskSpec{
                AttachMode: compute.AttachedDiskSpec_READ_WRITE,
                Type: &compute.AttachedDiskSpec_ExistingDisk{
                    ExistingDisk: &compute.ExistingDisk{
                        Id: exampleDiskOperation.ResourceID(),
                    },
                },
                DeviceId: "boot-disk",
            },
            NetworkInterfaces: []*compute.NetworkInterfaceSpec{
                &compute.NetworkInterfaceSpec{
                    Name: "eth0",
                    SubnetId: "<gateway_subnet_ID>",
                    IpAddress: &compute.IPAddress{
                        AllocationId: "<gateway_allocation_ID>",
                    },
                    PublicIpAddress: &compute.PublicIPAddress{},
                },
            },
            CloudInitUserData: exampleCloudInit,
        },
    },
)
if err != nil {
    return err
}
if _, err = exampleInstanceOperation.Wait(ctx); err != nil {
    return err
}
fmt.Println(exampleInstanceOperation)
```

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

### Python GET capacity-allowances

Source: https://docs.nebius.com/rest-api/capacity/v1/capacity-allowances/get

Uses the requests library to perform a GET request. Requires the requests package to be installed.

```python
import requests

url = "https://api.nebius.cloud/capacity/v1/capacity-allowances/{id}"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)
```

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

### Install Docker and prepare environment

Source: https://docs.nebius.com/serverless/tutorials/video-translation

Commands to install Docker and additional packages, and add the current user to the docker group.

```bash
sudo apt-get update
sudo apt-get install -y docker.io git curl wget unzip python3 python3-pip ca-certificates
sudo usermod -aG docker "$USER"
newgrp docker
```

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

### Example command with JSON input for nebius tunnel get

Source: https://docs.nebius.com/cli/reference/tunnel/get

Example of invoking the command with an inline JSON payload.

```bash
nebius tunnel get '
{          
  "id": "" 
}
'
```

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

### Example: Get a project by name

Source: https://docs.nebius.com/cli/reference/iam/v2/project/get-by-name

Example command that retrieves a project by its name within a parent container, using placeholders for the tenant ID and project name.

```bash
nebius iam v2 project get-by-name --parent-id <tenant_ID> --name <project_name>
```
Tokens:
Raw