🏡 🛀🏼 👩🏻‍💼 Ansible का उपयोग करके एक रेल एप्लिकेशन को तैनात करने के लिए एक सर्वर को कॉन्फ़िगर करना 🤵🏼 👩🏼‍🎤 🎥

बहुत पहले नहीं, मुझे रेल एप्लिकेशन को तैनात करने के लिए सर्वर को तैयार करने के लिए कई अखण्डनीय प्लेबुक लिखने की आवश्यकता थी। और, आश्चर्यजनक रूप से, मुझे एक सरल चरण-दर-चरण मैनुअल नहीं मिला। मैं यह समझे बिना किसी और की प्लेबुक को कॉपी नहीं करना चाहता था कि क्या हो रहा था और परिणामस्वरूप मुझे सब कुछ इकट्ठा करते हुए, डॉक्यूमेंटेशन पढ़ना पड़ा। शायद कोई मैं इस लेख के साथ इस प्रक्रिया को गति देने में मदद कर सकता हूं।

समझने वाली पहली बात यह है कि एसएसएच के माध्यम से रिमोट सर्वर (एस) पर क्रियाओं की पूर्वनिर्धारित सूची के प्रदर्शन के लिए एक सुविधाजनक इंटरफेस आपको प्रदान करता है। यहां कोई जादू नहीं है, आप प्लगइन को स्थापित नहीं कर सकते हैं और शून्य डाउनटाइम बॉक्स से बाहर निकल सकते हैं, आपके आवेदन की तैनाती डॉकटर, निगरानी और अन्य उपहारों के साथ हो सकती है। प्लेबुक लिखने के लिए आपको पता होना चाहिए कि आप वास्तव में क्या करना चाहते हैं और कैसे करना चाहते हैं। इसलिए, मैं जीथब से तैयार की गई प्लेबुक या ऐसे लेख पसंद नहीं करता जैसे: "कॉपी और रन करें, यह काम करेगा।"

हमें क्या चाहिए?

जैसा कि मैंने कहा, प्लेबुक लिखने के लिए आपको यह जानना होगा कि आप क्या करना चाहते हैं और कैसे करना चाहते हैं। आइए फैसला करें कि हमें क्या चाहिए। रेल एप्लिकेशन के लिए, हमें कई सिस्टम पैकेजों की आवश्यकता होगी: nginx, postgresql (redis, आदि)। इसके अतिरिक्त, हमें एक निश्चित संस्करण के माणिक की आवश्यकता है। Rbenv (rvm, asdf ...) के माध्यम से इसे स्थापित करना सबसे अच्छा है। उपयोगकर्ता के मूल से यह सब चलाना हमेशा एक बुरा विचार है, इसलिए आपको एक अलग उपयोगकर्ता बनाने और उसके लिए अधिकारों को कॉन्फ़िगर करने की आवश्यकता है। उसके बाद, आपको हमारे कोड को सर्वर पर अपलोड करने की आवश्यकता है, नग्नेक्स, पोस्टग्रेज आदि के लिए कॉन्फ़िगरेशन को कॉपी करें और इन सभी सेवाओं को चलाएं।

परिणामस्वरूप, क्रियाओं का क्रम इस प्रकार है:

रूट के रूप में लॉग इन करें
सिस्टम पैकेज स्थापित करें
एक नया उपयोगकर्ता बनाएं, अधिकार कॉन्फ़िगर करें, ssh कुंजी
सिस्टम पैकेज (nginx आदि) कॉन्फ़िगर करें और उन्हें चलाएं
डेटाबेस में एक उपयोगकर्ता बनाएँ (आप तुरंत एक डेटाबेस बना सकते हैं)
एक नए उपयोगकर्ता के रूप में लॉग इन करें
रेंबव और रूबी स्थापित करें
बंडल स्थापित करें
आवेदन कोड भरें
हम प्यूमा सर्वर शुरू करते हैं

