Terraformer - ហេដ្ឋារចនាសម្ព័ន្ធទៅកូដ

ខ្ញុំចង់ប្រាប់អ្នកអំពីឧបករណ៍ CLI ថ្មីដែលខ្ញុំបានសរសេរដើម្បីដោះស្រាយបញ្ហាចាស់។

បញ្ហា

Terraform គឺជាស្តង់ដារជាយូរមកហើយនៅក្នុងសហគមន៍ Devops/Cloud/IT ។ រឿងនេះគឺមានភាពងាយស្រួល និងមានប្រយោជន៍សម្រាប់ការដោះស្រាយជាមួយនឹងហេដ្ឋារចនាសម្ព័ន្ធជាកូដ។ មានភាពរីករាយជាច្រើននៅក្នុង Terraform ក៏ដូចជាសមជាច្រើន កាំបិតមុតស្រួច និងតុងរួច។
ជាមួយ Terraform វាងាយស្រួលណាស់ក្នុងការបង្កើតរបស់ថ្មី ហើយបន្ទាប់មកគ្រប់គ្រង ផ្លាស់ប្តូរ ឬលុបពួកវា។ តើអ្នកដែលមានហេដ្ឋារចនាសម្ព័ន្ធដ៏ធំនៅក្នុងពពក និងមិនត្រូវបានបង្កើតតាមរយៈ Terraform គួរធ្វើអ្វី? ការសរសេរឡើងវិញ និងបង្កើតពពកទាំងមូលឡើងវិញគឺមានតម្លៃថ្លៃ និងគ្មានសុវត្ថិភាព។
ខ្ញុំបានជួបប្រទះបញ្ហានេះនៅ 2 ការងារ ឧទាហរណ៍សាមញ្ញបំផុតគឺនៅពេលដែលអ្នកចង់ឱ្យអ្វីៗទាំងអស់នៅក្នុង Git ក្នុងទម្រង់ជាឯកសារ terraform ប៉ុន្តែអ្នកមាន 250+ ដាក់ធុងហើយវាច្រើនណាស់ក្នុងការសរសេរវានៅក្នុង terraform ដោយដៃ។
មាន issue ចាប់តាំងពីឆ្នាំ 2014 នៅ terrafom ដែលត្រូវបានបិទនៅឆ្នាំ 2016 ដោយសង្ឃឹមថានឹងមានការនាំចូល។

ជាទូទៅអ្វីគ្រប់យ៉ាងគឺដូចនៅក្នុងរូបភាពតែពីស្តាំទៅឆ្វេងប៉ុណ្ណោះ។

ការព្រមាន: អ្នកនិពន្ធមិនរស់នៅក្នុងប្រទេសរុស្ស៊ីសម្រាប់ពាក់កណ្តាលជីវិតរបស់គាត់ហើយសរសេរតិចតួចជាភាសារុស្សី។ ប្រយ័ត្នចំពោះកំហុសអក្ខរាវិរុទ្ធ។

ដំណោះស្រាយ

