ProHoster > Blog > Rêveberî > Sazkirina serverek ku bi karanîna Ansible serîlêdanek Rails bicîh bike

Sazkirina serverek ku bi karanîna Ansible serîlêdanek Rails bicîh bike

Demek berê min hewce kir ku ez çend pirtûkên lîstikê yên Ansible binivîsim da ku serverê ji bo bicîhkirina serîlêdana Rails amade bikim. Û, ecêb, min manualek gav-bi-gav sade nedît. Min nexwest lîstoka yekî din kopî bikim bêyî ku fêm bikim ka çi diqewime, û di dawiyê de neçar bûm ku ez belgeyê bixwînim, her tiştî bi xwe berhev bikim. Dibe ku ez bikaribim bi alîkariya vê gotarê ji kesekî re bibe alîkar ku vê pêvajoyê bilez bike.

Yekem tiştê ku meriv fêm dike ev e ku ansible navgînek hêsan peyda dike ku hûn navnîşek pêşbirkirî ya çalakiyan li ser serverek dûr bi navgîniya SSH-ê pêk bînin. Li vir sêrbazek tune ye, hûn nekarin pêvekek saz bikin û bi doker, çavdêrîkirin û tiştên din ên ji qutikê ve dorvegerek zexm a serîlêdana xwe bistînin. Ji bo ku hûn pirtûkek lîstikê binivîsin, divê hûn zanibin ku hûn bi rastî dixwazin çi bikin û çawa bikin. Ji ber vê yekê ez ji pirtûkên lîstikên amadekirî yên ji GitHub, an gotarên mîna: "Kopî bikin û bimeşînin, ew ê bixebite" ne razî me.

Çi hewcedariya me heye?

Wekî ku min berê jî got, ji bo ku hûn pirtûkek lîstikê binivîsin divê hûn zanibin ku hûn dixwazin çi bikin û çawa bikin. Werin em biryar bidin ku em çi hewce ne. Ji bo serîlêdanek Rails em ê hewceyê çend pakêtên pergalê bikin: nginx, postgresql (redis, hwd.). Wekî din, em hewceyê guhertoyek taybetî ya yaqûtê ne. Baştir e ku meriv wê bi riya rbenv (rvm, asdf...) saz bike. Rêvekirina van hemî wekî bikarhênerek root her gav ramanek xirab e, ji ber vê yekê hûn hewce ne ku bikarhênerek cihêreng biafirînin û mafên wî mîheng bikin. Piştî vê yekê, hûn hewce ne ku koda me li serverê bar bikin, konfigurasyonan ji bo nginx, postgres, hwd kopî bikin û van hemî karûbaran dest pê bikin.

Wekî encamek, rêza çalakiyan wiha ye:

  1. Têkeve wekî root
  2. pakêtên pergalê saz bikin
  3. bikarhênerek nû biafirînin, mafên mîheng bikin, mifteya ssh
  4. pakêtên pergalê (nginx hwd) mîheng bikin û wan bimeşînin
  5. Em di databasê de bikarhênerek diafirînin (hûn dikarin tavilê danegehek biafirînin)
  6. Têkeve wekî bikarhênerek nû
  7. Rbenv û yaqût saz bikin
  8. Sazkirina bundler
  9. Barkirina koda serîlêdanê
  10. Destpêkirina servera Puma

Digel vê yekê, qonaxên paşîn dikarin bi karanîna capistrano werin kirin, bi kêmî ve ew dikare kodê di pelrêçên berdanê de kopî bike, li ser bicîhkirina serketî berdanê bi simlinkek veguhezîne, konfigurasyonan ji pelrêçek hevpar kopî bike, puma ji nû ve bide destpêkirin, hwd. Hemî ev dikare bi karanîna Ansible were kirin, lê çima?

Struktura pelê

Ansible hişk heye avahiya pelê ji bo hemî pelên we, ji ber vê yekê çêtirîn e ku hûn hemî di pelrêçek cûda de biparêzin. Digel vê yekê, ew qas ne girîng e ka ew ê di serîlêdana railan bixwe de be, an ji hev veqetîne. Hûn dikarin pelan di depoyek git ya cihê de hilînin. Bi kesane, min herî rehet dît ku di pelrêça /config-ê ya serîlêdana rails de pelrêçek bêserûber biafirînim û her tiştî di yek depoyê de hilînim.

