ការដំឡើងម៉ាស៊ីនមេដើម្បីដាក់ពង្រាយកម្មវិធី Rails ដោយប្រើ Ansible

មិនយូរប៉ុន្មានខ្ញុំត្រូវសរសេរសៀវភៅលេង Ansible ជាច្រើនដើម្បីរៀបចំម៉ាស៊ីនមេសម្រាប់ដាក់ពង្រាយកម្មវិធី Rails ។ ហើយគួរឱ្យភ្ញាក់ផ្អើលដែលខ្ញុំមិនបានរកឃើញសៀវភៅណែនាំជំហានដោយជំហានសាមញ្ញ។ ខ្ញុំ​មិន​ចង់​ចម្លង​សៀវភៅ​លេង​របស់​អ្នក​ផ្សេង​ដោយ​មិន​យល់​ពី​អ្វី​ដែល​កំពុង​កើត​ឡើង​នោះ​ទេ ហើយ​នៅ​ទី​បញ្ចប់ ខ្ញុំ​ត្រូវ​អាន​ឯកសារ​ប្រមូល​អ្វីៗ​ទាំង​អស់​ដោយ​ខ្លួន​ឯង។ ប្រហែលជាខ្ញុំអាចជួយនរណាម្នាក់បង្កើនល្បឿនដំណើរការនេះ ដោយមានជំនួយពីអត្ថបទនេះ។

រឿងដំបូងដែលត្រូវយល់គឺថា ansible ផ្តល់ឱ្យអ្នកនូវចំណុចប្រទាក់ងាយស្រួលដើម្បីអនុវត្តបញ្ជីសកម្មភាពដែលបានកំណត់ជាមុននៅលើម៉ាស៊ីនមេពីចម្ងាយតាមរយៈ SSH ។ មិនមានវេទមន្តនៅទីនេះទេ អ្នកមិនអាចដំឡើងកម្មវិធីជំនួយ និងទទួលបានការដាក់ពង្រាយកម្មវិធីរបស់អ្នកដោយគ្មានពេលទំនេរជាមួយ docker ការត្រួតពិនិត្យ និងអត្ថប្រយោជន៍ផ្សេងទៀតចេញពីប្រអប់នោះទេ។ ដើម្បីសរសេរសៀវភៅលេង អ្នកត្រូវតែដឹងពីអ្វីដែលអ្នកចង់ធ្វើ និងរបៀបធ្វើវាឱ្យពិតប្រាកដ។ នោះហើយជាមូលហេតុដែលខ្ញុំមិនពេញចិត្តនឹងសៀវភៅដែលត្រៀមរួចជាស្រេចពី GitHub ឬអត្ថបទដូចជា៖ "ចម្លង ហើយដំណើរការ វានឹងដំណើរការ។"

តើយើងត្រូវការអ្វីខ្លះ?

ដូចដែលខ្ញុំបាននិយាយរួចហើយ ដើម្បីសរសេរសៀវភៅលេង អ្នកត្រូវដឹងពីអ្វីដែលអ្នកចង់ធ្វើ និងរបៀបធ្វើវា។ ចូរយើងសម្រេចចិត្តថាតើយើងត្រូវការអ្វី។ សម្រាប់កម្មវិធី Rails យើងនឹងត្រូវការកញ្ចប់ប្រព័ន្ធជាច្រើន៖ nginx, postgresql (redis, etc)។ លើសពីនេះទៀតយើងត្រូវការកំណែជាក់លាក់នៃ ruby ​​។ វាជាការល្អបំផុតក្នុងការដំឡើងវាតាមរយៈ rbenv (rvm, asdf...)។ ការដំណើរការទាំងអស់នេះក្នុងនាមជាអ្នកប្រើប្រាស់ root គឺតែងតែជាគំនិតអាក្រក់ ដូច្នេះអ្នកត្រូវបង្កើតអ្នកប្រើប្រាស់ដាច់ដោយឡែក និងកំណត់សិទ្ធិរបស់គាត់។ បន្ទាប់ពីនេះ អ្នកត្រូវបញ្ចូលកូដរបស់យើងទៅម៉ាស៊ីនមេ ចម្លងការកំណត់សម្រាប់ nginx, postgres ជាដើម ហើយចាប់ផ្តើមសេវាកម្មទាំងអស់នេះ។

ជាលទ្ធផល លំដាប់នៃសកម្មភាពមានដូចខាងក្រោម៖

1. ចូលជា root
2. ដំឡើងកញ្ចប់ប្រព័ន្ធ
3. បង្កើតអ្នកប្រើប្រាស់ថ្មី កំណត់រចនាសម្ព័ន្ធសិទ្ធិ ssh key
4. កំណត់រចនាសម្ព័ន្ធកញ្ចប់ប្រព័ន្ធ (nginx ជាដើម) ហើយដំណើរការពួកវា
5. យើងបង្កើតអ្នកប្រើប្រាស់នៅក្នុងមូលដ្ឋានទិន្នន័យ (អ្នកអាចបង្កើតមូលដ្ឋានទិន្នន័យភ្លាមៗ)
6. ចូលជាអ្នកប្រើប្រាស់ថ្មី។
7. ដំឡើង rbenv និង ruby
8. ការដំឡើងកញ្ចប់
9. កំពុងផ្ទុកឡើងកូដកម្មវិធី
10. បើកដំណើរការម៉ាស៊ីនមេ Puma

លើសពីនេះទៅទៀត ដំណាក់កាលចុងក្រោយអាចត្រូវបានធ្វើដោយប្រើ capistrano យ៉ាងហោចណាស់ចេញពីប្រអប់ វាអាចចម្លងកូដទៅក្នុងបញ្ជីចេញផ្សាយ ប្តូរការចេញផ្សាយដោយប្រើតំណភ្ជាប់និមិត្តសញ្ញានៅពេលដាក់ឱ្យដំណើរការដោយជោគជ័យ ចម្លងការកំណត់រចនាសម្ព័ន្ធពីថតដែលបានចែករំលែក ចាប់ផ្ដើម puma ឡើងវិញ។ល។ ទាំងអស់នេះអាចត្រូវបានធ្វើដោយប្រើ Ansible ប៉ុន្តែហេតុអ្វី?

រចនាសម្ព័ន្ធឯកសារ

