Ansible භාවිතයෙන් Rails යෙදුමක් යෙදවීමට සේවාදායකයක් සැකසීම

රේල් යෙදුමක් යෙදවීම සඳහා සේවාදායකය සූදානම් කිරීම සඳහා බොහෝ කලකට පෙර මට Ansible playbooks කිහිපයක් ලිවීමට අවශ්‍ය විය. තවද, පුදුමයට කරුණක් නම්, මම සරල පියවරෙන් පියවර අත්පොතක් සොයා ගත්තේ නැත. සිදුවන්නේ කුමක්ද යන්න තේරුම් නොගෙන වෙනත් කෙනෙකුගේ ක්‍රීඩා පොත පිටපත් කිරීමට මට අවශ්‍ය නොවූ අතර අවසානයේ මට සියල්ල එකතු කරමින් ලේඛන කියවීමට සිදු විය. සමහර විට මම මෙම ලිපියේ උපකාරයෙන් මෙම ක්රියාවලිය වේගවත් කිරීමට යමෙකුට උපකාර කළ හැකිය.

තේරුම් ගත යුතු පළමු දෙය නම්, SSH හරහා දුරස්ථ සේවාදායකයක (ය) පූර්ව නිශ්චිත ක්‍රියා ලැයිස්තුවක් සිදු කිරීමට ඇන්සිබල් ඔබට පහසු අතුරු මුහුණතක් ලබා දෙන බවයි. මෙහි මැජික් නොමැත, ඔබට ප්ලගිනයක් ස්ථාපනය කර ඩොකර්, අධීක්‍ෂණය සහ වෙනත් හොඳ දේවල් සමඟින් ඔබගේ යෙදුමේ ශුන්‍ය අක්‍රීය කාල යෙදවීමක් ලබා ගත නොහැක. ක්‍රීඩා පොතක් ලිවීම සඳහා, ඔබ හරියටම කළ යුත්තේ කුමක්ද සහ එය කරන්නේ කෙසේද යන්න දැන සිටිය යුතුය. GitHub වෙතින් සූදානම් කළ ක්‍රීඩා පොත් හෝ "පිටපත් කර ධාවනය කරන්න, එය ක්‍රියා කරයි" වැනි ලිපිවලින් මම සෑහීමකට පත් නොවන්නේ එබැවිනි.

අපට අවශ්ය කුමක්ද?

මම දැනටමත් පවසා ඇති පරිදි, ක්‍රීඩා පොතක් ලිවීමට ඔබ කළ යුතු දේ සහ එය කරන්නේ කෙසේද යන්න දැන සිටිය යුතුය. අවශ්‍ය දේ අපි තීරණය කරමු. Rails යෙදුමක් සඳහා අපට පද්ධති පැකේජ කිහිපයක් අවශ්‍ය වනු ඇත: nginx, postgresql (redis, etc). මීට අමතරව, අපට රුබී නිශ්චිත අනුවාදයක් අවශ්ය වේ. Rbenv (rvm, asdf...) හරහා එය ස්ථාපනය කිරීම වඩාත් සුදුසුය. මේ සියල්ල root පරිශීලකයෙකු ලෙස ධාවනය කිරීම සැමවිටම නරක අදහසකි, එබැවින් ඔබ වෙනම පරිශීලකයෙකු නිර්මාණය කර ඔහුගේ අයිතිවාසිකම් වින්‍යාසගත කළ යුතුය. මෙයින් පසු, ඔබ අපගේ කේතය සේවාදායකයට උඩුගත කළ යුතුය, nginx, postgres, ආදිය සඳහා වින්‍යාස පිටපත් කර මෙම සියලු සේවාවන් ආරම්භ කළ යුතුය.

ප්රතිඵලයක් වශයෙන්, ක්රියා අනුපිළිවෙල පහත පරිදි වේ:

1. root ලෙස ලොග් වන්න
2. පද්ධති පැකේජ ස්ථාපනය කරන්න
3. නව පරිශීලකයෙකු සාදන්න, අයිතිවාසිකම් වින්‍යාස කරන්න, ssh යතුර
4. පද්ධති පැකේජ (nginx ආදිය) වින්‍යාස කර ඒවා ක්‍රියාත්මක කරන්න
5. අපි දත්ත ගබඩාවේ පරිශීලකයෙකු නිර්මාණය කරමු (ඔබට වහාම දත්ත සමුදායක් සෑදිය හැක)
6. නව පරිශීලකයෙකු ලෙස පුරනය වන්න
7. Rbenv සහ ruby ​​ස්ථාපනය කරන්න
8. බණ්ඩලය ස්ථාපනය කිරීම
9. යෙදුම් කේතය උඩුගත කිරීම
10. Puma සේවාදායකය දියත් කිරීම