Pirtûka lîstikê ya hêsan

Playbook pelek yml ye ku, bi karanîna hevoksaziya taybetî, diyar dike ka Ansible divê çi bike û çawa bike. Ka em yekem pirtûka lîstikê ya ku tiştek nake biafirînin:

---
- name: Simple playbook
  hosts: all

Li vir em tenê dibêjin ku lîstika me tê gotin Simple Playbook û divê naveroka wê ji bo hemî mêvandaran were darve kirin. Em dikarin wê di pelrêça /ansible bi navê xwe hilînin playbook.yml û hewl bidin ku birevin:

ansible-playbook ./playbook.yml

PLAY [Simple Playbook] ************************************************************************************************************************************
skipping: no hosts matched

Ansible dibêje ku ew mêvandarên ku bi hemî navnîşê re hevber dikin nas nake. Divê ew di navnîşek taybetî de bêne navnîş kirin pelê envanterê.

Ka em wê di heman pelrêça ansible de biafirînin:

123.123.123.123

Bi vî rengî em bi tenê mêvandarê diyar dikin (bi îdeal mêvandarê VPS-ya me ya ji bo ceribandinê, an jî hûn dikarin hosteya herêmî tomar bikin) û wê di bin navê de hilînin. inventory.
Hûn dikarin bi pelê vesazkirinê re ansible biceribînin:

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

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

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

Ger we gihîştina ssh-ê ji mêvandarê diyarkirî re hebe, wê hingê ansible dê di derheqê pergala dûr de agahdariyan ve girêbide û berhev bike. (TASKê ya xwerû [Civandina Rastiyan]) piştî ku ew ê raporek kurt li ser darvekirinê bide (PLAY RECAP).

Ji hêla xwerû ve, girêdan navê bikarhênerê ku hûn di binê pergalê de têketinê bikar tîne. Bi îhtîmalek mezin dê ne li ser mêvandar be. Di pelê pirtûka lîstikê de, hûn dikarin diyar bikin ku kîjan bikarhêner bikar bîne ku bi karanîna rêwerza remote_user ve girêdayî bike. Di heman demê de, agahdariya di derbarê pergalek dûr de pir caran dibe ku ji we re nepêwist be û divê hûn dema xwe winda nekin berhevkirina wê. Ev kar jî dikare bête asteng kirin:

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

Dûv re pirtûka lîstikê biceribînin û pê ewle bibin ku girêdan dixebite. (Heke we bikarhênerê root diyar kir, wê hingê hûn hewce ne ku ji bo bidestxistina mafên bilindtir rêbernameya ben: rastîn jî diyar bikin. Wekî ku di belgeyê de hatî nivîsandin: become set to ‘true’/’yes’ to activate privilege escalation. her çend bi tevahî ne diyar e çima).

Dibe ku hûn ê xeletiyek bistînin ku ji ber vê rastiyê ye ku ansible nikare wergêrê Python destnîşan bike, wê hingê hûn dikarin wê bi destan diyar bikin:

ansible_python_interpreter: /usr/bin/python3

Hûn dikarin bi fermanê fêr bibin ka li ku derê python heye whereis python.

Sazkirina pakêtên pergalê

Belavkirina standard ya Ansible gelek modulan vedihewîne ji bo ku bi pakêtên pergalê yên cihêreng re bixebitin, ji ber vê yekê em neçar in ku ji ber sedemek skrîptên bash binivîsin. Naha em hewceyê yek ji van modulan in ku pergalê nûve bikin û pakêtên pergalê saz bikin. Li ser VPS-ya min Ubuntu Linux heye, ji ber vê yekê ji bo sazkirina pakêtan ez bikar tînim apt-get и module ji bo wê. Ger hûn pergalek xebitandinê ya cihêreng bikar tînin, wê hingê dibe ku hûn hewceyê modulek cûda bin (ji bîr mekin, min di destpêkê de got ku divê em berê zanibin ka em ê çi û çawa bikin). Lêbelê, hevoksaz dê bi îhtîmalek wekhev be.

Ka em pirtûka xwe ya lîstikê bi karên yekem re temam bikin:

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