इसके अलावा, अंतिम चरण कैपिस्ट्रानो का उपयोग करके किया जा सकता है, कम से कम वह बॉक्स से रिलीज निर्देशिकाओं में कोड को कॉपी कर सकता है, एक सफल तैनाती पर एक सिमलिंक के साथ रिलीज को स्विच कर सकता है, साझा निर्देशिका से कॉपी को कॉन्फ़िगर कर सकता है, प्यूमा को पुनरारंभ कर सकता है, आदि। यह सब Ansible के साथ किया जा सकता है, लेकिन क्यों?

फ़ाइल संरचना

अपनी सभी फ़ाइलों के लिए Ansible के पास एक सख्त फ़ाइल संरचना है , इसलिए इसे सभी को एक अलग निर्देशिका में रखना सर्वोत्तम है। और यह इतना महत्वपूर्ण नहीं है कि क्या यह रेल के आवेदन में ही होगा, या अलग से। आप फ़ाइलों को एक अलग गिट रिपॉजिटरी में स्टोर कर सकते हैं। व्यक्तिगत रूप से, यह मेरे लिए सबसे सुविधाजनक था कि मैं आवेदन की रेल निर्देशिका के इन-डिसिप्लिन डायरेक्टरी / कॉन्फिग को तैयार करूं और एक रिपॉजिटरी में सब कुछ स्टोर करूं।

सिंपल प्लेबुक

Playbook एक yml फ़ाइल है जो बताती है कि विशेष वाक्यविन्यास का उपयोग करके क्या और कैसे ansible करना चाहिए। चलिए पहली ऐसी प्लेबुक बनाते हैं जिसमें कुछ भी नहीं है:

--- - name: Simple playbook hosts: all

यहां, हम केवल यह कहते हैं कि हमारी प्लेबुक को Simple Playbook कहा जाता है और इसकी सामग्री सभी मेजबानों के लिए चलना चाहिए। हम इसे playbook.yml नाम के साथ / ansible निर्देशिका में सहेज सकते हैं और चलाने का प्रयास कर सकते हैं:

 ansible-playbook ./playbook.yml PLAY [Simple Playbook] ************************************************************************************************************************************ skipping: no hosts matched

Ansible का कहना है कि यह मेजबान को नहीं जानता है जो सभी सूची से मेल खाता है। उन्हें एक विशेष इन्वेंट्री फ़ाइल में सूचीबद्ध किया जाना चाहिए।

आइए इसे उसी आनुषंगिक निर्देशिका में बनाएँ:

 123.123.123.123

तो बस होस्ट निर्दिष्ट करें (आदर्श रूप से, परीक्षण के लिए आपके वीपीएस के मेजबान, या आप स्थानीयहोस्ट को पंजीकृत कर सकते हैं) और इसे नाम inventory तहत सहेज सकते हैं।
आप एक अनिवार्य फ़ाइल के साथ ansible चलाने की कोशिश कर सकते हैं:

 ansible-playbook ./playbook.yml -i inventory PLAY [Simple Playbook] ************************************************************************************************************************************ TASK [Gathering Facts] ************************************************************************************************************************************ PLAY RECAP ************************************************************************************************************************************

यदि आपके पास निर्दिष्ट होस्ट तक पहुंच है, तो ansible रिमोट सिस्टम के बारे में जानकारी कनेक्ट और एकत्रित करेगा। (डिफ़ॉल्ट TASK [एकत्रीकरण तथ्य]) जिसके बाद यह एक संक्षिप्त प्रगति रिपोर्ट (PLAY RECAP) देगा।

डिफ़ॉल्ट रूप से, उपयोगकर्ता नाम जिसके तहत आप सिस्टम में लॉग इन हैं कनेक्शन के लिए उपयोग किया जाता है। यह सबसे अधिक संभावना मेजबान पर नहीं होगा। प्लेबुक फ़ाइल में, आप यह निर्दिष्ट कर सकते हैं कि कौन सा उपयोगकर्ता रिमोट_्यूसर निर्देश का उपयोग करके कनेक्ट करने के लिए उपयोग करें। साथ ही, रिमोट सिस्टम की जानकारी अक्सर आपके लिए अनावश्यक हो सकती है और आपको इसे इकट्ठा करने में समय बर्बाद नहीं करना चाहिए। आप इस कार्य को भी बंद कर सकते हैं:

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