Ansible មានភាពតឹងរ៉ឹង រចនាសម្ព័ន្ធឯកសារ សម្រាប់ឯកសាររបស់អ្នកទាំងអស់ ដូច្នេះវាជាការល្អបំផុតក្នុងការរក្សាទុកវាទាំងអស់នៅក្នុងថតដាច់ដោយឡែកមួយ។ លើសពីនេះទៅទៀតវាមិនសំខាន់ទេថាតើវានឹងស្ថិតនៅក្នុងកម្មវិធីផ្លូវដែកដោយខ្លួនឯងឬដោយឡែកពីគ្នា។ អ្នកអាចរក្សាទុកឯកសារនៅក្នុងឃ្លាំង git ដាច់ដោយឡែក។ ដោយផ្ទាល់ ខ្ញុំបានរកឃើញថាវាងាយស្រួលបំផុតក្នុងការបង្កើតថតឯកសារដែលអាចប្រើប្រាស់បាននៅក្នុងថត /config នៃកម្មវិធីផ្លូវរថភ្លើង ហើយរក្សាទុកអ្វីគ្រប់យ៉ាងនៅក្នុងឃ្លាំងមួយ។

សៀវភៅលេងសាមញ្ញ

Playbook គឺជាឯកសារ yml ដែលប្រើវាក្យសម្ព័ន្ធពិសេស ពិពណ៌នាអំពីអ្វីដែល Ansible គួរធ្វើ និងរបៀប។ តោះបង្កើតសៀវភៅលេងដំបូងដែលមិនធ្វើអ្វីសោះ៖

---
- name: Simple playbook
  hosts: all

នៅទីនេះយើងនិយាយយ៉ាងសាមញ្ញថាសៀវភៅលេងរបស់យើងត្រូវបានគេហៅថា Simple Playbook ហើយមាតិការបស់វាគួរត្រូវបានប្រតិបត្តិសម្រាប់ម៉ាស៊ីនទាំងអស់។ យើង​អាច​រក្សា​ទុក​វា​ក្នុង​ថត /ansible ដោយ​ប្រើ​ឈ្មោះ playbook.yml ហើយព្យាយាមរត់៖

ansible-playbook ./playbook.yml

PLAY [Simple Playbook] ************************************************************************************************************************************
skipping: no hosts matched

Ansible និយាយថាវាមិនស្គាល់ម៉ាស៊ីនណាមួយដែលត្រូវនឹងបញ្ជីទាំងអស់។ ពួកគេត្រូវតែត្រូវបានរាយបញ្ជីពិសេស ឯកសារសារពើភ័ណ្ឌ.

ចូរយើងបង្កើតវានៅក្នុងថតឯកសារដូចគ្នា៖

123.123.123.123

នេះជារបៀបដែលយើងគ្រាន់តែបញ្ជាក់ម៉ាស៊ីន (តាមឧត្ដមគតិម៉ាស៊ីននៃ VPS របស់យើងសម្រាប់ការសាកល្បង ឬអ្នកអាចចុះឈ្មោះ localhost) ហើយរក្សាទុកវានៅក្រោមឈ្មោះ inventory.
អ្នកអាចសាកល្បងដំណើរការ ansible ជាមួយឯកសារសារពើភ័ណ្ឌ៖

ansible-playbook ./playbook.yml -i inventory
PLAY [Simple Playbook] ************************************************************************************************************************************

TASK [Gathering Facts] ************************************************************************************************************************************

PLAY RECAP ************************************************************************************************************************************

ប្រសិនបើអ្នកមានសិទ្ធិចូលប្រើ ssh ទៅកាន់ម៉ាស៊ីនដែលបានបញ្ជាក់ នោះ ansible នឹងភ្ជាប់ និងប្រមូលព័ត៌មានអំពីប្រព័ន្ធពីចម្ងាយ។ (លំនាំដើម TASK [Gathering Facts]) បន្ទាប់ពីនោះវានឹងផ្តល់របាយការណ៍ខ្លីមួយស្តីពីការប្រតិបត្តិ (PLAY RECAP)។

តាមលំនាំដើម ការតភ្ជាប់ប្រើឈ្មោះអ្នកប្រើប្រាស់ដែលអ្នកបានចូលទៅក្នុងប្រព័ន្ធ។ វាទំនងជានឹងមិននៅលើម្ចាស់ផ្ទះទេ។ នៅក្នុងឯកសារ playbook អ្នកអាចបញ្ជាក់អ្នកប្រើប្រាស់ណាដែលត្រូវប្រើដើម្បីភ្ជាប់ដោយប្រើការណែនាំ remote_user ។ ផងដែរ ព័ត៌មានអំពីប្រព័ន្ធពីចម្ងាយ ជារឿយៗមិនចាំបាច់សម្រាប់អ្នក ហើយអ្នកមិនគួរខ្ជះខ្ជាយពេលវេលាក្នុងការប្រមូលវាទេ។ កិច្ចការនេះក៏អាចត្រូវបានបិទផងដែរ៖

---
- name: Simple playbook
  hosts: all
  remote_user: root
  become: true
  gather_facts: no

សាកល្បងដំណើរការសៀវភៅលេងម្តងទៀត ហើយត្រូវប្រាកដថាការតភ្ជាប់ដំណើរការ។ (ប្រសិនបើអ្នក​បាន​បញ្ជាក់​អ្នក​ប្រើ​ជា root នោះ​អ្នក​ក៏​ត្រូវ​បញ្ជាក់​ការ​ក្លាយ​ជា៖ សេចក្តី​ណែនាំ​ពិត​ផង​ដែរ ដើម្បី​ទទួល​បាន​សិទ្ធិ​កើនឡើង។ ដូច​ដែល​បាន​សរសេរ​ក្នុង​ឯកសារ៖ become set to ‘true’/’yes’ to activate privilege escalation. ទោះបីជាវាមិនច្បាស់ថាហេតុអ្វីក៏ដោយ) ។

ប្រហែលជាអ្នកនឹងទទួលបានកំហុសដែលបណ្តាលមកពីការពិតដែលថា ansible មិនអាចកំណត់អ្នកបកប្រែ Python បានទេ បន្ទាប់មកអ្នកអាចបញ្ជាក់វាដោយដៃ៖