1. មានដំណោះស្រាយដែលត្រៀមរួចជាស្រេច និងចាស់សម្រាប់ AWS ផ្ទៃរាបស្មើ. នៅពេលដែលខ្ញុំព្យាយាមយក 250+ ធុងរបស់ខ្ញុំឆ្លងកាត់វា ខ្ញុំបានដឹងថាអ្វីគ្រប់យ៉ាងគឺមិនល្អនៅទីនោះ។ AWS យូរមកហើយបានណែនាំជម្រើសថ្មីជាច្រើន ប៉ុន្តែ terraforming មិនដឹងអំពីពួកវាទេ ហើយជាទូទៅវាជា ruby គំរូមើលទៅតូច. បន្ទាប់ពីម៉ោង 2 នៅពេលល្ងាចខ្ញុំបានផ្ញើ ទាញសំណើ ដើម្បីបន្ថែមលក្ខណៈពិសេសបន្ថែមទៀតនៅទីនោះ ហើយដឹងថាដំណោះស្រាយបែបនេះមិនសមរម្យទាល់តែសោះ។
របៀបដែល terraforming ដំណើរការ៖ វាយកទិន្នន័យពី AWS SDK ហើយបង្កើត tf និង tfstate តាមរយៈគំរូមួយ។
មានបញ្ហា 3 នៅទីនេះ៖
1. តែងតែមានការយឺតយ៉ាវក្នុងការធ្វើបច្ចុប្បន្នភាព
2. ឯកសារ tf ពេលខ្លះចេញមកខូច
3. tfstate ត្រូវបានប្រមូលដោយឡែកពី tf ហើយមិនតែងតែបញ្ចូលគ្នាទេ។
ជាទូទៅ វាពិបាកក្នុងការទទួលបានលទ្ធផលដែល 'ផែនការផ្ទៃផែនដី' និយាយថាមិនមានការផ្លាស់ប្តូរទេ។

2. `terraform import` គឺជាពាក្យបញ្ជាដែលភ្ជាប់មកជាមួយនៅក្នុង terraform។ តើ​វា​ដំណើរការ​យ៉ាង​ដូចម្តេច?
អ្នកសរសេរឯកសារ TF ទទេដែលមានឈ្មោះ និងប្រភេទនៃធនធាន បន្ទាប់មកដំណើរការ `terraform import` ហើយឆ្លងកាត់លេខសម្គាល់ធនធាន។ terraform ទាក់ទងអ្នកផ្តល់សេវា ទទួលទិន្នន័យ និងបង្កើតឯកសារ tfstate ។
មានបញ្ហា 3 នៅទីនេះ៖
1. យើងទទួលបានតែឯកសារ tfstate ហើយ tf គឺទទេ អ្នកត្រូវសរសេរវាដោយដៃ ឬបំប្លែងវាពី tfstate
2. អាចធ្វើការជាមួយធនធានមួយក្នុងពេលតែមួយ និងមិនគាំទ្រធនធានទាំងអស់។ ហើយតើខ្ញុំគួរធ្វើអ្វីម្តងទៀតជាមួយ 250+ ធុង?
3. អ្នកត្រូវដឹងពី ID នៃធនធាន - នោះគឺអ្នកត្រូវរុំវានៅក្នុងកូដដែលទទួលបានបញ្ជីធនធាន។
ជាទូទៅ លទ្ធផលគឺផ្នែកខ្លះ និងមិនមានមាត្រដ្ឋានល្អទេ។

ការសម្រេចចិត្តរបស់ខ្ញុំ

តម្រូវការ៖
1. សមត្ថភាពក្នុងការបង្កើតឯកសារ tf និង tfstate សម្រាប់ធនធាន។ ឧទាហរណ៍ ទាញយកធុង/ក្រុមសុវត្ថិភាព/ឧបករណ៍ផ្ទុកតុល្យភាពទាំងអស់ ហើយ 'ផែនការផ្ទៃផែនដី' បានត្រឡប់មកវិញថាមិនមានការផ្លាស់ប្តូរទេ។
2. អ្នកត្រូវការពពក 2 GCP + AWS
3. ដំណោះស្រាយសកលដែលងាយស្រួលធ្វើបច្ចុប្បន្នភាពរាល់ពេល និងមិនខ្ជះខ្ជាយពេលវេលាលើធនធាននីមួយៗសម្រាប់រយៈពេល 3 ថ្ងៃនៃការងារ
4. ធ្វើឱ្យវាក្លាយជាប្រភពបើកចំហ - មនុស្សគ្រប់គ្នាមានបញ្ហាដូចគ្នា។

ភាសា Go គឺជាមូលហេតុដែលខ្ញុំចូលចិត្តវា ហើយវាមានបណ្ណាល័យសម្រាប់បង្កើតឯកសារ HCL ដែលប្រើក្នុង terraform + កូដជាច្រើននៅក្នុង terraform ដែលអាចមានប្រយោជន៍

