ಅನ್ಸಿಬಲ್ ಬಳಸಿ ರೈಲ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಬಹಳ ಹಿಂದೆಯೇ ರೈಲ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ಸರ್ವರ್ ಅನ್ನು ತಯಾರಿಸಲು ನಾನು ಹಲವಾರು ಅನ್ಸಿಬಲ್ ಪ್ಲೇಬುಕ್‌ಗಳನ್ನು ಬರೆಯಬೇಕಾಗಿತ್ತು. ಮತ್ತು, ಆಶ್ಚರ್ಯಕರವಾಗಿ, ನಾನು ಸರಳವಾದ ಹಂತ-ಹಂತದ ಕೈಪಿಡಿಯನ್ನು ಕಂಡುಹಿಡಿಯಲಿಲ್ಲ. ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳದೆ ಬೇರೊಬ್ಬರ ಪ್ಲೇಬುಕ್ ಅನ್ನು ನಕಲಿಸಲು ನಾನು ಬಯಸುವುದಿಲ್ಲ, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ನಾನು ದಸ್ತಾವೇಜನ್ನು ಓದಬೇಕಾಗಿತ್ತು, ಎಲ್ಲವನ್ನೂ ನಾನೇ ಸಂಗ್ರಹಿಸಿದೆ. ಬಹುಶಃ ಈ ಲೇಖನದ ಸಹಾಯದಿಂದ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸಲು ನಾನು ಯಾರಿಗಾದರೂ ಸಹಾಯ ಮಾಡಬಹುದು.

SSH ಮೂಲಕ ರಿಮೋಟ್ ಸರ್ವರ್ (ಗಳು) ನಲ್ಲಿ ಕ್ರಿಯೆಗಳ ಪೂರ್ವನಿರ್ಧರಿತ ಪಟ್ಟಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಅನ್ಸಿಬಲ್ ನಿಮಗೆ ಅನುಕೂಲಕರ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ ಎಂಬುದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾದ ಮೊದಲ ವಿಷಯವಾಗಿದೆ. ಇಲ್ಲಿ ಯಾವುದೇ ಮ್ಯಾಜಿಕ್ ಇಲ್ಲ, ನೀವು ಪ್ಲಗಿನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಮತ್ತು ಡಾಕರ್, ಮಾನಿಟರಿಂಗ್ ಮತ್ತು ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ ಇತರ ಗುಡಿಗಳೊಂದಿಗೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಶೂನ್ಯ ಡೌನ್‌ಟೈಮ್ ನಿಯೋಜನೆಯನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ. ಪ್ಲೇಬುಕ್ ಬರೆಯಲು, ನೀವು ನಿಖರವಾಗಿ ಏನು ಮಾಡಬೇಕೆಂದು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನೀವು ತಿಳಿದಿರಬೇಕು. ಅದಕ್ಕಾಗಿಯೇ ನಾನು GitHub ನಿಂದ ಸಿದ್ಧಪಡಿಸಿದ ಪ್ಲೇಬುಕ್‌ಗಳು ಅಥವಾ ಈ ರೀತಿಯ ಲೇಖನಗಳಿಂದ ತೃಪ್ತನಾಗುವುದಿಲ್ಲ: "ನಕಲಿಸಿ ಮತ್ತು ರನ್ ಮಾಡಿ, ಅದು ಕೆಲಸ ಮಾಡುತ್ತದೆ."

ನಮಗೆ ಏನು ಬೇಕು?