එපමණක් නොව, අවසාන අදියර capistrano භාවිතයෙන් සිදු කළ හැකිය, අවම වශයෙන් කොටුවෙන් පිටත එය නිකුතුවේ නාමාවලි වලට කේතය පිටපත් කළ හැකිය, සාර්ථක ලෙස යෙදවීම මත symlink සමඟ නිකුතුව මාරු කළ හැකිය, හවුල් නාමාවලියකින් වින්‍යාස පිටපත් කිරීම, puma නැවත ආරම්භ කිරීම යනාදිය. මේ සියල්ල Ansible භාවිතයෙන් කළ හැකිය, නමුත් ඇයි?

ගොනු ව්යුහය

ඇන්සිබල් දැඩි ඇත ගොනු ව්යුහය ඔබගේ සියලුම ගොනු සඳහා, එබැවින් ඒ සියල්ල වෙනම නාමාවලියක තබා ගැනීම වඩාත් සුදුසුය. එපමණක් නොව, එය රේල් පීලි යෙදුම තුළම තිබේද, නැතහොත් වෙන වෙනම තිබේද යන්න එතරම් වැදගත් නොවේ. ඔබට ගොනු වෙනම git ගබඩාවක ගබඩා කළ හැකිය. පුද්ගලිකව, රේල් යෙදුමේ / config බහලුම තුළ ansible බහලුම නිර්මාණය කිරීම සහ එක් ගබඩාවක සියල්ල ගබඩා කිරීම වඩාත් පහසු බව මට පෙනී ගියේය.

සරල Playbook

Playbook යනු yml ගොනුවක් වන අතර එය විශේෂ වාක්‍ය ඛණ්ඩ භාවිතා කරමින් Ansible කළ යුතු දේ සහ කෙසේද යන්න විස්තර කරයි. කිසිවක් නොකරන පළමු ක්‍රීඩා පොත නිර්මාණය කරමු:

---
- name: Simple playbook
  hosts: all

මෙන්න අපි සරලව කියනවා අපේ playbook කියලා Simple Playbook සහ එහි අන්තර්ගතය සියලුම ධාරක සඳහා ක්‍රියාත්මක කළ යුතු බව. අපට එය /ansible නාමාවලියෙහි නම සමඟ සුරැකිය හැක playbook.yml සහ ධාවනය කිරීමට උත්සාහ කරන්න:

ansible-playbook ./playbook.yml

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

ඇන්සිබල් පවසන්නේ එය සියලුම ලැයිස්තුවට ගැලපෙන කිසිදු සත්කාරක සමාගමක් නොදන්නා බවයි. ඒවා විශේෂ ලෙස ලැයිස්තුගත කළ යුතුය ඉන්වෙන්ටරි ගොනුව.

අපි එය එකම ansible බහලුම තුළ නිර්මාණය කරමු:

123.123.123.123

අපි සරලව ධාරකය (පරීක්ෂා කිරීම සඳහා අපගේ VPS හි ධාරකය, නැතහොත් ඔබට දේශීය සත්කාරක ලියාපදිංචි කළ හැක) සහ එය නම යටතේ සුරකින්න. inventory.
ඔබට ඉන්වෙන්ටරි ගොනුවක් සමඟ ඇන්සිබල් ධාවනය කිරීමට උත්සාහ කළ හැකිය:

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

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

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

ඔබට නිශ්චිත ධාරකයට ssh ප්‍රවේශය තිබේ නම්, ansible සම්බන්ධ වී දුරස්ථ පද්ධතිය පිළිබඳ තොරතුරු රැස් කරයි. (පෙරනිමි කාර්යය [එකතු කිරීමේ කරුණු]) ඉන්පසු එය ක්‍රියාත්මක කිරීම පිළිබඳ කෙටි වාර්තාවක් ලබා දෙනු ඇත (PLAY RECAP).