ansible_python_interpreter: /usr/bin/python3 

អ្នកអាចស្វែងរកកន្លែងដែលអ្នកមាន python ដោយប្រើពាក្យបញ្ជា whereis python.

ការដំឡើងកញ្ចប់ប្រព័ន្ធ

ការចែកចាយស្តង់ដាររបស់ Ansible រួមមានម៉ូឌុលជាច្រើនសម្រាប់ធ្វើការជាមួយកញ្ចប់ប្រព័ន្ធផ្សេងៗ ដូច្នេះយើងមិនចាំបាច់សរសេរស្គ្រីប bash សម្រាប់ហេតុផលណាមួយឡើយ។ ឥឡូវនេះយើងត្រូវការម៉ូឌុលមួយក្នុងចំណោមម៉ូឌុលទាំងនេះដើម្បីធ្វើបច្ចុប្បន្នភាពប្រព័ន្ធ និងដំឡើងកញ្ចប់ប្រព័ន្ធ។ ខ្ញុំមាន Ubuntu Linux នៅលើ VPS របស់ខ្ញុំ ដូច្នេះដើម្បីដំឡើងកញ្ចប់ ខ្ញុំប្រើ apt-get и ម៉ូឌុលសម្រាប់វា។. ប្រសិនបើអ្នកកំពុងប្រើប្រព័ន្ធប្រតិបត្តិការផ្សេង នោះអ្នកប្រហែលជាត្រូវការម៉ូឌុលផ្សេង (សូមចាំថា ខ្ញុំបាននិយាយនៅដើមដំបូងថា យើងត្រូវដឹងជាមុនអំពីអ្វី និងរបៀបដែលយើងនឹងធ្វើ)។ ទោះយ៉ាងណាក៏ដោយ វាក្យសម្ព័ន្ធទំនងជានឹងស្រដៀងគ្នា។

តោះបំពេញសៀវភៅលេងរបស់យើងជាមួយនឹងកិច្ចការដំបូង៖

---
- name: Simple playbook
  hosts: all
  remote_user: root
  become: true
  gather_facts: no

  tasks:
    - name: Update system
      apt: update_cache=yes
    - name: Install system dependencies
      apt:
        name: git,nginx,redis,postgresql,postgresql-contrib
        state: present

Task គឺពិតជាកិច្ចការដែល Ansible នឹងអនុវត្តនៅលើម៉ាស៊ីនមេពីចម្ងាយ។ យើងផ្តល់ឈ្មោះឱ្យភារកិច្ច ដូច្នេះយើងអាចតាមដានការប្រតិបត្តិរបស់វានៅក្នុងកំណត់ហេតុ។ ហើយយើងពណ៌នា ដោយប្រើវាក្យសម្ព័ន្ធនៃម៉ូឌុលជាក់លាក់មួយ តើវាត្រូវធ្វើអ្វីខ្លះ។ ក្នុងករណី​នេះ apt: update_cache=yes - និយាយថាដើម្បីធ្វើបច្ចុប្បន្នភាពកញ្ចប់ប្រព័ន្ធដោយប្រើម៉ូឌុល apt ។ ពាក្យបញ្ជាទីពីរគឺស្មុគស្មាញបន្តិច។ យើងបញ្ជូនបញ្ជីកញ្ចប់មួយទៅម៉ូឌុល apt ហើយនិយាយថាពួកគេគឺ state គួរតែក្លាយជា presentនោះគឺយើងនិយាយថាដំឡើងកញ្ចប់ទាំងនេះ។ នៅក្នុងវិធីស្រដៀងគ្នានេះ យើងអាចប្រាប់ពួកគេឱ្យលុបពួកវា ឬធ្វើបច្ចុប្បន្នភាពពួកវាដោយគ្រាន់តែផ្លាស់ប្តូរ state. សូមចំណាំថាសម្រាប់ផ្លូវដែកដើម្បីធ្វើការជាមួយ postgresql យើងត្រូវការកញ្ចប់ postgresql-contrib ដែលយើងកំពុងដំឡើងឥឡូវនេះ។ ជាថ្មីម្តងទៀត អ្នកត្រូវដឹង ហើយធ្វើវាដោយខ្លួនឯង នឹងមិនធ្វើបែបនេះទេ។

សាកល្បងដំណើរការសៀវភៅលេងម្តងទៀត ហើយពិនិត្យមើលថាកញ្ចប់ត្រូវបានដំឡើង។

ការបង្កើតអ្នកប្រើប្រាស់ថ្មី។

ដើម្បីធ្វើការជាមួយអ្នកប្រើប្រាស់ Ansible ក៏មានម៉ូឌុលផងដែរ - អ្នកប្រើប្រាស់។ ចូរបន្ថែមកិច្ចការមួយបន្ថែមទៀត (ខ្ញុំបានលាក់ផ្នែកដែលគេស្គាល់រួចហើយនៃសៀវភៅលេងនៅពីក្រោយមតិយោបល់ ដើម្បីកុំឱ្យចម្លងវាទាំងស្រុងរាល់ពេល)៖

---
- name: Simple playbook
  # ...
  tasks:
    # ...
    - name: Add a new user
      user:
        name: my_user
        shell: /bin/bash
        password: "{{ 123qweasd | password_hash('sha512') }}"

យើងបង្កើតអ្នកប្រើប្រាស់ថ្មី កំណត់គ្រោងការណ៍ និងពាក្យសម្ងាត់សម្រាប់វា។ ហើយបន្ទាប់មកយើងជួបបញ្ហាជាច្រើន។ ចុះ​បើ​ឈ្មោះ​អ្នក​ប្រើ​ត្រូវ​ការ​ខុស​គ្នា​សម្រាប់​ម៉ាស៊ីន​ផ្សេង? ហើយ​ការ​ទុក​លេខ​សម្ងាត់​ជា​អក្សរ​ច្បាស់​ក្នុង​សៀវភៅ​លេង​គឺជា​គំនិត​អាក្រក់​ណាស់។ ដើម្បីចាប់ផ្តើម ចូរយើងដាក់ឈ្មោះអ្នកប្រើប្រាស់ និងពាក្យសម្ងាត់ទៅជាអថេរ ហើយនៅចុងបញ្ចប់នៃអត្ថបទ ខ្ញុំនឹងបង្ហាញពីរបៀបអ៊ិនគ្រីបពាក្យសម្ងាត់។

