[Yandex Cloud documentation](../../index.md) > [Yandex Managed Service for Apache Spark™](../index.md) > [Step-by-step guides](index.md) > Clusters > Creating a cluster

# Creating a Apache Spark™ cluster

Each Apache Spark™ cluster contains computing resources to run Spark applications.

## Roles for creating a cluster {#roles}

To create a Apache Spark™ cluster, your Yandex Cloud account needs the following roles:

* [managed-spark.admin](../security.md#managed-spark-admin): To create a cluster.
* [vpc.user](../../vpc/security/index.md#vpc-user): To use the cluster [network](../../vpc/concepts/network.md#network).
* [iam.serviceAccounts.user](../../iam/security/index.md#iam-serviceAccounts-user): To attach a service account to a cluster.

Make sure to assign the `managed-spark.integrationProvider` and `storage.editor` roles to the cluster service account. The cluster will thus get the permissions it needs to work with user resources.


For more information about assigning roles, see [this Yandex Identity and Access Management guide](../../iam/operations/roles/grant.md).


## Creating a cluster {#create-cluster}

{% list tabs group=instructions %}

- Management console {#console}

    1. In the [management console](https://console.yandex.cloud), select the folder where you want to create a Apache Spark™ cluster.
    1. Navigate to **Managed Service for Apache Spark™**.
    1. Click **Create cluster**.
    1. Under **Basic parameters**:

        1. Give the cluster a name. The name must be unique within the folder.
        1. Optionally, enter a description for the cluster.
        1. Optionally, create [labels](../../resource-manager/concepts/labels.md):

            1. Click **Add label**.
            1. Enter a label in `key: value` format.
            1. Press **Enter**.

        1. Select an existing [service account](../../iam/concepts/users/service-accounts.md) or [create a new one](../../iam/operations/sa/create.md).

            Make sure to assign the `managed-spark.integrationProvider` role to this service account:

        1. Select the Apache Spark™ version.

           {% note info %}
                      
           After creating a cluster, you can [change your Apache Spark™ version](cluster-version-update.md). You can only upgrade the version.
                      
           {% endnote %}

    1. Under **Network settings**, select a [network](../../vpc/operations/network-create.md), [subnet](../../vpc/operations/subnet-create.md), and [security group](../../vpc/concepts/security-groups.md) for the cluster.

    1. Specify the computing resources to run Spark applications on:

       * Driver configuration: Number of driver hosts and [their class](../concepts/instance-types.md). It can be either fixed or autoscalable.
       * Executor configuration: Number of executor hosts and [their class](../concepts/instance-types.md). It can be either fixed or autoscalable.

    1. If needed, configure the advanced cluster settings:
        
        1. **Pip packages** and **Deb packages**: Pip and deb package names for installing additional libraries and applications.
           
           To specify multiples packages, click **Add**.

           The package name format and version are defined by the install command: `pip install` for pip packages and `apt install` for deb packages.
        
        1. **Maintenance**: [Maintenance](../concepts/maintenance.md) window settings:

           * To enable maintenance at any time, select **At any time** (default).
           * To specify the preferred maintenance start time, select **By schedule** and specify the day of the week and the UTC time interval. For example, you can choose a time when the cluster is least loaded.
           
           Both active and stopped clusters are subject to maintenance. Maintenance operations include DBMS updates, patches, etc.

        1. **Metastore**: [Metastore server](../../metadata-hub/concepts/metastore.md) connected to your cluster.

        1.  **Deletion protection**: Manages cluster protection against accidental deletion.
        1. Enable the **History Server** setting to allow using the service to monitor [Spark History Server](https://spark.apache.org/docs/latest/monitoring.html) applications. After creating a cluster, the service will be available via a link.
        1. Configure logging:

            1. Enable the **Write logs** setting.
            1. Select the log destination:
                * **Folder**: Select a folder from the list.
                * **Group**: Select a [log group](../../logging/concepts/log-group.md) from the list or create a new one.
            1. Select **Min. logging level** from the list.

    1. Click **Create**.

- CLI {#cli}

    If you do not have the Yandex Cloud CLI yet, [install and initialize it](../../cli/quickstart.md#install).

    The folder used by default is the one specified when [creating](../../cli/operations/profile/profile-create.md) the CLI profile. To change the default folder, use the `yc config set folder-id <folder_ID>` command. You can also specify a different folder for any command using `--folder-name` or `--folder-id`. If you access a resource by its name, the search will be limited to the default folder. If you access a resource by its ID, the search will be global, i.e., through all folders based on access permissions.

    To create an Apache Spark™ cluster:

    1. Check whether the folder has any subnets for cluster hosts:

        ```bash
        yc vpc subnet list
        ```

        If there are no subnets in the folder, [create the right ones](../../vpc/operations/subnet-create.md) in VPC.

    1. View the description of the CLI command for creating a cluster:

        ```bash
        yc managed-spark cluster create --help
        ```

    1. Specify the cluster properties in this command (the example does not show all that are available):

        ```bash
        yc managed-spark cluster create \
           --name <cluster_name> \
           --spark-version <<Apache_Spark_version>> \
           --service-account-id <service_account_ID> \
           --subnet-ids <list_of_subnet_IDs> \
           --security-group-ids <list_of_security_group_IDs> \
           --driver-preset-id=<class_of_driver_computing_resources> \
           --driver-fixed-size <number_of_driver_hosts> \
           --executor-preset-id <class_of_executor_computing_resources> \
           --executor-min-size <minimum_number_of_executor_hosts> \
           --executor-max-size <maximum_number_of_executor_hosts> \
           --pip-packages <list_of_pip_packages> \
           --deb-packages <list_of_deb_packages>\
           --history-server-enabled \ 
           --metastore-cluster-id <cluster_ID> \
           --deletion-protection
        ```

        Where:

        * `--name`: Cluster name. It must be unique within the folder.
        * `--version`: Apache Spark™ version.

           {% note info %}
                      
           After creating a cluster, you can [change your Apache Spark™ version](cluster-version-update.md). You can only upgrade the version.
                      
           {% endnote %}

        * `--service-account-id`: Service account ID.
        * `--subnet-ids`: List of subnet IDs.
        * `--security-group-ids`: List of security group IDs.
        * `--driver-preset-id`: [Class](../concepts/instance-types.md) of [driver](../concepts/index.md#concepts) computing resources.
        * `--driver-fixed-size`: Fixed number of driver instances.
        * `--driver-min-size`: Minimum number of driver instances.
        * `--driver-max-size`: Maximum number of driver instances.

           Specify either a fixed number of drivers or minimum and maximum numbers of drivers for autoscaling.

        * `--executor-preset-id`: [Class](../concepts/instance-types.md) of executor computing resources.
        * `--executor-fixed-size`: Fixed number of executor instances.
        * `--executor-min-size`: Minimum number of executor instances.
        * `--executor-max-size`: Maximum number of executor instances.

           Specify either a fixed number of executors or minimum and maximum numbers of executors for autoscaling.

        * `--pip-packages`: List of pip packages enabling you to install additional libraries and applications in the cluster.

            The package name format and version are determined by the `pip install` command.

        * `--deb-packages`: List of deb packages enabling you to install additional libraries and applications in the cluster.

            The package name format and version are determined by the `apt install` command.

        * `--history-server-enabled`: Flag to enable history server. It allows using the service to monitor Spark History Server applications.

        * `--metastore-cluster-id`: ID of the [Apache Hive™ Metastore cluster](../../metadata-hub/concepts/metastore.md) to use as a metadata storage.

        * `--deletion-protection`: Cluster protection from accidental deletion, `true` or `false`.

            Even with deletion protection on, one can still connect to the cluster manually and delete it.

    1. To enable sending of Apache Spark™ logs to [Yandex Cloud Logging](../../logging/index.md), specify logging parameters:

        ```bash
        yc managed-spark cluster create <cluster_name> \
           ...
           --log-enabled \
           --log-folder-id <folder_ID>
        ```

        Where:

        * `--log-enabled`: Enables logging.
        * `--log-folder-id`: Folder ID. Logs will be written to the default [log group](../../logging/concepts/log-group.md) for this folder.
        * `--log-group-id`: Custom log group ID. Logs will be written to this group.

            Specify either a folder ID or a custom log group ID.

    1. To set up a [maintenance window](../concepts/maintenance.md) (including for disabled clusters), provide the relevant value in the `--maintenance-window` parameter:

        ```bash
        yc managed-spark cluster create <cluster_name> \
           ...
           --maintenance-window type=<maintenance_type>,`
                               `day=<day_of_week>,`
                               `hour=<hour> \
        ```

        Where `type` is the maintenance type:

        * `anytime`: Any time (default).
        * `weekly`: On a schedule. For this value, also specify the following:
            * `day`: Day of week, i.e., `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, or `SUN`.
            * `hour`: Sequence number of UTC hour interval, from `1` to `24`.
        
              > For example, `1` stands for the interval from `00:00` to `01:00`, and `5`, from `04:00` to `05:00`.

- Terraform {#tf}

    With [Terraform](https://www.terraform.io/), you can quickly create a cloud infrastructure in Yandex Cloud and manage it using configuration files. These files store the infrastructure description written in HashiCorp Configuration Language (HCL). If you change the configuration files, Terraform automatically detects which part of your configuration is already deployed, and what should be added or removed.
    
    Terraform is distributed under the [Business Source License](https://github.com/hashicorp/terraform/blob/main/LICENSE). The [Yandex Cloud provider for Terraform](https://github.com/yandex-cloud/terraform-provider-yandex) is distributed under the [MPL-2.0](https://www.mozilla.org/en-US/MPL/2.0/) license.
    
    For more information about the provider resources, see the guides on the [Terraform](https://www.terraform.io/docs/providers/yandex/index.html) website or [its mirror](../../terraform/index.md).

    If you do not have Terraform yet, [install it and configure the Yandex Cloud provider](../../tutorials/infrastructure-management/terraform-quickstart.md#install-terraform).
    
    
    To manage infrastructure using Terraform under a service account or user accounts (a Yandex account, a federated account, or a local user), [authenticate](../../terraform/authentication.md) using the appropriate method.

    To create a Yandex Managed Service for Apache Spark™ cluster:

    1. In the configuration file, describe the resources you are creating:

        * Yandex Managed Service for Apache Spark™ cluster: Cluster description.

        * Network: Description of the [cloud network](../../vpc/concepts/network.md#network) where a cluster will be located. If you already have a suitable network, you don't have to describe it again.

        * Subnets: Description of the [subnets](../../vpc/concepts/network.md#subnet) to connect the cluster hosts to. If you already have suitable subnets, you don't have to describe them again.

        Here is an example of the configuration file structure:
        
        ```hcl
        resource "yandex_spark_cluster" "<cluster_name>" {
          description         = "<cluster_description>"
          name                = "<cluster_name>"
          folder_id           = "<folder_ID>"
          service_account_id  = "<service_account_ID>"
          deletion_protection = <protect_cluster_from_deletion>
        
          labels = {
            <label_list>
          }
        
          network = {
            subnet_ids         = ["<list_of_subnet_IDs>"]
            security_group_ids = ["<list_of_security_group_IDs>"]
          }
        
          config = {
            resource_pools = {
              driver = {
                resource_preset_id = "<host_class>"
                size               = <fixed_number_of_instances>
              }
              executor = {
                resource_preset_id = "<host_class>"
                size               = <fixed_number_of_instances>
              }
            }
            spark_version = "<Apache_Spark_version>"
          }
        
          logging = {
            enabled      = <enable_logging>
            folder_id    = "<folder_ID>"
          }
        
        }
        
        resource "yandex_vpc_network" "<network_name>" {
          name = "<network_name>"
        }
        
        resource "yandex_vpc_subnet" "<subnet_name>" {
          name           = "<subnet_name>"
          zone           = "<availability_zone>"
          network_id     = "<network_ID>"
          v4_cidr_blocks = ["<range>"]
        }
        ```
        
        Where:
        
        * `description`: Cluster description. This is an optional parameter.
        * `name`: Cluster name.
        * `folder_id`: Folder ID. This is an optional parameter. If the value is missing, the cluster will reside in the folder specified in the provider settings.
        * `service_account_id`: Service account ID.
        * `deletion_protection`: Cluster protection from accidental deletion, `true` or `false`. This is an optional parameter.
        * `labels`: List of labels. This is an optional parameter. Provide labels in `<key> = "<value>"` format.
        * `subnet_ids`: List of subnet IDs.
        * `security_group_ids`: List of security group IDs.
        * `driver`: Host configuration to run Apache Spark™ drivers. In this section, specify:
        
          * [Host class](../concepts/instance-types.md) in the `resource_preset_id` parameter.
          * Number of instances. Specify a fixed number in the `size` parameter or the minimum and maximum number for autoscaling in the `min_size` and `max_size` parameters.
        
        * `executor`: Host configuration to run Apache Spark™ executors. In this section, specify:
        
          * [Host class](../concepts/instance-types.md) in the `resource_preset_id` parameter.
          * Number of instances. Specify a fixed number in the `size` parameter or the minimum and maximum number for autoscaling in the `min_size` and `max_size` parameters.
        
        * `spark_version` (optional): Apache Spark™ version.
        
           {% note info %}
                      
           After creating a cluster, you can [change your Apache Spark™ version](cluster-version-update.md). You can only upgrade the version.
                      
           {% endnote %}
              
        * `logging`: Logging parameters. Logs generated by Apache Spark™ components will be sent to Yandex Cloud Logging. To enable logging:
        
            * Set the `enabled = true` value.
            * Specify one of two log storage locations:
            
              * `folder_id`: Folder ID. Logs will be written to the default [log group](../../logging/concepts/log-group.md) for this folder.
              * `log_group_id`: Custom log group ID. Logs will be written to this group.

    1. If necessary, configure additional DBMS settings:

        * To set up the [maintenance](../concepts/maintenance.md) window that will also apply to stopped clusters, add the `maintenance_window` section to the cluster description:
          
          ```hcl
          resource "yandex_spark_cluster" "<cluster_name>" {
            ...
            maintenance_window {
              type = "<maintenance_type>"
              day  = "<day_of_week>"
              hour = <hour>
            }
            ...
          }
          ```
          
          Where:
          
          * `type`: Maintenance type. The possible values include:
              * `ANYTIME`: Any time.
              * `WEEKLY`: On a schedule.
          * `day`: Day of week for the `WEEKLY` type, i.e., `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, or `SUN`.
          * `hour`: Sequence number of UTC hour interval for the `WEEKLY` type, from `1` to `24`.
          
            > For example, `1` stands for the interval from `00:00` to `01:00`, and `5`, from `04:00` to `05:00`.
        
        * To enable Apache Spark™ History Server, add a section named `history_server` to the cluster configuration description:
        
            ```hcl
            resource "yandex_spark_cluster" "<cluster_name>" {
            ...
              config = {
              ...
                history_server = {
                  enabled = true
                }
              }
            }
            ```
        
        * To connect an [Apache Hive™ Metastore server](../../metadata-hub/concepts/metastore.md) to your cluster, add the `metastore` section to the cluster configuration description:
        
            ```hcl
            resource "yandex_spark_cluster" "<cluster_name>" {
            ...
              config = {
              ...
                metastore = {
                  cluster_id = "<metastore_cluster_ID>"
                }
              }
            }
            ```
        
        * To connect additional deb and pip packages for running Apache Spark™ jobs, add the `dependencies` section to the cluster configuration description:
        
            ```hcl
            resource "yandex_spark_cluster" "<cluster_name>" {
            ...
              config = {
              ...
                dependencies = {
                  deb_packages = ["<list_of_deb_packages>"]
                  pip_packages = ["<list_of_pip_packages>"]
                }
              }
            }
            ```
        
            Where `deb_packages` and `pip_packages` are package names. Their format depends on the installation command: `apt install` for deb packages and `pip install` for pip packages.

    1. Make sure the settings are correct.

        1. In the command line, navigate to the directory that contains the current Terraform configuration files defining the infrastructure.
        1. Run this command:
        
           ```bash
           terraform validate
           ```
        
           Terraform will show any errors found in your configuration files.

    1. Create a Yandex Managed Service for Apache Spark™ cluster.

        1. Run this command to view the planned changes:
        
           ```bash
           terraform plan
           ```
        
           If you described the configuration correctly, the terminal will display a list of the resources to update and their parameters. This is a verification step that does not apply changes to your resources.
        
        1. If everything looks correct, apply the changes:
           1. Run this command:
        
              ```bash
              terraform apply
              ```
        
           1. Confirm updating the resources.
           1. Wait for the operation to complete.

        This will create all the resources you need in the specified folder. You can check the new resources and their settings using the [management console](https://console.yandex.cloud).

    For more information, see [this Terraform provider guide](../../terraform/resources/spark_cluster.md).

- gRPC API {#grpc-api}

    1. [Get an IAM token for API authentication](../api-ref/authentication.md) and place it in an environment variable:
    
       ```bash
       export IAM_TOKEN="<IAM_token>"
       ```
    
    1. Clone the [cloudapi](https://github.com/yandex-cloud/cloudapi) repository:
       
       ```bash
       cd ~/ && git clone --depth=1 https://github.com/yandex-cloud/cloudapi
       ```
       
       Below, we assume that the repository contents reside in the `~/cloudapi/` directory.
    
    1. Create a file named `body.json` and paste the following code into it:

       ```json
       {
         "folder_id": "<folder_ID>",
         "name": "<cluster_name>",
         "description": "<cluster_description>",
         "labels": { <label_list> },
         "config": {
           "resource_pools": {
             "driver": {
               "resource_preset_id": "<resource_ID>",
               "scale_policy": {
                 "fixed_scale": {
                   "size": "<number_of_instances>"
                 }
               }
             },
             "executor": {
               "resource_preset_id": "<resource_ID>",
               "scale_policy": {
                 "auto_scale": {
                   "min_size": "<minimum_number_of_instances>",
                   "max_size": "<maximum_number_of_instances>"
                 }
               }
             },
             "spark_version": "<Apache_Spark_version>"
           },
           "history_server": {
             "enabled": <use_of_Apache_Spark_History_Server>
           },
           "dependencies": {
             "pip_packages": [ <list_of_pip_packages> ],
             "deb_packages": [ <list_of_deb_packages> ]
           },
           "metastore": {
             "cluster_id": "<cluster_ID>"
           }
         },
         "network": {
           "subnet_ids": [ <list_of_subnet_IDs> ],
           "security_group_ids": [ <list_of_security_group_IDs> ]
         },
         "deletion_protection": <deletion_protection>,
         "service_account_id": "<service_account_ID>",
         "logging": {
           "enabled": <use_of_logging>,
           "folder_id": "<folder_ID>"
         }
       }
       ```

       Where:

       * `folder_id`: Folder ID. You can request it with the [list of folders in the cloud](../../resource-manager/operations/folder/get-id.md).
       * `name`: Cluster name.
       * `description`: Cluster description.
       * `labels`: List of labels provided in `"<key>": "<value>"` format.
       * `config`: Cluster configuration:

           * `resource_pools`: Resource pool configuration:

               * `driver`: Host configuration to run Apache Spark™ drivers.

                   * `resource_preset_id`: Driver [host class](../concepts/instance-types.md).
                   * `scale_policy`: Host group scaling policy for the driver:

                       * `fixed_scale`: Fixed scaling policy.
                           * `size`: Number of driver hosts.

                       * `auto_scale`: Automatic scaling policy.
                           * `min_size`: Minimum number of driver hosts.
                           * `max_size`: Maximum number of driver hosts.

                           Specify either `fixed_scale` or `auto_scale`.

               * `executor`: Host configuration to run Apache Spark™ executors.

                   * `resource_preset_id`: Executor [host class](../concepts/instance-types.md).
                   * `scale_policy`: Host group scaling policy for the executor:

                       * `fixed_scale`: Fixed scaling policy.
                           * `size`: Number of executor hosts.

                       * `auto_scale`: Automatic scaling policy.
                           * `min_size`: Minimum number of executor hosts.
                           * `max_size`: Maximum number of executor hosts.

                           Specify either `fixed_scale` or `auto_scale`. 

           * `history_server`: History server parameters.
              * `enabled`: Flag to enable history server. It allows using the service to monitor Spark History Server applications.

           * `dependencies`: Lists of packages enabling you to install additional libraries and applications on the cluster.
              * `pip_packages`: List of pip packages.
              * `deb_packages`: List of deb packages.

              The package name format and version are defined by the install command: `pip install` for pip packages and `apt install` for deb packages.

           * `metastore`: Metastore parameters.
              * `cluster_id`: [Apache Hive™ Metastore](../../metadata-hub/concepts/metastore.md) cluster ID.

           * `spark_version`: Apache Spark™ version.

              {% note info %}
                         
              After creating a cluster, you can [change your Apache Spark™ version](cluster-version-update.md). You can only upgrade the version.
                         
              {% endnote %}

       * `network`: Network settings:
          * `subnet_ids`: List of subnet IDs.
          * `security_group_ids`: List of security group IDs.

       * `deletion_protection`: Enables cluster protection against accidental deletion. The possible values are `true` or `false`.

          Even with deletion protection on, one can still connect to the cluster manually and delete it.

       * `service_account_id`: Service account ID.

       * `logging`: Logging parameters:
          * `enabled`: Enables logging. Logs generated by Spark applications will go to Yandex Cloud Logging. The possible values are `true` or `false`.
          * `folder_id`: Folder ID. Logs will be written to the default [log group](../../logging/concepts/log-group.md) for this folder.
          * `log_group_id`: Custom log group ID. Logs will be written to this group.

          Specify either `folder_id` or `log_group_id`.

    1. Call the [ClusterService/Create](../api-ref/grpc/Cluster/create.md) method, e.g., via the following [gRPCurl](https://github.com/fullstorydev/grpcurl) request:

       ```bash
       grpcurl \
           -format json \
           -import-path ~/cloudapi/ \
           -import-path ~/cloudapi/third_party/googleapis/ \
           -proto ~/cloudapi/yandex/cloud/spark/v1/cluster_service.proto \
           -rpc-header "Authorization: Bearer $IAM_TOKEN" \
           -d @ \
           spark.api.cloud.yandex.net:443 \
           yandex.cloud.spark.v1.ClusterService.Create \
           < body.json
       ```

    1. Check the [server response](../api-ref/grpc/Cluster/create.md#yandex.cloud.operation.Operation) to make sure your request was successful.

{% endlist %}

## Examples {#examples}

{% list tabs group=instructions %}

- CLI {#cli}

    Create an Apache Spark™ cluster with the following test specifications:

    * Name: `myspark`.
    * Service account: `ajev56jp96ji********`.
    * Subnet: `b0rcctk2rvtr8efcch64`.
    * Security group: `enp6saqnq4ie244g67sb`.
    * Two drivers with [computing resource class](../concepts/instance-types.md): `c2-m16`.
    * Four executors with computing resource class: `c2-m16`.
    * History server enabled.
    * Accidental deletion protection enabled.

    Run this command:

    ```bash
    yc managed-spark cluster create \
       --name myspark \
       --service-account-id ajev56jp96ji******** \
       --subnet-ids b0rcctk2rvtr8efcch64 \
       --security-group-ids enp6saqnq4ie244g67sb \
       --driver-preset-id c2-m16 \
       --driver-fixed-size 2 \
       --executor-preset-id c2-m16 \
       --executor-fixed-size 4 \
       --history-server-enabled \
       --deletion-protection
    ```

- Terraform {#tf}

    Create an Apache Spark™ cluster and its supporting network, using the following test specifications:

    * Name: `myspark`.
    * Service account: `ajev56jp96ji********`.
    * Network: `msp-network`.
    * Subnet: `msp-subnet`. The subnet availability zone is `ru-central1-a`; the range is `10.1.0.0/16`.
    * Two drivers with [computing resource class](../concepts/instance-types.md): `c2-m16`.
    * Four executors with computing resource class: `c2-m16`.
    * History server enabled.
    * Accidental deletion protection enabled.
    * Logging disabled.

    The configuration file for this cluster is as follows:

    ```hcl
    resource "yandex_spark_cluster" "myspark" {
      name                = "myspark"
      service_account_id  = "ajev56jp96ji********"
      deletion_protection = true

      network = {
        subnet_ids = [yandex_vpc_subnet.msp-subnet.id]
      }

      config = {
        resource_pools = {
          driver = {
            resource_preset_id = "c2-m16"
            size               = 2
          }
          executor = {
            resource_preset_id = "c2-m16"
            size               = 4
          }
        }
        history_server = {
          enabled = true
        }
      }

      logging = {
        enabled = false
      }
    }

    resource "yandex_vpc_network" "msp-network" {
      name = "msp-network"
    }

    resource "yandex_vpc_subnet" "msp-subnet" {
      name           = "msp-subnet"
      zone           = "ru-central1-a"
      network_id     = yandex_vpc_network.msp-network.id
      v4_cidr_blocks = ["10.1.0.0/16"]
    }
    ```

{% endlist %}