## Compute ### Virtual machines # Compute Source: https://docs.nebius.com/compute/index.md Compute allows you to create and manage virtual machines. These virtual machines function similarly to your local machine but are hosted in the cloud. You can connect to them and use their GPUs and other computing resources in your ML/AI workloads. In the [web console](https://console.nebius.com), Compute virtual machines are grouped on the **Virtual machines** page into four tabs: **Standalone VMs**, **Kubernetes nodes**, **Container VMs** and **Job and endpoint VMs**. The service is available in all [Nebius AI Cloud regions](https://docs.nebius.com/overview/regions.md). *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* Create your first set of virtual machines and connect to them Learn about virtual machines configurations Learn how to create different types of virtual machines Learn how to connect to virtual machines using SSH and allow other users to access VMs Create a GPU cluster and add VMs to it to interconnect them with InfiniBand Learn how to run tests to check the InfiniBand network state and performance Choose a storage option for your VMs that fits your goals best Manage and configure disks and shared filesystems Use volumes that you created on virtual machines Control GPU and vCPU states of your VMs Control disks and filesystems states # Getting started with Compute: Create your first Nebius AI Cloud virtual machine Source: https://docs.nebius.com/compute/quickstart.md To set up infrastructure for ML workloads, create the following resources in the `eu-north1` region: * Virtual machine (VM) with eight GPUs and a shared filesystem for training * Virtual machine with one GPU for inference Then, connect to them. ## Prerequisites Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). * [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. * Install [jq](https://jqlang.github.io/jq/) to extract IDs from JSON data returned by the Nebius AI Cloud CLI: ```bash Ubuntu sudo apt-get install jq ``` ```bash macOS brew install jq ``` * Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). * [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). * Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). * [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). * Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). * [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). * Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). ## Create a VM with eight GPUs with InfiniBand™ and a shared filesystem for training 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Click **Create resource** → **Virtual machine**. The creation flow is a step-by-step wizard. The sidebar shows your progress through the configuration sections. To move between sections, click **Back** and **Next**. 3. On the **Compute** step, configure computing resources: 1. In the **Platform** section, select **With GPUs** and **Regular**. Then, select a [platform](https://docs.nebius.com/compute/virtual-machines/types.md) with NVIDIA® H100, H200 or B200 GPUs. Only these platforms support GPU clusters. 2. In the **Settings** section, select a **Preset** with 8 GPUs. 3. Create a GPU cluster for the VM. InfiniBand in the GPU cluster interconnects the VM GPUs for high-speed networking and efficient training. To use a GPU cluster, select an existing one or create a new cluster: 1. Click **Create** in the **GPU cluster** field. 2. In the window that opens, specify the cluster name and InfiniBand fabric. To select the fabric, see [InfiniBand fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. Click **Create**. 4. In the same section, select the **Project** for the VM location and specify the **VM name**. 4. On the **Storage** step, configure the boot disk and attach a shared filesystem: 1. In the **Boot disk** section, click next to the boot disk. In the window that opens, keep **New VM-managed disk** selected, choose an Ubuntu [operating system](https://docs.nebius.com/compute/storage/boot-disk-images.md#images-for-gpu-vms) with pre-installed NVIDIA® GPU drivers, set the size to 50 GiB and click **Save**. 2. In the **Shared filesystems** section, click **Attach shared filesystem**. 3. In the window that opens, create a new filesystem: specify its name, set the size to 50 GiB and the block size to 4 KiB. Click **Attach filesystem**. 4. After the window is closed, in the **Mount tag** field, specify a tag for mounting the filesystem to the VM. Create your own tag, such as `my-filesystem`. Make sure that it is unique within the VM. 5. To mount the filesystem to the VM automatically, keep the **Auto mount** option enabled. 5. On the **Network** step, select the **Network** and **Subnet**. In the **Public IP address** field, select **Auto (dynamic)**, so you can later connect to the VM by SSH. 6. On the **Configuration** step, in the **Access** section, add credentials so you can connect to the VM: 1. In the **Username and SSH key** field, click **Create**. 2. In the window that opens, specify the username of the VM user, a public key of your SSH key pair and the credentials name to recognize the key in the list. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. 3. Click **Add credentials**. 7. On the **Review** step, check the full VM configuration. To change a section quickly, click next to the corresponding block. The wizard opens the relevant step with your current settings. Then, click **Create VM**. For more information about the wizard settings, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a shared filesystem and save its ID to an environment variable: ```bash export TR_VM_FILESYSTEM_ID=$(nebius compute filesystem create \ --name training-vm-filesystem-1 \ --size-gibibytes 50 \ --type network_ssd \ --block-size-bytes 4096 \ --format json | jq -r ".metadata.id") ``` The command creates a 50 GiB SSD shared filesystem with 4 KiB blocks. 2. Get the subnet ID and save it to an environment variable: ```bash export SUBNET_ID=$(nebius vpc subnet list \ --format json \ | jq -r ".items[0].metadata.id") ``` Possible subnet ID: `vpcsubnet-***`. 3. For high-speed networking and efficient training, consider interconnecting multiple VM GPUs in a GPU cluster using InfiniBand. To do this, before creating the VM, create a GPU cluster to connect the VM and get its ID: ```bash export GPU_CLUSTER_ID=$(nebius compute gpu-cluster create \ --name gpu-cluster-name \ --infiniband-fabric fabric-3 \ --format json \ | jq -r ".metadata.id") ``` 4. Create a VM with 8 GPUs for training: ```bash export USER_DATA=$(jq -Rrs '.' < 1. Create a boot disk: ```go trainingDiskOperation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "training-vm-disk-1", }, 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 = trainingDiskOperation.Wait(ctx); err != nil { return err } trainingBootDiskID := trainingDiskOperation.ResourceID() ``` The code creates a 50 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Create a shared filesystem: ```go trainingFSOperation, err := sdk.Services().Compute().V1(). Filesystem().Create( ctx, &compute.CreateFilesystemRequest{ Metadata: &common.ResourceMetadata{ Name: "training-vm-filesystem-1", }, Spec: &compute.FilesystemSpec{ Size: &compute.FilesystemSpec_SizeGibibytes{ SizeGibibytes: 50, }, BlockSizeBytes: 4096, Type: compute.FilesystemSpec_NETWORK_SSD, }, }, ) if err != nil { return err } if _, err = trainingFSOperation.Wait(ctx); err != nil { return err } trainingFilesystemID := trainingFSOperation.ResourceID() ``` The code creates a 50 GiB SSD shared filesystem with 4 KiB blocks. 3. Get the subnet ID: ```go subnets, err := sdk.Services().VPC().V1(). Subnet().List( ctx, &vpc.ListSubnetsRequest{}, ) if err != nil { return err } if len(subnets.GetItems()) == 0 { return errors.New("no subnets found") } subnetID := subnets.GetItems()[0].GetMetadata().GetId() ``` Possible subnet ID: `vpcsubnet-e0dcbaa76x2024xyz8`. 4. For high-speed networking and efficient training, consider interconnecting multiple VM GPUs in a GPU cluster using InfiniBand™. To do this, before creating the VM, create a GPU cluster to connect the VM and get its ID: ```go gpuClusterOperation, err := sdk.Services().Compute().V1(). GpuCluster().Create( ctx, &compute.CreateGpuClusterRequest{ Metadata: &common.ResourceMetadata{ Name: "gpu-cluster-name", }, Spec: &compute.GpuClusterSpec{ InfinibandFabric: "fabric-3", }, }, ) if err != nil { return err } if _, err = gpuClusterOperation.Wait(ctx); err != nil { return err } gpuClusterID := gpuClusterOperation.ResourceID() ``` 5. Create a VM with 8 GPUs for training: ```go var gpuCluster *compute.InstanceGpuClusterSpec if gpuClusterID != "" { gpuCluster = &compute.InstanceGpuClusterSpec{ Id: gpuClusterID, } } trainingNetworkName := "multi-gpu-node-compute-api-" + "network-interface" trainingResources := &compute.ResourcesSpec{ Platform: "gpu-h100-sxm", Size: &compute.ResourcesSpec_Preset{ Preset: "8gpu-128vcpu-1600gb", }, } trainingBootDisk := &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: trainingBootDiskID, }, }, } trainingExistingFS := &compute.ExistingFilesystem{ Id: trainingFilesystemID, } trainingFilesystem := &compute.AttachedFilesystemSpec{ AttachMode: compute.AttachedFilesystemSpec_READ_WRITE, MountTag: "training-vm-filesystem-1", Type: &compute.AttachedFilesystemSpec_ExistingFilesystem{ ExistingFilesystem: trainingExistingFS, }, } trainingNetwork := &compute.NetworkInterfaceSpec{ Name: trainingNetworkName, SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } trainingSpec := &compute.InstanceSpec{ Resources: trainingResources, GpuCluster: gpuCluster, BootDisk: trainingBootDisk, Filesystems: []*compute.AttachedFilesystemSpec{ trainingFilesystem, }, CloudInitUserData: userData, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ trainingNetwork, }, } trainingVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "training-vm", }, Spec: trainingSpec, }, ) if err != nil { return err } if _, err = trainingVMOperation.Wait(ctx); err != nil { return err } trainingVMID := trainingVMOperation.ResourceID() ``` The given example assumes that you work with VMs that have public addresses, so you can later [connect to these VMs by SSH](https://docs.nebius.com/compute/quickstart.md#connect-to-the-vms). However, if you need isolated VMs without public addresses, do not set `PublicIpAddress` in the network interface specification. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a boot disk: ```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 ``` The code creates a 50 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Create a shared filesystem: ```python filesystem_service = FilesystemServiceClient(sdk) training_fs_operation = await filesystem_service.create( CreateFilesystemRequest( metadata=ResourceMetadata( name="training-vm-filesystem-1", ), spec=FilesystemSpec( block_size_bytes=4096, type=FilesystemSpec.FilesystemType.NETWORK_SSD, size_gibibytes=50, ), ), ) await training_fs_operation.wait() training_filesystem_id = training_fs_operation.resource_id ``` The code creates a 50 GiB SSD shared filesystem with 4 KiB blocks. 3. Get the subnet ID: ```python subnet_service = SubnetServiceClient(sdk) subnets = await subnet_service.list(ListSubnetsRequest()) if not subnets.items: raise ValueError("no subnets found") subnet_id = subnets.items[0].metadata.id ``` Possible subnet ID: `vpcsubnet-e0dcbaa76x2024xyz8`. 4. For high-speed networking and efficient training, consider interconnecting multiple VM GPUs in a GPU cluster using InfiniBand™. To do this, before creating the VM, create a GPU cluster to connect the VM and get its ID: ```python gpu_cluster_service = GpuClusterServiceClient(sdk) gpu_cluster_operation = await gpu_cluster_service.create( CreateGpuClusterRequest( metadata=ResourceMetadata( name="gpu-cluster-name", ), spec=GpuClusterSpec( infiniband_fabric="fabric-3", ), ), ) await gpu_cluster_operation.wait() gpu_cluster_id = gpu_cluster_operation.resource_id ``` 5. Create a VM with 8 GPUs for training: ```python gpu_cluster = None if gpu_cluster_id: gpu_cluster = InstanceGpuClusterSpec(id=gpu_cluster_id) training_network_name = ( "multi-gpu-node-compute-api-" "network-interface" ) instance_service = InstanceServiceClient(sdk) training_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name="training-vm"), spec=InstanceSpec( resources=ResourcesSpec( platform="gpu-h100-sxm", preset="8gpu-128vcpu-1600gb", ), gpu_cluster=gpu_cluster, boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), existing_disk=ExistingDisk( id=training_boot_disk_id, ), ), filesystems=[ AttachedFilesystemSpec( attach_mode=( AttachedFilesystemSpec.AttachMode.READ_WRITE ), existing_filesystem=ExistingFilesystem( id=training_filesystem_id, ), mount_tag="training-vm-filesystem-1", ), ], cloud_init_user_data=user_data, network_interfaces=[ NetworkInterfaceSpec( name=training_network_name, subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await training_vm_operation.wait() training_vm_id = training_vm_operation.resource_id ``` The given example assumes that you work with VMs that have public addresses, so you can later [connect to these VMs by SSH](https://docs.nebius.com/compute/quickstart.md#connect-to-the-vms). However, if you need isolated VMs without public addresses, do not set `public_ip_address` in the network interface specification. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a boot disk: ```ts const diskService = new DiskService(sdk); const trainingDiskOperation = await diskService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "training-vm-disk-1", }), spec: DiskSpec.create({ blockSizeBytes: 4096, type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-cuda13.0", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 50, }, }), }), ).result; await trainingDiskOperation.wait(); const trainingBootDiskId = trainingDiskOperation.resourceId(); ``` The code creates a 50 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Create a shared filesystem: ```ts const filesystemService = new FilesystemService(sdk); const trainingFsOperation = await filesystemService.create( CreateFilesystemRequest.create({ metadata: ResourceMetadata.create({ name: "training-vm-filesystem-1", }), spec: FilesystemSpec.create({ blockSizeBytes: 4096, type: FilesystemSpec_FilesystemType.NETWORK_SSD, size: { $case: "sizeGibibytes", sizeGibibytes: 1024, }, }), }), ).result; await trainingFsOperation.wait(); const trainingFilesystemId = trainingFsOperation.resourceId(); ``` The code creates a 50 GiB SSD shared filesystem with 4 KiB blocks. 3. Get the subnet ID: ```ts const subnetService = new SubnetService(sdk); const subnets = await subnetService.list( ListSubnetsRequest.create({}), ); const subnetId = subnets.items[0]?.metadata?.id; if (!subnetId) { throw new Error("no subnets found"); } ``` Possible subnet ID: `vpcsubnet-e0dcbaa76x2024xyz8`. 4. For high-speed networking and efficient training, consider interconnecting multiple VM GPUs in a GPU cluster using InfiniBand™. To do this, before creating the VM, create a GPU cluster to connect the VM and get its ID: ```ts const gpuClusterService = new GpuClusterService(sdk); const gpuClusterOperation = await gpuClusterService.create( CreateGpuClusterRequest.create({ metadata: ResourceMetadata.create({ name: "gpu-cluster-name", }), spec: GpuClusterSpec.create({ infinibandFabric: "fabric-3", }), }), ).result; await gpuClusterOperation.wait(); let gpuClusterId = gpuClusterOperation.resourceId(); ``` 5. Create a VM with 8 GPUs for training: ```ts const gpuCluster = gpuClusterId ? InstanceGpuClusterSpec.create({ id: gpuClusterId }) : undefined; const trainingNetworkName = "multi-gpu-node-compute-api-" + "network-interface"; const instanceService = new InstanceService(sdk); const trainingVmOperation = await instanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "training-vm", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "gpu-h100-sxm", size: { $case: "preset", preset: "8gpu-128vcpu-1600gb", }, }), gpuCluster, bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: trainingBootDiskId, }), }, }), filesystems: [ AttachedFilesystemSpec.create({ attachMode: AttachedFilesystemSpec_AttachMode.READ_WRITE, mountTag: "training-vm-filesystem-1", type: { $case: "existingFilesystem", existingFilesystem: ExistingFilesystem.create({ id: trainingFilesystemId, }), }, }), ], cloudInitUserData: userData, networkInterfaces: [ NetworkInterfaceSpec.create({ name: trainingNetworkName, subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await trainingVmOperation.wait(); const trainingVmId = trainingVmOperation.resourceId(); ``` The given example assumes that you work with VMs that have public addresses, so you can later [connect to these VMs by SSH](https://docs.nebius.com/compute/quickstart.md#connect-to-the-vms). However, if you need isolated VMs without public addresses, do not set `publicIpAddress` in the network interface specification. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). ## Create a VM with one GPU for inference 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Click **Create resource** → **Virtual machine**. 3. On the **Compute** step, configure computing resources: 1. In the **Platform** section, select **With GPUs** and **Regular**. Then, select any [GPU platform](https://docs.nebius.com/compute/virtual-machines/types.md). 2. In the **Settings** section, select a **Preset** with one GPU and the **Project** for the VM location, and specify the **VM name**. 4. On the **Storage** step, in the **Boot disk** section, click next to the boot disk. In the window that opens, keep **New VM-managed disk** selected, choose an Ubuntu operating system with pre-installed NVIDIA® GPU drivers, set the size to 50 GiB and click **Save**. 5. On the **Network** step, select the **Network** and **Subnet**. In the **Public IP address** field, select **Auto (dynamic)**, so you can later connect to the VM by SSH. 6. On the **Configuration** step, in the **Access** section, add the same username and SSH public key that you used for the VM with eight GPUs. 7. On the **Review** step, check the full VM configuration and click **Create VM**. Create a VM with one GPU for inference: ```bash export INF_VM_ID=$(nebius compute instance create \ --name inference-vm \ --resources-platform gpu-h100-sxm \ --resources-preset 1gpu-16vcpu-200gb \ --boot-disk-managed-disk-name inference-vm-disk-1 \ --boot-disk-managed-disk-type network_ssd \ --boot-disk-managed-disk-size-gibibytes 50 \ --boot-disk-managed-disk-block-size-bytes 4096 \ --boot-disk-managed-disk-source-image-family-image-family ubuntu24.04-cuda13.0 \ --boot-disk-attach-mode READ_WRITE \ --cloud-init-user-data "$USER_DATA" \ --network-interfaces "[{\"name\": \"eth0\", \"subnet_id\": \"$SUBNET_ID\", \"ip_address\": {}, \"public_ip_address\": {}}]" \ --format json | jq -r ".metadata.id") ``` The command creates the VM with a boot disk that has the same settings as the boot disk of the training VM. It uses the same `USER_DATA` variable and cloud-init configuration as the training VM. 1. Create a boot disk: ```go inferenceDiskOperation, err := sdk.Services().Compute().V1().Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "inference-vm-disk-1", }, 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 = inferenceDiskOperation.Wait(ctx); err != nil { return err } inferenceBootDiskID := inferenceDiskOperation.ResourceID() ``` The code creates a 50 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Create a VM with one GPU for inference: ```go inferenceNetworkName := "single-gpu-node-compute-api-" + "network-interface" inferenceResources := &compute.ResourcesSpec{ Platform: "gpu-h100-sxm", Size: &compute.ResourcesSpec_Preset{ Preset: "1gpu-16vcpu-200gb", }, } inferenceBootDisk := &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: inferenceBootDiskID, }, }, } inferenceNetwork := &compute.NetworkInterfaceSpec{ Name: inferenceNetworkName, SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } inferenceSpec := &compute.InstanceSpec{ Resources: inferenceResources, BootDisk: inferenceBootDisk, CloudInitUserData: userData, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ inferenceNetwork, }, } inferenceVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "inference-vm", }, Spec: inferenceSpec, }, ) if err != nil { return err } if _, err = inferenceVMOperation.Wait(ctx); err != nil { return err } inferenceVMID := inferenceVMOperation.ResourceID() ``` 1. Create a boot disk: ```python inference_disk_service = DiskServiceClient(sdk) inference_disk_operation = await inference_disk_service.create( CreateDiskRequest( metadata=ResourceMetadata( name="inference-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 inference_disk_operation.wait() inference_boot_disk_id = inference_disk_operation.resource_id ``` The code creates a 50 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Create a VM with one GPU for inference: ```python inference_network_name = ( "single-gpu-node-compute-api-" "network-interface" ) inference_service = InstanceServiceClient(sdk) inference_vm_operation = await inference_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name="inference-vm"), spec=InstanceSpec( resources=ResourcesSpec( platform="gpu-h100-sxm", preset="1gpu-16vcpu-200gb", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), existing_disk=ExistingDisk( id=inference_boot_disk_id, ), ), cloud_init_user_data=user_data, network_interfaces=[ NetworkInterfaceSpec( name=inference_network_name, subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await inference_vm_operation.wait() inference_vm_id = inference_vm_operation.resource_id ``` 1. Create a boot disk: ```ts const inferenceDiskService = new DiskService(sdk); const inferenceDiskOperation = await inferenceDiskService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "inference-vm-disk-1", }), spec: DiskSpec.create({ blockSizeBytes: 4096, type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-cuda13.0", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 50, }, }), }), ).result; await inferenceDiskOperation.wait(); const inferenceBootDiskId = inferenceDiskOperation.resourceId(); ``` The code creates a 50 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Create a VM with one GPU for inference: ```ts const inferenceNetworkName = "single-gpu-node-compute-api-" + "network-interface"; const inferenceService = new InstanceService(sdk); const inferenceVmOperation = await inferenceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "inference-vm", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "gpu-h100-sxm", size: { $case: "preset", preset: "1gpu-16vcpu-200gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: inferenceBootDiskId, }), }, }), cloudInitUserData: userData, networkInterfaces: [ NetworkInterfaceSpec.create({ name: inferenceNetworkName, subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await inferenceVmOperation.wait(); const inferenceVmId = inferenceVmOperation.resourceId(); ``` ## Connect to the VMs Connect to the VM for training via SSH: 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Open the page of the VM and copy its public IP address. 3. Use the public IP address to connect to the VM: ```bash ssh @ ``` Use the username that you specified when creating the VM. 1. Get your VM's public IP address and save it to an environment variable: ```bash export TR_PUBLIC_IP_ADDRESS=$(nebius compute instance get \ --id $TR_VM_ID \ --format json \ | jq -r '.status.network_interfaces[0].public_ip_address.address | split("/")[0]') ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@$TR_PUBLIC_IP_ADDRESS ``` 1. Get your VM's public IP address: ```go trainingInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: trainingVMID, }, ) if err != nil { return err } trainingAddress := trainingInstance.GetStatus(). GetNetworkInterfaces()[0]. GetPublicIpAddress().GetAddress() trainingPublicIP := strings.Split(trainingAddress, "/")[0] if trainingPublicIP == "" { return fmt.Errorf("training VM public IP is missing") } ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@ ``` 1. Get your VM's public IP address: ```python training_ip_service = InstanceServiceClient(sdk) training_instance = await training_ip_service.get( GetInstanceRequest(id=training_vm_id), ) training_address = ( training_instance.status.network_interfaces[0] .public_ip_address.address ) training_public_ip = training_address.split("/")[0] ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@ ``` 1. Get your VM's public IP address: ```ts const trainingIpService = new InstanceService(sdk); const trainingInstance = await trainingIpService.get( GetInstanceRequest.create({ id: trainingVmId, }), ); const trainingAddress = trainingInstance.status ?.networkInterfaces[0]?.publicIpAddress?.address; const trainingPublicIp = trainingAddress?.split("/")[0]; if (!trainingPublicIp) { throw new Error("training VM public IP is missing"); } ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@ ``` Connect to the VM for inference via SSH: Do the same steps as for the training VM. Open the page of the inference VM, copy its public IP address and then connect to the inference VM: ```bash ssh @ ``` Use the username that you specified when creating the inference VM. 1. Get your VM's public IP address and save it to an environment variable: ```bash export INF_PUBLIC_IP_ADDRESS=$(nebius compute instance get \ --id $INF_VM_ID \ --format json \ | jq -r '.status.network_interfaces[0].public_ip_address.address | split("/")[0]') ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@$INF_PUBLIC_IP_ADDRESS ``` 1. Get your VM's public IP address: ```go inferenceInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: inferenceVMID, }, ) if err != nil { return err } inferenceAddress := inferenceInstance.GetStatus(). GetNetworkInterfaces()[0]. GetPublicIpAddress().GetAddress() inferencePublicIP := strings.Split(inferenceAddress, "/")[0] if inferencePublicIP == "" { return fmt.Errorf("inference VM public IP is missing") } ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@ ``` 1. Get your VM's public IP address: ```python inference_ip_service = InstanceServiceClient(sdk) inference_instance = await inference_ip_service.get( GetInstanceRequest(id=inference_vm_id), ) inference_address = ( inference_instance.status.network_interfaces[0] .public_ip_address.address ) inference_public_ip = inference_address.split("/")[0] ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@ ``` 1. Get your VM's public IP address: ```ts const inferenceIpService = new InstanceService(sdk); const inferenceInstance = await inferenceIpService.get( GetInstanceRequest.create({ id: inferenceVmId, }), ); const inferenceAddress = inferenceInstance.status ?.networkInterfaces[0]?.publicIpAddress?.address; const inferencePublicIp = inferenceAddress?.split("/")[0]; if (!inferencePublicIp) { throw new Error("inference VM public IP is missing"); } ``` 2. Use the public IP address to connect to the VM: ```bash ssh user@ ``` ## What's next * Learn about [VM and GPU types](https://docs.nebius.com/compute/virtual-machines/types.md) * Learn how to [create different types of VMs](https://docs.nebius.com/compute/virtual-machines/manage.md) * Learn more about [VM networking](https://docs.nebius.com/compute/virtual-machines/network.md) * Learn how to work with [GPU clusters](https://docs.nebius.com/compute/clusters/gpu/index.md) *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # Getting started with Compute: Host an LLM on Nebius AI Cloud Source: https://docs.nebius.com/compute/quickstart-host-model.md You can create a virtual machine (VM) in Nebius AI Cloud, deploy the [Qwen/Qwen2.5-72B-Instruct](https://huggingface.co/Qwen/Qwen2.5-72B-Instruct) large language model (LLM) on the VM and then use [Open WebUI](https://openwebui.com/) to provide access to the model in a browser. ## Before you start Meet the following prerequisites, depending on the preferred interface: Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). 1. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. 2. To extract JSON data from the CLI output, install [jq](https://jqlang.github.io/jq/): ```bash Ubuntu sudo apt-get install jq ``` ```bash macOS brew install jq ``` 3. Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). 1. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). 2. Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). 1. [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). 2. Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). 1. [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). 2. Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). ## Create the VM 1. Go to the [web console](https://console.nebius.com), click **Create resource** and then select **Virtual machine**. 2. On the VM creation page that opens, set the following parameters: * **Platform**: NVIDIA® H100 NVLink with Intel Sapphire Rapids. * **Preset**: 1 GPU - 16 CPUs - 200 GiB RAM. * **Boot disk image**: Ubuntu 22.04 LTS for NVIDIA® GPUs (CUDA® 12). For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). * **Boot disk size**: 300 GiB SSD. * **Network**: Select the **Public IP address: Auto assign static IP** option. * **Username and SSH key**: Select the public key that you created earlier. In this field, do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. 3. Click **Create VM**. The given example assumes that you work with a VM that has a public address, so you can later [connect to this VM by SSH](https://docs.nebius.com/compute/quickstart-host-model.md#connect-to-the-vm). However, if you need an isolated VM, do not assign a public address. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a boot disk and save its ID to an environment variable: ```bash export BOOT_DISK_ID=$(nebius compute disk create \ --name openwebui-disk-1 \ --size-gibibytes 300 \ --type network_ssd \ --source-image-family-image-family ubuntu24.04-cuda13.0 \ --block-size-bytes 4096 \ --format json | jq -r ".metadata.id") ``` The command creates a 300 GiB SSD disk with a 4 KiB block size, and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Get the default subnet ID and save it to an environment variable: ```bash export SUBNET_ID=$(nebius vpc subnet list \ --format json \ | jq -r ".items[0].metadata.id") ``` 3. Create the VM with one GPU: ```bash export USER_DATA=$(jq -Rrs '.' < sudo: ALL=(ALL) NOPASSWD:ALL shell: /bin/bash ssh_authorized_keys: - $(cat ~/.ssh/id_ed25519.pub) EOF ) export VM_ID=$(nebius compute instance create \ --name openwebui \ --resources-platform gpu-h100-sxm \ --resources-preset 1gpu-16vcpu-200gb \ --boot-disk-existing-disk-id "$BOOT_DISK_ID" \ --boot-disk-attach-mode READ_WRITE \ --cloud-init-user-data "$USER_DATA" \ --network-interfaces "[{\"name\": \"default-subnet\", \"subnet_id\": \"$SUBNET_ID\", \"ip_address\": {}, \"public_ip_address\": {}}]" \ --format json | jq -r ".metadata.id") ``` The given example assumes that you work with a VM that has a public address, so you can later [connect to this VM by SSH](https://docs.nebius.com/compute/quickstart-host-model.md#connect-to-the-vm). However, if you need an isolated VM without a public address, remove `"public_ip_address": {}` from the `--network-interfaces` parameter. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a boot disk: ```go bootDiskOperation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "openwebui-disk-1", }, Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: 300, }, 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 = bootDiskOperation.Wait(ctx); err != nil { return err } bootDiskID := bootDiskOperation.ResourceID() ``` The code creates a 300 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Get the default subnet ID: ```go subnets, err := sdk.Services().VPC().V1(). Subnet().List( ctx, &vpc.ListSubnetsRequest{}, ) if err != nil { return err } if len(subnets.GetItems()) == 0 { return errors.New("no subnets found") } subnetID := subnets.GetItems()[0].GetMetadata().GetId() ``` 3. Create the VM with one GPU: ```go hostResources := &compute.ResourcesSpec{ Platform: "gpu-h100-sxm", Size: &compute.ResourcesSpec_Preset{ Preset: "1gpu-16vcpu-200gb", }, } hostBootDisk := &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: bootDiskID, }, }, } hostNetworkInterface := &compute.NetworkInterfaceSpec{ Name: "default-subnet", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } hostInstanceSpec := &compute.InstanceSpec{ Resources: hostResources, BootDisk: hostBootDisk, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ hostNetworkInterface, }, CloudInitUserData: userData, } hostOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "openwebui", }, Spec: hostInstanceSpec, }, ) if err != nil { return err } if _, err = hostOperation.Wait(ctx); err != nil { return err } ``` The given example assumes that you work with a VM that has a public address, so you can later [connect to this VM by SSH](https://docs.nebius.com/compute/quickstart-host-model.md#connect-to-the-vm). However, if you need an isolated VM without a public address, remove the public IP address specification from the network interface parameters. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a boot disk: ```python disk_service = DiskServiceClient(sdk) boot_disk_operation = await disk_service.create( CreateDiskRequest( metadata=ResourceMetadata( name="openwebui-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=300, ), ), ) await boot_disk_operation.wait() boot_disk_id = boot_disk_operation.resource_id ``` The code creates a 300 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Get the default subnet ID: ```python subnet_service = SubnetServiceClient(sdk) subnets = await subnet_service.list(ListSubnetsRequest()) if not subnets.items: raise ValueError("no subnets found") subnet_id = subnets.items[0].metadata.id ``` 3. Create the VM with one GPU: ```python instance_service = InstanceServiceClient(sdk) host_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name="openwebui"), spec=InstanceSpec( resources=ResourcesSpec( platform="gpu-h100-sxm", preset="1gpu-16vcpu-200gb", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), existing_disk=ExistingDisk(id=boot_disk_id), ), cloud_init_user_data=user_data, network_interfaces=[ NetworkInterfaceSpec( name="default-subnet", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await host_operation.wait() ``` The given example assumes that you work with a VM that has a public address, so you can later [connect to this VM by SSH](https://docs.nebius.com/compute/quickstart-host-model.md#connect-to-the-vm). However, if you need an isolated VM without a public address, remove the public IP address specification from the network interface parameters. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). 1. Create a boot disk: ```ts const diskService = new DiskService(sdk); const bootDiskOperation = await diskService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "openwebui-disk-1", }), spec: DiskSpec.create({ blockSizeBytes: 4096, type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-cuda13.0", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 300, }, }), }), ).result; await bootDiskOperation.wait(); const bootDiskId = bootDiskOperation.resourceId(); ``` The code creates a 300 GiB SSD disk with a 4 KiB block size and an Ubuntu boot image with pre-installed NVIDIA® GPU drivers. For details about boot disk images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 2. Get the default subnet ID: ```ts const subnetService = new SubnetService(sdk); const subnets = await subnetService.list( ListSubnetsRequest.create({}), ); const subnetId = subnets.items[0]?.metadata?.id; if (!subnetId) { throw new Error("no subnets found"); } ``` 3. Create the VM with one GPU: ```ts const instanceService = new InstanceService(sdk); const hostOperation = await instanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "openwebui", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "gpu-h100-sxm", size: { $case: "preset", preset: "1gpu-16vcpu-200gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: bootDiskId, }), }, }), cloudInitUserData: userData, networkInterfaces: [ NetworkInterfaceSpec.create({ name: "default-subnet", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await hostOperation.wait(); ``` The given example assumes that you work with a VM that has a public address, so you can later [connect to this VM by SSH](https://docs.nebius.com/compute/quickstart-host-model.md#connect-to-the-vm). However, if you need an isolated VM without a public address, remove the public IP address specification from the network interface parameters. To access the VM, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) later. This approach enhances security and still provides access to the VM within the same subnet. For more information about creating VMs and managing their network parameters, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). ## Connect to the VM 1. Get the public IP address of the VM: 1. Open the VM page. 2. In the **Network** block, copy the **Public IPv4** value. Run the following command: ```bash export PUBLIC_IP_ADDRESS=$(nebius compute instance get-by-name \ --name openwebui \ --format json \ | jq -r '.status.network_interfaces[0].public_ip_address.address | split("/")[0]') ``` ```go publicInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "openwebui", }, ) if err != nil { return err } publicAddress := publicInstance.GetStatus(). GetNetworkInterfaces()[0]. GetPublicIpAddress().GetAddress() publicIPAddress := strings.Split(publicAddress, "/")[0] if publicIPAddress == "" { return fmt.Errorf("public IP address is missing") } ``` ```python public_ip_service = InstanceServiceClient(sdk) public_instance = await public_ip_service.get_by_name( GetByNameRequest(name="openwebui"), ) public_address = ( public_instance.status.network_interfaces[0] .public_ip_address.address ) public_ip_address = public_address.split("/")[0] ``` ```ts const publicIpService = new InstanceService(sdk); const publicInstance = await publicIpService.getByName( GetByNameRequest.create({ name: "openwebui", }), ); const publicAddress = publicInstance.status ?.networkInterfaces[0]?.publicIpAddress?.address; const publicIpAddress = publicAddress?.split("/")[0]; if (!publicIpAddress) { throw new Error("public IP address is missing"); } ``` 2. Connect to the VM: ```bash ssh @ ``` Specify the received public IP address and the username that you set during the VM creation. ## Create a virtual environment and install the necessary packages To work with Open WebUI, you need a dedicated [virtual environment](https://docs.python.org/3/tutorial/venv.html). It enables you to set up and run the OpenWebUI server in isolation from other software on the VM. To create a virtual environment, use [Miniconda](https://docs.anaconda.com/miniconda/). To configure the environment: 1. Download and install the latest Miniconda version: ```bash mkdir -p ~/miniconda3 wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3 rm ~/miniconda3/miniconda.sh ``` 2. Initialize Miniconda: ```bash source ~/miniconda3/bin/activate ``` On initialization, Miniconda activates its `base` environment. 3. Create an `OpenWebUI` environment with Python 3.11: ```bash conda create -n OpenWebUI python=3.11 conda init bash echo "conda activate OpenWebUI " >> ~/.bashrc source ~/.bashrc ``` This command creates and activates a new environment. 4. Install [Ollama](https://ollama.com/), which provides access to the model: ```bash curl -fsSL https://ollama.com/install.sh | sh ``` 5. Install Open WebUI: ```bash pip install open-webui ``` ## Start the Open WebUI server 1. Start the server: ```bash open-webui serve ``` 2. Open the Open WebUI interface in the browser. To do this, enter the `http://:8080` address in the search bar. 3. In the Open WebUI interface, create an account to work with LLMs locally within the VM. For details on working with Open WebUI, see [their documentation](https://docs.openwebui.com/). If you need to restart the server, use the same command: `open-webui serve`. ## Download the Qwen/Qwen2.5-72B-Instruct model 1. In Open WebUI, click **Select a model**. 2. Paste `qwen2.5:72b` into the search bar. 3. Click **Pull "qwen2.5:72b" from Ollama** and wait for the download to finish. 4. Click **Select a model** again and then choose Qwen/Qwen2.5-72B-Instruct. Now you can chat with the model in the browser. ## Make Open WebUI start automatically With the current configuration, you need to manually start the Open WebUI server every time you connect to your VM. Alternatively, you can configure the server to start up whenever the VM starts. To do this: 1. Create a `systemd` service file for Open WebUI and open the file in an editor: ```bash sudo nano /etc/systemd/system/openwebui.service ``` 2. Paste the following contents into the file and save it. Specify the username that you set during the VM creation: ```ini [Unit] Description=OpenWebUI Server After=network.target [Service] User= WorkingDirectory=/home// ExecStart=/home//miniconda3/envs/OpenWebUI/bin/open-webui serve Restart=always [Install] WantedBy=multi-user.target ``` 3. To make the new service file recognizable, reload `systemd`: ```bash sudo systemctl daemon-reload ``` 4. To start automatically and immediately, enable the `systemd` service: ```bash sudo systemctl enable openwebui.service sudo systemctl start openwebui.service ``` 5. Verify that the service is running: ```bash sudo systemctl status openwebui.service ``` Whenever you start up your VM in the web console, Open WebUI now automatically launches in the background. You can directly access it in the browser at `http://ip_address:8080` and work with the Qwen/Qwen2.5-72B-Instruct model. # Types of virtual machines and GPUs in Nebius AI Cloud Source: https://docs.nebius.com/compute/virtual-machines/types.md Compute offers the following platforms for virtual machines (VMs) ([private regions](https://docs.nebius.com/overview/regions.md) are marked with \*): | Platform name | Platform ID | CPU | [Regions](https://docs.nebius.com/overview/regions.md) | | ----------------------------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | NVIDIA® B300 NVLink with Intel Granite Rapids | gpu-b300-sxm | [Intel Xeon 6776P](https://www.intel.com/content/www/us/en/products/sku/243691/intel-xeon-6776p-processor-336m-cache-2-30-ghz/specifications.html) | `uk-south1`, `eu-west2`*\** | | NVIDIA® B200 NVLink with Intel Emerald Rapids | gpu-b200-sxm | [Intel Xeon Platinum 8580](https://www.intel.com/content/www/us/en/products/sku/237250/intel-xeon-platinum-8580-processor-300m-cache-2-00-ghz/specifications.html) | `us-central1` | | NVIDIA® B200 NVLink with Intel Emerald Rapids | gpu-b200-sxm-a | [Intel Xeon Platinum 8570](https://www.intel.com/content/www/us/en/products/sku/237264/intel-xeon-platinum-8570-processor-300m-cache-2-10-ghz/specifications.html) | `me-west1` | | NVIDIA® RTX PRO™ 6000 with Intel Granite Rapids | gpu-rtx6000 | [Intel Xeon 6776P](https://www.intel.com/content/www/us/en/products/sku/243691/intel-xeon-6776p-processor-336m-cache-2-30-ghz/specifications.html) | `us-central1` | | NVIDIA® H200 NVLink with Intel Sapphire Rapids | gpu-h200-sxm | [Intel Xeon Platinum 8468](https://ark.intel.com/content/www/us/en/ark/products/231735/intel-xeon-platinum-8468-processor-105m-cache-2-10-ghz.html) | `eu-north1`, `eu-north2`*\**, `eu-west1`, `us-central1` | | NVIDIA® H100 NVLink with Intel Sapphire Rapids | gpu-h100-sxm | [Intel Xeon Platinum 8468](https://ark.intel.com/content/www/us/en/ark/products/231735/intel-xeon-platinum-8468-processor-105m-cache-2-10-ghz.html) | `eu-north1` | | NVIDIA® L40S PCIe with Intel Ice Lake | gpu-l40s-a | [Intel Xeon Gold 6338](https://ark.intel.com/content/www/us/en/ark/products/212285/intel-xeon-gold-6338-processor-48m-cache-2-00-ghz.html) | `eu-north1` | | NVIDIA® L40S PCIe with AMD EPYC Genoa | gpu-l40s-d | [AMD EPYC™ 9654](https://www.amd.com/en/products/processors/server/epyc/4th-generation-9004-and-8004-series/amd-epyc-9654.html) | `eu-north1` | | Non-GPU AMD EPYC Genoa | cpu-d3 | [AMD EPYC™ 9654](https://www.amd.com/en/products/processors/server/epyc/4th-generation-9004-and-8004-series/amd-epyc-9654.html) | `eu-north1`, `eu-west1`, `me-west1`, `us-central1`;
`eu-north2`*\**, `uk-south1`*\** | | Non-GPU Intel Ice Lake | cpu-e2 | [Intel Xeon Gold 6338](https://ark.intel.com/content/www/us/en/ark/products/212285/intel-xeon-gold-6338-processor-48m-cache-2-00-ghz.html) | `eu-north1` | Each platform offers different *presets* for creating VMs. The presets vary by the number of GPUs (for platforms with GPUs), vCPUs and RAM size. The exact amount of these resources is indicated in the preset name. Thus, `1gpu-16vcpu-200gb` preset stands for a VM with 1 GPU, 16 vCPUs and 200 Nebius uses binary units. For example, a gibibyte (GiB) is 2³⁰ (1024³) bytes.}>GiB RAM. Availability of platforms depends on a region and project. You can [get a list](https://docs.nebius.com/compute/virtual-machines/list-platforms.md) of platforms and presets supported in a given project. For VM platforms with GPUs, you can also use the [capacity advisor](https://docs.nebius.com/compute/virtual-machines/capacity-advisor.md) to get information about the availability of computing resources based on your quotas and the current physical capacity. ## GPU types Compute provides VMs with the following GPU types: | GPU | Architecture | Form factor | GPU memory | Memory bandwidth | InfiniBand interconnect | Network adapter | Platform | CPU | | --------------------------------------------------------------------------------------------------------------------- | --------------- | ----------- | ------------ | ---------------- | ------------------------ | -------------------- | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [NVIDIA B300](https://www.nvidia.com/en-us/data-center/dgx-b300/) | Blackwell Ultra | SXM | 288 GB HBM3e | 10 TB/s | 800 Gbps (8× ConnectX-8) | BlueField-3 400 Gbps | `gpu-b300-sxm` | [Intel Xeon 6776P](https://www.intel.com/content/www/us/en/products/sku/243691/intel-xeon-6776p-processor-336m-cache-2-30-ghz/specifications.html) | | [NVIDIA B200](https://www.nvidia.com/en-us/data-center/dgx-b200/) | Blackwell | SXM | 180 GB HBM3e | 8 TB/s | 400 Gbps (8× ConnectX-7) | BlueField-3 400 Gbps | `gpu-b200-sxm`, `gpu-b200-sxm-a` | [Intel Xeon Platinum 8580](https://www.intel.com/content/www/us/en/products/sku/237250/intel-xeon-platinum-8580-processor-300m-cache-2-00-ghz/specifications.html), [Intel Xeon Platinum 8570](https://www.intel.com/content/www/us/en/products/sku/237264/intel-xeon-platinum-8570-processor-300m-cache-2-10-ghz/specifications.html) | | [NVIDIA RTX PRO 6000 Server Edition](https://www.nvidia.com/en-us/data-center/rtx-pro-6000-blackwell-server-edition/) | Blackwell | PCIe Gen5 | 96 GB GDDR7 | 1.6 TB/s | — | BlueField-3 400 Gbps | `gpu-rtx6000` | [Intel Xeon 6776P](https://www.intel.com/content/www/us/en/products/sku/243691/intel-xeon-6776p-processor-336m-cache-2-30-ghz/specifications.html) | | [NVIDIA H200](https://www.nvidia.com/en-us/data-center/h200/) | Hopper | SXM | 141 GB HBM3e | 4.8 TB/s | 400 Gbps (8× ConnectX-7) | BlueField-3 200 Gbps | `gpu-h200-sxm` | [Intel Xeon Platinum 8468](https://ark.intel.com/content/www/us/en/ark/products/231735/intel-xeon-platinum-8468-processor-105m-cache-2-10-ghz.html) | | [NVIDIA H100](https://www.nvidia.com/en-us/data-center/h100/) | Hopper | SXM | 80 GB HBM3 | 3.35 TB/s | 400 Gbps (8× ConnectX-7) | ConnectX-6 100 Gbps | `gpu-h100-sxm` | [Intel Xeon Platinum 8468](https://ark.intel.com/content/www/us/en/ark/products/231735/intel-xeon-platinum-8468-processor-105m-cache-2-10-ghz.html) | | [NVIDIA L40S](https://www.nvidia.com/en-us/data-center/l40s/) | Ada Lovelace | PCIe | 48 GB GDDR6 | 864 GB/s | — | — | `gpu-l40s-a`, `gpu-l40s-d` | [Intel Xeon Gold 6338](https://ark.intel.com/content/www/us/en/ark/products/212285/intel-xeon-gold-6338-processor-48m-cache-2-00-ghz.html), [AMD EPYC™ 9654](https://www.amd.com/en/products/processors/server/epyc/4th-generation-9004-and-8004-series/amd-epyc-9654.html) | ## Presets for GPU platforms * NVIDIA® B300 NVLink with Intel Granite Rapids (gpu-b300-sxm), available in uk-south1 and eu-west2*\**: | Preset name | Number of GPUs | Number of vCPUs | RAM, Nebius uses binary units. For example, a gibibyte (GiB) is 2³⁰ (1024³) bytes.}>GiB | | --------------------- | -------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | `1gpu-24vcpu-346gb` | 1 | 24 | 346 | | `8gpu-192vcpu-2768gb` | 8 | 192 | 2768 | * NVIDIA® B200 NVLink with Intel Emerald Rapids (gpu-b200-sxm and gpu-b200-sxm-a), available in us-central1 and me-west1 respectively: | Preset name | Number of GPUs | Number of vCPUs | RAM, GiB | | --------------------- | -------------- | --------------- | -------- | | `1gpu-20vcpu-224gb` | 1 | 20 | 224 | | `8gpu-160vcpu-1792gb` | 8 | 160 | 1792 | * NVIDIA® H200 NVLink with Intel Sapphire Rapids (gpu-h200-sxm), available in eu-north1, eu-north2*\**, eu-west1 and us-central1: | Preset name | Number of GPUs | Number of vCPUs | RAM, GiB | [Regions](https://docs.nebius.com/overview/regions.md) | | --------------------- | -------------- | --------------- | -------- | ----------------------------------------------------------------------------------------------- | | `1gpu-16vcpu-200gb` | 1 | 16 | 200 | eu-north1, eu-west1, us-central1, eu-north2 | | `8gpu-128vcpu-1600gb` | 8 | 128 | 1600 | eu-north1, eu-west1, us-central1, eu-north2 | * NVIDIA® H100 NVLink with Intel Sapphire Rapids (gpu-h100-sxm), available in eu-north1: | Preset name | Number of GPUs | Number of vCPUs | RAM, GiB | | --------------------- | -------------- | --------------- | -------- | | `1gpu-16vcpu-200gb` | 1 | 16 | 200 | | `8gpu-128vcpu-1600gb` | 8 | 128 | 1600 | * NVIDIA® RTX PRO™ 6000 with Intel Granite Rapids (gpu-rtx6000), available in us-central1: | Preset name | Number of GPUs | Number of vCPUs | RAM, GiB | | --------------------- | -------------- | --------------- | -------- | | `1gpu-24vcpu-218gb` | 1 | 24 | 218 | | `8gpu-192vcpu-1744gb` | 8 | 192 | 1744 | * NVIDIA® L40S PCIe with Intel Ice Lake (gpu-l40s-a), available in eu-north1: | Preset name | Number of GPUs | Number of vCPUs | RAM, GiB | | ------------------- | -------------- | --------------- | -------- | | `1gpu-8vcpu-32gb` | 1 | 8 | 32 | | `1gpu-16vcpu-64gb` | 1 | 16 | 64 | | `1gpu-24vcpu-96gb` | 1 | 24 | 96 | | `1gpu-32vcpu-128gb` | 1 | 32 | 128 | | `1gpu-40vcpu-160gb` | 1 | 40 | 160 | * NVIDIA® L40S PCIe with AMD EPYC Genoa (gpu-l40s-d), available in eu-north1: | Preset name | Number of GPUs | Number of vCPUs | RAM, GiB | | --------------------- | -------------- | --------------- | -------- | | `1gpu-16vcpu-96gb` | 1 | 16 | 96 | | `1gpu-32vcpu-192gb` | 1 | 32 | 192 | | `1gpu-48vcpu-288gb` | 1 | 48 | 288 | | `2gpu-64vcpu-384gb` | 2 | 64 | 384 | | `2gpu-96vcpu-576gb` | 2 | 96 | 576 | | `4gpu-128vcpu-768gb` | 4 | 128 | 768 | | `4gpu-192vcpu-1152gb` | 4 | 192 | 1152 | ### Presets compatible with GPU clusters If you are adding a VM to a [GPU cluster](https://docs.nebius.com/compute/clusters/gpu/index.md), select from the following platforms and presets: | Platform | Presets | [Regions](https://docs.nebius.com/overview/regions.md) | | ----------------------------------------------------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------ | | NVIDIA® B300 NVLink with Intel Granite Rapids
(`gpu-b300-sxm`) | `8gpu-192vcpu-2768gb` | `uk-south1`, `eu-west2`*\** | | NVIDIA® B200 NVLink with Intel Emerald Rapids
(`gpu-b200-sxm`) | `8gpu-160vcpu-1792gb` | `us-central1` | | NVIDIA® B200 NVLink with Intel Emerald Rapids
(`gpu-b200-sxm-a`) | `8gpu-160vcpu-1792gb` | `me-west1` | | NVIDIA® H200 NVLink with Intel Sapphire Rapids
(`gpu-h200-sxm`) | `8gpu-128vcpu-1600gb` | `eu-north1`, `eu-north2`*\**, `eu-west1`, `us-central1` | | NVIDIA® H100 NVLink with Intel Sapphire Rapids
(`gpu-h100-sxm`) | `8gpu-128vcpu-1600gb` | `eu-north1` | Other presets and platforms are not compatible with GPU clusters. ## Presets for non-GPU platforms * Non-GPU AMD EPYC Genoa (cpu-d3): | Preset name | Number of vCPUs | RAM, GiB | [Regions](https://docs.nebius.com/overview/regions.md) | | ---------------- | --------------- | -------- | ----------------------------------------- | | `4vcpu-16gb` | 4 | 16 | All regions | | `8vcpu-32gb` | 8 | 32 | All regions | | `16vcpu-64gb` | 16 | 64 | All regions | | `32vcpu-128gb` | 32 | 128 | All regions | | `48vcpu-192gb` | 48 | 192 | All regions | | `64vcpu-256gb` | 64 | 256 | All regions | | `96vcpu-384gb` | 96 | 384 | All regions | | `128vcpu-512gb` | 128 | 512 | All regions | | `160vcpu-640gb` | 160 | 640 | All regions except eu-north1 | | `192vcpu-768gb` | 192 | 768 | All regions except eu-north1 | | `224vcpu-896gb` | 224 | 896 | All regions except eu-north1 | | `256vcpu-1024gb` | 256 | 1024 | All regions except eu-north1 | * Non-GPU Intel Ice Lake (cpu-e2), available in eu-north1: | Preset name | Number of vCPUs | RAM, GiB | | -------------- | --------------- | -------- | | `2vcpu-8gb` | 2 | 8 | | `4vcpu-16gb` | 4 | 16 | | `8vcpu-32gb` | 8 | 32 | | `16vcpu-64gb` | 16 | 64 | | `32vcpu-128gb` | 32 | 128 | | `48vcpu-192gb` | 48 | 192 | | `64vcpu-256gb` | 64 | 256 | | `80vcpu-320gb` | 80 | 320 | ## Compatibility with boot disk images Nebius AI Cloud provides boot disk images for GPU and non-GPU VMs. The image that you choose for a VM must be compatible with the VM's platform. For compatibility details, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). ## Compatibility with VM types All platforms support regular VMs. All platforms with GPUs also support [preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md). To get an up-to-date list of platforms, run the `nebius compute platform list` [command](https://docs.nebius.com/cli/reference/compute/platform/list). The platforms available for preemptible VMs are marked as `allowed_for_preemptibles: true`. # How to find out platforms and presets available in a project Source: https://docs.nebius.com/compute/virtual-machines/list-platforms.md Different virtual machine platforms and presets are available for different regions and projects. All supported platforms and presets are listed in [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). ## Prerequisites [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to find out available platforms and presets To find out what platforms and presets are available in a given project: Run the following command: ```bash nebius compute platform list --parent-id ``` In the `--parent-id` parameter, specify the ID of the project for which you want to see the list. ```go platforms, err := sdk.Services().Compute().V1(). Platform().List( ctx, &compute.ListPlatformsRequest{ ParentId: "", }, ) if err != nil { return err } fmt.Println(platforms) ``` In the `ParentId` parameter, specify the ID of the project for which you want to see the list. ```python platform_service = PlatformServiceClient(sdk) platforms = await platform_service.list( ListPlatformsRequest(parent_id=""), ) print(platforms) ``` In the `parent_id` parameter, specify the ID of the project for which you want to see the list. ```ts const platformService = new PlatformService(sdk); const platforms = await platformService.list( ListPlatformsRequest.create({ parentId: "", }), ); console.log(platforms); ``` In the `parentId` parameter, specify the ID of the project for which you want to see the list. # How to create a virtual machine in Nebius AI Cloud Source: https://docs.nebius.com/compute/virtual-machines/manage.md You can create a Compute virtual machine (VM) in the [web console](https://console.nebius.com), or by using the [CLI](https://docs.nebius.com/cli/index.md), [Terraform provider](https://docs.nebius.com/terraform-provider/index.md) or SDKs. You can tailor the VM configuration to your needs and, for example, attach secondary disks and filesystems, or allocate GPU resources to your VM. ## Prerequisites If you use the web console, you don't need to complete any prerequisites. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). The VM that you create this way is a *standalone VM*, which is a general-purpose Compute resource. In the [web console](https://console.nebius.com), standalone VMs are displayed on the **Standalone VMs** tab of the **Virtual machines** page. Other Compute resources, such as [container VMs](https://docs.nebius.com/compute/virtual-machines/containers.md), [Managed Service for Kubernetes®](https://docs.nebius.com/kubernetes/index.md) nodes or [Serverless AI](https://docs.nebius.com/serverless/index.md) job and endpoint VMs, are displayed on separate tabs. A standalone VM can be regular or [preemptible](https://docs.nebius.com/compute/virtual-machines/preemptible.md): regular VMs run until you stop them, while Compute may stop preemptible VMs at any time. ## Steps ### (Optional) Create a user data configuration You do not need to create a user data configuration in advance if you create a VM in the web console. To add a user for connections to a VM, create a configuration by using the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format: ```bash export USER_DATA=$(jq -Rrs '.' < 1. To add a user for connections to a VM, create a configuration by using the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format: ```bash export USER_DATA=$(jq -Rrs '.' < sudo: ALL=(ALL) NOPASSWD:ALL shell: /bin/bash ssh_authorized_keys: - ``` 4. Create the `variables.tf` file with the following contents: ```hcl variable "user_data" { description = "User data in the cloud-init format" type = string } ``` The file allows the Terraform provider to address the `TF_VAR_user_data` environment variable. 5. Initialize the working directory: ```bash terraform init ``` To add a user for connections to a VM, define `userData` as a string in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format. ```go publicKeyBytes, err := os.ReadFile( os.ExpandEnv("$HOME/.ssh/id_ed25519.pub"), ) if err != nil { return err } publicKey := strings.TrimSpace(string(publicKeyBytes)) userData := "#cloud-config\nusers:\n" + " - name: user\n" + " sudo: ALL=(ALL) NOPASSWD:ALL\n" + " shell: /bin/bash\n" + " ssh_authorized_keys:\n" + " - " + publicKey ``` The configuration contains the following parameters: * `name`: Username for connecting to the VM. The example sets `user`; replace it with your username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. To create the key pair, follow the instructions in [Generating SSH keys](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). When you create the VM, pass this string to `InstanceSpec.CloudInitUserData`. The VM applies this configuration on first boot. To add a user for connections to a VM, define `user_data` as a string in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format. ```python public_key = ( Path.home() .joinpath(".ssh/id_ed25519.pub") .read_text() .strip() ) user_data = "\n".join( [ "#cloud-config", "users:", " - name: user", " sudo: ALL=(ALL) NOPASSWD:ALL", " shell: /bin/bash", " ssh_authorized_keys:", f" - {public_key}", ], ) ``` The configuration contains the following parameters: * `name`: Username for connecting to the VM. The example sets `user`; replace it with your username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. To create the key pair, follow the instructions in [Generating SSH keys](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). When you create the VM, pass this string to `InstanceSpec.cloud_init_user_data`. The VM applies this configuration on first boot. To add a user for connections to a VM, define `userData` as a string in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format. ```ts const publicKey = readFileSync( `${process.env.HOME}/.ssh/id_ed25519.pub`, "utf8", ).trim(); const userData = [ "#cloud-config", "users:", " - name: user", " sudo: ALL=(ALL) NOPASSWD:ALL", " shell: /bin/bash", " ssh_authorized_keys:", " - " + publicKey, ].join("\n"); ``` The configuration contains the following parameters: * `name`: Username for connecting to the VM. The example sets `user`; replace it with your username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. To create the key pair, follow the instructions in [Generating SSH keys](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). When you create the VM, pass this string to `InstanceSpec.cloudInitUserData`. The VM applies this configuration on first boot. ### Create a VM 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Click **Create resource** → **Virtual machine**. The creation flow is a step-by-step wizard. The sidebar shows your progress through the configuration sections. To move between sections, click **Back** and **Next**. 3. If you have [capacity block groups](https://docs.nebius.com/overview/limits/capacity-block-groups.md), on the **General** step, choose how Compute allocates resources: * **Reserved VM**: Capacity is assured by your capacity block groups. This option is for regular VMs with GPUs. If you have active capacity block groups, the card shows how many are available. * **Pay-as-you-go VM**: Capacity is subject to availability. This option allows [preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md) and VMs without GPUs. If you do not have capacity block groups, the wizard skips the **General** step and opens **Compute** instead. 4. On the **Compute** step, configure computing resources: **Reserved VM:** 1. In the **Platform** section, select a [platform](https://docs.nebius.com/compute/virtual-machines/types.md). The list shows platforms that match your capacity block groups. Each platform card shows GPU memory, the platform ID and badges for associated capacity block groups. 2. In the **Reservation** section, configure how Compute uses your [reservations](https://docs.nebius.com/compute/virtual-machines/reservations.md). The **Reservation** section is only displayed if you have capacity block groups. 1. If you have capacity block groups in multiple regions, select a **Region**. 2. To let Compute choose among your capacity block groups automatically, select **Any (existing and future)**. 3. To use specific capacity block groups, select them. Each option shows the capacity block group ID, reservation period and GPU usage. 4. Under **Switch to PAYG**, choose whether the VM can start after you create or restart it without active intervals in selected capacity block groups: * **When reservation is exhausted**: The VM can start as a pay-as-you-go VM when no capacity is available in the selected capacity block groups. * **Never**: The VM cannot start without available capacity in the selected capacity block groups. This does not affect the VM when it is running. If an interval in a selected capacity block group expires while the VM is running, the VM always continues as a pay-as-you-go VM, regardless of this setting. 3. In the **Settings** section, configure the following: 1. Select a **Preset**. 2. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a **GPU cluster** for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. To use a GPU cluster, select an existing one or create a new cluster: 1. Click **Create** in the **GPU cluster** field. 2. In the window that opens, specify the cluster name and InfiniBand fabric. To select the fabric, see [InfiniBand fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. Click **Create**. 3. Select the **Project** for the VM location. 4. Specify the **VM name**. **Pay-as-you-go VM:** 1. At the top of the platform list, select **With GPUs** or **Without GPUs** and the VM type **Regular** or [Preemptible](https://docs.nebius.com/compute/virtual-machines/preemptible.md). VMs without GPUs only support the regular type. 2. Select a [platform and preset](https://docs.nebius.com/compute/virtual-machines/types.md). Expand a platform card to compare available presets by region. You can also see the platforms that are not currently available. 3. In the **Settings** section, configure the following: 1. Select a **Preset**. 2. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a **GPU cluster** for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. To use a GPU cluster, select an existing one or create a new cluster: 1. Click **Create** in the **GPU cluster** field. 2. In the window that opens, specify the cluster name and InfiniBand fabric. To select the fabric, see [InfiniBand fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. Click **Create**. 3. Select the **Project** for the VM location. 4. Specify the **VM name**. To check GPU availability across regions and presets before you create a VM, use the [capacity advisor](https://docs.nebius.com/compute/virtual-machines/capacity-advisor.md). 5. On the **Storage** step, configure disks and filesystems: 1. In the **Boot disk** section, set the boot disk settings: 1. Click on the boot disk card. 2. In the window that opens, select an existing disk or create a new one. 3. If you create a new boot disk, choose an operating system image: either a [public image](https://docs.nebius.com/compute/storage/boot-disk-images.md) provided by Nebius or a [custom image or image family](https://docs.nebius.com/compute/storage/custom-disk-images.md) that you created yourself. Also, configure the type, encryption, size and block size. For more information about these settings, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). 2. (Optional) If you want to attach an additional disk to your VM, in the **Additional disks** section: 1. Click **Attach disk**. 2. In the window that opens, select an existing secondary disk or create a new one. 3. If you create a new disk, specify its name and configure the type, encryption, size and block size. 4. Click **Attach disk**. After you create the VM, [mount the additional disks](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks. 3. (Optional) If the selected platform supports local SSD disks, enable **Local SSD disks** to add ephemeral local storage. Local SSD disks are available only for supported platforms and presets. For details, see [Availability](https://docs.nebius.com/compute/storage/local-disks.md#availability). 4. (Optional) If you want to attach a filesystem to your VM, in the **Shared filesystems** section: 1. Click **Attach shared filesystem**. 2. In the window that opens, select an existing filesystem or create a new one. 3. If you create a new filesystem, specify its name, size and the block size. 4. Click **Attach filesystem**. 5. After the window is closed, specify a mount tag for mounting the filesystem to the VM. Create your own tag, such as `my-filesystem`. Make sure that it is unique within the VM. 6. To mount the filesystem to the VM automatically, keep the **Auto mount** option enabled. 6. On the **Network** step, attach the VM to a [network and subnet](https://docs.nebius.com/vpc/overview.md): 1. Select the **Network** and **Subnet**. 2. In the **Primary private IP address** field, select whether to automatically assign a private IP address or select an already allocated one. For more information, see [Private IP addresses](https://docs.nebius.com/compute/virtual-machines/network.md#private-ip-addresses). 3. (Optional) In the **Secondary private IP address** field, assign secondary addresses. Use them as a backup option in case of incidents. For example, a backup node can take a secondary address of the main node when the main one fails. As a result, routing to this address can be preserved. After you click **Add IP address**, you can specify a new address or select an already created allocation. You can assign no more than five secondary addresses. 4. In the **Public IP address** field, specify whether the VM should have a public address and whether this address should be dynamic, static or taken from an allocation. If you need to secure your VM and make it isolated, you can create a VM without a public IP address. If you need to connect to this VM from the internet, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md). It has an IP address in the internet and an IP address in the VM's network. As a result, you can access the VM via the jump server from the internet. This approach enhances security and still provides access to the VM. For more information, see [How to enable a public IP address for a VM](https://docs.nebius.com/compute/virtual-machines/network.md#how-to-enable-a-public-ip-address-for-a-vm). 5. In the **Hostname** field, specify whether to use the VM ID or a custom hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md): * **Same as VM ID**: The default FQDN uses the VM ID. * **Custom**: Specify your own hostname. 7. On the **Configuration** step, configure access, identity and VM startup settings: 1. In the **Access** section, add credentials so you can [connect to the VM](https://docs.nebius.com/compute/virtual-machines/connect.md): 1. Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). 2. In the **Username and SSH key** field, click **Create**. 3. In the window that opens, specify the username of the VM user, a public key of your SSH key pair and the credentials name to recognize the key in the list. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. 4. Click **Add credentials**. 2. (Optional) In the **Additional** section, select an existing service account or click **Create** to add a new one. The service account will perform actions on behalf of the VM, for example, run scripts. 3. (Optional) In the **User data** section, select **Enable custom cloud-init config** and set a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format. This configuration affects the settings for shared filesystems and access that you set up earlier: * If you add a cloud-init configuration, you cannot manage the **Auto mount** option for filesystems. Their mounting settings automatically appear in the configuration. * The username and SSH key that you specify on the **Configuration** step are automatically added to a cloud-init configuration if you enable it. Ultimately, the settings from the configuration apply, not those from the **Configuration** step. The default configuration that only adds the user contains the following parameters: * `name`: Username for connecting to the VM. The above example sets the value of your machine's `USER` environment variable as the username for the VM. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). 8. On the **Review** step, check the full VM configuration. To change a section quickly, click next to the corresponding block. The wizard opens the relevant step with your current settings. 9. Click **Create VM**. 1. (Optional) If you want to attach a filesystem to your VM, create this filesystem: ```bash nebius compute filesystem create \ --name \ --size-gibibytes 10 \ --type network_ssd \ --block-size-bytes 4096 ``` Save the filesystem ID from the output `metadata.id` parameter. For more information about filesystem creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). You don't need to create disks for the VM in advance. You can create them along with the VM. Such disks are called [VM-managed](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). They are tied to the VM lifecycle. 2. (Optional) To provide the VM with an [allocation](https://docs.nebius.com/vpc/overview.md#allocation) that reserves a static public IP address, create this allocation. As a result, the address is preserved even if you delete the VM. 1. [Get the required subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id). 2. Run the following command: ```bash nebius vpc allocation create \ --ipv4-public-subnet-id \ --name ``` Save the allocation ID from the output `metadata.id` parameter. For more information about networking in Compute, see [Public IP addresses](https://docs.nebius.com/compute/virtual-machines/network.md#public-ip-addresses). 3. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a GPU cluster for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. To create a GPU cluster, run the following command: ```bash nebius compute gpu-cluster create \ --name \ --infiniband-fabric ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). Save the cluster ID from the output `metadata.id` parameter. 4. (Optional) Create a [service account](https://docs.nebius.com/iam/service-accounts/manage.md) that will perform actions on behalf of the VM: ```bash nebius iam service-account create --name ``` 5. Create the VM: ```bash nebius compute instance create \ --name \ --stopped \ --resources-platform \ --resources-preset \ --boot-disk-managed-disk-name \ --boot-disk-managed-disk-type \ --boot-disk-managed-disk-size-gibibytes \ --boot-disk-managed-disk-source-image-family-image-family \ --boot-disk-attach-mode READ_WRITE \ --boot-disk-device-id \ --secondary-disks '[{"attach_mode": "READ_WRITE", "device_id": "", "managed_disk": { "name": "", "spec": { "type": "", "size_gibibytes": 10 }}}]' \ --filesystems '[{"existing_filesystem": {"id": ""}, "attach_mode": "READ_WRITE", "mount_tag": ""}]' \ --cloud-init-user-data "$USER_DATA" \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {"allocation_id": ""}, "subnet_id": ""}]' \ --gpu-cluster-id \ --hostname \ --reservation-policy-policy \ --reservation-policy-reservation-ids \ --recovery-policy \ --preemptible-on-preemption stop \ --service-account-id ``` The command contains the following parameters: * `--name`: VM's name. * `--stopped` (optional): If you want to create a VM but not launch it, specify the `false` value. The VM will remain in the `Stopped` status. For more information, see [Lifecycle of a Compute virtual machine](https://docs.nebius.com/compute/virtual-machines/lifecycle.md). * `--resources-platform`: [VM platform](https://docs.nebius.com/compute/virtual-machines/types.md). * `--resources-preset`: VM preset. Depends on the chosen platform. * `--boot-disk-managed-disk-name`: Name of the [VM-managed boot disk](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks) that you create along with the VM. * `--boot-disk-managed-disk-type`: [Disk type](https://docs.nebius.com/compute/storage/types.md#network-ssd-disks). * `--boot-disk-managed-disk-size-gibibytes`: Disk size in gibibytes. Maximum boot disk size is 30,720 GiB (30 TiB). * `--boot-disk-managed-disk-source-image-family-image-family`: Public image that Nebius AI Cloud supports. For the list of available public images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). * `--boot-disk-attach-mode`: Write permission of the boot disk, `READ_ONLY` or `READ_WRITE`. * `--boot-disk-device-id` (optional): User-defined ID for mounting the boot disk to the VM. The default value is `disk-n` where `n` is an integer index. A `virtio-` prefix is added to the specified (or default) device ID. * `--secondary-disks` (optional): Settings of additional VM-managed disks that you create along with the VM. You can attach one or several disks. * `attach_mode`: Write permission of the additional disk, `READ_ONLY` or `READ_WRITE`. * `device_id`: User-defined ID for mounting the disk to the VM. * `managed_disk.name`: Name of a new disk. * `managed_disk.spec.type`: Disk type. * `managed_disk.spec.size_gibibytes`: Disk size in gibibytes. * `--filesystems` (optional): Filesystem settings. You can attach several filesystems, if required. * `id`: ID of the filesystem created earlier. * `attach_mode`: Write permission of the filesystem, `READ_ONLY` or `READ_WRITE`. * `mount_tag`: Tag for mounting the filesystem to the VM. Create your own tag, such as `my-filesystem`. Make sure that it is unique within the VM. If you do not specify the tag, it takes the `filesystem-N` default value where `N` is an integer. For example, `filesystem-0`. After you create the VM, [mount the additional disks and filesystems](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these volumes. * `--cloud-init-user-data` (optional): Configuration of VM users in the [cloud-init](https://cloud-init.io/) format. * `--network-interfaces`: Network settings. * To assign a dynamic public IP address, specify `"public_ip_address": {}`. A dynamic public IP address is randomly allocated from the [IPv4 public range](https://docs.nebius.com/compute/virtual-machines/manage.md#get-public-ip-range) of Nebius AI Cloud and is not persistent. If a VM with a dynamic address has the `Stopped` status for more than one hour, the address is automatically returned to the IPv4 public range. After that, Compute may allocate this address to a different VM. * To assign a static public IP address, specify `"public_ip_address": {"static": true}`. A static public IP address is also randomly allocated from the IPv4 public range of Nebius AI Cloud. If you stop a VM that has a static IP address, the address will not return to the range. However, if you delete this VM, the address will return. * To assign the allocation created earlier, specify `"public_ip_address": {"allocation_id": ""}`. An allocation allows you to use a reserved static public address for the VM. This address will not return to the IPv4 range even if you delete the VM. * To create a VM without a public IP address, remove the `public_ip_address` parameter from the JSON. The VM will only have a private address. If you need to secure your VM and make it isolated, you can create a VM without a public IP address. If you need to connect to this VM from the internet, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md). It has an IP address in the internet and an IP address in the VM's network. As a result, you can access the VM via the jump server from the internet. This approach enhances security and still provides access to the VM. * `--gpu-cluster-id` (optional): ID of the GPU cluster created earlier. * `--local-disks-passthrough-group-requested` (optional): Requests local SSD disks to be added to the VM when set to `true`. Local SSD disks are available only for supported platforms and presets. For details, see [Availability](https://docs.nebius.com/compute/storage/local-disks.md#availability). * `--hostname` (optional): Hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md). By default, the FQDN has the `..compute.internal.` format. If you want to customize it, use a hostname instead of the VM's ID in the FQDN. For example, if you specify `--hostname my-host`, the FQDN is `my-host.vpcnetwork-e00***.compute.internal.`. * `--reservation-policy-policy` (optional): Policy for reservation usage. You can use [reservations of capacity resources](https://docs.nebius.com/compute/virtual-machines/reservations.md) and run your VM based on them. As a result, the VM resources are reserved and always available. * `--reservation-policy-reservation-ids` (optional): IDs of specific reservations. These are capacity block groups that a Nebius manager has created. For information about how to configure `--reservation-policy-policy` and `--reservation-policy-reservation-ids`, see [How to add reservations to VMs](https://docs.nebius.com/compute/virtual-machines/reservations.md#how-to-add-reservations-to-vms). * `--recovery-policy` (optional): Defines what Compute does with the VM after it is preempted or fails. [Preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md) only support the `fail` value that stops the VM. They do not support the `recover` value that tries to restart the VM. If you set `recover` for a preemptible VM, it will cause an error. * `--preemptible-on-preemption` (optional; for preemptible VMs only): Specifies what happens when the VM is preempted. The only supported value is `stop`: Compute stops the VM without deleting or restarting it. * `--service-account-id` (optional): Service account associated with the VM. 1. (Optional) If you want to attach a filesystem to your VM, create this filesystem: ```hcl resource "nebius_compute_v1_filesystem" "my_filesystem" { name = "" parent_id = "" size_gibibytes = 10 type = "NETWORK_SSD" block_size_bytes = 4096 } ``` For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). You don't need to create disks for the VM in advance. You can create them along with the VM. Such disks are called [VM-managed](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). They are tied to the VM lifecycle. 2. (Optional) To provide the VM with an [allocation](https://docs.nebius.com/vpc/overview.md#allocation) that reserves a static public IP address, create this allocation. As a result, the address is preserved even if you delete the VM. ```hcl resource "nebius_vpc_v1_allocation" "my_allocation" { name = "" parent_id = "" ipv4_public = { subnet_id = "" } } ``` To create the allocation, [get the required subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id). For more information about networking in Compute, see [Public IP addresses](https://docs.nebius.com/compute/virtual-machines/network.md#public-ip-addresses). 3. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a GPU cluster for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. To create a GPU cluster, use the following configuration: ```hcl resource "nebius_compute_v1_gpu_cluster" "my_gpu_cluster" { name = "" parent_id = "" infiniband_fabric = "" } ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 4. (Optional) Create a [service account](https://docs.nebius.com/iam/service-accounts/manage.md) that will perform actions on behalf of the VM: ```hcl resource "nebius_iam_v1_service_account" "my_sa" { name = "" parent_id = "" } ``` 5. (Optional) If your `resources` block uses a platform and preset that support local SSD disks, add a `local_disks` block to the `nebius_compute_v1_instance` resource in the next step. The local SSD disks are provisioned as raw Non-Volatile Memory Express (NVMe) devices (`nvme0`, `nvme1`, and so on). You can enable local SSD disks only when you create the VM. For more information, see [Availability](https://docs.nebius.com/compute/storage/local-disks.md#availability). For example: ```hcl resource "nebius_compute_v1_instance" "my_vm" { # ... local_disks = { passthrough_group = { requested = true } } } ``` 6. Create the VM: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" stopped = resources = { platform = "" preset = "" } boot_disk = { managed_disk = { name = "" spec = { type = "" size_gibibytes = source_image_family = { image_family = "" } } } attach_mode = "" device_id = "" } secondary_disks = [ { managed_disk = { name = "" spec = { type = "" size_gibibytes = } } attach_mode = "" device_id = "" } ] filesystems = [ { existing_filesystem = { id = nebius_compute_v1_filesystem.my_filesystem.id } attach_mode = "" mount_tag = "" } ] cloud_init_user_data = var.user_data network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = { allocation_id = nebius_vpc_v1_allocation.my_allocation.id } subnet_id = "" } ] gpu_cluster = { id = nebius_compute_v1_gpu_cluster.my_gpu_cluster.id } hostname = "" reservation_policy = { policy = "" reservation_ids = "" } recovery_policy = "" preemptible = { on_preemption = "STOP" } service_account_id = nebius_iam_v1_service_account.my_sa.id } ``` The configuration contains the following parameters: * `name`: VM's name. * `stopped` (optional): If you want to create a VM but not launch it, specify the `false` value. The VM will remain in the `Stopped` status. For more information, see [Lifecycle of a Compute virtual machine](https://docs.nebius.com/compute/virtual-machines/lifecycle.md). * `resources.platform`: [VM platform](https://docs.nebius.com/compute/virtual-machines/types.md). * `resources.preset`: VM preset. Depends on the chosen platform. * `boot_disk`: Settings of a [VM-managed boot disk](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks) that you create along with the VM. * `managed_disk.name`: Name of the disk. * `managed_disk.spec.type`: [Disk type](https://docs.nebius.com/compute/storage/types.md#network-ssd-disks). * `managed_disk.spec.size_gibibytes`: Disk size in gibibytes. Maximum boot disk size is 30,720 GiB (30 TiB). * `managed_disk.spec.source_image_family.image_family`: Public image that Nebius AI Cloud supports. For the list of available public images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). * `attach_mode`: Write permission of the boot disk, `READ_ONLY` or `READ_WRITE`. * `device_id` (optional): User-defined ID for mounting the disk to the VM. The default value is `disk-n`, where `n` is an integer index. A `virtio-` prefix is added to the specified (or default) device ID. * `secondary_disks` (optional): Settings of additional VM-managed disks that you create along with the VM. You can attach one or several disks. * `managed_disk.name`: Name of a new disk. * `managed_disk.spec.type`: Disk type. * `managed_disk.spec.size_gibibytes`: Disk size in gibibytes. * `attach_mode`: Write permission of the additional disk, `READ_ONLY` or `READ_WRITE`. * `device_id`: User-defined ID for mounting the disk to the VM. * `filesystems` (optional): Filesystem settings. You can attach several filesystems, if required. * `existing_filesystem.id`: ID of the filesystem created earlier. * `attach_mode`: Write permission of the filesystem, `READ_ONLY` or `READ_WRITE`. * `mount_tag`: Tag for mounting the filesystem to the VM. Create your own tag, such as `my-filesystem`. Make sure that it is unique within the VM. If you do not specify the tag, it takes the `filesystem-N` default value where `N` is an integer. For example, `filesystem-0`. After you create the VM, [mount the additional disks and filesystems](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these volumes. * `cloud_init_user_data` (optional): Configuration of VM users in the [cloud-init](https://cloud-init.io/) format. * `network_interfaces`: Network settings. * To assign a dynamic public IP address, specify `public_ip_address = {}`. A dynamic public IP address is randomly allocated from the [IPv4 public range](https://docs.nebius.com/compute/virtual-machines/manage.md#get-public-ip-range) of Nebius AI Cloud and is not persistent. If a VM with a dynamic address has the `Stopped` status for more than one hour, the address is automatically returned to the IPv4 public range. After that, Compute may allocate this address to a different VM. * To assign a static public IP address, specify `public_ip_address = {static = true}`. A static public IP address is also randomly allocated from the IPv4 public range of Nebius AI Cloud. If you stop a VM that has a static IP address, the address will not return to the range. However, if you delete this VM, the address will return. * To assign the allocation created earlier, specify `public_ip_address = {allocation_id = nebius_vpc_v1_allocation.my_allocation.id}`. An allocation allows you to use a reserved static public address for the VM. This address will not return to the IPv4 range even if you delete the VM. * To create a VM without a public IP address, remove the `public_ip_address` parameter from the configuration. The VM will only have a private address. If you need to secure your VM and make it isolated, you can create a VM without a public IP address. If you need to connect to this VM from the internet, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md). It has an IP address in the internet and an IP address in the VM's network. As a result, you can access the VM via the jump server from the internet. This approach enhances security and still provides access to the VM. * `gpu_cluster.id` (optional): ID of the GPU cluster created earlier. * `local_disks` (optional): Set `passthrough_group.requested = true` to request local SSD disks to be added to the VM. Local SSD disks are available only for supported platforms and presets. For details, see [Availability](https://docs.nebius.com/compute/storage/local-disks.md#availability). * `hostname` (optional): Hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md). By default, the FQDN has the `..compute.internal.` format. If you want to customize it, use a hostname instead of the VM's ID in the FQDN. For example, if you specify `hostname = "my-host"`, the FQDN is `my-host.vpcnetwork-e00***.compute.internal.`. * `reservation_policy.policy` (optional): Policy for reservation usage. You can use [reservations of capacity resources](https://docs.nebius.com/compute/virtual-machines/reservations.md) and run your VM based on them. As a result, VM resources are reserved and always available. * `reservation_policy.reservation_ids` (optional): IDs of specific reservations. These are capacity block groups that a Nebius manager has created. For information about how to configure `reservation_policy.policy` and `reservation_policy.reservation_ids`, see [How to add reservations to VMs](https://docs.nebius.com/compute/virtual-machines/reservations.md#how-to-add-reservations-to-vms). * `recovery_policy` (optional): Defines what Compute does with the VM after it is preempted or fails. [Preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md) only support the `FAIL` value that stops the VM. They do not support the `RECOVER` value that tries to restart the VM. If you set `RECOVER` for a preemptible VM, it will cause an error. * `preemptible.on_preemption` (optional; for preemptible VMs only): Specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. * `service_account_id` (optional): Service account associated with the VM. 7. Check that the configuration is correct: ```bash terraform validate ``` 8. Apply the changes: ```bash terraform apply ``` 1. (Optional) If you want to attach a filesystem to your VM, create this filesystem: ```go filesystemOperation, err := sdk.Services().Compute().V1(). Filesystem().Create( ctx, &compute.CreateFilesystemRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.FilesystemSpec{ Size: &compute.FilesystemSpec_SizeGibibytes{ SizeGibibytes: 10, }, BlockSizeBytes: 4096, Type: compute.FilesystemSpec_NETWORK_SSD, }, }, ) if err != nil { return err } if _, err = filesystemOperation.Wait(ctx); err != nil { return err } ``` For more information about filesystem creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). You don't need to create disks for the VM in advance. You can create them along with the VM. Such disks are called [VM-managed](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). They are tied to the VM lifecycle. 2. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a GPU cluster for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. Create a GPU cluster: ```go gpuClusterOperation, err := sdk.Services().Compute().V1(). GpuCluster().Create( ctx, &compute.CreateGpuClusterRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.GpuClusterSpec{ InfinibandFabric: "", }, }, ) if err != nil { return err } if _, err = gpuClusterOperation.Wait(ctx); err != nil { return err } ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. (Optional) Create a [service account](https://docs.nebius.com/iam/service-accounts/manage.md) that will perform actions on behalf of the VM: ```go serviceAccountOperation, err := sdk.Services().IAM().V1(). ServiceAccount().Create( ctx, &iam.CreateServiceAccountRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &iam.ServiceAccountSpec{}, }, ) if err != nil { return err } if _, err = serviceAccountOperation.Wait(ctx); err != nil { return err } serviceAccountID := serviceAccountOperation.ResourceID() ``` 4. Create the VM: ```go managedBootDisk := &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, DeviceId: "", Type: &compute.AttachedDiskSpec_ManagedDisk{ ManagedDisk: &compute.ManagedDisk{ Name: "", Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: , }, Type: compute.DiskSpec_NETWORK_SSD, Source: &compute.DiskSpec_SourceImageFamily{ SourceImageFamily: &compute.SourceImageFamily{ ImageFamily: "", }, }, }, }, }, } managedSecondaryDisk := &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, DeviceId: "device-2", Type: &compute.AttachedDiskSpec_ManagedDisk{ ManagedDisk: &compute.ManagedDisk{ Name: "managed-secondary-disk", Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: 10, }, Type: compute.DiskSpec_NETWORK_SSD, }, }, }, } managedFilesystem := &compute.AttachedFilesystemSpec{ AttachMode: compute.AttachedFilesystemSpec_READ_WRITE, MountTag: "", Type: &compute.AttachedFilesystemSpec_ExistingFilesystem{ ExistingFilesystem: &compute.ExistingFilesystem{ Id: filesystemID, }, }, } managedNetwork := &compute.NetworkInterfaceSpec{ Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } managedVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ ServiceAccountId: serviceAccountID, Stopped: , Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_Preset{ Preset: "", }, }, GpuCluster: &compute.InstanceGpuClusterSpec{ Id: gpuClusterID, }, BootDisk: managedBootDisk, SecondaryDisks: []*compute.AttachedDiskSpec{ managedSecondaryDisk, }, Filesystems: []*compute.AttachedFilesystemSpec{ managedFilesystem, }, CloudInitUserData: userData, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ managedNetwork, }, Hostname: "", ReservationPolicy: &compute.ReservationPolicy{ Policy: compute.ReservationPolicy_FORBID, }, RecoveryPolicy: compute.InstanceRecoveryPolicy_FAIL, Preemptible: &compute.PreemptibleSpec{ OnPreemption: compute.PreemptibleSpec_STOP, }, }, }, ) if err != nil { return err } if _, err = managedVMOperation.Wait(ctx); err != nil { return err } ``` The code contains the following parameters: * `Metadata.Name`: VM's name. * `Spec.ServiceAccountId` (optional): Service account associated with the VM. * `Spec.Stopped` (optional): If you want to create a VM but not launch it, specify the `true` value. The VM will remain in the `Stopped` status. * `Spec.Resources.Platform`: [VM platform](https://docs.nebius.com/compute/virtual-machines/types.md). * `Spec.Resources.Size.Preset`: VM preset. Depends on the chosen platform. * `Spec.GpuCluster.Id` (optional): ID of the GPU cluster created earlier. * `managedBootDisk.AttachMode`: Write permission of the boot disk, `READ_ONLY` or `READ_WRITE`. * `managedBootDisk.DeviceId` (optional): User-defined ID for mounting the boot disk to the VM. The default value is `disk-n` where `n` is an integer index. A `virtio-` prefix is added to the specified (or default) device ID. * `managedBootDisk.ManagedDisk.Name`: Name of the [VM-managed boot disk](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks) that you create along with the VM. * `managedBootDisk.ManagedDisk.Spec.SizeGibibytes`: Disk size in gibibytes. Maximum boot disk size is 30,720 GiB (30 TiB). * `managedBootDisk.ManagedDisk.Spec.Type`: [Disk type](https://docs.nebius.com/compute/storage/types.md#network-ssd-disks). * `managedBootDisk.ManagedDisk.Spec.SourceImageFamily.ImageFamily`: Public image that Nebius AI Cloud supports. For the list of available public images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). * `managedSecondaryDisk.AttachMode`: Write permission of the additional disk, `READ_ONLY` or `READ_WRITE`. * `managedSecondaryDisk.DeviceId`: User-defined ID for mounting the additional disk to the VM. * `managedSecondaryDisk.ManagedDisk.Name`: Name of a new additional VM-managed disk. * `managedSecondaryDisk.ManagedDisk.Spec.SizeGibibytes`: Size of the additional disk in gibibytes. * `managedSecondaryDisk.ManagedDisk.Spec.Type`: Disk type of the additional disk. * `managedFilesystem.AttachMode`: Write permission of the filesystem, `READ_ONLY` or `READ_WRITE`. * `managedFilesystem.MountTag`: Tag for mounting the filesystem to the VM. * `managedFilesystem.ExistingFilesystem.Id`: ID of the filesystem created earlier. * `Spec.CloudInitUserData` (optional): Configuration of VM users in the [cloud-init](https://cloud-init.io/) format. * `managedNetwork.SubnetId`: ID of the subnet to attach the VM to. * `managedNetwork.IpAddress`: Private IP address settings. * `managedNetwork.PublicIpAddress`: Public IP address settings. In the example, an empty `PublicIPAddress` assigns a dynamic public IP address. * `Spec.Hostname` (optional): Hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md). By default, the FQDN has the `..compute.internal.` format. * `Spec.ReservationPolicy.Policy` (optional): Policy for reservation usage. You can use [reservations of capacity resources](https://docs.nebius.com/compute/virtual-machines/reservations.md) and run your VM based on them. * `Spec.RecoveryPolicy` (optional): Defines what Compute does with the VM after it is preempted or fails. * `Spec.Preemptible.OnPreemption` (optional; for preemptible VMs only): Specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. 1. (Optional) If you want to attach a filesystem to your VM, create this filesystem: ```python filesystem_service = FilesystemServiceClient(sdk) filesystem_operation = await filesystem_service.create( CreateFilesystemRequest( metadata=ResourceMetadata(name=""), spec=FilesystemSpec( block_size_bytes=4096, type=FilesystemSpec.FilesystemType.NETWORK_SSD, size_gibibytes=10, ), ), ) await filesystem_operation.wait() ``` For more information about filesystem creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). You don't need to create disks for the VM in advance. You can create them along with the VM. Such disks are called [VM-managed](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). They are tied to the VM lifecycle. 2. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a GPU cluster for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. Create a GPU cluster: ```python gpu_cluster_service = GpuClusterServiceClient(sdk) gpu_cluster_operation = await gpu_cluster_service.create( CreateGpuClusterRequest( metadata=ResourceMetadata( name="", ), spec=GpuClusterSpec( infiniband_fabric="", ), ), ) await gpu_cluster_operation.wait() ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. (Optional) Create a [service account](https://docs.nebius.com/iam/service-accounts/manage.md) that will perform actions on behalf of the VM: ```python service_account_service = ServiceAccountServiceClient(sdk) service_account_operation = await service_account_service.create( CreateServiceAccountRequest( metadata=ResourceMetadata( name="", ), spec=ServiceAccountSpec(), ), ) await service_account_operation.wait() service_account_id = service_account_operation.resource_id ``` 4. Create the VM: ```python instance_service = InstanceServiceClient(sdk) managed_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( service_account_id=service_account_id, stopped=, resources=ResourcesSpec( platform="", preset="", ), gpu_cluster=InstanceGpuClusterSpec( id=gpu_cluster_id, ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="", spec=DiskSpec( type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=( SourceImageFamily( image_family="", ) ), size_gibibytes=, ), ), device_id="", ), secondary_disks=[ AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-secondary-disk", spec=DiskSpec( type=( DiskSpec.DiskType.NETWORK_SSD ), size_gibibytes=10, ), ), device_id="device-2", ), ], filesystems=[ AttachedFilesystemSpec( attach_mode=( AttachedFilesystemSpec.AttachMode.READ_WRITE ), existing_filesystem=ExistingFilesystem( id=filesystem_id, ), mount_tag="", ), ], cloud_init_user_data=user_data, network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], hostname="", reservation_policy=ReservationPolicy( policy=ReservationPolicy.Policy.FORBID, ), recovery_policy=InstanceRecoveryPolicy.FAIL, preemptible=PreemptibleSpec( on_preemption=( PreemptibleSpec.PreemptionPolicy.STOP ), ), ), ), ) await managed_vm_operation.wait() ``` The code contains the following parameters: * `metadata.name`: VM's name. * `spec.service_account_id` (optional): Service account associated with the VM. * `spec.stopped` (optional): If you want to create a VM but not launch it, specify the `True` value. The VM will remain in the `Stopped` status. * `spec.resources.platform`: [VM platform](https://docs.nebius.com/compute/virtual-machines/types.md). * `spec.resources.preset`: VM preset. Depends on the chosen platform. * `spec.gpu_cluster.id` (optional): ID of the GPU cluster created earlier. * `spec.boot_disk.attach_mode`: Write permission of the boot disk, `READ_ONLY` or `READ_WRITE`. * `spec.boot_disk.managed_disk.name`: Name of the [VM-managed boot disk](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks) that you create along with the VM. * `spec.boot_disk.managed_disk.spec.type`: [Disk type](https://docs.nebius.com/compute/storage/types.md#network-ssd-disks). * `spec.boot_disk.managed_disk.spec.source_image_family.image_family`: Public image that Nebius AI Cloud supports. For the list of available public images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). * `spec.boot_disk.managed_disk.spec.size_gibibytes`: Disk size in gibibytes. Maximum boot disk size is 30,720 GiB (30 TiB). * `spec.boot_disk.device_id` (optional): User-defined ID for mounting the boot disk to the VM. The default value is `disk-n` where `n` is an integer index. A `virtio-` prefix is added to the specified (or default) device ID. * `spec.secondary_disks[].attach_mode`: Write permission of the additional disk, `READ_ONLY` or `READ_WRITE`. * `spec.secondary_disks[].managed_disk.name`: Name of a new additional VM-managed disk. * `spec.secondary_disks[].managed_disk.spec.type`: Disk type of the additional disk. * `spec.secondary_disks[].managed_disk.spec.size_gibibytes`: Size of the additional disk in gibibytes. * `spec.secondary_disks[].device_id`: User-defined ID for mounting the additional disk to the VM. * `spec.filesystems[].attach_mode`: Write permission of the filesystem, `READ_ONLY` or `READ_WRITE`. * `spec.filesystems[].existing_filesystem.id`: ID of the filesystem created earlier. * `spec.filesystems[].mount_tag`: Tag for mounting the filesystem to the VM. * `spec.cloud_init_user_data` (optional): Configuration of VM users in the [cloud-init](https://cloud-init.io/) format. * `spec.network_interfaces[].subnet_id`: ID of the subnet to attach the VM to. * `spec.network_interfaces[].ip_address`: Private IP address settings. * `spec.network_interfaces[].public_ip_address`: Public IP address settings. In the example, an empty `PublicIPAddress` assigns a dynamic public IP address. * `spec.hostname` (optional): Hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md). By default, the FQDN has the `..compute.internal.` format. * `spec.reservation_policy.policy` (optional): Policy for reservation usage. You can use [reservations of capacity resources](https://docs.nebius.com/compute/virtual-machines/reservations.md) and run your VM based on them. * `spec.recovery_policy` (optional): Defines what Compute does with the VM after it is preempted or fails. * `spec.preemptible.on_preemption` (optional; for preemptible VMs only): Specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. 1. (Optional) If you want to attach a filesystem to your VM, create this filesystem: ```ts const filesystemCreateService = new FilesystemService(sdk); const filesystemOperation = await filesystemCreateService.create( CreateFilesystemRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: FilesystemSpec.create({ blockSizeBytes: 4096, type: FilesystemSpec_FilesystemType.NETWORK_SSD, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), ).result; await filesystemOperation.wait(); ``` For more information about filesystem creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). You don't need to create disks for the VM in advance. You can create them along with the VM. Such disks are called [VM-managed](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). They are tied to the VM lifecycle. 2. (Optional) If you create a VM with 8 GPUs (for example, for training models), use a GPU cluster for the VM. InfiniBand™ in the cluster allows you to accelerate tasks that require high-performance computing (HPC) power. A single VM without InfiniBand™ cannot perform these tasks as quickly. Create a GPU cluster: ```ts const gpuClusterCreateService = new GpuClusterService(sdk); const gpuClusterOperation = await gpuClusterCreateService.create( CreateGpuClusterRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: GpuClusterSpec.create({ infinibandFabric: "", }), }), ).result; await gpuClusterOperation.wait(); ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. (Optional) Create a [service account](https://docs.nebius.com/iam/service-accounts/manage.md) that will perform actions on behalf of the VM: ```ts const serviceAccountCreateService = new ServiceAccountService(sdk); const serviceAccountOperation = await serviceAccountCreateService.create( CreateServiceAccountRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: ServiceAccountSpec.create({}), }), ).result; await serviceAccountOperation.wait(); const serviceAccountId = serviceAccountOperation.resourceId(); ``` 4. Create the VM: ```ts const managedVmService = new InstanceService(sdk); const managedVmOperation = await managedVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ serviceAccountId, stopped: , resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), gpuCluster: InstanceGpuClusterSpec.create({ id: gpuClusterId, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, deviceId: "", type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: , }, }), }), }, }), secondaryDisks: [ AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, deviceId: "device-2", type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-secondary-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), }, }), ], filesystems: [ AttachedFilesystemSpec.create({ attachMode: AttachedFilesystemSpec_AttachMode.READ_WRITE, mountTag: "", type: { $case: "existingFilesystem", existingFilesystem: ExistingFilesystem.create({ id: filesystemId, }), }, }), ], cloudInitUserData: userData, networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], hostname: "", reservationPolicy: ReservationPolicy.create({ policy: ReservationPolicy_Policy.FORBID, }), recoveryPolicy: InstanceRecoveryPolicy.FAIL, preemptible: PreemptibleSpec.create({ onPreemption: PreemptibleSpec_PreemptionPolicy.STOP, }), }), }), ).result; await managedVmOperation.wait(); ``` The code contains the following parameters: * `metadata.name`: VM's name. * `spec.serviceAccountId` (optional): Service account associated with the VM. * `spec.stopped` (optional): If you want to create a VM but not launch it, specify the `true` value. The VM will remain in the `Stopped` status. * `spec.resources.platform`: [VM platform](https://docs.nebius.com/compute/virtual-machines/types.md). * `spec.resources.size.preset`: VM preset. Depends on the chosen platform. * `spec.gpuCluster.id` (optional): ID of the GPU cluster created earlier. * `spec.bootDisk.attachMode`: Write permission of the boot disk, `READ_ONLY` or `READ_WRITE`. * `spec.bootDisk.deviceId` (optional): User-defined ID for mounting the boot disk to the VM. The default value is `disk-n` where `n` is an integer index. A `virtio-` prefix is added to the specified (or default) device ID. * `spec.bootDisk.type.managedDisk.name`: Name of the [VM-managed boot disk](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks) that you create along with the VM. * `spec.bootDisk.type.managedDisk.spec.type`: [Disk type](https://docs.nebius.com/compute/storage/types.md#network-ssd-disks). * `spec.bootDisk.type.managedDisk.spec.source.sourceImageFamily.imageFamily`: Public image that Nebius AI Cloud supports. For the list of available public images, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). * `spec.bootDisk.type.managedDisk.spec.size.sizeGibibytes`: Disk size in gibibytes. Maximum boot disk size is 30,720 GiB (30 TiB). * `spec.secondaryDisks[].attachMode`: Write permission of the additional disk, `READ_ONLY` or `READ_WRITE`. * `spec.secondaryDisks[].deviceId`: User-defined ID for mounting the additional disk to the VM. * `spec.secondaryDisks[].type.managedDisk.name`: Name of a new additional VM-managed disk. * `spec.secondaryDisks[].type.managedDisk.spec.type`: Disk type of the additional disk. * `spec.secondaryDisks[].type.managedDisk.spec.size.sizeGibibytes`: Size of the additional disk in gibibytes. * `spec.filesystems[].attachMode`: Write permission of the filesystem, `READ_ONLY` or `READ_WRITE`. * `spec.filesystems[].mountTag`: Tag for mounting the filesystem to the VM. * `spec.filesystems[].type.existingFilesystem.id`: ID of the filesystem created earlier. * `spec.cloudInitUserData` (optional): Configuration of VM users in the [cloud-init](https://cloud-init.io/) format. * `spec.networkInterfaces[].subnetId`: ID of the subnet to attach the VM to. * `spec.networkInterfaces[].ipAddress`: Private IP address settings. * `spec.networkInterfaces[].publicIpAddress`: Public IP address settings. In the example, an empty `PublicIPAddress` assigns a dynamic public IP address. * `spec.hostname` (optional): Hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md). By default, the FQDN has the `..compute.internal.` format. * `spec.reservationPolicy.policy` (optional): Policy for reservation usage. You can use [reservations of capacity resources](https://docs.nebius.com/compute/virtual-machines/reservations.md) and run your VM based on them. * `spec.recoveryPolicy` (optional): Defines what Compute does with the VM after it is preempted or fails. * `spec.preemptible.onPreemption` (optional; for preemptible VMs only): Specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. ## Examples ### Create a VM without an additional disk or filesystem To create a VM, run the following command: ```bash nebius compute instance create \ --name \ --resources-platform \ --resources-preset \ --boot-disk-managed-disk-name managed-boot-disk \ --boot-disk-managed-disk-type network_ssd \ --boot-disk-managed-disk-size-gibibytes 10 \ --boot-disk-managed-disk-source-image-family-image-family ubuntu24.04-driverless \ --boot-disk-attach-mode READ_WRITE \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {}, "subnet_id": ""}]' ``` The VM is provided with a dynamic public IPv4 address. For more information about the command parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. 2. Create a VM: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" resources = { platform = "" preset = "" } boot_disk = { managed_disk = { name = "managed-boot-disk" spec = { type = "network_ssd" size_gibibytes = 10 source_image_family = { image_family = "ubuntu24.04-driverless" } } } attach_mode = "" } network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = {} subnet_id = "" } ] } ``` The VM is provided with a dynamic public IPv4 address. For more information about the configuration parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 3. Check that the configuration is correct: ```bash terraform validate ``` 4. Apply the changes: ```bash terraform apply ``` Create a VM: ```go simpleBootDisk := &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", }, }, }, }, }, } simpleNetwork := &compute.NetworkInterfaceSpec{ Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } simpleVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_Preset{ Preset: "", }, }, BootDisk: simpleBootDisk, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ simpleNetwork, }, }, }, ) if err != nil { return err } if _, err = simpleVMOperation.Wait(ctx); err != nil { return err } ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). Create a VM: ```python instance_service = InstanceServiceClient(sdk) simple_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="", preset="", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-boot-disk", spec=DiskSpec( type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=( SourceImageFamily( image_family=( "ubuntu24.04-driverless" ), ) ), size_gibibytes=10, ), ), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await simple_vm_operation.wait() ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). Create a VM: ```ts const simpleVmService = new InstanceService(sdk); const simpleVmOperation = await simpleVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-boot-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-driverless", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await simpleVmOperation.wait(); ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). ### Create a VM with an additional disk Create a VM, its boot disk and an additional disk together: ```bash nebius compute instance create \ --name \ --resources-platform \ --resources-preset \ --boot-disk-managed-disk-name managed-boot-disk \ --boot-disk-managed-disk-type network_ssd \ --boot-disk-managed-disk-size-gibibytes 10 \ --boot-disk-managed-disk-source-image-family-image-family ubuntu24.04-driverless \ --boot-disk-attach-mode READ_WRITE \ --secondary-disks "[{\"attach_mode\": \"READ_WRITE\", \"device_id\": \"device-1\", \"managed_disk\": { \"name\": \"managed-secondary-disk\", \"spec\": { \"type\": \"network_ssd\", \"size_gibibytes\": 10 }}}]" \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {}, "subnet_id": ""}]' ``` The VM is provided with a dynamic public IPv4 address. For more information about the command parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. 2. Create a VM, its boot disk and an additional disk together: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" resources = { platform = "" preset = "" } boot_disk = { managed_disk = { name = "managed-boot-disk" spec = { type = "network_ssd" size_gibibytes = 10 source_image_family = { image_family = "ubuntu24.04-driverless" } } } attach_mode = "" } secondary_disks = [ { managed_disk = { name = "managed-additional-disk" spec = { type = "" size_gibibytes = } } attach_mode = "" device_id = "device-1" } ] network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = {} subnet_id = "" } ] } ``` The VM is provided with a dynamic public IPv4 address. For more information about the configuration parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 3. Check that the configuration is correct: ```bash terraform validate ``` 4. Apply the changes: ```bash terraform apply ``` Create a VM, its boot disk and an additional disk together: ```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: , }, 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: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_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 } ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). Create a VM, its boot disk and an additional disk together: ```python instance_service = InstanceServiceClient(sdk) additional_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="", preset="", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-boot-disk", spec=DiskSpec( type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=( SourceImageFamily( image_family=( "ubuntu24.04-driverless" ), ) ), size_gibibytes=10, ), ), ), secondary_disks=[ AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-secondary-disk", spec=DiskSpec( type=( DiskSpec.DiskType.NETWORK_SSD ), size_gibibytes=, ), ), device_id="device-1", ), ], network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await additional_vm_operation.wait() ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). Create a VM, its boot disk and an additional disk together: ```ts const additionalVmService = new InstanceService(sdk); const additionalVmOperation = await additionalVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-boot-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-driverless", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), }, }), secondaryDisks: [ AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, deviceId: "device-1", type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-secondary-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, size: { $case: "sizeGibibytes", sizeGibibytes: , }, }), }), }, }), ], networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await additionalVmOperation.wait(); ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). ### Create a VM with a filesystem 1. Create a filesystem: ```bash nebius compute filesystem create \ --name \ --size-gibibytes 10 \ --type network_ssd \ --block-size-bytes 4096 ``` Save the filesystem ID from the output `metadata.id` parameter. [Mount filesystems](https://docs.nebius.com/compute/storage/use.md#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM. 2. Create the VM: ```bash nebius compute instance create \ --name \ --stopped \ --resources-platform \ --resources-preset \ --boot-disk-managed-disk-name managed-boot-disk \ --boot-disk-managed-disk-type network_ssd \ --boot-disk-managed-disk-size-gibibytes 10 \ --boot-disk-managed-disk-source-image-family-image-family ubuntu24.04-driverless \ --boot-disk-attach-mode READ_WRITE \ --filesystems '[{"existing_filesystem": {"id": ""}, "attach_mode": "READ_WRITE", "mount_tag": ""}]' \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {}, "subnet_id": ""}]' ``` The VM is provided with a dynamic public IPv4 address. For more information about the command parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. 2. Create a filesystem: ```hcl resource "nebius_compute_v1_filesystem" "my_filesystem" { name = "" parent_id = "" size_gibibytes = 10 type = "NETWORK_SSD" block_size_bytes = 4096 } ``` For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). [Mount filesystems](https://docs.nebius.com/compute/storage/use.md#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM. 3. Create the VM: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" resources = { platform = "" preset = "" } boot_disk = { managed_disk = { name = "managed-boot-disk" spec = { type = "network_ssd" size_gibibytes = 10 source_image_family = { image_family = "ubuntu24.04-driverless" } } } attach_mode = "" } filesystems = [ { existing_filesystem = { id = nebius_compute_v1_filesystem.my_filesystem.id } attach_mode = "" mount_tag = "" } ] network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = {} subnet_id = "" } ] } ``` The VM is provided with a dynamic public IPv4 address. For more information about the configuration parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 4. Check that the configuration is correct: ```bash terraform validate ``` 5. Apply the changes: ```bash terraform apply ``` 1. Create a filesystem: ```go filesystemOperation, err := sdk.Services().Compute().V1(). Filesystem().Create( ctx, &compute.CreateFilesystemRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.FilesystemSpec{ Size: &compute.FilesystemSpec_SizeGibibytes{ SizeGibibytes: 10, }, BlockSizeBytes: 4096, Type: compute.FilesystemSpec_NETWORK_SSD, }, }, ) if err != nil { return err } if _, err = filesystemOperation.Wait(ctx); err != nil { return err } ``` [Mount filesystems](https://docs.nebius.com/compute/storage/use.md#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM. 2. Create the VM: ```go filesystemBootDisk := &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", }, }, }, }, }, } attachedFilesystem := &compute.AttachedFilesystemSpec{ AttachMode: compute.AttachedFilesystemSpec_READ_WRITE, MountTag: "", Type: &compute.AttachedFilesystemSpec_ExistingFilesystem{ ExistingFilesystem: &compute.ExistingFilesystem{ Id: filesystemID, }, }, } filesystemNetwork := &compute.NetworkInterfaceSpec{ Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } filesystemVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Stopped: , Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_Preset{ Preset: "", }, }, BootDisk: filesystemBootDisk, Filesystems: []*compute.AttachedFilesystemSpec{ attachedFilesystem, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ filesystemNetwork, }, }, }, ) if err != nil { return err } if _, err = filesystemVMOperation.Wait(ctx); err != nil { return err } ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. Create a filesystem: ```python filesystem_service = FilesystemServiceClient(sdk) filesystem_operation = await filesystem_service.create( CreateFilesystemRequest( metadata=ResourceMetadata(name=""), spec=FilesystemSpec( block_size_bytes=4096, type=FilesystemSpec.FilesystemType.NETWORK_SSD, size_gibibytes=10, ), ), ) await filesystem_operation.wait() ``` [Mount filesystems](https://docs.nebius.com/compute/storage/use.md#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM. 2. Create the VM: ```python instance_service = InstanceServiceClient(sdk) filesystem_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( stopped=, resources=ResourcesSpec( platform="", preset="", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-boot-disk", spec=DiskSpec( type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=( SourceImageFamily( image_family=( "ubuntu24.04-driverless" ), ) ), size_gibibytes=10, ), ), ), filesystems=[ AttachedFilesystemSpec( attach_mode=( AttachedFilesystemSpec.AttachMode.READ_WRITE ), existing_filesystem=ExistingFilesystem( id=filesystem_id, ), mount_tag="", ), ], network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await filesystem_vm_operation.wait() ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. Create a filesystem: ```ts const filesystemCreateService = new FilesystemService(sdk); const filesystemOperation = await filesystemCreateService.create( CreateFilesystemRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: FilesystemSpec.create({ blockSizeBytes: 4096, type: FilesystemSpec_FilesystemType.NETWORK_SSD, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), ).result; await filesystemOperation.wait(); ``` [Mount filesystems](https://docs.nebius.com/compute/storage/use.md#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM. 2. Create the VM: ```ts const filesystemVmService = new InstanceService(sdk); const filesystemVmOperation = await filesystemVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ stopped: , resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-boot-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-driverless", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), }, }), filesystems: [ AttachedFilesystemSpec.create({ attachMode: AttachedFilesystemSpec_AttachMode.READ_WRITE, mountTag: "", type: { $case: "existingFilesystem", existingFilesystem: ExistingFilesystem.create({ id: filesystemId, }), }, }), ], networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await filesystemVmOperation.wait(); ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). ### Create a VM with local SSD disks Local SSD disks are available only for supported platforms and presets. For details, see [Availability](https://docs.nebius.com/compute/storage/local-disks.md#availability). To create a VM with local SSD disks, run the following command: ```bash nebius compute instance create \ --name \ --stopped \ --resources-platform \ --resources-preset \ --boot-disk-managed-disk-name managed-boot-disk \ --boot-disk-managed-disk-type network_ssd \ --boot-disk-managed-disk-size-gibibytes 10 \ --boot-disk-managed-disk-source-image-family-image-family ubuntu24.04-driverless \ --boot-disk-attach-mode READ_WRITE \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {}, "subnet_id": ""}]' \ --local-disks-passthrough-group-requested true ``` This adds ephemeral local storage to the VM. The example creates a private IPv4 address and doesn't assign a public IPv4 address. For more information about the command parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. 2. Create the VM: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" resources = { platform = "" preset = "" } boot_disk = { managed_disk = { name = "managed-boot-disk" spec = { type = "network_ssd" size_gibibytes = 10 source_image_family = { image_family = "ubuntu24.04-driverless" } } } attach_mode = "" } network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = {} subnet_id = "" } ] local_disks = { passthrough_group = { requested = true } } } ``` This provides a VM with ephemeral local storage. The example creates a private IPv4 address and doesn't assign a public IPv4 address. For more information about the configuration parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 3. Check that the configuration is correct: ```bash terraform validate ``` 4. Apply the changes: ```bash terraform apply ``` Create a VM with local SSD disks: ```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: "", }, Spec: &compute.InstanceSpec{ Stopped: , Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_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 } ``` This adds ephemeral local storage to the VM. The example creates a private IPv4 address and doesn't assign a public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). Create a VM with local SSD disks: ```python instance_service = InstanceServiceClient(sdk) local_disk_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( stopped=, resources=ResourcesSpec( platform="", preset="", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-boot-disk", spec=DiskSpec( type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=( SourceImageFamily( image_family=( "ubuntu24.04-driverless" ), ) ), size_gibibytes=10, ), ), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], local_disks=LocalDisksSpec( passthrough_group=PassthroughGroupRequest( requested=True, ), ), ), ), ) await local_disk_vm_operation.wait() ``` This adds ephemeral local storage to the VM. The example creates a private IPv4 address and doesn't assign a public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). Create a VM with local SSD disks: ```ts const localDiskVmService = new InstanceService(sdk); const localDiskVmOperation = await localDiskVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ stopped: , resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-boot-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-driverless", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], localDisks: LocalDisksSpec.create({ request: { $case: "passthroughGroup", passthroughGroup: PassthroughGroupRequest.create({ requested: true, }), }, }), }), }), ).result; await localDiskVmOperation.wait(); ``` This adds ephemeral local storage to the VM. The example creates a private IPv4 address and doesn't assign a public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). ### Create a VM with standalone boot and additional disks By default, when you create a VM, its disks are created along with this VM. Such disks are called [VM-managed](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks): their lifecycle is tied to the VM, so when you delete the VM, its disks are deleted along with it. Alternatively, if you already have a disk or you want to keep the disk after the VM deletion, create a standalone disk first and attach it to the VM afterward. To create standalone disks and a VM with them, do the following: 1. Create a boot disk: ```bash nebius compute disk create \ --name \ --size-gibibytes 50 \ --type network_ssd \ --source-image-family-image-family ubuntu24.04-cuda13.0 \ --block-size-bytes 4096 ``` Save the disk ID from the output `metadata.id` parameter. For more information about disk creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). 2. Create an additional disk: ```bash nebius compute disk create \ --name \ --size-gibibytes 10 \ --type network_ssd \ --block-size-bytes 4096 ``` Save the disk ID from the output `metadata.id` parameter. After you create the VM, [mount the additional disks](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks. 3. Create a VM: ```bash nebius compute instance create \ --name \ --resources-platform \ --resources-preset \ --boot-disk-existing-disk-id \ --boot-disk-attach-mode \ --boot-disk-device-id \ --secondary-disks "[{\"existing_disk\": {\"id\": \"\"}, \"attach_mode\": \"READ_WRITE\", \"device_id\": \"device-1\"}]" \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {}, "subnet_id": ""}]' ``` The VM is provided with a dynamic public IPv4 address. For more information about the command parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. 2. Create a boot disk by using the following configuration: ```hcl resource "nebius_compute_v1_disk" "my_boot_disk" { name = "" parent_id = "" size_gibibytes = "50" type = "NETWORK_SSD" source_image_family = { image_family = "ubuntu24.04-cuda13.0" } block_size_bytes = 4096 } ``` Set the `parent_id` to your [Project ID](https://docs.nebius.com/iam/manage-projects.md#terraform-3). For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). 3. Create an additional disk: ```hcl resource "nebius_compute_v1_disk" "my_additional_disk" { name = "" parent_id = "" size_gibibytes = "10" type = "NETWORK_SSD" block_size_bytes = 4096 } ``` After you create the VM, [mount the additional disks](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks. 4. Create a VM: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" resources = { platform = "" preset = "" } boot_disk = { existing_disk = { id = nebius_compute_v1_disk.my_boot_disk.id } attach_mode = "" } secondary_disks = [ { existing_disk = { id = nebius_compute_v1_disk.my_additional_disk.id } attach_mode = "" device_id = "" } ] network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = {} subnet_id = "" } ] } ``` The VM is provided with a dynamic public IPv4 address. For more information about the configuration parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 5. Check that the configuration is correct: ```bash terraform validate ``` 6. Apply the changes: ```bash terraform apply ``` 1. Create a boot disk: ```go bootDiskOperation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, 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 = bootDiskOperation.Wait(ctx); err != nil { return err } ``` For more information about disk creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). 2. Create an additional disk: ```go addDiskOperation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: 10, }, BlockSizeBytes: 4096, Type: compute.DiskSpec_NETWORK_SSD, }, }, ) if err != nil { return err } if _, err = addDiskOperation.Wait(ctx); err != nil { return err } ``` After you create the VM, [mount the additional disks](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks. 3. Create a VM: ```go standaloneNetwork := &compute.NetworkInterfaceSpec{ Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } standaloneAttachMode := compute.AttachedDiskSpec_READ_WRITE standaloneVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_Preset{ Preset: "", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: standaloneAttachMode, DeviceId: "", Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: bootDiskID, }, }, }, SecondaryDisks: []*compute.AttachedDiskSpec{ { AttachMode: standaloneAttachMode, DeviceId: "", Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: additionalDiskID, }, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ standaloneNetwork, }, }, }, ) if err != nil { return err } if _, err = standaloneVMOperation.Wait(ctx); err != nil { return err } ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. Create a boot disk: ```python disk_service = DiskServiceClient(sdk) boot_disk_operation = await disk_service.create( CreateDiskRequest( metadata=ResourceMetadata(name=""), 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 boot_disk_operation.wait() ``` For more information about disk creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). 2. Create an additional disk: ```python disk_service = DiskServiceClient(sdk) additional_disk_operation = await disk_service.create( CreateDiskRequest( metadata=ResourceMetadata( name="", ), spec=DiskSpec( block_size_bytes=4096, type=DiskSpec.DiskType.NETWORK_SSD, size_gibibytes=10, ), ), ) await additional_disk_operation.wait() ``` After you create the VM, [mount the additional disks](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks. 3. Create a VM: ```python instance_service = InstanceServiceClient(sdk) standalone_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="", preset="", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=boot_disk_id), device_id="", ), secondary_disks=[ AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), existing_disk=ExistingDisk( id=additional_disk_id, ), device_id="", ), ], network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await standalone_vm_operation.wait() ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. Create a boot disk: ```ts const bootDiskCreateService = new DiskService(sdk); const bootDiskOperation = await bootDiskCreateService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: DiskSpec.create({ blockSizeBytes: 4096, type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-cuda13.0", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 50, }, }), }), ).result; await bootDiskOperation.wait(); ``` For more information about disk creation, see [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md). 2. Create an additional disk: ```ts const additionalDiskCreateService = new DiskService(sdk); const additionalDiskOperation = await additionalDiskCreateService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: DiskSpec.create({ blockSizeBytes: 4096, type: DiskSpec_DiskType.NETWORK_SSD, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), ).result; await additionalDiskOperation.wait(); ``` After you create the VM, [mount the additional disks](https://docs.nebius.com/compute/storage/use.md#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks. 3. Create a VM: ```ts const standaloneVmService = new InstanceService(sdk); const standaloneVmOperation = await standaloneVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, deviceId: "", type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: bootDiskId, }), }, }), secondaryDisks: [ AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, deviceId: "", type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: additionalDiskId, }), }, }), ], networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await standaloneVmOperation.wait(); ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). ### Create a VM within a GPU cluster If you want to create a VM with 8 GPUs (for example, for training models), create a GPU cluster for the VM. By using InfiniBand™, the cluster accelerates tasks that require high-performance computing (HPC) power. 1. Create a GPU cluster: ```bash nebius compute gpu-cluster create \ --name \ --infiniband-fabric ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). Save the cluster ID from the output `metadata.id` parameter. 2. Create a VM: ```bash nebius compute instance create \ --name \ --resources-platform \ --resources-preset \ --boot-disk-managed-disk-name managed-boot-disk \ --boot-disk-managed-disk-type network_ssd \ --boot-disk-managed-disk-size-gibibytes 10 \ --boot-disk-managed-disk-source-image-family-image-family ubuntu24.04-cuda13.0 \ --boot-disk-attach-mode READ_WRITE \ --network-interfaces '[{"name": "eth0", "ip_address": {}, "public_ip_address": {}, "subnet_id": ""}]' \ --gpu-cluster-id ``` The VM is provided with a dynamic public IPv4 address. For more information about the command parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. 2. Create a GPU cluster: ```hcl resource "nebius_compute_v1_gpu_cluster" "my_gpu_cluster" { name = "" parent_id = "" infiniband_fabric = "" } ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 3. Create a VM: ```hcl resource "nebius_compute_v1_instance" "my_vm" { name = "" parent_id = "" resources = { platform = "" preset = "" } boot_disk = { managed_disk = { name = "managed-boot-disk" spec = { type = "network_ssd" size_gibibytes = 10 source_image_family = { image_family = "ubuntu24.04-cuda13.0" } } } attach_mode = "" } network_interfaces = [ { name = "eth0" ip_address = {} public_ip_address = {} subnet_id = "" } ] gpu_cluster = { id = nebius_compute_v1_gpu_cluster.my_gpu_cluster.id } } ``` The VM is provided with a dynamic public IPv4 address. For more information about the configuration parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 4. Check that the configuration is correct: ```bash terraform validate ``` 5. Apply the changes: ```bash terraform apply ``` 1. Create a GPU cluster: ```go gpuClusterOperation, err := sdk.Services().Compute().V1(). GpuCluster().Create( ctx, &compute.CreateGpuClusterRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.GpuClusterSpec{ InfinibandFabric: "", }, }, ) if err != nil { return err } if _, err = gpuClusterOperation.Wait(ctx); err != nil { return err } ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 2. Create a VM: ```go clusterBootDisk := &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-cuda13.0", }, }, }, }, }, } clusterNetwork := &compute.NetworkInterfaceSpec{ Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } clusterVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_Preset{ Preset: "", }, }, GpuCluster: &compute.InstanceGpuClusterSpec{ Id: gpuClusterID, }, BootDisk: clusterBootDisk, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ clusterNetwork, }, }, }, ) if err != nil { return err } if _, err = clusterVMOperation.Wait(ctx); err != nil { return err } ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. Create a GPU cluster: ```python gpu_cluster_service = GpuClusterServiceClient(sdk) gpu_cluster_operation = await gpu_cluster_service.create( CreateGpuClusterRequest( metadata=ResourceMetadata( name="", ), spec=GpuClusterSpec( infiniband_fabric="", ), ), ) await gpu_cluster_operation.wait() ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 2. Create a VM: ```python instance_service = InstanceServiceClient(sdk) cluster_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="", preset="", ), gpu_cluster=InstanceGpuClusterSpec( id=gpu_cluster_id, ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), managed_disk=ManagedDisk( name="managed-boot-disk", spec=DiskSpec( type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=( SourceImageFamily( image_family="ubuntu24.04-cuda13.0", ) ), size_gibibytes=10, ), ), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await cluster_vm_operation.wait() ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). 1. Create a GPU cluster: ```ts const gpuClusterCreateService = new GpuClusterService(sdk); const gpuClusterOperation = await gpuClusterCreateService.create( CreateGpuClusterRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: GpuClusterSpec.create({ infinibandFabric: "", }), }), ).result; await gpuClusterOperation.wait(); ``` To select the fabric, see [InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). 2. Create a VM: ```ts const clusterVmService = new InstanceService(sdk); const clusterVmOperation = await clusterVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), gpuCluster: InstanceGpuClusterSpec.create({ id: gpuClusterId, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "managedDisk", managedDisk: ManagedDisk.create({ name: "managed-boot-disk", spec: DiskSpec.create({ type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-cuda13.0", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 10, }, }), }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await clusterVmOperation.wait(); ``` The VM is provided with a dynamic public IPv4 address. For more information about the code parameters, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). ## "Not enough resources" error Sometimes, demand for virtual machines and GPUs in certain [Nebius AI Cloud regions](https://docs.nebius.com/overview/regions.md) might be higher than the available supply. When this happens, you might see a "Not enough resources" error when creating or restarting VMs in the affected region. For more details, see ["Not enough resources" error for virtual machines in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/not-enough-resources.md). ## See also * [Private and public IP addresses of Compute virtual machines](https://docs.nebius.com/compute/virtual-machines/network.md) * [InfiniBand™ networking for Compute virtual machines with GPUs](https://docs.nebius.com/compute/clusters/gpu/index.md) * [Types of storage volumes in Compute](https://docs.nebius.com/compute/storage/types.md) * [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md) * [Attaching and mounting Compute volumes to VMs](https://docs.nebius.com/compute/storage/use.md) *** *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # Preemptible virtual machines Source: https://docs.nebius.com/compute/virtual-machines/preemptible.md *Preemptible VMs*, also known as spot VMs or spot instances, are virtual machines that Compute may stop at any time. This can happen when the system needs resources to launch a regular VM in the same region. Compute sends a `SIGTERM` signal 60 seconds before stopping the VM. If your system does not respond in time, Compute sends a `SIGKILL` signal to force shutdown. Compute preserves all data on the volumes attached to a stopped preemptible VM. It does not preserve dynamic resources, such as dynamic public IP addresses. Preemptible VMs [cost less than regular ones](https://docs.nebius.com/compute/resources/pricing.md#prices), but they do not provide guaranteed availability. You can create a preemptible VM, but you cannot change the type of an existing VM—either from regular to preemptible or from preemptible to regular. ## Supported platforms You can run preemptible VMs on all [VM platforms with GPUs](https://docs.nebius.com/compute/virtual-machines/types.md). To get an up-to-date list of platforms, run the `nebius compute platform list` [command](https://docs.nebius.com/cli/reference/compute/platform/list). The platforms available for preemptible VMs are marked as `allowed_for_preemptibles: true`. ## Prerequisites If you use the web console, you don't need to complete any prerequisites. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to create a preemptible VM 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Click **Create resource** → **Virtual machine**. 3. If you have [capacity block groups](https://docs.nebius.com/overview/limits/capacity-block-groups.md), on the **General** step, select **Pay-as-you-go VM**. If you do not have capacity block groups, the wizard skips the **General** step and opens **Compute** instead. 4. On the **Compute** step, select **With GPUs** or **Without GPUs**, set the VM type to **Preemptible** and select a [platform and preset](https://docs.nebius.com/compute/virtual-machines/types.md). For more information about the full wizard, see [How to create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). When [creating a VM](https://docs.nebius.com/compute/virtual-machines/manage.md): * Select a [platform that supports preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md#supported-platforms). * Add the following parameters to the `nebius compute instance create` command: ```bash nebius compute instance create \ ... \ --recovery-policy fail \ --preemptible-on-preemption stop ``` In this configuration, the following values are specified: * `recovery_policy` defines what Compute does with a VM after it's preempted or fails. Preemptible VMs support only the `FAIL` value, which stops the VM. They do not support the `RECOVER` value, which tries to restart the VM. Setting `RECOVER` for a preemptible VM results in an error. * `on_preemption` specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. For details about the nebius compute instance create command, see the [Nebius AI Cloud CLI reference](https://docs.nebius.com/cli/reference/compute/instance/create). When creating a VM, select a [platform that supports preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md#supported-platforms) and set the following parameters in the VM configuration: ```hcl resource "nebius_compute_v1_instance" "instance" { ... recovery_policy = "FAIL" preemptible = { on_preemption = "STOP" } ... } ``` In this configuration, the following values are specified: * `recovery_policy` defines what Compute does with a VM after it's preempted or fails. Preemptible VMs support only the `FAIL` value, which stops the VM. They do not support the `RECOVER` value, which tries to restart the VM. Setting `RECOVER` for a preemptible VM results in an error. * `on_preemption` specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. For details about the nebius\_compute\_v1\_instance Terraform resource, see the [provider reference](https://docs.nebius.com/terraform-provider/reference/resources/compute_v1_instance). When [creating a VM](https://docs.nebius.com/compute/virtual-machines/manage.md): * Select a [platform that supports preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md#supported-platforms). * Set the preemptible VM parameters in the code: ```go resources := &compute.ResourcesSpec{ Platform: "gpu-l40s-a", Size: &compute.ResourcesSpec_Preset{ Preset: "1gpu-24vcpu-96gb", }, } bootDisk := &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: bootDiskID, }, }, } networkInterface := &compute.NetworkInterfaceSpec{ Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, } instanceSpec := &compute.InstanceSpec{ Resources: resources, BootDisk: bootDisk, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ networkInterface, }, RecoveryPolicy: compute.InstanceRecoveryPolicy_FAIL, Preemptible: &compute.PreemptibleSpec{ OnPreemption: compute.PreemptibleSpec_STOP, }, } preemptibleOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "preemptible-instance", }, Spec: instanceSpec, }, ) if err != nil { return err } if _, err = preemptibleOperation.Wait(ctx); err != nil { return err } ``` In this configuration, the following values are specified: * `RecoveryPolicy` defines what Compute does with a VM after it's preempted or fails. Preemptible VMs support only the `FAIL` value, which stops the VM. They do not support the `RECOVER` value, which tries to restart the VM. Setting `RECOVER` for a preemptible VM results in an error. * `OnPreemption` specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. When [creating a VM](https://docs.nebius.com/compute/virtual-machines/manage.md): * Select a [platform that supports preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md#supported-platforms). * Set the preemptible VM parameters in the code: ```python instance_service = InstanceServiceClient(sdk) preemptible_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata( name="preemptible-instance", ), spec=InstanceSpec( resources=ResourcesSpec( platform="gpu-l40s-a", preset="1gpu-24vcpu-96gb", ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), existing_disk=ExistingDisk(id=boot_disk_id), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], recovery_policy=InstanceRecoveryPolicy.FAIL, preemptible=PreemptibleSpec( on_preemption=( PreemptibleSpec.PreemptionPolicy.STOP ), ), ), ), ) await preemptible_operation.wait() ``` In this configuration, the following values are specified: * `recovery_policy` defines what Compute does with a VM after it's preempted or fails. Preemptible VMs support only the `FAIL` value, which stops the VM. They do not support the `RECOVER` value, which tries to restart the VM. Setting `RECOVER` for a preemptible VM results in an error. * `on_preemption` specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. When [creating a VM](https://docs.nebius.com/compute/virtual-machines/manage.md): * Select a [platform that supports preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md#supported-platforms). * Set the preemptible VM parameters in the code: ```ts const instanceService = new InstanceService(sdk); const preemptibleOperation = await instanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "preemptible-instance", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "gpu-l40s-a", size: { $case: "preset", preset: "1gpu-24vcpu-96gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: bootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], recoveryPolicy: InstanceRecoveryPolicy.FAIL, preemptible: PreemptibleSpec.create({ onPreemption: PreemptibleSpec_PreemptionPolicy.STOP, }), }), }), ).result; await preemptibleOperation.wait(); ``` In this configuration, the following values are specified: * `recoveryPolicy` defines what Compute does with a VM after it's preempted or fails. Preemptible VMs support only the `FAIL` value, which stops the VM. They do not support the `RECOVER` value, which tries to restart the VM. Setting `RECOVER` for a preemptible VM results in an error. * `onPreemption` specifies what happens when the VM is preempted. The only supported value is `STOP`: Compute stops the VM without deleting or restarting it. A dynamic IP address is released when a preemptible VM stops. To keep your workload stable, consider using a static IP address instead. ## How to continue working with a stopped preemptible VM When Compute stops a preemptible VM, it preserves all data on the attached volumes. To resume work, [start the VM](https://docs.nebius.com/compute/virtual-machines/stop-start.md) again. If you used a dynamic IP address, update all systems that depended on the old IP address. If the VM uses local SSD disks, use them with caution. Local SSD disks are ephemeral, meaning any data stored on them will be lost when the preemptible VM stops. You can also [create a regular VM](https://docs.nebius.com/compute/virtual-machines/manage.md) with the same attached volumes. # Container virtual machines Source: https://docs.nebius.com/compute/virtual-machines/containers.md A container virtual machine (VM) is a VM with a container image deployed. You can use containers provided by Nebius AI Cloud or containers with custom Docker images from public registries. A container VM is based on the same settings as a [standalone VM](https://docs.nebius.com/compute/virtual-machines/manage.md). The key difference is that you select a container to deploy when you create a VM. In the [web console](https://console.nebius.com), container VMs are listed on the **Container VMs** tab of the **Virtual machines** page. You can also open them directly from **Compute** → **Container VMs** in the sidebar. By default, a VM with a dynamic public IPv4 address is created. This allows you to access the container after deployment. If you want to restrict access to the container and create a VM without a public address, you can change it in the advanced settings on the VM creation page. For more information, see [Private and public IP addresses of Compute virtual machines](https://docs.nebius.com/compute/virtual-machines/network.md). ## How to create a container VM 1. In the [web console](https://console.nebius.com), go to **Compute** → **Container VMs**. 2. Click **Create container VM**. 3. On the page that opens, select the project for the VM location. 4. Specify the VM name. 5. Select a container image to deploy on this VM. Certain container images require additional settings configured and access credentials stored (for example, save a token from the web console). If you want to deploy a custom Docker image from a public registry, select the **Custom image** option and then set Docker parameters. 6. Set computing resources. For detailed information about VM settings, see [Parameters of a virtual machine configuration in Compute](https://docs.nebius.com/compute/virtual-machines/params.md). 7. In the **Local storage** section, specify the size of the VM disk. 8. (Optional) Add shared filesystems to the VM. You can create a new filesystem or select an existing one. 9. In the **Access** section, add a username and an SSH key for the VM's user so you can [connect to the VM](https://docs.nebius.com/compute/virtual-machines/connect.md) on its behalf. You can add new credentials or select existing ones. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. 10. (Optional) Add advanced settings: * [GPU cluster](https://docs.nebius.com/compute/clusters/gpu/index.md): Allows accelerating tasks that require high-performance computing (HPC) power, such as training a model. A GPU cluster only helps if you add at least two VMs with 8 GPUs each to the cluster. * Local storage: Select an existing disk or create a new one. For a new disk, you can configure [parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters) such as a disk type, encryption, size and the block size. If you enable the advanced settings, you configure storage in them. The storage settings that you set earlier become disabled, and they do not apply. * Additional disks: Select an existing disk or create a new one as well. * Network settings: * Select a network and subnet to locate the VM. * Specify whether the VM's private IP address should be assigned automatically or be selected from a list of [allocations](https://docs.nebius.com/vpc/overview.md#allocation). * Specify whether the VM should have a public IP address. If you do not assign a public address to your VM, the [access to the container](https://docs.nebius.com/compute/virtual-machines/containers.md#how-to-access-a-deployed-container) is restricted. For more information about available options, see [Public IP addresses](https://docs.nebius.com/compute/virtual-machines/network.md#public-ip-addresses). * Service account: Specify a [service account](https://docs.nebius.com/iam/service-accounts/manage.md) that will perform actions on behalf of the VM, for example, run scripts. 11. Click **Create container VM**. The container is available about five minutes after the VM startup. ## How to access a deployed container Access depends on two major characteristics: * Whether a public IP address is assigned to a VM. If a public address is assigned, you can open the web interface of a container by a provided link. If a VM only has a private IP address, [configure a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) for the VM. After that, you can connect to your VM via a configured VPN and access your container by using an additional VM. * Whether a given container requires credentials, such as a token or API key. If credentials are needed, they are displayed on the container creation and overview pages. After you open the web interface, you can apply the provided credentials there and access the web interface. To open a web interface of a deployed container: 1. In the [web console](https://console.nebius.com), go to **Compute** → **Container VMs**. 2. Open the page of the VM with the required container. 3. If the VM is assigned a public IP address, click the go-to-web-UI button. 4. If the VM only has a private address, configure a WireGuard jump server. For more information, click **How to connect** on the VM page. ## How to check that a custom image is deployed If you want to make sure that a custom Docker image is deployed in your VM: 1. [Connect](https://docs.nebius.com/compute/virtual-machines/connect.md) to the VM via SSH. 2. Check the Docker logs: ```bash sudo docker logs ``` If the container image is deployed, the logs display information about it. # Parameters of a virtual machine configuration in Compute Source: https://docs.nebius.com/compute/virtual-machines/params.md When you [create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md) (VM) or edit its configuration, you operate with VM settings. Below is the list of the VM settings available in the [web console](https://console.nebius.com) creation wizard and on the VM settings page. ## General If you have [capacity block groups](https://docs.nebius.com/overview/limits/capacity-block-groups.md), on the **General** step of the wizard, you choose how Compute allocates resources: * **Reserved VM**: Capacity is assured by your capacity block groups. This option is for regular VMs with GPUs. * **Pay-as-you-go VM**: Capacity is subject to availability. This option allows [preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md) and VMs without GPUs. If you do not have capacity block groups, the wizard skips the **General** step and opens **Compute** instead. ## Compute On the **Compute** step, you configure computing resources. The available settings depend on whether you selected **Reserved VM** or **Pay-as-you-go VM** on the **General** step. If the **General** step was skipped, use the **Pay-as-you-go VM** settings below. ### Reserved VM * [Platform](https://docs.nebius.com/compute/virtual-machines/types.md). The list shows platforms that match your capacity block groups. * [**Reservation**](https://docs.nebius.com/compute/virtual-machines/reservations.md) settings: **Region**, **Any (existing and future)**, specific capacity block groups, and **Switch to PAYG** with **When reservation is exhausted** or **Never**. * Preset. * (Optional) [GPU cluster](https://docs.nebius.com/compute/clusters/gpu/index.md). Allows accelerating tasks that require high-performance computing (HPC) power, such as training a model. A GPU cluster only helps if you add at least two VMs with 8 GPUs each to the cluster. For container VMs, you can assign a GPU cluster in the **Advanced settings** section. * VM name. * Project for the VM location. ### Pay-as-you-go VM * Select **With GPUs** or **Without GPUs** and the VM type **Regular** or [Preemptible](https://docs.nebius.com/compute/virtual-machines/preemptible.md). * [Platform and preset](https://docs.nebius.com/compute/virtual-machines/types.md). * Preset. * (Optional) [GPU cluster](https://docs.nebius.com/compute/clusters/gpu/index.md). Allows accelerating tasks that require HPC power, such as training a model. A GPU cluster only helps if you add at least two VMs with 8 GPUs each to the cluster. For container VMs, you can assign a GPU cluster in the **Advanced settings** section. * VM name. * Project for the VM location. ## Storage On the **Storage** step, you can add a boot disk, additional disks and shared filesystems. For disks, you specify their type, size and block size. A boot disk is additionally based on an operating system. For more information about these settings, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). Boot disks are unavailable for container VMs. Only additional disks are available in advanced settings. For shared filesystems, you specify the following settings: * [Name, size and block size](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). * Mount tag for mounting the filesystem to the VM. Create your own tag, such as `my-filesystem`. Make sure that it is unique within the VM. * **Auto mount** option enabled to mount the filesystem to the VM automatically. ## Network On the **Network** step, you select a [network and subnet](https://docs.nebius.com/vpc/overview.md) and manage the VM addresses: * **Private address**: Select whether to allocate a random private IP address for the VM or to attach an allocation of a private address. * **Public address**: Specify whether the VM should have a public IP address and whether it should be static or dynamic. * **Hostname**: Select **Same as VM ID** or specify a **Custom** hostname for the VM's [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md). If you need to secure your VM and make it isolated, you can create a VM without a public IP address. If you need to connect to this VM from the internet, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md). It has an IP address in the internet and an IP address in the VM's network. As a result, you can access the VM via the jump server from the internet. This approach enhances security and still provides access to the VM. For more information about the settings of the addresses, see [Private and public IP addresses of Compute virtual machines](https://docs.nebius.com/compute/virtual-machines/network.md). ## Configuration On the **Configuration** step, you configure access, identity and VM startup settings for the VM. ### Access In the **Username and SSH key** field, you add credentials of the user on behalf of whom you can [connect to the VM](https://docs.nebius.com/compute/virtual-machines/connect.md). The access settings include the following: * Username of the VM user. Cannot be `root` or `admin`. These usernames are reserved for internal needs and are not allowed to connect to a VM by SSH. * [Public key of your SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md#getting-the-public-key). * Name of credentials to recognize the key in the list of keys. ### Additional (Optional) **Service account**: Select an existing [service account](https://docs.nebius.com/iam/service-accounts/manage.md) or create a new one. The service account will perform actions on behalf of the VM, for example, run scripts. ### User data (Optional) Select **Enable custom cloud-init config** and set a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format to customize how the VM starts. ## Review On the **Review** step, you see a summary of all settings before creating the VM. To edit a section, click next to the corresponding block on the **Review** step. # Maintenance of Compute virtual machines Source: https://docs.nebius.com/compute/virtual-machines/maintenance.md The Compute service performs maintenance for all virtual machines, including nodes of [Managed Service for Kubernetes®](https://docs.nebius.com/kubernetes/index.md) clusters and [Soperator](https://docs.nebius.com/slurm-soperator/overview/why-slurm-soperator.md) clusters. To ensure that maintenance is performed successfully, [stop and start VMs](https://docs.nebius.com/compute/virtual-machines/stop-start.md) until the specified date. You can open the list of VMs via the red banner on the top of the screen. For example:

If you do not stop VMs on time, the service will automatically stop them after the due date to perform maintenance. Delayed maintenance may cause VM instability. If you need to keep your VMs running, [contact the support team](https://console.nebius.com/support/create-ticket) to request rescheduling maintenance of the affected VMs. You can request to reschedule it up to two times, and you can postpone the maintenance by up to seven days each time. # Maintenance reasons in Nebius AI Cloud Source: https://docs.nebius.com/compute/virtual-machines/maintenance-reasons.md When Compute schedules maintenance for your virtual machine (VM), it assigns a *reason code* that describes why the maintenance was triggered. After you identify the reason, [stop and start your VM](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-compute-virtual-machines) to prepare it for maintenance. The reason code helps you assess the severity of the error and decide whether additional action is needed. ## How to identify the reason code for a maintenance event You can view the reason code for maintenance events by: * Checking the maintenance notification banner in the [web console](https://console.nebius.com/); * Using the [Nebius AI Cloud CLI](https://docs.nebius.com/cli/index.md) to list all active maintenance events scheduled for resources in a project. Run the following command, and specify your [project ID](https://docs.nebius.com/iam/manage-projects.md#how-to-get-a-project-id). ```bash nebius compute maintenance list-active --parent-id ``` The output contains a list of all maintenance events that are scheduled for resources in the project you specified. ## Reason codes Maintenance events can be triggered by GPU, InfiniBand™ or node-level errors. The tables below show the reason codes that map to different types of errors. If maintenance was triggered by a condition that is not mapped to one of these reason codes, Compute assigns `OTHER` as the reason code. ### GPU errors | Reason code | Description | | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `HW_GPU_PCI_FALLEN_OFF_BUS` | A GPU or NVSwitch has fallen off the PCI bus, typically due to critical thermal or power issues. The affected node is taken out of service for hardware inspection. | | `HW_GPU_PCI_CONFIG_ERROR` | Unexpected GPU PCI configuration detected, or critical PCI errors observed between the GPU, deltaboard and motherboard. Requires physical hardware maintenance. | | `HW_GPU_NVLINK_DOWN` | An NVLink connection is down on a Blackwell or newer GPU. Requires a GPU reset or VM restart to recover. | | `HW_GPU_XID_62` | The GPU internal micro-controller has halted (XID 62). Requires a GPU reset or VM restart. | | `HW_GPU_XID_109` | GPU context switch timeout (XID 109). Typically not fatal to running workloads, but may require a GPU reset or VM restart. | | `HW_GPU_XID_119` | GSP RPC timeout (XID 119). Requires a GPU reset or VM restart. | | `HW_GPU_FW_VERSION_UNAVAILABLE` | DCGM could not report the GPU firmware version. This is usually a symptom of other underlying hardware errors. | | `HW_GPU_DRIVER_INIT_FAILED` | The NVIDIA® driver failed to initialize one or more GPUs. Typically caused by other hardware errors. | ### InfiniBand™ errors | Reason code | Description | | -------------------------- | ----------------------------------------------------------------------------------------------------- | | `HW_IB_LINK_DOWN` | The InfiniBand link has been in a physically down state for more than 3 minutes. | | `HW_IB_PCI_FALLEN_OFF_BUS` | The InfiniBand adapter has fallen off the PCI bus, typically due to critical thermal or power issues. | | `HW_IB_PCI_CONFIG_ERROR` | Unexpected InfiniBand PCI configuration detected, typically due to critical PCI errors. | ### Node-level errors | Reason code | Description | | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------- | | `HW_NODE_OFFLINE` | The node hosting the VM went offline. The cause may vary. Affected VMs are force-migrated and will experience an unexpected reboot. | *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # How to stop and start Compute virtual machines Source: https://docs.nebius.com/compute/virtual-machines/stop-start.md To proceed with [maintenance](https://docs.nebius.com/compute/virtual-machines/maintenance.md), stop and start virtual machines [manually](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-vms-manually) or [automatically](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-vms-automatically-by-using-autohealing). If you need to keep your VMs running, [contact the support team](https://console.nebius.com/support/create-ticket) and consult them about the possibility of rescheduling maintenance of the affected VMs. Do not stop your VM by using Linux commands, such as `shutdown` or `halt`. Compute considers this as a failure, reboots the VM automatically and continues charging for this VM. Use Nebius AI Cloud interfaces instead and follow the instructions below. ## Prerequisites If you use the web console, you don't need to complete any prerequisites. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to stop and start VMs manually 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. On the **Standalone VMs** tab, find VMs with the maintenance label. maintenance-label

3. Click → **Stop** for these VMs. 4. In the window that opens, confirm stopping the VM. 5. When the VM status changes to **Stopped**, click → **Start**. 6. In the window that opens, confirm starting the VM. 1. Check whether maintenance is scheduled for a VM: ```bash nebius compute instance get --id ``` If the output contains the `status.maintenance_event_id` parameter, this means that you need to stop and start this VM. 2. Stop the VM: ```bash nebius compute instance stop --id ``` 3. Start the VM: ```bash nebius compute instance start --id ``` 1. Check whether maintenance is scheduled for a VM: ```go instance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } fmt.Println(instance) ``` If the response contains a maintenance event ID in the VM status, stop and start this VM. 2. Stop the VM: ```go stopInstanceOperation, err := sdk.Services().Compute().V1(). Instance().Stop( ctx, &compute.StopInstanceRequest{ Id: "", }, ) if err != nil { return err } if _, err = stopInstanceOperation.Wait(ctx); err != nil { return err } ``` 3. Start the VM: ```go startOperation, err := sdk.Services().Compute().V1(). Instance().Start( ctx, &compute.StartInstanceRequest{ Id: "", }, ) if err != nil { return err } if _, err = startOperation.Wait(ctx); err != nil { return err } ``` 1. Check whether maintenance is scheduled for a VM: ```python instance_service = InstanceServiceClient(sdk) instance = await instance_service.get( GetInstanceRequest(id=""), ) print(instance) ``` If the response contains a maintenance event ID in the VM status, stop and start this VM. 2. Stop the VM: ```python instance_service = InstanceServiceClient(sdk) stop_instance_operation = await instance_service.stop( StopInstanceRequest(id=""), ) await stop_instance_operation.wait() ``` 3. Start the VM: ```python instance_service = InstanceServiceClient(sdk) start_instance_operation = await instance_service.start( StartInstanceRequest(id=""), ) await start_instance_operation.wait() ``` 1. Check whether maintenance is scheduled for a VM: ```ts const getInstanceService = new InstanceService(sdk); const instance = await getInstanceService.get( GetInstanceRequest.create({ id: "", }), ); console.log(instance); ``` If the response contains a maintenance event ID in the VM status, stop and start this VM. 2. Stop the VM: ```ts const stopInstanceService = new InstanceService(sdk); const stopInstanceOperation = await stopInstanceService.stop( StopInstanceRequest.create({ id: "", }), ).result; await stopInstanceOperation.wait(); ``` 3. Start the VM: ```ts const startInstanceService = new InstanceService(sdk); const startInstanceOperation = await startInstanceService.start( StartInstanceRequest.create({ id: "", }), ).result; await startInstanceOperation.wait(); ``` ## How to stop and start VMs automatically by using autohealing You can create a VM with the autohealing function. It allows a VM to automatically stop and start each time maintenance is scheduled. As a result, the applications on this VM are highly available. Use autohealing only if the automatic VM shutdown is safe for the workloads on this VM. If you cannot stop the VM at any time, it is better to manage the VM [manually](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-vms-manually). To create a VM that stops and starts automatically during maintenance events: 1. Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has the `admin` role within your tenant or project; for example, the default `admins` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 2. [Create a service account](https://docs.nebius.com/iam/service-accounts/manage.md#create-a-service-account). 3. Add it to the default `viewers` group: 1. Get the ID of the `viewers` group: ```bash nebius iam group get-by-name --name viewers \ --parent-id \ --format json | jq -r '.metadata.id' ``` In the command, specify your [Tenant ID](https://docs.nebius.com/iam/get-tenants.md#cli). 2. Get the ID of the service account: ```bash nebius iam service-account get-by-name \ --name \ --format json | jq -r '.metadata.id' ``` 3. Add the service account to the `viewers` group: ```bash nebius iam group-membership create \ --parent-id \ --member-id ``` 1. Get the ID of the `viewers` group: ```go viewersGroup, err := sdk.Services().IAM().V1(). Group().GetByName( ctx, &iam.GetGroupByNameRequest{ ParentId: "", Name: "viewers", }, ) if err != nil { return err } viewersID := viewersGroup.GetMetadata().GetId() if viewersID == "" { return errors.New("viewers group ID is missing") } ``` In the code, specify your [tenant ID](https://docs.nebius.com/iam/get-tenants.md). 2. Get the ID of the service account: ```go serviceAccount, err := sdk.Services().IAM().V1(). ServiceAccount().GetByName( ctx, &iam.GetServiceAccountByNameRequest{ Name: "", }, ) if err != nil { return err } serviceAccountID := serviceAccount.GetMetadata().GetId() if serviceAccountID == "" { return errors.New("service account ID is missing") } ``` In the code, specify the service account name. 3. Add the service account to the `viewers` group: ```go membershipOperation, err := sdk.Services().IAM().V1(). GroupMembership().Create( ctx, &iam.CreateGroupMembershipRequest{ Metadata: &common.ResourceMetadata{ ParentId: "", }, Spec: &iam.GroupMembershipSpec{ MemberId: "", }, }, ) if err != nil { return err } if _, err = membershipOperation.Wait(ctx); err != nil { return err } ``` In the code, specify the IDs of the `viewers` group and the service account. 1. Get the ID of the `viewers` group: ```python group_service = GroupServiceClient(sdk) viewers_group = await group_service.get_by_name( GetGroupByNameRequest( parent_id="", name="viewers", ), ) viewers_id = viewers_group.metadata.id ``` In the code, specify your [tenant ID](https://docs.nebius.com/iam/get-tenants.md). 2. Get the ID of the service account: ```python service_account_service = ServiceAccountServiceClient(sdk) service_account = await service_account_service.get_by_name( GetServiceAccountByNameRequest(name=""), ) service_account_id = service_account.metadata.id ``` In the code, specify the service account name. 3. Add the service account to the `viewers` group: ```python membership_service = GroupMembershipServiceClient(sdk) membership_operation = await membership_service.create( CreateGroupMembershipRequest( metadata=ResourceMetadata(parent_id=""), spec=GroupMembershipSpec(member_id=""), ), ) await membership_operation.wait() ``` In the code, specify the IDs of the `viewers` group and the service account. 1. Get the ID of the `viewers` group: ```ts const groupService = new GroupService(sdk); const viewersGroup = await groupService.getByName( GetGroupByNameRequest.create({ parentId: "", name: "viewers", }), ); const viewersId = viewersGroup.metadata?.id; if (!viewersId) { throw new Error("viewers group ID is missing"); } ``` In the code, specify your [tenant ID](https://docs.nebius.com/iam/get-tenants.md). 2. Get the ID of the service account: ```ts const saService = new ServiceAccountService(sdk); const serviceAccount = await saService.getByName( GetServiceAccountByNameRequest.create({ name: "", }), ); const serviceAccountId = serviceAccount.metadata?.id; if (!serviceAccountId) { throw new Error("service account ID is missing"); } ``` In the code, specify the service account name. 3. Add the service account to the `viewers` group: ```ts const membershipService = new GroupMembershipService(sdk); const membershipOperation = await membershipService.create( CreateGroupMembershipRequest.create({ metadata: ResourceMetadata.create({ parentId: "", }), spec: GroupMembershipSpec.create({ memberId: "", }), }), ).result; await membershipOperation.wait(); ``` In the code, specify the IDs of the `viewers` group and the service account. 4. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md). In its configuration, specify the following: * [Settings that allow connections](https://docs.nebius.com/compute/virtual-machines/connect.md#set-up-the-vm) to this VM. * Created service account: ```bash nebius compute instance create \ ... \ --service-account-id ``` ```go fsAttachMode := compute.AttachedFilesystemSpec_READ_WRITE existingFS := &compute.ExistingFilesystem{ Id: filesystemID, } fsType := &compute.AttachedFilesystemSpec_ExistingFilesystem{ ExistingFilesystem: existingFS, } instanceOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "vm", }, Spec: &compute.InstanceSpec{ ServiceAccountId: "", Resources: &compute.ResourcesSpec{ Platform: "cpu-e2", Size: &compute.ResourcesSpec_Preset{ Preset: "2vcpu-8gb", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: bootDiskID, }, }, }, Filesystems: []*compute.AttachedFilesystemSpec{ { AttachMode: fsAttachMode, MountTag: "filesystem-1", Type: fsType, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, }, }, }, }, ) if err != nil { return err } if _, err = instanceOperation.Wait(ctx); err != nil { return err } ``` ```python instance_service = InstanceServiceClient(sdk) create_instance_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name="vm"), spec=InstanceSpec( service_account_id="", resources=ResourcesSpec( platform="cpu-e2", preset="2vcpu-8gb", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=boot_disk_id), ), filesystems=[ AttachedFilesystemSpec( attach_mode=( AttachedFilesystemSpec.AttachMode.READ_WRITE ), existing_filesystem=ExistingFilesystem( id=filesystem_id, ), mount_tag="filesystem-1", ), ], network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await create_instance_operation.wait() ``` ```ts const createInstanceService = new InstanceService(sdk); const createInstanceOperation = await createInstanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "vm", }), spec: InstanceSpec.create({ serviceAccountId: "", resources: ResourcesSpec.create({ platform: "cpu-e2", size: { $case: "preset", preset: "2vcpu-8gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: bootDiskId, }), }, }), filesystems: [ AttachedFilesystemSpec.create({ attachMode: AttachedFilesystemSpec_AttachMode.READ_WRITE, mountTag: "filesystem-1", type: { $case: "existingFilesystem", existingFilesystem: ExistingFilesystem.create({ id: filesystemId, }), }, }), ], networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId: subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await createInstanceOperation.wait(); ``` 5. [Connect to the VM](https://docs.nebius.com/compute/virtual-machines/connect.md#connect-to-the-vm-by-using-ssh). 6. Install `jq` on the VM: ```bash Ubuntu sudo apt-get install jq ``` ```bash macOS brew install jq ``` 7. Go to the `/usr/local/bin/` directory: ```bash cd /usr/local/bin/ ``` 8. Create the `vm_maintenance.sh` file: ```bash sudo nano vm_maintenance.sh ``` 9. Add the following Bash script to the file: ```bash #!/bin/bash INSTANCE_ID_FILE="/mnt/cloud-metadata/instance-id" CHECK_INTERVAL=600 # 10 minutes in seconds # Check if the Nebius AI Cloud CLI is installed check_nebius_installed() { if ! command -v nebius &> /dev/null; then echo "$(date) - Nebius utility not found, exiting..." exit 1 fi } get_instance_id() { if [[ -f "$INSTANCE_ID_FILE" ]]; then cat "$INSTANCE_ID_FILE" else echo "File with the virtual machine ID is not found" exit 1 fi } # Handle a maintenance event handle_maintenance_event() { # Add custom actions before stopping the virtual machine echo "$(date) - Custom actions before stopping the virtual machine" sudo shutdown -h +1 "Restarting virtual machine due to maintenance" } check_nebius_installed # main loop while true; do INSTANCE_ID=$(get_instance_id) if [[ -z "$INSTANCE_ID" ]]; then echo "Virtual machine ID is empty" exit 1 fi RESPONSE=$(nebius compute instance get --id "$INSTANCE_ID" --format json) if echo "$RESPONSE" | jq -e '.status.maintenance_event_id' >/dev/null; then echo "$(date) - Maintenance event detected" handle_maintenance_event else echo "$(date) - No maintenance event detected" fi sleep "$CHECK_INTERVAL" done ``` 10. Make the file executable: ```bash sudo chmod +x /usr/local/bin/vm_maintenance.sh ``` 11. To make the script run continuously and restart it when the VM fails or reboots, add a `systemd` unit to the script: ```bash sudo bash -c 'cat > /etc/systemd/system/vm_maintenance.service << EOF [Unit] Description=VM Maintenance Event Handler After=network.target [Service] ExecStart=/usr/local/bin/vm_maintenance.sh Restart=always User=root Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin WorkingDirectory=/usr/local/bin StandardOutput=append:/var/log/vm_maintenance.log StandardError=append:/var/log/vm_maintenance.log [Install] WantedBy=multi-user.target EOF' ``` 12. Start the service created with the `systemd` unit, and let it restart in case of the VM reboot: ```bash sudo systemctl daemon-reload sudo systemctl start vm_maintenance sudo systemctl enable vm_maintenance sudo systemctl status vm_maintenance ``` The output example is the following: ```text Created symlink /etc/systemd/system/multi-user.target.wants/vm_maintenance.service → /etc/systemd/system/vm_maintenance.service. ● vm_maintenance.service - VM Maintenance Event Handler Loaded: loaded (/etc/systemd/system/vm_maintenance.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2025-04-25 10:19:19 UTC; 214ms ago Main PID: 28530 (vm_maintenance.) Tasks: 6 (limit: 19056) Memory: 24.3M CPU: 25ms CGroup: /system.slice/vm_maintenance.service ├─28530 /bin/bash /usr/local/bin/vm_maintenance.sh └─28535 nebius compute instance get --id computeinstance-*** --format json Apr 25 10:19:19 computeinstance-*** systemd[1]: Started VM Maintenance Event Handler. ``` Now, the script runs continuously, and the VM stops and starts during maintenance events. # Lifecycle of a Compute virtual machine Source: https://docs.nebius.com/compute/virtual-machines/lifecycle.md Every virtual machine (VM) in Compute can have one of the following statuses: * `Stopped`: VM is stopped. * `Starting`: VM is launching. * `Running`: VM is running. * `Stopping`: VM is stopping. * `Deleting`: VM is being deleted. * `Error`: VM crashed and cannot be restored. When a VM assumes this status, delete this VM and create a new one. You cannot stop and start a VM with the `Error` status. ## Transitions between VM statuses ### VM is being created `Stopped` → `Starting` → `Running` If you [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md) by using the CLI or Terraform, you can specify `"stopped": true` in the VM configuration. In this case, the VM is created with the `Stopped` status. The status does not change until you [launch this VM](https://docs.nebius.com/compute/virtual-machines/stop-start.md). ### VM is being started `Stopped` → `Starting` → `Running` When a VM is `Starting`, its hypervisor launches the VM's operating system. Additionally, the service allocates computing resources to the VM, such as RAM, GPUs and CPUs. When a VM is `Running`, it functions fully. This influences [billing](https://docs.nebius.com/compute/virtual-machines/lifecycle.md#when-compute-charges-for-the-vm-usage) and [quotas](https://docs.nebius.com/compute/virtual-machines/lifecycle.md#when-compute-quotas-are-released). The service charges you for a running VM. Also, the number of resources occupied in the tenant or project increases. ### VM is being stopped `Running` → `Stopping` → `Stopped` When a VM is `Stopping`, its hypervisor shuts down the operating system of this VM. Before the OS is turned off completely, the hypervisor gracefully terminates all running processes within 60 seconds to prevent data loss. After that, the VM is `Stopped`. ### VM is being deleted `Running` → `Deleting` After the `Deleting` status, a VM is removed from the list of VMs and the occupied quotas are released. ### VM crashed and is being recovered If the VM recovery is successful, statuses of this VM change in the following order: `Running` → `Stopping` → `Stopped` → `Running` If Compute cannot start the VM properly during the recovery, for example, because of a lack of available resources, the VM goes through one of the following lifecycles: * `Running` → `Stopping` → `Stopped` → `Starting` → `Stopping` → `Stopped` or `Error` * `Running` → `Stopping` → `Stopped` or `Error` ## When Compute charges for the VM usage When you create a VM, Compute starts [charging](https://docs.nebius.com/compute/resources/pricing.md) for it once the VM assumes the `Running` status. When you delete a VM, Compute stops charging for it once you send the deletion command. For example, you click the **Delete** button or run a [CLI command](https://docs.nebius.com/cli/reference/compute/instance/delete). When a VM has crashed, Compute stops charging for it when recovery begins. If the VM is recovered successfully, the service continues charging. If not, the charging does not start again. ## When Compute quotas are released [Compute quotas](https://docs.nebius.com/compute/resources/quotas-limits.md) are only released after the VM deletion. If a VM is `Stopped`, the quotas are still occupied. To avoid running out of the quotas, revise your list of VMs from time to time and delete unused VMs. Stopping them will not help. # How to enable automatic security updates Source: https://docs.nebius.com/compute/storage/automatic-updates.md The Ubuntu [images](https://docs.nebius.com/compute/storage/boot-disk-images.md) used on boot disks of VMs include the `unattended-upgrades` package that can install security updates automatically. However, unexpected updates might break running GPU workloads. For this reason, unattended upgrades are disabled by default. We recommend that you check the compatibility of new library versions on a test VM, and then apply the updates manually to all running GPU nodes. If you do need constant security updates, you can enable `unattended-upgrades`. ## For an existing VM 1. [Connect](https://docs.nebius.com/compute/virtual-machines/connect.md) to the VM. 2. Check that the updates are enabled in the configuration: ```bash sudo nano /etc/apt/apt.conf.d/20auto-upgrades ``` The following values should be equal to 1. If they are set to 0, change them to 1: ```bash APT::Periodic::Update-Package-Lists "1"; APT::Periodic::Unattended-Upgrade "1"; ``` 3. Start the upgrade services: ```bash sudo systemctl unmask apt-daily.service apt-daily-upgrade.service sudo systemctl enable apt-daily.timer apt-daily-upgrade.timer sudo systemctl start apt-daily.timer apt-daily-upgrade.timer ``` 4. Check the service status: ```bash systemctl status apt-daily.timer apt-daily-upgrade.timer ``` Output for active updates should look like the following: ```bash ● apt-daily.timer - Daily apt download activities Loaded: loaded (/usr/lib/systemd/system/apt-daily.timer; enabled; preset: enabled) Active: active (waiting) since Wed 2025-10-01 14:59:29 UTC; 7s ago Trigger: Thu 2025-10-02 04:54:23 UTC; 13h left Triggers: ● apt-daily.service ● apt-daily-upgrade.timer - Daily apt upgrade and clean activities Loaded: loaded (/usr/lib/systemd/system/apt-daily-upgrade.timer; enabled; preset: enabled) Active: active (waiting) since Wed 2025-10-01 14:59:29 UTC; 7s ago Trigger: Thu 2025-10-02 06:10:29 UTC; 15h left Triggers: ● apt-daily-upgrade.service ``` ## During VM creation When you create a new VM, you can enable unattended upgrades for the VM in the [user data configuration](https://docs.nebius.com/compute/virtual-machines/manage.md#optional-create-a-user-data-configuration). On the VM creation page in to the **User data** section, enable the custom cloud-init configuration. The window below contains the code that specifies users who can connect to the VM. Add the following code to enable updates: ```yaml users: - name: $USER sudo: ALL=(ALL) NOPASSWD:ALL shell: /bin/bash ssh_authorized_keys: - $(cat ~/.ssh/id_ed25519.pub) package_update: true packages: - unattended-upgrades write_files: - path: /etc/apt/apt.conf.d/20auto-upgrades permissions: '0644' content: | APT::Periodic::Update-Package-Lists "1"; APT::Periodic::Unattended-Upgrade "1"; runcmd: - systemctl unmask apt-daily.service apt-daily-upgrade.service - systemctl enable --now apt-daily.timer apt-daily-upgrade.timer - systemctl restart unattended-upgrades ``` Create a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/explanation/about-cloud-config.html) format. Add the following code to enable updates for users who can connect to the VM: ```bash export USER_DATA=$(jq -Rrs '.' < Create a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/explanation/about-cloud-config.html) format. Add the following code to enable updates for users who can connect to the VM: ```bash export USER_DATA=$(jq -Rrs '.' < Create a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/explanation/about-cloud-config.html) format. Add the following code to enable updates for users who can connect to the VM: ```go publicKeyBytes, err := os.ReadFile( os.ExpandEnv("$HOME/.ssh/id_ed25519.pub"), ) if err != nil { return err } publicKey := strings.TrimSpace(string(publicKeyBytes)) userData := "#cloud-config\nusers:\n" + " - name: user\n" + " sudo: ALL=(ALL) NOPASSWD:ALL\n" + " shell: /bin/bash\n" + " ssh_authorized_keys:\n" + " - " + publicKey + "\n\n" + "package_update: true\n" + "packages:\n" + " - unattended-upgrades\n\n" + "write_files:\n" + " - path: /etc/apt/apt.conf.d/20auto-upgrades\n" + " permissions: '0644'\n" + " content: |\n" + " APT::Periodic::Update-Package-Lists \"1\";\n" + " APT::Periodic::Unattended-Upgrade \"1\";\n\n" + "runcmd:\n" + " - systemctl unmask apt-daily.service apt-daily-upgrade.service\n" + " - systemctl enable --now apt-daily.timer apt-daily-upgrade.timer\n" + " - systemctl restart unattended-upgrades" ``` Pass the configured user data to `InstanceSpec.CloudInitUserData` when creating the VM. Create a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/explanation/about-cloud-config.html) format. Add the following code to enable updates for users who can connect to the VM: ```python public_key = ( Path.home() .joinpath(".ssh/id_ed25519.pub") .read_text() .strip() ) user_data = "\n".join( [ "#cloud-config", "users:", " - name: user", " sudo: ALL=(ALL) NOPASSWD:ALL", " shell: /bin/bash", " ssh_authorized_keys:", f" - {public_key}", "", "package_update: true", "packages:", " - unattended-upgrades", "", "write_files:", " - path: /etc/apt/apt.conf.d/20auto-upgrades", " permissions: '0644'", " content: |", ' APT::Periodic::Update-Package-Lists "1";', ' APT::Periodic::Unattended-Upgrade "1";', "", "runcmd:", " - systemctl unmask apt-daily.service apt-daily-upgrade.service", " - systemctl enable --now apt-daily.timer apt-daily-upgrade.timer", " - systemctl restart unattended-upgrades", ], ) ``` Pass the configured user data to `InstanceSpec.cloud_init_user_data` when creating the VM. Create a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/explanation/about-cloud-config.html) format. Add the following code to enable updates for users who can connect to the VM: ```ts const publicKey = readFileSync( `${process.env.HOME}/.ssh/id_ed25519.pub`, "utf8", ).trim(); const userData = [ "#cloud-config", "users:", " - name: user", " sudo: ALL=(ALL) NOPASSWD:ALL", " shell: /bin/bash", " ssh_authorized_keys:", " - " + publicKey, "", "package_update: true", "packages:", " - unattended-upgrades", "", "write_files:", " - path: /etc/apt/apt.conf.d/20auto-upgrades", " permissions: '0644'", " content: |", ' APT::Periodic::Update-Package-Lists "1";', ' APT::Periodic::Unattended-Upgrade "1";', "", "runcmd:", " - systemctl unmask apt-daily.service apt-daily-upgrade.service", " - systemctl enable --now apt-daily.timer apt-daily-upgrade.timer", " - systemctl restart unattended-upgrades", ].join("\n"); ``` Pass the configured user data to `InstanceSpec.cloudInitUserData` when creating the VM. # Private and public IP addresses of Compute virtual machines Source: https://docs.nebius.com/compute/virtual-machines/network.md Virtual machines (VMs) in Compute can be reached at their private and public IP addresses. Assign them to manage access to the VM in a network. In addition, you can also configure [security groups](https://docs.nebius.com/vpc/security-groups/overview.md) to enable a firewall for your VMs and control ingress and egress traffic. For more information, see [Managing security groups and security rules](https://docs.nebius.com/vpc/security-groups/manage.md). ## Private IP addresses Each VM is created with a network interface that has a private IPv4 address. VMs can communicate with each other without internet access by using their private addresses. Private address ranges are randomly allocated from subnets within the `10.0.0.0/8` and `192.168.0.0/16` IPv4 CIDR blocks. Don't assign a private IPv4 address within the `172.17.0.0/16` CIDR block to a VM. The VMs running Docker cannot reach this address because the default boot disk images come with Docker preinstalled. As a result, this affects most VMs in the network. For more information, see [Virtual machine is unreachable due to a Docker subnet conflict](https://docs.nebius.com/compute/virtual-machines/docker-subnet-conflict.md). ## Prerequisites If you use the web console, you don't need to complete any prerequisites. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ### How to get a VM's private IP address 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. On the **Standalone VMs** tab, open the page of the required VM. 3. Copy the **Private IPv4** value from the **Network** block. ```bash export PRIVATE_IP_ADDRESS=$(nebius compute instance get-by-name \ --name \ --format json \ | jq -r '.status.network_interfaces[0].ip_address.address | split("/")[0]') echo $PRIVATE_IP_ADDRESS ``` ```go privateIPInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "", }, ) if err != nil { return err } privateAddress := privateIPInstance.GetStatus(). GetNetworkInterfaces()[0].GetIpAddress().GetAddress() privateIPAddress := strings.Split(privateAddress, "/")[0] fmt.Println(privateIPAddress) ``` ```python instance_service = InstanceServiceClient(sdk) private_ip_instance = await instance_service.get_by_name( GetByNameRequest(name=""), ) private_address = ( private_ip_instance.status.network_interfaces[0] .ip_address.address ) private_ip_address = private_address.split("/")[0] print(private_ip_address) ``` ```ts const privateIpService = new InstanceService(sdk); const privateIpInstance = await privateIpService.getByName( GetByNameRequest.create({ name: "", }), ); const privateAddress = privateIpInstance.status ?.networkInterfaces[0]?.ipAddress?.address; const privateIpAddress = privateAddress?.split("/")[0]; console.log(privateIpAddress); ``` ### How to assign a secondary private IP address to a VM You can use secondary private IP addresses as a backup option in case of incidents. For example, a backup node can take a secondary address of the main node when the main one fails. As a result, routing to this address can be preserved. To assign a secondary private address to a VM: 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. On the **Standalone VMs** tab, open the page of the required VM. 3. Click **Attach resource** → **Secondary private IP**. 4. In the window that opens, select whether you want to reuse an existing IP address as a secondary one or create a new address. 5. For an existing IP address, select an allocation and then click **Assign address**. 6. For a new address, specify the allocation name and address. After that, click **Create and assign address**. To assign a secondary private address to a VM, first create a private allocation with the required address. After that, add this allocation to the VM specification. 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet) for the allocation. 2. Check what private CIDR blocks this subnet includes: ```bash nebius vpc subnet get --id ``` The available CIDR blocks are specified in the `status.ipv4_private_cidrs` parameter in the output. 3. Create an allocation that reserves a private address. Use the address that belongs to one of the received private CIDR blocks. ```bash nebius vpc allocation create \ --name private_allocation \ --ipv4-private-subnet-id \ --ipv4-private-cidr ``` Copy the allocation ID from the output. 4. Assign the allocation to the required VM: ```bash nebius compute instance update \ --id \ --network-interfaces "[{\"aliases\": [{\"allocation_id\": \"\"}] }]" ``` For more information, see [Allocating custom private addresses to resources](https://docs.nebius.com/vpc/addressing/custom-private-addresses.md). To assign a secondary private address to a VM, first create a private allocation with the required address. After that, add this allocation to the VM specification. 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet) for the allocation. 2. Check what private CIDR blocks this subnet includes: ```go subnet, err := sdk.Services().VPC().V1(). Subnet().Get( ctx, &vpc.GetSubnetRequest{ Id: "", }, ) if err != nil { return err } fmt.Println(subnet) ``` The response includes the available CIDR blocks. 3. Create an allocation that reserves a private address. Use the address that belongs to one of the received private CIDR blocks. ```go privAllocOperation, err := sdk.Services().VPC().V1(). Allocation().Create( ctx, &vpc.CreateAllocationRequest{ Metadata: &common.ResourceMetadata{ Name: "private_allocation", }, Spec: &vpc.AllocationSpec{ IpSpec: &vpc.AllocationSpec_Ipv4Private{ Ipv4Private: &vpc.IPv4PrivateAllocationSpec{ Cidr: "", Pool: &vpc.IPv4PrivateAllocationSpec_SubnetId{ SubnetId: "", }, }, }, }, }, ) if err != nil { return err } if _, err = privAllocOperation.Wait(ctx); err != nil { return err } allocationID1 := privAllocOperation.ResourceID() ``` Copy the allocation ID from the response. 4. Assign the allocation to the required VM: ```go instanceForAlias, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } if instanceForAlias.GetSpec() == nil { return errors.New("instance spec is missing") } networkInterfaces := instanceForAlias.Spec.NetworkInterfaces networkInterfaces[0].Aliases = []*compute.IPAlias{ { AllocationId: "", }, } aliasOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: instanceForAlias.Metadata, Spec: instanceForAlias.Spec, }, ) if err != nil { return err } if _, err = aliasOperation.Wait(ctx); err != nil { return err } ``` For more information, see [Allocating custom private addresses to resources](https://docs.nebius.com/vpc/addressing/custom-private-addresses.md). To assign a secondary private address to a VM, first create a private allocation with the required address. After that, add this allocation to the VM specification. 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet) for the allocation. 2. Check what private CIDR blocks this subnet includes: ```python subnet_service = SubnetServiceClient(sdk) subnet = await subnet_service.get( GetSubnetRequest(id=""), ) print(subnet) ``` The response includes the available CIDR blocks. 3. Create an allocation that reserves a private address. Use the address that belongs to one of the received private CIDR blocks. ```python allocation_service = AllocationServiceClient(sdk) private_allocation_operation = await allocation_service.create( CreateAllocationRequest( metadata=ResourceMetadata(name="private_allocation"), spec=AllocationSpec( ipv4_private=IPv4PrivateAllocationSpec( cidr="", subnet_id="", ), ), ), ) await private_allocation_operation.wait() allocation_id_1 = private_allocation_operation.resource_id ``` Copy the allocation ID from the response. 4. Assign the allocation to the required VM: ```python instance_service = InstanceServiceClient(sdk) instance = await instance_service.get( GetInstanceRequest(id=""), ) if instance.spec is None: raise ValueError("instance spec is missing") instance.spec.network_interfaces[0].aliases = [ IPAlias(allocation_id=""), ] alias_operation = await instance_service.update( UpdateInstanceRequest( metadata=instance.metadata, spec=instance.spec, ), ) await alias_operation.wait() ``` For more information, see [Allocating custom private addresses to resources](https://docs.nebius.com/vpc/addressing/custom-private-addresses.md). To assign a secondary private address to a VM, first create a private allocation with the required address. After that, add this allocation to the VM specification. 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet) for the allocation. 2. Check what private CIDR blocks this subnet includes: ```ts const getSubnetService = new SubnetService(sdk); const subnet = await getSubnetService.get( GetSubnetRequest.create({ id: "", }), ); console.log(subnet); ``` The response includes the available CIDR blocks. 3. Create an allocation that reserves a private address. Use the address that belongs to one of the received private CIDR blocks. ```ts const privateAllocationService = new AllocationService(sdk); const privateAllocationOperation = await privateAllocationService.create( CreateAllocationRequest.create({ metadata: ResourceMetadata.create({ name: "private_allocation", }), spec: AllocationSpec.create({ ipSpec: { $case: "ipv4Private", ipv4Private: IPv4PrivateAllocationSpec.create({ cidr: "", pool: { $case: "subnetId", subnetId: "", }, }), }, }), }), ).result; await privateAllocationOperation.wait(); const allocationId1 = privateAllocationOperation.resourceId(); ``` Copy the allocation ID from the response. 4. Assign the allocation to the required VM: ```ts const aliasInstanceService = new InstanceService(sdk); const instanceForAlias = await aliasInstanceService.get( GetInstanceRequest.create({ id: "", }), ); if (!instanceForAlias.spec) { throw new Error("instance spec is missing"); } instanceForAlias.spec.networkInterfaces[0].aliases = [ IPAlias.create({ allocationId: "", }), ]; const aliasOperation = await aliasInstanceService.update( UpdateInstanceRequest.create({ metadata: instanceForAlias.metadata, spec: instanceForAlias.spec, }), ).result; await aliasOperation.wait(); ``` For more information, see [Allocating custom private addresses to resources](https://docs.nebius.com/vpc/addressing/custom-private-addresses.md). ## Public IP addresses When creating a VM, you can enable public IPv4 addressing for it. A VM's public address is mapped to its private address by using one-to-one NAT. All IP addresses assigned to a VM are [allocations](https://docs.nebius.com/vpc/overview.md#allocation). When you create a VM and automatically assign a static or dynamic public address, Compute creates an allocation for it and assigns this address to this VM. After that, Compute manages the lifecycle of this allocation. In particular, Compute deletes the allocation when the VM is deleted. Public IP addresses are allocated from the public IPv4 ranges available for a given project. The available range depends on the [region](https://docs.nebius.com/overview/regions.md) where you create a VM. For instructions on how to get these ranges, see [Getting public IPv4 ranges for projects](https://docs.nebius.com/vpc/addressing/public-address-ranges.md). If you assign an already existing allocation when you create a VM, Virtual Networks manages the lifecycle of this allocation. In this case, the allocation is preserved even if you delete the VM. If you need to secure your VM and make it isolated, you can create a VM without a public IP address. If you need to connect to this VM from the internet, you can [set up a WireGuard jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md). It has an IP address in the internet and an IP address in the VM's network. As a result, you can access the VM via the jump server from the internet. This approach enhances security and still provides access to the VM. ### How to enable a public IP address for a VM To enable a public address, either [create a VM](https://docs.nebius.com/compute/virtual-machines/network.md#how-to-create-a-vm-with-a-public-ip-address) with it or [assign a public address to an existing VM](https://docs.nebius.com/compute/virtual-machines/network.md#how-to-enable-a-public-ip-address-for-an-existing-vm). A VM must be in the same [region](https://docs.nebius.com/overview/regions.md) as the VM's subnet. An allocation assigned to a VM must belong to the VM's subnet. For more information, see [Virtual Networks documentation](https://docs.nebius.com/vpc/overview.md). #### How to create a VM with a public IP address On the **Network** step of the [VM creation wizard](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), in the **Public IP address** field, select one of the following options: * **Auto assign dynamic IP** (default): A dynamic public IP address is randomly allocated from the [public IPv4 ranges available for the project](https://docs.nebius.com/vpc/addressing/public-address-ranges.md). Dynamic public IP addresses are not persistent. If a VM with a dynamic address has the `Stopped` status for more than one hour, the address automatically returns to the IPv4 public range of Nebius AI Cloud. After that, Compute may allocate this address to a different VM. If you want to preserve the address, assign a static address or an [allocation](https://docs.nebius.com/vpc/overview.md#allocation) to the VM. * **Auto assign static IP**: A static public IP address is randomly allocated from the public IPv4 ranges available for the project. If you stop a VM that has a static IP address, the address will not return to the range. However, if you delete this VM, the address will return. * **Select from already allocated**: A preliminarily created allocation is assigned to a VM. If you use an allocation, its address will not return to the IPv4 range even if you delete the VM. If you want to create a VM with a private address only, select the **No public IP** option. You can [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md) with a public IP address. This can be either a dynamic address, a static address or an [allocation](https://docs.nebius.com/vpc/overview.md#allocation): * A dynamic public IP address is randomly allocated from the [IPv4 public range](https://docs.nebius.com/compute/virtual-machines/network.md#get-public-ip-range) of Nebius AI Cloud and is not persistent. If a VM with a dynamic address has the `Stopped` status for more than one hour, the address is automatically returned to the IPv4 public range. After that, Compute may allocate this address to a different VM. * A static public IP address is also randomly allocated from the IPv4 public range of Nebius AI Cloud. If you stop a VM that has a static IP address, the address will not return to the range. However, if you delete this VM, the address will return. * An allocation allows you to use a reserved static public address for the VM. This address will not return to the IPv4 range even if you delete the VM. To create a VM with a **dynamic public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Run the following command and specify the subnet ID in it: ```bash nebius compute instance create \ ... \ --network-interfaces "[{\"name\": \"eth0\", \"ip_address\": {}, \"public_ip_address\": {}, \"subnet_id\": \"\"}]" ``` To create a VM with a **static public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Run the following command and specify the subnet ID in it: ```bash nebius compute instance create \ ... \ --network-interfaces "[{\"name\": \"eth0\", \"ip_address\": {}, \"public_ip_address\": {\"static\": true}, \"subnet_id\": \"\"}]" ``` To create a VM with an **already allocated public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```bash nebius vpc allocation create \ --ipv4-public-subnet-id \ --name ``` 3. Create the VM. Specify the subnet ID and the allocation ID in the command: ```bash nebius compute instance create \ ... \ --network-interfaces "[{\"name\": \"eth0\", \"ip_address\": {}, \"public_ip_address\": {\"allocation_id\": \"\"}, \"subnet_id\": \"\"}]" ``` If you want to create a VM with a private address only, omit the `public_ip_address` parameter in the `nebius compute instance create` command. You can [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md) with a public IP address. This can be either a dynamic address, a static address or an [allocation](https://docs.nebius.com/vpc/overview.md#allocation). To create a VM with a **dynamic public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Use the following code: ```go publicVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "cpu-e2", Size: &compute.ResourcesSpec_Preset{ Preset: "2vcpu-8gb", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: publicBootDiskID, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, }, }, }, }, ) if err != nil { return err } if _, err = publicVMOperation.Wait(ctx); err != nil { return err } ``` To create a VM with a **static public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Use the following code: ```go staticVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "cpu-e2", Size: &compute.ResourcesSpec_Preset{ Preset: "2vcpu-8gb", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: staticBootDiskID, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{ Static: true, }, }, }, }, }, ) if err != nil { return err } if _, err = staticVMOperation.Wait(ctx); err != nil { return err } ``` To create a VM with an **already allocated public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```go publicAllocationOperation, err := sdk.Services().VPC().V1(). Allocation().Create( ctx, &vpc.CreateAllocationRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &vpc.AllocationSpec{ IpSpec: &vpc.AllocationSpec_Ipv4Public{ Ipv4Public: &vpc.IPv4PublicAllocationSpec{ Pool: &vpc.IPv4PublicAllocationSpec_SubnetId{ SubnetId: "", }, }, }, }, }, ) if err != nil { return err } if _, err = publicAllocationOperation.Wait(ctx); err != nil { return err } allocationID := publicAllocationOperation.ResourceID() ``` 3. Create the VM: ```go allocationIP := &compute.PublicIPAddress_AllocationId{ AllocationId: "", } allocationVMOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "cpu-e2", Size: &compute.ResourcesSpec_Preset{ Preset: "2vcpu-8gb", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: allocationBootDiskID, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{ Allocation: allocationIP, }, }, }, }, }, ) if err != nil { return err } if _, err = allocationVMOperation.Wait(ctx); err != nil { return err } ``` Create a VM with a private address only: ```go privateOnlyOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "cpu-e2", Size: &compute.ResourcesSpec_Preset{ Preset: "2vcpu-8gb", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: privateBootDiskID, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, }, }, }, }, ) if err != nil { return err } if _, err = privateOnlyOperation.Wait(ctx); err != nil { return err } ``` You can [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md) with a public IP address. This can be either a dynamic address, a static address or an [allocation](https://docs.nebius.com/vpc/overview.md#allocation). To create a VM with a **dynamic public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Use the following code: ```python instance_service = InstanceServiceClient(sdk) public_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="cpu-e2", preset="2vcpu-8gb", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=public_boot_disk_id), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await public_vm_operation.wait() ``` To create a VM with a **static public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Use the following code: ```python instance_service = InstanceServiceClient(sdk) static_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="cpu-e2", preset="2vcpu-8gb", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=static_boot_disk_id), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(static=True), ), ], ), ), ) await static_vm_operation.wait() ``` To create a VM with an **already allocated public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```python allocation_service = AllocationServiceClient(sdk) public_allocation_operation = await allocation_service.create( CreateAllocationRequest( metadata=ResourceMetadata(name=""), spec=AllocationSpec( ipv4_public=IPv4PublicAllocationSpec( subnet_id="", ), ), ), ) await public_allocation_operation.wait() allocation_id = public_allocation_operation.resource_id ``` 3. Create the VM: ```python instance_service = InstanceServiceClient(sdk) allocation_vm_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="cpu-e2", preset="2vcpu-8gb", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk( id=allocation_boot_disk_id, ), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress( allocation_id="", ), ), ], ), ), ) await allocation_vm_operation.wait() ``` Create a VM with a private address only: ```python instance_service = InstanceServiceClient(sdk) private_only_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name=""), spec=InstanceSpec( resources=ResourcesSpec( platform="cpu-e2", preset="2vcpu-8gb", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=private_boot_disk_id), ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), ), ], ), ), ) await private_only_operation.wait() ``` You can [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md) with a public IP address. This can be either a dynamic address, a static address or an [allocation](https://docs.nebius.com/vpc/overview.md#allocation). To create a VM with a **dynamic public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Use the following code: ```ts const publicVmService = new InstanceService(sdk); const publicVmOperation = await publicVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "cpu-e2", size: { $case: "preset", preset: "2vcpu-8gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: publicBootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await publicVmOperation.wait(); ``` To create a VM with a **static public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Use the following code: ```ts const staticVmService = new InstanceService(sdk); const staticVmOperation = await staticVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "cpu-e2", size: { $case: "preset", preset: "2vcpu-8gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: staticBootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({ static: true, }), }), ], }), }), ).result; await staticVmOperation.wait(); ``` To create a VM with an **already allocated public IP address**: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```ts const publicAllocationService = new AllocationService(sdk); const publicAllocationOperation = await publicAllocationService.create( CreateAllocationRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: AllocationSpec.create({ ipSpec: { $case: "ipv4Public", ipv4Public: IPv4PublicAllocationSpec.create({ pool: { $case: "subnetId", subnetId: "", }, }), }, }), }), ).result; await publicAllocationOperation.wait(); const allocationId = publicAllocationOperation.resourceId(); ``` 3. Create the VM: ```ts const allocationVmService = new InstanceService(sdk); const allocationVmOperation = await allocationVmService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "cpu-e2", size: { $case: "preset", preset: "2vcpu-8gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: allocationBootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({ allocation: { $case: "allocationId", allocationId: "", }, }), }), ], }), }), ).result; await allocationVmOperation.wait(); ``` Create a VM with a private address only: ```ts const privateOnlyService = new InstanceService(sdk); const privateOnlyOperation = await privateOnlyService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "cpu-e2", size: { $case: "preset", preset: "2vcpu-8gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: privateBootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), }), ], }), }), ).result; await privateOnlyOperation.wait(); ``` If an allocation with a public address has not been assigned to any resource for 30 days, Nebius AI Cloud can delete this allocation and release its address. If you want to preserve the address, assign its allocation to a Nebius AI Cloud resource. #### How to enable a public IP address for an existing VM You can only assign one public IP address to a VM. If the VM already has a public address, you cannot assign one more. 1. In the [web console](https://console.nebius.com), go to **Compute** → **Virtual machines**. 2. On the **Standalone VMs** tab, open the page of the required VM. 3. Click **Attach resource** → **Public IP address**. 4. In the window that opens, select whether you want to assign an existing IP address or create a new one. 5. For an existing IP address, select the required one and then click **Assign address**. 6. For a new address, specify the address type: dynamic or static. After that, click **Create and assign address**. After you enable an IP address for a VM, you can change the type of this address: make it static or dynamic. To do so, go to the VM page, open the **Network interface** tab and then click → **Edit type** in the line of the required address. To enable a **dynamic public IP address** for a VM, run the following command: ```bash nebius compute instance update \ --id \ --network-interfaces "[{\"public_ip_address\": {} }]" ``` To enable a **static public IP address** for a VM, run the following command: ```bash nebius compute instance update \ --id \ --network-interfaces "[{\"public_ip_address\": {\"static\": true}}]" ``` To assign an **already allocated public IP address** to a VM: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```bash nebius vpc allocation create \ --ipv4-public-subnet-id \ --name ``` 3. Assign this allocation to the VM: ```bash nebius compute instance update \ --id \ --network-interfaces "[{\"public_ip_address\": {\"allocation_id\": \"\"}}]" ``` Enable a **dynamic public IP address** for a VM: ```go privateInstance1, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } if privateInstance1.GetSpec() == nil { return errors.New("instance spec is missing") } privateInstance1.Spec.NetworkInterfaces[0]. PublicIpAddress = &compute.PublicIPAddress{} dynamicIPOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: privateInstance1.Metadata, Spec: privateInstance1.Spec, }, ) if err != nil { return err } if _, err = dynamicIPOperation.Wait(ctx); err != nil { return err } ``` Enable a **static public IP address** for a VM: ```go privateInstance2, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } if privateInstance2.GetSpec() == nil { return errors.New("instance spec is missing") } privateInstance2.Spec.NetworkInterfaces[0]. PublicIpAddress = &compute.PublicIPAddress{Static: true} staticIPOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: privateInstance2.Metadata, Spec: privateInstance2.Spec, }, ) if err != nil { return err } if _, err = staticIPOperation.Wait(ctx); err != nil { return err } ``` To assign an **already allocated public IP address** to a VM: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```go publicAllocationOperation, err := sdk.Services().VPC().V1(). Allocation().Create( ctx, &vpc.CreateAllocationRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &vpc.AllocationSpec{ IpSpec: &vpc.AllocationSpec_Ipv4Public{ Ipv4Public: &vpc.IPv4PublicAllocationSpec{ Pool: &vpc.IPv4PublicAllocationSpec_SubnetId{ SubnetId: "", }, }, }, }, }, ) if err != nil { return err } if _, err = publicAllocationOperation.Wait(ctx); err != nil { return err } allocationID := publicAllocationOperation.ResourceID() ``` 3. Assign this allocation to the VM: ```go privateInstance3, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } if privateInstance3.GetSpec() == nil { return errors.New("instance spec is missing") } privateInstance3.Spec.NetworkInterfaces[0]. PublicIpAddress = &compute.PublicIPAddress{ Allocation: &compute.PublicIPAddress_AllocationId{ AllocationId: "", }, } allocationIPOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: privateInstance3.Metadata, Spec: privateInstance3.Spec, }, ) if err != nil { return err } if _, err = allocationIPOperation.Wait(ctx); err != nil { return err } ``` Enable a **dynamic public IP address** for a VM: ```python instance_service = InstanceServiceClient(sdk) private_instance_1 = await instance_service.get( GetInstanceRequest(id=""), ) if private_instance_1.spec is None: raise ValueError("instance spec is missing") private_instance_1.spec.network_interfaces[0].public_ip_address = ( PublicIPAddress() ) dynamic_ip_operation = await instance_service.update( UpdateInstanceRequest( metadata=private_instance_1.metadata, spec=private_instance_1.spec, ), ) await dynamic_ip_operation.wait() ``` Enable a **static public IP address** for a VM: ```python instance_service = InstanceServiceClient(sdk) private_instance_2 = await instance_service.get( GetInstanceRequest(id=""), ) if private_instance_2.spec is None: raise ValueError("instance spec is missing") private_instance_2.spec.network_interfaces[0].public_ip_address = ( PublicIPAddress(static=True) ) static_ip_operation = await instance_service.update( UpdateInstanceRequest( metadata=private_instance_2.metadata, spec=private_instance_2.spec, ), ) await static_ip_operation.wait() ``` To assign an **already allocated public IP address** to a VM: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```python allocation_service = AllocationServiceClient(sdk) public_allocation_operation = await allocation_service.create( CreateAllocationRequest( metadata=ResourceMetadata(name=""), spec=AllocationSpec( ipv4_public=IPv4PublicAllocationSpec( subnet_id="", ), ), ), ) await public_allocation_operation.wait() allocation_id = public_allocation_operation.resource_id ``` 3. Assign this allocation to the VM: ```python instance_service = InstanceServiceClient(sdk) private_instance_3 = await instance_service.get( GetInstanceRequest(id=""), ) if private_instance_3.spec is None: raise ValueError("instance spec is missing") private_instance_3.spec.network_interfaces[0].public_ip_address = ( PublicIPAddress(allocation_id="") ) allocation_ip_operation = await instance_service.update( UpdateInstanceRequest( metadata=private_instance_3.metadata, spec=private_instance_3.spec, ), ) await allocation_ip_operation.wait() ``` Enable a **dynamic public IP address** for a VM: ```ts const dynamicIpService = new InstanceService(sdk); const privateInstance1 = await dynamicIpService.get( GetInstanceRequest.create({ id: "", }), ); if (!privateInstance1.spec) { throw new Error("instance spec is missing"); } privateInstance1.spec.networkInterfaces[0].publicIpAddress = PublicIPAddress.create({}); const dynamicIpOperation = await dynamicIpService.update( UpdateInstanceRequest.create({ metadata: privateInstance1.metadata, spec: privateInstance1.spec, }), ).result; await dynamicIpOperation.wait(); ``` Enable a **static public IP address** for a VM: ```ts const staticIpService = new InstanceService(sdk); const privateInstance2 = await staticIpService.get( GetInstanceRequest.create({ id: "", }), ); if (!privateInstance2.spec) { throw new Error("instance spec is missing"); } privateInstance2.spec.networkInterfaces[0].publicIpAddress = PublicIPAddress.create({ static: true, }); const staticIpOperation = await staticIpService.update( UpdateInstanceRequest.create({ metadata: privateInstance2.metadata, spec: privateInstance2.spec, }), ).result; await staticIpOperation.wait(); ``` To assign an **already allocated public IP address** to a VM: 1. Get the [subnet ID](https://docs.nebius.com/vpc/networking/resources.md#how-to-get-a-subnet-id) for the VM. 2. Create an allocation that reserves a static public address: ```ts const publicAllocationService = new AllocationService(sdk); const publicAllocationOperation = await publicAllocationService.create( CreateAllocationRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: AllocationSpec.create({ ipSpec: { $case: "ipv4Public", ipv4Public: IPv4PublicAllocationSpec.create({ pool: { $case: "subnetId", subnetId: "", }, }), }, }), }), ).result; await publicAllocationOperation.wait(); const allocationId = publicAllocationOperation.resourceId(); ``` 3. Assign this allocation to the VM: ```ts const allocationIpService = new InstanceService(sdk); const privateInstance3 = await allocationIpService.get( GetInstanceRequest.create({ id: "", }), ); if (!privateInstance3.spec) { throw new Error("instance spec is missing"); } privateInstance3.spec.networkInterfaces[0].publicIpAddress = PublicIPAddress.create({ allocation: { $case: "allocationId", allocationId: "", }, }); const allocationIpOperation = await allocationIpService.update( UpdateInstanceRequest.create({ metadata: privateInstance3.metadata, spec: privateInstance3.spec, }), ).result; await allocationIpOperation.wait(); ``` ### How to get a VM's public IP address 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. On the **Standalone VMs** tab, open the page of the required VM. 3. Copy the **Public IPv4** value from the **Network** block. ```bash export PUBLIC_IP_ADDRESS=$(nebius compute instance get-by-name \ --name \ --format json \ | jq -r '.status.network_interfaces[0].public_ip_address.address | split("/")[0]') echo $PUBLIC_IP_ADDRESS ``` ```go publicIPInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "", }, ) if err != nil { return err } publicAddress := publicIPInstance.GetStatus(). GetNetworkInterfaces()[0].GetPublicIpAddress().GetAddress() publicIPAddress := strings.Split(publicAddress, "/")[0] fmt.Println(publicIPAddress) ``` ```python instance_service = InstanceServiceClient(sdk) public_ip_instance = await instance_service.get_by_name( GetByNameRequest(name=""), ) public_address = ( public_ip_instance.status.network_interfaces[0] .public_ip_address.address ) public_ip_address = public_address.split("/")[0] print(public_ip_address) ``` ```ts const publicIpLookupService = new InstanceService(sdk); const publicIpInstance = await publicIpLookupService.getByName( GetByNameRequest.create({ name: "", }), ); const publicAddress = publicIpInstance.status ?.networkInterfaces[0]?.publicIpAddress?.address; const publicIpAddress = publicAddress?.split("/")[0]; console.log(publicIpAddress); ``` ### How to migrate a public static IP address from one VM to another To reassign a public static IP address from one VM to another, detach this address from the source VM and attach it to the target VM. Before you begin, make sure that you have a VM with a public static IP address (the source VM) and a VM without a public address (the target VM). For information about creating VMs, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md). To migrate the address, do the following: 1. To get IDs of the source and target VMs, list all VMs: ```bash nebius compute instance list ``` 2. Store the VMs' IDs in environment variables: ```bash SOURCE_VM="" TARGET_VM="" ``` 3. Extract the allocation ID of the public static IP address currently attached to the source VM. This value is required to reassign the IP address to another VM. ```bash ALLOC_ID=$(nebius compute instance get \ --id "$SOURCE_VM" \ --format json | jq -r '.status.network_interfaces[] | select(.name=="eth0") | .public_ip_address.allocation_id') ``` 4. Pin the allocation in the source VM specification. This prevents the allocation from being deleted when you detach it in the next step. ```bash nebius compute instance update --patch \ --id "$SOURCE_VM" \ "$(jq -n --arg alloc "$ALLOC_ID" '{"spec":{"network_interfaces":[{"name":"eth0","public_ip_address":{"static":true,"allocation_id":$alloc}}]}}')" ``` 5. Remove the public IP address from the source VM. This makes the allocation available for reuse. ```bash nebius compute instance update --patch \ --id "$SOURCE_VM" \ '{"spec":{"network_interfaces": [{"name":"eth0","public_ip_address":null}]}}' ``` 6. Assign the same allocation ID to the target VM: ```bash nebius compute instance update --patch \ --id "$TARGET_VM" \ "$(jq -n --arg alloc "$ALLOC_ID" '{"spec":{"network_interfaces": [{"name":"eth0","public_ip_address":{"static":true,"allocation_id":$alloc}}]}}')" ``` The output of this command shows that the allocation is attached to the target VM. 1. To get IDs of the source and target VMs, list all VMs: ```go instances, err := sdk.Services().Compute().V1(). Instance().List( ctx, &compute.ListInstancesRequest{}, ) if err != nil { return err } fmt.Println(instances) ``` 2. Set `sourceVM` to the ID of the source VM and `targetVM` to the ID of the target VM. 3. Extract the allocation ID of the public static IP address currently attached to the source VM. This value is required to reassign the IP address to another VM. ```go sourceInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: sourceVM, }, ) if err != nil { return err } allocID := sourceInstance.GetStatus(). GetNetworkInterfaces()[0].GetPublicIpAddress().GetAllocationId() if allocID == "" { return errors.New("allocation ID is missing") } ``` 4. Pin the allocation in the source VM specification. This prevents the allocation from being deleted when you detach it in the next step. ```go sourceInstanceForPin, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: sourceVM, }, ) if err != nil { return err } if sourceInstanceForPin.GetSpec() == nil { return errors.New("instance spec is missing") } sourceInstanceForPin.Spec.NetworkInterfaces[0]. PublicIpAddress = &compute.PublicIPAddress{ Static: true, Allocation: &compute.PublicIPAddress_AllocationId{ AllocationId: allocID, }, } pinAllocationOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: sourceInstanceForPin.Metadata, Spec: sourceInstanceForPin.Spec, }, ) if err != nil { return err } if _, err = pinAllocationOperation.Wait(ctx); err != nil { return err } ``` 5. Remove the public IP address from the source VM. This makes the allocation available for reuse. ```go removeInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: sourceVM, }, ) if err != nil { return err } if removeInstance.GetSpec() == nil { return errors.New("instance spec is missing") } removeInstance.Spec.NetworkInterfaces[0]. PublicIpAddress = nil removeAddressOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: removeInstance.Metadata, Spec: removeInstance.Spec, }, ) if err != nil { return err } if _, err = removeAddressOperation.Wait(ctx); err != nil { return err } ``` 6. Assign the same allocation ID to the target VM: ```go assignInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: targetVM, }, ) if err != nil { return err } if assignInstance.GetSpec() == nil { return errors.New("instance spec is missing") } assignInstance.Spec.NetworkInterfaces[0]. PublicIpAddress = &compute.PublicIPAddress{ Static: true, Allocation: &compute.PublicIPAddress_AllocationId{ AllocationId: allocID, }, } assignAddressOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: assignInstance.Metadata, Spec: assignInstance.Spec, }, ) if err != nil { return err } if _, err = assignAddressOperation.Wait(ctx); err != nil { return err } ``` 1. To get IDs of the source and target VMs, list all VMs: ```python instance_service = InstanceServiceClient(sdk) instances = await instance_service.list(ListInstancesRequest()) print(instances) ``` 2. Set `source_vm` to the ID of the source VM and `target_vm` to the ID of the target VM. 3. Extract the allocation ID of the public static IP address currently attached to the source VM. This value is required to reassign the IP address to another VM. ```python instance_service = InstanceServiceClient(sdk) source_instance = await instance_service.get( GetInstanceRequest(id=source_vm), ) alloc_id = ( source_instance.status.network_interfaces[0] .public_ip_address.allocation_id ) if not alloc_id: raise ValueError("allocation ID is missing") ``` 4. Pin the allocation in the source VM specification. This prevents the allocation from being deleted when you detach it in the next step. ```python instance_service = InstanceServiceClient(sdk) source_instance_for_pin = await instance_service.get( GetInstanceRequest(id=source_vm), ) if source_instance_for_pin.spec is None: raise ValueError("instance spec is missing") source_interfaces = source_instance_for_pin.spec.network_interfaces source_interfaces[0].public_ip_address = ( PublicIPAddress(static=True, allocation_id=alloc_id) ) pin_operation = await instance_service.update( UpdateInstanceRequest( metadata=source_instance_for_pin.metadata, spec=source_instance_for_pin.spec, ), ) await pin_operation.wait() ``` 5. Remove the public IP address from the source VM. This makes the allocation available for reuse. ```python instance_service = InstanceServiceClient(sdk) source_instance_for_removal = await instance_service.get( GetInstanceRequest(id=source_vm), ) if source_instance_for_removal.spec is None: raise ValueError("instance spec is missing") source_instance_for_removal.spec.network_interfaces[ 0 ].public_ip_address = None remove_address_operation = await instance_service.update( UpdateInstanceRequest( metadata=source_instance_for_removal.metadata, spec=source_instance_for_removal.spec, ), ) await remove_address_operation.wait() ``` 6. Assign the same allocation ID to the target VM: ```python instance_service = InstanceServiceClient(sdk) target_instance = await instance_service.get( GetInstanceRequest(id=target_vm), ) if target_instance.spec is None: raise ValueError("instance spec is missing") target_instance.spec.network_interfaces[0].public_ip_address = ( PublicIPAddress(static=True, allocation_id=alloc_id) ) assign_address_operation = await instance_service.update( UpdateInstanceRequest( metadata=target_instance.metadata, spec=target_instance.spec, ), ) await assign_address_operation.wait() ``` 1. To get IDs of the source and target VMs, list all VMs: ```ts const listInstanceService = new InstanceService(sdk); const instances = await listInstanceService.list( ListInstancesRequest.create({}), ); console.log(instances); ``` 2. Set `sourceVm` to the ID of the source VM and `targetVm` to the ID of the target VM. 3. Extract the allocation ID of the public static IP address currently attached to the source VM. This value is required to reassign the IP address to another VM. ```ts const sourceInstanceService = new InstanceService(sdk); const sourceInstance = await sourceInstanceService.get( GetInstanceRequest.create({ id: sourceVm, }), ); const allocId = sourceInstance.status ?.networkInterfaces[0]?.publicIpAddress?.allocationId; if (!allocId) { throw new Error("allocation ID is missing"); } ``` 4. Pin the allocation in the source VM specification. This prevents the allocation from being deleted when you detach it in the next step. ```ts const pinAllocationService = new InstanceService(sdk); const sourceInstanceForPin = await pinAllocationService.get( GetInstanceRequest.create({ id: sourceVm, }), ); if (!sourceInstanceForPin.spec) { throw new Error("instance spec is missing"); } sourceInstanceForPin.spec.networkInterfaces[0].publicIpAddress = PublicIPAddress.create({ static: true, allocation: { $case: "allocationId", allocationId: allocId, }, }); const pinAllocationOperation = await pinAllocationService.update( UpdateInstanceRequest.create({ metadata: sourceInstanceForPin.metadata, spec: sourceInstanceForPin.spec, }), ).result; await pinAllocationOperation.wait(); ``` 5. Remove the public IP address from the source VM. This makes the allocation available for reuse. ```ts const removeAddressService = new InstanceService(sdk); const sourceInstanceForRemoval = await removeAddressService.get( GetInstanceRequest.create({ id: sourceVm, }), ); if (!sourceInstanceForRemoval.spec) { throw new Error("instance spec is missing"); } sourceInstanceForRemoval.spec.networkInterfaces[0].publicIpAddress = undefined; const removeAddressOperation = await removeAddressService.update( UpdateInstanceRequest.create({ metadata: sourceInstanceForRemoval.metadata, spec: sourceInstanceForRemoval.spec, }), ).result; await removeAddressOperation.wait(); ``` 6. Assign the same allocation ID to the target VM: ```ts const assignAddressService = new InstanceService(sdk); const targetInstance = await assignAddressService.get( GetInstanceRequest.create({ id: targetVm, }), ); if (!targetInstance.spec) { throw new Error("instance spec is missing"); } targetInstance.spec.networkInterfaces[0].publicIpAddress = PublicIPAddress.create({ static: true, allocation: { $case: "allocationId", allocationId: allocId, }, }); const assignAddressOperation = await assignAddressService.update( UpdateInstanceRequest.create({ metadata: targetInstance.metadata, spec: targetInstance.spec, }), ).result; await assignAddressOperation.wait(); ``` ## How to detach an IP address from a VM To detach a public address or a secondary private address from a VM: 1. In the [web console](https://console.nebius.com), go to **Compute** → **Virtual machines**. 2. On the **Standalone VMs** tab, open the page of the required VM and then go to the **Network interface** tab. 3. In the line of the allocation that you want to detach from a VM, click → **Detach**. 4. In the window that opens, confirm the action. To detach a public IP address, set the `SOURCE_VM` environment variable to the VM ID and run the following command: ```bash nebius compute instance update --patch \ --id "$SOURCE_VM" \ '{"spec":{"network_interfaces": [{"name":"eth0","public_ip_address":null}]}}' ``` To detach a secondary private IP address, run the following command: ```bash nebius compute instance update \ --id \ --network-interfaces "[{\"aliases\": []}]" ``` If the VM has several secondary private IP addresses, keep the aliases that you do not want to detach in the `aliases` list. To detach a public IP address, set `sourceVM` to the VM ID: ```go removeInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: sourceVM, }, ) if err != nil { return err } if removeInstance.GetSpec() == nil { return errors.New("instance spec is missing") } removeInstance.Spec.NetworkInterfaces[0]. PublicIpAddress = nil removeAddressOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: removeInstance.Metadata, Spec: removeInstance.Spec, }, ) if err != nil { return err } if _, err = removeAddressOperation.Wait(ctx); err != nil { return err } ``` Detach a secondary private IP address: ```go detachAliasInstance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } if detachAliasInstance.GetSpec() == nil { return errors.New("instance spec is missing") } detachNetworkInterfaces := detachAliasInstance.Spec.NetworkInterfaces aliases := detachNetworkInterfaces[0].Aliases[:0] for _, alias := range detachNetworkInterfaces[0].Aliases { if alias.GetAllocationId() != "" { aliases = append(aliases, alias) } } detachNetworkInterfaces[0].Aliases = aliases detachAliasOperation, err := sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: detachAliasInstance.Metadata, Spec: detachAliasInstance.Spec, }, ) if err != nil { return err } if _, err = detachAliasOperation.Wait(ctx); err != nil { return err } ``` To detach a public IP address, set `source_vm` to the VM ID: ```python instance_service = InstanceServiceClient(sdk) source_instance_for_removal = await instance_service.get( GetInstanceRequest(id=source_vm), ) if source_instance_for_removal.spec is None: raise ValueError("instance spec is missing") source_instance_for_removal.spec.network_interfaces[ 0 ].public_ip_address = None remove_address_operation = await instance_service.update( UpdateInstanceRequest( metadata=source_instance_for_removal.metadata, spec=source_instance_for_removal.spec, ), ) await remove_address_operation.wait() ``` Detach a secondary private IP address: ```python instance_service = InstanceServiceClient(sdk) detach_alias_instance = await instance_service.get( GetInstanceRequest(id=""), ) if detach_alias_instance.spec is None: raise ValueError("instance spec is missing") aliases = detach_alias_instance.spec.network_interfaces[0].aliases detach_alias_instance.spec.network_interfaces[0].aliases = [ alias for alias in aliases if alias.allocation_id != "" ] detach_alias_operation = await instance_service.update( UpdateInstanceRequest( metadata=detach_alias_instance.metadata, spec=detach_alias_instance.spec, ), ) await detach_alias_operation.wait() ``` To detach a public IP address, set `sourceVm` to the VM ID: ```ts const removeAddressService = new InstanceService(sdk); const sourceInstanceForRemoval = await removeAddressService.get( GetInstanceRequest.create({ id: sourceVm, }), ); if (!sourceInstanceForRemoval.spec) { throw new Error("instance spec is missing"); } sourceInstanceForRemoval.spec.networkInterfaces[0].publicIpAddress = undefined; const removeAddressOperation = await removeAddressService.update( UpdateInstanceRequest.create({ metadata: sourceInstanceForRemoval.metadata, spec: sourceInstanceForRemoval.spec, }), ).result; await removeAddressOperation.wait(); ``` Detach a secondary private IP address: ```ts const detachAliasService = new InstanceService(sdk); const detachAliasInstance = await detachAliasService.get( GetInstanceRequest.create({ id: "", }), ); if (!detachAliasInstance.spec) { throw new Error("instance spec is missing"); } const aliases = detachAliasInstance.spec.networkInterfaces[0].aliases ?? []; detachAliasInstance.spec.networkInterfaces[0].aliases = aliases.filter( (alias) => alias.allocationId !== "", ); const detachAliasOperation = await detachAliasService.update( UpdateInstanceRequest.create({ metadata: detachAliasInstance.metadata, spec: detachAliasInstance.spec, }), ).result; await detachAliasOperation.wait(); ``` # Tuning TCP window sizes on Linux virtual machines Source: https://docs.nebius.com/compute/virtual-machines/tcp-window-tuning.md TCP throughput depends on how much unacknowledged data a sender and receiver can keep in flight. On long-distance or high-latency connections, the default Linux TCP buffer limits can constrain a single flow before the network link is saturated. This article shows how to increase TCP receive and send window limits on a Linux virtual machine (VM) in Nebius AI Cloud. Use this tuning if your workload transfers large amounts of data over connections with both: * High bandwidth * Noticeable round-trip latency Typical examples include: * Cross-region replication * Large model or dataset transfers * Long-lived TCP sessions that need higher per-flow throughput If your traffic is short-lived, latency-sensitive, or limited by the application rather than the network path, this tuning may have little effect. ## Recommended values The following settings increase the maximum TCP buffer sizes while keeping default behavior unchanged: ```text net.ipv4.tcp_rmem = 4096 131072 268435456 net.ipv4.tcp_wmem = 4096 16384 268435456 net.core.rmem_max = 536870912 net.core.wmem_max = 536870912 net.ipv4.tcp_adv_win_scale = 1 ``` These values keep the minimum and default TCP buffer settings close to the Linux defaults, while increasing the maximum values for high-bandwidth links. The recommended maximum TCP window targets a single flow of about 3 Gbit/s over a 300 ms round-trip-time path. That bandwidth-delay product is about 108 MB, which is rounded up to 128 MiB and then doubled to account for the effect of `net.ipv4.tcp_adv_win_scale=1`. Larger TCP buffers can increase memory consumption under heavy connection fan-out. Verify available memory before applying this tuning on smaller VMs or on hosts with many simultaneous high-throughput flows. ## How to tune TCP window sizes ### Prerequisites Make sure that: 1. The VM runs Linux. 2. You can connect to the VM by using SSH. For more information, see [How to connect to virtual machines in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/connect.md). 3. You have `sudo` privileges on the VM. ### Apply the changes 1. Connect to the VM: ```bash ssh @ ``` 2. Create a sysctl configuration file: ```bash sudo tee /etc/sysctl.d/90-nebius-tcp-window.conf >/dev/null <<'EOF' net.ipv4.tcp_rmem = 4096 131072 268435456 net.ipv4.tcp_wmem = 4096 16384 268435456 net.core.rmem_max = 536870912 net.core.wmem_max = 536870912 net.ipv4.tcp_adv_win_scale = 1 EOF ``` 3. Apply the configuration: ```bash sudo sysctl --system ``` ### Verify the configuration Check that the VM reports the configured values: ```bash sysctl \ net.ipv4.tcp_rmem \ net.ipv4.tcp_wmem \ net.core.rmem_max \ net.core.wmem_max \ net.ipv4.tcp_adv_win_scale ``` Expected output: ```text net.ipv4.tcp_rmem = 4096 131072 268435456 net.ipv4.tcp_wmem = 4096 16384 268435456 net.core.rmem_max = 536870912 net.core.wmem_max = 536870912 net.ipv4.tcp_adv_win_scale = 1 ``` If your application still does not reach the expected throughput, check the end-to-end path for other limits such as application-level buffer sizing, rate limiting, packet loss or congestion on the remote side. ### Roll back the changes To remove the configuration: ```bash sudo rm /etc/sysctl.d/90-nebius-tcp-window.conf sudo sysctl --system ``` After rollback, the VM uses the remaining sysctl configuration from the operating system image and any other files in `/etc/sysctl.d`. # FQDN and hostname of a virtual machine Source: https://docs.nebius.com/compute/virtual-machines/fqdn.md When you create a virtual machine (VM), the service assigns an [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) to this VM. By using this FQDN, other VMs can access your VM within a single [network](https://docs.nebius.com/vpc/overview.md#network). You can configure the FQDN on your own or you can use the default FQDN: * The format of the default FQDN is the following: ```text ..compute.internal. ``` In this case, the FQDN (as well as the VM's ID) is only known after the VM is created. * The format of a custom FQDN is the following: ```text ..compute.internal. ``` You can [set the hostname](https://docs.nebius.com/compute/virtual-machines/fqdn.md#how-to-customize-an-fqdn) when you create or update a VM. You can configure an FQDN, but you cannot delete it. The guest OS hostname of the VM is set up during the VM creation; it matches the FQDN. If the FQDN is changed later, the guest OS hostname does not change; and it remains the same as the FQDN was when the VM was created. ## Prerequisites [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to get an FQDN To get an FQDN of a VM, run the following command: ```bash nebius compute instance get-by-name \ --name \ --format json \ | jq -r '.status.network_interfaces[0].fqdn | split("/")[0]' ``` The FQDN is specified in the `status.network_interfaces.fqdn` field of the output. Get an FQDN of a VM: ```go fqdnInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "", }, ) if err != nil { return err } fqdn := fqdnInstance.GetStatus().GetNetworkInterfaces()[0].GetFqdn() fmt.Println(strings.Split(fqdn, "/")[0]) ``` Get an FQDN of a VM: ```python fqdn_service = InstanceServiceClient(sdk) fqdn_instance = await fqdn_service.get_by_name( GetByNameRequest(name=""), ) fqdn = fqdn_instance.status.network_interfaces[0].fqdn print(fqdn.split("/")[0]) ``` Get an FQDN of a VM: ```ts const fqdnInstanceService = new InstanceService(sdk); const fqdnInstance = await fqdnInstanceService.getByName( GetByNameRequest.create({ name: "", }), ); const fqdn = fqdnInstance.status?.networkInterfaces[0]?.fqdn; console.log(fqdn?.split("/")[0]); ``` ## How to customize an FQDN If you do not want to use the default FQDN, you can use your own hostname instead of the VM's ID. To customize an FQDN, use the `hostname` parameter: * [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with a customized FQDN: ```bash nebius compute instance create \ ... \ --hostname ``` * Change an FQDN of an existing VM: ```bash nebius compute instance update --id --hostname ``` Use the following VM configuration: ```hcl resource "nebius_compute_v1_instance" "my_vm" { ... hostname = "" ... } ``` For more information, see [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). * [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with a customized FQDN: ```go instanceOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "vm-for-scenario", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "cpu-d3", Size: &compute.ResourcesSpec_Preset{ Preset: "4vcpu-16gb", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, DeviceId: "my-device", Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: bootDiskID, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, }, }, Hostname: "", }, }, ) if err != nil { return err } if _, err = instanceOperation.Wait(ctx); err != nil { return err } vmID := instanceOperation.ResourceID() ``` * Change an FQDN of an existing VM: ```go instance, err = sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "", }, ) if err != nil { return err } if instance.GetSpec() == nil { return errors.New("instance spec is missing") } instance.Spec.Hostname = "" instanceOperation, err = sdk.Services().Compute().V1(). Instance().Update( ctx, &compute.UpdateInstanceRequest{ Metadata: instance.Metadata, Spec: instance.Spec, }, ) if err != nil { return err } if _, err = instanceOperation.Wait(ctx); err != nil { return err } ``` * [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with a customized FQDN: ```python instance_service = InstanceServiceClient(sdk) create_instance_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name="vm-for-scenario"), spec=InstanceSpec( resources=ResourcesSpec( platform="cpu-d3", preset="4vcpu-16gb", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=boot_disk_id), device_id="my-device", ), network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], hostname="", ), ), ) await create_instance_operation.wait() vm_id = create_instance_operation.resource_id ``` * Change an FQDN of an existing VM: ```python instance_service = InstanceServiceClient(sdk) instance = await instance_service.get( GetInstanceRequest(id=""), ) if instance.spec is None: raise ValueError("instance spec is missing") instance.spec.hostname = "" update_instance_operation = await instance_service.update( UpdateInstanceRequest( metadata=instance.metadata, spec=instance.spec, ), ) await update_instance_operation.wait() ``` * [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with a customized FQDN: ```ts const instanceService = new InstanceService(sdk); const createInstanceOperation = await instanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "vm-for-scenario", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "cpu-d3", size: { $case: "preset", preset: "4vcpu-16gb", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, deviceId: "my-device", type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: bootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId: subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], hostname: "", }), }), ).result; await createInstanceOperation.wait(); const vmId = createInstanceOperation.resourceId(); ``` * Change an FQDN of an existing VM: ```ts const updateInstanceService = new InstanceService(sdk); const instanceForHostname = await updateInstanceService.get( GetInstanceRequest.create({ id: "", }), ); if (!instanceForHostname.spec) { throw new Error("instance spec is missing"); } instanceForHostname.spec.hostname = ""; const updateInstanceOperation = await updateInstanceService.update( UpdateInstanceRequest.create({ metadata: instanceForHostname.metadata, spec: instanceForHostname.spec, }), ).result; await updateInstanceOperation.wait(); ``` The hostname must be unique, and it cannot contain a full stop (`.`). For example, if you set `hostname` to `my-host`, the FQDN is the following: ```text my-host.vpcnetwork-e00***.compute.internal. ``` If you do not set `hostname`, the VM's ID is used instead of the hostname, according to the default FQDN. # How to generate SSH keys Source: https://docs.nebius.com/compute/virtual-machines/ssh-keys.md An *SSH key pair* is used to authenticate with a remote resource over SSH. It consists of: * A *public key* that you add to the resource or share with an administrator. * A *private key* that you keep on your local machine and use when connecting. You need an SSH key pair to: * Configure SSH access when [creating a virtual machine (VM)](https://docs.nebius.com/compute/virtual-machines/manage.md) and to [connect to your Compute VM](https://docs.nebius.com/compute/virtual-machines/connect.md) over SSH. * [Create a container VM](https://docs.nebius.com/compute/virtual-machines/containers.md). * [Give another user access to a VM](https://docs.nebius.com/compute/virtual-machines/connect.md#shared-access-to-the-vm). * [Connect to login and worker nodes in a Soperator cluster](https://docs.nebius.com/slurm-soperator/clusters/connect.md). * [Access a VM through a jump server](https://docs.nebius.com/compute/virtual-machines/wireguard.md) when the VM does not have a public IP address. ## Generating a key pair 1. In the terminal, create the `.ssh` directory if it does not exist: ```bash mkdir -p ~/.ssh chmod 700 ~/.ssh ``` 2. Go to the `~/.ssh` directory: ```bash cd ~/.ssh ``` 3. Generate an SSH key pair: ```bash ssh-keygen -t ed25519 ``` * To add a comment that identifies the key, add the optional `-C` parameter: ```bash ssh-keygen -t ed25519 -C "" ``` 4. When prompted, enter the file path where you want to save the key pair. * To save the key pair to the default location, press `Enter`. * If you already have a key in the default location, specify a custom file name, for example: ```bash /home//.ssh/nebius_ed25519 ``` 5. (Optional) When prompted, enter a passphrase for the private key. Press `Enter` to generate a key without a passphrase. However, using a passphrase protects the private key if someone gets access to your local machine. 6. Repeat the passphrase when prompted. The command creates two files: * The private key, for example `~/.ssh/id_ed25519`. * The public key, for example `~/.ssh/id_ed25519.pub`. ## Getting the public key You need the contents of the public key when a resource or configuration asks for an SSH public key. For example, you can add it to a VM to configure SSH access or send it to an administrator who manages access to the resource. To get the contents of the public key, run: ```bash cat ~/.ssh/id_ed25519.pub ``` If you saved the public key to a custom file when you generated the key, specify the name with the `.pub` extension: ```bash cat ~/.ssh/.pub ``` The output contains the contents of the public key, for example: ```text ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI*** user@example.com ``` ## Protecting the private key Follow these recommendations when using SSH keys: * Keep the private key only on your local machine and don't share it with others. * Share only the public key, which is stored in the file with the `.pub` extension. * Use a passphrase for the private key. * Use a separate key pair for each user. * Remove public keys that are no longer used from the resource. # How to connect to virtual machines in Nebius AI Cloud Source: https://docs.nebius.com/compute/virtual-machines/connect.md Safe connection to the VM over SSH uses a key pair: you place the public key on the VM and store the private key on your device. ## Prerequisites [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## Set up the VM To be able to connect to the VM, define specific information during the [VM creation](https://docs.nebius.com/compute/virtual-machines/manage.md). ### Generate a key pair Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You will need the [contents of the public key](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md#getting-the-public-key) and the path to your private key in later steps. ### Configure the user data User configuration helps to quickly create VMs with identical user data: it stores your username and the public key for the access to the VM. Create a configuration in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format: ```bash export USER_DATA=$(jq -Rrs '.' < Define `userData` as a string in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format: ```go publicKeyBytes, err := os.ReadFile( os.ExpandEnv("$HOME/.ssh/id_ed25519.pub"), ) if err != nil { return err } publicKey := strings.TrimSpace(string(publicKeyBytes)) userData := "#cloud-config\nusers:\n" + " - name: user\n" + " sudo: ALL=(ALL) NOPASSWD:ALL\n" + " shell: /bin/bash\n" + " ssh_authorized_keys:\n" + " - " + publicKey ``` The configuration contains the following parameters: * `name`: Username for connecting to the VM. The example sets `user`; replace it with your username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. To create the key pair, follow the instructions in [Generating SSH keys](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). Pass `userData` to `InstanceSpec.CloudInitUserData` when you create the VM. Define `user_data` as a string in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format: ```python public_key = ( Path.home() .joinpath(".ssh/id_ed25519.pub") .read_text() .strip() ) user_data = "\n".join( [ "#cloud-config", "users:", " - name: user", " sudo: ALL=(ALL) NOPASSWD:ALL", " shell: /bin/bash", " ssh_authorized_keys:", f" - {public_key}", ], ) ``` The configuration contains the following parameters: * `name`: Username for connecting to the VM. The example sets `user`; replace it with your username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. To create the key pair, follow the instructions in [Generating SSH keys](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). Pass `user_data` to `InstanceSpec.cloud_init_user_data` when you create the VM. Define `userData` as a string in the [cloud-init](https://cloudinit.readthedocs.io/en/latest/reference/modules.html#users-and-groups) format: ```ts const publicKey = readFileSync( `${process.env.HOME}/.ssh/id_ed25519.pub`, "utf8", ).trim(); const userData = [ "#cloud-config", "users:", " - name: user", " sudo: ALL=(ALL) NOPASSWD:ALL", " shell: /bin/bash", " ssh_authorized_keys:", ` - ${publicKey}`, ].join("\n"); ``` The configuration contains the following parameters: * `name`: Username for connecting to the VM. The example sets `user`; replace it with your username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and are not allowed to connect to a VM by SSH. * `sudo`: Sudo policy. `ALL=(ALL) NOPASSWD:ALL` allows users unrestricted sudo access; `False` disables sudo access for users. * `shell`: Default shell. * `ssh_authorized_keys`: User's authorized keys. Allows configuring SSH access to the VM. To create the key pair, follow the instructions in [Generating SSH keys](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). You can specify several users and their public SSH keys. For more information, see [cloud-init configuration examples](https://cloudinit.readthedocs.io/en/latest/reference/examples.html). Pass `userData` to `InstanceSpec.cloudInitUserData` when you create the VM. ### Configure the VM When you [create the VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), specify the user data, network settings and boot disk: In the `nebius compute instance create` command, set the following parameters: * `--cloud-init-user-data`: Pass the user data with your username and public key. * `--network-interfaces`: To enable public access to the VM, include `"public_ip_address": {}` in the network interface specification. Alternatively, to enable public access to the VM, set `"public_ip_address": {"allocation_id": ""}` with an [allocation](https://docs.nebius.com/vpc/overview.md#allocation) ID. This way the public IP address is preserved as an allocation object and you can reuse it for another VM after deleting this one. 1. Get the default subnet's ID: ```bash export SUBNET_ID=$(nebius vpc subnet list \ --format json \ | jq -r ".items[0].metadata.id") ``` 2. Create an [allocation](https://docs.nebius.com/vpc/overview.md#allocation) by using the default subnet's ID: ```bash export ALLOCATION_ID=$(nebius vpc allocation create \ --ipv4-public-subnet-id $SUBNET_ID \ --name allocation-name \ --format json \ | jq -r ".metadata.id") ``` If an allocation with a public address has not been assigned to any resource for 30 days, Nebius AI Cloud can delete this allocation and release its address. If you want to preserve the address, assign its allocation to a Nebius AI Cloud resource. Example: ```bash nebius compute instance create \ --name inference-vm \ --resources-platform \ --resources-preset \ --boot-disk-existing-disk-id \ --boot-disk-attach-mode READ_WRITE \ --cloud-init-user-data "$USER_DATA" \ --network-interfaces '[{"name": "eth0", "subnet_id": "", "ip_address": {}, "public_ip_address": {"allocation_id": ""}}]' ``` 1. Get the subnet ID: ```go subnets, err := sdk.Services().VPC().V1(). Subnet().List( ctx, &vpc.ListSubnetsRequest{}, ) if err != nil { return err } if len(subnets.GetItems()) == 0 { return errors.New("no subnets found") } subnetID := subnets.GetItems()[0].GetMetadata().GetId() ``` 2. Create a public allocation: ```go allocationOperation, err := sdk.Services().VPC().V1(). Allocation().Create( ctx, &vpc.CreateAllocationRequest{ Metadata: &common.ResourceMetadata{ Name: "allocation-name", }, Spec: &vpc.AllocationSpec{ IpSpec: &vpc.AllocationSpec_Ipv4Public{ Ipv4Public: &vpc.IPv4PublicAllocationSpec{ Pool: &vpc.IPv4PublicAllocationSpec_SubnetId{ SubnetId: subnetID, }, }, }, }, }, ) if err != nil { return err } if _, err = allocationOperation.Wait(ctx); err != nil { return err } allocationID := allocationOperation.ResourceID() ``` 3. Set the platform, preset, existing boot disk ID and cloud-init user data: ```go publicAllocation := &compute.PublicIPAddress_AllocationId{ AllocationId: allocationID, } instanceOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "inference-vm", }, Spec: &compute.InstanceSpec{ Resources: &compute.ResourcesSpec{ Platform: "", Size: &compute.ResourcesSpec_Preset{ Preset: "", }, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: compute.AttachedDiskSpec_READ_WRITE, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: "", }, }, }, CloudInitUserData: userData, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "eth0", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{ Allocation: publicAllocation, }, }, }, }, }, ) if err != nil { return err } if _, err = instanceOperation.Wait(ctx); err != nil { return err } ``` 1. Get the subnet ID: ```python subnet_service = SubnetServiceClient(sdk) subnets = await subnet_service.list(ListSubnetsRequest()) if not subnets.items: raise ValueError("no subnets found") subnet_id = subnets.items[0].metadata.id ``` 2. Create a public allocation: ```python allocation_service = AllocationServiceClient(sdk) allocation_operation = await allocation_service.create( CreateAllocationRequest( metadata=ResourceMetadata(name="allocation-name"), spec=AllocationSpec( ipv4_public=IPv4PublicAllocationSpec( subnet_id=subnet_id, ), ), ), ) await allocation_operation.wait() allocation_id = allocation_operation.resource_id ``` 3. Set the platform, preset, existing boot disk ID and cloud-init user data: ```python instance_service = InstanceServiceClient(sdk) create_instance_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata(name="inference-vm"), spec=InstanceSpec( resources=ResourcesSpec( platform="", preset="", ), boot_disk=AttachedDiskSpec( attach_mode=AttachedDiskSpec.AttachMode.READ_WRITE, existing_disk=ExistingDisk(id=""), ), cloud_init_user_data=user_data, network_interfaces=[ NetworkInterfaceSpec( name="eth0", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress( allocation_id=allocation_id, ), ), ], ), ), ) await create_instance_operation.wait() ``` 1. Get the subnet ID: ```ts const subnetService = new SubnetService(sdk); const subnets = await subnetService.list( ListSubnetsRequest.create({}), ); const subnetId = subnets.items[0]?.metadata?.id; if (!subnetId) { throw new Error("no subnets found"); } ``` 2. Create a public allocation: ```ts const allocationService = new AllocationService(sdk); const allocationOperation = await allocationService.create( CreateAllocationRequest.create({ metadata: ResourceMetadata.create({ name: "allocation-name", }), spec: AllocationSpec.create({ ipSpec: { $case: "ipv4Public", ipv4Public: IPv4PublicAllocationSpec.create({ pool: { $case: "subnetId", subnetId, }, }), }, }), }), ).result; await allocationOperation.wait(); const allocationId = allocationOperation.resourceId(); ``` 3. Set the platform, preset, existing boot disk ID and cloud-init user data: ```ts const connectInstanceService = new InstanceService(sdk); const connectInstanceOperation = await connectInstanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "inference-vm", }), spec: InstanceSpec.create({ resources: ResourcesSpec.create({ platform: "", size: { $case: "preset", preset: "", }, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: "", }), }, }), cloudInitUserData: userData, networkInterfaces: [ NetworkInterfaceSpec.create({ name: "eth0", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({ allocation: { $case: "allocationId", allocationId, }, }), }), ], }), }), ).result; await connectInstanceOperation.wait(); ``` For the full set of parameters and more examples, see [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md#examples). ## Connect to the VM by using SSH **Requirements to connect to a private IP address or FQDN** To connect to a VM from another VM by using a [private IP address](https://docs.nebius.com/compute/virtual-machines/network.md#private-ip-addresses) or an [FQDN](https://docs.nebius.com/compute/virtual-machines/fqdn.md), both VMs must be in the same network. 1. Get your VM's IP address: To connect to the VM from the internet (if you have enabled public access to it), get its public IP address: ```bash export PUBLIC_IP_ADDRESS=$(nebius compute instance get-by-name \ --name \ --format json \ | jq -r '.status.network_interfaces[0].public_ip_address.address | split("/")[0]') ``` ```go publicInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "", }, ) if err != nil { return err } publicAddress := publicInstance.GetStatus(). GetNetworkInterfaces()[0].GetPublicIpAddress().GetAddress() publicIPAddress := strings.Split(publicAddress, "/")[0] if publicIPAddress == "" { return fmt.Errorf("public IP address is missing") } ``` ```python public_ip_service = InstanceServiceClient(sdk) public_instance = await public_ip_service.get_by_name( GetByNameRequest(name=""), ) public_address = ( public_instance.status.network_interfaces[0] .public_ip_address.address ) public_ip_address = public_address.split("/")[0] ``` ```ts const publicIpInstanceService = new InstanceService(sdk); const publicIpInstance = await publicIpInstanceService.getByName( GetByNameRequest.create({ name: "", }), ); const publicAddress = publicIpInstance.status ?.networkInterfaces[0]?.publicIpAddress?.address; let publicIpAddress = publicAddress?.split("/")[0]; ``` To connect to the VM from another Compute VM, get the private IP address or FQDN of the VM that you connect to: * Private IP address: ```bash nebius compute instance get-by-name \ --name \ --format json \ | jq -r '.status.network_interfaces[0].ip_address.address | split("/")[0]' ``` * FQDN: ```bash nebius compute instance get-by-name \ --name \ --format json \ | jq -r '.status.network_interfaces[0].fqdn | split("/")[0]' ``` * Private IP address: ```go privateInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "", }, ) if err != nil { return err } privateAddress := privateInstance.GetStatus(). GetNetworkInterfaces()[0].GetIpAddress().GetAddress() fmt.Println(strings.Split(privateAddress, "/")[0]) ``` * FQDN: ```go fqdnInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "", }, ) if err != nil { return err } fqdn := fqdnInstance.GetStatus().GetNetworkInterfaces()[0].GetFqdn() fmt.Println(strings.Split(fqdn, "/")[0]) ``` * Private IP address: ```python private_ip_service = InstanceServiceClient(sdk) private_instance = await private_ip_service.get_by_name( GetByNameRequest(name=""), ) private_address = ( private_instance.status.network_interfaces[0] .ip_address.address ) print(private_address.split("/")[0]) ``` * FQDN: ```python fqdn_service = InstanceServiceClient(sdk) fqdn_instance = await fqdn_service.get_by_name( GetByNameRequest(name=""), ) fqdn = fqdn_instance.status.network_interfaces[0].fqdn print(fqdn.split("/")[0]) ``` * Private IP address: ```ts const privateIpInstanceService = new InstanceService(sdk); const privateIpInstance = await privateIpInstanceService.getByName( GetByNameRequest.create({ name: "", }), ); const privateAddress = privateIpInstance.status ?.networkInterfaces[0]?.ipAddress?.address; console.log(privateAddress?.split("/")[0]); ``` * FQDN: ```ts const fqdnInstanceService = new InstanceService(sdk); const fqdnInstance = await fqdnInstanceService.getByName( GetByNameRequest.create({ name: "", }), ); const fqdn = fqdnInstance.status?.networkInterfaces[0]?.fqdn; console.log(fqdn?.split("/")[0]); ``` 2. Connect to the VM: ```bash ssh @ ``` If your private key is stored in a custom location, specify the path to it with the `-i` parameter: ```bash ssh -i ~/.ssh/ @ ``` Use the received private address or FQDN: ```bash ssh @ ``` If your private key is stored in a custom location, specify the path to it with the `-i` parameter: ```bash ssh -i ~/.ssh/ @ ``` ## Shared access to the VM To let the other users connect to your VM: 1. Ask them to [generate an SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md#generating-a-key-pair) and share the [contents of their public key](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md#getting-the-public-key) with you. 2. Connect to the VM under the name used when creating the VM: ```bash ssh @ ``` 3. Create a new user for VM access, named `newuser` in this example: ```bash sudo useradd -m -d /home/newuser -s /bin/bash newuser ``` 4. Switch to the new user: ```bash sudo su - newuser ``` 5. Create the `ssh` directory: ```bash mkdir .ssh ``` 6. In the directory, create the `authorized_keys` file: ```bash cd .ssh touch authorized_keys ``` 7. Add the new user's public key to the created file: ```bash echo "" > /home/newuser/.ssh/authorized_keys ``` 8. Change the directory's access permissions: ```bash chmod 700 ~/.ssh chmod 600 ~/.ssh/authorized_keys ``` 9. Exit the new user's shell: ```bash exit ``` 10. Restart the VM: ```bash sudo reboot ``` 11. Ask the other user to check the connection: ```bash ssh newuser@ ``` ## Example Example of getting the public IP address of the VM named `training-instance` and connecting to it from the internet: ```bash export PUBLIC_IP_ADDRESS=$(nebius compute instance get-by-name \ --name training-instance \ --format json \ | jq -r '.status.network_interfaces[0].public_ip_address.address | split("/")[0]') ssh $USER@$PUBLIC_IP_ADDRESS ``` ```go trainingInstance, err := sdk.Services().Compute().V1(). Instance().GetByName( ctx, &common.GetByNameRequest{ Name: "training-instance", }, ) if err != nil { return err } trainingAddress := trainingInstance.GetStatus(). GetNetworkInterfaces()[0].GetPublicIpAddress().GetAddress() publicIPAddress = strings.Split(trainingAddress, "/")[0] fmt.Printf("ssh user@%s\n", publicIPAddress) ``` ```python training_ip_service = InstanceServiceClient(sdk) training_instance = await training_ip_service.get_by_name( GetByNameRequest(name="training-instance"), ) training_address = ( training_instance.status.network_interfaces[0] .public_ip_address.address ) public_ip_address = training_address.split("/")[0] print(f"ssh user@{public_ip_address}") ``` ```ts const trainingInstanceService = new InstanceService(sdk); const trainingInstance = await trainingInstanceService.getByName( GetByNameRequest.create({ name: "training-instance", }), ); const trainingAddress = trainingInstance.status ?.networkInterfaces[0]?.publicIpAddress?.address; publicIpAddress = trainingAddress?.split("/")[0]; console.log(`ssh user@${publicIpAddress}`); ``` # Creating a jump server with WireGuard installed on it Source: https://docs.nebius.com/compute/virtual-machines/wireguard.md You can create a jump server to build a reliable tunnel between two zones: * Secure zone that consists of virtual machine (VMs) created in Nebius AI Cloud * Demilitarized zone (DMZ) that consists of machines outside Nebius AI Cloud All connections from the DMZ to the secure zone go through the jump server. This solution provides several benefits: * You can use one public IP address to access all VMs. * You can keep the number of public addresses within a [quota](https://docs.nebius.com/compute/resources/quotas-limits.md#network). * You can limit access to the secure zone and allow only authorized machines to connect to the secure zone. To create a jump server, deploy a VM with [WireGuard](https://www.wireguard.com) installed and configure a VPN. The traffic between the zones is routed in an encrypted form via the jump server. To create a VM with WireGuard deployed, Nebius AI Cloud offers a Terraform-based solution. You can apply manifests that contain configuration of a VM with a WireGuard image. ## Costs The tutorial includes the following chargeable resources: * [Compute virtual machines](https://docs.nebius.com/compute/resources/pricing.md#virtual-machines-gpus-vcpus-ram) * [Compute disks](https://docs.nebius.com/compute/resources/pricing.md#disks) ## Prerequisites 1. [Install Terraform](https://developer.hashicorp.com/terraform/install). 2. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. The Terraform-based solution uses the CLI to get credentials. For enhanced security, [use a service account](https://docs.nebius.com/cli/configure.md#how-to-set-up-the-cli-for-a-service-account) to configure the CLI. Make sure that this account is in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has at least the `editor` role within your tenant; for example, the default `editors` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 3. Install `jq`: ```bash Ubuntu sudo apt-get install jq ``` ```bash macOS brew install jq ``` 4. Clone the [nebius-solution-library](https://github.com/nebius/nebius-solution-library/tree/main) repository from where the WireGuard solution is going to be deployed: ```bash git clone git@github.com:nebius/nebius-solution-library.git ``` 5. Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). ## Steps ### Deploy infrastructure 1. In your terminal, go to the `wireguard` directory in the cloned repository: ```bash cd nebius-solution-library/wireguard ``` 2. In the `environment.sh` file in this directory, uncomment the following variables and specify values for them: * `NEBIUS_TENANT_ID`: [Tenant ID](https://docs.nebius.com/iam/get-tenants.md). * `NEBIUS_PROJECT_ID`: [Project ID](https://docs.nebius.com/iam/manage-projects.md#terraform-3). * `NEBIUS_REGION`: The [region](https://docs.nebius.com/overview/regions.md) where your project is located. You can find the region in the web console, in the list of projects. 3. Run the script that creates an access token for Terraform, saves the token to environment variables and configures Terraform state to be saved in Object Storage: ```bash source ./environment.sh ``` 4. Initialize Terraform in the `wireguard` directory: ```bash terraform init ``` 5. In the `terraform.tfvars` file in this directory, uncomment the following variables and specify values for them: * `ssh_user_name`: The user required for an SSH connection to the VM, for example `user1`. * `ssh_public_key`: The public SSH key that you [created earlier](https://docs.nebius.com/compute/virtual-machines/wireguard.md#prerequisites). Specify either the key body or the path to this key. * `public_ip_allocation_id`: An ID of an [allocation](https://docs.nebius.com/vpc/overview.md#allocation) with a public IP address. The WireGuard UI will be available at this address. To preserve the address even in case of the VM deletion, create the allocation: ```bash nebius vpc allocation create \ --ipv4-public-subnet-id \ --name wireguard_allocation \ --parent-id \ --format json \ | jq -r ".metadata.id" ``` The command returns the allocation ID. Specify it in the `public_ip_allocation_id` variable. 6. Preview the configuration that you are going to deploy: ```bash terraform plan ``` 7. Apply the changes: ```bash terraform apply ``` When the command is finished, it returns the VM public address: ```text Outputs: wg_instance_pib = "" ``` Copy the address: It is required to connect to the deployed VM. ### Access WireGuard 1. Connect to the VM: ```bash ssh -i @ ``` The command contains: * Path to the private SSH key that you [created earlier](https://docs.nebius.com/compute/virtual-machines/wireguard.md#prerequisites) * Username specified in the `terraform.tfvars` file * Public IP address of the deployed VM 2. Get the WireGuard UI password: ```bash sudo cat /var/lib/wireguard-ui/initial_password ``` 3. In the browser, open the WireGuard UI at `http://:5000`. 4. In the window that opens, sign in with the `admin` username and the password retrieved from the VM. The working space of the WireGuard UI opens. ### Configure WireGuard Set up a VPN and grant access to the VMs in the secure zone. To do this, add the DMZ machines as WireGuard clients: 1. Click **New client**. 2. In the window that opens, specify details of the machines that require access. In the **Allowed IPs** field, enter CIDRs of these machines. 3. Click **Submit**. 4. After the window is closed, click **Apply config**. Click this button every time after you create, change or delete WireGuard clients. After that, the DMZ machines are able to connect to the VMs in the secure zone. You do not need to configure the same access for the jump server because it is located in the same subnet as the VMs in the secure zone. ## How to delete the created resources The created Compute virtual machine and its boot disk are chargeable. If you do not need them, delete these resources, so Nebius AI Cloud does not charge for it. Use the following command to delete all the created infrastructure at once: ```bash terraform destroy -target=nebius_compute_v1_instance.wireguard_instance ``` # InfiniBand™ networking for Compute virtual machines with GPUs Source: https://docs.nebius.com/compute/clusters/gpu/index.md You can group your virtual machines with GPUs into a *GPU cluster*. The cluster accelerates high-performance computing (HPC) tasks such as training and inference. These tasks require a lot of processing power that a single VM cannot provide. The GPU clusters are built with InfiniBand™ secure high-speed networking. Each GPU in a VM is connected through a network interface card (NIC) that provides 400 Gbps. As a compute VM for GPU clusters consists of 8 GPUs, the total bandwidth for a node is 3.2 Tbps. Nebius AI Cloud uses GPUDirect RDMA, an NVIDIA® technology of remote direct memory access (RDMA) that allows data to flow directly between each GPU and its NIC, avoiding CPU, thus boosting the data exchange speed. ## InfiniBand™ fabrics Each GPU cluster is created in one of the physical *InfiniBand™ fabrics*. This is where GPUs interconnected over InfiniBand™ are located. Each fabric has limited GPU capacity. When creating a GPU cluster, select an InfiniBand™ fabric for it. Take into account the type of GPUs you are going to use. For example, if you select `fabric-7`, you can only add NVIDIA® H200 NVLink with Intel Sapphire Rapids GPUs to this cluster. Available fabrics and corresponding regions ([private regions](https://docs.nebius.com/overview/regions.md) are marked with \*): | Fabric | GPU platform | [Region](https://docs.nebius.com/overview/regions.md) | | -------------------------- | --------------------------------------------------------------------------- | --------------------------- | | `fabric-2` | NVIDIA® H100 NVLink with Intel Sapphire Rapids (gpu-h100-sxm) | eu-north1 | | `fabric-3` | NVIDIA® H100 NVLink with Intel Sapphire Rapids (gpu-h100-sxm) | eu-north1 | | `fabric-4` | NVIDIA® H100 NVLink with Intel Sapphire Rapids (gpu-h100-sxm) | eu-north1 | | `fabric-5` | NVIDIA® H200 NVLink with Intel Sapphire Rapids (gpu-h200-sxm) | eu-west1 | | `fabric-6` | NVIDIA® H100 NVLink with Intel Sapphire Rapids (gpu-h100-sxm) | eu-north1 | | `fabric-7` | NVIDIA® H200 NVLink with Intel Sapphire Rapids (gpu-h200-sxm) | eu-north1 | | eu-north2-a | NVIDIA® H200 NVLink with Intel Sapphire Rapids (gpu-h200-sxm) | eu-north2\* | | eu-west2-a | NVIDIA® B300 NVLink with Intel Granite Rapids (gpu-b300-sxm) | eu-west2\* | | me-west1-a | NVIDIA® B200 NVLink with Intel Emerald Rapids (gpu-b200-sxm-a) | me-west1 | | uk-south1-a | NVIDIA® B300 NVLink with Intel Granite Rapids (gpu-b300-sxm) | uk-south1 | | us-central1-a | NVIDIA® H200 NVLink with Intel Sapphire Rapids (gpu-h200-sxm) | us-central1 | | us-central1-b | NVIDIA® B200 NVLink with Intel Emerald Rapids (gpu-b200-sxm) | us-central1 | In most cases, you do not need to change the preselected fabric. We recommend that you create a GPU cluster in another fabric only if it is better suited for a different platform or if you experience capacity issues with an existing GPU cluster. ## Isolation and security of InfiniBand™ traffic Nebius AI Cloud isolates InfiniBand™ traffic between GPU clusters by using InfiniBand™ *partition keys* (P-Keys). Each GPU cluster is assigned a unique P-Key to create isolation inside shared [physical InfiniBand™ fabrics](https://docs.nebius.com/compute/clusters/gpu/topology). This way, nodes in different GPU clusters cannot communicate over InfiniBand™ even if they use the same fabric infrastructure. This creates isolation between [tenants](https://docs.nebius.com/iam/overview.md#tenants) without requiring a dedicated physical fabric for each cluster. ## Prerequisites If you use the web console, you don't need to complete any prerequisites. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to enable InfiniBand™ for VMs with GPUs 1. Create a GPU cluster: 1. In the sidebar, go to **Compute** → **GPU clusters**. 2. Click **Create GPU cluster**. 3. On the page that opens, specify the cluster name. It should contain from 3 to 63 characters: lowercase letters, numbers and hyphens. 4. Select the InfiniBand™ fabric. 5. Click **Create GPU cluster**. 2. Add VMs to the cluster. You can assign a GPU cluster only when creating a VM: All virtual machines added to the GPU cluster, including Managed Service for Kubernetes® nodes, must be in the same [project](https://docs.nebius.com/iam/overview.md#projects). 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Click **Create resource** → **Virtual machine**. 3. On the **Compute** step of the VM creation wizard, select a platform and preset compatible with GPU clusters. For more information, see [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). 4. In the **Settings** section, select an existing GPU cluster in the **GPU cluster** field, or create a new one. 5. On the **Storage** step, select the boot disk for NVIDIA® GPUs. For details, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). You can also create a GPU cluster while [creating the first VM in it](https://docs.nebius.com/compute/virtual-machines/manage.md): 1. On the **Compute** step of the VM creation wizard: 1. Select a platform and a preset compatible with GPU clusters. For more information, see [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). 2. In the **Settings** section, create or select a GPU cluster in the **GPU cluster** field. 2. On the **Storage** step, select the boot disk for NVIDIA® GPUs. For details, see [Boot disk images for Compute virtual machines](https://docs.nebius.com/compute/storage/boot-disk-images.md). 1. Check that your project ID is saved in the Nebius AI Cloud CLI profile configuration: ```bash cat ~/.nebius/config.yaml ``` 2. If you have not set your project ID as `parent-id`, or you want to create resources in a different project, [get the project ID](https://docs.nebius.com/iam/manage-projects.md#how-to-get-a-project-id) and update your [CLI profile](https://docs.nebius.com/cli/configure.md): ```bash nebius profile update --parent-id ``` 3. Depending on your project's [region](https://docs.nebius.com/overview/regions.md), select an [InfiniBand™ fabric](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics) for VM interconnection and save it to an environment variable: ```bash export INFINIBAND_FABRIC= ``` 4. Create a GPU cluster and save its ID: ```bash export GPU_CLUSTER_ID=$(nebius compute gpu-cluster create \ --name \ --infiniband-fabric $INFINIBAND_FABRIC \ --format json \ | jq -r ".metadata.id") ``` Where: * `Name`: A cluster name that you can use to quickly find the cluster. 5. Create a boot disk optimized for VMs with NVIDIA® GPUs: ```bash export BOOT_DISK_ID=$(nebius compute disk create \ --name \ --size-gibibytes 200 \ --type network_ssd \ --source-image-family-image-family ubuntu24.04-cuda13.0 \ --block-size-bytes 4096 \ --format json \ | jq -r ".metadata.id") ``` For compatible boot disk images (`--source-image-family-image-family`), see [Boot disk images](https://docs.nebius.com/compute/storage/boot-disk-images.md). 6. [Create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with GPUs and specify the GPU cluster ID in its parameters. All virtual machines added to the GPU cluster, including Managed Service for Kubernetes® nodes, must be in the same project. For example: ```bash nebius compute instance create \ --resources-platform gpu-h100-sxm \ --resources-preset 8gpu-128vcpu-1600gb \ --gpu-cluster-id $GPU_CLUSTER_ID \ --boot-disk-existing-disk-id $BOOT_DISK_ID \ ... ``` Specify a VM platform with GPUs in `--resources-platform`, and a preset compatible with GPU clusters in `--resources-preset`. For more information, see [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). 1. Depending on your project's [region](https://docs.nebius.com/overview/regions.md), select an [InfiniBand™ fabric](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics) for VM interconnection and set it in the code: ```go infinibandFabric := "" ``` 2. Create a GPU cluster and save its ID: ```go gpuClusterOperation, err := sdk.Services().Compute().V1(). GpuCluster().Create( ctx, &compute.CreateGpuClusterRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.GpuClusterSpec{ InfinibandFabric: infinibandFabric, }, }, ) if err != nil { return err } if _, err = gpuClusterOperation.Wait(ctx); err != nil { return err } gpuClusterID := gpuClusterOperation.ResourceID() ``` Where: * `Metadata.Name`: A cluster name that you can use to quickly find the cluster. 3. Create a boot disk optimized for VMs with NVIDIA® GPUs: ```go diskOperation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: 200, }, 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 = diskOperation.Wait(ctx); err != nil { return err } bootDiskID := diskOperation.ResourceID() ``` For compatible boot disk images, see [Boot disk images](https://docs.nebius.com/compute/storage/boot-disk-images.md). 4. [Create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with GPUs and specify the GPU cluster ID in its parameters. All virtual machines added to the GPU cluster, including Managed Service for Kubernetes® nodes, must be in the same project. ```go attachMode := compute.AttachedDiskSpec_READ_WRITE instanceOperation, err := sdk.Services().Compute().V1(). Instance().Create( ctx, &compute.CreateInstanceRequest{ Metadata: &common.ResourceMetadata{ Name: "vm", }, Spec: &compute.InstanceSpec{ Stopped: true, Resources: &compute.ResourcesSpec{ Platform: "gpu-h100-sxm", Size: &compute.ResourcesSpec_Preset{ Preset: "8gpu-128vcpu-1600gb", }, }, GpuCluster: &compute.InstanceGpuClusterSpec{ Id: gpuClusterID, }, BootDisk: &compute.AttachedDiskSpec{ AttachMode: attachMode, Type: &compute.AttachedDiskSpec_ExistingDisk{ ExistingDisk: &compute.ExistingDisk{ Id: bootDiskID, }, }, }, NetworkInterfaces: []*compute.NetworkInterfaceSpec{ { Name: "ni", SubnetId: subnetID, IpAddress: &compute.IPAddress{}, PublicIpAddress: &compute.PublicIPAddress{}, }, }, }, }, ) if err != nil { return err } if _, err = instanceOperation.Wait(ctx); err != nil { return err } ``` Specify a VM platform with GPUs and a preset compatible with GPU clusters. For more information, see [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). 1. Depending on your project's [region](https://docs.nebius.com/overview/regions.md), select an [InfiniBand™ fabric](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics) for VM interconnection and set it in the code: ```python infiniband_fabric = "" ``` 2. Create a GPU cluster and save its ID: ```python gpu_cluster_service = GpuClusterServiceClient(sdk) create_cluster_operation = await gpu_cluster_service.create( CreateGpuClusterRequest( metadata=ResourceMetadata( name="", ), spec=GpuClusterSpec( infiniband_fabric=infiniband_fabric, ), ), ) await create_cluster_operation.wait() gpu_cluster_id = create_cluster_operation.resource_id ``` Where: * `metadata.name`: A cluster name that you can use to quickly find the cluster. 3. Create a boot disk optimized for VMs with NVIDIA® GPUs: ```python disk_service = DiskServiceClient(sdk) create_disk_operation = await disk_service.create( CreateDiskRequest( metadata=ResourceMetadata( name="", ), spec=DiskSpec( block_size_bytes=4096, type=DiskSpec.DiskType.NETWORK_SSD, source_image_family=SourceImageFamily( image_family="ubuntu24.04-cuda13.0", ), size_gibibytes=200, ), ), ) await create_disk_operation.wait() boot_disk_id = create_disk_operation.resource_id ``` For compatible boot disk images, see [Boot disk images](https://docs.nebius.com/compute/storage/boot-disk-images.md). 4. [Create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with GPUs and specify the GPU cluster ID in its parameters. All virtual machines added to the GPU cluster, including Managed Service for Kubernetes® nodes, must be in the same project. ```python instance_service = InstanceServiceClient(sdk) create_instance_operation = await instance_service.create( CreateInstanceRequest( metadata=ResourceMetadata( name="vm", ), spec=InstanceSpec( stopped=True, resources=ResourcesSpec( platform="gpu-h100-sxm", preset="8gpu-128vcpu-1600gb", ), gpu_cluster=InstanceGpuClusterSpec( id=gpu_cluster_id, ), boot_disk=AttachedDiskSpec( attach_mode=( AttachedDiskSpec.AttachMode.READ_WRITE ), existing_disk=ExistingDisk(id=boot_disk_id), ), network_interfaces=[ NetworkInterfaceSpec( name="ni", subnet_id=subnet_id, ip_address=IPAddress(), public_ip_address=PublicIPAddress(), ), ], ), ), ) await create_instance_operation.wait() ``` Specify a VM platform with GPUs and a preset compatible with GPU clusters. For more information, see [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). 1. Depending on your project's [region](https://docs.nebius.com/overview/regions.md), select an [InfiniBand™ fabric](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics) for VM interconnection and set it in the code: ```ts const infinibandFabric = ""; ``` 2. Create a GPU cluster and save its ID: ```ts const gpuClusterService = new GpuClusterService(sdk); const createGpuClusterOperation = await gpuClusterService.create( CreateGpuClusterRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: GpuClusterSpec.create({ infinibandFabric, }), }), ).result; await createGpuClusterOperation.wait(); const gpuClusterId = createGpuClusterOperation.resourceId(); ``` Where: * `metadata.name`: A cluster name that you can use to quickly find the cluster. 3. Create a boot disk optimized for VMs with NVIDIA® GPUs: ```ts const diskService = new DiskService(sdk); const createDiskOperation = await diskService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: DiskSpec.create({ blockSizeBytes: 4096, type: DiskSpec_DiskType.NETWORK_SSD, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "ubuntu24.04-cuda13.0", }), }, size: { $case: "sizeGibibytes", sizeGibibytes: 200, }, }), }), ).result; await createDiskOperation.wait(); const bootDiskId = createDiskOperation.resourceId(); ``` For compatible boot disk images, see [Boot disk images](https://docs.nebius.com/compute/storage/boot-disk-images.md). 4. [Create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with GPUs and specify the GPU cluster ID in its parameters. All virtual machines added to the GPU cluster, including Managed Service for Kubernetes® nodes, must be in the same project. ```ts const instanceService = new InstanceService(sdk); const createInstanceOperation = await instanceService.create( CreateInstanceRequest.create({ metadata: ResourceMetadata.create({ name: "vm", }), spec: InstanceSpec.create({ stopped: true, resources: ResourcesSpec.create({ platform: "gpu-h100-sxm", size: { $case: "preset", preset: "8gpu-128vcpu-1600gb", }, }), gpuCluster: InstanceGpuClusterSpec.create({ id: gpuClusterId, }), bootDisk: AttachedDiskSpec.create({ attachMode: AttachedDiskSpec_AttachMode.READ_WRITE, type: { $case: "existingDisk", existingDisk: ExistingDisk.create({ id: bootDiskId, }), }, }), networkInterfaces: [ NetworkInterfaceSpec.create({ name: "ni", subnetId, ipAddress: IPAddress.create({}), publicIpAddress: PublicIPAddress.create({}), }), ], }), }), ).result; await createInstanceOperation.wait(); ``` Specify a VM platform with GPUs and a preset compatible with GPU clusters. For more information, see [Types of virtual machines and GPUs in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/types.md). ## How to test the connection with the NCCL tests To test InfiniBand™ performance in a Compute cluster, you can run the NVIDIA® Collective Communications Library (NCCL) test in it. For instructions, see our tutorial on running distributed jobs with [MPIrun](https://docs.nebius.com/3p-integrations/mpirun.md): it uses the NCCL test as an example. ## How to delete a GPU cluster Before deleting a GPU cluster, make sure all virtual machines in the cluster are deleted or moved to another cluster. 1. In the sidebar, go to **Compute** → **GPU clusters**. 2. In the row of the GPU cluster you want to delete, click → **Delete**. 3. In the window that opens, confirm the deletion. 1. Get the ID of the GPU cluster you want to delete: ```bash nebius compute gpu-cluster list ``` 2. Delete the GPU cluster: ```bash nebius compute gpu-cluster delete ``` 1. Get the ID of the GPU cluster you want to delete: ```go gpuClusters, err := sdk.Services().Compute().V1(). GpuCluster().List( ctx, &compute.ListGpuClustersRequest{ ParentId: nbProject, }, ) if err != nil { return err } fmt.Println(gpuClusters) ``` 2. Delete the GPU cluster: ```go delClusterOp, err := sdk.Services().Compute().V1(). GpuCluster().Delete( ctx, &compute.DeleteGpuClusterRequest{ Id: "", }, ) if err != nil { return err } if _, err = delClusterOp.Wait(ctx); err != nil { return err } ``` 1. Get the ID of the GPU cluster you want to delete: ```python gpu_cluster_service = GpuClusterServiceClient(sdk) gpu_clusters = await gpu_cluster_service.list( ListGpuClustersRequest(parent_id=nb_project), ) print(gpu_clusters) ``` 2. Delete the GPU cluster: ```python gpu_cluster_service = GpuClusterServiceClient(sdk) delete_cluster_operation = await gpu_cluster_service.delete( DeleteGpuClusterRequest(id=""), ) await delete_cluster_operation.wait() ``` 1. Get the ID of the GPU cluster you want to delete: ```ts const listGpuClusterService = new GpuClusterService(sdk); const gpuClusters = await listGpuClusterService.list( ListGpuClustersRequest.create({ parentId: nbProject, }), ); console.log(gpuClusters); ``` 2. Delete the GPU cluster: ```ts const deleteGpuClusterService = new GpuClusterService(sdk); const deleteClusterOperation = await deleteGpuClusterService.delete( DeleteGpuClusterRequest.create({ id: "", }), ).result; await deleteClusterOperation.wait(); ``` ## See also * [How to test a GPU cluster physical state in Compute](https://docs.nebius.com/compute/clusters/gpu/test.md) * [InfiniBand™ networking for Compute virtual machines with GPUs](https://docs.nebius.com/kubernetes/gpu/clusters.md) * [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md) * [Running the all-reduce NCCL performance test in Soperator clusters](https://docs.nebius.com/slurm-soperator/jobs/examples/nccl-all-reduce.md) *** *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # How to test a GPU cluster physical state in Compute Source: https://docs.nebius.com/compute/clusters/gpu/test.md In this article, you will learn how to test the physical state of the InfiniBand™ connection. The guides below will help you to check that InfiniBand connections are established between GPUs in a GPU cluster. ## Testing the port state 1. [Connect to the VM using SSH](https://docs.nebius.com/compute/virtual-machines/connect.md). 2. In the VM's shell, run `ibstatus` command that displays operational information about InfiniBand network devices. Result: ```bash Infiniband device 'mlx5_0' port 1 status: default gid: fe80:0000:0000:0000:****:****:****:03c5 base lid: 0x*** sm lid: 0x* state: 4: ACTIVE phys state: 5: LinkUp rate: 400 Gb/sec (4X NDR) link_layer: InfiniBand Infiniband device 'mlx5_1' port 1 status: default gid: fe80:0000:0000:0000:****:****:****:03c6 base lid: 0x*** sm lid: 0x* state: 4: ACTIVE phys state: 5: LinkUp rate: 400 Gb/sec (4X NDR) link_layer: InfiniBand ... ``` 3. For each device in the result, check the physical state (`phys state`): it should be `LinkUp`. ## Testing network performance You can also emulate the network activity by sending some data from GPUs on one VM to GPUs on another: 1. Install the [perftest](https://github.com/linux-rdma/perftest) package on each one of the test VMs: ```bash sudo apt install perftest ``` 2. [Connect to the first VM using SSH](https://docs.nebius.com/compute/virtual-machines/connect.md). 3. Run `ib_send_bw --report_gbits`. 4. Copy the first VM's [private IP address](https://docs.nebius.com/compute/virtual-machines/network.md). 5. [Connect to the second VM using SSH](https://docs.nebius.com/compute/virtual-machines/connect.md). 6. Run `ib_send_bw --report_gbits`. In the commands output, you should see non-zero values for the bytes sent, average bandwith speed, and average message rate. The bandwidth peak speed might not reach the theoretical maximum 400 Gbps. Example: ```text +--------------------------------------------------------------------------------+ | #bytes #iterations #BW peak[Gb/sec] #BW average[Gb/sec] #MsgRate[Mpps] | +--------------------------------------------------------------------------------+ | 65536 1000 360.39 359.91 0.686466 | +--------------------------------------------------------------------------------+ ``` ## See also * [InfiniBand™ networking for Compute virtual machines with GPUs](https://docs.nebius.com/compute/clusters/gpu/index.md) * [How to create a virtual machine in Nebius AI Cloud](https://docs.nebius.com/compute/virtual-machines/manage.md) *** *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # InfiniBand™ topology of a GPU cluster Source: https://docs.nebius.com/compute/clusters/gpu/topology/index.md ## Why InfiniBand topology is important Workload managers like [Slurm](https://slurm.schedmd.com) and [Volcano](https://volcano.sh/en/docs/) allow you to specify the network topology of your virtual machines within a GPU cluster for *topology-aware job scheduling*. Topology files describe how the VMs are located relative to each other. When you provide a topology file to a workload manager, it schedules distributed jobs on the worker nodes that are topologically closest to each other. This reduces network latency in such jobs and leads to better performance in both real workloads and synthetic tests. > For example, the [AllReduce](https://github.com/NVIDIA/nccl-tests/blob/master/doc/PERFORMANCE.md#allreduce) tests from the [NCCL Tests suite](https://github.com/NVIDIA/nccl-tests) that we ran in Nebius AI Cloud as topology-aware jobs have shown performance gains of up to 20%, depending on cluster size, compared to the same tests without the topology provided. ## Architecture of InfiniBand topology Every virtual machine with GPUs is connected to a set of three nodes related to a particular [InfiniBand fabric](https://docs.nebius.com/compute/clusters/gpu/index.md#infiniband-fabrics). Every node is located on a separate network layer. The hierarchy of an InfiniBand network includes the following layers with different types of switches: 1. InfiniBand fabric layer. Contains a root switch. 2. Point of delivery (POD). Represents a set of racks with servers. Core switches interconnect PODs. 3. Scalable unit (SU). Consists of a set of servers. Leaf switches interconnect scalable units.

## Cost of network communication The cost of network communication increases as you go to a higher layer. For example, if you need to transfer data from one POD to another, the data goes through a root switch. This leads to a higher cost of resources. Mutual connections between PODs or SUs do not influence the cost. If a connection or data exchange takes place within one entity (POD or SU), the cost of network communication does not change. *** *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # Working with InfiniBand™ topology of a GPU cluster Source: https://docs.nebius.com/compute/clusters/gpu/topology/manage.md [InfiniBand™ topology](https://docs.nebius.com/compute/clusters/gpu/topology) can help you increase performance of multi-VM jobs in GPU clusters. ## Prerequisites [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to get InfiniBand™ topology of a GPU cluster After you [create a GPU cluster and add VMs to it](https://docs.nebius.com/compute/clusters/gpu/index.md#how-to-enable-infiniband-for-vms-with-gpus), you can view the InfiniBand™ topology of this cluster and its VMs. To get the topology for all VMs in a GPU cluster: Run the following command: ```bash nebius compute gpu-cluster get --id computegpucluster-*** ``` In the `--id` parameter, specify the GPU cluster ID. The output example is the following: ```text ... status: infiniband_topology_path: instances: - instance_id: computeinstance-***rnqz path: - ***27bf - ***bb9b - ***b7ad - instance_id: computeinstance-***pepp path: - ***27bf - ***bb9b - ***e1ff - ... ``` ```go gpuCluster, err := sdk.Services().Compute().V1(). GpuCluster().Get( ctx, &compute.GetGpuClusterRequest{ Id: "computegpucluster-***", }, ) if err != nil { return err } fmt.Println(gpuCluster) ``` In the code, specify the GPU cluster ID. ```python gpu_cluster_service = GpuClusterServiceClient(sdk) gpu_cluster = await gpu_cluster_service.get( GetGpuClusterRequest(id="computegpucluster-***"), ) print(gpu_cluster) ``` In the code, specify the GPU cluster ID. ```ts const getGpuClusterService = new GpuClusterService(sdk); const gpuCluster = await getGpuClusterService.get( GetGpuClusterRequest.create({ id: "computegpucluster-***", }), ); console.log(gpuCluster); ``` In the code, specify the GPU cluster ID. To get the topology for an individual VM: Run the following command: ```bash nebius compute instance get --id computeinstance-*** ``` In the `--id` parameter, specify the ID of the VM attached to the GPU cluster. The output example is the following: ```text ... status: infiniband_topology_path: path: - ***27bf - ***bb9b - ***e1ff ``` ```go instance, err := sdk.Services().Compute().V1(). Instance().Get( ctx, &compute.GetInstanceRequest{ Id: "computeinstance-***", }, ) if err != nil { return err } fmt.Println(instance) ``` In the code, specify the ID of the VM attached to the GPU cluster. ```python instance_service = InstanceServiceClient(sdk) instance = await instance_service.get( GetInstanceRequest(id="computeinstance-***"), ) print(instance) ``` In the code, specify the ID of the VM attached to the GPU cluster. ```ts const getInstanceService = new InstanceService(sdk); const instance = await getInstanceService.get( GetInstanceRequest.create({ id: "computeinstance-***", }), ); console.log(instance); ``` In the code, specify the ID of the VM attached to the GPU cluster. In the topology data, the `path` list shows components of the [InfiniBand™ network layers](https://docs.nebius.com/compute/clusters/gpu/topology#architecture-of-infiniband-topology): ```text ***27bf # 1st network layer (InfiniBand™ fabric) ***bb9b # 2nd network layer (point of delivery, POD) ***e1ff # 3rd network layer (scalable unit, SU) ``` ## How to create the Slurm topology configuration To set up topology in [Slurm](https://slurm.schedmd.com) and run jobs for ML workloads, you need the [topology.conf](https://slurm.schedmd.com/topology.conf.html) file. This file shows the network hierarchy: how nodes are interconnected, what layers they are located at and what switches are used. The `topology.conf` file represents InfiniBand™ topology. You can create this file based on the [information about a given GPU cluster](https://docs.nebius.com/compute/clusters/gpu/topology/manage.md#how-to-get-infiniband-topology-of-a-gpu-cluster). To create the file, run one of the scripts from the [Nebius AI Cloud solution library](https://github.com/nebius/nebius-solution-library/tree/main/scripts/ib-topology) on GitHub. *** *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # Managing applications with the Virtual machine deployment option Source: https://docs.nebius.com/compute/virtual-machines/applications.md Nebius AI Cloud provides several applications that you can deploy by using the **Virtual machine** deployment option on [Compute virtual machines](https://docs.nebius.com/compute/virtual-machines/manage.md). For example, you can deploy AI models, development environments or data processing tools. For information about deploying applications, see [Deploying applications in Nebius AI Cloud](https://docs.nebius.com/applications/deploy.md). ## Prerequisites For managing an application with the Virtual machine deployment option: Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has at least the `editor` role within your tenant or project; for example, the default `editors` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. ## How to find and deploy an application To see the list of applications with the **Virtual machine** deployment option and deploy an application: 1. In the sidebar, go to **Applications**. 2. In the **Deployment** dropdown, select **Virtual machine** to see only applications that support the **Virtual machine** deployment option. 3. Choose an application, open its page and click **Deploy**. 4. Configure the application. You can specify the VM platform, preset, network settings and other parameters according to your needs. 5. Click **Deploy application**. 6. Wait until the application is deployed and running. ## How to delete an application 1. In the sidebar, go to **Applications**. 2. Go to the **Installed** tab to see your deployed applications. 3. Find the application you want to delete and open it. 4. On the application details page, go to the **Settings** tab. 5. Click **Delete application**. 6. To confirm that you want to delete the application, enter its name and click **Delete application**. When you delete an application deployed with the **Virtual machine** deployment option, the underlying virtual machine is also deleted. Applications deployed with this option are subject to Compute [charges](https://docs.nebius.com/compute/resources/pricing.md) and [quotas](https://docs.nebius.com/compute/resources/quotas-limits.md). # Running applications and custom containers on virtual machines Source: https://docs.nebius.com/compute/virtual-machines/applications-containers.md In Nebius AI Cloud, you can run applications in [container virtual machines](https://docs.nebius.com/compute/virtual-machines/containers.md) (VMs). A container VM allows you to launch a VM with a pre-installed container image, such as Jupyter Notebook, or a custom Docker image from a public registry. Container VMs are useful when you want to quickly deploy an application environment without manually configuring the VM or installing dependencies. This tutorial demonstrates two alternative ways to run container VMs: * [Run a container VM with a pre-installed application image](https://docs.nebius.com/compute/virtual-machines/applications-containers.md#run-a-container-vm-with-a-pre-installed-application-image) * [Run a container VM with a custom Docker image from the public registry](https://docs.nebius.com/compute/virtual-machines/applications-containers.md#run-a-container-vm-with-a-custom-docker-image) ## Costs The tutorial includes the following chargeable resources: * [Compute virtual machines](https://docs.nebius.com/compute/resources/pricing.md#virtual-machines-gpus-vcpus-ram) * [Compute disks](https://docs.nebius.com/compute/resources/pricing.md#disks) ## Prerequisites Generate an [SSH key pair](https://docs.nebius.com/compute/virtual-machines/ssh-keys.md). ## Steps ### Run a container VM with a pre-installed application image #### Create a single-GPU VM with Jupyter Notebook 1. In the [web console](https://console.nebius.com), go to **Compute** → **Container VMs**. 2. Click **Create container VM**. 3. Specify the VM name. 4. Select the **Jupyter Notebook** container image. 5. Copy and save the token that appears. You will need this token later to access the JupyterLab web interface. 6. In **Computing resources**, configure the VM with one GPU. For example, select NVIDIA® L40S PCIe with Intel Ice Lake and keep the predefined preset with eight CPUs. 7. In **Local storage**, specify the disk size. 8. In **Access**, add new credentials or select existing ones. To add new credentials: 1. Specify the username. Do not use the `root` or `admin` usernames. They are reserved for internal needs and cannot be used for SSH access. 2. Copy the contents of the `.pub` file generated earlier and paste it into the **Public key** field. 3. Click **Add credentials**. 9. Click **Create container VM**. #### Launch Jupyter Notebook When the container VM is running, connect to the application: 1. In **Container VMs**, open the page of the created VM. 2. Click **Go to Web UI** at the top of the VM page. 3. When prompted, paste the token into the authentication field and click **Log in**. If you did not save the Jupyter token earlier, you can copy it from the **Container parameters** section on the container VM page. 4. In JupyterLab, create a new notebook. 5. Run the following code. It shows information about available GPUs: ```python import torch if torch.cuda.is_available(): print("CUDA is available. PyTorch can use your GPU.") print(f"Number of GPUs available: {torch.cuda.device_count()}") print(f"GPU Name: {torch.cuda.get_device_name()}") else: print("CUDA is not available. PyTorch will run on CPU.") ``` Example output: ```text CUDA is available. PyTorch can use your GPU. Number of GPUs available: 1 GPU Name: NVIDIA L40S ``` #### Benchmark a VM with one GPU Run a simple benchmark to measure how long the GPU takes to multiply large matrices. This test multiplies two 30,000×30,000 tensors several times and measures the total execution time. Later in the tutorial, you will repeat the same benchmark on a VM with eight GPUs and compare the results. Run the following code: ```python import torch import time device = torch.device("cuda" if torch.cuda.is_available() else "cpu") matrix_size = 30000 a = torch.randn(matrix_size, matrix_size, device=device) b = torch.randn(matrix_size, matrix_size, device=device) num_runs = 10 for _ in range(3): torch.matmul(a, b) torch.cuda.synchronize() start_time = time.time() for _ in range(num_runs): torch.matmul(a, b) torch.cuda.synchronize() end_time = time.time() average_time = (end_time - start_time) print(f"Time for {num_runs} matrix multiplications ({matrix_size}x{matrix_size}): {average_time:.4f} seconds") ``` Example output: ```text Time for 10 matrix multiplications (30000x30000): 16.7096 seconds ``` In this benchmark test, CUDA synchronization ensures that each multiplication finishes before the next one starts, which makes the timing more accurate. #### Replace the VM with an 8-GPU VM while preserving data To scale from one GPU to eight GPUs and keep your notebooks: 1. Delete the current VM. When deleting the VM, select the option to keep the boot disk. 2. Create a new container VM as described in the [Create a single-GPU VM with Jupyter Notebook](https://docs.nebius.com/compute/virtual-machines/applications-containers.md#create-a-single-gpu-vm-with-jupyter-notebook) section, but: * In **Computing resources**, choose a configuration with eight GPUs * Attach the existing disk that contains your data as an additional disk #### Benchmark a VM with eight GPUs Run the benchmark test again on the VM with eight GPUs to measure how the workload performs after scaling. 1. Go to Jupyter Notebook and open your existing notebook. 2. Replace the benchmark code with: ```python import torch import time num_gpus = torch.cuda.device_count() matrix_size = 30000 num_runs = 10 chunk_size = matrix_size // num_gpus B_cpu = torch.randn(matrix_size, matrix_size) B_chunks = [B_cpu.to(f"cuda:{i}") for i in range(num_gpus)] A_chunks = [torch.randn(chunk_size, matrix_size, device=f"cuda:{i}") for i in range(num_gpus)] start_time = time.time() for _ in range(num_runs): C_chunks = [] for i in range(num_gpus): C = A_chunks[i] @ B_chunks[i] C_chunks.append(C) for i in range(num_gpus): torch.cuda.synchronize(i) end_time = time.time() print(f"Time for {num_runs} multi-GPU matrix multiplications ({matrix_size}x{matrix_size}): {(end_time - start_time):.4f} seconds") ``` Example output: ```text Time for 10 multi-GPU matrix multiplications (30000x30000): 1.3283 seconds. ``` This demonstrates the performance improvement when scaling from one GPU to eight GPUs. ### Run a container VM with a custom Docker image In the previous section, you deployed a container by using a pre-installed Jupyter Notebook application image on a container VM. You can also deploy containers with custom Docker images from public registries. In this section, you will create a container VM by using a Docker image from Docker Hub and access the application running inside the container. The [TensorFlow Jupyter image](https://hub.docker.com/r/tensorflow/tensorflow) is used as an example. This image includes both TensorFlow and Jupyter Notebook, so you can run TensorFlow workloads directly in a notebook environment. #### Create a container VM with a custom Docker image 1. In the [web console](https://console.nebius.com), go to **Compute** → **Container VMs**. 2. Click **Create container VM**. 3. Specify the VM name. 4. Select **Custom Image**. 5. In **Docker Image**, enter `tensorflow/tensorflow:nightly-gpu-jupyter`. 6. In **Docker run arguments**, specify `--restart=always --gpus all --shm-size=16GB -p 8888:8888`. These arguments enable GPU access, allocate shared memory and expose port 8888 for Jupyter Notebook. 7. In **Computing resources**, use at least one GPU. 8. In **Local storage**, specify the disk size. 9. In **Access**, select the previously created credentials. 10. Click **Create container VM**. #### Connect to the VM When the container VM is running, connect to the application: 1. In the **Container VMs** section, open the page of the VM with the custom Docker image installed. 2. In the **Network** section, copy the **Public IPv4** address. 3. Connect to the VM by using SSH: ```bash ssh @ ``` 4. List the running containers and copy the name of the TensorFlow container: ```bash sudo docker ps ``` 5. Get the Jupyter token: ```bash sudo docker logs ``` 6. Open in browser `http://:8888/?token=`. 7. In JupyterLab, create a new notebook and run the following code to verify that TensorFlow works in the container: ```python import tensorflow as tf import time matrix_size = 10000 a = tf.random.normal([matrix_size, matrix_size]) b = tf.random.normal([matrix_size, matrix_size]) start = time.time() c = tf.matmul(a, b) _ = c.numpy() end = time.time() print(f"Matrix multiplication ({matrix_size}x{matrix_size}) took {end - start:.4f} ``` Example output: ```text Matrix multiplication (10000x10000) took 1.9316 seconds ``` This example performs large matrix multiplication by using TensorFlow and prints the execution time. ## How to delete the created resources The created Compute VMs and their boot disks are chargeable. If you do not need them, delete the resources created during this tutorial: 1. Go to **Compute** → **Container VMs**. 2. Open the VM page. 3. Switch to **Settings**. 4. Click **Delete virtual machine**. 5. In the window that opens, select **Delete the boot disk**. 6. Confirm the deletion. 7. Repeat these steps for any other VMs created during this tutorial. # Capacity advisor for GPU availability in Nebius AI Cloud Source: https://docs.nebius.com/compute/virtual-machines/capacity-advisor.md export const RolePrerequisite = ({role, defaultGroup}) => { return <> Make sure that you are in a group that has at least the {role} role within your tenant {defaultGroup ? <>; for example, the default {defaultGroup} group : ""}. You can check this in the Administration → IAM section of the web console. ; }; Nebius AI Cloud's *capacity advisor* provides insights into GPU capacity availability for launching virtual machines (VMs) with specific hardware presets. It helps you understand where you can launch VMs based on your [quotas](https://docs.nebius.com/compute/resources/quotas-limits.md) and the current physical capacity in Nebius AI Cloud [regions](https://docs.nebius.com/overview/regions.md). ## Scope The capacity advisor provides data for the following virtual machines with GPUs: * **By service**: * VMs that you create directly in Compute * [Managed Soperator](https://docs.nebius.com/slurm-soperator/index.md) nodes * [Managed Kubernetes®](https://docs.nebius.com/kubernetes/index.md) nodes * VMs launched by [Serverless AI](https://docs.nebius.com/serverless/index.md) for running jobs and endpoints * **By type**: * [Regular VMs](https://docs.nebius.com/compute/virtual-machines/manage.md) * [Preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md) * [VMs with reservations](https://docs.nebius.com/compute/virtual-machines/reservations.md) * [Container VMs](https://docs.nebius.com/compute/virtual-machines/containers.md) Data about computing resource availability of [standalone applications](https://docs.nebius.com/applications/types.md) and VMs without GPUs isn't provided. Data provided by the capacity advisor is accurate as of a specific timestamp included in the data and doesn't guarantee availability of GPU resources at creation time. ## Prerequisites 1. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. 2. Nebius AI Cloud provider for Terraform doesn't support the capacity advisor. ## How to get data from the capacity advisor In the sidebar, go to **Administration** → **Capacity dashboard**. For each VM platform, preset, region, InfiniBand™ fabric and VM type (regular, preemptible or with reservations), the capacity advisor shows: * How many VMs you can launch, based on your quotas and the current physical capacity (for regular and [preemptible](https://docs.nebius.com/compute/virtual-machines/preemptible.md) VMs) or on your active [capacity reservations](https://docs.nebius.com/compute/virtual-machines/reservations.md) (for VMs with reservations). * How likely you are to be able to launch the displayed number of regular or preemptible VMs. > For example, if your quota for a certain kind of VMs is 10 VMs, you have a high chance of launching them all when the overall capacity is in the hundreds, but a low chance when the capacity is less than 10 VMs. As reservations guarantee you a certain number of GPUs that aren't subject to quotas, the chance of launch isn't displayed for VMs with reservations. 1. Get the tenant ID. To get the tenant ID, go to the [web console](https://console.nebius.com) and expand the top-left list of tenants. Next to the tenant’s name, click → **Copy tenant ID**. 2. Run `nebius capacity resource-advice list` to get the capacity advisor data: ```bash nebius capacity resource-advice list --parent-id ``` In the output, each list item contains data for a single combination of VM platform, preset, region, InfiniBand fabric and VM type: ```yaml highlight={3-8,15-16,19-22,25-28} items: - spec: region: eu-north1 fabric: fabric-2 compute_instance: platform: gpu-h100-sxm preset: name: 1gpu-16vcpu-200gb resources: vcpu_count: 16 memory_gibibytes: 200 gpu_count: 1 gpu_memory_gigabytes: 80 status: reserved: availability_level: AVAILABILITY_LEVEL_LIMIT_REACHED data_state: DATA_STATE_FRESH effective_at: "2026-03-27T11:25:55.695087Z" on_demand: available: 24 limit: 32 availability_level: AVAILABILITY_LEVEL_HIGH data_state: DATA_STATE_FRESH effective_at: "2026-03-27T11:08:07.360Z" preemptible: available: 22 limit: 128 availability_level: AVAILABILITY_LEVEL_MEDIUM data_state: DATA_STATE_FRESH effective_at: "2026-03-27T11:08:07.360Z" ... ``` In the `.items[*].status` fields, `on_demand`, `preemptible` and `reserved` contain data about regular VMs, preemptible VMs and VMs with reservations, respectively. Each of these fields contains the following data: * `available`: Maximum number of VMs that you can launch, based on your quotas and the current physical capacity. * `limit`: Your current quota. * `availability_level`: Level of resource availability. Possible values: * `AVAILABILITY_LEVEL_LOW`: **Low chance of launch** — Available capacity is significantly lower than your quota. Creating resources might not be possible. * `AVAILABILITY_LEVEL_MEDIUM`: **Medium chance of launch** — Available capacity is lower than your quota. Creating resources is possible, but may fail. * `AVAILABILITY_LEVEL_HIGH`: **High chance of launch** — Available capacity is enough to fully satisfy your quota. * `AVAILABILITY_LEVEL_LIMIT_REACHED`: **Launch impossible** — No available capacity. * `data_state`: State of the data. Possible values: * `DATA_STATE_FRESH`: Data is up to date (fetched recently). * `DATA_STATE_STALE`: Data is stale (fetched a long time ago). * `DATA_STATE_UNKNOWN`: Capacity advisor failed to fetch data. * `effective_at`: Timestamp of the last update. # Capacity reservations for Compute virtual machines Source: https://docs.nebius.com/compute/virtual-machines/reservations.md To make sure that GPU capacity is always available for your virtual machines (VMs), you can reserve GPUs. A *reservation* represents a [capacity block group](https://docs.nebius.com/overview/limits/capacity-block-groups.md), and it reserves a specific number of GPUs that are allocated to your infrastructure. GPUs from a reservation remain available, even if a VM is stopped. Without reservations, GPU capacity is taken from a shared pool and returned when a VM is stopped (for example, by you or a [maintenance event](https://docs.nebius.com/compute/virtual-machines/maintenance.md)). To start using reservations, send a request to your Nebius manager. In this request, specify how many GPUs you would like to reserve and for what period. If you are not in contact with a Nebius manager, you can ask [technical support](https://console.nebius.com/support/create-ticket) to connect you with one. After reservations are ready, you can add them to your VMs when you create or update these VMs. You can also check your capacity block groups on the **Limits** page and get detailed information about them. For more information, see [List of capacity block groups](https://docs.nebius.com/overview/limits/capacity-block-groups.md#list-of-capacity-block-groups). GPUs allocated from reservations do not count towards [quotas on the number of GPUs](https://docs.nebius.com/compute/resources/quotas-limits.md#gpu-virtual-machines). ## How to add reservations to VMs VMs of a regular type and with GPUs support reservations. [Preemptible VMs](https://docs.nebius.com/compute/virtual-machines/preemptible.md) and VMs without GPUs do not support them. If you want to [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) and you have [capacity block groups](https://docs.nebius.com/overview/limits/capacity-block-groups.md), on the **General** step, select **Reserved VM**. On the **Compute** step, select a platform and configure the **Reservation** settings. If you do not have capacity block groups, the wizard skips the **General** step and opens **Compute** instead. If you want to modify an existing VM, [stop it](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-vms-manually) first and then go to its **Settings** tab on the VM page. Next, update the reservation settings. The **Reservation** section is only displayed if you have capacity block groups. In the **Reservation** section, you can configure the following options: * **Any (existing and future)** (default): Compute selects among your matching capacity block groups automatically. * **Specific capacity block groups**: Select one or more capacity block groups. Each option shows the capacity block group ID, reservation period and GPU usage. Make sure the selected groups have enough capacity and do not expire soon. * **Switch to PAYG**: Choose whether the VM can start after you create or restart it without active intervals in selected capacity block groups: * **When reservation is exhausted** (default): The VM can start as a pay-as-you-go VM when no capacity is available in the selected capacity block groups. * **Never**: The VM cannot start without available capacity in the selected capacity block groups. This does not affect the VM when it is running. If an interval in a selected capacity block group expires while the VM is running, the VM always continues as a pay-as-you-go VM, regardless of this setting. If you have capacity block groups in multiple regions, select a **Region** first. Use the `--reservation-policy-*` parameters when creating or updating a VM: * To create a VM, use the following command: ```bash nebius compute instance create \ ... \ --reservation-policy-policy \ --reservation-policy-reservation-ids ``` * To update a VM, [stop it](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-vms-manually) first and then use the following command: ```bash nebius compute instance update \ ... \ --reservation-policy-policy \ --reservation-policy-reservation-ids ``` Description of the parameters: * `--reservation-policy-policy`: Policy for reservation usage. Supports the following values: * `auto`: VM resources are allocated from reservations. If no reservations are currently available, the VM runs without them. In this case, resources for the VM are provided from the common pool. The `auto` value is default. If you don't have any reservations and you don't set the `--reservation-policy-policy` parameter, the `auto` value applies and the VM runs without reservations. * `forbid`: VM resources are provided from the common pool, and no reservations are used. * `strict`: VM resources are exclusively allocated from reservations. The VM doesn't run without the reservations. * `--reservation-policy-reservation-ids` (optional): IDs of specific reservations (capacity block groups). Use this parameter only if you need specific reservations. Specify the IDs in the order in which reservations should apply. For instance, resources should be allocated from the first specified reservation. When it is exhausted or expired, the service uses resources from the second specified reservation, and so on. Make sure to select reservations that have enough capacity and that do not expire in several days. To find out how different combinations of parameter values impact the result, see the table below: | `policy` | `reservation-ids` | **Behavior** | | -------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `auto` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, VM resources are provided from the common pool, not from a reservation. | | `auto` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit (for example, they are not currently active or there are not enough GPUs), VM resources are provided from the common pool. | | `forbid` | Not specified | VM resources are provided from the common pool. No reservations are used. | | `forbid` | Specified | Not supported. If you apply this combination, it will result in a validation error. | | `strict` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, a request for creating or updating a VM fails. | | `strict` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit, a request for creating or updating a VM fails. | Use the `reservation_policy` parameter in the VM configuration: ```hcl resource "nebius_compute_v1_instance" "my_vm" { ... reservation_policy = { policy = "" reservation_ids = "" } ... } ``` Description of the parameters: * `policy`: Policy for reservation usage. Supports the following values: * `AUTO`: VM resources are allocated from reservations. If no reservations are currently available, the VM runs without them. In this case, resources for the VM are provided from the common pool. The `AUTO` value is default. If you don't have any reservations and you don't set the `policy` parameter, the `AUTO` value applies and the VM runs without reservations. * `FORBID`: VM resources are provided from the common pool, and no reservations are used. * `STRICT`: VM resources are exclusively allocated from reservations. The VM doesn't run without the reservations. * `reservation_ids`: IDs of specific reservations (capacity block groups). You can use this parameter with the `AUTO` and `STRICT` reservation usages: Specify the IDs in the order in which reservations should apply. For instance, resources should be allocated from the first specified reservation. When it is exhausted or expired, the service uses resources from the second specified reservation, and so on. Make sure to select reservations that have enough capacity and that do not expire in several days. To find out how different combinations of parameter values impact the result, see the table below: | `policy` | `reservation_ids` | **Behavior** | | -------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `AUTO` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, VM resources are provided from the common pool, not from a reservation. | | `AUTO` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit (for example, they are not currently active or there are not enough GPUs), VM resources are provided from the common pool. | | `FORBID` | Not specified | VM resources are provided from the common pool. No reservations are used. | | `FORBID` | Specified | Not supported. If you apply this combination, it will result in a validation error. | | `STRICT` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, a request for creating or updating a VM fails. | | `STRICT` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit, a request for creating or updating a VM fails. | Use `ReservationPolicy` in `InstanceSpec` when creating or updating a VM: ```go reservationPolicy := &compute.ReservationPolicy{ Policy: compute.ReservationPolicy_STRICT, ReservationIds: []string{ "", }, } ``` Description of the parameters: * `Policy`: Policy for reservation usage. Supports the `AUTO`, `FORBID` and `STRICT` values. * `ReservationIds` (optional): IDs of specific reservations (capacity block groups). Use this parameter only if you need specific reservations. Specify the IDs in the order in which reservations should apply. For instance, resources should be allocated from the first specified reservation. When it is exhausted or expired, the service uses resources from the second specified reservation, and so on. Make sure to select reservations that have enough capacity and that do not expire in several days. To find out how different combinations of parameter values impact the result, see the table below: | `Policy` | `ReservationIds` | **Behavior** | | -------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `AUTO` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, VM resources are provided from the common pool, not from a reservation. | | `AUTO` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit (for example, they are not currently active or there are not enough GPUs), VM resources are provided from the common pool. | | `FORBID` | Not specified | VM resources are provided from the common pool. No reservations are used. | | `FORBID` | Specified | Not supported. If you apply this combination, it will result in a validation error. | | `STRICT` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, a request for creating or updating a VM fails. | | `STRICT` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit, a request for creating or updating a VM fails. | Use `reservation_policy` in `InstanceSpec` when creating or updating a VM: ```python reservation_policy = ReservationPolicy( policy=ReservationPolicy.Policy.STRICT, reservation_ids=[""], ) ``` Description of the parameters: * `policy`: Policy for reservation usage. Supports the `AUTO`, `FORBID` and `STRICT` values. * `reservation_ids` (optional): IDs of specific reservations (capacity block groups). Use this parameter only if you need specific reservations. Specify the IDs in the order in which reservations should apply. For instance, resources should be allocated from the first specified reservation. When it is exhausted or expired, the service uses resources from the second specified reservation, and so on. Make sure to select reservations that have enough capacity and that do not expire in several days. To find out how different combinations of parameter values impact the result, see the table below: | `policy` | `reservation_ids` | **Behavior** | | -------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `AUTO` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, VM resources are provided from the common pool, not from a reservation. | | `AUTO` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit (for example, they are not currently active or there are not enough GPUs), VM resources are provided from the common pool. | | `FORBID` | Not specified | VM resources are provided from the common pool. No reservations are used. | | `FORBID` | Specified | Not supported. If you apply this combination, it will result in a validation error. | | `STRICT` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, a request for creating or updating a VM fails. | | `STRICT` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit, a request for creating or updating a VM fails. | Use `reservationPolicy` in `InstanceSpec` when creating or updating a VM: ```ts const reservationPolicy = ReservationPolicy.create({ policy: ReservationPolicy_Policy.STRICT, reservationIds: [""], }); ``` Description of the parameters: * `policy`: Policy for reservation usage. Supports the `AUTO`, `FORBID` and `STRICT` values. * `reservationIds` (optional): IDs of specific reservations (capacity block groups). Use this parameter only if you need specific reservations. Specify the IDs in the order in which reservations should apply. For instance, resources should be allocated from the first specified reservation. When it is exhausted or expired, the service uses resources from the second specified reservation, and so on. Make sure to select reservations that have enough capacity and that do not expire in several days. To find out how different combinations of parameter values impact the result, see the table below: | `policy` | `reservationIds` | **Behavior** | | -------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `AUTO` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, VM resources are provided from the common pool, not from a reservation. | | `AUTO` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit (for example, they are not currently active or there are not enough GPUs), VM resources are provided from the common pool. | | `FORBID` | Not specified | VM resources are provided from the common pool. No reservations are used. | | `FORBID` | Specified | Not supported. If you apply this combination, it will result in a validation error. | | `STRICT` | Not specified | Compute tries to launch a VM in any available and suitable reservation. If none is found, a request for creating or updating a VM fails. | | `STRICT` | Specified | Compute tries to launch a VM in one of the specified reservations. If none of them fit, a request for creating or updating a VM fails. | ## How to find information about reservations for an already configured VM You can check the list of VMs and an overview of a given VM to find information about the VM reservations. ### List of VMs The [list of VMs](https://console.nebius.com/compute) provides the following: * The **Platform and VM type** column shows what configuration you have set up for a given VM. * The **Current reservations** column shows what reservations are currently used. Data in these columns does not always match: * If a VM is preemptible or stopped, **Current reservations** do not show any data (**N/A** is displayed). * If capacity in reservations is exhausted, **Current reservations** show that there are no reservations currently consumed. ### VM overview On the VM page, on the **VM overview** tab, in the **Resource capacity** block, you can find more detailed information: * The **VM type**, **Reservation usage** and **If no capacity** fields show the configuration that you have set up. * The **Current reservations** and **Next interval** fields show the current consumption of reservations. If the VM runs without reservations, no data about them is displayed. ## Billing for reservations Reservations and [billing models](https://docs.nebius.com/signup-billing/billing-models/overview.md) do not match directly. If your VMs run without reservations, this does not mean that the pay-as-you-go (PAYG) pricing applies by default for these VMs. It depends on whether you have an addendum for the commitment discounts. When a Nebius manager creates reservations for you, they also prepare an addendum for the commitment discounts. After the addendum comes into force, you are charged for VMs based on this billing model. If your VM runs without reservations, the service still charges you based on the commitment discounts because of the addendum. If you do not have the addendum, your VMs are based on PAYG. ## See also * [Capacity block groups in Nebius AI Cloud](https://docs.nebius.com/overview/limits/capacity-block-groups.md) * [Capacity reservations for Managed Service for Kubernetes® node groups](https://docs.nebius.com/kubernetes/node-groups/reservations.md) # Running AI workloads on VMs Source: https://docs.nebius.com/compute/clusters/ai-workloads.md You can run AI workloads on Compute VMs by using third-party tools. Information about how to do it is now located in separate documentation. See [Third-party integrations with Nebius AI Cloud](https://docs.nebius.com/3p-integrations/index.md). # Types of storage volumes in Compute Source: https://docs.nebius.com/compute/storage/types.md In Compute, storage resources that can be added to virtual machines (VMs) as separate managed resources are called *volumes*. Compute offers two types of managed volumes and one host-local storage option: * [Disks](https://docs.nebius.com/compute/storage/types.md#disks): * **Network SSD disks**: managed *block storage* volumes. * **Local SSD disks**: *ephemeral* host-local block storage. * [Shared filesystems](https://docs.nebius.com/compute/storage/types.md#shared-filesystems) are *file storage* volumes. A filesystem can be shared by multiple VMs. Nebius AI Cloud also provides *object storage* through a separate service, [Object Storage](https://docs.nebius.com/object-storage/index.md). Together, these block, file and object storage options cover all [use cases](https://docs.nebius.com/compute/storage/types.md#use-cases-and-suggestions) for data preparation, training and inference workloads, as well as associated infrastructure (boot disks, database hosts etc.) ## Disks *Disks* provide block storage for Compute VMs. Data that you put on disks is divided into blocks that are stored efficiently and reliably on underlying physical drives. You can create boot disks and additional disks. A *boot disk* is a core disk in a VM, and an *additional disk* is mainly for data storage. Compute provides different disk sources: * [Public disk images](https://docs.nebius.com/compute/storage/boot-disk-images.md) supported by the platform. * [Custom disk images](https://docs.nebius.com/compute/storage/custom-disk-images.md) that you create and tailor to your needs. * Custom image families that contain a series of custom images and provide the latest image for the disk. * [Disk snapshots](https://docs.nebius.com/compute/storage/disk-snapshots.md), which are point-in-time copies of a disk state. Alternatively, you can [create](https://docs.nebius.com/compute/storage/manage.md#how-to-create-a-disk) a blank disk. Images and image families are only supported for boot disks. ### Network and local SSD disks Compute offers two kinds of disks: * [Network SSD disks](https://docs.nebius.com/compute/storage/types.md#network-ssd-disks) can be created as a boot disk for a VM, from one of the boot disk images provided by Nebius AI Cloud, or as an empty additional disk. One Compute network SSD disk can only be added to one running VM at a time. * [Local SSD disks](https://docs.nebius.com/compute/storage/types.md#local-ssd-disks) are Non-Volatile Memory Express (NVMe) drives physically attached to the Compute host that runs a virtual machine (VM). They are not created or managed as separate storage resources, and you can only add them when [creating a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). #### Network SSD disks * **Network SSD** (`network_ssd`) Reliable disks backed by solid state drives (SSDs). Best used for infrastructure purposes: as VM boot disks, disks on Slurm controller VMs, etc. Reliability of Network SSD disks is ensured by means of [erasure coding](https://en.wikipedia.org/wiki/Erasure_code). A disk will tolerate up to two concurrent hardware failures in the Nebius AI Cloud [region](https://docs.nebius.com/overview/regions.md). * **Network SSD Non-replicated** (Network SSD NRD, `network_ssd_non_replicated`) High-performance disks backed by SSDs. Best used as temporary storage without strict reliability requirements, e.g., a boot disk for nodes in Managed Service for Kubernetes® clusters where redundancy is less important. Data blocks of Network SSD Non-replicated disks are stored in [NVMe namespaces](https://nvmexpress.org/resource/nvme-namespaces/) on underlying SSDs. The size of each namespace is 93 GiB, so the disk size must be a multiple of 93 GiB. Network SSD Non-replicated disks have no redundancy. It's not recommended to store any persistent data on these disks. If a disk fails, its data will be lost. * **Network SSD IO M3** (`network_ssd_io_m3`) High-performance and reliable disks backed by SSDs. Best used in performance-critical storage solutions, e.g., as storage disks in GlusterFS clusters. In addition to performance levels similar to Network SSD Non-replicated disks, Network SSD IO M3 disks are reliable through replication, with each disk's data mirrored to three physical drives. In the disk type name, "IO" stands for "input/output (optimized)" and "M3" stands for "mirrors 3". #### Local SSD disks Consider local SSD disks if your workload needs high-performance, low-latency storage for data that can be recreated. Local SSD disks are ephemeral, meaning temporary: their data is erased when the VM is stopped or deleted. Local SSD disks are available only on some platforms, presets and regions. For details, see [Availability](https://docs.nebius.com/compute/storage/local-disks.md#availability). Local SSD disks are useful for: * Scratch space for files and intermediate outputs that can be recreated. * Training or inference workloads that require low latency. * Read or write caches for data that can be recreated. ### Disk types comparison Network SSD disk types are differentiated by several characteristics: * **Performance** (bandwidth and IOPS): Local SSD > SSD IO M3 = SSD Non-replicated > SSD * **Reliability**: SSD IO M3 > SSD > SSD Non-replicated = Local SSD * **Price per 1 GiB per month**: SSD Non-replicated \< Local SSD \< SSD \< SSD IO M3 You can choose the size of a network disk, but local SSD disks are attached to the VM host as part of a predefined configuration for the selected platform and preset. For more details, see the following comparison table. The values for local SSD disks are the performance numbers per one local SSD disk. The bandwidth and IOPS values below are upper bounds; actual performance depends on workload. | **Disk type** | **Network SSD** | **Network SSD NRD** | **Network SSD IO M3** | **Local SSD disk**¹ | | -------------------------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------ | ------------------------------------------------ | ----------------------------------- | | Capacity | 1–8192 GiB (= 8 TiB) | 93–262,074 GiB (\~ 256 TiB), multiples of 93 GiB | 93–262,074 GiB (\~ 256 TiB), multiples of 93 GiB | 3.5 TiB | | Read/write bandwidth | 450 MiB/s | 2 GiB/s | 2 GiB/s | Read: 6.8 GB/s
Write: 2.6 GB/s | | Read IOPS | 20,000 | 75,000 | 75,000 | 510,000 | | Write IOPS | 20,000 | 75,000 | 75,000 | 350,000 | | Reliability features | Erasure coding – tolerates two concurrent hardware failures | None | Replication – data mirrored to three drives | None | | [Price per 1 GiB per month](https://docs.nebius.com/compute/resources/pricing.md)² | \$0.071 | \$0.053 | \$0.118 | \$0.065 | ¹ For local SSD disks, the listed values are achieved under synthetic workload. ² The listed prices are valid as of March 9, 2026. For up-to-date prices, see [Price per 1 GiB per month](https://docs.nebius.com/compute/resources/pricing.md). ### VM-managed and standalone disks When you [create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md), you can use either VM-managed or standalone disks: * *VM-managed disks* are the disks that you create along with the VM. Their lifecycle is tied to the VM. When you delete the VM, all of its VM-managed disks are deleted with the VM in a single operation. This makes VM-managed disks a good fit for ephemeral workloads, for example, training jobs or inference clusters where the VM and its storage should be cleaned up together. * *Standalone disks* are the disks that you create separately from the VM and attach them later to the VM by using the disk ID. Use standalone disks when you need them to persist independently after the VM is deleted, for example, to reattach them to another VM or to enable deletion protection. Renaming a VM-managed disk deletes the existing disk and creates a new one with a new name. All data on the disk is permanently lost. To rename a VM-managed disk without data loss, [convert it to a standalone disk](https://docs.nebius.com/compute/storage/manage.md#how-to-make-a-disk-vm-managed-or-standalone) and then rename it. ### Encryption of disks To store personal and other sensitive data securely, and to reduce the risk of unauthorized access, you can enable data encryption. To do so, [create a disk](https://docs.nebius.com/compute/storage/manage.md#how-to-create-a-disk) with data encryption enabled. For Network SSD disks, encryption is enabled by default and cannot be disabled. For Network SSD NRD and Network SSD IO M3 disks, encryption is optional and you can enable it. Encryption is available for both boot disks and secondary disks. Local SSD disks are not encrypted and no other data protection method is applied to them. Ensuring the protection of data stored on these devices is your responsibility. We don't recommend using local SSD disks for data that can't be recreated. For more information, see [Encryption in Nebius AI Cloud](https://docs.nebius.com/security/encryption.md). ### Disk performance Disk performance depends on both the disk type and its size — it increases as you add more allocation units. Every allocation unit contributes equally to the overall bandwidth and IOPS until you reach the [upper bounds](https://docs.nebius.com/compute/storage/types.md#disk-types-comparison) for the disk. While you have fewer allocation units than needed to reach the upper bounds, the disk performance equals the sum of each unit's performance. Once the sum reaches the upper bound for bandwidth or IOPS, adding more capacity does not increase performance any further. Disk performance metrics per allocation unit are shown in the following table. The bandwidth and IOPS values below are upper bounds; actual performance depends on workload. | **Disk type** | **Network SSD** | **Network SSD NRD** | **Network SSD IO M3** | **Local SSD disk**¹ | | ------------------------ | --------------- | ------------------- | --------------------- | ------------------- | | Allocation unit size | 32 GiB | 93 GiB | 93 GiB | 3.5 TiB | | Read bandwidth per unit | 15 MiB/s | 110 MiB/s | 110 MiB/s | 6.8 GB/s | | Write bandwidth per unit | 15 MiB/s | 82 MiB/s | 82 MiB/s | 2.6 GB/s | | Read IOPS per unit | 1,000 | 28,000 | 28,000 | 510,000 | | Write IOPS per unit | 1,000 | 5,600 | 5,600 | 350,000 | ¹ For local SSD disks, the listed values are peak numbers achieved per disk under synthetic workload. Disk encryption also affects the disk performance. Encryption requires additional processing of write operations; therefore, it can reduce performance by up to 15%. Local SSD disks can only be enabled during VM creation, cannot be scaled later, and are available only in fixed configurations. For supported configurations, see [Using local SSD disks on Compute virtual machines](https://docs.nebius.com/compute/storage/local-disks.md#availability). For other disks, you can choose your disk size in multiples of its allocation units to achieve the desired performance. Examples: How to reach the maximum for each disk performance metric: * Read/write bandwidth: * Maximum overall bandwidth is 450 MiB/s. * Number of allocation units needed to achieve it = Maximum overall read/write bandwidth ÷ Maximum read/write bandwidth per unit = 450 MiB/s ÷ 15 MiB/s = 30 units. * Minimum disk size = 30 × 32 GiB = 960 GiB. * Read IOPS: * Maximum overall read IOPS is 20,000. * Number of allocation units needed to achieve it = Maximum overall read IOPS ÷ Maximum overall read IOPS per unit = 20,000 ÷ 1,000 = 20 units. * Minimum disk size = 20 × 32 GiB = 640 GiB. * Write IOPS: * Maximum overall write IOPS is 20,000. * Number of allocation units needed to achieve it = Maximum overall write IOPS ÷ Maximum write IOPS per unit = 20,000 ÷ 1,000 = 20 units. * Minimum disk size = 20 × 32 GiB = 640 GiB. To achieve the maximum disk performance for all metrics, you need a disk of 960 GiB or more. How to reach the maximum for each disk performance metric: * Read bandwidth: * Maximum overall read bandwidth is 2 GiB/s. * Number of allocation units needed to achieve it = Maximum overall read bandwidth ÷ Maximum read bandwidth per unit = 2048 MiB/s ÷ 110 MiB/s ≈ 18.62, rounding up to 19 units. * Minimum disk size = 19 × 93 GiB = 1767 GiB. * Write bandwidth: * Maximum overall write bandwidth is 2 GiB/s. * Number of allocation units needed to achieve it = Maximum overall write bandwidth ÷ Maximum write bandwidth per unit = 2048 MiB/s ÷ 82 MiB/s ≈ 24.98, rounding up to 25 units. * Minimum disk size = 25 × 93 GiB = 2325 GiB. * Read IOPS: * Maximum overall read IOPS is 75,000. * Number of allocation units needed to achieve it = Maximum overall read IOPS ÷ Maximum read IOPS per unit = 75,000 ÷ 28,000 ≈ 2.68, rounding up to 3 units. * Minimum disk size = 3 × 93 GiB = 279 GiB. * Write IOPS: * Maximum overall write IOPS is 75,000. * Number of allocation units needed to achieve it = Maximum overall write IOPS ÷ Maximum write IOPS per unit = 75,000 ÷ 5,600 ≈ 13.39, rounding up to 14 units. * Minimum disk size = 14 × 93 GiB = 1302 GiB. To achieve the maximum disk performance for all metrics, you need a disk of 2325 GiB or more. ## Shared filesystems Shared filesystems provide file storage for Compute VMs. When VMs work with file storage, they work with a hierarchy of folders and files, as opposed to blocks when disks are involved. One shared filesystem can be attached to multiple VMs at once. All VMs that the filesystem is attached to must belong to the same [project](https://docs.nebius.com/iam/overview.md#projects). Sharing a filesystem across projects is not supported, even if the projects are in the same [region](https://docs.nebius.com/overview/regions.md). To use a shared filesystem on a VM that it is attached to, you must mount it as a virtiofs device. Filesystems support [data encryption](https://docs.nebius.com/security/encryption.md) by default; you cannot disable it. Encryption allows you to store personal and other sensitive data on filesystems securely, and reduce the risk of unauthorized access. ### Filesystem specifications Nebius provides shared filesystems that are generally based on solid state drives (`network_ssd` in developer tools such as Nebius AI Cloud CLI or provider for Terraform) to back them up. Shared filesystems have the following specifications: * Capacity: 1–5,242,880 GiB (= 5120 TiB = 5 PiB) * Read bandwidth per client: up to 12 GiB/s * Write bandwidth per client: up to 8 GiB/s * Aggregate read bandwidth: up to 940 GiB/s * Aggregate write bandwidth: up to 475 GiB/s * Maximum file size: 512 GiB × filesystem's [block size](https://docs.nebius.com/compute/storage/manage.md#type-encryption-and-size) in KiB (for example, for the default block size it will be 512 GiB × 4 = 2TiB) * Maximum number of [inodes](https://www.kernel.org/doc/html/v6.3/filesystems/vfs.html#the-inode-object): * For filesystems up to 256 GiB: 4,194,304 (4 × 2²⁰) * For filesystems larger than 256 GiB: filesystem's size ÷ 64 KiB For example, if the filesystem's size is 512 GiB, its maximum number of inodes is (512 × 2³⁰) ÷ (64 × 2¹⁰) = 8 × 2²⁰ = 8,388,608. * Reliability features: Erasure coding – tolerates two concurrent hardware failures * [Price per 1 GiB per month](https://docs.nebius.com/compute/resources/pricing.md)¹: \$0.08 ¹ The price is shown as of July 2, 2025. For up-to-date prices, see [Price per 1 GiB per month](https://docs.nebius.com/compute/resources/pricing.md). ### Filesystem performance Filesystem performance depends on its size — performance increases with each 4 TiB of the filesystem size. Every 4 TiB contributes equally to the overall bandwidth until you reach the [upper bounds](https://docs.nebius.com/compute/storage/types.md#filesystem-specifications) for the filesystem. Each 4 TiB of SSD filesystem improves the performance metrics by the following values: * Read bandwidth: by up to 3.70 GiB/s. * Write bandwidth: by up to 1.89 GiB/s. ## Storage types comparison | Characteristic | [Local SSD disks](https://docs.nebius.com/compute/storage/types.md#local-ssd-disks) | [Network disks](https://docs.nebius.com/compute/storage/types.md#disks) | [Shared filesystems](https://docs.nebius.com/compute/storage/types.md#shared-filesystems) | | ---------------- | --------------------------------------------------------- | ------------------------------------------------------- | --------------------------------------------------------------- | | Durability | Ephemeral | Durable | Durable | | Attachment model | Tied to the VM run and physical host | Independent volume attached to one running VM at a time | Independent volume that can be shared by multiple VMs | | Capacity model | Preconfigured, all or none | User-defined | User-defined | ## Use cases and suggestions Here is an overview of various stages of ML/AI workloads and storage options that Compute and other Nebius AI Cloud services provide for these stages, as well as general suggestions for using Compute storage. ### Infrastructure * **VM boot disks: Network SSD disks** For OS and system data on your VMs, the main storage requirement is reliability, so the suggested disk type is Network SSD. * **VM storage disks: Network SSD IO M3 disks** If you are building storage solutions on VMs, e.g., GlusterFS clusters, use Network SSD IO M3 disks for speed and reliability. * **Managed Kubernetes node storage: Network SSD Non-replicated disks** For Kubernetes worker nodes where data reliability isn't a top priority (as the data is often transient), Network SSD Non-replicated disks provide high performance and low latency. * **Database hosts: Network SSD IO M3 disks** Database workloads often demand consistent and high input/output operations per second (IOPS), and Network SSD IO M3 disks offer the best combination of reliability and speed. ### Data preparation * **Storing and preprocessing datasets: Object Storage buckets** Object Storage is ideal for handling large, unstructured datasets and provides a scalable solution for preprocessing tasks like data normalization or augmentation. ### Training * **Streaming datasets to workers: SSD shared filesystems or Object Storage buckets** In most cases, SSD shared filesystems ensure fast access to datasets during training, without bottlenecks. For exceptionally large datasets (1 PiB+) or distributed training across external workers, Object Storage buckets provide a scalable solution. * **Sharing code between workers: SSD shared filesystems** By using SSD shared filesystems, multiple workers can efficiently access and synchronize code during distributed training, ensuring consistency and minimizing latency. * **Checkpoints: SSD shared filesystems, then Object Storage buckets** During training, SSD shared filesystems allow for quickly saving and loading checkpoints, thus ensuring minimal disruption. Once training is completed, asynchronous transfer to Object Storage reduces costs while maintaining accessibility for future use. * **Scratch space: local SSD disks** On [supported platforms, presets and regions](https://docs.nebius.com/compute/storage/local-disks.md#availability), [local SSD disks](https://docs.nebius.com/compute/storage/local-disks.md) provide host-local NVMe for data that can be recreated and benefits from high performance and low latency. Treat them as ephemeral and keep important data on durable storage. ### Inference * **Autoscaling, sharing weights between GPUs: SSD shared filesystems** When inference workloads require scaling across multiple VMs with GPUs, SSD shared filesystems allow for fast sharing of model weights, thus ensuring consistent performance across nodes during autoscaling. * **Sharing results: Object Storage buckets** Once inference tasks are completed, Object Storage is ideal for sharing outputs such as logs, predictions or reports with other users or systems, due to its scalable and cost-efficient nature. ### General suggestions * For maximum IOPS, reads and writes to a volume should be close to its [block size](https://docs.nebius.com/compute/storage/manage.md#type-encryption-and-size). * For maximum bandwidth, reads and writes to a volume should be in 4 MiB chunks. ## See also * [How to create a virtual machine](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) * [Managing Compute volumes](https://docs.nebius.com/compute/storage/manage.md) * [Attaching and mounting Compute volumes to VMs](https://docs.nebius.com/compute/storage/use.md) * [How to detach additional volumes from virtual machines](https://docs.nebius.com/compute/storage/detach-volume.md) * [Local SSD disks for Compute virtual machines](https://docs.nebius.com/compute/storage/local-disks.md) # Managing Compute volumes Source: https://docs.nebius.com/compute/storage/manage.md In this article, you will learn how to manage [Compute volumes](https://docs.nebius.com/compute/storage/types.md): Network SSD disks and shared filesystems. Boot disks are added to virtual machines (VMs) immediately. To use secondary (additional) disks and shared filesystems on VMs after you create the volumes, you need to [attach and mount them to the VMs](https://docs.nebius.com/compute/storage/use.md). You can [detach these volumes](https://docs.nebius.com/compute/storage/detach-volume.md) later, if necessary. A VM and its volumes must be located in the same project. For more details about projects and resource hierarchy in Nebius AI Cloud, see [How resources, identities and access are managed in Nebius AI Cloud](https://docs.nebius.com/iam/overview.md). ## Prerequisites If you use the web console, you don't need to complete any prerequisites. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and configure](https://docs.nebius.com/terraform-provider/install.md) the Nebius AI Cloud provider for Terraform. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to create a disk 1. In the sidebar, go to **Storage** → **Disks**. 2. Click **Create disk**. 3. On the creation page, specify a disk name. 4. In **Disk source type**, select one of the supported sources for the disk: * **Blank disk**: Create a regular, blank disk. Suitable for any boot or additional disk. * **Public image**: Create a boot disk from one of [public images](https://docs.nebius.com/compute/storage/boot-disk-images.md) that Nebius AI Cloud provides. An image represents an operating system for the disk. * **Custom image**: Create a boot disk based on your [custom image](https://docs.nebius.com/compute/storage/custom-disk-images.md) that includes custom software. * **Custom image family**: Create a boot disk based on your custom image family. When you create custom images, you can add them to an arbitrary custom family. If an image family contains several images, the latest one is used. * **Snapshot**: Create a boot or additional disk based on a [disk snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md). 5. In **Storage configuration**, select the disk type. 6. (Optional) Enable [data encryption](https://docs.nebius.com/security/encryption.md) if you're creating a Network SSD Non-replicated or Network SSD IO M3 disk. Encryption is enabled by default for Network SSD disks. 7. Set the disk size and block size. 8. (Optional) Enable **Deletion protection** to prevent this disk from being accidentally deleted. 9. Click **Create disk**. Run the following command: ```bash nebius compute disk create \ --name \ --source-image-family-image-family \ --source-image-family-parent-id \ --source-image-id \ --source-snapshot-id \ --type network_ \ --disk-encryption-type disk_encryption_managed \ --size-gibibytes \ --block-size-bytes \ --forbid-deletion ``` For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). 1. Create the following configuration: ```hcl resource "nebius_compute_v1_disk" "" { name = "" parent_id = "" type = "NETWORK_" size_gibibytes = block_size_bytes = # Only for boot disks. Use one of the supported disk sources. source_image_family = { image_family = "" parent_id = "" # Optional: for custom image families only } source_image_id = "" source_snapshot_id = "" # Optional: only for NETWORK_SSD_NON_REPLICATED and NETWORK_SSD_IO_M3 disk_encryption = { type = "DISK_ENCRYPTION_MANAGED" } # Optional: protect disk from deletion forbid_deletion = true } ``` For `parent_id`, use the [project ID](https://docs.nebius.com/iam/manage-projects.md#terraform-3). For more information about other parameters, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). For the full reference on the disk resource, see [nebius\_compute\_v1\_disk](https://docs.nebius.com/terraform-provider/reference/resources/compute_v1_disk). 2. Check that the configuration is correct: ```bash terraform validate ``` 3. Apply the changes: ```bash terraform apply ``` ```go // One of compute.DiskSpec_NETWORK_SSD, // compute.DiskSpec_NETWORK_SSD_NON_REPLICATED, // or compute.DiskSpec_NETWORK_SSD_IO_M3. diskType := compute.DiskSpec_NETWORK_SSD_NON_REPLICATED diskEncryptionType := compute.DiskEncryption_DISK_ENCRYPTION_MANAGED operation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: , }, BlockSizeBytes: , Type: diskType, Source: &compute.DiskSpec_SourceImageFamily{ SourceImageFamily: &compute.SourceImageFamily{ ImageFamily: "", }, }, DiskEncryption: &compute.DiskEncryption{ Type: diskEncryptionType, }, ForbidDeletion: true, }, }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). ```python # One of DiskSpec.DiskType.NETWORK_SSD, # DiskSpec.DiskType.NETWORK_SSD_NON_REPLICATED, # or DiskSpec.DiskType.NETWORK_SSD_IO_M3. disk_type = DiskSpec.DiskType.NETWORK_SSD_NON_REPLICATED encryption_type = ( DiskEncryption.DiskEncryptionType.DISK_ENCRYPTION_MANAGED ) disk_service = DiskServiceClient(sdk) create_disk_operation = await disk_service.create( CreateDiskRequest( metadata=ResourceMetadata( name="", ), spec=DiskSpec( block_size_bytes=, type=disk_type, source_image_family=SourceImageFamily( image_family="", ), disk_encryption=DiskEncryption( type=encryption_type, ), forbid_deletion=True, size_gibibytes=, ), ), ) await create_disk_operation.wait() ``` For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). ```ts // One of DiskSpec_DiskType.NETWORK_SSD, // DiskSpec_DiskType.NETWORK_SSD_NON_REPLICATED, // or DiskSpec_DiskType.NETWORK_SSD_IO_M3. const diskType = DiskSpec_DiskType.NETWORK_SSD_NON_REPLICATED; const createDiskService = new DiskService(sdk); const createDiskOperation = await createDiskService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: DiskSpec.create({ blockSizeBytes: , type: diskType, source: { $case: "sourceImageFamily", sourceImageFamily: SourceImageFamily.create({ imageFamily: "", }), }, diskEncryption: DiskEncryption.create({ type: DiskEncryption_DiskEncryptionType.DISK_ENCRYPTION_MANAGED, }), forbidDeletion: true, size: { $case: "sizeGibibytes", sizeGibibytes: , }, }), }), ).result; await createDiskOperation.wait(); ``` For more information, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). For more information about how to start using secondary disks, see [Attaching and mounting Compute volumes to VMs](https://docs.nebius.com/compute/storage/use.md). ## How to create a shared filesystem 1. In the sidebar, go to **Storage** → **Shared filesystems**. 2. Click **Create filesystem**. 3. On the creation page, specify a filesystem name. 4. Set the filesystem size and block size. 5. (Optional) Enable **Deletion protection** to prevent this filesystem from being accidentally deleted. 6. Click **Create filesystem**. Run the following command: ```bash nebius compute filesystem create \ --name \ --type network_ssd \ --size-gibibytes \ --block-size-bytes \ --forbid-deletion ``` For more details about volume parameters, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). 1. Create the following configuration: ```hcl resource "nebius_compute_v1_filesystem" "" { name = "" parent_id = "" type = "NETWORK_SSD" size_gibibytes = block_size_bytes = # Optional: protect filesystem from deletion forbid_deletion = true } ``` For `parent_id`, use [project ID](https://docs.nebius.com/iam/manage-projects.md#terraform-3). For more information about other parameters, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). For the full reference on the filesystem resource, see [nebius\_compute\_v1\_filesystem](https://docs.nebius.com/terraform-provider/reference/resources/compute_v1_filesystem). 2. Check that the configuration is correct: ```bash terraform validate ``` 3. Apply the changes: ```bash terraform apply ``` ```go operation, err = sdk.Services().Compute().V1(). Filesystem().Create( ctx, &compute.CreateFilesystemRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.FilesystemSpec{ Size: &compute.FilesystemSpec_SizeGibibytes{ SizeGibibytes: , }, BlockSizeBytes: , Type: compute.FilesystemSpec_NETWORK_SSD, ForbidDeletion: true, }, }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` For more details about volume parameters, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). ```python filesystem_service = FilesystemServiceClient(sdk) create_filesystem_operation = await filesystem_service.create( CreateFilesystemRequest( metadata=ResourceMetadata( name="", ), spec=FilesystemSpec( block_size_bytes=, type=FilesystemSpec.FilesystemType.NETWORK_SSD, forbid_deletion=True, size_gibibytes=, ), ), ) await create_filesystem_operation.wait() ``` For more details about volume parameters, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). ```ts const createFilesystemService = new FilesystemService(sdk); const createFilesystemOperation = await createFilesystemService.create( CreateFilesystemRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: FilesystemSpec.create({ blockSizeBytes: , type: FilesystemSpec_FilesystemType.NETWORK_SSD, forbidDeletion: true, size: { $case: "sizeGibibytes", sizeGibibytes: , }, }), }), ).result; await createFilesystemOperation.wait(); ``` For more details about volume parameters, see [Volume parameters](https://docs.nebius.com/compute/storage/manage.md#volume-parameters). For more information about how to start using the created shared filesystem, see [Attaching and mounting Compute volumes to VMs](https://docs.nebius.com/compute/storage/use.md). ## Volume parameters Disks and shared filesystems share almost all of their parameters, except for boot disk image which can only be set for disks. CLI parameter names are shown in parentheses. Terraform uses the corresponding snake\_case attributes, and SDKs use the corresponding parameter names for each language, such as camelCase in JavaScript, as shown in the examples. ### Metadata **Name** (`name`): A Nebius AI Cloud resource name. It must be unique inside your tenant. Required at creation, cannot be changed after it. ### Type, encryption and size * **Type** (`type`): The volume type. See available types of [disks](https://docs.nebius.com/compute/storage/types.md#disk-types) and [shared filesystems](https://docs.nebius.com/compute/storage/types.md#filesystem-specifications). Required at creation, and cannot be changed later. * **Enable data encryption** (`disk-encryption-type`): Whether a volume should support [data encryption](https://docs.nebius.com/security/encryption.md). Encryption allows you to store personal and other sensitive data securely on volumes, and reduce the risk of unauthorized access. Use this parameter only for disks of the Network SSD Non-replicated and Network SSD IO M3 types. Filesystems and Network SSD disks support encryption by default, and you cannot disable it. For more information, see [Encryption of disks](https://docs.nebius.com/compute/storage/types.md#encryption-of-disks). In the CLI, use `--disk-encryption-type disk_encryption_managed` to enable encryption. * **Size** (`size-gibibytes`, `size-mebibytes`, `size-kibibytes` or `size-bytes`): The volume size. See requirements for sizes of [disks](https://docs.nebius.com/compute/storage/types.md#disk-types-comparison) and [shared filesystems](https://docs.nebius.com/compute/storage/types.md#filesystem-specifications) in their comparison tables. Required at creation. After creation, size can only be [increased](https://docs.nebius.com/compute/storage/manage.md#how-to-resize-a-volume). When using the CLI, you can set the volume size in GiB, MiB, KiB or B using a respective parameter. * **Block size** (`block-size-bytes`): The data block size for the volume. The data stored on the volume is divided into blocks of this size on the underlying physical drives. Cannot be changed after the volume is created. The block size must be a power of two between 4096 bytes (4 KiB) and 131,072 bytes (128 KiB). The default value is 4096 bytes (4 KiB). For maximum IOPS, reads and writes to a volume should be close to its block size. ### Disk sources Use one of the supported disk sources: * **Public image** (`source-image-family-image-family`): Create a boot disk from one of the [public images](https://docs.nebius.com/compute/storage/boot-disk-images.md) that Nebius AI Cloud provides. An image represents an operating system for the disk. * **Custom image** (`source-image-id`): Create a boot disk based on your [custom image](https://docs.nebius.com/compute/storage/custom-disk-images.md) that includes custom software. * **Custom image family** (both `source-image-family-image-family` and `source-image-family-parent-id`): Create a boot disk based on your custom image family. When you create custom images, you can add them to an arbitrary custom family. If an image family contains several images, the latest one is used. * **Snapshot** (`source-snapshot-id`): Create a boot or additional disk based on a [disk snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md). To create a blank additional disk, don't specify any disk source. ### Deletion protection * **Deletion protection** (`forbid-deletion`): Prevents the volume from being deleted. Use this parameter to protect disks and shared filesystems from accidental deletion, especially in automated environments such as CI/CD pipelines or Terraform configurations. Deletion protection can be enabled at creation time or changed at any time after creation. When enabled, any attempt to delete the volume fails with an error. To delete a protected volume, disable deletion protection first. ## How to resize a volume You can increase the size of an existing disk or shared filesystem. Reducing volume size is not possible. ### How to resize a disk Compute supports *hot resize*: the resize operation itself does not require stopping the VM. However, you need to restart the VM afterward for the operating system to recognize the new disk size. To resize a disk: 1. Change the disk size: 1. In the sidebar, go to **Storage** → **Disks**. Alternatively, go to the virtual machine where the disk is attached and find it in the **Disks** tab. 2. Click the disk you want to resize and go to the **Settings** tab. 3. In the **Parameters** section, enter the new **Size** value or use the slider to set the new size. 4. Click **Save changes**. 1. If you haven't saved the disk's ID when creating it, get its ID: ```bash export DISK_ID=$(nebius compute disk get-by-name \ --parent-id \ --name \ --format json | jq -r ".metadata.id") ``` 2. Run [nebius compute disk update](https://docs.nebius.com/cli/reference/compute/disk/update) and set the new size by using one of the `--size-gibibytes`, `--size-mebibytes`, `--size-kibibytes` or `--size-bytes` parameters: ```bash nebius compute disk update \ --id $DISK_ID \ --size-gibibytes ``` 1. In your Terraform configuration, update the `size_gibibytes` value (or `size_mebibytes`, `size_kibibytes`, `size_bytes`) in the disk resource. For example: ```hcl highlight={4} resource "nebius_compute_v1_disk" "" { name = "" ... size_gibibytes = } ``` 2. Check that the configuration is correct: ```bash terraform validate ``` 3. Apply the changes: ```bash terraform apply ``` 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```go disk, err := sdk.Services().Compute().V1(). Disk().GetByName( ctx, &common.GetByNameRequest{ ParentId: "", Name: "", }, ) if err != nil { return err } diskID := disk.GetMetadata().GetId() ``` For a filesystem, get its ID by name with the same parameters. 2. Update the disk or filesystem size. Here is an example for a disk: ```go disk, err = sdk.Services().Compute().V1(). Disk().Get( ctx, &compute.GetDiskRequest{ Id: diskID, }, ) if err != nil { return err } if disk.GetSpec() == nil { return errors.New("disk spec is missing") } disk.Spec.Size = &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: , } operation, err = sdk.Services().Compute().V1(). Disk().Update( ctx, &compute.UpdateDiskRequest{ Metadata: disk.Metadata, Spec: disk.Spec, }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```python disk_service = DiskServiceClient(sdk) disk = await disk_service.get_by_name( GetByNameRequest( parent_id="", name="", ), ) disk_id = disk.metadata.id ``` For a filesystem, get its ID by name with the same parameters. 2. Update the disk or filesystem size. Here is an example for a disk: ```python disk_service = DiskServiceClient(sdk) disk = await disk_service.get( GetDiskRequest(id=disk_id), ) if disk.spec is None: raise ValueError("disk spec is missing") disk.spec.size_gibibytes = update_disk_operation = await disk_service.update( UpdateDiskRequest( metadata=disk.metadata, spec=disk.spec, ), ) await update_disk_operation.wait() ``` 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```ts const getDiskByNameService = new DiskService(sdk); const diskByName = await getDiskByNameService.getByName( GetByNameRequest.create({ parentId: "", name: "", }), ); const diskId = diskByName.metadata?.id; if (!diskId) { throw new Error("disk ID is missing"); } ``` For a filesystem, get its ID by name with the same parameters. 2. Update the disk or filesystem size. Here is an example for a disk: ```ts const updateDiskService = new DiskService(sdk); const diskForResize = await updateDiskService.get( GetDiskRequest.create({ id: diskId, }), ); if (!diskForResize.spec) { throw new Error("disk spec is missing"); } diskForResize.spec.size = { $case: "sizeGibibytes", sizeGibibytes: , }; const updateDiskResizeOperation = await updateDiskService.update( UpdateDiskRequest.create({ metadata: diskForResize.metadata, spec: diskForResize.spec, }), ).result; await updateDiskResizeOperation.wait(); ``` 2. If you resized a secondary disk and it is currently attached to a running virtual machine, do the following: 1. [Restart](https://docs.nebius.com/compute/virtual-machines/stop-start.md#how-to-stop-and-start-vms-manually) this VM. 2. [Connect](https://docs.nebius.com/compute/virtual-machines/connect.md) to this VM. 3. Install the `cloud-guest-utils` package that manages the disk partitions: ```bash sudo apt-get update && sudo apt-get install -y cloud-guest-utils ``` 4. List disks and partitions: ```bash lsblk --paths ``` Output example: ```bash NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS /dev/vda 253:0 0 10G 0 disk ├─/dev/vda1 253:1 0 9G 0 part / ├─/dev/vda14 253:14 0 4M 0 part ├─/dev/vda15 253:15 0 106M 0 part /boot/efi └─/dev/vda16 259:0 0 913M 0 part /boot /dev/vdb 253:16 0 1M 0 disk /dev/vdc 253:32 0 20G 0 disk └─/dev/vdc1 253:33 0 10G 0 part /mnt/disk-0 ``` Find the device name of the resized disk and get the name of its last partition. The secondary disk is most likely the last one in the list. Also, check the `SIZE` column: it shows that the disk size is increased, but the partition size stays the same. In this example, the required device name is `/dev/vdc`, and the partition is `/dev/vdc1`. 5. Grow the partition to fill the disk: ```bash sudo growpart /dev/vdc 1 ``` If you work with a disk that has a device name other than `/dev/vdc`, change the device name and the partition index `1` in the current command and commands below. You can get the index of the partition from its name. Only the last partition may be grown. In the commands, you can use the device ID of the disk (`/dev/disk/by-id/virtio-disk-0`) instead of the device name (`/dev/vdc`). Run the `ls /dev/disk/by-id` command to get device IDs for all disks. 6. Refresh the kernel partition table for the disk and wait for the device information to be updated: ```bash sudo partprobe /dev/vdc && sudo udevadm settle ``` 7. Show information about partitions and check that the size of the partition has increased: ```bash lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT /dev/vdc ``` Output example: ```bash NAME SIZE TYPE FSTYPE MOUNTPOINT vdc 25G disk └─vdc1 25G part ext4 /mnt/disk-0 ``` 8. Grow the `ext4` filesystem on the increased partition: ```bash sudo resize2fs /dev/vdc1 ``` 9. Check that the filesystem size has increased: ```bash df -hT ``` Output example: ```bash Filesystem Type Size Used Avail Use% Mounted on tmpfs tmpfs 795M 1.1M 794M 1% /run /dev/vda1 ext4 38G 3.3G 35G 9% / tmpfs tmpfs 3.9G 0 3.9G 0% /dev/shm tmpfs tmpfs 5.0M 0 5.0M 0% /run/lock cloud-metadata virtiofs 252G 16K 252G 1% /mnt/cloud-metadata /dev/vdc1 ext4 25G 24K 24G 1% /mnt/disk-0 /dev/vda16 ext4 881M 174M 645M 22% /boot /dev/vda15 vfat 105M 6.2M 99M 6% /boot/efi tmpfs tmpfs 795M 12K 795M 1% /run/user/1001 ``` ### How to resize a shared filesystem To resize a shared filesystem: 1. In the sidebar, go to **Storage** → **Shared filesystems**. Alternatively, go to the virtual machine where the filesystem is attached and find it in the **Shared filesystems** tab. 2. Click the filesystem you want to resize and go to the **Settings** tab. 3. In the **Parameters** section, enter the new **Size** value or use the slider to set the new size. 4. Click **Save changes**. 1. If you haven't saved the filesystem's ID when creating it, get its ID by using [nebius compute filesystem get-by-name](https://docs.nebius.com/cli/reference/compute/filesystem/get-by-name). 2. Run [nebius compute filesystem update](https://docs.nebius.com/cli/reference/compute/filesystem/update) and set the new size by using one of the `--size-gibibytes`, `--size-mebibytes`, `--size-kibibytes` or `--size-bytes` parameters. 1. In your Terraform configuration, update the `size_gibibytes` value (or `size_mebibytes`, `size_kibibytes`, `size_bytes`) in the filesystem resource. For example: ```hcl highlight={4} resource "nebius_compute_v1_filesystem" "" { name = "" ... size_gibibytes = } ``` 2. Check that the configuration is correct: ```bash terraform validate ``` 3. Apply the changes: ```bash terraform apply ``` ## How to enable or disable deletion protection You can only change deletion protection of a [standalone disk](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). If you need to update a VM-managed disk, [convert it first to standalone](https://docs.nebius.com/compute/storage/manage.md#how-to-make-a-disk-vm-managed-or-standalone). To enable or disable deletion protection: 1. In the sidebar, go to **Storage** → **Disks** or **Storage** → **Shared filesystems**. 2. Click the volume you want to update and go to the **Settings** tab. 3. In the **Parameters** section, enable or disable **Deletion protection**. 4. Click **Save changes**. 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```bash export DISK_ID=$(nebius compute disk get-by-name \ --parent-id \ --name \ --format json | jq -r ".metadata.id") ``` For a filesystem, use [nebius compute filesystem get-by-name](https://docs.nebius.com/cli/reference/compute/filesystem/get-by-name) with the same parameters. 2. Run [nebius compute disk update](https://docs.nebius.com/cli/reference/compute/disk/update) for a disk, or [nebius compute filesystem update](https://docs.nebius.com/cli/reference/compute/filesystem/update) for a filesystem: ```bash nebius compute disk update \ --id $DISK_ID \ --forbid-deletion= ``` 1. In your Terraform configuration, set `forbid_deletion` to `true` or `false` in the disk or filesystem resource. For example, for a disk: ```hcl highlight={4} resource "nebius_compute_v1_disk" "" { name = "" ... forbid_deletion = true } ``` 2. Check that the configuration is correct: ```bash terraform validate ``` 3. Apply the changes: ```bash terraform apply ``` 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```go disk, err := sdk.Services().Compute().V1(). Disk().GetByName( ctx, &common.GetByNameRequest{ ParentId: "", Name: "", }, ) if err != nil { return err } diskID := disk.GetMetadata().GetId() ``` For a filesystem, get its ID by name with the same parameters. 2. Update the disk or filesystem deletion protection. Here is an example for a disk: ```go disk, err = sdk.Services().Compute().V1(). Disk().Get( ctx, &compute.GetDiskRequest{ Id: diskID, }, ) if err != nil { return err } if disk.GetSpec() == nil { return errors.New("disk spec is missing") } disk.Spec.ForbidDeletion = operation, err = sdk.Services().Compute().V1(). Disk().Update( ctx, &compute.UpdateDiskRequest{ Metadata: disk.Metadata, Spec: disk.Spec, }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```python disk_service = DiskServiceClient(sdk) disk = await disk_service.get_by_name( GetByNameRequest( parent_id="", name="", ), ) disk_id = disk.metadata.id ``` For a filesystem, get its ID by name with the same parameters. 2. Update the disk or filesystem deletion protection. Here is an example for a disk: ```python disk_service = DiskServiceClient(sdk) disk = await disk_service.get( GetDiskRequest(id=disk_id), ) if disk.spec is None: raise ValueError("disk spec is missing") disk.spec.forbid_deletion = update_disk_operation = await disk_service.update( UpdateDiskRequest( metadata=disk.metadata, spec=disk.spec, ), ) await update_disk_operation.wait() ``` 1. If you haven't saved the disk or filesystem's ID when creating it, get its ID: ```ts const getDiskByNameService = new DiskService(sdk); const diskByName = await getDiskByNameService.getByName( GetByNameRequest.create({ parentId: "", name: "", }), ); const diskId = diskByName.metadata?.id; if (!diskId) { throw new Error("disk ID is missing"); } ``` For a filesystem, get its ID by name with the same parameters. 2. Update the disk or filesystem deletion protection. Here is an example for a disk: ```ts const updateDiskDeletionService = new DiskService(sdk); const diskForDeletion = await updateDiskDeletionService.get( GetDiskRequest.create({ id: diskId, }), ); if (!diskForDeletion.spec) { throw new Error("disk spec is missing"); } diskForDeletion.spec.forbidDeletion = ; const updateDiskDeletionOperation = await updateDiskDeletionService.update( UpdateDiskRequest.create({ metadata: diskForDeletion.metadata, spec: diskForDeletion.spec, }), ).result; await updateDiskDeletionOperation.wait(); ``` If you try to delete a volume with deletion protection enabled, the operation will fail, and you'll see the following message: `Error: rpc error: code = FailedPrecondition desc = disk cannot be deleted because forbid_deletion is set`. Disable deletion protection first, then delete the volume. ## How to make a disk VM-managed or standalone Each disk is either [VM-managed or standalone](https://docs.nebius.com/compute/storage/types.md#vm-managed-and-standalone-disks). You can convert a disk from one state to another. To do so: 1. In the sidebar, go to **Compute** → **Virtual machines**. 2. Open the page of the required VM and then go to the **Disks** tab. 3. In the line of the required disk, click → **Convert to VM-managed** or → **Convert to standalone**. ## How to delete a volume Deleting a volume permanently removes all data stored on it. Before deleting, make sure the volume is [detached](https://docs.nebius.com/compute/storage/detach-volume.md) from any virtual machine. 1. In the sidebar, go to **Storage** → **Disks** or **Storage** → **Shared filesystems**. 2. Open the page of the volume that you want to delete. 3. Go to the **Settings** tab. 4. Click **Delete disk** or **Delete filesystem**. 5. In the window that opens, confirm the deletion. 1. Get the ID of the volume you want to delete: ```bash nebius compute list ``` 2. Delete the disk: ```bash nebius compute disk delete ``` 3. Delete the filesystem: ```bash nebius compute filesystem delete ``` 1. In your Terraform configuration, remove the `nebius_compute_v1_disk` or `nebius_compute_v1_filesystem` resource block. If the resource has `forbid_deletion = true`, set it to `false` before removing the resource, then apply the configuration. Once done, remove the resource. 2. Check that the configuration is correct: ```bash terraform validate ``` 3. Apply the changes: ```bash terraform apply ``` 1. If you haven't saved the volume ID, get it as described in [How to resize a volume](https://docs.nebius.com/compute/storage/manage.md#how-to-resize-a-volume). 2. Delete the disk: ```go operation, err = sdk.Services().Compute().V1(). Disk().Delete( ctx, &compute.DeleteDiskRequest{ Id: "", }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` 3. Delete the filesystem: ```go operation, err = sdk.Services().Compute().V1(). Filesystem().Delete( ctx, &compute.DeleteFilesystemRequest{ Id: "", }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` 1. If you haven't saved the volume ID, get it as described in [How to resize a volume](https://docs.nebius.com/compute/storage/manage.md#how-to-resize-a-volume). 2. Delete the disk: ```python disk_service = DiskServiceClient(sdk) delete_disk_operation = await disk_service.delete( DeleteDiskRequest( id="", ), ) await delete_disk_operation.wait() ``` 3. Delete the filesystem: ```python filesystem_service = FilesystemServiceClient(sdk) delete_filesystem_operation = await filesystem_service.delete( DeleteFilesystemRequest( id="", ), ) await delete_filesystem_operation.wait() ``` 1. If you haven't saved the volume ID, get it as described in [How to resize a volume](https://docs.nebius.com/compute/storage/manage.md#how-to-resize-a-volume). 2. Delete the disk: ```ts const deleteDiskService = new DiskService(sdk); const deleteDiskOperation = await deleteDiskService.delete( DeleteDiskRequest.create({ id: "", }), ).result; await deleteDiskOperation.wait(); ``` 3. Delete the filesystem: ```ts const deleteFilesystemService = new FilesystemService(sdk); const deleteFilesystemOperation = await deleteFilesystemService.delete( DeleteFilesystemRequest.create({ id: "", }), ).result; await deleteFilesystemOperation.wait(); ``` ## See also * [Types of storage volumes in Compute](https://docs.nebius.com/compute/storage/types.md) * [Attaching and mounting Compute volumes to VMs](https://docs.nebius.com/compute/storage/use.md) # Boot disk images for Compute virtual machines Source: https://docs.nebius.com/compute/storage/boot-disk-images.md When you [create a boot disk](https://docs.nebius.com/compute/storage/manage.md#how-to-create-a-disk) for a virtual machine, you need to choose an image for the disk. Compute supports two types of boot disk images: * *Public images* are provided and supported by the platform by default. * *Custom images* are images that you [create](https://docs.nebius.com/compute/storage/custom-disk-images.md) yourself with customized software and architecture. Nebius AI Cloud provides public boot disk images for GPU and non-GPU VMs. ## Compatibility types The image that you choose for a VM must be compatible with the VM's [platform](https://docs.nebius.com/compute/virtual-machines/types.md). There are different types of compatibility: * *Recommended images* ensure stable VM performance. * *Alternative images* are compatible with the platform but do not guarantee stable performance. ## Image family Each image has a family. When you use the [Nebius AI Cloud CLI](https://docs.nebius.com/cli/reference/compute/disk/create) or the [provider for Terraform](https://docs.nebius.com/terraform-provider/reference/resources/compute_v1_disk) to create a boot disk, you need to specify its family. For example, the image Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) has the family `ubuntu24.04-cuda13.0`. ## Prerequisites [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). ## How to get a list of available public images To get a list of public boot disk images available in a [region](https://docs.nebius.com/overview/regions.md): Run the following command: ```bash nebius compute image list-public --region ``` ```go images, err := sdk.Services().Compute().V1(). Image().ListPublic( ctx, &compute.ListPublicRequest{ Region: "", }, ) if err != nil { return err } fmt.Println(images) ``` ```python image_service = ImageServiceClient(sdk) images = await image_service.list_public( ListPublicRequest( region="", ), ) print(images) ``` ```ts const imageService = new ImageService(sdk); const images = await imageService.listPublic( ListPublicRequest.create({ region: "", }), ); console.log(images); ``` In the output, you'll see public images available in the specified region, including image families and other metadata. To determine which VM platforms are compatible with a public image, check the following parameters in the output: * `recommended_platforms`: Platforms for which the image is recommended. * `unsupported_platforms`: Platforms for which the image is not supported (with reasons, if available). Availability of images and their compatibility with platforms differ by region. ## Images for GPU VMs For VMs with GPUs, create boot disks from the following images: * Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 12), `ubuntu24.04-cuda12` * Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13), `ubuntu24.04-cuda13.0` The `ubuntu22.04-cuda12` image family is deprecated. Existing disks created from images in this family remain available, but creating new disks from this image family isn't supported. Migrate to newer images. The following boot disk images are compatible with GPU VMs: | VM platform | [Recommended images](https://docs.nebius.com/compute/storage/boot-disk-images.md#compatibility-types) | [Alternative images](https://docs.nebius.com/compute/storage/boot-disk-images.md#compatibility-types) | | -------------------------------------------------------------- | ------------------------------------------------------------------- | ----------------------------------------------------------------- | | NVIDIA® B300 NVLink with Intel Granite Rapids `gpu-b300-sxm` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | *None* | | NVIDIA® B200 NVLink with Intel Emerald Rapids `gpu-b200-sxm` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | *None* | | NVIDIA® B200 NVLink with Intel Emerald Rapids `gpu-b200-sxm-a` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | *None* | | NVIDIA® H200 NVLink with Intel Sapphire Rapids `gpu-h200-sxm` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 12) `ubuntu24.04-cuda12` | | NVIDIA® H100 NVLink with Intel Sapphire Rapids `gpu-h100-sxm` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 12) `ubuntu24.04-cuda12` | | NVIDIA® RTX PRO™ 6000 with Intel Granite Rapids `gpu-rtx6000` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | *None* | | NVIDIA® L40S PCIe with Intel Ice Lake `gpu-l40s-a` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 12) `ubuntu24.04-cuda12` | | NVIDIA® L40S PCIe with AMD Epyc Genoa `gpu-l40s-d` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 13) `ubuntu24.04-cuda13.0` | Ubuntu 24.04 LTS for NVIDIA® GPUs (CUDA® 12) `ubuntu24.04-cuda12` | The `1gpu-20vcpu-224gb` preset for NVIDIA® B200 platforms (`gpu-b200-sxm` and `gpu-b200-sxm-a`) requires [driver](https://docs.nebius.com/compute/storage/boot-disk-images.md#gpu-drivers-and-other-components) version 580.x or newer. Earlier driver versions are not supported. ### GPU drivers and other components The boot disk images for VMs with GPUs include the following components:

Component	`ubuntu24.04-cuda12`	`ubuntu24.04-cuda13.0`
Drivers preset	`cuda12.8`	`cuda13.0`
CUDA Toolkit	12.8 ([release notes](https://docs.nvidia.com/cuda/archive/12.8.0/))	13.0 ([release notes](https://docs.nvidia.com/cuda/archive/13.0.0/))
NVIDIA® Data Center GPU Driver	570.x	580.x
Linux kernel	6.11, NVIDIA® HWE	6.11, NVIDIA® HWE
Networking package	[NVIDIA® DOCA](https://developer.nvidia.com/networking/doca) 2.9.2 ([release notes](https://docs.nvidia.com/doca/archive/2-9-2-lts-ovs-update/doca+release+notes/index.html))	NVIDIA® DOCA 3.1.0 ([release notes](https://docs.nvidia.com/doca/archive/3-1-0/doca+release+notes/index.html))
Other components	[NVIDIA® Collective Communications Library](https://developer.nvidia.com/nccl) (NCCL) [NVIDIA® Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/index.html) [NVIDIA® Data Center GPU Manager](https://developer.nvidia.com/dcgm) (DCGM) [Nebius AI Cloud monitoring agent](https://docs.nebius.com/observability/agents/monitoring-agent.md)

## Images for non-GPU VMs For VMs without GPUs, create boot disks from the Ubuntu 24.04 LTS, `ubuntu24.04-driverless` image without GPU drivers and components. The images without drivers are also compatible with GPU VMs, but you need to install the drivers and components manually. We recommend using the [dedicated images for GPU VMs](https://docs.nebius.com/compute/storage/boot-disk-images.md#images-for-gpu-vms). The following boot disk images are compatible with non-GPU VMs: | VM platform | [Recommended images](https://docs.nebius.com/compute/storage/boot-disk-images.md#compatibility-types) | [Alternative images](https://docs.nebius.com/compute/storage/boot-disk-images.md#compatibility-types) | | ------------------------------- | ------------------------------------------ | ------------------------------------------ | | Non-GPU AMD EPYC Genoa `cpu-d3` | Ubuntu 24.04 LTS `ubuntu24.04-driverless` | None | | Non-GPU Intel Ice Lake `cpu-e2` | Ubuntu 24.04 LTS `ubuntu24.04-driverless` | None | The `ubuntu22.04-driverless` image family is deprecated. Existing disks created from images in this family remain available, but creating new disks from this image family isn't supported. Migrate to newer images. ## Security updates Automatic security updates are disabled by default. We recommend that you check the compatibility of new library versions on a test VM, and then apply the updates manually to all running GPU nodes. If you do need automatic updates, you can [enable](https://docs.nebius.com/compute/storage/automatic-updates.md) them. *** *InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.* # Creating custom boot disk images Source: https://docs.nebius.com/compute/storage/custom-disk-images.md *Custom images* allow you to quickly [create virtual machines (VMs)](https://docs.nebius.com/compute/storage/custom-disk-images.md#how-to-create-a-vm-from-a-custom-image) or boot disks with all the necessary software, OS and configuration, which can greatly reduce infrastructure deployment time and ensure consistency across environments. You can [create](https://docs.nebius.com/compute/storage/custom-disk-images.md#how-to-create-a-custom-boot-disk-image), [edit or delete](https://docs.nebius.com/compute/storage/custom-disk-images.md#how-to-edit-or-delete-a-custom-boot-disk-image) custom [boot disk images](https://docs.nebius.com/compute/storage/boot-disk-images.md) in the web console, by using the CLI or by using a Nebius SDK. Alternatively, you can create custom boot disk images by using [Packer with the Nebius plug-in](https://docs.nebius.com/compute/storage/packer.md). ## Prerequisites 1. Make sure that you have enough quotas for images (**Number of images** and **Total storage capacity of all images**). You can view quotas and request changes on the [Administration → Limits → Quotas](https://console.nebius.com/limits/quotas) page of the web console. 2. Prepare the source from which the image inherits configuration and architecture. Choose one of the following types of sources: * Boot disk. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), [connect to it](https://docs.nebius.com/compute/virtual-machines/connect.md) and install the software that the image should inherit. The image will be based on the boot disk of this VM and will include the installed software. * Disk snapshot. [Create a snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md#how-to-create-a-snapshot) from a boot disk and reuse this snapshot for the image. * File with the ready image. [Upload an image file to a bucket](https://docs.nebius.com/object-storage/objects/upload-download.md#upload-a-single-file) in Object Storage and use this file to create the image. 1. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. 2. Make sure that you have enough quotas for images (**Number of images** and **Total storage capacity of all images**). You can view quotas and request changes on the [Administration → Limits → Quotas](https://console.nebius.com/limits/quotas) page of the web console. 3. Prepare the source from which the image inherits configuration and architecture. Choose one of the following types of sources: * Boot disk. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), [connect to it](https://docs.nebius.com/compute/virtual-machines/connect.md) and install the software that the image should inherit. The image will be based on the boot disk of this VM and will include the installed software. * Disk snapshot. [Create a snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md#how-to-create-a-snapshot) from a boot disk and reuse this snapshot for the image. * File with the ready image. [Upload an image file to a bucket](https://docs.nebius.com/object-storage/objects/upload-download.md#upload-a-single-file) in Object Storage and use this file to create the image. 1. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). 2. Make sure that you have enough quotas for images (**Number of images** and **Total storage capacity of all images**). You can view quotas and request changes on the [Administration → Limits → Quotas](https://console.nebius.com/limits/quotas) page of the web console. 3. Prepare the source from which the image inherits configuration and architecture. Choose one of the following types of sources: * Boot disk. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), [connect to it](https://docs.nebius.com/compute/virtual-machines/connect.md) and install the software that the image should inherit. The image will be based on the boot disk of this VM and will include the installed software. * Disk snapshot. [Create a snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md#how-to-create-a-snapshot) from a boot disk and reuse this snapshot for the image. * File with the ready image. [Upload an image file to a bucket](https://docs.nebius.com/object-storage/objects/upload-download.md#upload-a-single-file) in Object Storage and use this file to create the image. 1. [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). 2. Make sure that you have enough quotas for images (**Number of images** and **Total storage capacity of all images**). You can view quotas and request changes on the [Administration → Limits → Quotas](https://console.nebius.com/limits/quotas) page of the web console. 3. Prepare the source from which the image inherits configuration and architecture. Choose one of the following types of sources: * Boot disk. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), [connect to it](https://docs.nebius.com/compute/virtual-machines/connect.md) and install the software that the image should inherit. The image will be based on the boot disk of this VM and will include the installed software. * Disk snapshot. [Create a snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md#how-to-create-a-snapshot) from a boot disk and reuse this snapshot for the image. * File with the ready image. [Upload an image file to a bucket](https://docs.nebius.com/object-storage/objects/upload-download.md#upload-a-single-file) in Object Storage and use this file to create the image. 1. [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). 2. Make sure that you have enough quotas for images (**Number of images** and **Total storage capacity of all images**). You can view quotas and request changes on the [Administration → Limits → Quotas](https://console.nebius.com/limits/quotas) page of the web console. 3. Prepare the source from which the image inherits configuration and architecture. Choose one of the following types of sources: * Boot disk. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm), [connect to it](https://docs.nebius.com/compute/virtual-machines/connect.md) and install the software that the image should inherit. The image will be based on the boot disk of this VM and will include the installed software. * Disk snapshot. [Create a snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md#how-to-create-a-snapshot) from a boot disk and reuse this snapshot for the image. * File with the ready image. [Upload an image file to a bucket](https://docs.nebius.com/object-storage/objects/upload-download.md#upload-a-single-file) in Object Storage and use this file to create the image. ## How to create a custom boot disk image 1. In the [web console](https://console.nebius.com), go to **Storage** → **Disks**. 2. Click **Create resource** and then select **Image**. 3. In the window that opens, specify the name of your image. 4. Select the image source: * **Disk**: Create an image from a disk. Specify the following parameters: * **Project of source disk**: Project that the source disk of your image belongs to. * **Source disk**: Disk used as the source for your image. The image will retain the basic architecture, size and installed software of the source disk. You cannot create images from disks that are attached to a VM that is currently running. Stop the VM before attempting to create an image. * **Snapshot**: Create an image from a disk snapshot. Select the snapshot in the **Source snapshot** field. * **Object Storage file**: Import an image from a bucket. Specify the path to the file that you uploaded to the bucket. For example, `s3://nebius-bucket-test/my-image-file.qcow2`. You can copy and paste this value. To copy it, go to the bucket page. In the line of the uploaded image file, click → **Copy key**. For information about requirements to the image file, see [Importing your own image into Compute](https://docs.nebius.com/compute/storage/import-image.md#prerequisites). 5. (Optional) Specify the image family. It represents a new or existing label used to group your custom images into a family. If you create a VM or a boot disk from this image family, you will use the latest image in the family. 6. (Optional) Specify the image description. 7. (Optional) Under **Advanced settings**, specify: * **Image family description**: Description of the family that your new image belongs to (if you specified one). * **Recommended platforms**: Comma-separated list of compatible [platforms](https://docs.nebius.com/compute/virtual-machines/types.md) that your image will use by default. * **Unsupported platforms**: Comma-separated list of platforms that your image architecture is *not* compatible with. Must be in the `=` format. For example, `gpu-l40s-d=not supported`. 8. Click **Create image**. The new image will appear on the **Images** tab in **Storage** → **Disks**. 1. If the source disk for your image is attached to a VM that is currently running, stop it: ```bash nebius compute instance stop --id ``` To get the VM ID, run nebius compute instance list. 2. Create an image: ```bash nebius compute image create \ --name \ --source-disk-id \ --parent-id \ --source-disk-snapshot-id \ --source-storage-bucket-name \ --source-storage-object-name \ --image-family \ --description \ --image-family-human-readable \ --recommended-platforms ",,..." \ --unsupported-platforms "=" ``` The CLI command includes the following parameters: * `--name`: Name of your image. * Image sources. Use one of the following: * `--source-disk-id`: ID of the source disk that you want to create an image from. Use together with `--parent-id`: ID of the project that the source disk belongs to. To get both `--parent-id` and `--source-disk-id`, run `nebius compute disk list`. * `--source-disk-snapshot-id`: ID of the [disk snapshot](https://docs.nebius.com/compute/storage/disk-snapshots.md) that you want to create an image from. To get the snapshot ID, run `nebius compute disk-snapshot list`. * `--source-storage-bucket-name` and `--source-storage-object-name`: Bucket and object that contain the source image. You can import an image from a file that meets certain [requirements](https://docs.nebius.com/compute/storage/import-image.md#prerequisites). To do so, upload this file to a bucket. Then, specify the name of this bucket in the `--source-storage-bucket-name` parameter and the name of the file in the `--source-storage-object-name` parameter. ```bash nebius compute image create \ --name \ --source-storage-bucket-name \ --source-storage-object-name ``` * `--image-family` (optional): New or existing label used to group your custom images into a family. If you create a VM or a boot disk from this image family, you will use the latest image in the family. * `--description` (optional): Description of your image. * `--image-family-human-readable` (optional): Description of the family that your new image belongs to (if you specified one). * `--recommended-platforms` (optional): Comma-separated list of compatible [platforms](https://docs.nebius.com/compute/virtual-machines/types.md) that your image will use by default. * `--unsupported-platforms` (optional): Comma-separated list of platforms that your image architecture is *not* compatible with. Must be in the `=` format. For example, `gpu-l40s-d=not supported`. 1. If the source disk for your image is attached to a VM that is currently running, stop it: ```go operation, err := sdk.Services().Compute().V1(). Instance().Stop( ctx, &compute.StopInstanceRequest{ Id: "", }, ) if err != nil { return err } if _, err = operation.Wait(ctx); err != nil { return err } ``` 2. Create an image: ```go familyDescription := "" recommendedPlatforms := []string{} for _, platform := range strings.Split( ",,...", ",", ) { platform = strings.TrimSpace(platform) if platform != "" { recommendedPlatforms = append(recommendedPlatforms, platform) } } unsupportedPlatforms := map[string]string{} for _, platform := range strings.Split( "=", ",", ) { parts := strings.SplitN(platform, "=", 2) if len(parts) == 2 && parts[0] != "" { unsupportedPlatforms[parts[0]] = parts[1] } } imageOperation, err := sdk.Services().Compute().V1(). Image().Create( ctx, &compute.CreateImageRequest{ Metadata: &common.ResourceMetadata{ ParentId: "", Name: "", }, Spec: &compute.ImageSpec{ Description: "", ImageFamily: "", Source: &compute.ImageSpec_SourceDiskId{ SourceDiskId: "", }, ImageFamilyHumanReadable: familyDescription, RecommendedPlatforms: recommendedPlatforms, UnsupportedPlatforms: unsupportedPlatforms, }, }, ) if err != nil { return err } if _, err = imageOperation.Wait(ctx); err != nil { return err } ``` The code includes the following parameters: * `Metadata.ParentId`: ID of the project that the source disk belongs to. * `Metadata.Name`: Name of your image. * `Spec.Description` (optional): Description of your image. * `Spec.ImageFamily` (optional): New or existing label used to group your custom images into a family. * `Spec.Source.SourceDiskId`: ID of the source disk that you want to create an image from. * `Spec.ImageFamilyHumanReadable` (optional): Description of the family that your new image belongs to. * `Spec.RecommendedPlatforms` (optional): Compatible platforms that your image will use by default. * `Spec.UnsupportedPlatforms` (optional): Platforms that your image architecture is not compatible with. The Object Storage example uses `Metadata.Name`, `Spec.Source.SourceStorage.BucketName` and `Spec.Source.SourceStorage.ObjectName`. ```go imageOperation, err = sdk.Services().Compute().V1(). Image().Create( ctx, &compute.CreateImageRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.ImageSpec{ Source: &compute.ImageSpec_SourceStorage_{ SourceStorage: &compute.ImageSpec_SourceStorage{ BucketName: "", ObjectName: "", }, }, }, }, ) if err != nil { return err } if _, err = imageOperation.Wait(ctx); err != nil { return err } ``` 1. If the source disk for your image is attached to a VM that is currently running, stop it: ```python instance_service = InstanceServiceClient(sdk) stop_instance_operation = await instance_service.stop( StopInstanceRequest(id=""), ) await stop_instance_operation.wait() ``` 2. Create an image: ```python recommended_platforms = [ platform.strip() for platform in ",,...".split(",") if platform.strip() ] unsupported_platforms = dict( platform.split("=", 1) for platform in "=".split(",") if platform ) image_service = ImageServiceClient(sdk) create_image_operation = await image_service.create( CreateImageRequest( metadata=ResourceMetadata( parent_id="", name="", ), spec=ImageSpec( source_disk_id="", image_family="", description="", image_family_human_readable="", recommended_platforms=recommended_platforms, unsupported_platforms=unsupported_platforms, ), ), ) await create_image_operation.wait() ``` The code includes the following parameters: * `metadata.parent_id`: ID of the project that the source disk belongs to. * `metadata.name`: Name of your image. * `spec.source_disk_id`: ID of the source disk that you want to create an image from. * `spec.image_family` (optional): New or existing label used to group your custom images into a family. * `spec.description` (optional): Description of your image. * `spec.image_family_human_readable` (optional): Description of the family that your new image belongs to. * `spec.recommended_platforms` (optional): Compatible platforms that your image will use by default. * `spec.unsupported_platforms` (optional): Platforms that your image architecture is not compatible with. The Object Storage example uses `metadata.name`, `spec.source_storage.bucket_name` and `spec.source_storage.object_name`. ```python image_service = ImageServiceClient(sdk) create_image_operation = await image_service.create( CreateImageRequest( metadata=ResourceMetadata( name="", ), spec=ImageSpec( source_storage=ImageSpec.SourceStorage( bucket_name="", object_name="", ), ), ), ) await create_image_operation.wait() ``` 1. If the source disk for your image is attached to a VM that is currently running, stop it: ```ts const stopInstanceService = new InstanceService(sdk); const stopInstanceOperation = await stopInstanceService.stop( StopInstanceRequest.create({ id: "", }), ).result; await stopInstanceOperation.wait(); ``` 2. Create an image: ```ts const recommendedPlatforms = ",,..." .split(",") .map((platform) => platform.trim()) .filter(Boolean); const unsupportedPlatforms = Object.fromEntries( "=" .split(",") .filter(Boolean) .map((platform) => platform.split("=", 2)), ); const createImageService = new ImageService(sdk); const createImageOperation = await createImageService.create( CreateImageRequest.create({ metadata: ResourceMetadata.create({ parentId: "", name: "", }), spec: ImageSpec.create({ source: { $case: "sourceDiskId", sourceDiskId: "", }, imageFamily: "", description: "", imageFamilyHumanReadable: "", recommendedPlatforms, unsupportedPlatforms, }), }), ).result; await createImageOperation.wait(); ``` The code includes the following parameters: * `metadata.parentId`: ID of the project that the source disk belongs to. * `metadata.name`: Name of your image. * `spec.source.sourceDiskId`: ID of the source disk that you want to create an image from. * `spec.imageFamily` (optional): New or existing label used to group your custom images into a family. * `spec.description` (optional): Description of your image. * `spec.imageFamilyHumanReadable` (optional): Description of the family that your new image belongs to. * `spec.recommendedPlatforms` (optional): Compatible platforms that your image will use by default. * `spec.unsupportedPlatforms` (optional): Platforms that your image architecture is not compatible with. The Object Storage example uses `metadata.name`, `spec.source.sourceStorage.bucketName` and `spec.source.sourceStorage.objectName`. ```ts const createBucketImageService = new ImageService(sdk); const createBucketImageOperation = await createBucketImageService.create( CreateImageRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: ImageSpec.create({ source: { $case: "sourceStorage", sourceStorage: ImageSpec_SourceStorage.create({ bucketName: "", objectName: "", }), }, }), }), ).result; await createBucketImageOperation.wait(); ``` ## How to edit or delete a custom boot disk image 1. In the [web console](https://console.nebius.com), go to **Storage** → **Disks**. 2. Switch to the **Images** tab and open the image you want to access. The **Image overview** tab shows detailed information about the image and the source disk that it's based on. 3. On the image page, switch to the **Settings** tab. 4. Update the image name or click **Delete image** to delete it. * To check the status of your image, run: ```bash nebius compute image get computeimage-e*** ``` To get the image ID, run nebius compute image list. * To edit your image (for example, rename it), run: ```bash nebius compute image update computeimage-e*** ``` For more information about the command parameters, see the [command reference](https://docs.nebius.com/cli/reference/compute/image/update). * To delete your image, run: ```bash nebius compute image delete computeimage-e*** ``` * Check the status of your image: ```go imageDetails, err := sdk.Services().Compute().V1(). Image().Get( ctx, &compute.GetImageRequest{ Id: "computeimage-e***", }, ) if err != nil { return err } fmt.Println(imageDetails) ``` * Edit your image, for example, rename it: ```go imageForUpdate, err := sdk.Services().Compute().V1(). Image().Get( ctx, &compute.GetImageRequest{ Id: "computeimage-e***", }, ) if err != nil { return err } if imageForUpdate.GetSpec() == nil { return errors.New("image spec is missing") } imageOperation, err = sdk.Services().Compute().V1(). Image().Update( ctx, &compute.UpdateImageRequest{ Metadata: imageForUpdate.Metadata, Spec: imageForUpdate.Spec, }, ) if err != nil { return err } if _, err = imageOperation.Wait(ctx); err != nil { return err } ``` * Delete your image: ```go deleteImageOperation, err := sdk.Services().Compute().V1(). Image().Delete( ctx, &compute.DeleteImageRequest{ Id: "computeimage-e***", }, ) if err != nil { return err } if _, err = deleteImageOperation.Wait(ctx); err != nil { return err } ``` * Check the status of your image: ```python image_service = ImageServiceClient(sdk) image = await image_service.get( GetImageRequest(id="computeimage-e***"), ) print(image) ``` * Edit your image, for example, rename it: ```python image_service = ImageServiceClient(sdk) image = await image_service.get( GetImageRequest(id="computeimage-e***"), ) if image.spec is None: raise ValueError("image spec is missing") update_image_operation = await image_service.update( UpdateImageRequest( metadata=image.metadata, spec=image.spec, ), ) await update_image_operation.wait() ``` * Delete your image: ```python image_service = ImageServiceClient(sdk) delete_image_operation = await image_service.delete( DeleteImageRequest(id="computeimage-e***"), ) await delete_image_operation.wait() ``` * Check the status of your image: ```ts const getImageService = new ImageService(sdk); const imageDetails = await getImageService.get( GetImageRequest.create({ id: "computeimage-e***", }), ); console.log(imageDetails); ``` * Edit your image, for example, rename it: ```ts const updateImageService = new ImageService(sdk); const imageForUpdate = await updateImageService.get( GetImageRequest.create({ id: "computeimage-e***", }), ); if (!imageForUpdate.spec) { throw new Error("image spec is missing"); } const updateImageOperation = await updateImageService.update( UpdateImageRequest.create({ metadata: imageForUpdate.metadata, spec: imageForUpdate.spec, }), ).result; await updateImageOperation.wait(); ``` * Delete your image: ```ts const deleteImageService = new ImageService(sdk); const deleteImageOperation = await deleteImageService.delete( DeleteImageRequest.create({ id: "computeimage-e***", }), ).result; await deleteImageOperation.wait(); ``` ## How to create a VM from a custom image After your custom boot disk image is ready, you can deploy a VM from it or create a boot disk based on this image. To create a VM from a custom image: 1. In the [web console](https://console.nebius.com), go to **Storage** → **Disks** → **Images**. 2. Next to the image, click → **Create virtual machine**. 3. [Configure and create the VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm). You can also select a custom image on the VM creation page. To do that, click in the **Boot disk** section and select your custom image or image family in **Image configuration**. 1. Create a boot disk based on a custom image: ```bash nebius compute disk create \ --name \ --type network_ \ --size-gibibytes \ --block-size-bytes \ --source-image-id computeimage-*** ``` To get the image ID, run nebius compute image list. 2. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with the new disk. Use the ID of the boot disk created earlier with the `--boot-disk-existing-disk-id` parameter. 1. Create a boot disk based on a custom image: ```go // One of compute.DiskSpec_NETWORK_SSD, // compute.DiskSpec_NETWORK_SSD_NON_REPLICATED, // or compute.DiskSpec_NETWORK_SSD_IO_M3. diskType := compute.DiskSpec_NETWORK_SSD diskOperation, err := sdk.Services().Compute().V1(). Disk().Create( ctx, &compute.CreateDiskRequest{ Metadata: &common.ResourceMetadata{ Name: "", }, Spec: &compute.DiskSpec{ Size: &compute.DiskSpec_SizeGibibytes{ SizeGibibytes: , }, BlockSizeBytes: , Type: diskType, Source: &compute.DiskSpec_SourceImageId{ SourceImageId: "computeimage-***", }, }, }, ) if err != nil { return err } if _, err = diskOperation.Wait(ctx); err != nil { return err } ``` 2. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with the new disk. Use the ID of the boot disk created earlier. 1. Create a boot disk based on a custom image: ```python # One of DiskSpec.DiskType.NETWORK_SSD, # DiskSpec.DiskType.NETWORK_SSD_NON_REPLICATED, # or DiskSpec.DiskType.NETWORK_SSD_IO_M3. disk_type = DiskSpec.DiskType.NETWORK_SSD disk_service = DiskServiceClient(sdk) create_disk_operation = await disk_service.create( CreateDiskRequest( metadata=ResourceMetadata( name="", ), spec=DiskSpec( block_size_bytes=, type=disk_type, source_image_id="computeimage-***", size_gibibytes=, ), ), ) await create_disk_operation.wait() ``` 2. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with the new disk. Use the ID of the boot disk created earlier. 1. Create a boot disk based on a custom image: ```ts // One of DiskSpec_DiskType.NETWORK_SSD, // DiskSpec_DiskType.NETWORK_SSD_NON_REPLICATED, // or DiskSpec_DiskType.NETWORK_SSD_IO_M3. const imageDiskType = DiskSpec_DiskType.NETWORK_SSD; const createDiskFromImageService = new DiskService(sdk); const createDiskFromImageOperation = await createDiskFromImageService.create( CreateDiskRequest.create({ metadata: ResourceMetadata.create({ name: "", }), spec: DiskSpec.create({ blockSizeBytes: , type: imageDiskType, source: { $case: "sourceImageId", sourceImageId: "computeimage-***", }, size: { $case: "sizeGibibytes", sizeGibibytes: , }, }), }), ).result; await createDiskFromImageOperation.wait(); ``` 2. [Create a VM](https://docs.nebius.com/compute/virtual-machines/manage.md#create-a-vm) with the new disk. Use the ID of the boot disk created earlier. # Creating boot disk images with Packer Source: https://docs.nebius.com/compute/storage/packer.md You can create custom boot disk images based on existing images by using [Packer](https://developer.hashicorp.com/packer) and the [Nebius Packer plug-in](https://github.com/nebius/packer-plugin-nebius/blob/main/README.md). The Nebius Packer plug-in creates a temporary virtual machine (VM) from a base image, connects to it over SSH, runs provisioners and then creates a new boot disk image. Use this workflow to: * Pre-install packages and system dependencies * Prepare versioned images for repeated VM creation * Standardize environments across teams or workloads ## Before you start 1. Install [Packer](https://developer.hashicorp.com/packer/downloads). 2. Make sure your project has sufficient [quotas](https://docs.nebius.com/overview/quotas.md) for image creation: * Number of images * Total storage capacity of all images 3. Set up authentication by using one of the following methods. * **Service account** 1. [Create a service account](https://docs.nebius.com/iam/service-accounts/manage.md) and [generate a key pair](https://docs.nebius.com/iam/service-accounts/authorized-keys.md#create-a-key-pair). The key pair is saved to a JSON file, for example, `~/.nebius/_credentials.json`. 2. Open the file and copy the value of the `private_key` field. 3. Save the key to the `private.pem` file: ```text -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY----- ``` 4. Use the values from the JSON file in your Packer configuration. * **Access token** Generate an access token: ```bash nebius iam get-access-token ``` An access token is valid for 12 hours. After it expires, create a new one. ## Steps ### Install the Nebius Packer plug-in 1. Create the `config.pkr.hcl` file and add the Nebius plug-in configuration: ```hcl packer { required_plugins { nebius = { source = "github.com/nebius/nebius" version = ">= 0.0.4" } } } ``` 2. Initialize the plug-in in the directory that contains your Packer configuration files: ```bash packer init . ``` ### Build the disk image The Nebius image builder creates a VM from a base image, provisions it over SSH and publishes a new image. 1. Create the `build.pkr.hcl` file and add the `nebius-image` source to it: ```hcl source "nebius-image" "ubuntu2404" { communicator = "ssh" ssh_username = "ubuntu" # Service account credentials used for image creation service_account { private_key_file = "./private.pem" public_key_id = "" account_id = "" } # Alternatively, use an access token # token = # Boot disk configuration for the temporary VM disk { size_gibibytes = 60 } # Source image used to create the temporary VM base_image { family = "ubuntu24.04-driverless" } # Network configuration for the temporary VM network { subnet_id = "" associate_public_ip_address = true } # Compute resources for the temporary VM instance { platform = "cpu-d3" preset = "16vcpu-64gb" } # Parameters of the resulting image image { name = "ubuntu24.04-131-0.0.1" version = "0.0.1" image_family = "ubuntu24.04-131" cpu_architecture = "amd64" image_family_human_readable = "Ubuntu 24.04 CUDA 13.1 Hackathon" } # Project where the image will be created parent_id = "" } ``` The `nebius-image` source has the following parameters: **General parameters** * `communicator` (optional): Specifies how Packer connects to the VM. Supported value: `ssh` (default). * `parent_id`: ID of the project where the resulting image will be created. * `ssh_username`: Username used to connect to the VM. **Authentication** * `service_account.private_key_file`: Path to the private key file. * `service_account.public_key_id`: ID of the public key. * `service_account.account_id`: Service account ID. * `token`: Access token used for authentication. Use this as an alternative to `service_account`. **Disk configuration** * `disk.size_gibibytes`: Size of the disk in GiB. **Base image** * `base_image.family`: Image family name. * `base_image.id`: Specific image ID. **Network** * `network.subnet_id` (optional): ID of an existing subnet that will be used to create a VM. If not provided, the plug-in attempts to find the project's default network. * `network.associate_public_ip_address` (optional): Assigns a public IP address. Use a public IP if your build environment connects directly via SSH. **VM configuration** * `instance.platform`: VM [platform](https://docs.nebius.com/compute/virtual-machines/types.md). * `instance.preset`: VM platform preset (number of GPUs and vCPUs, RAM size). **Output image configuration** * `image.name`: Image name. * `image.version` (optional): Image version. * `image.image_family` (optional): Image family identifier. * `image.image_family_human_readable` (optional): Display name for the image family. * `image.cpu_architecture` (optional): CPU architecture. 2. Add the build block to the `build.pkr.hcl` file: ```hcl build { sources = ["source.nebius-image.ubuntu2404"] provisioner "file" { # Path to a local script in your project source = "some-local-file.txt" destination = "/tmp/helloworld.txt" } provisioner "shell" { inline = [ "cd /tmp", "echo Installing hello world text", "sudo mv /tmp/helloworld.txt /root", "echo Resetting cloud-init and caches", "sudo apt clean", "sudo uv cache clean", "sudo cloud-init clean --logs", "sudo sync", ] } } ``` 3. From the directory with the configuration files, run: ```bash packer init . packer build build.pkr.hcl ``` ### Check the image 1. In the [web console](https://console.nebius.com), go to **Storage** → **Disks**. 2. Go to the **Images** tab and locate your image. ### Example: CUDA® 13.1 image The following example builds an image with CUDA 13.1 from a driverless image. It uses a single configuration file that includes both the plug-in and build configuration. ```hcl packer { required_plugins { nebius = { version = ">= 0.0.4" source = "github.com/nebius/nebius" } } } source "nebius-image" "ubuntu2404-cu131" { communicator = "ssh" ssh_username = "ubuntu" service_account { private_key_file = "./private.pem" public_key_id = "" account_id = "" } disk { size_gibibytes = 60 } base_image { family = "ubuntu24.04-driverless" } network { associate_public_ip_address = true } instance { platform = "cpu-d3" preset = "16vcpu-64gb" } image { name = "ubuntu24.04-131-0.0.1" version = "0.0.1" image_family = "ubuntu24.04-131" cpu_architecture = "amd64" image_family_human_readable = "Ubuntu 24.04 CUDA 13.1 Hackathon" } parent_id = "project-..." } build { sources = ["source.nebius-image.ubuntu2404-cu131"] provisioner "file" { source = "guest.config" destination = "/tmp/guest.config" } provisioner "file" { source = "install-gpu-cuda13.1-ubuntu24.04.sh" destination = "/tmp/install-gpu-cuda13.1-ubuntu24.04.sh" } provisioner "shell" { inline = [ "cd /tmp", "echo Installing cuda 13.1 et al", "sudo bash /tmp/install-gpu-cuda13.1-ubuntu24.04.sh", "echo Resetting cloud-init and caches", "sudo apt clean", "sudo uv cache clean", "sudo cloud-init clean --logs", "sudo sync", ] } } ``` The `file` and `shell` provisioners are used to copy files to the VM and execute commands during the build. Create your own scripts depending on the software and configuration you want to include in the image. # Importing your own image into Compute Source: https://docs.nebius.com/compute/storage/import-image.md You can import an image file into Nebius AI Cloud, and create boot disks and virtual machines (VMs) based on your custom image. To make an import, upload an image file to a bucket in Object Storage and create an image in Compute. ## Prerequisites 1. Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has the `admin` role within your tenant or project; for example, the default `admins` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 2. Prepare an image that meets the following requirements: * BIOS mode * AMD64 or ARM64 architecture * `.vmdk`, `.vhd`, `.raw` or `.qcow2` format for the image file 1. [Install and configure](https://docs.nebius.com/cli/install.md) the Nebius AI Cloud CLI. 2. Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has the `admin` role within your tenant or project; for example, the default `admins` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 3. Prepare an image that meets the following requirements: * BIOS mode * AMD64 or ARM64 architecture * `.vmdk`, `.vhd`, `.raw` or `.qcow2` format for the image file 1. [Install and initialize the Nebius SDK for Go](https://docs.nebius.com/grpc-api/sdk/go.md). 2. Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has the `admin` role within your tenant or project; for example, the default `admins` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 3. Prepare an image that meets the following requirements: * BIOS mode * AMD64 or ARM64 architecture * `.vmdk`, `.vhd`, `.raw` or `.qcow2` format for the image file 1. [Install and initialize the Nebius SDK for Python](https://docs.nebius.com/grpc-api/sdk/python.md). 2. Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has the `admin` role within your tenant or project; for example, the default `admins` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 3. Prepare an image that meets the following requirements: * BIOS mode * AMD64 or ARM64 architecture * `.vmdk`, `.vhd`, `.raw` or `.qcow2` format for the image file 1. [Install and initialize the Nebius SDK for JavaScript](https://docs.nebius.com/grpc-api/sdk/javascript.md). 2. Make sure you are in a [group](https://docs.nebius.com/iam/authorization/groups/index.md) that has the `admin` role within your tenant or project; for example, the default `admins` group. You can check this in the [Administration → IAM](https://console.nebius.com/iam) section of the web console. 3. Prepare an image that meets the following requirements: * BIOS mode * AMD64 or ARM64 architecture * `.vmdk`, `.vhd`, `.raw` or `.qcow2` format for the image file ## How to import an image and create a boot disk and a VM 1. [Create an Object Storage bucket](https://docs.nebius.com/object-storage/buckets/manage.md#how-to-create-buckets). The bucket, image and VM should be in the same region. 2. [Upload](https://docs.nebius.com/object-storage/objects/upload-download.md#upload-a-single-file) your image file to this bucket. 3. Create an image based on the uploaded file: 1. Copy the key of the file object: 1. In the [web console](https://console.nebius.com), go to **Storage** → **Object Storage**. 2. Open the bucket page. 3. In the line of the uploaded object, click → **Copy key**. 2. Create the image in Nebius AI Cloud: 1. In the web console, go to **Storage** → **Disks**. 2. Click **Create resource** → **Image**. 3. In the window that opens, specify the name of your image. 4. In the **Source** field, select **Object Storage file**. 5. In the **Object Storage file** field, specify the copied object key. The value must meet the `s3:///

Command parameter	Description	Environment variable	#SBATCH directive	Slurm default
`--job-name=` or `-J=`	The name of your job.	`SBATCH_JOB_NAME`	`#SBATCH --job-name=` or `#SBATCH -J=`	`job-name=` or `J=`
`--nodes=` or `-N=`	The number of worker nodes to allocate for the job.	N/A	`#SBATCH --nodes=` or `#SBATCH -N=`	`nodes=` or `N=`
`--nodelist=` or `-w=`	The list of specific worker nodes to allocate for the job. For example, `--nodelist="worker-0,worker-2"` or `--nodelist="worker-[0-2,3]"`.	N/A	`#SBATCH --nodelist=` or `#SBATCH -w=`	`nodelist=` or `w=`
`--exclude=` or `-x=`	The list of worker nodes to exclude from the job allocation. For example, `--exclude="worker-3"` or `--nodelist="worker-[4-7]"`.	N/A	`#SBATCH --exclude=` or `#SBATCH -x=`	`exclude=` or `x=`
`--output=` or `-o=`	The path to the file for the job's standard output. The path can contain special replacement symbols; for example, `%j` is replaced by the job ID. For more details, see the [Slurm documentation](https://slurm.schedmd.com/sbatch.html#SECTION_FILENAME-PATTERN).	`SBATCH_OUTPUT`	`#SBATCH --output=` or `#SBATCH -o=`	`output=` or `o=`
`--error=` or `-e=`	The path to the file for the job's error output. The path can contain the replacement symbols as described for the `output` setting.	`SBATCH_ERROR`	`#SBATCH --error=` or `#SBATCH -e=`	`error=` or `e=`
`--time=` or `-t=`	The time limit for the job. When the job reaches the time limit, all its tasks (processes) are terminated. For example, `01:00` limits the job to one hour, and `1-00` limits the job to one day (24 hours).	`SBATCH_TIMELIMIT`	`#SBATCH --time=` or `#SBATCH -t=`	`time=` or `t=`
`--gpus-per-node=`	The number of GPUs to allocate for the job on each worker node.	`SBATCH_GPUS_PER_NODE`	`#SBATCH --gpus-per-node=`	`gpus-per-node=`
`--ntasks-per-node=`	The maximum number of tasks to run on each worker node. When you define resources for the job in per-task settings like `gpus-per-task`, `cpus-per-task`, etc., total resources in the job allocation are based on the value of `ntasks-per-node`.	N/A	`#SBATCH --ntasks-per-node=`	`ntasks-per-node=`
`--exclusive`	Allocates all CPUs on the allocated worker nodes to the job, preventing other jobs from using these nodes. This allows the total number of tasks of the job to be unlimited.	`SBATCH_EXCLUSIVE`	`#SBATCH --exclusive`	N/A
`--cpus-per-task=` or `-c=`	The number of CPUs to allocate for the job per task.	N/A	`#SBATCH --cpus-per-task=` or `#SBATCH -c=`	`cpus-per-task=` or `c=`
`--mem=[]` or `-m=[]`	The RAM size to allocate for the job on each worker node. For example, `mem=4G`. To allocate all available RAM, specify `mem=0`.	`SBATCH_MEM_PER_NODE`	`#SBATCH --mem=[]` or `#SBATCH -m=[]`	`mem=[]` or `m=[]`
`--partition=` or `-p=`	The Slurm partition to allocate nodes from.	`SBATCH_PARTITION`	`#SBATCH --partition=` or `#SBATCH -p=`	`partition=` or `p=`
`--account=` or `-A=`	The Slurm account name.	`SBATCH_ACCOUNT`	`#SBATCH --account=` or `#SBATCH -A=`	`account=` or `A=`
`--requeue`	Requeues the job automatically: restarts it (with the same ID) when its worker nodes fail or other, higher-priority jobs preempt them.	`SBATCH_REQUEUE`	`#SBATCH --requeue`	`requeue`
`--no-requeue`	Disables automatically requeuing the job (see `requeue`).	`SBATCH_NO_REQUEUE`	`#SBATCH --no-requeue`	`no-requeue`
`--dependency=` or `-d=`	Dependencies of the job. For example: `dependency=singleton` requires that the job only starts after other jobs with the same name and user are terminated. This means that at any moment, there can only be one job with this name and owned by this user. `dependency=afterany:20:21` requires that the job only starts after the jobs with IDs 20 and 21 are terminated. For more details, see the [Slurm documentation](https://slurm.schedmd.com/sbatch.html#OPT_dependency).	N/A	`#SBATCH --dependency=` or `#SBATCH -d=`	`dependency=` or `d=`
`--parsable`	Changes the standard output of `sbatch` from `Submitted batch job ` to just ``.	N/A	`#SBATCH --parsable`	`parsable`
`--verbose` or `-v`	Increases the verbosity of `sbatch`'s informational messages. For more verbosity, use the parameter, `#SBATCH` directive or Slurm default multiple times, or set the `SBATCH_DEBUG` environment variable to `2`, `3`, etc.	`SBATCH_DEBUG`	`#SBATCH --verbose` or `#SBATCH -v`	`verbose` or `v`