🥇 Ansible | वापरून रेल ऍप्लिकेशन उपयोजित करण्यासाठी सर्व्हर सेट करणे प्रोहोस्टर

काही काळापूर्वी मला रेल ऍप्लिकेशन तैनात करण्यासाठी सर्व्हर तयार करण्यासाठी अनेक उत्तरदायी प्लेबुक लिहिण्याची गरज होती. आणि, आश्चर्याची गोष्ट म्हणजे, मला एक साधे चरण-दर-चरण मॅन्युअल सापडले नाही. काय घडत आहे हे समजून घेतल्याशिवाय मला कोणाच्यातरी प्लेबुकची कॉपी करायची नव्हती आणि शेवटी मला सर्व काही स्वतः गोळा करून दस्तऐवजीकरण वाचावे लागले. कदाचित मी या लेखाच्या मदतीने एखाद्याला ही प्रक्रिया वेगवान करण्यात मदत करू शकेन.

समजून घेण्याची पहिली गोष्ट म्हणजे एंसिबल तुम्हाला SSH द्वारे रिमोट सर्व्हरवर क्रियांची पूर्वनिर्धारित सूची करण्यासाठी सोयीस्कर इंटरफेस प्रदान करते. येथे कोणतीही जादू नाही, तुम्ही प्लगइन स्थापित करू शकत नाही आणि बॉक्सच्या बाहेर डॉकर, मॉनिटरिंग आणि इतर वस्तूंसह तुमच्या अनुप्रयोगाचा शून्य डाउनटाइम उपयोजन मिळवू शकत नाही. प्लेबुक लिहिण्यासाठी, तुम्हाला नक्की काय करायचे आहे आणि ते कसे करायचे आहे हे माहित असणे आवश्यक आहे. म्हणूनच मी GitHub वरील रेडीमेड प्लेबुक किंवा "कॉपी करा आणि चालवा, ते कार्य करेल" यासारख्या लेखांवर समाधानी नाही.

आम्हाला काय हवे आहे?

मी आधीच म्हटल्याप्रमाणे, प्लेबुक लिहिण्यासाठी तुम्हाला काय करायचे आहे आणि ते कसे करायचे आहे हे माहित असणे आवश्यक आहे. आम्हाला काय हवे आहे ते ठरवूया. रेल ऍप्लिकेशनसाठी आम्हाला अनेक सिस्टम पॅकेजेसची आवश्यकता असेल: nginx, postgresql (redis, इ). याव्यतिरिक्त, आम्हाला रुबीच्या विशिष्ट आवृत्तीची आवश्यकता आहे. हे rbenv (rvm, asdf...) द्वारे स्थापित करणे सर्वोत्तम आहे. रूट वापरकर्ता म्हणून हे सर्व चालवणे नेहमीच एक वाईट कल्पना असते, म्हणून तुम्हाला स्वतंत्र वापरकर्ता तयार करणे आणि त्याचे अधिकार कॉन्फिगर करणे आवश्यक आहे. यानंतर, तुम्हाला आमचा कोड सर्व्हरवर अपलोड करावा लागेल, nginx, postgres इत्यादीसाठी कॉन्फिग कॉपी करावी लागेल आणि या सर्व सेवा सुरू कराव्या लागतील.

परिणामी, क्रियांचा क्रम खालीलप्रमाणे आहे:

रूट म्हणून लॉग इन करा
सिस्टम पॅकेजेस स्थापित करा
नवीन वापरकर्ता तयार करा, अधिकार कॉन्फिगर करा, ssh की
सिस्टम पॅकेजेस (nginx इ.) कॉन्फिगर करा आणि त्यांना चालवा
आम्ही डेटाबेसमध्ये वापरकर्ता तयार करतो (तुम्ही लगेच डेटाबेस तयार करू शकता)
नवीन वापरकर्ता म्हणून लॉग इन करा
rbenv आणि ruby स्थापित करा
बंडलर स्थापित करत आहे
अर्ज कोड अपलोड करत आहे
Puma सर्व्हर लाँच करत आहे

शिवाय, शेवटचे टप्पे कॅपिस्ट्रानो वापरून केले जाऊ शकतात, कमीतकमी बॉक्सच्या बाहेर तो कोड रिलीझ डिरेक्टरीमध्ये कॉपी करू शकतो, यशस्वी डिप्लॉयमेंटवर सिमलिंकसह रिलीझ स्विच करू शकतो, शेअर केलेल्या डिरेक्टरीमधून कॉन्फिगरेशन कॉपी करू शकतो, प्यूमा रीस्टार्ट करू शकतो इ. हे सर्व Ansible वापरून करता येते, पण का?

फाइल संरचना

Ansible कडक आहे फाइल संरचना तुमच्या सर्व फायलींसाठी, त्यामुळे ते सर्व वेगळ्या निर्देशिकेत ठेवणे चांगले. शिवाय, ते स्वतः रेल ऍप्लिकेशनमध्ये असेल किंवा स्वतंत्रपणे असेल हे इतके महत्त्वाचे नाही. तुम्ही फाइल्स वेगळ्या गिट रिपॉजिटरीमध्ये साठवू शकता. वैयक्तिकरित्या, मला रेल ऍप्लिकेशनच्या /कॉन्फिग डिरेक्टरीमध्ये उत्तरदायी निर्देशिका तयार करणे आणि सर्व काही एका रेपॉजिटरीमध्ये संग्रहित करणे सर्वात सोयीचे वाटले.

साधे प्लेबुक

प्लेबुक ही एक 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 प्रवेश असेल, तर ansible कनेक्ट करेल आणि रिमोट सिस्टमबद्दल माहिती गोळा करेल. (डिफॉल्ट टास्क [गॅदरिंग फॅक्ट्स]) त्यानंतर ते अंमलबजावणीवर एक छोटा अहवाल देईल (प्ले रीकॅप).