---
- name: Simple playbook
  # ...
  tasks:
    # ...
    - name: Add a new user
      user:
        name: "{{ user }}"
        shell: /bin/bash
        password: "{{ user_password | password_hash('sha512') }}"

អថេរ​ត្រូវ​បាន​កំណត់​ក្នុង​សៀវភៅ​ចាក់​ដោយ​ប្រើ​ដង្កៀប​រួញ​ទ្វេ។

យើងនឹងបង្ហាញពីតម្លៃនៃអថេរនៅក្នុងឯកសារសារពើភ័ណ្ឌ៖

123.123.123.123

[all:vars]
user=my_user
user_password=123qweasd

សូមកត់សម្គាល់ការណែនាំ [all:vars] - វានិយាយថាប្លុកបន្ទាប់នៃអត្ថបទគឺជាអថេរ (vars) ហើយពួកវាអាចអនុវត្តបានចំពោះម៉ាស៊ីនទាំងអស់ (ទាំងអស់) ។

ការរចនាក៏គួរឱ្យចាប់អារម្មណ៍ផងដែរ។ "{{ user_password | password_hash('sha512') }}". រឿងនេះគឺថា ansible មិនដំឡើងអ្នកប្រើប្រាស់តាមរយៈ user_add ដូចជាអ្នកនឹងធ្វើវាដោយដៃ។ ហើយវារក្សាទុកទិន្នន័យទាំងអស់ដោយផ្ទាល់ ដែលជាមូលហេតុដែលយើងត្រូវតែបំប្លែងពាក្យសម្ងាត់ទៅជា hash ជាមុន ដែលជាពាក្យបញ្ជានេះធ្វើ។

តោះបន្ថែមអ្នកប្រើប្រាស់របស់យើងទៅក្រុម sudo ។ ទោះយ៉ាងណាក៏ដោយ មុននេះ យើងត្រូវធ្វើឱ្យប្រាកដថា មានក្រុមបែបនេះ ព្រោះគ្មាននរណាម្នាក់នឹងធ្វើបែបនេះសម្រាប់យើងទេ៖

---
- name: Simple playbook
  # ...
  tasks:
    # ...
    - name: Ensure a 'sudo' group
      group:
        name: sudo
        state: present
    - name: Add a new user
      user:
        name: "{{ user }}"
        shell: /bin/bash
        password: "{{ user_password | password_hash('sha512') }}"
        groups: "sudo"

អ្វី​គ្រប់​យ៉ាង​គឺ​សាមញ្ញ​ណាស់ យើង​ក៏​មាន​ម៉ូឌុល​ក្រុម​សម្រាប់​បង្កើត​ក្រុម ដោយ​មាន​វាក្យសម្ព័ន្ធ​ស្រដៀង​នឹង apt ។ បន្ទាប់មក វាគ្រប់គ្រាន់ហើយក្នុងការចុះឈ្មោះក្រុមនេះទៅកាន់អ្នកប្រើប្រាស់ (groups: "sudo").
វាក៏មានប្រយោជន៍ផងដែរក្នុងការបន្ថែមសោ ssh ទៅកាន់អ្នកប្រើប្រាស់នេះ ដូច្នេះយើងអាចចូលដោយប្រើវាដោយគ្មានពាក្យសម្ងាត់៖

---
- name: Simple playbook
  # ...
  tasks:
    # ...
    - name: Ensure a 'sudo' group
      group:
      name: sudo
        state: present
    - name: Add a new user
      user:
        name: "{{ user }}"
        shell: /bin/bash
        password: "{{ user_password | password_hash('sha512') }}"
        groups: "sudo"
    - name: Deploy SSH Key
      authorized_key:
        user: "{{ user }}"
        key: "{{ lookup('file', '~/.ssh/id_rsa.pub') }}"
        state: present

ក្នុងករណីនេះការរចនាគួរឱ្យចាប់អារម្មណ៍ "{{ lookup('file', '~/.ssh/id_rsa.pub') }}" — វាចម្លងមាតិកានៃឯកសារ id_rsa.pub (ឈ្មោះរបស់អ្នកអាចខុសគ្នា) នោះគឺជាផ្នែកសាធារណៈនៃសោ ssh ហើយបញ្ចូលវាទៅក្នុងបញ្ជីនៃសោដែលបានអនុញ្ញាតសម្រាប់អ្នកប្រើប្រាស់នៅលើម៉ាស៊ីនមេ។

តួនាទី

កិច្ចការទាំងបីសម្រាប់បង្កើតការប្រើប្រាស់អាចត្រូវបានចាត់ថ្នាក់យ៉ាងងាយស្រួលទៅជាក្រុមមួយនៃកិច្ចការ ហើយវាជាការល្អក្នុងការរក្សាទុកក្រុមនេះដាច់ដោយឡែកពីសៀវភៅលេងសំខាន់ ដើម្បីកុំឱ្យវាធំពេក។ សម្រាប់គោលបំណងនេះ Ansible មាន តួនាទី.
យោងតាមរចនាសម្ព័ន្ធឯកសារដែលបានបង្ហាញនៅដើមដំបូង តួនាទីត្រូវតែដាក់ក្នុងថតតួនាទីដាច់ដោយឡែក សម្រាប់តួនាទីនីមួយៗមានថតដាច់ដោយឡែកដែលមានឈ្មោះដូចគ្នា នៅខាងក្នុងកិច្ចការ ឯកសារ គំរូ ថតឯកសារ។ល។
តោះបង្កើតរចនាសម្ព័ន្ធឯកសារ៖ ./ansible/roles/user/tasks/main.yml (មេគឺជាឯកសារសំខាន់ដែលនឹងត្រូវបានផ្ទុក និងប្រតិបត្តិនៅពេលដែលតួនាទីត្រូវបានភ្ជាប់ទៅសៀវភៅលេង។ ឯកសារតួនាទីផ្សេងទៀតអាចភ្ជាប់ទៅវាបាន)។ ឥឡូវ​នេះ អ្នក​អាច​ផ្ទេរ​កិច្ចការ​ទាំងអស់​ដែល​ទាក់ទង​នឹង​អ្នក​ប្រើ​ទៅ​ឯកសារ​នេះ៖

