Ansible નો ઉપયોગ કરીને રેલ્સ એપ્લિકેશનને જમાવવા માટે સર્વર સેટ કરવું

થોડા સમય પહેલા મને રેલ્સ એપ્લિકેશન જમાવવા માટે સર્વરને તૈયાર કરવા માટે ઘણી જવાબી પ્લેબુક લખવાની જરૂર હતી. અને, આશ્ચર્યજનક રીતે, મને એક સરળ પગલું દ્વારા પગલું માર્ગદર્શિકા મળી નથી. શું થઈ રહ્યું છે તે સમજ્યા વિના હું કોઈ બીજાની પ્લેબુકની નકલ કરવા માંગતો ન હતો, અને અંતે મારે બધું જાતે એકત્રિત કરીને દસ્તાવેજો વાંચવા પડ્યા. કદાચ હું આ લેખની મદદથી આ પ્રક્રિયાને ઝડપી બનાવવા માટે કોઈને મદદ કરી શકું.

સમજવા માટેની પ્રથમ વસ્તુ એ છે કે જવાબી એ તમને SSH મારફતે રીમોટ સર્વર(ઓ) પર ક્રિયાઓની પૂર્વવ્યાખ્યાયિત સૂચિ કરવા માટે અનુકૂળ ઇન્ટરફેસ પ્રદાન કરે છે. અહીં કોઈ જાદુ નથી, તમે પ્લગઇન ઇન્સ્ટોલ કરી શકતા નથી અને ડોકર, મોનિટરિંગ અને બૉક્સની બહારની અન્ય ગૂડીઝ સાથે તમારી એપ્લિકેશનનો શૂન્ય ડાઉનટાઇમ જમાવટ મેળવી શકતા નથી. પ્લેબુક લખવા માટે, તમારે જાણવું જોઈએ કે તમે બરાબર શું કરવા માંગો છો અને તે કેવી રીતે કરવું. તેથી જ હું GitHub તરફથી તૈયાર પ્લેબુક અથવા લેખોથી સંતુષ્ટ નથી જેમ કે: "કૉપિ કરો અને ચલાવો, તે કામ કરશે."

આપણને શું જોઈએ છે?

મેં પહેલેથી જ કહ્યું તેમ, પ્લેબુક લખવા માટે તમારે જાણવાની જરૂર છે કે તમે શું કરવા માંગો છો અને તે કેવી રીતે કરવું. ચાલો નક્કી કરીએ કે આપણને શું જોઈએ છે. રેલ્સ એપ્લિકેશન માટે અમને ઘણા સિસ્ટમ પેકેજોની જરૂર પડશે: nginx, postgresql (redis, વગેરે). વધુમાં, અમને રૂબીના ચોક્કસ સંસ્કરણની જરૂર છે. તેને rbenv (rvm, asdf...) દ્વારા ઇન્સ્ટોલ કરવું શ્રેષ્ઠ છે. રુટ વપરાશકર્તા તરીકે આ બધું ચલાવવું એ હંમેશા ખરાબ વિચાર છે, તેથી તમારે એક અલગ વપરાશકર્તા બનાવવાની અને તેના અધિકારોને ગોઠવવાની જરૂર છે. આ પછી, તમારે અમારો કોડ સર્વર પર અપલોડ કરવો પડશે, nginx, postgres, વગેરે માટે રૂપરેખાઓની નકલ કરવી પડશે અને આ બધી સેવાઓ શરૂ કરવી પડશે.

પરિણામે, ક્રિયાઓનો ક્રમ નીચે મુજબ છે:

