Գնահատել նախագիծը
← Բոլոր հրապարակումները

Infrastructure as code (IaC) – ինչ է այն և ինչու պետք է դա ինձ հետաքրքրի

IaC տերմինը գոյություն ունի վաղուց և այլևս առանձնապես թրենդ չէ։ Իմացեք, թե ինչու է այն շարունակում մնալ գրավիչ թեմա և ինչու է արժանի ձեր ուշադրությանը։

9 րոպե
Infrastructure as codeDevOpsTerraformԱմպIaC

Ներածություն

Համոզված եմ, որ այս տերմինը այնքան երկար է օգտագործվում, որ ինչ-որ տեղ ճանապարհին կորցրել է իր իմաստը։ Ոչ այնքան վաղուց այն buzzword էր, այսօր՝ ոչ։ Թեև այն դուրս է գալիս նորաձևությունից, ես կփորձեմ առավելագույնս լուսաբանել թեման, քանի որ այն նույնքան կարևոր է, որքան միշտ։

Սկսենք հենց սկզբից։ Պատկերացրեք, որ ղեկավարում եք ձեր առաջին լուրջ նախագիծը ամպում։ Շաբաթներ շարունակ այն կայուն է և հիանալի է աշխատում։ Հետո ինչ-որ պահի նկատում եք, որ ձեր հավելվածի տրաֆիկը շատ կարճ ժամանակում թռիչք է կատարել։ Հանկարծ թվում է՝ ավելի շատ մարդիկ են փորձում օգտվել դրանից։ Ի՞նչ եք անում։ Բնականաբար, բացում եք AWS console-ը և ձեր load balancer-ին ավելացնում ևս մեկ վիրտուալ մեքենա։ Եվ սա շարունակվում է, քանի որ ձեր հավելվածը հիթ է, և աշխարհի տարբեր ծայրերի մարդիկ դրա մասին խոսում են։

Ի վերջո հասկանում եք, որ սա ամենևին արդյունավետ չէ, քանի որ ենթակառուցվածքը UI-ով կառավարելու վրա շատ ժամանակ եք ծախսում՝ սեղմելով տարբեր կոճակներ և անցնելով էջից էջ։ Որպես մշակող՝ ցանկանում եք, որ ենթակառուցվածքը կառուցեիք այնպես, ինչպես կառուցում եք ծրագրեր։ Կարող եք, օրինակ, գրել VM-ի նկարագրություն և նշել դրա հատկությունները՝ պրոցեսորի տեսակը, հիշողության ծավալը, սկավառակի տեսակն ու տարողությունը և այլն։ Մի խոսքով՝ կուզենայիք կարողանալ ենթակառուցվածքը տեղակայել դեկլարատիվ կերպով։

Պարզվում է՝ ուրիշներն արդեն ունեցել են այդ գաղափարը։ Բայց գուցե հարցնեք…

Ինչու՞ խոչընդոտել

Իմ կարծիքով, ամենամեծ օգուտը հետևողականությունն է։ Երբ ենթակառուցվածքը նկարագրվել է, այն պետք է մնա անփոփոխ։ Ցանկացած առաջացած շեղում (շնորհակալություն, էնտրոպիա) վերադարձվում է բավական պարզ տեքստային ֆայլում պահվող սպեցիֆիկացիային։ Իրականում տարբերություն չկա, թե ինչ է պատահում՝ օգտատիրոջ կողմից գործարկված իրադարձության, ինչ-որ խափանման, թե թիմակցի սխալի պատճառով. IaC-ի դեպքում վերականգնումը պետք է հեշտ լինի։ Կարող եք այն պատկերացնել որպես թեթև snapshot, որին կարող եք հետ գալ։ GitOps-ի դեպքում այն էլ ավելի հեշտ է դառնում։

Լավ գրված կոդը բերում է ևս մեկ օգուտ՝ կրկնակի օգտագործելիություն։ Կոդով նկարագրված ցանկացած բան կարելի է հետագայում նորից օգտագործել։ Պե՞տք է ևս մեկ միջավայր։ Կամ գուցե հենց նոր ստեղծածի պատճենը։ Հեշտ է։ Նախապես պլանավորելու դեպքում կարող եք կոնտեյներների կլաստերների, տվյալների բազաների, քեշերի և image registry-ների տեղակայման կոդը գրել որպես մոդուլներ։ Հաջորդ անգամ, երբ կոդից միջավայր կառուցեք, պարզապես հղվում եք այդ մոդուլներին և տալիս անհրաժեշտ պարամետրերը։ Վստահեք ինձ, սա շատ ժամանակ կխնայի։