डीफॉल्टनुसार, कनेक्शन वापरकर्तानाव वापरते ज्या अंतर्गत तुम्ही सिस्टममध्ये लॉग इन केले आहे. हे बहुधा होस्टवर नसेल. प्लेबुक फाइलमध्ये, तुम्ही 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.

सिस्टम पॅकेजेस स्थापित करत आहे

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 मॉड्यूल वापरून सिस्टम पॅकेजेस अद्यतनित करण्यास सांगते. दुसरी आज्ञा थोडी अधिक क्लिष्ट आहे. आम्ही पॅकेजेसची यादी 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"

सर्व काही अगदी सोपे आहे, आमच्याकडे गट तयार करण्यासाठी एक गट मॉड्यूल देखील आहे, ज्याचा सिंटॅक्स apt सारखाच आहे. मग हा गट वापरकर्त्याकडे नोंदणी करणे पुरेसे आहे (groups: "sudo").
या वापरकर्त्यासाठी ssh की जोडणे देखील उपयुक्त आहे जेणेकरून आम्ही पासवर्डशिवाय लॉग इन करू शकू:

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

या प्रकरणात, डिझाइन मनोरंजक आहे "{{ lookup('file', '~/.ssh/id_rsa.pub') }}" — ते id_rsa.pub फाईलची सामग्री कॉपी करते (तुमचे नाव वेगळे असू शकते), म्हणजेच ssh कीचा सार्वजनिक भाग आणि सर्व्हरवरील वापरकर्त्यासाठी अधिकृत कीच्या सूचीमध्ये अपलोड करतो.

भूमिका

वापर तयार करण्यासाठी सर्व तीन कार्ये सहजपणे कार्यांच्या एका गटामध्ये वर्गीकृत केली जाऊ शकतात आणि हा गट मुख्य प्लेबुकपासून वेगळा संग्रहित करणे चांगली कल्पना असेल जेणेकरून ते खूप मोठे होणार नाही. या उद्देशासाठी, Ansible आहे भूमिका.
अगदी सुरुवातीला सूचित केलेल्या फाइल स्ट्रक्चरनुसार, भूमिका वेगळ्या भूमिका निर्देशिकेत ठेवल्या पाहिजेत, प्रत्येक भूमिकेसाठी कार्ये, फाइल्स, टेम्पलेट्स इत्यादी निर्देशिकेत समान नावाची वेगळी निर्देशिका असते.
चला फाईल स्ट्रक्चर तयार करूया: ./ansible/roles/user/tasks/main.yml (मुख्य ही मुख्य फाईल आहे जी प्लेबुकशी रोल कनेक्ट केल्यावर लोड केली जाईल आणि कार्यान्वित केली जाईल; इतर रोल फाइल्स त्याच्याशी कनेक्ट केल्या जाऊ शकतात). आता तुम्ही वापरकर्त्याशी संबंधित सर्व कार्ये या फाईलमध्ये हस्तांतरित करू शकता:

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

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

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

मुख्य प्लेबुकमध्ये, आपण वापरकर्ता भूमिका वापरण्यासाठी निर्दिष्ट करणे आवश्यक आहे:

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

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

  roles:
    - user

तसेच, इतर सर्व कार्यांपूर्वी सिस्टम अपडेट करणे अर्थपूर्ण असू शकते; हे करण्यासाठी, आपण ब्लॉकचे नाव बदलू शकता tasks ज्यामध्ये त्यांची व्याख्या केली आहे pre_tasks.

nginx सेट करत आहे

आम्ही आधीच Nginx स्थापित केले पाहिजे; आम्हाला ते कॉन्फिगर करून चालवावे लागेल. भूमिकेत लगेच करू. चला फाईल स्ट्रक्चर तयार करूया:

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

आता आम्हाला फाइल्स आणि टेम्पलेट्सची आवश्यकता आहे. त्यांच्यातील फरक असा आहे की उत्तरदायी फायली थेट कॉपी करतात. आणि टेम्पलेट्समध्ये 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

आम्ही आता आमचे प्लेबुक लाँच केल्यास, ते दोन्ही होस्टसाठी निर्दिष्ट कार्ये करेल. परंतु त्याच वेळी, स्टेजिंग होस्टसाठी, व्हेरिएबल्स उत्पादनापेक्षा भिन्न असतील आणि केवळ भूमिका आणि प्लेबुकमध्येच नाही तर एनजीनेक्स कॉन्फिगमध्ये देखील असतील. {{ 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. वस्तुस्थिती अशी आहे की डीफॉल्टनुसार, केवळ पोस्टग्रेस वापरकर्त्यास पोस्टग्रेसक्यूएल डेटाबेसमध्ये प्रवेश असतो आणि केवळ स्थानिक पातळीवर. हा निर्देश आम्हाला या वापरकर्त्याच्या वतीने आदेश कार्यान्वित करण्याची परवानगी देतो (जर आम्हाला प्रवेश असेल तर नक्कीच).
तसेच, डेटाबेसमध्ये नवीन वापरकर्त्याला प्रवेश देण्यासाठी तुम्हाला 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 त्याच्या होम डिरेक्ट्रीमध्ये स्थापित केले आहे, आणि जागतिक स्तरावर नाही. आणि आम्ही रेपो आणि डेस्ट निर्दिष्ट करून रेपॉजिटरी क्लोन करण्यासाठी 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

आणि शेवटी रुबी स्थापित करा. हे 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

Ansible वापरून Rails अनुप्रयोग उपयोजित करण्यासाठी सर्व्हर सेट करणे