1. રૂટ તરીકે લોગિન કરો
2. સિસ્ટમ પેકેજો સ્થાપિત કરો
3. નવો વપરાશકર્તા બનાવો, અધિકારો ગોઠવો, ssh કી
4. સિસ્ટમ પેકેજો (nginx વગેરે) રૂપરેખાંકિત કરો અને તેમને ચલાવો
5. અમે ડેટાબેઝમાં વપરાશકર્તા બનાવીએ છીએ (તમે તરત જ ડેટાબેઝ બનાવી શકો છો)
6. નવા વપરાશકર્તા તરીકે લોગિન કરો
7. rbenv અને ruby ​​ઇન્સ્ટોલ કરો
8. બંડલર ઇન્સ્ટોલ કરી રહ્યું છે
9. એપ્લિકેશન કોડ અપલોડ કરી રહ્યા છીએ
10. પુમા સર્વર લોંચ કરી રહ્યા છીએ

વધુમાં, છેલ્લા તબક્કાઓ કેપિસ્ટ્રાનોનો ઉપયોગ કરીને કરી શકાય છે, ઓછામાં ઓછા બૉક્સની બહાર તે કોડને રિલીઝ ડિરેક્ટરીઓમાં કૉપિ કરી શકે છે, સફળ જમાવટ પર સિમલિંક સાથે રિલીઝને સ્વિચ કરી શકે છે, શેર કરેલી ડિરેક્ટરીમાંથી કૉપિ કૉપિ કરી શકે છે, પ્યુમાને ફરીથી શરૂ કરી શકે છે, વગેરે. આ બધું Ansible નો ઉપયોગ કરીને કરી શકાય છે, પણ શા માટે?

ફાઇલ માળખું

Ansible કડક છે ફાઇલ માળખું તમારી બધી ફાઇલો માટે, તેથી તે બધું અલગ ડિરેક્ટરીમાં રાખવું શ્રેષ્ઠ છે. તદુપરાંત, તે એટલું મહત્વનું નથી કે તે રેલ્સ એપ્લિકેશનમાં જ હશે, અથવા અલગથી. તમે ફાઇલોને અલગ ગિટ રિપોઝીટરીમાં સ્ટોર કરી શકો છો. અંગત રીતે, મને રેલ્સ એપ્લીકેશનની /config ડાયરેક્ટરીમાં જવાબદાર ડિરેક્ટરી બનાવવી અને દરેક વસ્તુને એક રીપોઝીટરીમાં સંગ્રહિત કરવાનું સૌથી અનુકૂળ લાગ્યું.

સરળ પ્લેબુક

પ્લેબુક એ એક yml ફાઇલ છે જે, વિશિષ્ટ વાક્યરચનાનો ઉપયોગ કરીને, Ansible શું અને કેવી રીતે કરવું જોઈએ તેનું વર્ણન કરે છે. ચાલો પ્રથમ પ્લેબુક બનાવીએ જે કંઈ કરતું નથી:

---
- 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 ઍક્સેસ હોય, તો જવાબીબલ કનેક્ટ કરશે અને રીમોટ સિસ્ટમ વિશેની માહિતી એકત્રિત કરશે. (ડિફૉલ્ટ ટાસ્ક [ગેધરિંગ ફેક્ટ્સ]) જે પછી તે એક્ઝેક્યુશન પર ટૂંકી રિપોર્ટ આપશે (RECAP પ્લે કરો).

મૂળભૂત રીતે, જોડાણ એ વપરાશકર્તાનામનો ઉપયોગ કરે છે કે જેના હેઠળ તમે સિસ્ટમમાં લૉગ ઇન થયા છો. તે મોટે ભાગે હોસ્ટ પર રહેશે નહીં. પ્લેબુક ફાઇલમાં, તમે remote_user ડાયરેક્ટિવનો ઉપયોગ કરીને કનેક્ટ કરવા માટે કયા વપરાશકર્તાનો ઉપયોગ કરવો તેનો ઉલ્લેખ કરી શકો છો. ઉપરાંત, રિમોટ સિસ્ટમ વિશેની માહિતી તમારા માટે ઘણીવાર બિનજરૂરી હોઈ શકે છે અને તમારે તેને એકત્રિત કરવામાં સમય બગાડવો જોઈએ નહીં. આ કાર્યને અક્ષમ પણ કરી શકાય છે:

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

