Ansible ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਰੇਲ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ ਇੱਕ ਸਰਵਰ ਸੈਟ ਕਰਨਾ

ਕੁਝ ਸਮਾਂ ਪਹਿਲਾਂ ਮੈਨੂੰ ਰੇਲਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ ਸਰਵਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਲਈ ਕਈ ਜਵਾਬਦੇਹ ਪਲੇਬੁੱਕ ਲਿਖਣ ਦੀ ਲੋੜ ਸੀ। ਅਤੇ, ਹੈਰਾਨੀ ਦੀ ਗੱਲ ਹੈ ਕਿ, ਮੈਨੂੰ ਇੱਕ ਸਧਾਰਨ ਕਦਮ-ਦਰ-ਕਦਮ ਮੈਨੂਅਲ ਨਹੀਂ ਮਿਲਿਆ. ਮੈਂ ਇਹ ਸਮਝੇ ਬਿਨਾਂ ਕਿਸੇ ਹੋਰ ਦੀ ਪਲੇਬੁੱਕ ਦੀ ਨਕਲ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ ਕਿ ਕੀ ਹੋ ਰਿਹਾ ਹੈ, ਅਤੇ ਅੰਤ ਵਿੱਚ ਮੈਨੂੰ ਸਭ ਕੁਝ ਆਪਣੇ ਆਪ ਇਕੱਠਾ ਕਰਦੇ ਹੋਏ, ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਪਿਆ। ਸ਼ਾਇਦ ਮੈਂ ਇਸ ਲੇਖ ਦੀ ਮਦਦ ਨਾਲ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਵਿੱਚ ਕਿਸੇ ਦੀ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ.

ਸਮਝਣ ਵਾਲੀ ਪਹਿਲੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਜਵਾਬਦੇਹ ਤੁਹਾਨੂੰ SSH ਰਾਹੀਂ ਰਿਮੋਟ ਸਰਵਰ (ਸਰਵਰਾਂ) 'ਤੇ ਕਾਰਵਾਈਆਂ ਦੀ ਪੂਰਵ-ਪ੍ਰਭਾਸ਼ਿਤ ਸੂਚੀ ਕਰਨ ਲਈ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਕੋਈ ਜਾਦੂ ਨਹੀਂ ਹੈ, ਤੁਸੀਂ ਇੱਕ ਪਲੱਗਇਨ ਸਥਾਪਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਡੌਕਰ, ਨਿਗਰਾਨੀ ਅਤੇ ਹੋਰ ਚੀਜ਼ਾਂ ਦੇ ਨਾਲ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ ਤੈਨਾਤੀ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਕ ਪਲੇਬੁੱਕ ਲਿਖਣ ਲਈ, ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਕੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਕਰਨਾ ਹੈ। ਇਸ ਲਈ ਮੈਂ GitHub ਤੋਂ ਤਿਆਰ ਪਲੇਬੁੱਕਾਂ ਜਾਂ ਲੇਖਾਂ ਜਿਵੇਂ ਕਿ: "ਕਾਪੀ ਕਰੋ ਅਤੇ ਚਲਾਓ, ਇਹ ਕੰਮ ਕਰੇਗਾ" ਤੋਂ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਹਾਂ।

ਸਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ?

ਜਿਵੇਂ ਕਿ ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਕਿਹਾ ਹੈ, ਇੱਕ ਪਲੇਬੁੱਕ ਲਿਖਣ ਲਈ ਤੁਹਾਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਕਰਨਾ ਹੈ। ਆਓ ਫੈਸਲਾ ਕਰੀਏ ਕਿ ਸਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ। ਰੇਲਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਸਾਨੂੰ ਕਈ ਸਿਸਟਮ ਪੈਕੇਜਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ: nginx, postgresql (redis, ਆਦਿ)। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਾਨੂੰ ਰੂਬੀ ਦੇ ਇੱਕ ਖਾਸ ਸੰਸਕਰਣ ਦੀ ਲੋੜ ਹੈ. ਇਸਨੂੰ rbenv (rvm, asdf...) ਰਾਹੀਂ ਇੰਸਟਾਲ ਕਰਨਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ। ਇੱਕ ਰੂਟ ਉਪਭੋਗਤਾ ਦੇ ਤੌਰ ਤੇ ਇਹ ਸਭ ਚਲਾਉਣਾ ਹਮੇਸ਼ਾਂ ਇੱਕ ਬੁਰਾ ਵਿਚਾਰ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਖਰਾ ਉਪਭੋਗਤਾ ਬਣਾਉਣ ਅਤੇ ਉਸਦੇ ਅਧਿਕਾਰਾਂ ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਸਾਡੇ ਕੋਡ ਨੂੰ ਸਰਵਰ 'ਤੇ ਅਪਲੋਡ ਕਰਨ, nginx, postgres, ਆਦਿ ਲਈ ਸੰਰਚਨਾ ਦੀ ਨਕਲ ਕਰਨ ਅਤੇ ਇਹ ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਨਤੀਜੇ ਵਜੋਂ, ਕਾਰਵਾਈਆਂ ਦਾ ਕ੍ਰਮ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ:

