[Yandex Cloud documentation](../../../index.md) > [Yandex Compute Cloud](../../index.md) > [Tutorials](../index.md) > [Single-node file server](index.md) > Management console

# Creating a single-node file server using the management console

To create an infrastructure for a [single-node file server](index.md) using the Yandex Cloud management console:

1. [Get your cloud ready](#before-you-begin).
1. [Create a security group](#create-security-group).
1. [Create a virtual machine to host your file server](#create-vm).
1. [Set up Samba and NFS](#setup-samba-nfs).
1. [Test your file server](#test-file-server).

If you no longer need the resources you created, [delete them](#clear-out).

## Getting started {#before-you-begin}

Sign up for Yandex Cloud and create a [billing account](../../../billing/concepts/billing-account.md):
1. Navigate to the [management console](https://console.yandex.cloud) and log in to Yandex Cloud or create a new account.
1. On the **[Yandex Cloud Billing](https://center.yandex.cloud/billing/accounts)** page, make sure you have a billing account linked and it has the `ACTIVE` or `TRIAL_ACTIVE` [status](../../../billing/concepts/billing-account-statuses.md). If you do not have a billing account, [create one](../../../billing/quickstart/index.md) and [link](../../../billing/operations/pin-cloud.md) a cloud to it.

If you have an active billing account, you can create or select a [folder](../../../resource-manager/concepts/resources-hierarchy.md#folder) for your infrastructure on the [cloud page](https://console.yandex.cloud/cloud).

[Learn more about clouds and folders here](../../../resource-manager/concepts/resources-hierarchy.md).

### Required paid resources {#paid-resources}

The cost for hosting a single node file server includes:
* Fee for a continuously running [VM](../../concepts/vm.md) (see [Yandex Compute Cloud pricing](../../pricing.md)).
* Fee for a dynamic or static [public IP address](../../../vpc/concepts/address.md#public-adresses) (see [Yandex Virtual Private Cloud pricing](../../../vpc/pricing.md)).
* Fee for outgoing traffic (see [Yandex Virtual Private Cloud pricing](../../../vpc/pricing.md#prices-traffic)).

### Prepare your network infrastructure {#deploy-infrastructure}

1. Navigate to the Yandex Cloud [management console](https://console.yandex.cloud) and select a folder for your network infrastructure.
1. Make sure the selected folder contains a network with a subnet you can connect your VM to. On the folder page, click **Virtual Private Cloud**. You will see the list of available networks. If the list contains at least one network, click it to see its subnets. If you cannot see any networks or subnets [create them](../../../vpc/quickstart.md) as required.

## Create a security group {#create-security-group}

To create a [security group](../../../vpc/concepts/security-groups.md) for your file server:

{% list tabs group=instructions %}

- Management console {#console}

  1. In the [management console](https://console.yandex.cloud), select the folder you want to create your security group in.
  1. Navigate to **Virtual Private Cloud**.
  1. Open the **Security groups** tab.
  1. Create a security group:

     1. Click **Create security group**.
     1. In the **Name** field, specify the security group name: `fileserver-sg`.
     1. In the **Network** field, select the network hosting the `fileserver-tutorial` VM.
     1. Under **Rules**, create the following rules using the instructions below the table:

        | Traffic<br/>direction | Description | Port range | Protocol | Destination name /<br/>Source | CIDR blocks |
        | --- | --- | --- | --- | --- | --- |
        | Outbound | `any` | `All` | `Any` | `CIDR` | `0.0.0.0/0` |
        | Inbound | `ssh` | `22` | `TCP` | `CIDR` | `0.0.0.0/0` |
        | Inbound | `ext-http` | `80` | `TCP` | `CIDR` | `0.0.0.0/0` |
        | Inbound | `ext-https` | `443` | `TCP` | `CIDR` | `0.0.0.0/0` |
        | Inbound | `nfs` | `2049` | `TCP` | `CIDR` | `0.0.0.0/0` |

        1. Select the **Egress** or **Ingress** tab.
        1. Click **Add**.
        1. In the **Port range** field of the window that opens, specify a single port or a port range for traffic to come to or from. To open all ports, click **Select entire range**.
        1. In the **Protocol** field, specify the required protocol or leave **Any** to allow traffic over any protocol.
        1. In the **Destination name** or **Source** field, select `CIDR` for the rule to apply to a range of IP addresses. In the **CIDR blocks** field, specify `0.0.0.0/0`.
        1. Click **Save**. Repeat these steps to create all rules from the table.

     1. Click **Save**.

{% endlist %}

## Create a virtual machine to host your file server {#create-vm}

To create a VM:

{% list tabs group=instructions %}

- Management console {#console}

  1. In the [management console](https://console.yandex.cloud), select the [folder](../../../resource-manager/concepts/resources-hierarchy.md#folder) where you want to create your VM.
  1. Navigate to **Compute Cloud**.
  1. In the left-hand panel, select ![image](../../../_assets/console-icons/server.svg) **Virtual machines**.
  1. Click **Create virtual machine**.
  1. Under **Boot disk image**, select the [Ubuntu](https://yandex.cloud/en/marketplace?tab=software&search=Ubuntu&categories=os) public image.
  1. Under **Location**, select an [availability zone](../../../overview/concepts/geo-scope.md) for your VM.
  1. Add a secondary [disk](../../concepts/disk.md) for data storage:

      * Under **Disks and file storages**, click **Add**.
      * In the window that opens, select **Disk**.
      * Select `Create new disk` and specify the parameters:

          * **Contents**: `Empty`.
          * **Name**: `fileserver-tutorial-disk`.
          * **Type**: `SSD`.
          * **Size**: `100 GB`.

      * Click **Add disk**.

  1. Under **Computing resources**, navigate to the **Custom** tab, select the [platform](../../concepts/vm-platforms.md) and specify the file server parameters:

      * **vCPU**: `8` or more.
      * **Guaranteed vCPU performance**: `100%`.
      * **RAM**: `56 GB` or more.

  1. Under **Network settings**:

      * In the **Subnet** field, enter the ID of a subnet in the new VM’s availability zone. Alternatively, select a [cloud network](../../../vpc/concepts/network.md#network) from the list.

          * Each network must have at least one [subnet](../../../vpc/concepts/network.md#subnet). If there is no subnet, create one by selecting **Create subnet**.
          * If there are no networks in the list, click **Create network** to create one:

              * In the window that opens, specify the network name and select the folder where it will be created.
              * Optionally, enable the **Create subnets** setting to automatically create subnets in all availability zones.
              * Click **Create network**.

      * In the **Public IP address** field, select `Auto` to assign the VM a random external IP address from the Yandex Cloud pool. If you reserved a static IP address, you can select it from the list.
      * In the **Security groups** field, select the `fileserver-sg` security group you created earlier.

  1. Under **Access**, select **SSH key** and specify the VM access credentials:

      * In the **Login** field, enter a name for the user you want to create on the VM, e.g., `ubuntu`.

        {% note alert %}

        Do not use `root` or other OS-reserved usernames. For operations requiring root privileges, use the `sudo` command.

        {% endnote %}

      * In the **SSH key** field, select the SSH key saved in your [organization user](../../../organization/concepts/membership.md) profile.
        
        If there are no SSH keys in your profile or you want to add a new key:
        
        1. Click **Add key**.
        1. Enter a name for the SSH key.
        1. Select one of the following:
        
            * `Enter manually`: Paste the contents of the public SSH key. You need to [create](../../operations/vm-connect/ssh.md#creating-ssh-keys) an SSH key pair on your own.
            * `Load from file`: Upload the public part of the SSH key. You need to create an SSH key pair on your own.
            * `Generate key`: Automatically create an SSH key pair.
            
              When adding a new SSH key, an archive containing the key pair will be created and downloaded. In Linux or macOS-based operating systems, unpack the archive to the `/home/<user_name>/.ssh` directory. In Windows, unpack the archive to the `C:\Users\<user_name>/.ssh` directory. You do not need additionally enter the public key in the management console.
        
        1. Click **Add**.
        
        The system will add the SSH key to your organization user profile. If the organization has [disabled](../../../organization/operations/os-login-access.md) the ability for users to add SSH keys to their profiles, the added public SSH key will only be saved in the user profile inside the newly created resource.

  1. Under **General information**, specify the VM name: `fileserver-tutorial`.
  1. Click **Create VM**.

{% endlist %}

It may take a few minutes to create the VM. When the VM status switches to `RUNNING`, copy the public IP address from the **Network** section on the VM page. You will need it later to [configure NFS and Samba](#setup-samba-nfs).

## Set up Samba and NFS {#setup-samba-nfs}

After the `fileserver-tutorial` VM enters the `RUNNING` status, run:

1. On the VM page of the [management console](https://console.yandex.cloud), under **Network**, find the VM's public IP address.

1. [Connect](../../operations/vm-connect/ssh.md) to the VM over SSH.

   We recommend using a key pair when authenticating over SSH. Make sure to set up the created key pair so that the private key matches the public key sent to the VM.

1. Configure Samba and NFS:

   {% list tabs group=operating_system %}

   - Ubuntu {#ubuntu}

     1. Download and install Samba:

        ```bash
        sudo apt-get update
        sudo apt-get install nfs-kernel-server samba
        ```

     1. Prepare and mount the file system on the disk:

        ```bash
        sudo mkfs -t ext4 -L data /dev/vdb
        ```

     1. Prepare and mount a folder named `my_folder` for data storage on the disk:

        ```bash
        sudo mkdir /my_folder
        echo "LABEL=data /my_folder ext4 defaults 0 0" | sudo tee -a /etc/fstab
        sudo mount /my_folder
        ```

     1. Set the NFS configuration in the `/etc/exports` file. You can edit the file using `nano`:

        ```bash
        sudo nano /etc/exports
        ```

        Add the following lines to the file:

        ```bash
        /my_folder <IP_address>(rw,no_subtree_check,fsid=100)
        /my_folder 127.0.0.1(rw,no_subtree_check,fsid=100)
        ```

        Where `<IP_address>` is the IP address of the computer you are going to connect the network data disk to via NFS.

     1. Set the Samba configuration in the `/etc/samba/smb.conf` file. You can edit the file using `nano`:

        ```bash
        sudo nano /etc/samba/smb.conf
        ```

        Edit the file as follows:

        ```bash
        [global]
           workgroup = WORKGROUP
           server string = %h server (Samba)
           dns proxy = no
           log file = /var/log/samba/log.%m
           max log size = 1000
           syslog = 0
           panic action = /usr/share/samba/panic-action %d
           server role = standalone server
           passdb backend = tdbsam
           obey pam restrictions = yes
           unix password sync = yes
           passwd program = /usr/bin/passwd %u
           passwd chat = *Enter\snew\s*\spassword:* %n\n *Retype\snew\s*\spassword:* %n\n *password\supdated\ssuccessfully* .
           pam password change = yes
           map to guest = bad user
           usershare allow guests = yes
        [printers]
           comment = All Printers
           browseable = no
           path = /var/spool/samba
           printable = yes
           guest ok = no
           read only = yes
           create mask = 0700
        [print$]
           comment = Printer Drivers
           path = /var/lib/samba/printers
           browseable = yes
           read only = yes
           guest ok = no
        [data]
           comment = /my_folder
           path = /my_folder
           browseable = yes
           read only = no
           writable = yes
           guest ok = yes
           hosts allow = <IP_address> 127.0.0.1
           hosts deny = 0.0.0.0/0
        ```

        Where `<IP_address>` in the `[data]` section is the IP address of the computer you are going to connect the network data disk to via NFS.

     1. Restart Samba and NFS:

        ```bash
        sudo service nfs-kernel-server restart
        sudo service smbd restart
        ```

   {% endlist %}

## Test your file server {#test-file-server}

1. Install ACL on the `fileserver-tutorial` VM and create a directory named `remote` and a file named `test.txt`.

   {% list tabs group=operating_system %}

   - Ubuntu {#ubuntu}

     ```bash
     sudo apt-get install acl
     sudo mkdir /my_folder/remote
     sudo setfacl -m u:<your_username>:rwx /my_folder/remote
     echo "Hello world!" > /my_folder/remote/test.txt
     ```

   {% endlist %}

1. Connect the network disk to your computer via NFS and check if the test file is available:

   {% list tabs group=operating_system %}

   - Linux/macOS {#linux-macos}

     If needed, install the network disk utility:

     ```bash
     sudo apt-get install nfs-common
     ```

     Create a mount point:

     ```bash
     sudo mkdir /remote-test-dir
     ```

     Attach a network disk:

     ```bash
     sudo mount -t nfs <VM_public_IP_address>:/my_folder /remote-test-dir
     ```

     As as result, the test directory and the file should become available at the mount point.

   - Windows {#windows}

     {% note info %}

     You may need to configure Windows security policies for access to the file server.

     {% endnote %}

     1. Run the **cmd.exe** utility. To do this, use the **Windows** + **R** keyboard shortcut and run the `cmd` command.
     1. From the command line, run:

        ```bash
        net use x: \\<VM_public_IP_address>\data
        ```

     This will create a disk **X** with the test directory and file.

   {% endlist %}

## How to delete the resources you created {#clear-out}

To stop paying for the resources you created:

1. [Delete the VM](../../operations/vm-control/vm-delete.md).
1. [Delete the static public IP address](../../../vpc/operations/address-delete.md) if you reserved one.

#### Useful links {#see-also}

* [Creating a single-node file server using Terraform](terraform.md).