Assigning a domain name to a VM with a web server

In this tutorial, you will assign your own domain name to a VM with a web server. You can use any domain name registrar to register your domain name.

To create a VM, this tutorial uses a public LAMP image with a pre-installed Apache HTTP server. Using a public LEMP image with an NGINX web server is also possible.

To assign a domain name to a VM with a web server in Cloud DNS:

1. Prepare your cloud.
2. Create a VM with a web server.
3. Create a public DNS zone.
4. Delegate your domain to Cloud DNS.
5. Create a type A resource record.
6. Test the website.

If you no longer need the resources you created, delete them.

You can also assign a domain name to a VM with a web server via Terraform using a ready-made configuration file.

Prepare your cloudPrepare your cloud

Sign up for Yandex Cloud and create a billing account:

1. Go to the management console and log in to Yandex Cloud or create an account if you do not have one yet.
2. On the Yandex Cloud Billing page, make sure you have a billing account linked and it has the ACTIVE or TRIAL_ACTIVE status. If you do not have a billing account, create one.

If you have an active billing account, you can go to the cloud page to create or select a folder for your infrastructure to operate in.

Learn more about clouds and folders.

Required paid resourcesRequired paid resources

The support cost includes:

• Fee for using a public IP address (see Yandex Virtual Private Cloud pricing).
• Fee for VM computing resources and disks (see Yandex Compute Cloud pricing).
• Fee for using a public DNS zone and public DNS requests (see Yandex Cloud DNS pricing).

Create a cloud network and subnetCreate a cloud network and subnet

Create a security groupCreate a security group

Create a security group that allows inbound TCP traffic on ports 22, 80, and 443 as well as any outbound traffic.

yc vpc security-group create \
  --name webserver-sg \
  --rule "description=http,direction=ingress,port=80,protocol=tcp,v4-cidrs=[0.0.0.0/0]" \
  --rule "description=https,direction=ingress,port=443,protocol=tcp,v4-cidrs=[0.0.0.0/0]" \
  --rule "description=ssh,direction=ingress,port=22,protocol=tcp,v4-cidrs=[0.0.0.0/0]" \
  --rule "description=any,direction=egress,port=any,protocol=any,v4-cidrs=[0.0.0.0/0]" \
  --network-name webserver-network

id: enp4htsnl1sa********
folder_id: b1gt6g8ht345********
created_at: "2023-12-23T19:07:03Z"
name: webserver-sg
network_id: enp37qpnksl2********
status: ACTIVE
rules:
  - id: enpdu0t8san9********
    description: http
    direction: INGRESS
    ports:
      from_port: "80"
      to_port: "80"
    protocol_name: TCP
    protocol_number: "6"
    cidr_blocks:
      v4_cidr_blocks:
        - 0.0.0.0/0
  - id: enpr7oirpff5********
    description: https
    direction: INGRESS
    ports:
      from_port: "443"
      to_port: "443"
    protocol_name: TCP
    protocol_number: "6"
    cidr_blocks:
      v4_cidr_blocks:
        - 0.0.0.0/0
  - id: enp0bgk6dkdd********
    description: ssh
    direction: INGRESS
    ports:
      from_port: "22"
      to_port: "22"
    protocol_name: TCP
    protocol_number: "6"
    cidr_blocks:
      v4_cidr_blocks:
        - 0.0.0.0/0
  - id: enpspns0tfml********
    description: any
    direction: EGRESS
    protocol_name: ANY
    protocol_number: "-1"
    cidr_blocks:
      v4_cidr_blocks:
        - 0.0.0.0/0

Create a VM with a web serverCreate a VM with a web server

Before you start, prepare a key pair (public and private keys) to access your VM over SSH.

yc compute instance create \
  --name mywebserver \
  --zone ru-central1-b \
  --network-interface subnet-name=webserver-subnet-ru-central1-b,nat-ip-version=ipv4,security-group-ids=<security_group_ID> \
  --create-boot-disk image-folder-id=standard-images,image-id=fd8jtn9i7e9ha5q25niu \
  --ssh-key <SSH_key>

done (32s)
id: fhmaq4shfrcm********
folder_id: b1gt6g8ht345********
created_at: "2023-12-23T05:36:34Z"
name: mywebserver
zone_id: ru-central1-b
platform_id: standard-v2
resources:
  memory: "2147483648"
  cores: "2"
  core_fraction: "100"
status: RUNNING
metadata_options:
  gce_http_endpoint: ENABLED
  aws_v1_http_endpoint: ENABLED
  gce_http_token: ENABLED
  aws_v1_http_token: DISABLED