1. ਰੂਟ ਦੇ ਤੌਰ 'ਤੇ ਲਾਗਇਨ ਕਰੋ
2. ਸਿਸਟਮ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ
3. ਇੱਕ ਨਵਾਂ ਉਪਭੋਗਤਾ ਬਣਾਓ, ਅਧਿਕਾਰਾਂ ਦੀ ਸੰਰਚਨਾ ਕਰੋ, ssh ਕੁੰਜੀ
4. ਸਿਸਟਮ ਪੈਕੇਜਾਂ (nginx ਆਦਿ) ਨੂੰ ਸੰਰਚਿਤ ਕਰੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਚਲਾਓ
5. ਅਸੀਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਇੱਕ ਉਪਭੋਗਤਾ ਬਣਾਉਂਦੇ ਹਾਂ (ਤੁਸੀਂ ਤੁਰੰਤ ਇੱਕ ਡੇਟਾਬੇਸ ਬਣਾ ਸਕਦੇ ਹੋ)
6. ਇੱਕ ਨਵੇਂ ਉਪਭੋਗਤਾ ਵਜੋਂ ਲੌਗਇਨ ਕਰੋ
7. rbenv ਅਤੇ ruby ​​ਇੰਸਟਾਲ ਕਰੋ
8. ਬੰਡਲ ਨੂੰ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
9. ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਅੱਪਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
10. Puma ਸਰਵਰ ਨੂੰ ਲਾਂਚ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਆਖਰੀ ਪੜਾਅ ਕੈਪਿਸਟ੍ਰਾਨੋ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਘੱਟੋ-ਘੱਟ ਬਕਸੇ ਤੋਂ ਬਾਹਰ ਇਹ ਰੀਲੀਜ਼ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਕੋਡ ਦੀ ਨਕਲ ਕਰ ਸਕਦਾ ਹੈ, ਸਫਲ ਤੈਨਾਤੀ 'ਤੇ ਸਿਮਲਿੰਕ ਨਾਲ ਰੀਲੀਜ਼ ਨੂੰ ਸਵਿਚ ਕਰ ਸਕਦਾ ਹੈ, ਸਾਂਝੀ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਕੌਂਫਿਗਸ ਕਾਪੀ ਕਰ ਸਕਦਾ ਹੈ, ਪੁਮਾ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰ ਸਕਦਾ ਹੈ, ਆਦਿ। ਇਹ ਸਭ Ansible ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਕਿਉਂ?

ਫਾਈਲ ਬਣਤਰ

ਜਵਾਬਦੇਹ ਸਖਤ ਹੈ ਫਾਇਲ ਬਣਤਰ ਤੁਹਾਡੀਆਂ ਸਾਰੀਆਂ ਫਾਈਲਾਂ ਲਈ, ਇਸ ਲਈ ਇਹ ਸਭ ਨੂੰ ਇੱਕ ਵੱਖਰੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰੱਖਣਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਇੰਨਾ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਰੇਲਜ਼ ਐਪਲੀਕੇਸ਼ਨ ਵਿਚ ਹੀ ਹੋਵੇਗਾ, ਜਾਂ ਵੱਖਰੇ ਤੌਰ 'ਤੇ. ਤੁਸੀਂ ਫਾਈਲਾਂ ਨੂੰ ਇੱਕ ਵੱਖਰੀ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ। ਨਿੱਜੀ ਤੌਰ 'ਤੇ, ਮੈਨੂੰ ਰੇਲ ਐਪਲੀਕੇਸ਼ਨ ਦੀ /config ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਇੱਕ ਜਵਾਬਦੇਹ ਡਾਇਰੈਕਟਰੀ ਬਣਾਉਣਾ ਅਤੇ ਸਭ ਕੁਝ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕਰਨਾ ਸਭ ਤੋਂ ਸੁਵਿਧਾਜਨਕ ਲੱਗਿਆ।

ਸਧਾਰਨ ਪਲੇਬੁੱਕ