ផ្លូវ

ការប៉ុនប៉ងដំបូង
ខ្ញុំចាប់ផ្តើមជាមួយកំណែសាមញ្ញ។ ទាក់ទងពពកតាមរយៈ SDK សម្រាប់ធនធានដែលត្រូវការ ហើយបំប្លែងវាទៅជាវាលសម្រាប់ terraform ។ ការប៉ុនប៉ងនេះបានស្លាប់ភ្លាមៗចំពោះក្រុមសន្តិសុខ ដោយសារតែខ្ញុំមិនចូលចិត្តរយៈពេល 1.5 ថ្ងៃដើម្បីបំប្លែងតែក្រុមសន្តិសុខ (ហើយមានធនធានច្រើន)។ ក្នុងរយៈពេលយូរ ហើយបន្ទាប់មក វាលអាចត្រូវបានផ្លាស់ប្តូរ/បន្ថែម

ការប៉ុនប៉ងលើកទីពីរ
ផ្អែកលើគំនិតដែលបានពិពណ៌នា នៅទីនេះ. គ្រាន់តែយកហើយបំប្លែង tfstate ទៅ tf ។ ទិន្នន័យទាំងអស់គឺនៅទីនោះ ហើយវាលគឺដូចគ្នា។ តើធ្វើដូចម្តេចដើម្បីទទួលបាន tfstate ពេញលេញសម្រាប់ធនធានជាច្រើន ?? នេះគឺជាកន្លែងដែលពាក្យបញ្ជា 'terraform refresh' បានមកជួយសង្គ្រោះ។ terraform យកធនធានទាំងអស់នៅក្នុង tfstate ហើយតាម ID ទាញទិន្នន័យនៅលើពួកវា ហើយសរសេរអ្វីគ្រប់យ៉ាងទៅ tfstate ។ នោះគឺបង្កើត tfstate ទទេដែលមានតែឈ្មោះ និងលេខសម្គាល់ ដំណើរការ `terraform refresh` ហើយបន្ទាប់មកយើងទទួលបាន tfstates ពេញលេញ។ ហ៊ឺយ!
ឥឡូវនេះ ចូរយើងធ្វើរូបអាសអាភាសដដែលៗនៃការសរសេរកម្មវិធីបម្លែងសម្រាប់ tfstate ទៅ tf ។ សម្រាប់អ្នកដែលមិនធ្លាប់អាន tfstate វាគឺជា JSON ប៉ុន្តែពិសេស។
នេះគឺជាគុណលក្ខណៈផ្នែកសំខាន់របស់វា។

 "attributes": {
                            "id": "default/backend-logging-load-deployment",
                            "metadata.#": "1",
                            "metadata.0.annotations.%": "0",
                            "metadata.0.generate_name": "",
                            "metadata.0.generation": "24",
                            "metadata.0.labels.%": "1",
                            "metadata.0.labels.app": "backend-logging",
                            "metadata.0.name": "backend-logging-load-deployment",
                            "metadata.0.namespace": "default",
                            "metadata.0.resource_version": "109317427",
                            "metadata.0.self_link": "/apis/apps/v1/namespaces/default/deployments/backend-logging-load-deployment",
                            "metadata.0.uid": "300ecda1-4138-11e9-9d5d-42010a8400b5",
                            "spec.#": "1",
                            "spec.0.min_ready_seconds": "0",
                            "spec.0.paused": "false",
                            "spec.0.progress_deadline_seconds": "600",
                            "spec.0.replicas": "1",
                            "spec.0.revision_history_limit": "10",
                            "spec.0.selector.#": "1",

មាន:
1. លេខសម្គាល់ - ខ្សែអក្សរ
2. ទិន្នន័យមេតា - អារេនៃទំហំ 1 ហើយនៅក្នុងវាជាវត្ថុមួយដែលមានវាលដែលត្រូវបានពិពណ៌នាខាងក្រោម
3. spec - hash of size 1 and key, value in it
និយាយឱ្យខ្លី ទម្រង់សប្បាយ អ្វីគ្រប់យ៉ាងអាចជ្រៅដល់កម្រិតជាច្រើន។

                   "spec.#": "1",
                            "spec.0.min_ready_seconds": "0",
                            "spec.0.paused": "false",
                            "spec.0.progress_deadline_seconds": "600",
                            "spec.0.replicas": "1",
                            "spec.0.revision_history_limit": "10",
                            "spec.0.selector.#": "1",
                            "spec.0.selector.0.match_expressions.#": "0",
                            "spec.0.selector.0.match_labels.%": "1",
                            "spec.0.selector.0.match_labels.app": "backend-logging-load",
                            "spec.0.strategy.#": "0",
                            "spec.0.template.#": "1",
                            "spec.0.template.0.metadata.#": "1",
                            "spec.0.template.0.metadata.0.annotations.%": "0",
                            "spec.0.template.0.metadata.0.generate_name": "",
                            "spec.0.template.0.metadata.0.generation": "0",
                            "spec.0.template.0.metadata.0.labels.%": "1",
                            "spec.0.template.0.metadata.0.labels.app": "backend-logging-load",
                            "spec.0.template.0.metadata.0.name": "",
                            "spec.0.template.0.metadata.0.namespace": "",
                            "spec.0.template.0.metadata.0.resource_version": "",
                            "spec.0.template.0.metadata.0.self_link": "",
                            "spec.0.template.0.metadata.0.uid": "",
                            "spec.0.template.0.spec.#": "1",
                            "spec.0.template.0.spec.0.active_deadline_seconds": "0",
                            "spec.0.template.0.spec.0.container.#": "1",
                            "spec.0.template.0.spec.0.container.0.args.#": "3",

ជាទូទៅ ប្រសិនបើអ្នកណាម្នាក់ចង់បានបញ្ហាសរសេរកម្មវិធីសម្រាប់ការសម្ភាសន៍ គ្រាន់តែសុំឱ្យពួកគេសរសេរ parser សម្រាប់កិច្ចការនេះ :)
បន្ទាប់ពីការព្យាយាមជាច្រើនដើម្បីសរសេរ parser ដោយគ្មានកំហុស ខ្ញុំបានរកឃើញផ្នែករបស់វានៅក្នុងកូដ terraform និងជាផ្នែកសំខាន់បំផុត។ ហើយអ្វីៗហាក់ដូចជាដំណើរការល្អ។