boot_disk:
  mode: READ_WRITE
  device_name: fhmprher1d0q********
  auto_delete: true
  disk_id: fhmprher1d0q********
network_interfaces:
  - index: "0"
    mac_address: d0:0d:ad:13:91:7e
    subnet_id: e9bk1m87r4m4********
    primary_v4_address:
      address: 192.168.1.11
      one_to_one_nat:
        address: 158.160.***.***
        ip_version: IPV4
    security_group_ids:
      - enpa5j0mrgm4********
gpu_settings: {}
fqdn: fhmaq4shfrcm********.auto.internal
scheduling_policy: {}
network_settings:
  type: STANDARD
placement_policy: {}

This will create the mywebserver VM in your folder. To connect to the VM over SSH, use the yc-user username and the VM’s public IP address. If you plan to use the created web server over a long period of time, make this VM's public IP address static.

Create a public DNS zoneCreate a public DNS zone

yc dns zone create \
  --name <zone_name> \
  --zone <domain_zone> \
  --public-visibility

id: dns39gihj0ef********
folder_id: b1gt6g8ht345********
created_at: "2023-12-21T16:43:37.883Z"
name: my-domain-zone
zone: example.com.
public_visibility: {}

Delegate your domain to Cloud DNSDelegate your domain to Cloud DNS

To delegate a domain to Cloud DNS, in your account on your domain registrar's website, specify the DNS server addresses in the domain settings:

• ns1.yandexcloud.net
• ns2.yandexcloud.net

Delegation does not take effect immediately. It usually takes up to 24 hours (86,400 seconds) for internet service providers to update records. This depends on the TTL value which specifies how long domain records are cached.

You can check the domain delegation using Whois or the dig utility:

dig +short NS example.com

Result:

ns2.yandexcloud.net.
ns1.yandexcloud.net.

Create a type A resource recordCreate a type A resource record

In your DNS zone, create a type A resource record that points to the web server's public IP address:

yc dns zone add-records \
  --name <zone_name> \
  --record "<domain_name> 600 A <VM_IP_address>"

+--------+--------------+------+---------------+-----+
| ACTION |     NAME     | TYPE |     DATA      | TTL |
+--------+--------------+------+---------------+-----+
| +      | example.com. | A    | 51.250.**.*** | 600 |
+--------+--------------+------+---------------+-----+

Test the websiteTest the website

The website on your web server is now accessible by its domain name. To test the site, enter its IP address or domain name in your browser:

• http://<VM_public_IP_address>
• http://example.com

How to delete the resources you createdHow to delete the resources you created

Some resources are not free of charge. To avoid paying for them, delete the resources you no longer need:

1. In Compute Cloud, delete the VM you created.
2. In Cloud DNS, delete the domain zone you created.
3. In Virtual Private Cloud, delete the security group first, then delete the subnet; finally, delete the network.

How to create an infrastructure using TerraformHow to create an infrastructure using Terraform

Terraform allows you to quickly create a cloud infrastructure in Yandex Cloud and manage it using configuration files. Configuration files store the infrastructure description in the HashiCorp Configuration Language (HCL). Terraform and its providers are distributed under the Business Source License.

For more information about the provider resources, see the documentation on the Terraform website or the mirror.

If you change the configuration files, Terraform automatically detects which part of your configuration is already deployed, and what should be added or removed.

To create an infrastructure for assigning a domain name to a VM with a web server in Cloud DNS using Terraform:

1. Install Terraform, get the authentication credentials, and specify the source for installing the Yandex Cloud provider (see Configure a provider, step 1).

