Ansibleని ఉపయోగించి రైల్స్ అప్లికేషన్‌ని అమలు చేయడానికి సర్వర్‌ని సెటప్ చేస్తోంది

చాలా కాలం క్రితం నేను రైల్స్ అప్లికేషన్‌ని అమలు చేయడానికి సర్వర్‌ను సిద్ధం చేయడానికి అనేక అన్సిబుల్ ప్లేబుక్‌లను వ్రాయవలసి వచ్చింది. మరియు, ఆశ్చర్యకరంగా, నేను సాధారణ దశల వారీ మాన్యువల్‌ని కనుగొనలేదు. నేను ఏమి జరుగుతుందో అర్థం చేసుకోకుండా వేరొకరి ప్లేబుక్‌ని కాపీ చేయకూడదనుకున్నాను మరియు చివరికి నేను డాక్యుమెంటేషన్ చదవవలసి వచ్చింది, ప్రతిదీ నేనే సేకరించాను. బహుశా ఈ ఆర్టికల్ సహాయంతో ఈ ప్రక్రియను వేగవంతం చేయడానికి నేను ఎవరికైనా సహాయం చేయగలను.

SSH ద్వారా రిమోట్ సర్వర్(ల)లో చర్యల యొక్క ముందే నిర్వచించబడిన జాబితాను నిర్వహించడానికి ansible మీకు అనుకూలమైన ఇంటర్‌ఫేస్‌ను అందిస్తుంది అని అర్థం చేసుకోవలసిన మొదటి విషయం. ఇక్కడ ఎలాంటి మ్యాజిక్ లేదు, మీరు ప్లగిన్‌ని ఇన్‌స్టాల్ చేయలేరు మరియు డాకర్, మానిటరింగ్ మరియు ఇతర గూడీస్‌తో మీ అప్లికేషన్ యొక్క సున్నా డౌన్‌టైమ్ విస్తరణను పొందలేరు. ప్లేబుక్‌ను వ్రాయడానికి, మీరు ఖచ్చితంగా ఏమి చేయాలనుకుంటున్నారు మరియు ఎలా చేయాలో మీరు తెలుసుకోవాలి. అందుకే నేను GitHub నుండి రెడీమేడ్ ప్లేబుక్‌లు లేదా ఇలాంటి కథనాలతో సంతృప్తి చెందలేదు: "కాపీ చేసి రన్ చేయండి, ఇది పని చేస్తుంది."

మనకు ఏమి కావాలి?

నేను ఇప్పటికే చెప్పినట్లుగా, ప్లేబుక్ రాయడానికి మీరు ఏమి చేయాలనుకుంటున్నారో మరియు ఎలా చేయాలో తెలుసుకోవాలి. మనకు ఏది అవసరమో నిర్ణయించుకుందాం. రైల్స్ అప్లికేషన్ కోసం మనకు అనేక సిస్టమ్ ప్యాకేజీలు అవసరం: nginx, postgresql (redis, etc). అదనంగా, మాకు రూబీ యొక్క నిర్దిష్ట వెర్షన్ అవసరం. దీన్ని rbenv (rvm, asdf...) ద్వారా ఇన్‌స్టాల్ చేయడం ఉత్తమం. రూట్ యూజర్‌గా వీటన్నింటినీ అమలు చేయడం ఎల్లప్పుడూ చెడ్డ ఆలోచన, కాబట్టి మీరు ప్రత్యేక వినియోగదారుని సృష్టించి, అతని హక్కులను కాన్ఫిగర్ చేయాలి. దీని తర్వాత, మీరు మా కోడ్‌ను సర్వర్‌కు అప్‌లోడ్ చేయాలి, nginx, postgres మొదలైన వాటి కోసం కాన్ఫిగరేషన్‌లను కాపీ చేసి, ఈ సేవలన్నింటినీ ప్రారంభించాలి.

ఫలితంగా, చర్యల క్రమం క్రింది విధంగా ఉంటుంది:

1. రూట్‌గా లాగిన్ చేయండి
2. సిస్టమ్ ప్యాకేజీలను ఇన్‌స్టాల్ చేయండి
3. కొత్త వినియోగదారుని సృష్టించండి, హక్కులను కాన్ఫిగర్ చేయండి, ssh కీ
4. సిస్టమ్ ప్యాకేజీలను కాన్ఫిగర్ చేయండి (nginx మొదలైనవి) మరియు వాటిని అమలు చేయండి
5. మేము డేటాబేస్లో వినియోగదారుని సృష్టిస్తాము (మీరు వెంటనే డేటాబేస్ను సృష్టించవచ్చు)
6. కొత్త వినియోగదారుగా లాగిన్ చేయండి
7. rbenv మరియు రూబీని ఇన్‌స్టాల్ చేయండి
8. బండ్లర్‌ను ఇన్‌స్టాల్ చేస్తోంది
9. అప్లికేషన్ కోడ్‌ని అప్‌లోడ్ చేస్తోంది
10. Puma సర్వర్‌ని ప్రారంభిస్తోంది