Task tam peywira ku Ansible dê li ser serverên dûr pêk bîne ye. Em navekî didin peywirê da ku em bikarin pêkanîna wê di têketinê de bişopînin. Û em, bi karanîna hevoksaziya modulek taybetî, tiştê ku ew hewce dike diyar dikin. Di vê rewşê de apt: update_cache=yes - dibêje ku pakêtên pergalê bi karanîna modula apt nûve bikin. Fermana duyemîn hinekî tevlihevtir e. Em navnîşek pakêtan derbasî modula apt dikin û dibêjin ku ew in state divê bibe present, ango em dibêjin van pakêtan saz bikin. Bi vî rengî, em dikarin ji wan re bibêjin ku wan jêbikin, an jî bi tenê guhertina wan nûve bikin state. Ji kerema xwe bala xwe bidin ku ji bo ku rail bi postgresql re bixebitin em hewceyê pakêta postgresql-contrib e, ya ku em nuha saz dikin. Dîsa, hûn hewce ne ku vê yekê zanibin û bikin; aqil bi serê xwe wê vê yekê neke.

Dûv re pirtûka lîstikê biceribînin û kontrol bikin ka pakêt hatine saz kirin.

Afirandina bikarhênerên nû.

Ji bo ku bi bikarhêneran re bixebite, Ansible jî modulek - bikarhêner heye. Ka em peywirek din lê zêde bikin (min beşên jixwe naskirî yên pirtûka lîstikê li pişt şîroveyan veşart da ku her carê wê bi tevahî kopî nekim): 

---
- name: Simple playbook
  # ...
  tasks:
    # ...
    - name: Add a new user
      user:
        name: my_user
        shell: /bin/bash
        password: "{{ 123qweasd | password_hash('sha512') }}"

Em bikarhênerek nû diafirînin, ji bo wê şêl û şîfreyek saz dikin. Û paşê em bi gelek pirsgirêkan re rû bi rû ne. Ger hewce be ku navên bikarhêner ji bo mêvandarên cûda cûda bin? Û hilanîna şîfreyê di nivîsa zelal a di lîstikê de ramanek pir xirab e. Ji bo destpêkê, em navê bikarhêner û şîfreyê têxin nav guherbaran, û berbi dawiya gotarê ez ê nîşan bidim ka meriv çawa şîfreyê şîfre dike.

---
- name: Simple playbook
  # ...
  tasks:
    # ...
    - name: Add a new user
      user:
        name: "{{ user }}"
        shell: /bin/bash
        password: "{{ user_password | password_hash('sha512') }}"

Guherbarên di pirtûkên lîstikê de bi karanîna brayên ducarî têne danîn.

Em ê di pelê depoyê de nirxên guherbaran destnîşan bikin:

123.123.123.123

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

Ji kerema xwe dîrektîfê hişyar bikin [all:vars] - ew dibêje ku bloka paşîn a nivîsê guhêrbar (vars) ne û ew ji bo hemî mêvandar (hemû) têne sepandin.

Dîzam jî balkêş e "{{ user_password | password_hash('sha512') }}". Tişt ev e ku ansible bikarhêner bi rêya saz nake user_add mîna ku hûn wê bi destan bikin. Û ew rasterast hemî daneyan hildibijêre, ji ber vê yekê divê em şîfreyê jî di pêş de veguherînin haş, ya ku ev ferman dike.

Werin em bikarhênerê xwe li koma sudo zêde bikin. Lêbelê, berî vê yekê divê em piştrast bikin ku komek wusa heye ji ber ku kes dê vê yekê ji me re neke:

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

Her tişt pir hêsan e, me modulek komê jî heye ji bo afirandina koman, bi hevoksaziyek pir dişibihe apt. Wê hingê bes e ku meriv vê komê ji bikarhênerê re tomar bike (groups: "sudo").
Di heman demê de bikêr e ku meriv mifteyek ssh li vê bikarhênerê zêde bike da ku em bikarin bêyî şîfre bikar bînin têkevinê:

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

Di vê rewşê de, sêwirana balkêş e "{{ lookup('file', '~/.ssh/id_rsa.pub') }}" - ew naveroka pelê id_rsa.pub kopî dike (dibe ku navê we cûda be), ango, beşa giştî ya mifteya ssh û wê li navnîşa bişkojkên destûrdar ên bikarhênerê li ser serverê bar dike.