2. Prepare a file with the infrastructure description:

   Ready-made archive

   Creating files manually

   1. Create a folder for the file with the infrastructure description.
   2. Download the archive (2 KB).
   3. Unpack the archive to the directory. As a result, it should contain the bind-domain-to-vm.tf configuration file and the bind-domain-to-vm.auto.tfvars user data file.

   1. Create a folder for the file with the infrastructure description.

   2. In the directory, create a configuration file named bind-domain-to-vm.tf:

      bind-domain-to-vm.tf

      # Declaring variables for custom parameters
      
      variable "folder_id" {
        type = string
      }
      
      variable "domain_name" {
        type = string
      }
      
      variable "ssh_key_path" {
        type = string
      }
      
      # Adding other variables
      
      locals {
        network_name     = "webserver-network"
        subnet_name      = "webserver-subnet-ru-central1-b"
        sg_name          = "webserver-sg"
        vm_name          = "mywebserver"
        domain_zone_name = "my-domain-zone"
      }
      
      # Setting the provider
      
      terraform {
        required_providers {
          yandex = {
            source  = "yandex-cloud/yandex"
            version = ">= 0.47.0"
          }
        }
      }
      
      provider "yandex" {
        folder_id = var.folder_id
      }
      
      # Creating a cloud network
      
      resource "yandex_vpc_network" "webserver-network" {
        name = local.network_name
      }
      
      # Creating a subnet
      
      resource "yandex_vpc_subnet" "webserver-subnet-b" {
        name           = local.subnet_name
        zone           = "ru-central1-b"
        network_id     = "${yandex_vpc_network.webserver-network.id}"
        v4_cidr_blocks = ["192.168.1.0/24"]
      }
      
      # Creating a security group
      
      resource "yandex_vpc_security_group" "webserver-sg" {
        name        = local.sg_name
        network_id  = "${yandex_vpc_network.webserver-network.id}"
        ingress {
          protocol       = "TCP"
          description    = "http"
          v4_cidr_blocks = ["0.0.0.0/0"]
          port           = 80
        }
      
        ingress {
          protocol       = "TCP"
          description    = "https"
          v4_cidr_blocks = ["0.0.0.0/0"]
          port           = 443
        }
      
        ingress {
          protocol       = "TCP"
          description    = "ssh"
          v4_cidr_blocks = ["0.0.0.0/0"]
          port           = 22
        }
      
        egress {
          protocol       = "ANY"
          description    = "any"
          v4_cidr_blocks = ["0.0.0.0/0"]
          from_port      = 0
          to_port        = 65535
        }
      }
      
      # Creating a VM instance
      
      resource "yandex_compute_instance" "mywebserver" {
        name        = local.vm_name
        platform_id = "standard-v2"
        zone        = "ru-central1-b"
      
        resources {
          cores  = "2"
          memory = "2"
        }
      
        boot_disk {
          initialize_params {
            image_id = "fd8jtn9i7e9ha5q25niu"
          }
        }
      
        network_interface {
          subnet_id          = "${yandex_vpc_subnet.webserver-subnet-b.id}"
          nat                = true
          security_group_ids = ["${yandex_vpc_security_group.webserver-sg.id}"]
        }
      
        metadata = {
          user-data = "#cloud-config\nusers:\n  - name: yc-user\n    groups: sudo\n    shell: /bin/bash\n    sudo: 'ALL=(ALL) NOPASSWD:ALL'\n    ssh-authorized-keys:\n      - ${file("${var.ssh_key_path}")}"
        }
      }
      
      # Creating a DNS zone
      
      resource "yandex_dns_zone" "my-domain-zone" {
        name    = local.domain_zone_name
        zone    = "${var.domain_name}."
        public  = true
      }
      
      # Creating a type А resource record
      
      resource "yandex_dns_recordset" "rsА1" {
        zone_id = yandex_dns_zone.my-domain-zone.id
        name    = "${yandex_dns_zone.my-domain-zone.zone}"
        type    = "A"
        ttl     = 600
        data    = ["${yandex_compute_instance.mywebserver.network_interface.0.nat_ip_address}"]
      }
      

   3. In the directory, create a user data file named bind-domain-to-vm.auto.tfvars:

      bind-domain-to-vm.auto.tfvars

      folder_id    = "<folder_ID>"
      ssh_key_path = "<path_to_SSH_key>"
      domain_name  = "<domain_name>"
      

   For more information about the parameters of resources used in Terraform, see the provider documentation:

   • yandex_vpc_network
   • yandex_vpc_subnet
   • yandex_vpc_security_group
   • yandex_compute_instance
   • yandex_dns_zone
   • yandex_dns_recordset

3. In the bind-domain-to-vm.auto.tfvars file, set the following user-defined parameters:

   • folder_id: Folder ID.
   • ssh_key_path: Path to the file with a public SSH key to authenticate the user on the VM, e.g., ~/.ssh/id_ed25519.pub. For more information, see Creating an SSH key pair.
   • domain_name: Your domain name, e.g., example.com.

4. Create resources:

   1. In the terminal, change to the folder where you edited the configuration file.

   2. Make sure the configuration file is correct using the command:

      terraform validate
      

      If the configuration is correct, the following message is returned:

      Success! The configuration is valid.
      

   3. Run the command:

      terraform plan
      

      The terminal will display a list of resources with parameters. No changes are made at this step. If the configuration contains errors, Terraform will point them out.

   4. Apply the configuration changes:

      terraform apply
      

   5. Confirm the changes: type yes in the terminal and press Enter.

5. Test secure access to files.

See alsoSee also

• Cloud DNS integration with Compute Cloud