ನಾನು ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, ಪ್ಲೇಬುಕ್ ಬರೆಯಲು ನೀವು ಏನು ಮಾಡಬೇಕೆಂದು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ತಿಳಿಯಬೇಕು. ನಮಗೆ ಏನು ಬೇಕು ಎಂದು ನಿರ್ಧರಿಸೋಣ. ರೈಲ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ನಮಗೆ ಹಲವಾರು ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜುಗಳು ಬೇಕಾಗುತ್ತವೆ: nginx, postgresql (redis, ಇತ್ಯಾದಿ). ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಮಗೆ ಮಾಣಿಕ್ಯದ ನಿರ್ದಿಷ್ಟ ಆವೃತ್ತಿಯ ಅಗತ್ಯವಿದೆ. Rbenv (rvm, asdf...) ಮೂಲಕ ಅದನ್ನು ಸ್ಥಾಪಿಸುವುದು ಉತ್ತಮ. ರೂಟ್ ಬಳಕೆದಾರರಾಗಿ ಈ ಎಲ್ಲವನ್ನು ಚಲಾಯಿಸುವುದು ಯಾವಾಗಲೂ ಕೆಟ್ಟ ಆಲೋಚನೆಯಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಪ್ರತ್ಯೇಕ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಬೇಕು ಮತ್ತು ಅವರ ಹಕ್ಕುಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದರ ನಂತರ, ನೀವು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸರ್ವರ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ, nginx, postgres ಇತ್ಯಾದಿಗಳಿಗಾಗಿ ಸಂರಚನೆಗಳನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಈ ಎಲ್ಲಾ ಸೇವೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು.

ಪರಿಣಾಮವಾಗಿ, ಕ್ರಿಯೆಗಳ ಅನುಕ್ರಮವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

1. ರೂಟ್ ಆಗಿ ಲಾಗಿನ್ ಮಾಡಿ
2. ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸಿ
3. ಹೊಸ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಿ, ಹಕ್ಕುಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ, ssh ಕೀ
4. ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ (nginx ಇತ್ಯಾದಿ) ಮತ್ತು ಅವುಗಳನ್ನು ರನ್ ಮಾಡಿ
5. ನಾವು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರನ್ನು ರಚಿಸುತ್ತೇವೆ (ನೀವು ತಕ್ಷಣ ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸಬಹುದು)
6. ಹೊಸ ಬಳಕೆದಾರರಾಗಿ ಲಾಗಿನ್ ಮಾಡಿ
7. Rbenv ಮತ್ತು ಮಾಣಿಕ್ಯವನ್ನು ಸ್ಥಾಪಿಸಿ
8. ಬಂಡ್ಲರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು
9. ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
10. ಪೂಮಾ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ

ಇದಲ್ಲದೆ, ಕೊನೆಯ ಹಂತಗಳನ್ನು ಕ್ಯಾಪಿಸ್ಟ್ರಾನೊ ಬಳಸಿ ಮಾಡಬಹುದು, ಕನಿಷ್ಠ ಪೆಟ್ಟಿಗೆಯಿಂದ ಅದು ಕೋಡ್ ಅನ್ನು ಬಿಡುಗಡೆ ಡೈರೆಕ್ಟರಿಗಳಿಗೆ ನಕಲಿಸಬಹುದು, ಯಶಸ್ವಿ ನಿಯೋಜನೆಯ ಮೇಲೆ ಸಿಮ್‌ಲಿಂಕ್‌ನೊಂದಿಗೆ ಬಿಡುಗಡೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು, ಹಂಚಿಕೆಯ ಡೈರೆಕ್ಟರಿಯಿಂದ ಕಾನ್ಫಿಗ್‌ಗಳನ್ನು ನಕಲಿಸಬಹುದು, ಪೂಮಾವನ್ನು ಮರುಪ್ರಾರಂಭಿಸಬಹುದು, ಇತ್ಯಾದಿ. ಅನ್ಸಿಬಲ್ ಬಳಸಿ ಇದೆಲ್ಲವನ್ನೂ ಮಾಡಬಹುದು, ಆದರೆ ಏಕೆ?

ಫೈಲ್ ರಚನೆ

ಅನ್ಸಿಬಲ್ ಕಟ್ಟುನಿಟ್ಟನ್ನು ಹೊಂದಿದೆ ಫೈಲ್ ರಚನೆ ನಿಮ್ಮ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳಿಗೆ, ಆದ್ದರಿಂದ ಎಲ್ಲವನ್ನೂ ಪ್ರತ್ಯೇಕ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಇಡುವುದು ಉತ್ತಮ. ಇದಲ್ಲದೆ, ಇದು ಹಳಿಗಳ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿಯೇ ಅಥವಾ ಪ್ರತ್ಯೇಕವಾಗಿ ಇರುತ್ತದೆಯೇ ಎಂಬುದು ಅಷ್ಟು ಮುಖ್ಯವಲ್ಲ. ನೀವು ಫೈಲ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಜಿಟ್ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು. ವೈಯಕ್ತಿಕವಾಗಿ, ರೈಲ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನ / ಕಾನ್ಫಿಗರ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಅನ್ಸಿಬಲ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಲು ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಒಂದೇ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ನಾನು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ.