ਪਲੇਬੁੱਕ ਇੱਕ 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: true directive ਨੂੰ ਵੀ ਨਿਸ਼ਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਜਿਵੇਂ ਕਿ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ: become set to ‘true’/’yes’ to activate privilege escalation. ਹਾਲਾਂਕਿ ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੈ ਕਿ ਕਿਉਂ)।

ਸ਼ਾਇਦ ਤੁਸੀਂ ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਇੱਕ ਗਲਤੀ ਪ੍ਰਾਪਤ ਕਰੋਗੇ ਕਿ ansible ਪਾਈਥਨ ਦੁਭਾਸ਼ੀਏ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ, ਫਿਰ ਤੁਸੀਂ ਇਸਨੂੰ ਹੱਥੀਂ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ:

ansible_python_interpreter: /usr/bin/python3 

ਤੁਸੀਂ ਕਮਾਂਡ ਨਾਲ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਕੋਲ python ਕਿੱਥੇ ਹੈ whereis python.

ਸਿਸਟਮ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨਾ

Ansible ਦੀ ਸਟੈਂਡਰਡ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਸਿਸਟਮ ਪੈਕੇਜਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਬਹੁਤ ਸਾਰੇ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਇਸਲਈ ਸਾਨੂੰ ਕਿਸੇ ਵੀ ਕਾਰਨ ਕਰਕੇ ਬੈਸ਼ ਸਕ੍ਰਿਪਟਾਂ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਹੁਣ ਸਾਨੂੰ ਸਿਸਟਮ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਅਤੇ ਸਿਸਟਮ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਮੋਡੀਊਲ ਦੀ ਲੋੜ ਹੈ। ਮੇਰੇ ਕੋਲ ਮੇਰੇ VPS 'ਤੇ ਉਬੰਟੂ ਲੀਨਕਸ ਹੈ, ਇਸਲਈ ਮੇਰੇ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਪੈਕੇਜਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ apt-get и ਇਸ ਲਈ ਮੋਡੀਊਲ. ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵੱਖਰੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਖਰੇ ਮੋਡੀਊਲ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ (ਯਾਦ ਰੱਖੋ, ਮੈਂ ਸ਼ੁਰੂ ਵਿੱਚ ਕਿਹਾ ਸੀ ਕਿ ਸਾਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਅਸੀਂ ਕੀ ਅਤੇ ਕਿਵੇਂ ਕਰਾਂਗੇ)। ਹਾਲਾਂਕਿ, ਸੰਟੈਕਸ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਸਮਾਨ ਹੋਵੇਗਾ।

ਆਉ ਸਾਡੀ ਪਲੇਬੁੱਕ ਨੂੰ ਪਹਿਲੇ ਕੰਮਾਂ ਦੇ ਨਾਲ ਪੂਰਕ ਕਰੀਏ:

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

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

ਟਾਸਕ ਬਿਲਕੁਲ ਉਹ ਕੰਮ ਹੈ ਜੋ ਜਵਾਬੀ ਰਿਮੋਟ ਸਰਵਰਾਂ 'ਤੇ ਕਰੇਗਾ। ਅਸੀਂ ਕੰਮ ਨੂੰ ਇੱਕ ਨਾਮ ਦਿੰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਅਸੀਂ ਲੌਗ ਵਿੱਚ ਇਸਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਟ੍ਰੈਕ ਕਰ ਸਕੀਏ। ਅਤੇ ਅਸੀਂ ਇੱਕ ਖਾਸ ਮੋਡੀਊਲ ਦੇ ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਰਣਨ ਕਰਦੇ ਹਾਂ, ਇਸਨੂੰ ਕੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ apt: update_cache=yes - 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] - ਇਹ ਕਹਿੰਦਾ ਹੈ ਕਿ ਟੈਕਸਟ ਦਾ ਅਗਲਾ ਬਲਾਕ ਵੇਰੀਏਬਲ (ਵਰ) ਹੈ ਅਤੇ ਉਹ ਸਾਰੇ ਮੇਜ਼ਬਾਨਾਂ (ਸਾਰੇ) 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।