Ինչպե՞ս ընտրել գործիք

Ենթակառուցվածքը որպես կոդ իրականացնող գործիքների լայն շրջանակ կա։ Ես շատ մանրամասնությունների մեջ չեմ մտնի, քանի որ դա այս հոդվածի շրջանակներից դուրս է։ Այսօր հիմնական տարբերությունները կայանում են գործիքի օգտագործած ձևանմուշավորման մեջ (օրինակ՝ Jinja Ansible-ում, Embedded Ruby Puppet-ում և Chef-ում, HCL Terraform-ում), կոնֆիգուրացիայի կիրառման եղանակում (կոնֆիգը քաշվում է կառավարող սերվերից, ինչպես Chef-ում, կամ հրվում է կառավարվող ենթակառուցվածք, ինչպես Ansible-ում և Terraform-ում) և լեզվում, որով գրված է հենց գործիքը։ Տարբերություններ սպասեք նաև գաղտնիքների և state ֆայլերի մշակման ու իրենց կառավարած ռեսուրսները խմբավորելու եղանակներում։

Արժե նշել, որ այդ գործիքներից որոշները կոնֆիգուրացիայի կառավարման մեջ ավելի լավն են, քան ենթակառուցվածքի պրովիժնինգում, և հակառակը։ Այլ կերպ ասած՝ ոչ բոլոր գործիքներն են նույնքան լավ անհրաժեշտ ռեսուրսներ ստեղծելիս, որքան դրանք կոնֆիգուրացնելիս։ Անձամբ ես կարծում եմ, որ Terraform-ը ավելի լավ է գլուխ հանում ենթակառուցվածքի պրովիժնինգից (հատկապես ամպում), իսկ Ansible-ը՝ վիրտուալ մեքենաների կոնֆիգուրացիայից։

Այս օրերին վերը թվարկված գործիքների մեծ մասն աջակցում է բոլոր տեսակի միջավայրերը՝ ներառյալ bare metal սերվերները և հանրային ամպի ռեսուրսները։ Պետք է նշել, որ դրանցից որոշները կառուցվել են կոնկրետ ֆունկցիոնալություն նկատի ունենալով և ժամանակի ընթացքում ընդլայնվել են այլ բաներ աջակցելու համար. Chef-ի AWS աջակցությունը դրա օրինակներից մեկն է։ Առանձին դեպք են այն գործիքները, որոնք առաջացել են հանրային ամպի առաջարկից։ CloudFormation-ը (AWS), AWS CDK-ն (AWS, ակնհայտորեն) և Bicep-ը (Azure) չեն կարող ընդլայնվել որևէ այլ տեղ օգտագործելու համար։

Այդուհանդերձ, եթե լիովին վստահ եք, որ երբեք չեք լքի ձեր ընթացիկ ամպը, դրանք արժե դիտարկել։ Հանրային ամպի թիմը դրանք ամենաարագն է թարմացնում, երբ ամպի API-ն փոխվում է, այնպես որ չեք ստիպված լինի սպասել, մինչև համայնքը թարմացում թողարկի։

Ասվածից հետո կասեմ, որ Terraform-ը, իմ կարծիքով, անվտանգ ընտրություն է՝ անկախ ձեր ամպային պլաններից։ Stack Overflow-ի տարեկան հարցման մեջ Terraform-ը IaC գործիքն էր, որին հարցվողներն ամենից հաճախ են նշել, և այն, անշուշտ, առողջ տարբերակ է, եթե մտադիր եք ենթակառուցվածքը տեղակայել հանրաճանաչ ամպում, ինչպիսին AWS-ը կամ Azure-ն են։ GCP-ում տեղակայումների համար Terraform-ը իրականում այն գործիքն է, որ խորհուրդ է տալիս Google-ը։

Terraform?

Թույլ տվեք մի քանի բառ ասել Terraform-ի մասին և այն մասին, թե ինչու է այն այսօր այդքան տարածված։ Սա ենթակառուցվածքի կառավարման գործիք է, որը դեկլարատիվ մոտեցում է ընդունում և ենթակառուցվածքի սահմանումները գրելու համար օգտագործում է HCL (HashiCorp Configuration Language)։