అంతేకాకుండా, చివరి దశలను కాపిస్ట్రానో ఉపయోగించి చేయవచ్చు, కనీసం బాక్స్ వెలుపల కోడ్‌ను విడుదల డైరెక్టరీలలోకి కాపీ చేయవచ్చు, విజయవంతమైన విస్తరణపై సిమ్‌లింక్‌తో విడుదలను మార్చవచ్చు, షేర్డ్ డైరెక్టరీ నుండి కాన్ఫిగరేషన్‌లను కాపీ చేయవచ్చు, ప్యూమాని పునఃప్రారంభించవచ్చు మొదలైనవి. ఇదంతా అన్సిబుల్ ఉపయోగించి చేయవచ్చు, కానీ ఎందుకు?

ఫైల్ నిర్మాణం

అన్సిబుల్ కఠినంగా ఉంటుంది ఫైల్ నిర్మాణం మీ అన్ని ఫైల్‌ల కోసం, అన్నింటినీ ప్రత్యేక డైరెక్టరీలో ఉంచడం ఉత్తమం. అంతేకాకుండా, ఇది పట్టాల అప్లికేషన్‌లోనే ఉంటుందా లేదా విడిగా ఉంటుందా అనేది అంత ముఖ్యమైనది కాదు. మీరు ఫైల్‌లను ప్రత్యేక గిట్ రిపోజిటరీలో నిల్వ చేయవచ్చు. వ్యక్తిగతంగా, రైల్స్ అప్లికేషన్ యొక్క / config డైరెక్టరీలో ఒక ansible డైరెక్టరీని సృష్టించడం మరియు ఒక రిపోజిటరీలో ప్రతిదీ నిల్వ చేయడం చాలా సౌకర్యవంతంగా ఉందని నేను కనుగొన్నాను.

సాధారణ ప్లేబుక్

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 యొక్క హోస్ట్‌ని ఆదర్శంగా పేర్కొనవచ్చు లేదా మీరు లోకల్ హోస్ట్‌ని నమోదు చేసుకోవచ్చు) మరియు దానిని పేరుతో సేవ్ చేస్తాము inventory.
మీరు ఇన్వెటరీ ఫైల్‌తో ansibleని అమలు చేయడానికి ప్రయత్నించవచ్చు:

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

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

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

మీరు పేర్కొన్న హోస్ట్‌కు ssh యాక్సెస్ కలిగి ఉంటే, అప్పుడు ansible కనెక్ట్ చేస్తుంది మరియు రిమోట్ సిస్టమ్ గురించి సమాచారాన్ని సేకరిస్తుంది. (డిఫాల్ట్ టాస్క్ [గేదరింగ్ ఫ్యాక్ట్స్]) ఆ తర్వాత అది ఎగ్జిక్యూషన్‌పై చిన్న నివేదికను ఇస్తుంది (ప్లే రీకాప్).

డిఫాల్ట్‌గా, కనెక్షన్ మీరు సిస్టమ్‌లోకి లాగిన్ అయిన వినియోగదారు పేరును ఉపయోగిస్తుంది. ఇది చాలా మటుకు హోస్ట్‌లో ఉండదు. ప్లేబుక్ ఫైల్‌లో, రిమోట్_యూజర్ డైరెక్టివ్‌ని ఉపయోగించి కనెక్ట్ చేయడానికి ఏ వినియోగదారుని ఉపయోగించాలో మీరు పేర్కొనవచ్చు. అలాగే, రిమోట్ సిస్టమ్ గురించిన సమాచారం తరచుగా మీకు అనవసరంగా ఉండవచ్చు మరియు మీరు దానిని సేకరించడానికి సమయాన్ని వృథా చేయకూడదు. ఈ విధిని కూడా నిలిపివేయవచ్చు:

---
- 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.

సిస్టమ్ ప్యాకేజీలను సంస్థాపిస్తోంది

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

