Sio muda mrefu uliopita nilihitaji kuandika vitabu kadhaa vya kucheza vya Ansible kuandaa seva kwa kupeleka programu ya Reli. Na, kwa kushangaza, sikupata mwongozo rahisi wa hatua kwa hatua. Sikutaka kunakili kitabu cha kucheza cha mtu mwingine bila kuelewa kinachotokea, na mwishowe nilipaswa kusoma nyaraka, kukusanya kila kitu mwenyewe. Labda ninaweza kumsaidia mtu kuharakisha mchakato huu kwa msaada wa nakala hii.
Jambo la kwanza kuelewa ni kwamba ansible hukupa kiolesura rahisi kufanya orodha iliyoainishwa ya vitendo kwenye seva ya mbali kupitia SSH. Hakuna uchawi hapa, huwezi kusakinisha programu-jalizi na kupata utumaji wa programu yako kwa muda usiopungua sifuri ukiwa na dokta, ufuatiliaji na vitu vingine vyema nje ya boksi. Ili kuandika kitabu cha kucheza, lazima ujue ni nini hasa unataka kufanya na jinsi ya kuifanya. Ndiyo maana sijaridhika na vitabu vya kucheza vilivyotengenezwa tayari kutoka GitHub, au makala kama vile: "Nakili na ukimbie, itafanya kazi."
Tunahitaji nini?
Kama nilivyosema tayari, ili kuandika kitabu cha kucheza unahitaji kujua nini unataka kufanya na jinsi ya kuifanya. Hebu tuamue kile tunachohitaji. Kwa programu ya reli tutahitaji vifurushi kadhaa vya mfumo: nginx, postgresql (redis, nk). Kwa kuongeza, tunahitaji toleo maalum la ruby. Ni bora kuiweka kupitia rbenv (rvm, asdf...). Kuendesha haya yote kama mtumiaji wa mizizi daima ni wazo mbaya, kwa hivyo unahitaji kuunda mtumiaji tofauti na kusanidi haki zake. Baada ya hayo, unahitaji kupakia msimbo wetu kwa seva, nakala ya usanidi wa nginx, postgres, nk na uanze huduma hizi zote.
Kama matokeo, mlolongo wa vitendo ni kama ifuatavyo.
- Ingia kama mzizi
- kufunga vifurushi vya mfumo
- unda mtumiaji mpya, sanidi haki, kitufe cha ssh
- sanidi vifurushi vya mfumo (nginx nk) na uendeshe
- Tunaunda mtumiaji kwenye hifadhidata (unaweza kuunda hifadhidata mara moja)
- Ingia kama mtumiaji mpya
- Weka rbenv na ruby
- Kufunga kifurushi
- Inapakia msimbo wa programu
- Inazindua seva ya Puma
Kwa kuongezea, hatua za mwisho zinaweza kufanywa kwa kutumia capistrano, angalau nje ya kisanduku inaweza kunakili nambari kwenye saraka za kutolewa, kubadilisha toleo na ulinganifu wakati wa kupelekwa kwa mafanikio, kunakili usanidi kutoka kwa saraka iliyoshirikiwa, kuanzisha upya puma, nk. Haya yote yanaweza kufanywa kwa kutumia Ansible, lakini kwa nini?
Muundo wa faili
Ansible ina kali kwa faili zako zote, kwa hivyo ni bora kuziweka zote kwenye saraka tofauti. Kwa kuongeza, sio muhimu sana ikiwa itakuwa katika matumizi ya reli yenyewe, au tofauti. Unaweza kuhifadhi faili kwenye hazina tofauti ya git. Binafsi, niliona ni rahisi zaidi kuunda saraka inayowezekana katika saraka ya / usanidi wa programu ya reli na kuhifadhi kila kitu kwenye hazina moja.
Playbook Rahisi
Playbook ni faili ya yml ambayo, kwa kutumia syntax maalum, inaelezea kile Ansible inapaswa kufanya na jinsi gani. Wacha tuunde kitabu cha kwanza cha kucheza ambacho hakifanyi chochote:
---
- name: Simple playbook
hosts: allHapa tunasema tu kwamba kitabu chetu cha kucheza kinaitwa Simple Playbook na kwamba yaliyomo ndani yake yanapaswa kutekelezwa kwa majeshi yote. Tunaweza kuihifadhi katika saraka inayowezekana na jina playbook.yml na jaribu kukimbia:
ansible-playbook ./playbook.yml
PLAY [Simple Playbook] ************************************************************************************************************************************
skipping: no hosts matchedAnsible anasema haijui wapangishi wowote wanaolingana na orodha yote. Lazima ziorodheshwe katika maalum .
Wacha tuiunda katika saraka sawa inayowezekana:
123.123.123.123Hivi ndivyo tunavyobainisha mwenyeji (kwa kweli mwenyeji wa VPS yetu kwa majaribio, au unaweza kusajili mwenyeji) na kuihifadhi chini ya jina. inventory.
Unaweza kujaribu kutekelezwa na faili ya hesabu:
ansible-playbook ./playbook.yml -i inventory
PLAY [Simple Playbook] ************************************************************************************************************************************
TASK [Gathering Facts] ************************************************************************************************************************************
PLAY RECAP ************************************************************************************************************************************Ikiwa una ufikiaji wa ssh kwa seva pangishi iliyobainishwa, basi ansible itaunganisha na kukusanya taarifa kuhusu mfumo wa mbali. (KAZI chaguomsingi [Kukusanya Ukweli]) baada ya hapo itatoa ripoti fupi kuhusu utekelezaji (PLAY RECAP).
Kwa chaguo-msingi, uunganisho hutumia jina la mtumiaji ambalo umeingia kwenye mfumo. Uwezekano mkubwa zaidi hautakuwa kwenye mwenyeji. Katika faili ya kitabu cha kucheza, unaweza kubainisha ni mtumiaji gani utamtumia kuunganisha kwa kutumia maelekezo ya remote_user. Pia, habari kuhusu mfumo wa mbali mara nyingi inaweza kuwa sio lazima kwako na hupaswi kupoteza muda kuikusanya. Jukumu hili pia linaweza kulemazwa:
---
- name: Simple playbook
hosts: all
remote_user: root
become: true
gather_facts: noJaribu kuendesha kitabu cha kucheza tena na uhakikishe kuwa muunganisho unafanya kazi. (Ikiwa ulibainisha mzizi mtumiaji, basi unahitaji pia kubainisha kuwa: maagizo ya kweli ili kupata haki za juu. Kama ilivyoandikwa katika hati: become set to βtrueβ/βyesβ to activate privilege escalation. ingawa haijulikani kabisa kwa nini).
Labda utapokea kosa linalosababishwa na ukweli kwamba ansible haiwezi kuamua mkalimani wa Python, basi unaweza kutaja kwa mikono:
ansible_python_interpreter: /usr/bin/python3 Unaweza kujua ni wapi unayo python na amri whereis python.
Kufunga vifurushi vya mfumo
Usambazaji wa kawaida wa Ansible ni pamoja na moduli nyingi za kufanya kazi na vifurushi anuwai vya mfumo, kwa hivyo sio lazima tuandike hati za bash kwa sababu yoyote. Sasa tunahitaji mojawapo ya moduli hizi kusasisha mfumo na kusakinisha vifurushi vya mfumo. Nina Ubuntu Linux kwenye VPS yangu, kwa hivyo kusanikisha vifurushi ninavyotumia apt-get ΠΈ . Ikiwa unatumia mfumo tofauti wa uendeshaji, basi unaweza kuhitaji moduli tofauti (kumbuka, nilisema mwanzoni kwamba tunahitaji kujua mapema nini na jinsi tutakavyofanya). Walakini, syntax itawezekana kuwa sawa.
Wacha tuongeze kitabu chetu cha kucheza na kazi za kwanza:
---
- 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: presentKazi ndiyo kazi ambayo Ansible itafanya kwenye seva za mbali. Tunaipa kazi hiyo jina ili tuweze kufuatilia utekelezaji wake kwenye logi. Na tunaelezea, kwa kutumia syntax ya moduli maalum, nini inahitaji kufanya. Kwa kesi hii apt: update_cache=yes - inasema kusasisha vifurushi vya mfumo kwa kutumia moduli inayofaa. Amri ya pili ni ngumu zaidi. Tunapitisha orodha ya vifurushi kwa moduli apt na kusema kwamba ni state inapaswa kuwa present, yaani, tunasema kufunga vifurushi hivi. Vivyo hivyo, tunaweza kuwaambia wazifute, au kusasisha kwa kubadilisha tu state. Tafadhali kumbuka kuwa ili reli zifanye kazi na postgresql tunahitaji kifurushi cha postgresql-contrib, ambacho tunasakinisha sasa. Tena, unahitaji kujua na kufanya hivi; busara peke yake haitafanya hivi.
Jaribu kuendesha kitabu cha kucheza tena na uangalie kuwa vifurushi vimesakinishwa.
Kuunda watumiaji wapya.
Kufanya kazi na watumiaji, Ansible pia ina moduli - mtumiaji. Wacha tuongeze kazi moja zaidi (nilificha sehemu zinazojulikana za kitabu cha kucheza nyuma ya maoni ili nisikinakili kabisa kila wakati):
---
- name: Simple playbook
# ...
tasks:
# ...
- name: Add a new user
user:
name: my_user
shell: /bin/bash
password: "{{ 123qweasd | password_hash('sha512') }}"Tunaunda mtumiaji mpya, kuweka schell na nenosiri kwa ajili yake. Na kisha tunaingia kwenye shida kadhaa. Je, ikiwa majina ya watumiaji yanahitaji kuwa tofauti kwa wapangishaji tofauti? Na kuhifadhi nenosiri katika maandishi wazi katika kitabu cha kucheza ni wazo mbaya sana. Kuanza, hebu tuweke jina la mtumiaji na nenosiri katika vigezo, na kuelekea mwisho wa makala nitaonyesha jinsi ya kusimba nenosiri.
---
- name: Simple playbook
# ...
tasks:
# ...
- name: Add a new user
user:
name: "{{ user }}"
shell: /bin/bash
password: "{{ user_password | password_hash('sha512') }}"Vigezo vimewekwa katika vitabu vya kucheza kwa kutumia braces mbili za curly.
Tutaonyesha maadili ya anuwai kwenye faili ya hesabu:
123.123.123.123
[all:vars]
user=my_user
user_password=123qweasdTafadhali kumbuka maagizo [all:vars] - inasema kwamba kizuizi kinachofuata cha maandishi ni vigezo (vars) na vinatumika kwa majeshi yote (wote).
Ubunifu pia unavutia "{{ user_password | password_hash('sha512') }}". Jambo ni kwamba ansible haisakinishi mtumiaji kupitia user_add kama ungefanya kwa mikono. Na huhifadhi data zote moja kwa moja, ndiyo sababu lazima pia tubadilishe nenosiri kuwa heshi mapema, ambayo ndiyo amri hii hufanya.
Wacha tuongeze mtumiaji wetu kwenye kikundi cha sudo. Walakini, kabla ya hii tunahitaji kuhakikisha kuwa kikundi kama hicho kipo kwa sababu hakuna mtu atakayetufanyia hivi:
---
- 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"Kila kitu ni rahisi sana, pia tunayo moduli ya kikundi ya kuunda vikundi, na syntax inayofanana sana na apt. Basi inatosha kusajili kikundi hiki kwa mtumiaji (groups: "sudo").
Ni muhimu pia kuongeza kitufe cha ssh kwa mtumiaji huyu ili tuweze kuingia kwa kutumia bila nenosiri:
---
- 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: presentKatika kesi hii, kubuni ni ya kuvutia "{{ lookup('file', '~/.ssh/id_rsa.pub') }}" - inakili yaliyomo kwenye faili ya id_rsa.pub (jina lako linaweza kuwa tofauti), yaani, sehemu ya umma ya ufunguo wa ssh na kuipakia kwenye orodha ya funguo zilizoidhinishwa kwa mtumiaji kwenye seva.
Wajibu
Kazi zote tatu za kuunda matumizi zinaweza kuainishwa kwa urahisi katika kundi moja la kazi, na lingekuwa wazo nzuri kuhifadhi kikundi hiki kando na kitabu kikuu cha kucheza ili kisizidi kuwa kikubwa. Kwa kusudi hili, Ansible ina .
Kulingana na muundo wa faili ulioonyeshwa mwanzoni, majukumu lazima yawekwe kwenye saraka tofauti ya majukumu, kwa kila jukumu kuna saraka tofauti iliyo na jina moja, ndani ya kazi, faili, templeti, nk saraka.
Wacha tuunda muundo wa faili: ./ansible/roles/user/tasks/main.yml (kuu ni faili kuu ambayo itapakiwa na kutekelezwa wakati jukumu limeunganishwa kwenye kitabu cha kucheza; faili zingine za jukumu zinaweza kuunganishwa kwayo). Sasa unaweza kuhamisha kazi zote zinazohusiana na mtumiaji hadi faili hii:
# 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: presentKatika kitabu kikuu cha kucheza, lazima ubainishe ili kutumia jukumu la mtumiaji:
---
- 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:
- userPia, inaweza kuwa na maana kusasisha mfumo kabla ya kazi zingine zote; kwa kufanya hivyo, unaweza kubadilisha jina la kizuizi tasks ambamo zimefafanuliwa ndani pre_tasks.
Kuanzisha nginx
Tunapaswa kuwa tayari na Nginx iliyosanikishwa; tunahitaji kuisanidi na kuiendesha. Wacha tuifanye mara moja kwenye jukumu. Wacha tuunda muundo wa faili:
- ansible
- roles
- nginx
- files
- tasks
- main.yml
- templatesSasa tunahitaji faili na templates. Tofauti kati yao ni kwamba ansible kunakili faili moja kwa moja, kama ilivyo. Na violezo lazima viwe na kiendelezi cha j2 na vinaweza kutumia thamani zinazobadilika kwa kutumia viunga viwili vilivyopindapinda.
Wacha tuwashe nginx ndani main.yml faili. Kwa hili tunayo moduli ya mfumo:
# Copy nginx configs and start it
- name: enable service nginx and start
systemd:
name: nginx
state: started
enabled: yesHapa hatusemi tu kwamba nginx lazima ianzishwe (yaani, tunaizindua), lakini mara moja tunasema kwamba lazima iwezeshwe.
Sasa hebu tunakili faili za usanidi:
# 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'Tunaunda faili kuu ya usanidi wa nginx (unaweza kuichukua moja kwa moja kutoka kwa seva, au uandike mwenyewe). Na pia faili ya usanidi wa programu yetu katika saraka ya tovuti_inapatikana (hii sio lazima lakini ni muhimu). Katika kesi ya kwanza, tunatumia moduli ya nakala kunakili faili (faili lazima iwe ndani /ansible/roles/nginx/files/nginx.conf) Katika pili, tunakili template, tukibadilisha maadili ya vigezo. Kiolezo kinapaswa kuwa ndani /ansible/roles/nginx/templates/my_app.j2) Na inaweza kuonekana kama hii:
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 }};
....
}Makini na kuingiza {{ app_name }}, {{ app_path }}, {{ server_name }}, {{ inventory_hostname }} - hizi ni vigeu vyote ambavyo thamani zake Ansible zitabadilishwa kwenye kiolezo kabla ya kunakili. Hii ni muhimu ikiwa unatumia kitabu cha kucheza kwa vikundi tofauti vya wapangishaji. Kwa mfano, tunaweza kuongeza faili yetu ya hesabu:
[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_appIkiwa sasa tutazindua kitabu chetu cha kucheza, kitafanya kazi zilizobainishwa kwa wapangishaji wote wawili. Lakini wakati huo huo, kwa mwenyeji wa staging, vigezo vitakuwa tofauti na wale wa uzalishaji, na si tu katika majukumu na vitabu vya kucheza, lakini pia katika mipangilio ya nginx. {{ inventory_hostname }} hauitaji kuainishwa kwenye faili ya hesabu - hii na mpangishi ambaye kitabu cha kucheza kinatumika kwa sasa huhifadhiwa hapo.
Ikiwa unataka kuwa na faili ya hesabu kwa majeshi kadhaa, lakini endesha kwa kikundi kimoja tu, hii inaweza kufanywa kwa amri ifuatayo:
ansible-playbook -i inventory ./playbook.yml -l "staging"Chaguo jingine ni kuwa na faili tofauti za hesabu kwa vikundi tofauti. Au unaweza kuchanganya mbinu hizi mbili ikiwa una wapangishaji wengi tofauti.
Wacha turudi kusanidi nginx. Baada ya kunakili faili za usanidi, tunahitaji kuunda ulinganifu katika sitest_enabled kwa my_app.conf kutoka kwa sites_available. Na anza tena 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: restartedKila kitu ni rahisi hapa - tena moduli zinazofaa na syntax ya kawaida. Lakini kuna hatua moja. Hakuna maana ya kuanza tena nginx kila wakati. Umeona kuwa hatuandiki amri kama: "fanya hivi hivi", sintaksia inaonekana zaidi kama "hii inapaswa kuwa na hali hii". Na mara nyingi hii ndio jinsi busara inavyofanya kazi. Ikiwa kikundi tayari kipo, au kifurushi cha mfumo tayari kimewekwa, basi ansible itaangalia hii na kuruka kazi. Pia, faili hazitanakiliwa ikiwa zinalingana kabisa na kile ambacho tayari kiko kwenye seva. Tunaweza kuchukua fursa hii na kuanzisha tena nginx ikiwa faili za usanidi zimebadilishwa. Kuna maagizo ya rejista kwa hili:
# 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.changedIkiwa faili moja ya usanidi itabadilika, nakala itafanywa na utofauti utasajiliwa restart_nginx. Na ikiwa tu utaftaji huu umesajiliwa, huduma itaanzishwa tena.
Na, bila shaka, unahitaji kuongeza jukumu la nginx kwenye kitabu kikuu cha kucheza.
Kuanzisha postgresql
Tunahitaji kuwezesha postgresql kutumia systemd kwa njia ile ile kama tulivyofanya na nginx, na pia kuunda mtumiaji ambaye tutamtumia kufikia hifadhidata na hifadhidata yenyewe.
Wacha tutengeneze jukumu /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 }}"Sitaelezea jinsi ya kuongeza vigezo kwenye hesabu, hii tayari imefanywa mara nyingi, pamoja na syntax ya moduli za postgresql_db na postgresql_user. Habari zaidi inaweza kupatikana katika nyaraka. Maagizo ya kuvutia zaidi hapa ni become_user: postgres. Ukweli ni kwamba kwa chaguo-msingi, mtumiaji wa posta pekee ndiye anayeweza kufikia hifadhidata ya postgresql na ndani tu. Maagizo haya huturuhusu kutekeleza amri kwa niaba ya mtumiaji huyu (ikiwa tuna ufikiaji, bila shaka).
Unaweza pia kuongeza laini kwenye pg_hba.conf ili kuruhusu ufikiaji wa mtumiaji mpya kwenye hifadhidata. Hii inaweza kufanywa kwa njia ile ile kama tulivyobadilisha usanidi wa nginx.
Na bila shaka, unahitaji kuongeza jukumu la postgresql kwenye kitabu kikuu cha kucheza.
Kufunga ruby ββββkupitia rbenv
Ansible haina moduli za kufanya kazi na rbenv, lakini imewekwa kwa kuunda hazina ya git. Kwa hiyo, tatizo hili linakuwa lisilo la kawaida zaidi. Hebu tumtengenezee jukumu /ansible/roles/ruby_rbenv/main.yml na wacha tuanze kuijaza:
# Install rbenv and ruby
- name: Install rbenv
become_user: "{{ user }}"
git: repo=https://github.com/rbenv/rbenv.git dest=~/.rbenvTunatumia tena mwongozo wa kuwa_mtumiaji kufanya kazi chini ya mtumiaji tuliyemuunda kwa madhumuni haya. Kwa kuwa rbenv imewekwa kwenye saraka yake ya nyumbani, na sio ulimwenguni kote. Na pia tunatumia moduli ya git kuiga hazina, tukibainisha repo na dest.
Ifuatayo, tunahitaji kusajili rbenv init katika bashrc na kuongeza rbenv kwa PATH hapo. Kwa hili tunayo moduli ya 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 -)"'Kisha unahitaji kusakinisha ruby_build:
- name: Install ruby-build
become_user: "{{ user }}"
git: repo=https://github.com/rbenv/ruby-build.git dest=~/.rbenv/plugins/ruby-buildNa hatimaye kufunga ruby. Hii inafanywa kupitia rbenv, ambayo ni, kwa amri ya bash:
- name: Install ruby
become_user: "{{ user }}"
shell: |
export PATH="${HOME}/.rbenv/bin:${PATH}"
eval "$(rbenv init -)"
rbenv install {{ ruby_version }}
args:
executable: /bin/bashTunasema ni amri gani ya kutekeleza na kwa nini. Walakini, hapa tunakutana na ukweli kwamba ansible haiendeshi nambari iliyomo kwenye bashrc kabla ya kutekeleza amri. Hii inamaanisha kuwa rbenv italazimika kufafanuliwa moja kwa moja kwenye hati sawa.
Shida inayofuata ni kwa sababu ya ukweli kwamba amri ya ganda haina hali kutoka kwa maoni yanayofaa. Hiyo ni, hakutakuwa na ukaguzi wa moja kwa moja ikiwa toleo hili la ruby ββββlimewekwa au la. Tunaweza kufanya hivi sisi wenyewe:
- 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/bashKinachobaki ni kusakinisha bundler:
- name: Install bundler
become_user: "{{ user }}"
shell: |
export PATH="${HOME}/.rbenv/bin:${PATH}"
eval "$(rbenv init -)"
gem install bundlerNa tena, ongeza jukumu letu ruby_rbenv kwenye kitabu kikuu cha kucheza.
Faili zilizoshirikiwa.
Kwa ujumla, usanidi unaweza kukamilika hapa. Ifuatayo, kilichobaki ni kuendesha capistrano na itaiga msimbo yenyewe, kuunda saraka muhimu na kuzindua programu (ikiwa kila kitu kimeundwa kwa usahihi). Walakini, capistrano mara nyingi inahitaji faili za usanidi za ziada, kama vile database.yml au .env Wanaweza kunakiliwa kama faili na violezo vya nginx. Kuna ujanja mmoja tu. Kabla ya kunakili faili, unahitaji kuunda muundo wa saraka kwao, kitu kama hiki:
# Copy shared files for deploy
- name: Ensure shared dir
become_user: "{{ user }}"
file:
path: "{{ app_path }}/shared/config"
state: directorytunabainisha saraka moja tu na inayowezekana itaunda kiotomatiki ya wazazi ikiwa ni lazima.
Vault Ansible
Tayari tumegundua ukweli kwamba vigezo vinaweza kuwa na data ya siri kama vile nenosiri la mtumiaji. Ikiwa umeunda .env faili kwa ajili ya maombi, na database.yml basi lazima kuwe na data muhimu zaidi kama hiyo. Itakuwa nzuri kuwaficha kutoka kwa macho ya nje. Kwa kusudi hili hutumiwa .
Wacha tuunde faili kwa anuwai /ansible/vars/all.yml (hapa unaweza kuunda faili tofauti za vikundi tofauti vya wapangishaji, kama vile kwenye faili ya hesabu: production.yml, staging.yml, n.k).
Vigezo vyote ambavyo lazima visimbwe kwa njia fiche lazima vihamishwe kwa faili hii kwa kutumia sintaksia ya kawaida ya 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_baseBaada ya hapo faili hii inaweza kusimbwa kwa amri:
ansible-vault encrypt ./vars/all.ymlKwa kawaida, wakati wa kusimba, utahitaji kuweka nenosiri kwa usimbuaji. Unaweza kuona nini kitakuwa ndani ya faili baada ya kupiga amri hii.
Kwa njia ya ansible-vault decrypt faili inaweza kusimbwa, kurekebishwa na kisha kusimbwa tena.
Huhitaji kusimbua faili ili kufanya kazi. Unaihifadhi kwa njia fiche na kuendesha kitabu cha kucheza kwa hoja --ask-vault-pass. Ansible itauliza nenosiri, kurejesha vigezo, na kutekeleza majukumu. Data yote itasalia kwa njia fiche.
Amri kamili kwa vikundi kadhaa vya majeshi na vault yenye busara itaonekana kitu kama hiki:
ansible-playbook -i inventory ./playbook.yml -l "staging" --ask-vault-passLakini sitakupa maandishi kamili ya vitabu vya kucheza na majukumu, andika mwenyewe. Kwa sababu busara ni kama hiyo - ikiwa hauelewi kinachohitajika kufanywa, basi haitakufanyia.
Chanzo: mapenzi.com