ਡਿਜ਼ਾਈਨ ਵੀ ਦਿਲਚਸਪ ਹੈ "{{ 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 ਨੂੰ ਇਨ ਯੋਗ ਕਰੀਏ 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 ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਨ ਦਾ ਕੋਈ ਮਤਲਬ ਨਹੀਂ ਹੈ. ਕੀ ਤੁਸੀਂ ਦੇਖਿਆ ਹੈ ਕਿ ਅਸੀਂ ਕਮਾਂਡਾਂ ਨਹੀਂ ਲਿਖਦੇ ਜਿਵੇਂ ਕਿ: “ਇਸ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਰੋ”, ਸੰਟੈਕਸ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ ਜਿਵੇਂ “ਇਸ ਦੀ ਇਹ ਅਵਸਥਾ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ”। ਅਤੇ ਅਕਸਰ ਇਹ ਬਿਲਕੁਲ ਇਸ ਤਰ੍ਹਾਂ ਹੈ ਕਿ ਜਵਾਬਦੇਹ ਕੰਮ ਕਰਦਾ ਹੈ. ਜੇਕਰ ਗਰੁੱਪ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹੈ, ਜਾਂ ਸਿਸਟਮ ਪੈਕੇਜ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਇੰਸਟਾਲ ਹੈ, ਤਾਂ ansible ਇਸਦੀ ਜਾਂਚ ਕਰੇਗਾ ਅਤੇ ਕੰਮ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ। ਨਾਲ ਹੀ, ਫਾਈਲਾਂ ਦੀ ਨਕਲ ਨਹੀਂ ਕੀਤੀ ਜਾਵੇਗੀ ਜੇਕਰ ਉਹ ਸਰਵਰ 'ਤੇ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਚੀਜ਼ਾਂ ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮੇਲ ਖਾਂਦੀਆਂ ਹਨ। ਅਸੀਂ ਇਸਦਾ ਫਾਇਦਾ ਉਠਾ ਸਕਦੇ ਹਾਂ ਅਤੇ nginx ਨੂੰ ਸਿਰਫ ਤਾਂ ਹੀ ਰੀਸਟਾਰਟ ਕਰ ਸਕਦੇ ਹਾਂ ਜੇਕਰ ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਨੂੰ ਬਦਲਿਆ ਗਿਆ ਹੈ। ਇਸਦੇ ਲਈ ਇੱਕ ਰਜਿਸਟਰ ਨਿਰਦੇਸ਼ ਹੈ:

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

- name: Copy the nginx.conf
  copy:
    src: nginx.conf
    dest: /etc/nginx/nginx.conf
    owner: root
    group: root
    mode: '0644'
    backup: yes
  register: restart_nginx

- name: Copy template my_app.conf
  template:
    src: my_app_conf.j2
    dest: /etc/nginx/sites-available/my_app.conf
    owner: root
    group: root
    mode: '0644'
  register: restart_nginx

- name: Create symlink to sites-enabled
  file:
    src: /etc/nginx/sites-available/my_app.conf
    dest: /etc/nginx/sites-enabled/my_app.conf
    state: link

- name: restart nginx
  service:
    name: nginx
    state: restarted
  when: restart_nginx.changed

ਜੇਕਰ ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਦਲਦੀ ਹੈ, ਤਾਂ ਇੱਕ ਕਾਪੀ ਬਣਾਈ ਜਾਵੇਗੀ ਅਤੇ ਵੇਰੀਏਬਲ ਰਜਿਸਟਰ ਕੀਤਾ ਜਾਵੇਗਾ restart_nginx. ਅਤੇ ਕੇਵਲ ਤਾਂ ਹੀ ਜੇਕਰ ਇਹ ਵੇਰੀਏਬਲ ਰਜਿਸਟਰ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਸੇਵਾ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕੀਤਾ ਜਾਵੇਗਾ।

ਅਤੇ, ਬੇਸ਼ਕ, ਤੁਹਾਨੂੰ ਮੁੱਖ ਪਲੇਬੁੱਕ ਵਿੱਚ nginx ਰੋਲ ਨੂੰ ਜੋੜਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

postgresql ਸੈੱਟਅੱਪ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਸਾਨੂੰ postgresql ਨੂੰ systemd ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਸੇ ਤਰ੍ਹਾਂ ਸਮਰੱਥ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਵੇਂ ਅਸੀਂ nginx ਨਾਲ ਕੀਤੀ ਸੀ, ਅਤੇ ਇੱਕ ਉਪਭੋਗਤਾ ਵੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਡੇਟਾਬੇਸ ਅਤੇ ਡੇਟਾਬੇਸ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਕਰਾਂਗੇ।
ਆਓ ਇੱਕ ਰੋਲ ਬਣਾਈਏ /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

ਅਸੀਂ ਇਹਨਾਂ ਉਦੇਸ਼ਾਂ ਲਈ ਬਣਾਏ ਗਏ ਉਪਯੋਗਕਰਤਾ ਦੇ ਅਧੀਨ ਕੰਮ ਕਰਨ ਲਈ ਦੁਬਾਰਾ become_user ਡਾਇਰੈਕਟਿਵ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਕਿਉਂਕਿ 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