Դրա ճկունությունը գալիս է արտաքին համակարգերի՝ հանրային ամպերի, API-ների և այլնի հետ շփվող provider-ների լայն ընտրությունից։ Provider-ները գալիս են և՛ պաշտոնական բաշխման հետ, և՛ որպես աշխույժ Terraform համայնքի կառուցած մոդուլներ։ Արդյունքում օգտատերերը կարող են ռեսուրսներ ստեղծել մեկ միասնական շարահյուսությամբ։ Provider-ը թաքցնում է իրականացման մանրամասները, ինչը կոդը պարզ է պահում։ Բնականաբար, փոքր տարբերություններ կան՝ կախված կոնկրետ միջավայրից, բայց ինժեներական արժեքը հսկայական է։

Ավելին, Terraform-ը իր ողջ կոնֆիգուրացիան պահում է state ֆայլում, ինչն ունի մի քանի առավելություն։ Առաջին հերթին այն նվազեցնում է պատահական ջնջման ռիսկը, քանի որ state ֆայլը դիտվում է որպես Terraform-ի կառավարած ողջ ենթակառուցվածքի ճշմարտության աղբյուր։ Իսկ եթե state ֆայլը պահում ենք object storage-ում, կարող ենք այն առանց ջանքի կիսել գործընկերների հետ և ենթակառուցվածքը կառավարել թիմով։

Terraform կոդի նվազագույն հատվածը կարող է այսպիսի տեսք ունենալ.

provider "aws" {
  region = "eu-west-1"
}

resource "aws_instance" "instance" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "DemoInstance"
  }
}

Այստեղ մենք հայտարարում ենք, որ կօգտագործենք aws provider-ը, որը ռեսուրսներ է պրովիժնինգի ենթարկում AWS-ում։ Մեր EC2 instance-ը պետք է տեղակայվի eu-west-1 ռեգիոնում։ Այնուհետև Terraform-ին հրահանգում ենք օգտագործել կոնկրետ AMI (Amazon Machine Image) ID, և ընտրում ենք փոքր t2.micro տիպը, քանի որ սա ընդամենը թեստ է և ոչ մի շքեղ բան պետք չէ։ Վերջում Terraform-ին խնդրում ենք ավելացնել Name tag՝ DemoInstance արժեքով։ Երբ Terraform-ն ունենա մեր AWS credentials-ը, կարող ենք գործարկել terraform init՝ մեզ անհրաժեշտ provider-ը ներբեռնելու համար։ Դրանից հետո պետք է պատրաստ լինենք գործարկել terraform plan-ը։ Ինչ-որ բան ստեղծելուց առաջ Terraform-ը մեզ ցույց կտա, թե ինչ է մտադիր անել։

iac ➤ terraform plan

Terraform-ն օգտագործեց ընտրված provider-ները՝ հետևյալ կատարման պլանը գեներացնելու համար։ Ռեսուրսների գործողությունները նշված են հետևյալ նշաններով.
+ create

Terraform-ը կկատարի հետևյալ գործողությունները.