# Create user and add him to groups
- name: Ensure a 'sudo' group
  group:
    name: sudo
    state: present

- name: Add a new user
  user:
    name: "{{ user }}"
    shell: /bin/bash
    password: "{{ user_password | password_hash('sha512') }}"
    groups: "sudo"

- name: Deploy SSH Key
  authorized_key:
    user: "{{ user }}"
    key: "{{ lookup('file', '~/.ssh/id_rsa.pub') }}"
    state: present

នៅក្នុងសៀវភៅចាក់មេ អ្នកត្រូវតែបញ្ជាក់ដើម្បីប្រើតួនាទីរបស់អ្នកប្រើ៖

---
- name: Simple playbook
  hosts: all
  remote_user: root
  gather_facts: no

  tasks:
    - name: Update system
      apt: update_cache=yes
    - name: Install system dependencies
      apt:
        name: git,nginx,redis,postgresql,postgresql-contrib
        state: present

  roles:
    - user

ដូចគ្នានេះផងដែរ, វាអាចសមហេតុផលដើម្បីធ្វើបច្ចុប្បន្នភាពប្រព័ន្ធមុនពេលការងារផ្សេងទៀតទាំងអស់; ដើម្បីធ្វើដូចនេះអ្នកអាចប្តូរឈ្មោះប្លុក tasks ដែលពួកគេត្រូវបានកំណត់នៅក្នុង pre_tasks.

ការដំឡើង nginx

យើងគួរតែដំឡើង Nginx រួចហើយ យើងត្រូវកំណត់វា ហើយដំណើរការវា។ ចូរធ្វើវាភ្លាមៗនៅក្នុងតួនាទី។ តោះបង្កើតរចនាសម្ព័ន្ធឯកសារ៖

- ansible
  - roles
    - nginx
      - files
      - tasks
        - main.yml
      - templates

ឥឡូវនេះយើងត្រូវការឯកសារ និងគំរូ។ ភាពខុសគ្នារវាងពួកវាគឺថា ansible ចម្លងឯកសារដោយផ្ទាល់ដូចជា។ ហើយគំរូត្រូវតែមានផ្នែកបន្ថែម j2 ហើយពួកគេអាចប្រើតម្លៃអថេរដោយប្រើដង្កៀប curly ទ្វេដូចគ្នា។

តោះបើក nginx ចូល main.yml ឯកសារ។ សម្រាប់បញ្ហានេះយើងមានម៉ូឌុលប្រព័ន្ធ៖

# Copy nginx configs and start it
- name: enable service nginx and start
  systemd:
    name: nginx
    state: started
    enabled: yes

នៅទីនេះយើងមិនត្រឹមតែនិយាយថា nginx ត្រូវតែត្រូវបានចាប់ផ្តើម (នោះគឺយើងបើកដំណើរការវា) ប៉ុន្តែយើងនិយាយភ្លាមៗថាវាត្រូវតែត្រូវបានបើក។
ឥឡូវនេះសូមចម្លងឯកសារកំណត់រចនាសម្ព័ន្ធ៖

# Copy nginx configs and start it
- name: enable service nginx and start
  systemd:
    name: nginx
    state: started
    enabled: yes

- name: Copy the nginx.conf
  copy:
    src: nginx.conf
    dest: /etc/nginx/nginx.conf
    owner: root
    group: root
    mode: '0644'
    backup: yes

- name: Copy template my_app.conf
  template:
    src: my_app_conf.j2
    dest: /etc/nginx/sites-available/my_app.conf
    owner: root
    group: root
    mode: '0644'

យើងបង្កើតឯកសារកំណត់រចនាសម្ព័ន្ធ nginx មេ (អ្នកអាចយកវាដោយផ្ទាល់ពីម៉ាស៊ីនមេ ឬសរសេរវាដោយខ្លួនឯង)។ ហើយក៏ជាឯកសារកំណត់រចនាសម្ព័ន្ធសម្រាប់កម្មវិធីរបស់យើងនៅក្នុង sites_available directory (វាមិនចាំបាច់ទេ ប៉ុន្តែមានប្រយោជន៍)។ ក្នុងករណីដំបូងយើងប្រើម៉ូឌុលចម្លងដើម្បីចម្លងឯកសារ (ឯកសារត្រូវតែនៅក្នុង /ansible/roles/nginx/files/nginx.conf) នៅក្នុងទីពីរយើងចម្លងគំរូដោយជំនួសតម្លៃនៃអថេរ។ គំរូគួរតែនៅក្នុង /ansible/roles/nginx/templates/my_app.j2) ហើយវាអាចមើលទៅដូចនេះ៖

upstream {{ app_name }} {
  server unix:{{ app_path }}/shared/tmp/sockets/puma.sock;
}

server {
  listen 80;
  server_name {{ server_name }} {{ inventory_hostname }};
  root {{ app_path }}/current/public;

  try_files $uri/index.html $uri.html $uri @{{ app_name }};
  ....
}

យកចិត្តទុកដាក់លើការបញ្ចូល {{ app_name }}, {{ app_path }}, {{ server_name }}, {{ inventory_hostname }} - ទាំងនេះគឺជាអថេរទាំងអស់ដែលតម្លៃ Ansible នឹងជំនួសទៅក្នុងគំរូមុនពេលចម្លង។ វាមានប្រយោជន៍ប្រសិនបើអ្នកប្រើសៀវភៅលេងសម្រាប់ក្រុមផ្សេងៗនៃម៉ាស៊ីន។ ឧទាហរណ៍ យើងអាចបន្ថែមឯកសារសារពើភ័ណ្ឌរបស់យើង៖

[production]
123.123.123.123

[staging]
231.231.231.231

[all:vars]
user=my_user
user_password=123qweasd

[production:vars]
server_name=production
app_path=/home/www/my_app
app_name=my_app

[staging:vars]
server_name=staging
app_path=/home/www/my_stage
app_name=my_stage_app