ಸರಳ ಪ್ಲೇಬುಕ್

ಪ್ಲೇಬುಕ್ ಒಂದು yml ಫೈಲ್ ಆಗಿದ್ದು, ವಿಶೇಷ ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ, ಅನ್ಸಿಬಲ್ ಏನು ಮಾಡಬೇಕು ಮತ್ತು ಹೇಗೆ ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಏನನ್ನೂ ಮಾಡದ ಮೊದಲ ಪ್ಲೇಬುಕ್ ಅನ್ನು ರಚಿಸೋಣ:

---
- 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 ಸಂಪರ್ಕಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ರಿಮೋಟ್ ಸಿಸ್ಟಮ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. (ಡೀಫಾಲ್ಟ್ ಟಾಸ್ಕ್ [ಗ್ಯಾಥರಿಂಗ್ ಫ್ಯಾಕ್ಟ್ಸ್]) ಅದರ ನಂತರ ಅದು ಎಕ್ಸಿಕ್ಯೂಷನ್ ಕುರಿತು ಕಿರು ವರದಿಯನ್ನು ನೀಡುತ್ತದೆ (ಪ್ಲೇ ರಿಕಾಪ್).

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನೀವು ಸಿಸ್ಟಮ್‌ಗೆ ಲಾಗ್ ಇನ್ ಆಗಿರುವ ಬಳಕೆದಾರರ ಹೆಸರನ್ನು ಸಂಪರ್ಕವು ಬಳಸುತ್ತದೆ. ಇದು ಹೆಚ್ಚಾಗಿ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಇರುವುದಿಲ್ಲ. ಪ್ಲೇಬುಕ್ ಫೈಲ್‌ನಲ್ಲಿ, ರಿಮೋಟ್_ಯೂಸರ್ ನಿರ್ದೇಶನವನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಪರ್ಕಿಸಲು ಯಾವ ಬಳಕೆದಾರರನ್ನು ಬಳಸಬೇಕೆಂದು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಅಲ್ಲದೆ, ರಿಮೋಟ್ ಸಿಸ್ಟಮ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯು ನಿಮಗೆ ಅನಗತ್ಯವಾಗಿರಬಹುದು ಮತ್ತು ನೀವು ಅದನ್ನು ಸಂಗ್ರಹಿಸುವ ಸಮಯವನ್ನು ವ್ಯರ್ಥ ಮಾಡಬಾರದು. ಈ ಕಾರ್ಯವನ್ನು ಸಹ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು:

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

ಪ್ಲೇಬುಕ್ ಅನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಸಂಪರ್ಕವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. (ನೀವು ಮೂಲ ಬಳಕೆದಾರರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ಉನ್ನತ ಹಕ್ಕುಗಳನ್ನು ಪಡೆಯಲು ನೀವು ಆಗಲು: ನಿಜವಾದ ನಿರ್ದೇಶನವನ್ನು ಸಹ ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗುತ್ತದೆ. ದಾಖಲಾತಿಯಲ್ಲಿ ಬರೆದಂತೆ: become set to ‘true’/’yes’ to activate privilege escalation. ಏಕೆ ಎಂಬುದು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲವಾದರೂ).

ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಅನ್ಸಿಬಲ್ ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂಬ ಅಂಶದಿಂದ ಉಂಟಾದ ದೋಷವನ್ನು ನೀವು ಸ್ವೀಕರಿಸಬಹುದು, ನಂತರ ನೀವು ಅದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

ansible_python_interpreter: /usr/bin/python3 