# aws_instance.instance will be created
+ resource "aws_instance" "instance" {
      + ami                                  = "ami-0c55b159cbfafe1f0"
      + arn                                  = (known after apply)
      + associate_public_ip_address          = (known after apply)
      + availability_zone                    = (known after apply)
      + cpu_core_count                       = (known after apply)
      + cpu_threads_per_core                 = (known after apply)
      + disable_api_stop                     = (known after apply)
      + disable_api_termination              = (known after apply)
      + ebs_optimized                        = (known after apply)
      + get_password_data                    = false
      + host_id                              = (known after apply)
      + host_resource_group_arn              = (known after apply)
      + iam_instance_profile                 = (known after apply)
      + id                                   = (known after apply)
      + instance_initiated_shutdown_behavior = (known after apply)
      + instance_lifecycle                   = (known after apply)
      + instance_state                       = (known after apply)
      + instance_type                        = "t2.micro"
      + ipv6_address_count                   = (known after apply)
      + ipv6_addresses                       = (known after apply)
      + key_name                             = (known after apply)
      + monitoring                           = (known after apply)
      + outpost_arn                          = (known after apply)
      + password_data                        = (known after apply)
      + placement_group                      = (known after apply)
      + placement_partition_number           = (known after apply)
      + primary_network_interface_id         = (known after apply)
      + private_dns                          = (known after apply)
      + private_ip                           = (known after apply)
      + public_dns                           = (known after apply)
      + public_ip                            = (known after apply)
      + secondary_private_ips                = (known after apply)
      + security_groups                      = (known after apply)
      + source_dest_check                    = true
      + spot_instance_request_id             = (known after apply)
      + subnet_id                            = (known after apply)
      + tags                                 = {
          + "Name" = "DemoInstance"
        }
      + tags_all                             = {
          + "Name" = "DemoInstance"
        }
      + tenancy                              = (known after apply)
      + user_data                            = (known after apply)
      + user_data_base64                     = (known after apply)
      + user_data_replace_on_change          = false
      + vpc_security_group_ids               = (known after apply)

      + capacity_reservation_specification {
          + capacity_reservation_preference = (known after apply)

          + capacity_reservation_target {
              + capacity_reservation_id                 = (known after apply)
              + capacity_reservation_resource_group_arn = (known after apply)
            }
        }

      + cpu_options {
          + amd_sev_snp      = (known after apply)
          + core_count       = (known after apply)
          + threads_per_core = (known after apply)
        }

      + ebs_block_device {
          + delete_on_termination = (known after apply)
          + device_name           = (known after apply)
          + encrypted             = (known after apply)
          + iops                  = (known after apply)
          + kms_key_id            = (known after apply)
          + snapshot_id           = (known after apply)
          + tags                  = (known after apply)
          + throughput            = (known after apply)
          + volume_id             = (known after apply)
          + volume_size           = (known after apply)
          + volume_type           = (known after apply)
        }

      + enclave_options {
          + enabled = (known after apply)
        }

      + ephemeral_block_device {
          + device_name  = (known after apply)
          + no_device    = (known after apply)
          + virtual_name = (known after apply)
        }

      + instance_market_options {
          + market_type = (known after apply)

          + spot_options {
              + instance_interruption_behavior = (known after apply)
              + max_price                      = (known after apply)
              + spot_instance_type             = (known after apply)
              + valid_until                    = (known after apply)
            }
        }

      + maintenance_options {
          + auto_recovery = (known after apply)
        }

      + metadata_options {
          + http_endpoint               = (known after apply)
          + http_protocol_ipv6          = (known after apply)
          + http_put_response_hop_limit = (known after apply)
          + http_tokens                 = (known after apply)
          + instance_metadata_tags      = (known after apply)
        }

      + network_interface {
          + delete_on_termination = (known after apply)
          + device_index          = (known after apply)
          + network_card_index    = (known after apply)
          + network_interface_id  = (known after apply)
        }

      + private_dns_name_options {
          + enable_resource_name_dns_a_record    = (known after apply)
          + enable_resource_name_dns_aaaa_record = (known after apply)
          + hostname_type                        = (known after apply)
        }

      + root_block_device {
          + delete_on_termination = (known after apply)
          + device_name           = (known after apply)
          + encrypted             = (known after apply)
          + iops                  = (known after apply)
          + kms_key_id            = (known after apply)
          + tags                  = (known after apply)
          + throughput            = (known after apply)
          + volume_id             = (known after apply)
          + volume_size           = (known after apply)
          + volume_type           = (known after apply)
        }
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Ակնհայտ է, որ Terraform-ը ավտոմատ կերպով լրացնում է դաշտերի մեծ մասը, երբ գործարկում ենք terraform apply։ Մաքրելու համար կարող ենք գործարկել terraform destroy, որը հեռացնում է միայն state ֆայլում գրանցված ռեսուրսները։

Մի հետաձգեք, ներդրեք IaC այսօր

Ցանկացած պահ լավ պահ է ենթակառուցվածքը որպես կոդ ձեր թիմ ներմուծելու համար։ Մշակումը դրանով սկսելը առաջին օրվանից, անշուշտ, ավելի հեշտ է, բայց որքան շուտ ընդունեք այն, այնքան լավ։ Մեր ընկերությունում IaC-ը ստանդարտ պրակտիկա է, որը թույլ է տալիս արդյունավետ աշխատել։