ប្រសិនបើឥឡូវនេះយើងបើកដំណើរការសៀវភៅលេងរបស់យើង វានឹងបំពេញភារកិច្ចដែលបានបញ្ជាក់សម្រាប់ម៉ាស៊ីនទាំងពីរ។ ប៉ុន្តែក្នុងពេលជាមួយគ្នានេះ សម្រាប់កម្មវិធីលំដាប់លំដោយ អថេរនឹងខុសពីផលិតកម្ម ហើយមិនត្រឹមតែនៅក្នុងតួនាទី និងសៀវភៅលេងប៉ុណ្ណោះទេ ប៉ុន្តែក៏មាននៅក្នុងការកំណត់រចនាសម្ព័ន្ធ nginx ផងដែរ។ {{ inventory_hostname }} មិនចាំបាច់បញ្ជាក់នៅក្នុងឯកសារសារពើភ័ណ្ឌ - នេះ។ អថេរ ansible ពិសេស ហើយម៉ាស៊ីនដែលសៀវភៅកំពុងដំណើរការបច្ចុប្បន្នត្រូវបានរក្សាទុកនៅទីនោះ។
ប្រសិនបើអ្នកចង់មានឯកសារសារពើភ័ណ្ឌសម្រាប់ម៉ាស៊ីនជាច្រើន ប៉ុន្តែដំណើរការសម្រាប់ក្រុមតែមួយ នេះអាចត្រូវបានធ្វើដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

ansible-playbook -i inventory ./playbook.yml -l "staging"

ជម្រើសមួយទៀតគឺត្រូវមានឯកសារសារពើភ័ណ្ឌដាច់ដោយឡែកសម្រាប់ក្រុមផ្សេងៗគ្នា។ ឬអ្នកអាចបញ្ចូលគ្នានូវវិធីសាស្រ្តទាំងពីរ ប្រសិនបើអ្នកមានម៉ាស៊ីនផ្សេងគ្នាជាច្រើន។

ចូរយើងត្រលប់ទៅការដំឡើង nginx វិញ។ បន្ទាប់ពីចម្លងឯកសារកំណត់រចនាសម្ព័ន្ធ យើងត្រូវបង្កើត symlink ក្នុង sitest_enabled ទៅ my_app.conf ពី sites_available ។ ហើយចាប់ផ្តើម nginx ឡើងវិញ។

... # old code in mail.yml

- name: Create symlink to sites-enabled
  file:
    src: /etc/nginx/sites-available/my_app.conf
    dest: /etc/nginx/sites-enabled/my_app.conf
    state: link

- name: restart nginx
  service:
    name: nginx
    state: restarted

អ្វីគ្រប់យ៉ាងគឺសាមញ្ញនៅទីនេះ - ម៉ូឌុល ansible ម្តងទៀតជាមួយនឹងវាក្យសម្ព័ន្ធស្តង់ដារសមរម្យ។ ប៉ុន្តែមានចំណុចមួយ។ រាល់ពេលចាប់ផ្តើម nginx ឡើងវិញមិនមានចំណុចអ្វីនោះទេ។ តើអ្នកបានកត់សម្គាល់ទេថាយើងមិនសរសេរពាក្យបញ្ជាដូចជា "ធ្វើដូចនេះ" វាក្យសម្ព័ន្ធមើលទៅហាក់ដូចជា "នេះគួរតែមានស្ថានភាពនេះ" ។ ហើយភាគច្រើននេះពិតជារបៀបដែល ansible ដំណើរការ។ ប្រសិនបើក្រុមមានរួចហើយ ឬកញ្ចប់ប្រព័ន្ធត្រូវបានដំឡើងរួចហើយ ansible នឹងពិនិត្យមើលវា ហើយរំលងកិច្ចការនេះ។ ដូចគ្នានេះផងដែរ ឯកសារនឹងមិនត្រូវបានចម្លងទេ ប្រសិនបើពួកវាត្រូវគ្នាទាំងស្រុងនូវអ្វីដែលមាននៅលើម៉ាស៊ីនមេ។ យើងអាចទាញយកប្រយោជន៍ពីវា ហើយចាប់ផ្តើម nginx ឡើងវិញបានលុះត្រាតែឯកសារកំណត់រចនាសម្ព័ន្ធត្រូវបានផ្លាស់ប្តូរ។ មានការណែនាំអំពីការចុះឈ្មោះសម្រាប់រឿងនេះ៖

# Copy nginx configs and start it
- name: enable service nginx and start
  systemd:
    name: nginx
    state: started
    enabled: yes

- name: Copy the nginx.conf
  copy:
    src: nginx.conf
    dest: /etc/nginx/nginx.conf
    owner: root
    group: root
    mode: '0644'
    backup: yes
  register: restart_nginx

- name: Copy template my_app.conf
  template:
    src: my_app_conf.j2
    dest: /etc/nginx/sites-available/my_app.conf
    owner: root
    group: root
    mode: '0644'
  register: restart_nginx

- name: Create symlink to sites-enabled
  file:
    src: /etc/nginx/sites-available/my_app.conf
    dest: /etc/nginx/sites-enabled/my_app.conf
    state: link

- name: restart nginx
  service:
    name: nginx
    state: restarted
  when: restart_nginx.changed

ប្រសិនបើឯកសារកំណត់រចនាសម្ព័ន្ធណាមួយផ្លាស់ប្តូរ ច្បាប់ចម្លងនឹងត្រូវបានធ្វើឡើង ហើយអថេរនឹងត្រូវបានចុះឈ្មោះ restart_nginx. ហើយលុះត្រាតែអថេរនេះត្រូវបានចុះឈ្មោះ សេវាកម្មនឹងចាប់ផ្តើមឡើងវិញ។

ហើយជាការពិតណាស់ អ្នកត្រូវបន្ថែមតួនាទី nginx ទៅសៀវភៅលេងមេ។

ការដំឡើង postgresql

យើងត្រូវបើកដំណើរការ postgresql ដោយប្រើ systemd តាមរបៀបដូចដែលយើងបានធ្វើជាមួយ nginx ហើយក៏អាចបង្កើត user ដែលយើងនឹងប្រើដើម្បីចូលប្រើ database និង database ខ្លួនឯងផងដែរ។
តោះបង្កើតតួនាទី /ansible/roles/postgresql/tasks/main.yml:

# Create user in postgresql
- name: enable postgresql and start
  systemd:
    name: postgresql
    state: started
    enabled: yes