પ્લેબુકને ફરીથી ચલાવવાનો પ્રયાસ કરો અને ખાતરી કરો કે કનેક્શન કામ કરી રહ્યું છે. (જો તમે રૂટ યુઝરનો ઉલ્લેખ કર્યો છે, તો તમારે એલિવેટેડ અધિકારો મેળવવા માટે become: true ડાયરેક્ટિવ પણ સ્પષ્ટ કરવાની જરૂર છે. દસ્તાવેજીકરણમાં લખ્યા પ્રમાણે: become set to ‘true’/’yes’ to activate privilege escalation. જો કે તે શા માટે સંપૂર્ણપણે સ્પષ્ટ નથી).

કદાચ તમને એ હકીકતને કારણે ભૂલ પ્રાપ્ત થશે કે જવાબી પાયથોન દુભાષિયાને નિર્ધારિત કરી શકતું નથી, પછી તમે તેને જાતે જ સ્પષ્ટ કરી શકો છો:

ansible_python_interpreter: /usr/bin/python3 

તમે આદેશ વડે શોધી શકો છો કે તમારી પાસે પાયથોન ક્યાં છે whereis python.

સિસ્ટમ પેકેજો સ્થાપિત કરી રહ્યા છીએ

Ansible ના પ્રમાણભૂત વિતરણમાં વિવિધ સિસ્ટમ પેકેજો સાથે કામ કરવા માટે ઘણા મોડ્યુલોનો સમાવેશ થાય છે, તેથી અમારે કોઈપણ કારણોસર બેશ સ્ક્રિપ્ટો લખવાની જરૂર નથી. હવે અમને સિસ્ટમ અપડેટ કરવા અને સિસ્ટમ પેકેજો ઇન્સ્ટોલ કરવા માટે આ મોડ્યુલોમાંથી એકની જરૂર છે. મારી પાસે મારા 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

