ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಆಟೊಮೇಷನ್ ಜನರೇಷನ್: ಬ್ಯಾಷ್, ಪೈಥಾನ್ ಮತ್ತು ಪವರ್‌ಶೆಲ್

ಲಾಭಗಳು:

• ಬ್ಯಾಷ್, ಪೈಥಾನ್ ಮತ್ತು ಪವರ್‌ಶೆಲ್‌ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆ ಸುರಕ್ಷಿತ, ರಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟ್ ಡ್ರಾಫ್ಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ
• ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್, ಖಾಲಿ ವೇರಿಯಬಲ್ ತಪಾಸಣೆ, ಡ್ರೈ-ರನ್ ಮೋಡ್ ಮತ್ತು ಲಾಗಿಂಗ್‌ನಂತಹ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗೆ ಗಾರ್ಡ್‌ರೈಲ್‌ಗಳನ್ನು ಸೇರಿಸುವ ಸಾಮರ್ಥ್ಯ
• ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಗಳನ್ನು ಓದಲು ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಪರಿಸರದಲ್ಲಿ ಮತ್ತು ಡ್ರೈ-ರನ್‌ನೊಂದಿಗೆ ಪ್ರಯತ್ನಿಸುವ ಸಾಮರ್ಥ್ಯ, ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡದಿರುವ ಶಿಸ್ತನ್ನು ಅನ್ವಯಿಸಲು.

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

AI ಪ್ರಾಯಶಃ ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಅತ್ಯಂತ ಪ್ರಾಯೋಗಿಕ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತದೆ: ಒಂದು-ವಾಕ್ಯದ ವಿವರಣೆಯಿಂದ ಕೆಲಸದ ಡ್ರಾಫ್ಟ್ ಅನ್ನು ತಯಾರಿಸುವುದು, ನಿಗೂಢ ದೋಷವನ್ನು ಪರಿಹರಿಸುವುದು, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಇನ್ನೊಂದು ಭಾಷೆಗೆ ಅನುವಾದಿಸುವುದು. ಆದರೆ ಕುರುಡಾಗಿ ರನ್ ಮಾಡಿದಾಗ ಸ್ಕ್ರಿಪ್ಟ್ ಅಪಾಯಕಾರಿ - ತಪ್ಪಾದ rm, ತೆಗೆದುಹಾಕಿ-ಐಟಂ -ರಿಕರ್ಸ್ ಫೈಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗದಂತೆ ಅಳಿಸುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ಈ ಘಟಕದ ಧ್ಯೇಯವಾಕ್ಯವೆಂದರೆ: AI ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಲಿ, ನೀವು ಅದನ್ನು ಓದಿ, ಅದನ್ನು ಮೊದಲು ಸುರಕ್ಷಿತ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿ, ನಂತರ ಅದನ್ನು ಚಲಾಯಿಸಿ.