- name: Create database user
  become_user: postgres
  postgresql_user:
    name: "{{ db_user }}"
    password: "{{ db_password }}"
    role_attr_flags: SUPERUSER

- name: Create database
  become_user: postgres
  postgresql_db:
    name: "{{ db_name }}"
    encoding: UTF-8
    owner: "{{ db_user }}"

ខ្ញុំនឹងមិនរៀបរាប់ពីរបៀបបន្ថែមអថេរទៅក្នុងសារពើភ័ណ្ឌទេ នេះត្រូវបានធ្វើជាច្រើនដងរួចមកហើយ ក៏ដូចជាវាក្យសម្ព័ន្ធនៃម៉ូឌុល postgresql_db និង postgresql_user ។ ព័ត៌មានបន្ថែមអាចរកបាននៅក្នុងឯកសារ។ ការណែនាំគួរឱ្យចាប់អារម្មណ៍បំផុតនៅទីនេះគឺ become_user: postgres. ការពិតគឺថាតាមលំនាំដើម មានតែអ្នកប្រើប្រាស់ postgres ប៉ុណ្ណោះដែលអាចចូលប្រើមូលដ្ឋានទិន្នន័យ postgresql ហើយមានតែក្នុងស្រុកប៉ុណ្ណោះ។ ការណែនាំនេះអនុញ្ញាតឱ្យយើងប្រតិបត្តិពាក្យបញ្ជាជំនួសឱ្យអ្នកប្រើប្រាស់នេះ (ជាការពិតណាស់ប្រសិនបើយើងមានសិទ្ធិចូលប្រើ)។
ដូចគ្នានេះផងដែរ អ្នកប្រហែលជាត្រូវបន្ថែមបន្ទាត់ទៅ pg_hba.conf ដើម្បីអនុញ្ញាតឱ្យអ្នកប្រើថ្មីចូលប្រើមូលដ្ឋានទិន្នន័យ។ នេះអាចត្រូវបានធ្វើតាមរបៀបដូចគ្នានឹងយើងបានផ្លាស់ប្តូរការកំណត់រចនាសម្ព័ន្ធ nginx ។

ហើយជាការពិតណាស់ អ្នកត្រូវបន្ថែមតួនាទី postgresql ទៅសៀវភៅលេងសំខាន់។

ការដំឡើង Ruby ​​តាមរយៈ rbenv

Ansible មិនមានម៉ូឌុលសម្រាប់ធ្វើការជាមួយ rbenv ទេ ប៉ុន្តែវាត្រូវបានដំឡើងដោយការក្លូន git repository ។ ដូច្នេះ​ហើយ បញ្ហា​នេះ​ក្លាយ​ជា​បញ្ហា​មិន​ស្តង់ដារ​បំផុត។ ចូរបង្កើតតួនាទីសម្រាប់នាង /ansible/roles/ruby_rbenv/main.yml ហើយចាប់ផ្តើមបំពេញវា៖

# Install rbenv and ruby
- name: Install rbenv
  become_user: "{{ user }}"
  git: repo=https://github.com/rbenv/rbenv.git dest=~/.rbenv

យើងប្រើការណែនាំរបស់ become_user ម្តងទៀត ដើម្បីធ្វើការក្រោមអ្នកប្រើប្រាស់ដែលយើងបានបង្កើតសម្រាប់គោលបំណងទាំងនេះ។ ចាប់តាំងពី rbenv ត្រូវបានដំឡើងនៅក្នុងថតផ្ទះរបស់វា ហើយមិនមែននៅទូទាំងពិភពលោកទេ។ ហើយយើងក៏ប្រើម៉ូឌុល git ដើម្បីក្លូនឃ្លាំង ដោយបញ្ជាក់ repo និង dest ។

បន្ទាប់មកយើងត្រូវចុះឈ្មោះ rbenv init នៅក្នុង bashrc ហើយបន្ថែម rbenv ទៅ PATH នៅទីនោះ។ សម្រាប់នេះយើងមានម៉ូឌុល lineinfile:

- name: Add rbenv to PATH
  become_user: "{{ user }}"
  lineinfile:
    path: ~/.bashrc
    state: present
    line: 'export PATH="${HOME}/.rbenv/bin:${PATH}"'

- name: Add rbenv init to bashrc
  become_user: "{{ user }}"
  lineinfile:
    path: ~/.bashrc
    state: present
    line: 'eval "$(rbenv init -)"'

បន្ទាប់មកអ្នកត្រូវដំឡើង ruby_build៖

- name: Install ruby-build
  become_user: "{{ user }}"
  git: repo=https://github.com/rbenv/ruby-build.git dest=~/.rbenv/plugins/ruby-build

ហើយទីបំផុតដំឡើង Ruby ។ នេះត្រូវបានធ្វើតាមរយៈ rbenv ពោលគឺសាមញ្ញជាមួយពាក្យបញ្ជា bash:

- name: Install ruby
  become_user: "{{ user }}"
  shell: |
    export PATH="${HOME}/.rbenv/bin:${PATH}"
    eval "$(rbenv init -)"
    rbenv install {{ ruby_version }}
  args:
    executable: /bin/bash

យើងនិយាយថាពាក្យបញ្ជាមួយណាដែលត្រូវប្រតិបត្តិ និងជាមួយអ្វី។ ទោះយ៉ាងណាក៏ដោយ នៅទីនេះយើងបានឆ្លងកាត់ការពិតដែលថា ansible មិនដំណើរការកូដដែលមាននៅក្នុង bashrc មុនពេលដំណើរការពាក្យបញ្ជា។ នេះមានន័យថា rbenv នឹងត្រូវកំណត់ដោយផ្ទាល់នៅក្នុងស្គ្រីបតែមួយ។

បញ្ហាបន្ទាប់គឺដោយសារតែការពិតដែលថាពាក្យបញ្ជាសែលមិនមានស្ថានភាពពីទស្សនៈដែលអាចយល់បាន។ នោះគឺវានឹងមិនមានការត្រួតពិនិត្យដោយស្វ័យប្រវត្តិថាតើកំណែ Ruby នេះត្រូវបានដំឡើងឬអត់។ យើងអាចធ្វើវាដោយខ្លួនឯងបាន៖