පෙරනිමියෙන්, සම්බන්ධතාවය ඔබ පද්ධතියට ලොග් වී ඇති පරිශීලක නාමය භාවිතා කරයි. එය බොහෝ විට ධාරකයෙහි නොසිටිනු ඇත. playbook ගොනුව තුළ, remote_user විධානය භාවිතයෙන් සම්බන්ධ වීමට කුමන පරිශීලකයා භාවිතා කළ යුතුද යන්න ඔබට සඳහන් කළ හැක. එසේම, දුරස්ථ පද්ධතියක් පිළිබඳ තොරතුරු ඔබට බොහෝ විට අනවශ්ය විය හැකි අතර එය එකතු කිරීමට කාලය නාස්ති නොකළ යුතුය. මෙම කාර්යය ද අබල කළ හැක:

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

Playbook නැවත ධාවනය කිරීමට උත්සාහ කර සම්බන්ධතාවය ක්‍රියා කරන බවට වග බලා ගන්න. (ඔබ මූල පරිශීලකයා සඳහන් කළේ නම්, උසස් අයිතීන් ලබා ගැනීම සඳහා ඔබ බවට පත් වීම: සත්‍ය විධානයද සඳහන් කළ යුතුය. ලේඛනයේ ලියා ඇති පරිදි: become set to ‘true’/’yes’ to activate privilege escalation. එයට හේතුව සම්පූර්ණයෙන්ම පැහැදිලි නැතත්).

සමහර විට ඔබට පයිතන් පරිවර්තකය තීරණය කළ නොහැකි නිසා ඔබට දෝෂයක් ලැබෙනු ඇත, එවිට ඔබට එය අතින් නියම කළ හැකිය:

ansible_python_interpreter: /usr/bin/python3 

ඔබට python ඇත්තේ කොතැනද යන්න විධානය මඟින් සොයා ගත හැක whereis python.

පද්ධති පැකේජ ස්ථාපනය කිරීම

ඇන්සිබල් හි සම්මත බෙදාහැරීමේ විවිධ පද්ධති පැකේජ සමඟ වැඩ කිරීම සඳහා බොහෝ මොඩියුල ඇතුළත් වේ, එබැවින් අපට කිසිදු හේතුවක් නිසා බාෂ් ස්ක්‍රිප්ට් ලිවීමට අවශ්‍ය නොවේ. දැන් අපට පද්ධතිය යාවත්කාලීන කිරීමට සහ පද්ධති පැකේජ ස්ථාපනය කිරීමට මෙම මොඩියුල වලින් එකක් අවශ්‍ය වේ. මගේ VPS මත Ubuntu Linux ඇත, එබැවින් මම භාවිතා කරන පැකේජ ස්ථාපනය කිරීමට 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 පැකේජය අවශ්‍ය වන බව කරුණාවෙන් සලකන්න. නැවතත්, ඔබ මෙය දැනගෙන එය කළ යුතුය; ඇසිබල් විසින්ම මෙය නොකරනු ඇත.

Playbook නැවත ධාවනය කර පැකේජ ස්ථාපනය කර ඇත්දැයි පරීක්ෂා කරන්න.

නව පරිශීලකයින් නිර්මාණය කිරීම.

පරිශීලකයන් සමඟ වැඩ කිරීමට, ඇන්සිබල්ට මොඩියුලයක් ද ඇත - පරිශීලක. අපි තවත් එක් කාර්යයක් එකතු කරමු (මම ක්‍රීඩා පොතේ දැනටමත් දන්නා කොටස් සෑම විටම සම්පූර්ණයෙන්ම පිටපත් නොකිරීමට අදහස් පිටුපස සඟවා තැබුවෙමි):

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

අපි නව පරිශීලකයෙකු නිර්මාණය කරමු, ඒ සඳහා ෂෙල් එකක් සහ මුරපදයක් සකසන්න. ඊට පස්සේ අපි ගැටළු කිහිපයකට මුහුණ දෙනවා. විවිධ සත්කාරක සඳහා පරිශීලක නාම වෙනස් විය යුතු නම් කුමක් කළ යුතුද? ඒවගේම Playbook හි මුරපදය පැහැදිලි අකුරු වල ගබඩා කිරීම ඉතා නරක අදහසකි. ආරම්භ කිරීම සඳහා, අපි පරිශීලක නාමය සහ මුරපදය විචල්‍යවලට දමමු, සහ ලිපියේ අවසානයේ මුරපදය සංකේතනය කරන්නේ කෙසේදැයි මම පෙන්වන්නම්.

---
- 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') }}". කාරණය වන්නේ ඇන්සිබල් හරහා පරිශීලකයා ස්ථාපනය නොකිරීමයි user_add ඔබ එය අතින් කරනවා වගේ. තවද එය සියලුම දත්ත කෙලින්ම සුරකියි, ඒ නිසා අපි මුරපදය හෑෂ් එකක් බවට පෙරළා පරිවර්තනය කළ යුතුය, මෙම විධානය කරන්නේ එයයි.