ಯಾವ ಭಾಷೆಯನ್ನು ಮತ್ತು ಯಾವಾಗ ಆಯ್ಕೆ ಮಾಡಬೇಕು? ಹೆಬ್ಬೆರಳಿನ ಒರಟು ನಿಯಮ: ಕೆಲಸವು ಸತತವಾಗಿ ಹಲವಾರು ಸಿಸ್ಟಮ್ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ (ಫೈಲ್ ನಕಲಿಸಿ, ಸೇವೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ, ಆರ್ಕೈವ್ ಹಿಂಪಡೆಯಿರಿ) ಬ್ಯಾಷ್ ಅತ್ಯಂತ ನೈಸರ್ಗಿಕ ಆಯ್ಕೆಯಾಗಿದೆ ಏಕೆಂದರೆ ಲಿನಕ್ಸ್ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಸರ್ವತ್ರವಾಗಿದೆ. ಕೆಲಸವು ನಿರ್ಧಾರ ತರ್ಕ, ಲೂಪಿಂಗ್, ಡೇಟಾ ರೂಪಾಂತರ, API ಅನ್ನು ವಿನಂತಿಸುವುದು ಅಥವಾ JSON ಸಂಸ್ಕರಣೆ-ಅಂದರೆ, 20 ಸಾಲುಗಳನ್ನು ಮೀರಿದ ತರ್ಕ-ಪೈಥಾನ್ ಅದರ ಓದುವಿಕೆ ಮತ್ತು ಶ್ರೀಮಂತ ಲೈಬ್ರರಿಗಳಿಗೆ ಎದ್ದು ಕಾಣುತ್ತದೆ; ಸಂಕೀರ್ಣವಾದ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ತ್ವರಿತವಾಗಿ ಅಗ್ರಾಹ್ಯವಾಗುತ್ತದೆ, ಆದರೆ ಪೈಥಾನ್ ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿರುತ್ತದೆ. ಕೆಲಸವು ವಿಂಡೋಸ್ ಸರ್ವರ್‌ಗಳು, ಆಕ್ಟಿವ್ ಡೈರೆಕ್ಟರಿ ಅಥವಾ ಅಜೂರ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ, ಪವರ್‌ಶೆಲ್ ನೈಸರ್ಗಿಕ ಪರಿಸರವಾಗಿದೆ ಏಕೆಂದರೆ ಅದರ ವಸ್ತು-ಆಧಾರಿತ ಸ್ವಭಾವವು ಈ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳೊಂದಿಗೆ ಆಳವಾಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ. AI ಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ವಿನಂತಿಸುವಾಗ ನೀವು ಯಾವ ಭಾಷೆಯನ್ನು ಆರಿಸಿದ್ದೀರಿ ಮತ್ತು ಏಕೆ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದರಿಂದ ಔಟ್‌ಪುಟ್ ನಿಮ್ಮ ಪರಿಸರಕ್ಕೆ ಸೂಕ್ತವಾಗಿದೆ ಮತ್ತು ಭಾಷಾವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಹಂತ ಹಂತವಾಗಿ: ಸುರಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟ್ ಉತ್ಪಾದನೆ

1. ಕಾರ್ಯ ಮತ್ತು ಪರಿಸರವನ್ನು ವಿವರಿಸಿ. ಅದು ಏನು ಮಾಡುತ್ತದೆ, ಯಾವ ಓಎಸ್ / ಶೆಲ್, ಯಾವ ನಿರ್ಬಂಧಗಳು?
2. ಸುರಕ್ಷತಾ ರೇಲಿಂಗ್‌ಗಳಿಗಾಗಿ ಕೇಳಿ. ಬ್ಯಾಷ್‌ನಲ್ಲಿ, -euo ಪೈಪ್‌ಫೇಲ್ ಅನ್ನು ಹೊಂದಿಸಿ (ದೋಷದ ಮೇಲೆ ನಿಲ್ಲಿಸಿ, ವ್ಯಾಖ್ಯಾನಿಸದ ವೇರಿಯಬಲ್‌ನಲ್ಲಿ ನಿಲ್ಲಿಸಿ), ಅಪಾಯಕಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ದೃಢೀಕರಣ ಪ್ರಾಂಪ್ಟ್, ಅಳಿಸುವ ಬದಲು ಮೊದಲು ಸರಿಸಿ.
3. ಡ್ರೈ-ರನ್ ಮೋಡ್ ಅನ್ನು ವಿನಂತಿಸಿ. --ಡ್ರೈ-ರನ್‌ನೊಂದಿಗೆ ಏನು ಮಾಡಬೇಕೆಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಲಿ, ಆದರೆ ಅದನ್ನು ಮಾಡಬೇಡಿ.
4. ಓದಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ. ಪ್ರತಿ ಸಾಲು ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ, ವಿಶೇಷವಾಗಿ ಅಳಿಸಿ/ಮೂವ್/ನೆಟ್‌ವರ್ಕ್ ಕಾರ್ಯಾಚರಣೆಗಳು.
5. ಪ್ರತ್ಯೇಕ ಪರಿಸರದಲ್ಲಿ ಇದನ್ನು ಪ್ರಯತ್ನಿಸಿ. ಪರೀಕ್ಷಾ ಫೋಲ್ಡರ್ನಲ್ಲಿ, ಮಾದರಿ ಡೇಟಾದೊಂದಿಗೆ ಅದನ್ನು ರನ್ ಮಾಡಿ.
6. ಲಾಗಿಂಗ್‌ಗೆ ಸೇರಿಸಿ. ಸ್ಕ್ರಿಪ್ಟ್ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಲಿ ಆದ್ದರಿಂದ ಅದನ್ನು ನಂತರ ವೀಕ್ಷಿಸಬಹುದು.

ಸುರಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್‌ನ ಅಗತ್ಯತೆಗಳು

ನಿರ್ಮಾಣ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಗಾರ್ಡ್ರೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬೇಕು:

• ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ ನಿಲ್ಲಿಸುವುದು. ಬ್ಯಾಷ್: ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್. PowerShell: $ErrorActionPreference = 'ನಿಲ್ಲಿಸು'. ಒಂದು ಹೆಜ್ಜೆ ವಿಫಲವಾದರೆ, ಮುಂದಿನದು ಕೆಲಸ ಮಾಡಬಾರದು.
• ಐಡೆಂಪೊಟೆನ್ಸಿ (ಪುನರಾವರ್ತನೆ). ಸ್ಕ್ರಿಪ್ಟ್ ಎರಡು ಬಾರಿ ಚಲಿಸಿದರೆ, ಅದು ಡಬಲ್ ಹಾನಿಯನ್ನು ಎದುರಿಸಬಾರದು; "ನೀವು ಈಗಾಗಲೇ ಅದನ್ನು ಹೊಂದಿದ್ದರೆ, ಅದನ್ನು ಬಿಟ್ಟುಬಿಡಿ" ತರ್ಕ.
• ಅನುಮೋದನೆ ಮತ್ತು ಡ್ರೈ ರನ್. ವಿನಾಶಕಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ "ನಿಮಗೆ ಖಚಿತವಾಗಿದೆಯೇ?" ಅಥವಾ --ಡ್ರೈ-ರನ್ ಫ್ಲ್ಯಾಗ್.
• ಇನ್ಪುಟ್ ಮೌಲ್ಯೀಕರಣ. ನಿಯತಾಂಕಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ಇದೆಯೇ? ಖಾಲಿ ವೇರಿಯೇಬಲ್ rm -rf "$DIR"/ ಅನ್ನು rm -rf / ಡಿಸಾಸ್ಟರ್ ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು.
• ಲಾಗಿಂಗ್. ಏನು ಮತ್ತು ಯಾವಾಗ ಮಾಡಲಾಯಿತು ಎಂಬುದರ ದಾಖಲೆ.

ಸಲಹೆ: ಖಾಲಿ ವೇರಿಯೇಬಲ್‌ನೊಂದಿಗೆ ಅಳಿಸುವುದು ಬ್ಯಾಷ್‌ನಲ್ಲಿನ ಅತ್ಯಂತ ಅಪಾಯಕಾರಿ ತಪ್ಪು. rm -rf "$DIR" $DIR ಖಾಲಿಯಾಗಿದ್ದರೆ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಅಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಸೆಟ್ -u (ಅನಿರ್ದಿಷ್ಟ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ನಿಲ್ಲಿಸಿ) ಮತ್ತು ಅಳಿಸುವ ಮೊದಲು [ -n "$DIR" ] ಅನ್ನು ಪರಿಶೀಲಿಸುವುದು ಜೀವರಕ್ಷಕವಾಗಿದೆ. AI ನಿಂದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ವಿನಂತಿಸುವಾಗ ಈ ರಕ್ಷಣೆಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವಿನಂತಿಸಿ.

ಭದ್ರತೆ: ರಹಸ್ಯ ಮತ್ತು ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಗಳು

ಎರಡು ದೊಡ್ಡ ಅಪಾಯಗಳು:

1. ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡುವುದು. ಟೋಕನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪಾಸ್‌ವರ್ಡ್ ಸರಳ ಪಠ್ಯವಾಗಿರಬಾರದು; ಪರಿಸರ ವೇರಿಯಬಲ್ ಅಥವಾ ವಾಲ್ಟ್‌ನಿಂದ ಓದಬೇಕು. ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು Git ಗೆ ಹೋಗುತ್ತವೆ; ಸಮಾಧಿ ರಹಸ್ಯ ಶಾಶ್ವತ ಸೋರಿಕೆಯಾಗಿದೆ.
2. ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಗಳು. rm -rf, ತೆಗೆದುಹಾಕಿ-ಐಟಂ -ರಿಕರ್ಸ್ -ಫೋರ್ಸ್, ಡ್ರಾಪ್ ಟೇಬಲ್, ಟೆರಾಫಾರ್ಮ್ ನಾಶ — ನೀವು ಇವುಗಳನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನೋಡಿದಾಗ, ನಿಲ್ಲಿಸಿ ಮತ್ತು ಎರಡು ಬಾರಿ ಯೋಚಿಸಿ. ಮೊದಲು ಉತ್ಪನ್ನದಲ್ಲಿ AI ನಿಂದ ರಚಿಸಲಾದ ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಯನ್ನು ಎಂದಿಗೂ ಪ್ರಯತ್ನಿಸಬೇಡಿ.