Role

Her sê peywirên ji bo afirandina karanîna bi hêsanî dikarin di yek komê peywiran de werin dabeş kirin, û dê ramanek baş be ku hûn vê komê ji pirtûka lîstika sereke veqetînin da ku ew pir mezin nebe. Ji bo vê armancê, Ansible heye rolên.
Li gorî strûktûra pelê ya ku di destpêkê de hatî destnîşan kirin, pêdivî ye ku rol di pelrêça rolên cihêreng de werin danîn, ji bo her rolê pelrêçek cûda bi heman navî heye, di hundurê peywir, pel, şablon, hwd.
Ka em strukturek pelê biafirînin: ./ansible/roles/user/tasks/main.yml (sereke pelê sereke ye ku dê were barkirin û darve kirin dema ku rolek bi lîstika lîstikê ve girêdayî ye; pelên rola din dikarin pê ve girêdayî bibin). Naha hûn dikarin hemî karên ku bi bikarhêner ve girêdayî ne veguhezînin vê pelê:

# 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

Di lîstika sereke de, divê hûn diyar bikin ku hûn rola bikarhêner bikar bînin:

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

Di heman demê de, dibe ku watedar be ku pergalê berî hemî karên din nûve bikin; ji bo vê yekê, hûn dikarin navê blokê biguherînin tasks ku ew tê de têne destnîşan kirin pre_tasks.

Sazkirina nginx

Divê me jixwe Nginx sazkirî be; pêdivî ye ku em wê mîheng bikin û bimeşînin. Werin em tavilê di rola xwe de bikin. Ka em strukturek pelê biafirînin:

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

Niha em pel û şablonan hewce ne. Cûdahiya wan ev e ku ansible pelan rasterast, wekî ku ye, kopî dike. Û pêdivî ye ku şablon xwedan pêveka j2 be û ew dikarin bi karanîna heman kelûpelên ducarî bi karanîna nirxên guhêrbar bikar bînin.

Ka em nginx tê de çalak bikin main.yml dosî. Ji bo vê yekê me modulek pergalê heye:

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

Li vir em ne tenê dibêjin ku divê nginx were destpêkirin (ango em wê bidin destpêkirin), lê em tavilê dibêjin ku divê ew were çalak kirin.
Naha em pelên mîhengê kopî bikin:

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

Em pelê veavakirina sereke ya nginx diafirînin (hûn dikarin wê rasterast ji serverê bigirin, an bi xwe binivîsin). Û her weha pelê veavakirinê ji bo serîlêdana me di pelrêça sites_available de (ev ne hewce ye lê bikêr e). Di rewşa yekem de, em modula kopîkirinê bikar tînin ku pelan kopî bikin (divê pel tê de be /ansible/roles/nginx/files/nginx.conf). Di ya duyemîn de, em şablonê kopî dikin, li şûna nirxên guhêrbaran. Divê şablon tê de be /ansible/roles/nginx/templates/my_app.j2). Û dibe ku tiştek mîna vê xuya bike:

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

Bala xwe bidin insertan {{ app_name }}, {{ app_path }}, {{ server_name }}, {{ inventory_hostname }} - ev hemî guhêrbar in ku nirxên wan Ansible dê berî kopîkirinê biguhezîne şablonê. Ger hûn pirtûkek lîstikê ji bo komên cûda yên mêvandar bikar bînin ev bikêr e. Mînakî, em dikarin pelê depoya xwe zêde bikin:

[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

Ger em naha pirtûka xweya lîstikê bidin destpêkirin, ew ê ji bo her du mêvandaran peywirên diyarkirî pêk bîne. Lê di heman demê de, ji bo mêvandarek sehneyê, guhêrbar dê ji yên hilberînê cûda bin, û ne tenê di rol û pirtûkên lîstikê de, lê di heman demê de di mîhengên nginx de jî. {{ inventory_hostname }} ne hewce ye ku di pelê envanterê de were destnîşankirin - ev guhêrbar ansible taybet û mazûvaniya ku pirtûka lîstikê niha tê xebitandin li wir tê hilanîn.
Heke hûn dixwazin ji bo çend hosteyan pelek envanterê hebe, lê tenê ji bo yek komê bixebite, ev dikare bi fermana jêrîn were kirin:

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

Vebijarkek din ev e ku ji bo komên cûda pelên envanterê yên cihêreng hebin. An jî heke hûn gelek mêvandarên cûda hebin hûn dikarin her du nêzîkatiyan hev bikin.

Ka em vegerin ser sazkirina nginx. Piştî kopîkirina pelên vesazkirinê, pêdivî ye ku em di sites_enabled-a my_app.conf-ê de ji sites_available symlinkek çêbikin. Û nginx ji nû ve bidin destpêkirin.

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

Li vir her tişt sade ye - dîsa modulên asayî yên bi hevoksaziyek pir standard. Lê xalek heye. Ti wateya ku her carê nginx ji nû ve bidin destpêkirin tune. We bala xwe dayê ku em fermanên mîna: "vê wusa bikin" nanivîsin, hevoksazî bêtir wekî "divê ev rewş hebe" xuya dike. Û pir caran ev e ku meriv çawa kar dike. Ger kom jixwe hebe, an pakêta pergalê jixwe hatî saz kirin, wê hingê ansible dê vê yekê kontrol bike û peywirê biavêje. Di heman demê de, heke pelan bi tevahî bi ya ku jixwe li ser serverê ye li hev bikin dê neyên kopî kirin. Em dikarin ji vê yekê sûd werbigirin û nginx-ê ji nû ve bidin destpêkirin tenê heke pelên vesazkirinê hatine guhertin. Ji bo vê yekê rêwerzek qeydkirinê heye:

# 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

Ger yek ji pelên vesazkirinê biguhere, dê kopiyek were çêkirin û guhêrbar dê were tomar kirin restart_nginx. Û tenê heke ev guhêrbar hatibe qeyd kirin dê karûbar ji nû ve were destpêkirin.

Û, bê guman, hûn hewce ne ku rola nginx li pirtûka lîstika sereke zêde bikin.

Sazkirina postgresql

Pêdivî ye ku em postgresql bi karanîna systemd-ê bi heman awayê ku me bi nginx re kir çalak bikin, û her weha bikarhênerek ku em ê bikar bînin ji bo gihîştina databas û databasê bixwe bikar bînin.
Werin em rolek çêbikin /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 }}"

Ez ê diyar nekim ka meriv çawa guhêrbaran li ser envanterê zêde dike, ev jixwe gelek caran hatiye kirin, û hem jî hevoksaziya modulên postgresql_db û postgresql_user. Agahiyên bêtir dikarin di belgeyê de bibînin. Rêbernameya herî balkêş li vir e become_user: postgres. Rastî ev e ku ji hêla xwerû, tenê bikarhênerê postgres xwedan databasa postgresql û tenê herêmî ye. Ev rêwerz rê dide me ku em li ser navê vî bikarhêner fermanan bi cih bînin (bê guman heke gihîştina me hebe).
Di heman demê de, dibe ku hûn xêzek li pg_hba.conf zêde bikin da ku bikarhênerek nû bigihîje databasê. Ev dikare bi heman rengî were kirin ku me veavakirina nginx guhert.

Û bê guman, hûn hewce ne ku rola postgresql li pirtûka lîstika sereke zêde bikin.

Sazkirina ruby ​​bi riya rbenv

Ansible modulên xebata bi rbenv re tune, lê ew bi klonkirina depoyek git ve tê saz kirin. Ji ber vê yekê, ev pirsgirêk dibe ya herî ne-standard. Werin em ji bo wê rolekê çêbikin /ansible/roles/ruby_rbenv/main.yml û em dest bi dagirtina wê bikin:

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

Em dîsa rêbernameya bene_user bikar tînin da ku di bin bikarhênerê ku me ji bo van armancan çêkiriye bixebitin. Ji ber ku rbenv di pelrêça xweya malê de hatî saz kirin, û ne gerdûnî. Û em modula git-ê jî bikar tînin da ku depoyê klon bikin, repo û dest diyar bikin.

Dûv re, pêdivî ye ku em rbenv init li bashrc tomar bikin û li wir rbenv li PATH zêde bikin. Ji bo vê me modula lineinfile heye:

- 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 -)"'

Dûv re hûn hewce ne ku ruby_build saz bikin:

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

Û di dawiyê de ruby ​​saz bikin. Ev bi riya rbenv, ango, bi tenê bi fermana bash tê kirin:

- name: Install ruby
  become_user: "{{ user }}"
  shell: |
    export PATH="${HOME}/.rbenv/bin:${PATH}"
    eval "$(rbenv init -)"
    rbenv install {{ ruby_version }}
  args:
    executable: /bin/bash

Em dibêjin kîjan fermanê û bi çi pêk bînin. Lêbelê, li vir em rastî vê yekê tên ku ansible berî ku fermanan bimeşîne koda ku di bashrc de heye naxebitîne. Ev tê wê wateyê ku rbenv dê rasterast di heman nivîsê de were destnîşankirin.

Pirsgirêka din ji ber vê yekê ye ku fermana şêlê ji hêla guncan ve xwedî dewletek e. Ango, dê kontrolek otomatîkî neyê kirin ka gelo ev guhertoya ruby ​​sazkirî ye an na. Em dikarin bi xwe vê yekê bikin:

- 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

Tiştê ku dimîne sazkirina bundler e:

- name: Install bundler
  become_user: "{{ user }}"
  shell: |
    export PATH="${HOME}/.rbenv/bin:${PATH}"
    eval "$(rbenv init -)"
    gem install bundler

Û dîsa, rola me ruby_rbenv li pirtûka lîstika sereke zêde bike.

Pelên hevpar.

Bi gelemperî, sazkirin dikare li vir were qedandin. Dûv re, ya ku dimîne ev e ku meriv capistrano bimeşîne û ew ê kodê bixwe kopî bike, pelrêçayên pêwîst biafirîne û serîlêdanê bide destpêkirin (heke her tişt rast were mîheng kirin). Lêbelê, capistrano bi gelemperî pelên vesazkirinê yên din hewce dike, wek database.yml an .env Ew dikarin mîna pel û şablonên ji bo nginx werin kopî kirin. Tenê yek hûrgelek heye. Berî kopîkirina pelan, hûn hewce ne ku ji wan re avahiyek pelrêça biafirînin, tiştek mîna vê:

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

em tenê pelrêçek destnîşan dikin û heke hewce be dê ansible bixweber yên dêûbav biafirîne.

Ansible Vault

Me berê rastî vê yekê hat ku guhêrbar dikarin daneyên veşartî yên wekî şîfreya bikarhênerê hebin. Ger we afirandiye .env pelê ji bo serîlêdanê, û database.yml wê demê divê hîn bêhtir daneyên wisa krîtîk hebin. Wê baş be ku meriv wan ji çavên xerîb veşêre. Ji bo vê armancê tê bikaranîn kasa bêserûber.

Ka em ji bo guherbaran pelek çêkin /ansible/vars/all.yml (li vir hûn dikarin ji bo komên cûda yên mêvandar pelên cûda biafirînin, mîna pelê envanterê: production.yml, staging.yml, hwd.).
Hemî guhêrbarên ku divê werin şîfrekirin divê bi karanîna hevoksaziya standard yml veguhezînin vê pelê:

# 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

Piştî ku ev pel dikare bi fermanê were şîfre kirin:

ansible-vault encrypt ./vars/all.yml

Bi xwezayî, dema şîfrekirinê, hûn ê hewce bikin ku şîfreyek ji bo deşîfrekirinê saz bikin. Hûn dikarin bibînin ku piştî bangkirina vê fermanê dê di hundurê pelê de çi be.

Bi alîkariya alîkariya ansible-vault decrypt pel dikare were deşîfrekirin, guherandin û dûv re dîsa were şîfrekirin.

Ji bo xebatê ne hewce ye ku hûn pelê deşîfre bikin. Hûn wê bi şîfrekirî hilînin û pirtûka lîstikê bi argumanan dimeşînin --ask-vault-pass. Ansible dê şîfreyê bipirse, guherbaran bigire, û peywiran pêk bîne. Hemî dane dê şîfrekirî bimînin.

Fermana bêkêmasî ya ji bo çend komên mêvandar û vault ansible dê bi vî rengî xuya bike:

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

Lê ez ê tam nivîsa lîstik û rolan nedim we, bi xwe binivîsin. Ji ber ku ansible wusa ye - heke hûn fêm nakin ka çi divê were kirin, wê hingê ew ê ji we re neke.

Source: www.habr.com

Add a comment