> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nebius.com/llms.txt
> Use this file to discover all available pages before exploring further.
# How to create a virtual machine in Nebius AI Cloud
You can create a Compute virtual machine (VM) in the [web console](https://console.nebius.com), or by using the [CLI](/cli/index) or [Terraform provider](/terraform-provider/index). You can tailor the VM configuration to your needs and, for example, attach secondary disks and filesystems, or allocate GPU resources to your VM.
## 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 theme={null}
export USER_DATA=$(jq -Rrs '.' <
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. 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 theme={null}
export USER_DATA=$(jq -Rrs '.' <
sudo: ALL=(ALL) NOPASSWD:ALL
shell: /bin/bash
ssh_authorized_keys:
-
```
5. Create the `variables.tf` file with the following contents:
```hcl theme={null}
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.
6. Initialize the working directory:
```bash theme={null}
terraform init
```
### 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** at the bottom of each step.
3. If you have [capacity block groups](/overview/limits/capacity-block-groups), 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](/compute/virtual-machines/preemptible) 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](/compute/virtual-machines/types).
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](/compute/virtual-machines/reservations).
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](/compute/clusters/gpu/index#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](/compute/virtual-machines/preemptible).
VMs without GPUs only support the regular type.
2. Select a [platform and preset](/compute/virtual-machines/types).
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](/compute/clusters/gpu/index#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](/compute/virtual-machines/capacity-advisor).
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](/compute/storage/boot-disk-images) provided by Nebius or a [custom image or image family](/compute/storage/custom-disk-images) that you created yourself. Also, configure the type, encryption, size and block size. For more information about these settings, see [Volume parameters](/compute/storage/manage#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](/compute/storage/use#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](/compute/storage/local-disks#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](/vpc/overview):
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](/compute/virtual-machines/network#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](/compute/virtual-machines/wireguard). 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](/compute/virtual-machines/network#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](/compute/virtual-machines/fqdn):
* **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](/compute/virtual-machines/connect):
1. Generate an [SSH key pair](/compute/virtual-machines/ssh-keys).
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 theme={null}
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](/compute/storage/manage).
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](/compute/storage/types#vm-managed-and-standalone-disks). They are tied to the VM lifecycle.
2. (Optional) To provide the VM with an [allocation](/vpc/overview#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](/vpc/networking/resources#how-to-get-a-subnet-id).
2. Run the following command:
```bash theme={null}
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](/compute/virtual-machines/network#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 theme={null}
nebius compute gpu-cluster create \
--name \
--infiniband-fabric
```
To select the fabric, see [InfiniBand fabrics](/compute/clusters/gpu/index#infiniband-fabrics).
Save the cluster ID from the output `metadata.id` parameter.
4. (Optional) Create a [service account](/iam/service-accounts/manage) that will perform actions on behalf of the VM:
```bash theme={null}
nebius iam service-account create --name
```
5. Create the VM:
```bash theme={null}
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](/compute/virtual-machines/lifecycle).
* `--resources-platform`: [VM platform](/compute/virtual-machines/types).
* `--resources-preset`: VM preset. Depends on the chosen platform.
* `--boot-disk-managed-disk-name`: Name of the [VM-managed boot disk](/compute/storage/types#vm-managed-and-standalone-disks) that you create along with the VM.
* `--boot-disk-managed-disk-type`: [Disk type](/compute/storage/types#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](/compute/storage/boot-disk-images).
* `--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](/compute/storage/use#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](#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](/compute/virtual-machines/wireguard). 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](/compute/storage/local-disks#availability).
* `--hostname` (optional): Hostname for the VM's [FQDN](/compute/virtual-machines/fqdn). 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](/compute/virtual-machines/reservations) 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](/compute/virtual-machines/reservations#how-to-add-reservations-to-vms).
* `--recovery-policy` (optional): Defines what Compute does with the VM after it is preempted or fails.
[Preemptible VMs](/compute/virtual-machines/preemptible) 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 theme={null}
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](/compute/storage/manage#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](/compute/storage/types#vm-managed-and-standalone-disks). They are tied to the VM lifecycle.
2. (Optional) To provide the VM with an [allocation](/vpc/overview#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 theme={null}
resource "nebius_vpc_v1_allocation" "my_allocation" {
name = ""
parent_id = ""
ipv4_public = {
subnet_id = ""
}
}
```
To create the allocation, [get the required subnet ID](/vpc/networking/resources#how-to-get-a-subnet-id).
For more information about networking in Compute, see [Public IP addresses](/compute/virtual-machines/network#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 theme={null}
resource "nebius_compute_v1_gpu_cluster" "my_gpu_cluster" {
name = ""
parent_id = ""
infiniband_fabric = ""
}
```
To select the fabric, see [InfiniBand fabrics](/compute/clusters/gpu/index#infiniband-fabrics).
4. (Optional) Create a [service account](/iam/service-accounts/manage) that will perform actions on behalf of the VM:
```hcl theme={null}
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](/compute/storage/local-disks#availability).
For example:
```hcl theme={null}
resource "nebius_compute_v1_instance" "my_vm" {
# ...
local_disks = {
passthrough_group = {
requested = true
}
}
}
```
6. Create the VM:
```hcl theme={null}
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](/compute/virtual-machines/lifecycle).
* `resources.platform`: [VM platform](/compute/virtual-machines/types).
* `resources.preset`: VM preset. Depends on the chosen platform.
* `boot_disk`: Settings of a [VM-managed boot disk](/compute/storage/types#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](/compute/storage/types#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](/compute/storage/boot-disk-images).
* `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](/compute/storage/use#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](#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](/compute/virtual-machines/wireguard). 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](/compute/storage/local-disks#availability).
* `hostname` (optional): Hostname for the VM's [FQDN](/compute/virtual-machines/fqdn). 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](/compute/virtual-machines/reservations) 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](/compute/virtual-machines/reservations#how-to-add-reservations-to-vms).
* `recovery_policy` (optional): Defines what Compute does with the VM after it is preempted or fails.
[Preemptible VMs](/compute/virtual-machines/preemptible) 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 theme={null}
terraform validate
```
8. Apply the changes:
```bash theme={null}
terraform apply
```
## Examples
### Create a VM without an additional disk or filesystem
To create a VM, run the following command:
```bash theme={null}
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](#create-a-vm).
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. Create a VM:
```hcl theme={null}
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](#create-a-vm).
3. Check that the configuration is correct:
```bash theme={null}
terraform validate
```
4. Apply the changes:
```bash theme={null}
terraform apply
```
### Create a VM with an additional disk
Create a VM, its boot disk and an additional disk together:
```bash theme={null}
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](#create-a-vm).
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. Create a VM, its boot disk and an additional disk together:
```hcl theme={null}
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](#create-a-vm).
3. Check that the configuration is correct:
```bash theme={null}
terraform validate
```
4. Apply the changes:
```bash theme={null}
terraform apply
```
### Create a VM with a filesystem
1. Create a filesystem:
```bash theme={null}
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](/compute/storage/use#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM.
2. Create the VM:
```bash theme={null}
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](#create-a-vm).
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. Create a filesystem:
```hcl theme={null}
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](/compute/storage/manage#volume-parameters).
[Mount filesystems](/compute/storage/use#shared-filesystems) after you create the VM. Otherwise, the filesystems are not attached to the VM.
3. Create the VM:
```hcl theme={null}
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](#create-a-vm).
4. Check that the configuration is correct:
```bash theme={null}
terraform validate
```
5. Apply the changes:
```bash theme={null}
terraform apply
```
### Create a VM with local SSD disks
Local SSD disks are available only for supported platforms and presets. For details, see [Availability](/compute/storage/local-disks#availability).
To create a VM with local SSD disks, run the following command:
```bash theme={null}
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](#create-a-vm).
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. Create the VM:
```hcl theme={null}
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](#create-a-vm).
3. Check that the configuration is correct:
```bash theme={null}
terraform validate
```
4. Apply the changes:
```bash theme={null}
terraform apply
```
### 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](/compute/storage/types#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 theme={null}
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](/compute/storage/manage).
2. Create an additional disk:
```bash theme={null}
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](/compute/storage/use#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks.
3. Create a VM:
```bash theme={null}
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](#create-a-vm).
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. Create a boot disk by using the following configuration:
```hcl theme={null}
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](/iam/manage-projects#terraform-3).
For more information, see [Volume parameters](/compute/storage/manage#volume-parameters).
3. Create an additional disk:
```hcl theme={null}
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](/compute/storage/use#how-to-mount-volumes-to-vms) to it. Otherwise, the VM's operating system does not recognize these disks.
4. Create a VM:
```hcl theme={null}
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](#create-a-vm).
5. Check that the configuration is correct:
```bash theme={null}
terraform validate
```
6. Apply the changes:
```bash theme={null}
terraform apply
```
### 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 theme={null}
nebius compute gpu-cluster create \
--name \
--infiniband-fabric
```
To select the fabric, see [InfiniBand fabrics](/compute/clusters/gpu/index#infiniband-fabrics).
Save the cluster ID from the output `metadata.id` parameter.
2. Create a VM:
```bash theme={null}
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](#create-a-vm).
1. [Install and configure](/terraform-provider/install) the Nebius AI Cloud provider for Terraform.
2. Create a GPU cluster:
```hcl theme={null}
resource "nebius_compute_v1_gpu_cluster" "my_gpu_cluster" {
name = ""
parent_id = ""
infiniband_fabric = ""
}
```
To select the fabric, see [InfiniBand fabrics](/compute/clusters/gpu/index#infiniband-fabrics).
3. Create a VM:
```hcl theme={null}
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](#create-a-vm).
4. Check that the configuration is correct:
```bash theme={null}
terraform validate
```
5. Apply the changes:
```bash theme={null}
terraform apply
```
## "Not enough resources" error
Sometimes, demand for virtual machines and GPUs in certain [Nebius AI Cloud regions](/overview/regions) 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](/compute/virtual-machines/not-enough-resources).
## See also
* [Private and public IP addresses of Compute virtual machines](/compute/virtual-machines/network)
* [InfiniBand™ networking for Compute virtual machines with GPUs](/compute/clusters/gpu/index)
* [Types of storage volumes in Compute](/compute/storage/types)
* [Managing Compute volumes](/compute/storage/manage)
* [Attaching and mounting Compute volumes to VMs](/compute/storage/use)
***
*InfiniBand and InfiniBand Trade Association are registered trademarks of the InfiniBand Trade Association.*