టాస్క్ అనేది రిమోట్ సర్వర్‌లలో అన్సిబుల్ చేసే పని. మేము టాస్క్‌కు పేరు పెట్టాము, తద్వారా లాగ్‌లో దాని అమలును ట్రాక్ చేయవచ్చు. మరియు మేము ఒక నిర్దిష్ట మాడ్యూల్ యొక్క వాక్యనిర్మాణాన్ని ఉపయోగించి, అది ఏమి చేయాలో వివరిస్తాము. ఈ విషయంలో apt: update_cache=yes - ఆప్ట్ మాడ్యూల్‌ని ఉపయోగించి సిస్టమ్ ప్యాకేజీలను అప్‌డేట్ చేయమని చెప్పింది. రెండవ ఆదేశం కొంచెం క్లిష్టంగా ఉంటుంది. మేము ప్యాకేజీల జాబితాను ఆప్ట్ మాడ్యూల్‌కి పంపుతాము మరియు అవి ఉన్నాయని చెబుతాము state అవ్వాలి present, అంటే, మేము ఈ ప్యాకేజీలను ఇన్‌స్టాల్ చేస్తాము. అదే విధంగా, మేము వాటిని తొలగించమని లేదా వాటిని మార్చడం ద్వారా వాటిని అప్‌డేట్ చేయమని చెప్పవచ్చు state. దయచేసి పోస్ట్‌గ్రెస్‌క్యూల్‌తో పని చేయడానికి పట్టాలు కోసం మనం ఇప్పుడు ఇన్‌స్టాల్ చేస్తున్న 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 మీరు దీన్ని మాన్యువల్‌గా చేస్తారు. మరియు ఇది మొత్తం డేటాను నేరుగా సేవ్ చేస్తుంది, అందుకే మనం పాస్‌వర్డ్‌ను ముందుగానే హాష్‌గా మార్చాలి, అదే ఈ కమాండ్ చేస్తుంది.

సుడో గ్రూప్‌లో మన యూజర్‌ని యాడ్ చేద్దాం. అయితే, దీనికి ముందు మనం అలాంటి సమూహం ఉందని నిర్ధారించుకోవాలి ఎందుకంటే మన కోసం ఎవరూ దీన్ని చేయరు:

---
- 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 in ఎనేబుల్ చేద్దాం 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 configsలో కూడా ఉంటాయి. {{ inventory_hostname }} ఇన్వెంటరీ ఫైల్‌లో పేర్కొనవలసిన అవసరం లేదు - ఇది ప్రత్యేక ansible వేరియబుల్ మరియు ప్లేబుక్ ప్రస్తుతం నడుస్తున్న హోస్ట్ అక్కడ నిల్వ చేయబడుతుంది.
మీరు అనేక హోస్ట్‌ల కోసం ఇన్వెంటరీ ఫైల్‌ను కలిగి ఉండాలనుకుంటే, కానీ ఒక సమూహం కోసం మాత్రమే అమలు చేయాలనుకుంటే, ఇది క్రింది ఆదేశంతో చేయవచ్చు:

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ని పునఃప్రారంభించడంలో అర్థం లేదు. మేము కమాండ్‌లను వ్రాయడం లేదని మీరు గమనించారా: “ఇలా చేయండి”, వాక్యనిర్మాణం “దీనికి ఈ స్థితి ఉండాలి” లాగా కనిపిస్తుంది. మరియు చాలా తరచుగా ఇది అన్సిబుల్ ఎలా పనిచేస్తుంది. సమూహం ఇప్పటికే ఉన్నట్లయితే లేదా సిస్టమ్ ప్యాకేజీ ఇప్పటికే ఇన్‌స్టాల్ చేయబడి ఉంటే, అప్పుడు 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ని సెటప్ చేస్తోంది

మనం 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

ఈ ప్రయోజనాల కోసం మేము సృష్టించిన వినియోగదారు కింద పని చేయడానికి మేము మళ్లీ become_user ఆదేశాన్ని ఉపయోగిస్తాము. Rbenv దాని హోమ్ డైరెక్టరీలో ఇన్‌స్టాల్ చేయబడినందున, ప్రపంచవ్యాప్తంగా కాదు. మరియు మేము రిపోజిటరీని క్లోన్ చేయడానికి git మాడ్యూల్‌ని కూడా ఉపయోగిస్తాము, repo మరియు destని పేర్కొంటాము.

తర్వాత, మనం bashrcలో rbenv initని నమోదు చేయాలి మరియు అక్కడ PATHకి rbenvని జోడించాలి. దీని కోసం మనకు లైన్ఇన్‌ఫైల్ మాడ్యూల్ ఉంది:

- 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

మేము ఒక డైరెక్టరీని మాత్రమే పేర్కొంటాము మరియు అవసరమైతే ansible స్వయంచాలకంగా పేరెంట్ వాటిని సృష్టిస్తుంది.

అన్సిబుల్ వాల్ట్

వేరియబుల్స్ వినియోగదారు పాస్‌వర్డ్ వంటి రహస్య డేటాను కలిగి ఉండవచ్చని మేము ఇప్పటికే తెలుసుకున్నాము. మీరు సృష్టించినట్లయితే .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