ટાસ્ક બરાબર એ જ કાર્ય છે જે Ansible રિમોટ સર્વર્સ પર કરશે. અમે કાર્યને એક નામ આપીએ છીએ જેથી કરીને અમે લોગમાં તેના અમલને ટ્રૅક કરી શકીએ. અને અમે વિશિષ્ટ મોડ્યુલના વાક્યરચનાનો ઉપયોગ કરીને, તેને શું કરવાની જરૂર છે તેનું વર્ણન કરીએ છીએ. આ બાબતે apt: update_cache=yes - એપ્ટ મોડ્યુલનો ઉપયોગ કરીને સિસ્ટમ પેકેજોને અપડેટ કરવાનું કહે છે. બીજો આદેશ થોડો વધુ જટિલ છે. અમે 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') }}". બાબત એ છે કે જવાબીબલ દ્વારા વપરાશકર્તાને ઇન્સ્ટોલ કરતું નથી 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 પાસે છે ભૂમિકાઓ.
શરૂઆતમાં દર્શાવેલ ફાઇલ સ્ટ્રક્ચર મુજબ, ભૂમિકાઓ અલગ રોલ ડિરેક્ટરીમાં મૂકવી આવશ્યક છે, દરેક ભૂમિકા માટે કાર્ય, ફાઇલો, ટેમ્પલેટ્સ વગેરે ડિરેક્ટરીની અંદર સમાન નામની એક અલગ ડિરેક્ટરી હોય છે.
ચાલો ફાઈલ સ્ટ્રક્ચર બનાવીએ: ./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 રૂપરેખાંકન ફાઇલ બનાવીએ છીએ (તમે તેને સીધા સર્વરમાંથી લઈ શકો છો, અથવા તેને જાતે લખી શકો છો). અને સાઇટ્સ_ઉપલબ્ધ ડિરેક્ટરીમાં અમારી એપ્લિકેશન માટેની રૂપરેખાંકન ફાઇલ પણ (આ જરૂરી નથી પણ ઉપયોગી છે). પ્રથમ કિસ્સામાં, અમે ફાઇલોની નકલ કરવા માટે કૉપિ મોડ્યુલનો ઉપયોગ કરીએ છીએ (ફાઇલ તેમાં હોવી આવશ્યક છે /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-playbook -i inventory ./playbook.yml -l "staging"

બીજો વિકલ્પ એ છે કે વિવિધ જૂથો માટે અલગ ઇન્વેન્ટરી ફાઇલો હોય. અથવા જો તમારી પાસે ઘણાં વિવિધ હોસ્ટ હોય તો તમે બે અભિગમોને જોડી શકો છો.

ચાલો nginx સેટ કરવા પર પાછા જઈએ. રૂપરેખાંકન ફાઇલોની નકલ કર્યા પછી, અમારે 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

અહીં બધું સરળ છે - એકદમ પ્રમાણભૂત વાક્યરચના સાથે ફરીથી જવાબદાર મોડ્યુલો. પરંતુ એક બિંદુ છે. દર વખતે 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 દ્વારા રૂબી ઇન્સ્ટોલ કરી રહ્યું છે

rbenv સાથે કામ કરવા માટે Ansible પાસે મોડ્યુલો નથી, પરંતુ તે ગિટ રિપોઝીટરીને ક્લોન કરીને ઇન્સ્ટોલ કરેલું છે. તેથી, આ સમસ્યા સૌથી બિન-માનક બની જાય છે. ચાલો તેના માટે એક ભૂમિકા બનાવીએ /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 તેની હોમ ડિરેક્ટરીમાં ઇન્સ્ટોલ કરેલું છે, અને વૈશ્વિક રીતે નહીં. અને અમે રેપો અને ડેસ્ટનો ઉલ્લેખ કરીને રિપોઝીટરીને ક્લોન કરવા માટે ગિટ મોડ્યુલનો પણ ઉપયોગ કરીએ છીએ.

આગળ, આપણે 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 -)"'

પછી તમારે રૂબી_બિલ્ડ ઇન્સ્ટોલ કરવાની જરૂર છે:

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

અને છેલ્લે રૂબી ઇન્સ્ટોલ કરો. આ 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 એ જ સ્ક્રિપ્ટમાં સીધી વ્યાખ્યાયિત કરવી પડશે.

આગળની સમસ્યા એ હકીકતને કારણે છે કે શેલ કમાન્ડ પાસે જવાબી દૃષ્ટિકોણથી કોઈ સ્થિતિ નથી. એટલે કે, રૂબીનું આ સંસ્કરણ ઇન્સ્ટોલ કરેલું છે કે નહીં તેની કોઈ સ્વચાલિત તપાસ થશે નહીં. અમે આ જાતે કરી શકીએ છીએ:

- 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 ને ઘણીવાર વધારાની રૂપરેખાંકન ફાઈલોની જરૂર પડે છે, જેમ કે 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 પાસવર્ડ માટે પૂછશે, ચલો પુનઃપ્રાપ્ત કરશે અને કાર્યોને એક્ઝિક્યુટ કરશે. તમામ ડેટા એન્ક્રિપ્ટેડ રહેશે.

યજમાનોના ઘણા જૂથો અને જવાબી વૉલ્ટ માટેનો સંપૂર્ણ આદેશ કંઈક આના જેવો દેખાશે:

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

પરંતુ હું તમને પ્લેબુક અને ભૂમિકાઓનું સંપૂર્ણ લખાણ આપીશ નહીં, તે જાતે લખો. કારણ કે જવાબી એવું છે - જો તમે સમજી શકતા નથી કે શું કરવાની જરૂર છે, તો તે તમારા માટે તે કરશે નહીં.

સોર્સ: www.habr.com