ಎಚ್ಚರಿಕೆ: "ಈ ಫೈಲ್‌ಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಿರಿ" ಎಂದು ನೀವು AI ಗೆ ಹೇಳಿದಾಗ, ಅದು ಉತ್ಪಾದಿಸುವ ಫೈಂಡ್ ... -delete ಅಥವಾ rm ಆಜ್ಞೆಯ ವ್ಯಾಪ್ತಿಯನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಓದಿ. ವೈಲ್ಡ್‌ಕಾರ್ಡ್ (*) ಅಥವಾ ತಪ್ಪು ಮಾರ್ಗವು ನೀವು ಅಳಿಸಲು ಬಯಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದನ್ನು ಅಳಿಸುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಅಳಿಸುವ ಬದಲು "ಅಳಿಸಬೇಕಾದ ಪಟ್ಟಿ" ಮೋಡ್‌ನೊಂದಿಗೆ ಯಾವಾಗಲೂ ರನ್ ಮಾಡಿ.

ಮೂರು ಭಾಷೆಗಳ ಹೋಲಿಕೆ

ಮಾನದಂಡ

ಬಾಷ್

ಹೆಬ್ಬಾವು

ಪವರ್ಶೆಲ್

ಎಲ್ಲಿ ಅದು ಉತ್ತಮವಾಗಿದೆ

ಲಿನಕ್ಸ್ ಶೆಲ್, ಕಮಾಂಡ್ ಚೈನ್

ಸಂಕೀರ್ಣ ತರ್ಕ, API, ಡೇಟಾ

ವಿಂಡೋಸ್ ಕ್ಲೌಡ್ ನಿರ್ವಹಣೆ

ಕಲಿಕೆಯ ರೇಖೆ

ಮಧ್ಯಮ (ಸಿಕ್ಕಿ)

ಸುಲಭ

ಮಧ್ಯಮ

ನಿರ್ವಹಣೆ ದೋಷ

ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್

ಪ್ರಯತ್ನಿಸಿ/ಹೊರತುಪಡಿಸಿ

ಪ್ರಯತ್ನಿಸಿ/ಕ್ಯಾಚ್, -ErrorAction

ಪೋರ್ಟಬಿಲಿಟಿ

Unix/Linux/mac

ಎಲ್ಲೆಡೆ

ಕ್ರಾಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ (PS 7+)

ಯಾವಾಗ

ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಸಿಸ್ಟಮ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

ಲಾಜಿಕ್ 20 ಸಾಲುಗಳಿಗಿಂತ ಹೆಚ್ಚು

ವಿಂಡೋಸ್/AD/Azure

ಮೂರು ಸಣ್ಣ ಪ್ರಕರಣಗಳು

ಪ್ರಕರಣ 1 - 2 ಗಂಟೆಗಳ ಕರಕುಶಲ 5 ನಿಮಿಷಗಳಲ್ಲಿ. ಒಬ್ಬ ಇಂಜಿನಿಯರ್ ಪ್ರತಿ ವಾರ 40 ಸರ್ವರ್‌ಗಳಿಂದ ದಾಖಲೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಆರ್ಕೈವ್ ಮಾಡಲು 2 ಗಂಟೆಗಳ ಕಾಲ ಕಳೆಯುತ್ತಿದ್ದ. ಅವರು AI ಕಾರ್ಯವನ್ನು ವಿವರಿಸಿದರು ಮತ್ತು -euo ಪೈಪ್‌ಫೈಲ್ + ಡ್ರೈ-ರನ್ ರಕ್ಷಣೆಗಳನ್ನು ಹೊಂದಿಸಿದರು ಮತ್ತು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸಿದರು. ಮೊದಲು ಡ್ರೈ-ರನ್‌ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಲಾಗಿದೆ, ನಂತರ ಅದನ್ನು ನಿಗದಿತ ಕಾರ್ಯಕ್ಕೆ (ಕ್ರಾನ್) ಲಿಂಕ್ ಮಾಡಿದೆ. ಸಾಪ್ತಾಹಿಕ ಕೆಲಸವನ್ನು 5 ನಿಮಿಷಕ್ಕೆ ಇಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮಾನವ ದೋಷವನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