අපි අපේ පරිශීලකයා 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/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

දැන් අපට ගොනු සහ සැකිලි අවශ්යයි. ඒවා අතර ඇති වෙනස නම් ඇසිබල් ගොනු කෙලින්ම පිටපත් කිරීමයි. සහ සැකිලි වල j2 දිගුව තිබිය යුතු අතර ඒවාට එකම ද්විත්ව කැරලි වරහන් භාවිතයෙන් විචල්‍ය අගයන් භාවිතා කළ හැක.

අපි nginx in enable කරමු main.yml ගොනුව. මේ සඳහා අපට systemd මොඩියුලයක් ඇත:

# 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 නාමාවලියෙහි අපගේ යෙදුම සඳහා වින්‍යාස ගොනුව (මෙය අවශ්‍ය නොවන නමුත් ප්‍රයෝජනවත් වේ). පළමු අවස්ථාවේදී, අපි ගොනු පිටපත් කිරීමට පිටපත් මොඩියුලය භාවිතා කරමු (ගොනුව තිබිය යුතුය /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 configs වලද වේ. {{ inventory_hostname }} ඉන්වෙන්ටරි ගොනුවේ සඳහන් කිරීමට අවශ්ය නොවේ - මෙය විශේෂ ansible විචල්‍යය සහ playbook දැනට ක්‍රියාත්මක වන ධාරකය එහි ගබඩා කර ඇත.
ඔබට සත්කාරක කිහිපයක් සඳහා ඉන්වෙන්ටරි ගොනුවක් තබා ගැනීමට අවශ්‍ය නම්, නමුත් එක් කණ්ඩායමක් සඳහා පමණක් ක්‍රියාත්මක වේ නම්, මෙය පහත විධානය සමඟ කළ හැකිය:

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

තවත් විකල්පයක් වන්නේ විවිධ කණ්ඩායම් සඳහා වෙනම ඉන්වෙන්ටරි ගොනු තිබීමයි. නැතහොත් ඔබට විවිධ ධාරක තිබේ නම් ඔබට ප්‍රවේශ දෙක ඒකාබද්ධ කළ හැකිය.

අපි නැවතත් nginx පිහිටුවීමට යමු. වින්‍යාස ගොනු පිටපත් කිරීමෙන් පසුව, sites_available වෙතින් my_app.conf වෙත sitest_enabled හි symlink එකක් සෑදිය යුතුය. සහ 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

මෙහි සෑම දෙයක්ම සරලයි - නැවතත් තරමක් සම්මත වාක්‍ය ඛණ්ඩයක් සහිත ඇසිබල් මොඩියුල. නමුත් එක් කරුණක් තිබේ. සෑම විටම nginx නැවත ආරම්භ කිරීමෙන් පලක් නැත. අපි මෙවැනි විධාන ලියන්නේ නැති බව ඔබ දැක තිබේද: “මෙය මේ ආකාරයට කරන්න”, වාක්‍ය ඛණ්ඩය “මෙයට මෙම තත්වය තිබිය යුතුය” ලෙස පෙනේ. බොහෝ විට මෙය හරියටම ඇන්සිබල් ක්‍රියා කරන ආකාරයයි. කණ්ඩායම දැනටමත් පවතී නම් හෝ පද්ධති පැකේජය දැනටමත් ස්ථාපනය කර ඇත්නම්, ඇන්සිබල් මෙය පරීක්ෂා කර කාර්යය මඟ හරිනු ඇත. එසේම, ගොනු දැනටමත් සේවාදායකයේ ඇති දේට සම්පූර්ණයෙන්ම ගැලපේ නම් ඒවා පිටපත් නොකෙරේ. අපිට මේකෙන් ප්‍රයෝජනයක් අරන් nginx එක Restart කරන්න පුළුවන් configuration files වෙනස් කරලා තිබ්බොත් විතරයි. මේ සඳහා ලියාපදිංචි විධානයක් ඇත:

# 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 පිහිටුවීම

අපි nginx සමඟ කළ ආකාරයටම systemd භාවිතයෙන් postgresql සක්‍රීය කළ යුතු අතර, දත්ත සමුදායට සහ දත්ත සමුදායට ප්‍රවේශ වීමට අප භාවිතා කරන පරිශීලකයෙකු නිර්මාණය කළ යුතුය.
අපි භූමිකාවක් නිර්මාණය කරමු /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 config එක වෙනස් කළ ආකාරයටම මෙය කළ හැකිය.