ព្យាយាមបី
អ្នកផ្តល់ terraform គឺជាប្រព័ន្ធគោលពីរដែលមានកូដជាមួយនឹងធនធាន និងតក្កវិជ្ជាទាំងអស់សម្រាប់ធ្វើការជាមួយ cloud API ។ ពពកនីមួយៗមានអ្នកផ្តល់សេវាផ្ទាល់ខ្លួន ហើយ terraform ខ្លួនវាគ្រាន់តែហៅពួកគេតាមរយៈពិធីការ RPC របស់វារវាងដំណើរការពីរ។
ឥឡូវនេះខ្ញុំបានសម្រេចចិត្តទាក់ទងអ្នកផ្តល់ terraform ដោយផ្ទាល់តាមរយៈការហៅ RPC ។ វាប្រែចេញយ៉ាងស្រស់ស្អាត និងធ្វើឱ្យវាអាចផ្លាស់ប្តូរអ្នកផ្តល់សេវា terraform ទៅកាន់អ្នកថ្មីជាងនេះ និងទទួលបានមុខងារថ្មីៗដោយមិនចាំបាច់ផ្លាស់ប្តូរលេខកូដ។ វាក៏បង្ហាញផងដែរថាមិនមែនគ្រប់វាលទាំងអស់នៅក្នុង tfstate គួរតែស្ថិតនៅក្នុង tf នោះទេ ប៉ុន្តែតើអ្នកអាចរកឃើញដោយរបៀបណា? គ្រាន់តែសួរអ្នកផ្តល់សេវារបស់អ្នកអំពីបញ្ហានេះ។ បន្ទាប់មករូបភាពអាសអាភាសដែលកើតឡើងដដែលៗនៃការប្រមូលផ្តុំកន្សោមធម្មតាបានចាប់ផ្តើម ដោយស្វែងរកវាលនៅខាងក្នុង tfstate នៅគ្រប់កម្រិតយ៉ាងស៊ីជម្រៅ។

