🥇Ansible |ஐப் பயன்படுத்தி ரெயில்ஸ் அப்ளிகேஷனை வரிசைப்படுத்த சர்வரை அமைத்தல் ProHoster

ரெயில்ஸ் அப்ளிகேஷனை வரிசைப்படுத்துவதற்கு சர்வரை தயார் செய்ய நான் பல அன்சிபிள் பிளேபுக்குகளை எழுத வேண்டியிருந்தது. மேலும், ஆச்சரியப்படும் விதமாக, நான் ஒரு எளிய படிப்படியான கையேட்டைக் கண்டுபிடிக்கவில்லை. என்ன நடக்கிறது என்பதைப் புரிந்து கொள்ளாமல் வேறொருவரின் பிளேபுக்கை நகலெடுக்க நான் விரும்பவில்லை, இறுதியில் எல்லாவற்றையும் நானே சேகரித்து ஆவணங்களைப் படிக்க வேண்டியிருந்தது. இந்த கட்டுரையின் உதவியுடன் இந்த செயல்முறையை விரைவுபடுத்த யாராவது உதவலாம்.

புரிந்து கொள்ள வேண்டிய முதல் விஷயம் என்னவென்றால், SSH வழியாக ரிமோட் சர்வரில் (களில்) செயல்களின் முன் வரையறுக்கப்பட்ட பட்டியலைச் செய்ய அன்சிபிள் உங்களுக்கு வசதியான இடைமுகத்தை வழங்குகிறது. இங்கே எந்த மந்திரமும் இல்லை, நீங்கள் ஒரு செருகுநிரலை நிறுவ முடியாது மற்றும் டோக்கர், கண்காணிப்பு மற்றும் பிற இன்னபிற பொருட்களுடன் உங்கள் பயன்பாட்டை பூஜ்ஜியமாக பயன்படுத்த முடியாது. ஒரு விளையாட்டு புத்தகத்தை எழுதுவதற்கு, நீங்கள் சரியாக என்ன செய்ய விரும்புகிறீர்கள், எப்படி செய்ய வேண்டும் என்பதை நீங்கள் அறிந்திருக்க வேண்டும். அதனால்தான், GitHub இன் ஆயத்த விளையாட்டு புத்தகங்கள் அல்லது "நகலெடு செய்து இயக்கவும், அது வேலை செய்யும்" போன்ற கட்டுரைகளில் எனக்கு திருப்தி இல்லை.

நமக்கு என்ன தேவை?

நான் ஏற்கனவே கூறியது போல், ஒரு நாடக புத்தகத்தை எழுத, நீங்கள் என்ன செய்ய விரும்புகிறீர்கள், எப்படி செய்ய வேண்டும் என்பதை நீங்கள் அறிந்து கொள்ள வேண்டும். நமக்கு என்ன தேவை என்பதை முடிவு செய்வோம். ரெயில்ஸ் பயன்பாட்டிற்கு நமக்கு பல சிஸ்டம் பேக்கேஜ்கள் தேவைப்படும்: nginx, postgresql (redis, etc). கூடுதலாக, எங்களுக்கு ரூபியின் ஒரு குறிப்பிட்ட பதிப்பு தேவை. rbenv (rvm, asdf...) வழியாக நிறுவுவது சிறந்தது. இதையெல்லாம் ரூட் பயனராக இயக்குவது எப்போதுமே தவறான யோசனையாகும், எனவே நீங்கள் ஒரு தனி பயனரை உருவாக்கி அவருடைய உரிமைகளை உள்ளமைக்க வேண்டும். இதற்குப் பிறகு, நீங்கள் எங்கள் குறியீட்டை சேவையகத்தில் பதிவேற்ற வேண்டும், nginx, postgres போன்றவற்றிற்கான configs ஐ நகலெடுத்து இந்த சேவைகள் அனைத்தையும் தொடங்க வேண்டும்.

இதன் விளைவாக, செயல்களின் வரிசை பின்வருமாறு:

ரூட்டாக உள்நுழைக
கணினி தொகுப்புகளை நிறுவவும்
புதிய பயனரை உருவாக்கவும், உரிமைகளை உள்ளமைக்கவும், ssh விசை
கணினி தொகுப்புகளை (nginx போன்றவை) கட்டமைத்து அவற்றை இயக்கவும்
தரவுத்தளத்தில் ஒரு பயனரை உருவாக்குகிறோம் (நீங்கள் உடனடியாக ஒரு தரவுத்தளத்தை உருவாக்கலாம்)
புதிய பயனராக உள்நுழைக
rbenv மற்றும் ruby ஐ நிறுவவும்
தொகுப்பை நிறுவுதல்
பயன்பாட்டுக் குறியீட்டைப் பதிவேற்றுகிறது
பூமா சேவையகத்தை துவக்குகிறது

மேலும், கேபிஸ்ட்ரானோவைப் பயன்படுத்தி கடைசி கட்டங்களைச் செய்யலாம், குறைந்தபட்சம் பெட்டிக்கு வெளியே குறியீட்டை வெளியீட்டு கோப்பகங்களில் நகலெடுக்கலாம், வெற்றிகரமான வரிசைப்படுத்தலின் போது வெளியீட்டை சிம்லிங்க் மூலம் மாற்றலாம், பகிரப்பட்ட கோப்பகத்திலிருந்து கட்டமைப்புகளை நகலெடுக்கலாம், பூமாவை மறுதொடக்கம் செய்யலாம். அன்சிபிளைப் பயன்படுத்தி இதையெல்லாம் செய்யலாம், ஆனால் ஏன்?

கோப்பு அமைப்பு

அன்சிபிள் கண்டிப்பானது கோப்பு அமைப்பு உங்கள் எல்லா கோப்புகளுக்கும், அதை தனித்தனி கோப்பகத்தில் வைத்திருப்பது சிறந்தது. மேலும், இது தண்டவாள பயன்பாட்டில் உள்ளதா அல்லது தனித்தனியாக இருக்குமா என்பது அவ்வளவு முக்கியமல்ல. நீங்கள் கோப்புகளை ஒரு தனி ஜிட் களஞ்சியத்தில் சேமிக்கலாம். தனிப்பட்ட முறையில், ரெயில்ஸ் பயன்பாட்டின் / config கோப்பகத்தில் ஒரு அன்சிபிள் கோப்பகத்தை உருவாக்குவது மற்றும் எல்லாவற்றையும் ஒரே களஞ்சியத்தில் சேமிப்பது மிகவும் வசதியானது.

எளிய விளையாட்டு புத்தகம்

Playbook என்பது ஒரு yml கோப்பாகும், இது சிறப்பு தொடரியல் பயன்படுத்தி, அன்சிபிள் என்ன செய்ய வேண்டும், எப்படி செய்ய வேண்டும் என்பதை விவரிக்கிறது. எதுவும் செய்யாத முதல் பிளேபுக்கை உருவாக்குவோம்:

---
- name: Simple playbook
  hosts: all

இங்கே நாம் வெறுமனே எங்கள் நாடக புத்தகம் என்று சொல்கிறோம் Simple Playbook மற்றும் அதன் உள்ளடக்கங்கள் அனைத்து ஹோஸ்ட்களுக்கும் செயல்படுத்தப்பட வேண்டும். பெயருடன் /ansible கோப்பகத்தில் சேமிக்கலாம் playbook.yml மற்றும் இயக்க முயற்சிக்கவும்:

ansible-playbook ./playbook.yml

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

அனைத்து பட்டியலுக்கும் பொருந்தக்கூடிய எந்த ஹோஸ்ட்களும் தனக்குத் தெரியாது என்று அன்சிபிள் கூறுகிறது. அவர்கள் ஒரு சிறப்பு பட்டியலில் பட்டியலிடப்பட வேண்டும் சரக்கு கோப்பு.

அதை அதே அன்சிபிள் கோப்பகத்தில் உருவாக்குவோம்:

123.123.123.123

இப்படித்தான் நாங்கள் ஹோஸ்டைக் குறிப்பிடுகிறோம் (சோதனைக்கான எங்கள் VPS இன் ஹோஸ்ட் அல்லது நீங்கள் லோக்கல் ஹோஸ்டைப் பதிவு செய்யலாம்) மற்றும் அதை பெயரில் சேமிக்கவும் inventory.
இன்வெட்டரி கோப்புடன் அன்சிபிளை இயக்க முயற்சி செய்யலாம்:

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

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

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

குறிப்பிட்ட ஹோஸ்டுக்கான ssh அணுகல் உங்களிடம் இருந்தால், தொலைநிலை அமைப்பைப் பற்றிய தகவலை ansible இணைத்து சேகரிக்கும். (Default TASK [Gathering Facts]) அதன் பிறகு அது செயல்படுத்துவது பற்றிய ஒரு சிறிய அறிக்கையை அளிக்கும் (PLAY RECAP).

இயல்பாக, நீங்கள் கணினியில் உள்நுழைந்துள்ள பயனர்பெயரை இணைப்பு பயன்படுத்துகிறது. இது பெரும்பாலும் ஹோஸ்டில் இருக்காது. பிளேபுக் கோப்பில், remote_user கட்டளையைப் பயன்படுத்தி இணைக்க எந்தப் பயனரைப் பயன்படுத்த வேண்டும் என்பதைக் குறிப்பிடலாம். மேலும், ரிமோட் சிஸ்டம் பற்றிய தகவல்கள் உங்களுக்கு பெரும்பாலும் தேவையற்றதாக இருக்கலாம், அதைச் சேகரிப்பதில் நேரத்தை வீணடிக்க வேண்டாம். இந்த பணியும் முடக்கப்படலாம்:

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

பிளேபுக்கை மீண்டும் இயக்க முயற்சிக்கவும் மற்றும் இணைப்பு செயல்படுகிறதா என்பதை உறுதிப்படுத்தவும். (நீங்கள் ரூட் பயனரைக் குறிப்பிட்டிருந்தால், உயர்ந்த உரிமைகளைப் பெறுவதற்கு, ஆக: உண்மை கட்டளையையும் குறிப்பிட வேண்டும். ஆவணத்தில் எழுதப்பட்டபடி: become set to ‘true’/’yes’ to activate privilege escalation. ஏன் என்பது முற்றிலும் தெளிவாக இல்லை என்றாலும்).

பைதான் மொழிபெயர்ப்பாளரை அன்சிபிள் தீர்மானிக்க முடியாததால் ஏற்படும் பிழையை நீங்கள் பெறுவீர்கள், பின்னர் நீங்கள் அதை கைமுறையாக குறிப்பிடலாம்:

ansible_python_interpreter: /usr/bin/python3

பைதான் எங்குள்ளது என்பதை கட்டளை மூலம் கண்டறியலாம் 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

டாஸ்க் என்பது ரிமோட் சர்வர்களில் அன்சிபிள் செய்யும் பணியாகும். பணிக்கு ஒரு பெயரைக் கொடுக்கிறோம், இதன் மூலம் அதன் செயல்பாட்டை பதிவில் கண்காணிக்க முடியும். ஒரு குறிப்பிட்ட தொகுதியின் தொடரியல் பயன்படுத்தி, அது என்ன செய்ய வேண்டும் என்பதை நாங்கள் விவரிக்கிறோம். இந்த வழக்கில் apt: update_cache=yes - apt தொகுதியைப் பயன்படுத்தி கணினி தொகுப்புகளைப் புதுப்பிக்கச் சொல்கிறது. இரண்டாவது கட்டளை இன்னும் கொஞ்சம் சிக்கலானது. நாங்கள் தொகுப்புகளின் பட்டியலை apt தொகுதிக்கு அனுப்பி, அவை உள்ளன என்று கூறுகிறோம் state ஆக வேண்டும் present, அதாவது, இந்த தொகுப்புகளை நிறுவுகிறோம். அதே வழியில், அவற்றை நீக்கச் சொல்லலாம் அல்லது மாற்றுவதன் மூலம் அவற்றைப் புதுப்பிக்கலாம் state. postgresql உடன் தண்டவாளங்கள் வேலை செய்ய, நாம் இப்போது நிறுவும் postgresql-contrib தொகுப்பு தேவை என்பதை நினைவில் கொள்ளவும். மீண்டும், நீங்கள் இதைத் தெரிந்து கொள்ள வேண்டும் மற்றும் செய்ய வேண்டும்; சொந்தமாக அன்சிபிள் இதைச் செய்யாது.