फिर से प्लेबुक चलाने की कोशिश करें और सुनिश्चित करें कि कनेक्शन काम कर रहा है। (यदि आपने उपयोगकर्ता की जड़ निर्दिष्ट की है, तो आपको भी निर्दिष्ट करना होगा: उन्नत अधिकारों को प्राप्त करने के लिए सही निर्देश। जैसा कि प्रलेखन कहता है: become set to 'true'/'yes' to activate privilege escalation. जाता है become set to 'true'/'yes' to activate privilege escalation. हालांकि यह स्पष्ट नहीं है कि क्यों।) ।

शायद आपको एक त्रुटि के कारण त्रुटि मिलती है कि अजगर दुभाषिया निर्धारित नहीं कर सकता है, तो आप इसे मैन्युअल रूप से निर्दिष्ट कर सकते हैं:

 ansible_python_interpreter: /usr/bin/python3

जहाँ आपके पास अजगर है, जहाँ पर whereis python कमांड के साथ पाया जा सकता है।

सिस्टम पैकेज स्थापित करें

विभिन्न सिस्टम पैकेज के साथ काम करने के लिए उत्तर देने योग्य कई मॉड्यूल हैं, इसलिए हमें किसी भी कारण से बैश स्क्रिप्ट नहीं लिखनी है। अब हमें सिस्टम को अपडेट करने और सिस्टम पैकेज स्थापित करने के लिए इनमें से एक मॉड्यूल की आवश्यकता है। मेरे पास क्रमशः 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 बदलकर। कृपया ध्यान दें कि पोस्टग्रैसेकल के साथ काम करने के लिए रेल्स के लिए, हमें पोस्टग्रैस्कल-कंट्रीब पैकेज की आवश्यकता है जिसे हम वर्तमान में स्थापित कर रहे हैं। इसे फिर से जानने और करने की जरूरत है, अपने आप से यह करने योग्य नहीं होगा।

प्लेबुक को फिर से चलाने की कोशिश करें और सत्यापित करें कि पैकेज स्थापित हैं।

नए उपयोगकर्ताओं का निर्माण।

उपयोगकर्ताओं के साथ काम करने के लिए, 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') }}"

चर को Playbooks में डबल घुंघराले कोष्ठक का उपयोग करके सेट किया जाता है।

हम इन्वेंट्री फ़ाइल में चर के मूल्यों को इंगित करेंगे:

 123.123.123.123 [all:vars] user=my_user user_password=123qweasd

निर्देश [all:vars] - यह कहता है कि पाठ का अगला खंड चर (vars) है और वे सभी होस्ट (सभी) पर लागू होते हैं।

"{{ user_password | password_hash('sha512') }}" भी दिलचस्प है। तथ्य यह है कि ansible उपयोगकर्ता को 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 में परिभाषित किए pre_tasks ।

Nginx सेटअप

Nginx पहले से ही हमारे साथ स्थापित होना चाहिए, आपको इसे कॉन्फ़िगर करने और इसे चलाने की आवश्यकता है। आइए इसे अभी भूमिका में करें। एक फ़ाइल संरचना बनाएँ:

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

अब हमें फाइल और टेम्प्लेट चाहिए। दोनों के बीच अंतर यह है कि ansible फ़ाइलों को सीधे कॉपी किया जाता है, जैसा कि है। और टेम्प्लेट में एक्सटेंशन j2 होना चाहिए और वे एक ही डबल घुंघराले कोष्ठक का उपयोग करके चर के मूल्यों का उपयोग कर सकते हैं।

चलिए main.yml फाइल में nginx को शामिल main.yml हैं। इसके लिए, हमारे पास एक सिस्टम मॉड्यूल है:

 # Copy nginx configs and start it - name: enable service nginx and start systemd: name: nginx state: started enabled: yes

यहां हम न केवल कहते हैं कि नगनेक्स को शुरू किया जाना चाहिए (यानी, इसे चलाएं), लेकिन तुरंत कहते हैं कि इसे सक्षम होना चाहिए।
अब कॉन्फ़िगरेशन फ़ाइलों की प्रतिलिपि बनाएँ:

 # 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