ಆಜ್ಞೆಯೊಂದಿಗೆ ನೀವು ಪೈಥಾನ್ ಅನ್ನು ಎಲ್ಲಿ ಹೊಂದಿದ್ದೀರಿ ಎಂಬುದನ್ನು ನೀವು ಕಂಡುಹಿಡಿಯಬಹುದು whereis python.

ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ಅನ್ಸಿಬಲ್‌ನ ಪ್ರಮಾಣಿತ ವಿತರಣೆಯು ವಿವಿಧ ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅನೇಕ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಯಾವುದೇ ಕಾರಣಕ್ಕೂ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಬೇಕಾಗಿಲ್ಲ. ಸಿಸ್ಟಮ್ ಅನ್ನು ನವೀಕರಿಸಲು ಮತ್ತು ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಈಗ ನಮಗೆ ಈ ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಅಗತ್ಯವಿದೆ. ನನ್ನ VPS ನಲ್ಲಿ ನಾನು Ubuntu Linux ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ, ಆದ್ದರಿಂದ ನಾನು ಬಳಸುವ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲು 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 - ಆಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜುಗಳನ್ನು ನವೀಕರಿಸಲು ಹೇಳುತ್ತದೆ. ಎರಡನೆಯ ಆಜ್ಞೆಯು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ. ನಾವು ಪ್ಯಾಕೇಜುಗಳ ಪಟ್ಟಿಯನ್ನು ಆಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗೆ ರವಾನಿಸುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳು ಎಂದು ಹೇಳುತ್ತೇವೆ state ಆಗಬೇಕು present, ಅಂದರೆ, ಈ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಿ ಎಂದು ನಾವು ಹೇಳುತ್ತೇವೆ. ಅದೇ ರೀತಿಯಲ್ಲಿ, ಅವುಗಳನ್ನು ಅಳಿಸಲು ಅಥವಾ ಸರಳವಾಗಿ ಬದಲಾಯಿಸುವ ಮೂಲಕ ಅವುಗಳನ್ನು ನವೀಕರಿಸಲು ನಾವು ಅವರಿಗೆ ಹೇಳಬಹುದು state. postgresql ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹಳಿಗಳಿಗೆ ನಮಗೆ postgresql-contrib ಪ್ಯಾಕೇಜ್ ಅಗತ್ಯವಿದೆ, ಅದನ್ನು ನಾವು ಈಗ ಸ್ಥಾಪಿಸುತ್ತಿದ್ದೇವೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮತ್ತೊಮ್ಮೆ, ನೀವು ಇದನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಮತ್ತು ಮಾಡಬೇಕಾಗಿದೆ; ಅನ್ಸಿಬಲ್ ಸ್ವತಃ ಇದನ್ನು ಮಾಡುವುದಿಲ್ಲ.

ಪ್ಲೇಬುಕ್ ಅನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಹೊಸ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ.

ಬಳಕೆದಾರರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು, ಅನ್ಸಿಬಲ್ ಕೂಡ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹೊಂದಿದೆ - ಬಳಕೆದಾರ. ಇನ್ನೂ ಒಂದು ಕಾರ್ಯವನ್ನು ಸೇರಿಸೋಣ (ಪ್ಲೇಬುಕ್‌ನ ಈಗಾಗಲೇ ತಿಳಿದಿರುವ ಭಾಗಗಳನ್ನು ನಾನು ಪ್ರತಿ ಬಾರಿಯೂ ಸಂಪೂರ್ಣವಾಗಿ ನಕಲಿಸದಂತೆ ಕಾಮೆಂಟ್‌ಗಳ ಹಿಂದೆ ಮರೆಮಾಡಿದೆ):

---
- 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 ನೀವು ಅದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾಡುವಂತೆ. ಮತ್ತು ಇದು ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ನೇರವಾಗಿ ಉಳಿಸುತ್ತದೆ, ಅದಕ್ಕಾಗಿಯೇ ನಾವು ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಮುಂಚಿತವಾಗಿ ಹ್ಯಾಶ್ ಆಗಿ ಪರಿವರ್ತಿಸಬೇಕು, ಅದು ಈ ಆಜ್ಞೆಯನ್ನು ಮಾಡುತ್ತದೆ.

ನಮ್ಮ ಬಳಕೆದಾರರನ್ನು ಸುಡೋ ಗುಂಪಿಗೆ ಸೇರಿಸೋಣ. ಆದಾಗ್ಯೂ, ಇದಕ್ಕೂ ಮೊದಲು ಅಂತಹ ಗುಂಪು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು ಏಕೆಂದರೆ ಯಾರೂ ನಮಗಾಗಿ ಇದನ್ನು ಮಾಡುವುದಿಲ್ಲ:

---
- 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/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 }} - ಇವೆಲ್ಲವೂ ಅಸ್ಥಿರಗಳಾಗಿದ್ದು, ಅದರ ಮೌಲ್ಯಗಳನ್ನು ಅನ್ಸಿಬಲ್ ನಕಲಿಸುವ ಮೊದಲು ಟೆಂಪ್ಲೇಟ್‌ಗೆ ಬದಲಿಸುತ್ತದೆ. ಹೋಸ್ಟ್‌ಗಳ ವಿವಿಧ ಗುಂಪುಗಳಿಗೆ ನೀವು ಪ್ಲೇಬುಕ್ ಅನ್ನು ಬಳಸಿದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ನಮ್ಮ ದಾಸ್ತಾನು ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಬಹುದು:

[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

ನಾವು ಈಗ ನಮ್ಮ ಪ್ಲೇಬುಕ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದರೆ, ಅದು ಎರಡೂ ಹೋಸ್ಟ್‌ಗಳಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ, ಸ್ಟೇಜಿಂಗ್ ಹೋಸ್ಟ್‌ಗಾಗಿ, ಅಸ್ಥಿರಗಳು ಉತ್ಪಾದನೆಯಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತವೆ ಮತ್ತು ಪಾತ್ರಗಳು ಮತ್ತು ಪ್ಲೇಬುಕ್‌ಗಳಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ nginx ಕಾನ್ಫಿಗರ್‌ಗಳಲ್ಲಿಯೂ ಸಹ. {{ inventory_hostname }} ದಾಸ್ತಾನು ಕಡತದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ - ಇದು ವಿಶೇಷ ಅನ್ಸಿಬಲ್ ವೇರಿಯಬಲ್ ಮತ್ತು ಪ್ಲೇಬುಕ್ ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಹೋಸ್ಟ್ ಅನ್ನು ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.
ನೀವು ಹಲವಾರು ಹೋಸ್ಟ್‌ಗಳಿಗೆ ದಾಸ್ತಾನು ಫೈಲ್ ಅನ್ನು ಹೊಂದಲು ಬಯಸಿದರೆ, ಆದರೆ ಒಂದು ಗುಂಪಿಗೆ ಮಾತ್ರ ಚಲಾಯಿಸಿದರೆ, ಇದನ್ನು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಮಾಡಬಹುದು:

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

ವಿಭಿನ್ನ ಗುಂಪುಗಳಿಗೆ ಪ್ರತ್ಯೇಕ ದಾಸ್ತಾನು ಫೈಲ್‌ಗಳನ್ನು ಹೊಂದಿರುವುದು ಮತ್ತೊಂದು ಆಯ್ಕೆಯಾಗಿದೆ. ಅಥವಾ ನೀವು ವಿವಿಧ ಹೋಸ್ಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ನೀವು ಎರಡು ವಿಧಾನಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು.

nginx ಅನ್ನು ಹೊಂದಿಸಲು ಹಿಂತಿರುಗಿ ನೋಡೋಣ. ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ನಕಲಿಸಿದ ನಂತರ, sites_available ನಿಂದ my_app.conf ಗೆ sitest_enabled ನಲ್ಲಿ ನಾವು ಸಿಮ್‌ಲಿಂಕ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಮತ್ತು nginx ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ.

... # old code in mail.yml

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

- name: restart nginx
  service:
    name: nginx
    state: restarted

ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ - ಸಾಕಷ್ಟು ಪ್ರಮಾಣಿತ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನೊಂದಿಗೆ ಮತ್ತೆ ಅನ್ಸಿಬಲ್ ಮಾಡ್ಯೂಲ್‌ಗಳು. ಆದರೆ ಒಂದು ಅಂಶವಿದೆ. ಪ್ರತಿ ಬಾರಿ nginx ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುವುದರಲ್ಲಿ ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ. ನಾವು ಈ ರೀತಿಯ ಆಜ್ಞೆಗಳನ್ನು ಬರೆಯುವುದಿಲ್ಲ ಎಂದು ನೀವು ಗಮನಿಸಿದ್ದೀರಾ: "ಇದನ್ನು ಹೀಗೆ ಮಾಡಿ", ಸಿಂಟ್ಯಾಕ್ಸ್ "ಇದು ಈ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರಬೇಕು" ಎಂದು ತೋರುತ್ತಿದೆ. ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಇದು ನಿಖರವಾಗಿ ಹೇಗೆ ಅನ್ಸಿಬಲ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಗುಂಪು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಅಥವಾ ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಈಗಾಗಲೇ ಸ್ಥಾಪಿಸಿದ್ದರೆ, ಅನ್ಸಿಬಲ್ ಇದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯವನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ಅಲ್ಲದೆ, ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಫೈಲ್‌ಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಹೊಂದಾಣಿಕೆಯಾದರೆ ಅವುಗಳನ್ನು ನಕಲಿಸಲಾಗುವುದಿಲ್ಲ. ನಾವು ಇದರ ಲಾಭವನ್ನು ಪಡೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಿದ್ದರೆ ಮಾತ್ರ nginx ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಬಹುದು. ಇದಕ್ಕಾಗಿ ನೋಂದಣಿ ನಿರ್ದೇಶನವಿದೆ:

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

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

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

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

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

ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಬದಲಾಯಿಸಿದರೆ, ನಕಲನ್ನು ಮಾಡಲಾಗುವುದು ಮತ್ತು ವೇರಿಯಬಲ್ ಅನ್ನು ನೋಂದಾಯಿಸಲಾಗುತ್ತದೆ restart_nginx. ಮತ್ತು ಈ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನೋಂದಾಯಿಸಿದ್ದರೆ ಮಾತ್ರ ಸೇವೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.

ಮತ್ತು, ಸಹಜವಾಗಿ, ನೀವು ಮುಖ್ಯ ಪ್ಲೇಬುಕ್‌ಗೆ nginx ಪಾತ್ರವನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ.

postgresql ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ನಾವು nginx ನೊಂದಿಗೆ ಮಾಡಿದ ರೀತಿಯಲ್ಲಿಯೇ systemd ಅನ್ನು ಬಳಸಿಕೊಂಡು postgresql ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು ಮತ್ತು ಡೇಟಾಬೇಸ್ ಮತ್ತು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ನಾವು ಬಳಸುವ ಬಳಕೆದಾರರನ್ನು ಸಹ ರಚಿಸಬೇಕಾಗಿದೆ.
ಪಾತ್ರವನ್ನು ರಚಿಸೋಣ /ansible/roles/postgresql/tasks/main.yml:

# Create user in postgresql
- name: enable postgresql and start
  systemd:
    name: postgresql
    state: started
    enabled: yes

- name: Create database user
  become_user: postgres
  postgresql_user:
    name: "{{ db_user }}"
    password: "{{ db_password }}"
    role_attr_flags: SUPERUSER

- name: Create database
  become_user: postgres
  postgresql_db:
    name: "{{ db_name }}"
    encoding: UTF-8
    owner: "{{ db_user }}"

ದಾಸ್ತಾನುಗಳಿಗೆ ಅಸ್ಥಿರಗಳನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು ಎಂದು ನಾನು ವಿವರಿಸುವುದಿಲ್ಲ, ಇದನ್ನು ಈಗಾಗಲೇ ಹಲವು ಬಾರಿ ಮಾಡಲಾಗಿದೆ, ಹಾಗೆಯೇ postgresql_db ಮತ್ತು postgresql_user ಮಾಡ್ಯೂಲ್‌ಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ದಸ್ತಾವೇಜನ್ನು ಕಾಣಬಹುದು. ಇಲ್ಲಿ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ನಿರ್ದೇಶನವಾಗಿದೆ become_user: postgres. ಸತ್ಯವೆಂದರೆ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, postgres ಬಳಕೆದಾರರು ಮಾತ್ರ postgresql ಡೇಟಾಬೇಸ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತಾರೆ ಮತ್ತು ಸ್ಥಳೀಯವಾಗಿ ಮಾತ್ರ. ಈ ನಿರ್ದೇಶನವು ಈ ಬಳಕೆದಾರರ ಪರವಾಗಿ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ (ನಾವು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದ್ದರೆ, ಸಹಜವಾಗಿ).
ಅಲ್ಲದೆ, ಡೇಟಾಬೇಸ್‌ಗೆ ಹೊಸ ಬಳಕೆದಾರರ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸಲು ನೀವು pg_hba.conf ಗೆ ಸಾಲನ್ನು ಸೇರಿಸಬೇಕಾಗಬಹುದು. ನಾವು nginx ಸಂರಚನೆಯನ್ನು ಬದಲಾಯಿಸಿದ ರೀತಿಯಲ್ಲಿಯೇ ಇದನ್ನು ಮಾಡಬಹುದು.

ಮತ್ತು ಸಹಜವಾಗಿ, ನೀವು ಮುಖ್ಯ ಪ್ಲೇಬುಕ್‌ಗೆ postgresql ಪಾತ್ರವನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ.

Rbenv ಮೂಲಕ ಮಾಣಿಕ್ಯವನ್ನು ಸ್ಥಾಪಿಸುವುದು

ಅನ್ಸಿಬಲ್ 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

ಈ ಉದ್ದೇಶಗಳಿಗಾಗಿ ನಾವು ರಚಿಸಿದ ಬಳಕೆದಾರರ ಅಡಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ನಾವು ಮತ್ತೊಮ್ಮೆ be_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 ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಸರಳವಾಗಿ ಬ್ಯಾಷ್ ಆಜ್ಞೆಯೊಂದಿಗೆ:

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

ಯಾವ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಮತ್ತು ಯಾವುದರೊಂದಿಗೆ ನಾವು ಹೇಳುತ್ತೇವೆ. ಆದಾಗ್ಯೂ, ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು bashrc ನಲ್ಲಿರುವ ಕೋಡ್ ಅನ್ನು ansible ರನ್ ಮಾಡುವುದಿಲ್ಲ ಎಂಬ ಅಂಶವನ್ನು ಇಲ್ಲಿ ನಾವು ನೋಡುತ್ತೇವೆ. ಇದರರ್ಥ 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 ಅನ್ನು ಮುಖ್ಯ ಪ್ಲೇಬುಕ್‌ಗೆ ಸೇರಿಸಿ.

ಹಂಚಿದ ಫೈಲ್‌ಗಳು.

ಸಾಮಾನ್ಯವಾಗಿ, ಸೆಟಪ್ ಅನ್ನು ಇಲ್ಲಿ ಪೂರ್ಣಗೊಳಿಸಬಹುದು. ಮುಂದೆ, ಕ್ಯಾಪಿಸ್ಟ್ರಾನೊವನ್ನು ಚಲಾಯಿಸಲು ಮಾತ್ರ ಉಳಿದಿದೆ ಮತ್ತು ಅದು ಕೋಡ್ ಅನ್ನು ಸ್ವತಃ ನಕಲಿಸುತ್ತದೆ, ಅಗತ್ಯ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ರಚಿಸಿ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (ಎಲ್ಲವನ್ನೂ ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದರೆ). ಆದಾಗ್ಯೂ, ಕ್ಯಾಪಿಸ್ಟ್ರಾನೊಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚುವರಿ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ, ಉದಾಹರಣೆಗೆ 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-playbook -i inventory ./playbook.yml -l "staging" --ask-vault-pass

ಆದರೆ ನಾನು ನಿಮಗೆ ಪ್ಲೇಬುಕ್‌ಗಳು ಮತ್ತು ಪಾತ್ರಗಳ ಸಂಪೂರ್ಣ ಪಠ್ಯವನ್ನು ನೀಡುವುದಿಲ್ಲ, ಅದನ್ನು ನೀವೇ ಬರೆಯಿರಿ. ಏಕೆಂದರೆ ಅನ್ಸಿಬಲ್ ಹಾಗೆ - ಏನು ಮಾಡಬೇಕೆಂದು ನಿಮಗೆ ಅರ್ಥವಾಗದಿದ್ದರೆ, ಅದು ನಿಮಗಾಗಿ ಅದನ್ನು ಮಾಡುವುದಿಲ್ಲ.

ಮೂಲ: www.habr.com