பிளேபுக்கை மீண்டும் இயக்க முயற்சிக்கவும் மற்றும் தொகுப்புகள் நிறுவப்பட்டுள்ளதா என சரிபார்க்கவும்.

புதிய பயனர்களை உருவாக்குதல்.

பயனர்களுடன் பணிபுரிய, அன்சிபில் ஒரு தொகுதி உள்ளது - பயனர். இன்னும் ஒரு பணியைச் சேர்ப்போம் (பிளேபுக்கின் ஏற்கனவே அறியப்பட்ட பகுதிகளை ஒவ்வொரு முறையும் முழுவதுமாக நகலெடுக்காதபடி கருத்துகளுக்குப் பின்னால் மறைத்துவிட்டேன்):

---
- 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') }}". விஷயம் என்னவென்றால், அன்சிபிள் மூலம் பயனரை நிறுவவில்லை 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"

எல்லாம் மிகவும் எளிமையானது, எங்களிடம் குழுக்களை உருவாக்குவதற்கான ஒரு குழு தொகுதி உள்ளது, இது ஒரு தொடரியல் பொருத்தமானது. இந்த குழுவை பயனரிடம் பதிவு செய்தால் போதும் (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 ஐ இயக்குவோம் 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 }} — இவை அனைத்தும் மாறிகள் ஆகும், அதன் மதிப்புகளை நகலெடுப்பதற்கு முன் அன்சிபிள் டெம்ப்ளேட்டில் மாற்றும். ஹோஸ்ட்களின் வெவ்வேறு குழுக்களுக்கு பிளேபுக்கைப் பயன்படுத்தினால் இது பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, எங்கள் சரக்குக் கோப்பைச் சேர்க்கலாம்:

[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-playbook -i inventory ./playbook.yml -l "staging"

வெவ்வேறு குழுக்களுக்கு தனித்தனி சரக்கு கோப்புகளை வைத்திருப்பது மற்றொரு விருப்பம். அல்லது உங்களிடம் பல்வேறு ஹோஸ்ட்கள் இருந்தால் இரண்டு அணுகுமுறைகளையும் இணைக்கலாம்.

nginx ஐ அமைப்பதற்கு திரும்புவோம். உள்ளமைவு கோப்புகளை நகலெடுத்த பிறகு, sites_available இலிருந்து my_app.conf க்கு sitest_enabled இல் ஒரு சிம்லிங்கை உருவாக்க வேண்டும். மற்றும் 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 ஐ மறுதொடக்கம் செய்ய முடியும். இதற்கான பதிவு உத்தரவு உள்ளது:

# 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 கட்டமைப்பை மாற்றியதைப் போலவே இதைச் செய்யலாம்.

நிச்சயமாக, நீங்கள் முக்கிய பிளேபுக்கில் 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 அதன் முகப்பு கோப்பகத்தில் நிறுவப்பட்டிருப்பதால், உலகளவில் இல்லை. ரெப்போ மற்றும் டெஸ்டைக் குறிப்பிடுவதன் மூலம், களஞ்சியத்தை குளோன் செய்ய ஜிட் தொகுதியைப் பயன்படுத்துகிறோம்.

அடுத்து, 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

இறுதியாக ரூபியை நிறுவவும். இது rbenv மூலம் செய்யப்படுகிறது, அதாவது பாஷ் கட்டளை மூலம்:

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

எந்த கட்டளையை எதனுடன் செயல்படுத்த வேண்டும் என்று நாங்கள் கூறுகிறோம். இருப்பினும், கட்டளைகளை இயக்குவதற்கு முன், bashrc இல் உள்ள குறியீட்டை ansible இயக்காது என்ற உண்மையை இங்கு காண்கிறோம். இதன் பொருள் rbenv அதே ஸ்கிரிப்ட்டில் நேரடியாக வரையறுக்கப்பட வேண்டும்.

அடுத்த பிரச்சனை ஷெல் கட்டளைக்கு எந்த நிலையும் இல்லை என்பதன் காரணமாகும். அதாவது, ரூபியின் இந்த பதிப்பு நிறுவப்பட்டுள்ளதா இல்லையா என்பதை தானாக சரிபார்க்க முடியாது. இதை நாமே செய்யலாம்:

- 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 ஐ முக்கிய நாடக புத்தகத்தில் சேர்க்கவும்.

பகிரப்பட்ட கோப்புகள்.

பொதுவாக, அமைப்பை இங்கே முடிக்க முடியும். அடுத்து, எஞ்சியிருப்பது கேபிஸ்ட்ரானோவை இயக்குவது மட்டுமே, அது குறியீட்டை நகலெடுத்து, தேவையான கோப்பகங்களை உருவாக்கி பயன்பாட்டைத் தொடங்கும் (எல்லாம் சரியாக உள்ளமைக்கப்பட்டிருந்தால்). இருப்பினும், கேபிஸ்ட்ரானோவிற்கு அடிக்கடி கூடுதல் உள்ளமைவு கோப்புகள் தேவை database.yml அல்லது .env nginx க்கான கோப்புகள் மற்றும் டெம்ப்ளேட்களைப் போலவே அவை நகலெடுக்கப்படலாம். ஒரே ஒரு நுணுக்கம் உள்ளது. கோப்புகளை நகலெடுப்பதற்கு முன், நீங்கள் அவற்றுக்கான கோப்பக கட்டமைப்பை உருவாக்க வேண்டும், இது போன்றது:

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

நாங்கள் ஒரே ஒரு கோப்பகத்தை மட்டுமே குறிப்பிடுகிறோம், தேவைப்பட்டால், அன்சிபிள் தானாகவே பெற்றோரை உருவாக்கும்.

அன்சிபிள் வால்ட்

மாறிகள் பயனரின் கடவுச்சொல் போன்ற ரகசியத் தரவைக் கொண்டிருக்கலாம் என்ற உண்மையை நாங்கள் ஏற்கனவே அறிந்திருக்கிறோம். நீங்கள் உருவாக்கியிருந்தால் .env விண்ணப்பத்திற்கான கோப்பு, மற்றும் database.yml அப்படியானால் இன்னும் கூடுதலான முக்கியமான தரவுகள் இருக்க வேண்டும். துருவியறியும் கண்களிலிருந்து அவற்றை மறைப்பது நல்லது. இந்த நோக்கத்திற்காக இது பயன்படுத்தப்படுகிறது முதுகு பெட்டகம்.

மாறிகளுக்கு ஒரு கோப்பை உருவாக்குவோம் /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-playbook -i inventory ./playbook.yml -l "staging" --ask-vault-pass

ஆனால் நாடக புத்தகங்கள் மற்றும் பாத்திரங்களின் முழு உரையை நான் உங்களுக்கு கொடுக்க மாட்டேன், அதை நீங்களே எழுதுங்கள். ஏனெனில் அன்சிபிள் அப்படித்தான் - என்ன செய்ய வேண்டும் என்று உங்களுக்குப் புரியவில்லை என்றால், அது உங்களுக்காகச் செய்யாது.

ஆதாரம்: www.habr.com

Ansible ஐப் பயன்படுத்தி ரெயில்ஸ் பயன்பாட்டை வரிசைப்படுத்த ஒரு சேவையகத்தை அமைத்தல்