यदि हम अपनी प्लेबुक अभी चलाते हैं, तो यह दोनों मेजबानों के लिए निर्दिष्ट कार्य करेगा। लेकिन एक ही समय में, मचान मेजबान के लिए, चर उत्पादन से अलग होंगे, और न केवल भूमिकाओं और प्लेबुक में, बल्कि नगीन विन्यास में भी। {{ inventory_hostname }} को इन्वेंट्री फाइल में निर्दिष्ट करने की आवश्यकता नहीं है - यह एक विशेष चर ansible है और जिस होस्ट के लिए प्लेबुक वर्तमान में चल रहा है वह वहां संग्रहीत है।
यदि आप कई मेजबानों के लिए एक इन्वेंट्री फ़ाइल चाहते हैं, और केवल एक समूह के लिए चलाते हैं, तो यह निम्नलिखित कमांड के साथ किया जा सकता है:

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

एक अन्य विकल्प अलग-अलग समूहों के लिए अलग-अलग इन्वेंट्री फाइलें रखना है। या यदि आपके पास कई अलग-अलग होस्ट हैं, तो आप दो दृष्टिकोणों को जोड़ सकते हैं।

चलो nginx को कॉन्फ़िगर करने के लिए वापस आते हैं। कॉन्फ़िगरेशन फ़ाइलों की प्रतिलिपि बनाने के बाद, हमें साइट_अवले से my_app.conf पर sitest_enabled में एक सिमलिंक बनाने की आवश्यकता है। और नग्नेक्स को पुनरारंभ करें।

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

यहां सब कुछ सरल है - फिर से, काफी मानक वाक्यविन्यास के साथ ansible मॉड्यूल। लेकिन एक बिंदु है। हर बार नग्नेक्स को फिर से शुरू करने का कोई मतलब नहीं है। आपने देखा कि हम फ़ॉर्म की कमांड नहीं लिख रहे हैं: "इसे इस तरह से करें", वाक्यविन्यास "इस राज्य में होना चाहिए" जैसा दिखता है। और सबसे अधिक बार यह कैसे काम करता है। यदि समूह पहले से मौजूद है या सिस्टम पैकेज पहले से स्थापित है, तो 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 पंजीकृत किया जाएगा। और केवल अगर यह चर पंजीकृत किया गया है, तो सेवा फिर से शुरू होगी।

ठीक है, निश्चित रूप से, आपको नग्नेक्स की भूमिका को मुख्य प्लेबुक में जोड़ना होगा।

Postgresql सेटअप

हमें सिस्टमग्रैड के साथ postgresql को सक्षम करने की आवश्यकता है, जैसा कि हमने nginx के साथ किया था, और एक उपयोगकर्ता भी बनाएं जिसका उपयोग हम डेटाबेस और डेटाबेस तक पहुंचने के लिए करेंगे।
भूमिका / /ansible/roles/postgresql/tasks/main.yml / /ansible/roles/postgresql/tasks/main.yml / /ansible/roles/postgresql/tasks/main.yml / /ansible/roles/postgresql/tasks/main.yml / /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 }}"

मैं यह नहीं बताऊंगा कि इन्वेंट्री में वैरिएबल को कैसे जोड़ा जाए, यह पहले से ही कई बार किया गया है, साथ ही साथ पोस्टग्रैसक्ला_डब और पोस्टग्रेक्स्ल_सुअर मॉड्यूल का सिंटैक्स भी है। प्रलेखन में अधिक डेटा पाया जा सकता है। निर्देशक become_user: postgres सबसे दिलचस्प become_user: postgres । तथ्य यह है कि डिफ़ॉल्ट रूप से केवल पोस्टग्रैज उपयोगकर्ता के पास पोस्टग्रैसक्ल डेटाबेस तक पहुंच है और केवल स्थानीय रूप से है। यह निर्देश हमें इस उपयोगकर्ता की ओर से आदेशों को निष्पादित करने की अनुमति देता है (जब तक कि हमारे पास पहुंच न हो)।
साथ ही, नए उपयोगकर्ता के लिए डेटाबेस तक पहुँच खोलने के लिए आपको pg_hba.conf में एक पंक्ति जोड़ना पड़ सकता है। यह उसी तरह से किया जा सकता है जैसे हमने nginx config को बदल दिया।