ඇත්ත වශයෙන්ම, ඔබ ප්‍රධාන ක්‍රීඩා පොතට postgresql භූමිකාව එක් කළ යුතුය.

Rbenv හරහා රූබි ස්ථාපනය කිරීම

Ansible සතුව rbenv සමඟ වැඩ කිරීම සඳහා මොඩියුල නොමැත, නමුත් එය ස්ථාපනය කර ඇත්තේ git ගබඩාවක් ක්ලෝන කිරීමෙනි. එමනිසා, මෙම ගැටළුව වඩාත්ම සම්මත නොවන එකක් බවට පත්වේ. අපි ඇය වෙනුවෙන් භූමිකාවක් නිර්මාණය කරමු /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

මෙම අරමුණු සඳහා අප විසින් නිර්මාණය කරන ලද පරිශීලකයා යටතේ ක්‍රියා කිරීමට අපි නැවතත් බවට_පරිශීලක විධානය භාවිතා කරමු. Rbenv එහි මුල් නාමාවලියෙහි ස්ථාපනය කර ඇති බැවින් ගෝලීය වශයෙන් නොවේ. තවද අපි repo සහ dest සඳහන් කරමින් ගබඩාව ක්ලෝන කිරීමට git මොඩියුලය භාවිතා කරමු.

මීළඟට, අපි bashrc හි rbenv init ලියාපදිංචි කර එහි PATH වෙත rbenv එකතු කළ යුතුය. මේ සඳහා අපට 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 එකම ස්ක්‍රිප්ට් එකකින් කෙලින්ම අර්ථ දැක්විය යුතු බවයි.

ඊළඟ ගැටලුව වන්නේ shell විධානයට ප්‍රතිවිරෝධී දෘෂ්ටි කෝණයකින් කිසිදු තත්වයක් නොමැති වීමයි. එනම්, මෙම රූබි අනුවාදය ස්ථාපනය කර තිබේද නැද්ද යන්න ස්වයංක්‍රීයව පරීක්ෂා කිරීමක් සිදු නොවේ. අපට මෙය තනිවම කළ හැකිය:

- 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

ඉතිරිව ඇත්තේ බණ්ඩලය ස්ථාපනය කිරීම පමණි:

- 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 ස්වයංක්‍රීයව මාපිය ඒවා සාදනු ඇත.

ඇන්සිබල් වෝල්ට්

විචල්‍යයන් පරිශීලකයාගේ මුරපදය වැනි රහස් දත්ත අඩංගු විය හැකි බව අපි දැනටමත් සොයාගෙන ඇත. ඔබ නිර්මාණය කර ඇත්නම් .env අයදුම්පත සඳහා ගොනුව, සහ database.yml එවිට තවත් එවැනි විවේචනාත්මක දත්ත තිබිය යුතුය. සෝදිසියෙන් සිටින ඇස්වලින් ඔවුන් සැඟවීමට හොඳ වනු ඇත. මෙම කාර්යය සඳහා එය භාවිතා වේ ansible සුරක්ෂිතාගාරය.

අපි විචල්‍ය සඳහා ගොනුවක් සාදා ගනිමු /ansible/vars/all.yml (මෙහිදී ඔබට ඉන්වෙන්ටරි ගොනුවේ මෙන් විවිධ ධාරක කණ්ඩායම් සඳහා විවිධ ගොනු සෑදිය හැක: production.yml, staging.yml, etc).
සංකේතනය කළ යුතු සියලුම විචල්‍යයන් සම්මත 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 විසින් මුරපදය ඉල්ලා, විචල්‍යයන් ලබාගෙන, සහ කාර්යයන් ක්‍රියාත්මක කරනු ඇත. සියලුම දත්ත සංකේතාත්මකව පවතිනු ඇත.

ධාරක කණ්ඩායම් කිහිපයක් සහ ඇසිබල් වෝල්ට් සඳහා සම්පූර්ණ විධානය මේ වගේ දෙයක් පෙනෙනු ඇත:

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

නමුත් මම ඔබට සෙල්ලම් පොත් සහ භූමිකාවන්හි සම්පූර්ණ පාඨය ලබා නොදෙමි, එය ඔබම ලියන්න. Ansible ඒ වගේ නිසා - ඔබ කළ යුතු දේ තේරුම් නොගන්නේ නම්, එය ඔබ වෙනුවෙන් එය නොකරනු ඇත.

මූලාශ්රය: www.habr.com