- name: Install ruby
  become_user: "{{ user }}"
  shell: |
    export PATH="${HOME}/.rbenv/bin:${PATH}"
    eval "$(rbenv init -)"
    if ! rbenv versions | grep -q {{ ruby_version }}
      then rbenv install {{ ruby_version }} && rbenv global {{ ruby_version }}
    fi
  args:
    executable: /bin/bash

អ្វីដែលនៅសល់គឺត្រូវដំឡើង bundler៖

- name: Install bundler
  become_user: "{{ user }}"
  shell: |
    export PATH="${HOME}/.rbenv/bin:${PATH}"
    eval "$(rbenv init -)"
    gem install bundler

ហើយម្តងទៀត បន្ថែមតួនាទីរបស់យើង ruby_rbenv ទៅសៀវភៅលេងសំខាន់។

ឯកសារដែលបានចែករំលែក។

ជាទូទៅ ការដំឡើងអាចត្រូវបានបញ្ចប់នៅទីនេះ។ បន្ទាប់មក អ្វីដែលនៅសេសសល់គឺត្រូវដំណើរការ capistrano ហើយវានឹងចម្លងកូដដោយខ្លួនឯង បង្កើតថតឯកសារចាំបាច់ និងបើកដំណើរការកម្មវិធី (ប្រសិនបើអ្វីៗត្រូវបានកំណត់ត្រឹមត្រូវ)។ ទោះជាយ៉ាងណាក៏ដោយ capistrano ជារឿយៗតម្រូវឱ្យមានឯកសារកំណត់រចនាសម្ព័ន្ធបន្ថែមដូចជា database.yml ឬ .env ពួកវាអាចត្រូវបានចម្លងដូចឯកសារ និងគំរូសម្រាប់ nginx ដែរ។ មានតែភាពប៉ិនប្រសប់មួយ។ មុនពេលចម្លងឯកសារ អ្នកត្រូវបង្កើតរចនាសម្ព័ន្ធថតសម្រាប់ពួកវា អ្វីមួយដូចនេះ៖

# Copy shared files for deploy
- name: Ensure shared dir
  become_user: "{{ user }}"
  file:
    path: "{{ app_path }}/shared/config"
    state: directory

យើងបញ្ជាក់តែថតមួយប៉ុណ្ណោះ ហើយ ansible នឹងបង្កើតមេដោយស្វ័យប្រវត្តិប្រសិនបើចាំបាច់។

តុដេក Ansible

យើងបានឆ្លងកាត់ការពិតដែលថាអថេរអាចមានទិន្នន័យសម្ងាត់ដូចជាពាក្យសម្ងាត់របស់អ្នកប្រើ។ ប្រសិនបើអ្នកបានបង្កើត .env ឯកសារសម្រាប់កម្មវិធី និង database.yml បន្ទាប់មក វាត្រូវតែមានទិន្នន័យសំខាន់ៗបន្ថែមទៀត។ វាជាការល្អក្នុងការលាក់ពួកគេពីភ្នែក។ សម្រាប់គោលបំណងនេះវាត្រូវបានប្រើ តុដេក ansible.

តោះបង្កើតឯកសារសម្រាប់អថេរ /ansible/vars/all.yml (នៅទីនេះអ្នកអាចបង្កើតឯកសារផ្សេងៗគ្នាសម្រាប់ក្រុមផ្សេងៗគ្នានៃម៉ាស៊ីន ដូចជានៅក្នុងឯកសារសារពើភ័ណ្ឌ៖ production.yml, staging.yml ។ល។)។
អថេរទាំងអស់ដែលត្រូវតែត្រូវបានអ៊ិនគ្រីបត្រូវតែផ្ទេរទៅឯកសារនេះដោយប្រើវាក្យសម្ព័ន្ធ yml ស្តង់ដារ៖

# System vars
user_password: 123qweasd
db_password: 123qweasd

# ENV vars
aws_access_key_id: xxxxx
aws_secret_access_key: xxxxxx
aws_bucket: bucket_name
rails_secret_key_base: very_secret_key_base

បន្ទាប់ពីនោះឯកសារនេះអាចត្រូវបានអ៊ិនគ្រីបដោយប្រើពាក្យបញ្ជា៖

ansible-vault encrypt ./vars/all.yml

ជាធម្មតា នៅពេលអ៊ិនគ្រីប អ្នកនឹងត្រូវកំណត់ពាក្យសម្ងាត់សម្រាប់ការឌិគ្រីប។ អ្នក​អាច​មើល​ឃើញ​អ្វី​ដែល​នឹង​មាន​នៅ​ក្នុង​ឯកសារ​បន្ទាប់​ពី​ហៅ​ពាក្យ​បញ្ជា​នេះ។

ដោយមានជំនួយពី ansible-vault decrypt ឯកសារអាចត្រូវបានឌិគ្រីប កែប្រែ និងបន្ទាប់មកអ៊ិនគ្រីបម្តងទៀត។

អ្នកមិនចាំបាច់ឌិគ្រីបឯកសារដើម្បីដំណើរការទេ។ អ្នករក្សាទុកវាដោយអ៊ិនគ្រីប ហើយដំណើរការសៀវភៅលេងដោយប្រើអាគុយម៉ង់ --ask-vault-pass. Ansible នឹងសួររកពាក្យសម្ងាត់ ទាញយកអថេរ និងប្រតិបត្តិភារកិច្ច។ ទិន្នន័យទាំងអស់នឹងនៅតែត្រូវបានអ៊ិនគ្រីប។

ពាក្យបញ្ជាពេញលេញសម្រាប់ក្រុមជាច្រើននៃ hosts និង ansible vault នឹងមើលទៅដូចនេះ៖

ansible-playbook -i inventory ./playbook.yml -l "staging" --ask-vault-pass

ប៉ុន្តែខ្ញុំនឹងមិនផ្តល់ឱ្យអ្នកនូវអត្ថបទពេញលេញនៃសៀវភៅលេង និងតួនាទីទេ សូមសរសេរវាដោយខ្លួនឯង។ ដោយសារតែ ansible គឺបែបនោះ - ប្រសិនបើអ្នកមិនយល់ពីអ្វីដែលត្រូវធ្វើ នោះវានឹងមិនធ្វើវាសម្រាប់អ្នកទេ។

ប្រភព: www.habr.com