और निश्चित रूप से आपको पोस्टग्रैक्स्ल की भूमिका को मुख्य प्लेबुक में जोड़ना होगा।

रूबेन के माध्यम से रूबी स्थापित करें

आरनेबल के पास रेंबव के साथ काम करने के लिए कोई मॉड्यूल नहीं है, लेकिन यह एक गिट रिपॉजिटरी को क्लोन करके स्थापित किया गया है। इसलिए, यह कार्य सबसे गैर-मानक हो जाता है। आइए, उसके लिए भूमिका / /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 इनिट को पंजीकृत करने और उसी स्थान पर 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 -)"'

इसके बाद माणिक्य स्थापित करें:

 - 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

और फिर से, हमारी playy_rbenv भूमिका को मुख्य प्लेबुक में जोड़ें।

फ़ाइलें साझा की हैं।

सामान्य तौर पर, यह सेटिंग पूरी हो सकती है। फिर यह कैपिस्ट्रानो को चलाने के लिए रहता है और यह कोड को कॉपी करेगा, आवश्यक निर्देशिकाएं बनाएगा और एप्लिकेशन लॉन्च करेगा (यदि सब कुछ सही तरीके से कॉन्फ़िगर किया गया है)। हालांकि, अक्सर कैपिस्ट्रानो को अतिरिक्त कॉन्फ़िगरेशन फ़ाइलों की आवश्यकता होती है, जैसे .env या .env उन्हें कॉपी कर सकते हैं जैसे कि nginx के लिए फ़ाइलें और टेम्पलेट। केवल एक सूक्ष्मता है। फ़ाइलों की प्रतिलिपि बनाने से पहले, आपको उनके लिए एक निर्देशिका संरचना बनाने की आवश्यकता है, कुछ इस तरह से:

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

हम केवल एक निर्देशिका निर्दिष्ट करते हैं और यदि आवश्यक हो तो ansible स्वचालित रूप से माता-पिता का निर्माण करेगा।

अस्थिर तिजोरी

हम पहले से ही इस तथ्य पर ठोकर खा चुके हैं कि उपयोगकर्ता पासवर्ड जैसे गुप्त डेटा चर में दिखाई दे सकते हैं। यदि आपने एप्लिकेशन और database.yml लिए एक .env फ़ाइल बनाई है, तो database.yml ऐसे और भी महत्वपूर्ण डेटा होने चाहिए। आँखों को चुभने से उन्हें छुपाना अच्छा होगा। इसके लिए Ansible वॉल्ट का उपयोग किया जाता है।

चलो वैरिएबल /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 का उपयोग करके ansible-vault decrypt फ़ाइल को डिक्रिप्ट, संशोधित और फिर से एन्क्रिप्ट किया जा सकता है।

काम करने के लिए, फ़ाइल को डिक्रिप्ट करना आवश्यक नहीं है। आप इसे एन्क्रिप्टेड रूप में संग्रहीत करते हैं और प्लेबुक को तर्क के साथ चलाते हैं --ask-vault-pass । जवाबदेह एक पासवर्ड के लिए पूछेगा, चर प्राप्त करें, और कार्यों को पूरा करें। सभी डेटा एन्क्रिप्टेड रहेंगे।

कई मेजबान समूहों और ansible तिजोरी के लिए एक पूर्ण आदेश कुछ इस तरह दिखेगा:

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

और मैंने आपको प्लेबुक और भूमिकाओं का पूरा पाठ नहीं दिया, अपने लिए लिखें। क्योंकि सूक्ष्मतम बात यह है - यदि आप यह नहीं समझते हैं कि क्या करने की आवश्यकता है, तो वह ऐसा नहीं करेगा।

Ansible का उपयोग करके एक रेल एप्लिकेशन को तैनात करने के लिए एक सर्वर को कॉन्फ़िगर करना