នៅទីបញ្ចប់ យើងទទួលបានឧបករណ៍ CLI ដ៏មានប្រយោជន៍ដែលមានហេដ្ឋារចនាសម្ព័ន្ធទូទៅសម្រាប់អ្នកផ្តល់សេវា terraform ទាំងអស់ ហើយអ្នកអាចបន្ថែមឧបករណ៍ថ្មីមួយយ៉ាងងាយស្រួល។ ផងដែរ ការបន្ថែមធនធានត្រូវការលេខកូដតិចតួច។ បូក​រួម​ទាំង​ប្រភេទ​នៃ​ការ​ល្អ​ដូច​ជា​ការ​តភ្ជាប់​រវាង​ធនធាន​។ ជាការពិតណាស់ មានបញ្ហាផ្សេងៗគ្នាជាច្រើន ដែលមិនអាចពិពណ៌នាបានទាំងអស់។
ខ្ញុំបានដាក់ឈ្មោះសត្វថា Terrafomer ។

ចុងក្រោយ

ដោយប្រើ Terrafomer យើងបានបង្កើត 500-700 ពាន់បន្ទាត់នៃកូដ tf + tfstate ពីពពកពីរ។ យើង​អាច​យក​វត្ថុ​ដែល​មាន​កេរដំណែល​មក​ហើយ​ចាប់​ផ្ដើម​ប៉ះ​វា​បាន​តែ​តាម​រយៈ​ការ​ប្រើ​ផ្ទៃ​ដី ដូច​ជា​នៅ​ក្នុង​ហេដ្ឋារចនាសម្ព័ន្ធ​ល្អ​បំផុត​ជា​គំនិត​កូដ។ វាគ្រាន់តែជាវេទមន្ត នៅពេលដែលអ្នកយកពពកដ៏ធំមួយ ហើយទទួលវាតាមរយៈក្រុមក្នុងទម្រង់ជាឯកសារបុគ្គលិក terraform។ ហើយបន្ទាប់មក grep/replace/git ជាដើម។

ខ្ញុំ​សិត​វា​ចេញ​ហើយ​ដាក់​តាម​លំដាប់​ដោយ​ទទួល​បាន​ការ​អនុញ្ញាត។ បានចេញផ្សាយនៅលើ GitHub សម្រាប់អ្នករាល់គ្នានៅថ្ងៃព្រហស្បតិ៍ (02.05.19/XNUMX/XNUMX) ។ github.com/GoogleCloudPlatform/terraformer
បានទទួលផ្កាយ 600 រួចហើយ សំណើទាញ 2 សម្រាប់បន្ថែមការគាំទ្រសម្រាប់ openstack និង kubernetes ។ មតិកែលម្អល្អ។ ជាទូទៅគម្រោងនេះមានប្រយោជន៍សម្រាប់មនុស្ស
ខ្ញុំណែនាំអ្នកគ្រប់គ្នាដែលចង់ចាប់ផ្តើមធ្វើការជាមួយ Terraform ហើយកុំសរសេរឡើងវិញនូវអ្វីគ្រប់យ៉ាងសម្រាប់រឿងនេះ។
ខ្ញុំនឹងរីករាយក្នុងការទាញសំណើបញ្ហាផ្កាយ។

ការបង្ហាញ


ប្រភព: www.habr.com