---
title: Provisioning
url: https://docs.vultr.com/products/compute/instances/vx1-cloud-compute/provisioning
description: Provision a high-performance Vultr VX1™ Cloud Compute instance using the Vultr Console or API, with flexible boot options including local NVMe and Block Storage.
publish_date: 2025-11-19T14:05:56.576792Z
last_updated: 2026-05-26T18:51:44.482806Z
---

# How to Provision Vultr VX1™ Cloud Compute Instances

Vultr VX1™ Cloud Compute delivers industry-leading price-performance with dedicated CPU resources. VX1™ supports booting from high-performance Vultr Block Storage and can also leverage local NVMe for high-speed scratch storage.

Follow this guide to provision a Vultr VX1™ Cloud Compute instance using the Vultr Console or Vultr API.

> [!NOTE]
> VX1™ is available in select locations and expanding to more regions. To verify availability, navigate to the **Deploy Instance** page in the [Vultr Console](https://console.vultr.com), select the required VX1™ plan, and verify that it is available in your preferred location.

=== "Vultr Console"

    1. Navigate to **Products** and click **Compute**.
    1. Click **Deploy**.
    1. Choose **Dedicated CPU** as the instance type.
    1. Select your desired Vultr location to deploy the instance.
    1. Select **VX1** from the sidebar plan categories.
    1. Select a plan from the available options:

        * **General Purpose** (`vx1-g-*`): Provide a balanced combination of vCPUs and memory, suitable for most workloads including web servers, application servers, development environments, container workloads, and moderate database deployments.

        * **Memory Optimized** (`vx1-m-*`): Provide a higher memory-to-vCPU ratio, ideal for workloads requiring large in-memory datasets such as caching engines, analytics workloads, JVM applications, high-memory web services, and large databases.

        > [!NOTE]
        > Plans ending with `-###s` suffix (such as `vx1-g-4c-16g-240s`) include local NVMe storage.

    1. Click **Configure Software**.
    1. Select Boot Disk Settings:

        * **Local NVMe**: Boot from high-speed local NVMe storage.

        * **Bootable Block Volume**: Boot from Vultr Block Storage. Select an existing bootable block volume or click **Create Bootable Block Volume** to create a new one. When creating a bootable block volume, select the operating system, storage size, and label.

    1. Select a cloud image to install on your instance based on the following options:

        * **Operating System**: Installs a fresh operating system image on the instance.
        * **Marketplace Apps**: Installs a prebuilt software stack or application and the recommended operating system image on the instance.
        * **ISO/iPXE**: Boots a specific ISO available or iPXE-compatible image on the instance.
        * **ISO Library**: Installs a specific ISO image from the Vultr ISOs library.
        * **Backup**: Recovers a specific backup available in your Vultr account to the instance.
        * **Snapshot**: Installs a specific snapshot available in your Vultr account to the instance.

    1. Select optional **Server Settings** to apply on the instance.

        * **SSH Keys**: Installs a specific SSH key on the instance.
        * **Startup Script**: Enables a startup script to execute at deployment or a PXE script to automate the operating system installation.
        * **Firewall Group**: Activates a Vultr Firewall group to filter incoming network traffic on the instance.

    1. Enter a new hostname in the **Server Hostname** field and a descriptive label in the **Server Label** field to identify the instance.

    1. Configure **Additional Features** for the instance.

        * **Instance Connectivity**: Select how the instance connects to the internet.
            - **Instance(s) with Public IP**: Assigns public IP addresses directly to the instance. Under **Instance Address**, **Public IPv4** is enabled by default. Select **Public IPv6** to enable IPv6 addressing. After selecting IPv6, you can optionally deselect **Public IPv4** to create an IPv6-only instance.
            - **Private Instance(s) behind NAT Gateway**: Routes internet traffic through a NAT Gateway in a Virtual Private Cloud (VPC) Network. Select an existing VPC Network with a NAT Gateway or click **Add VPC Network** to create a new one.
        * **VPC Network**: Connects the instance to a VPC Network in the current location.
        * **Automatic Backups**: Automatically creates backups for data recovery in case of instance failures.
        * **DDoS Protection**: Prevents potential Distributed Denial of Service (DDoS) attacks on the instance.
        * **Limited User Login**: Creates a `linuxuser` non-root user with sudo privileges as the default user account instead of `root`.
        * **Cloud-Init User Data**: Enables Cloud-Init user data to initialize and customize the instance at boot.

    1. Click **Deploy** to provision the instance.

=== "Vultr API"

    Use the examples below as a reference for deploying VX1™ instances using API.

    ## Boot from Local NVMe

    In this section, you create a VX1™ instance that boots directly from the high-performance local NVMe device included with `-###s` plans. You can rely on the default boot configuration or explicitly specify the local NVMe disk as the bootable device, depending on your deployment requirements.

    ### Option A — Basic Local Boot (Default Local NVMe)

    Send a `POST` request to the [Create Instance endpoint](https://www.vultr.com/api/#tag/instances/operation/create-instance) to create a VX1™ instance using local NVMe as the default boot device.

    ```console
    $ curl "https://api.vultr.com/v2/instances" \
        -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer ${VULTR_API_KEY}" \
        --data '{
            "region": "ewr",
            "plan": "vx1-g-4c-16g-240s",
            "label": "VX1 Local Disk Only",
            "hostname": "vx1-localonly-1",
            "os_id": 2284
        }'
    ```

    ### Option B — Explicit Local Boot Configuration

    Send a `POST` request to the [Create Instance endpoint](https://www.vultr.com/api/#tag/instances/operation/create-instance) to explicitly configure the local NVMe device (`block_id: "local"`) as the boot drive.

    ```console
    $ curl "https://api.vultr.com/v2/instances" \
        -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer ${VULTR_API_KEY}" \
        --data '{
            "region": "ewr",
            "plan": "vx1-g-4c-16g-240s",
            "label": "VX1 Local Disk Only - Bootable",
            "hostname": "vx1-localonly-2",
            "os_id": 2284,
            "block_devices": [
            {
                "block_id": "local",
                "bootable": true
            }
            ]
        }'
    ```

    > [!NOTE]
    > Select a plan with the `-###s` suffix (for example, `vx1-g-4c-16g-240s`) to include local NVMe storage.

    ## Boot from Block Storage

    In this section, you create a VX1™ instance that boots from a high-performance block storage volume. You can either provision a bootable block device first and attach it to a new instance or create a VX1™ instance that includes a newly provisioned bootable block volume during deployment.

    ### Option A - Create a Bootable Block Volume and VX1™ Instance

    1. Send a POST request to the [Create Block Storage endpoint](https://www.vultr.com/api/#tag/block/operation/create-block) to create a bootable block device.

        ```console
        $ curl "https://api.vultr.com/v2/blocks" \
            -X POST \
            -H "Content-Type: application/json" \
            -H "Authorization: Bearer ${VULTR_API_KEY}" \
            --data '{
                "region": "ewr",
                "size_gb": 50,
                "label": "Bootable Block",
                "block_type": "high_perf",
                "os_id": 2284,
                "bootable": true
            }'
        ```

    1. Send a `POST` request to the [Create Instance endpoint](https://www.vultr.com/api/#tag/instances/operation/create-instance) to create the VX1™ instance using the previously created bootable block volume.

        ```console
        $ curl "https://api.vultr.com/v2/instances" \
            -X POST \
            -H "Content-Type: application/json" \
            -H "Authorization: Bearer ${VULTR_API_KEY}" \
            --data '{
                "region": "ewr",
                "plan": "vx1-g-4c-16g",
                "label": "vx1-blockonly-existing-boot-block-1",
                "hostname": "vx1-blockonly-existing-boot-block-1",
                "os_id": 2284,
                "block_devices": [
                {
                    "block_id": "BLOCK_UUID",
                    "bootable": true
                }
                ]
            }'
        ```

        Replace `BLOCK_UUID` with the UUID of your bootable block.

    ### Option B — Create a VX1™ Instance with a New Bootable Block

    Send a POST request to the [Create Instance endpoint](https://www.vultr.com/api/#tag/instances/operation/create-instance) to create the VX1™ instance and provision a new bootable block device at the same time.

    ```console
    $ curl "https://api.vultr.com/v2/instances" \
        -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer ${VULTR_API_KEY}" \
        --data '{
            "region": "ewr",
            "plan": "vx1-g-4c-16g",
            "label": "vx1-blockonly-new-boot-block-1",
            "hostname": "vx1-blockonly-new-boot-block-1",
            "os_id": 2284,
            "block_devices": [
            {
                "disk_size": 50,
                "label": "New Bootable Block",
                "bootable": true
            }
            ]
        }'
    ```

    Replace `BLOCK_UUID` with the UUID of your bootable block device.

    ## Boot from Local NVMe and Block Storage

    In this section, you deploy a VX1™ instance that boots from a block storage device while also attaching the high-performance local NVMe disk for additional data storage. You can create a new bootable block volume during deployment or boot from an existing bootable block device.

    ### Option A — New Bootable Block + Local Storage

    Send a `POST` request to the [Create Instance endpoint](https://www.vultr.com/api/#tag/instances/operation/create-instance) to create a VX1™ instance that boots from a new bootable block device and includes local NVMe for additional data storage.

    ```console
    $ curl "https://api.vultr.com/v2/instances" \
        -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer ${VULTR_API_KEY}" \
        --data '{
            "region": "ewr",
            "plan": "vx1-g-4c-16g-240s",
            "label": "vx1-new-boot-block-plus-local-1",
            "hostname": "vx1-new-boot-block-plus-local-1",
            "os_id": 2284,
            "block_devices": [
            {
                "disk_size": 50,
                "label": "New Bootable Block",
                "bootable": true
            },
            {
                "block_id": "local"
            }
        ]
        }'
    ```

    ### Option B — Existing Bootable Block + Local Storage

    Send a `POST` request to the [Create Instance endpoint](https://www.vultr.com/api/#tag/instances/operation/create-instance) to create a VX1™ instance that boots from an existing bootable block device and includes local NVMe.

    ```console
    $ curl "https://api.vultr.com/v2/instances" \
        -X POST \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer ${VULTR_API_KEY}" \
        --data '{
            "region": "ewr",
            "plan": "vx1-g-4c-16g-240s",
            "label": "vx1-existing-boot-block-plus-local-1",
            "hostname": "vx1-existing-boot-block-plus-local-1",
            "os_id": 2284,
            "block_devices": [
            {
                "block_id": "local"
            },
            {
                "block_id": "BLOCK_UUID",
                "bootable": true
            }
        ]
        }'
    ```

    Replace `BLOCK_UUID` with the UUID of your bootable block device.

    > [!NOTE]
    > After deployment, format and mount the local NVMe disk inside your operating system if you plan to use it for data storage.

## Additional Notes

* Windows operating systems are not available for VX1™ instances.
* When creating bootable block devices, you must set `block_type` to `high_perf`.