ಪ್ರಕರಣ 2 - ಶೂನ್ಯ ವೇರಿಯಬಲ್ ದುರಂತವನ್ನು ತಪ್ಪಿಸಲಾಗಿದೆ. AI ನಿರ್ಮಿಸಿದ ಕ್ಲೀನಿಂಗ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ rm -rf "$TARGET"/* ಇತ್ತು, ಆದರೆ TARGET ಅನ್ನು ಎಲ್ಲೋ ನಿಯೋಜಿಸದಿದ್ದರೆ, ಅದು ಖಾಲಿಯಾಗಿಯೇ ಉಳಿಯುತ್ತದೆ. ಇಂಜಿನಿಯರ್ ಆಗಿ ಓದುತ್ತಿರುವಾಗಲೇ ಅವರು ಇದನ್ನು ಅರಿತುಕೊಂಡರು; ಸೆಟ್ -ಯು ಮತ್ತು [ -n "$TARGET" ] || ನಿರ್ಗಮನ 1 ನಿಯಂತ್ರಣವನ್ನು ಸೇರಿಸಲಾಗಿದೆ. ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ವೇರಿಯಬಲ್ ಶೂನ್ಯವಾಗಿ ಉಳಿಯಿತು ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ದುರಂತದ ಬದಲಿಗೆ ಸುರಕ್ಷಿತವಾಗಿ ನಿಲ್ಲಿಸಿತು.

ಪ್ರಕರಣ 3 - ಎಂಬೆಡೆಡ್ ಟೋಕನ್ ಸೆರೆಹಿಡಿಯಲಾಗಿದೆ. ಅನುಕೂಲಕ್ಕಾಗಿ, API ಅನ್ನು ವಿನಂತಿಸುವ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ TOKEN = "ghp_realtoken" ಸಾಲನ್ನು AI ಸೇರಿಸಿದೆ (ಉದಾಹರಣೆಗೆ). ಇಂಜಿನಿಯರ್ ಇದನ್ನು ತೆಗೆದುಹಾಕಿದರು ಮತ್ತು os.environ["TOKEN"] ಜೊತೆಗೆ ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ನಿಂದ ಓದುವುದಕ್ಕೆ ಬದಲಾಯಿಸಿದರು ಮತ್ತು ಟೋಕನ್ ಅನ್ನು ರದ್ದುಗೊಳಿಸಿದರು ಮತ್ತು ನವೀಕರಿಸಿದರು. ಸ್ಕ್ರಿಪ್ಟ್ Git ಗೆ ಹೋದರೆ, ಟೋಕನ್ ಸಾರ್ವಜನಿಕವಾಗಿರುತ್ತದೆ.

ನಾಲ್ಕು ನಕಲಿಸಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್‌ಗಳು

1) ಸುರಕ್ಷಿತ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್:

ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಿರಿ: [ಕಾರ್ಯ]. ಕಡ್ಡಾಯ ನಿಯಮಗಳು:- `ಸೆಟ್ -euo pipefail` ಪ್ರಾರಂಭದಲ್ಲಿ.- ವೇರಿಯೇಬಲ್ ಅನ್ನು ಅಳಿಸುವಾಗ/ಚಲಿಸುವಲ್ಲೆಲ್ಲಾ ಖಾಲಿಯಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ.- `--dry-run` ಫ್ಲ್ಯಾಗ್: ಈ ಮೋಡ್‌ನಲ್ಲಿ ಏನು ಮಾಡಬೇಕೆಂದು ಬರೆಯಿರಿ ಆದರೆ ಅದನ್ನು ಮಾಡಬೇಡಿ.- ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಬೇಡಿ; ಪರಿಸರ ವೇರಿಯಬಲ್‌ನಿಂದ ಓದಿ. - ಪ್ರತಿ ಹಂತದಲ್ಲಿ ತಿಳಿವಳಿಕೆ ಲಾಗ್ ಅನ್ನು ಮುದ್ರಿಸಿ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾಮೆಂಟ್ ಮಾಡಿ ಮತ್ತು ಅತ್ಯಂತ ಅಪಾಯಕಾರಿ ರೇಖೆಯನ್ನು ಗುರುತಿಸಿ.

2) ಸ್ಕ್ರಿಪ್ಟ್ ವಿವರಣೆ/ನಿಯಂತ್ರಣ:

ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಲೈನ್ ಅನ್ನು ಸಾಲಿನ ಮೂಲಕ ವಿವರಿಸಿ ಮತ್ತು ಭದ್ರತೆಗಾಗಿ ಪರಿಶೀಲಿಸಿ: ಎಂಬೆಡೆಡ್ ರಹಸ್ಯ, ವಿನಾಶಕಾರಿ ಆಜ್ಞೆ (rm/Remove-Item/DROP), ಮಾನ್ಯತೆ ಇಲ್ಲದ ಇನ್‌ಪುಟ್, ದೋಷ ನಿರ್ವಹಣೆಯ ಕೊರತೆ? ಪ್ರಾಮುಖ್ಯತೆ ಮತ್ತು ತಿದ್ದುಪಡಿಯ ಕ್ರಮದಲ್ಲಿ ಪ್ರತಿ ಅಪಾಯವನ್ನು ಬರೆಯಿರಿ. ಸ್ಕ್ರಿಪ್ಟ್: [ಕೋಡ್]

3) ಭಾಷಾ ಅನುವಾದ:

ಆ [SOURCE LANGUAGE] ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು [TARGET LANGUAGE] ಗೆ ಅನುವಾದಿಸಿ. ನಡವಳಿಕೆಯನ್ನು ಮಾತಿನಂತೆ ಇರಿಸಿ, ಗುರಿ ಭಾಷೆಯ ಭಾಷಾವೈಶಿಷ್ಟ್ಯದ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಬಳಸಿ, ಯಾವುದೇ ಎಂಬೆಡೆಡ್ ರಹಸ್ಯಗಳನ್ನು ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗೆ ಸರಿಸಿ. ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸಬಹುದಾದ ಅಂಶಗಳನ್ನು ಗಮನಿಸಿ. ಸ್ಕ್ರಿಪ್ಟ್: [ಕೋಡ್]

4) ಯೋಜಿತ ಕಾರ್ಯ (ಕ್ರಾನ್/ಶೆಡ್ಯೂಲ್ಡ್ ಟಾಸ್ಕ್):

ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಿ [ಆವರ್ತನ: ಉದಾ. ವೇಳಾಪಟ್ಟಿಯ ವ್ಯಾಖ್ಯಾನವನ್ನು ಬರೆಯಿರಿ ([ಕ್ರಾನ್ / ಸಿಸ್ಟಮ್‌ಡಿ ಟೈಮರ್ / ವಿಂಡೋಸ್ ಟಾಸ್ಕ್ ಶೆಡ್ಯೂಲರ್]) ಅದು ರನ್ ಆಗುತ್ತದೆ [ಪ್ರತಿ ರಾತ್ರಿ 02:00 ಕ್ಕೆ]. ವೈಫಲ್ಯದ ಬಗ್ಗೆ ನನಗೆ ಹೇಗೆ ಎಚ್ಚರಿಕೆ ನೀಡಬೇಕು (ಲಾಗ್/ನಿರ್ಗಮನ ಕೋಡ್/ಅಧಿಸೂಚನೆ) ಮತ್ತು ಅತಿಕ್ರಮಣವನ್ನು ತಡೆಯುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಸೇರಿಸಿ.

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್

ದುರ್ಬಲ: "ಹಳೆಯ ಫೈಲ್‌ಗಳನ್ನು ಅಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಿರಿ."

ಫಲಿತಾಂಶ: ಸ್ಕೋಪ್‌ಲೆಸ್, ಅಸುರಕ್ಷಿತ, ಡ್ರೈ-ರನ್‌ಲೆಸ್ ಆರ್ಎಮ್ ಸ್ಕ್ರಿಪ್ಟ್; ಅದು ತಪ್ಪಾದ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ರನ್ ಆಗಿದ್ದರೆ, ಅದನ್ನು ಬದಲಾಯಿಸಲಾಗದಂತೆ ಅಳಿಸಲಾಗುತ್ತದೆ.

ಪ್ರಬಲ: "/var/log/app ಅಡಿಯಲ್ಲಿ 30 ದಿನಗಳಿಗಿಂತ ಹಳೆಯದಾದ .log ಫೈಲ್‌ಗಳನ್ನು ಅಳಿಸಲು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಿರಿ. set -euo pipefail ಬಳಸಿ, ಗುರಿ ಡೈರೆಕ್ಟರಿ ಖಾಲಿಯಾಗಿದ್ದರೆ ನಿಲ್ಲಿಸಿ, ಏನನ್ನು ಅಳಿಸಬೇಕು ಎಂಬುದನ್ನು ಪಟ್ಟಿ ಮಾಡಿ --dry-run ಮೊದಲು, ಪ್ರತಿ ವ್ಯವಹಾರವನ್ನು ಲಾಗ್ ಮಾಡಿ, ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಬೇಡಿ. ಅತ್ಯಂತ ಅಪಾಯಕಾರಿ ರೇಖೆಯನ್ನು ಗುರುತಿಸಿ."

ವ್ಯತ್ಯಾಸ: ಎರಡನೆಯ ಹಕ್ಕು ಸಂಪೂರ್ಣ ವ್ಯಾಪ್ತಿ, ಸುರಕ್ಷತಾ ಗಾರ್ಡ್ರೈಲ್‌ಗಳು ಮತ್ತು ಡ್ರೈ ರನ್ ನಿರೀಕ್ಷೆಯನ್ನು ನೀಡುತ್ತದೆ; ಔಟ್ಪುಟ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಚಲಾಯಿಸಬಹುದು.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಓದದೆ ಓಡಿಸುವುದು. ನಿರ್ದಿಷ್ಟವಾಗಿ ಸಾಲುಗಳನ್ನು ಅಳಿಸಿ/ಸರಿಸುವುದು ದುರಂತಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.
• ಖಾಲಿ ವೇರಿಯೇಬಲ್‌ಗಳಿಗಾಗಿ ಪರಿಶೀಲಿಸುತ್ತಿಲ್ಲ. rm -rf "$X"/ ನೊಂದಿಗೆ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಅಳಿಸುವ ಕ್ಲಾಸಿಕ್ ಅನಾಹುತ.
• `set -euo pipefail` / `-ErrorAction Stop` ಅನ್ನು ಬಿಟ್ಟುಬಿಡಿ. ಒಂದು ಹೆಜ್ಜೆ ಉರಿಯುತ್ತದೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಕುರುಡಾಗಿ ಮುಂದುವರಿಯುತ್ತದೆ.
• ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡುವುದು. Git ಗೆ ನಿರಂತರ ಸೋರಿಕೆ.
• ಡ್ರೈ ರನ್ ಇಲ್ಲದೆ ವಿನಾಶಕಾರಿ ಪ್ರಕ್ರಿಯೆ. ಮೊದಲು "ಏನು ಮಾಡಬೇಕೆಂದು ನನಗೆ ತೋರಿಸಿ", ನಂತರ ಅದನ್ನು ಮಾಡಿ.
• ಉತ್ಪನ್ನದಲ್ಲಿ ಮೊದಲ ಪ್ರಯತ್ನವನ್ನು ಮಾಡುವುದು. ಪ್ರತ್ಯೇಕವಾದ ಪರೀಕ್ಷಾ ಪರಿಸರವಿಲ್ಲದೆ ರನ್ನಿಂಗ್.

ಸಾರಾಂಶದಲ್ಲಿ

DevOps ಎಂಬುದು ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಕಲೆಯಾಗಿದೆ; ಪುನರಾವರ್ತಿತ ಕೆಲಸವನ್ನು ಬ್ಯಾಷ್, ಪೈಥಾನ್ ಮತ್ತು ಪವರ್‌ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗೆ ನಿಯೋಜಿಸಲಾಗಿದೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ರೂಪಿಸಲು, ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಭಾಷಾಂತರಿಸಲು AI ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ - ಆದರೆ ಸುರಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟ್ ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್, ಶೂನ್ಯ ವೇರಿಯಬಲ್ ತಪಾಸಣೆ, ಡ್ರೈ-ರನ್ ಮೋಡ್, ಎಂಬೆಡೆಡ್ ರಹಸ್ಯವಿಲ್ಲದಿರುವಿಕೆ ಮತ್ತು ಲಾಗಿಂಗ್‌ನಂತಹ ದೋಷ ಗಾರ್ಡ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬೇಕು. ಪ್ರತಿಯೊಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು, ವಿಶೇಷವಾಗಿ ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ, ಪ್ರತ್ಯೇಕ ಪರಿಸರದಲ್ಲಿ ಮತ್ತು ಮೊದಲು ಡ್ರೈ-ರನ್‌ನಲ್ಲಿ ಓದುವುದು ಮತ್ತು ಪರೀಕ್ಷಿಸುವುದು ನಿಮ್ಮ ಜವಾಬ್ದಾರಿಯಾಗಿದೆ.

ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ

ಮರುಕಳಿಸುವ ಕಾರ್ಯವನ್ನು ಆರಿಸಿ (ಲಾಗ್ ಆರ್ಕೈವಿಂಗ್, ಬ್ಯಾಕಪ್, ಶುಚಿಗೊಳಿಸುವಿಕೆ). (1) "ಸೆಕ್ಯೂರ್ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್" ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ AI ರಕ್ಷಿತ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸುವಂತೆ ಮಾಡಿ. (2) ಅದೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು "ಸ್ಕ್ರಿಪ್ಟ್ ವಿವರಣೆ/ಆಡಿಟ್" ಟೆಂಪ್ಲೇಟ್‌ನಂತೆ ಭದ್ರತೆಗಾಗಿ ಪರೀಕ್ಷಿಸಿ ಮತ್ತು AI ಫ್ಲ್ಯಾಗ್ ಮಾಡಿರುವ ಅತ್ಯಂತ ಅಪಾಯಕಾರಿ ರೇಖೆಯನ್ನು ಹುಡುಕಿ. (3) ಪರೀಕ್ಷಾ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಮಾದರಿ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ಅದರ ನಡವಳಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಿ, ಮೊದಲು --dry-run ನೊಂದಿಗೆ.

ಪರಿಶೀಲನಾಪಟ್ಟಿ

• [ ] ನಾನು ಬಯಸದ ಕಾರ್ಯವನ್ನು ನಾನು ಬರೆದಿದ್ದೇನೆ, OS/ಶೆಲ್ ಮತ್ತು ಸೆಕ್ಯುರಿಟಿ ಗಾರ್ಡ್‌ರೈಲ್‌ಗಳು.
• [ ] ಸ್ಕ್ರಿಪ್ಟ್ ಸೆಟ್ -euo pipefail / -ErrorAction Stop ನಂತಹ ದೋಷವನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ.
• [ ] ನಾನು ಅಳಿಸುವಿಕೆ/ಸರಿಸುವ ಮೊದಲು ಖಾಲಿ ವೇರಿಯೇಬಲ್ ಮತ್ತು ಇನ್‌ಪುಟ್ ಚೆಕ್ ಅನ್ನು ಸೇರಿಸಿದೆ.
• [ ] ವಿನಾಶಕಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ --ಡ್ರೈ-ರನ್/ದೃಢೀಕರಣ ಕಾರ್ಯವಿಧಾನವಿದೆ.
• [ ] ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಯಾವುದೇ ರಹಸ್ಯ ಹುದುಗಿಲ್ಲ; ಮೌಲ್ಯಗಳು ಪರಿಸರ ವೇರಿಯಬಲ್/ಕೇಸ್‌ನಿಂದ ಬರುತ್ತವೆ.
• [ ] ನಾನು ಡ್ರೈ-ರನ್‌ನೊಂದಿಗೆ ಪ್ರತ್ಯೇಕವಾದ ಪರೀಕ್ಷಾ ಪರಿಸರದಲ್ಲಿ ಮೊದಲ ಪರೀಕ್ಷೆಯನ್ನು ಮಾಡಿದ್ದೇನೆ.