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

ಲಾಭಗಳು:

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

ಆಟೊಮೇಷನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು: AI ಯೊಂದಿಗೆ ಸುರಕ್ಷಿತವಾಗಿ ಬ್ಯಾಷ್, ಪವರ್‌ಶೆಲ್ ಮತ್ತು ಪೈಥಾನ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವುದು

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

ಈ ಘಟಕದಲ್ಲಿ, AI ನೊಂದಿಗೆ ಸುರಕ್ಷಿತ, ಓದಬಲ್ಲ ಮತ್ತು ಮರುಪಡೆಯಬಹುದಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ತಯಾರಿಸಬೇಕೆಂದು ನೀವು ಕಲಿಯುವಿರಿ; ಐಡೆಂಪೊಟೆನ್ಸಿ (ಒಂದೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಎರಡು ಬಾರಿ ಚಲಾಯಿಸುವುದರಿಂದ ಹಾನಿಯಾಗುವುದಿಲ್ಲ) ಮತ್ತು ಡ್ರೈ-ರನ್‌ನಂತಹ ಜೀವ ಉಳಿಸುವ ತತ್ವಗಳು; ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉತ್ಪಾದನೆಗೆ ಒಳಪಡಿಸುವ ಮೊದಲು ಅದರ ಮೂಲಕ ಹೋಗಬೇಕಾದ ತಪಾಸಣೆಗಳನ್ನು ನೀವು ಕಲಿಯುವಿರಿ.

AI ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಏಕೆ ಶಕ್ತಿಯುತವಾಗಿದೆ?

ಒಬ್ಬ ಅನುಭವಿ ನಿರ್ವಾಹಕರು ಸಹ ಬ್ಯಾಷ್ ಲೂಪ್‌ನ ನಿಖರವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್, ಪವರ್‌ಶೆಲ್ cmdlet (ಕಮಾಂಡ್) ನ ನಿಯತಾಂಕಗಳು ಅಥವಾ ಪೈಥಾನ್ ಪ್ರಯತ್ನವನ್ನು / ಹೃದಯದಿಂದ ನಿರ್ಬಂಧಿಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ತಿಳಿದಿರುವುದಿಲ್ಲ. AI ಈ ಅಂತರವನ್ನು ತಕ್ಷಣವೇ ತುಂಬುತ್ತದೆ: ನೀವು ಸರಳ ಟರ್ಕಿಶ್‌ನಲ್ಲಿ ಉದ್ದೇಶವನ್ನು ವಿವರಿಸುತ್ತೀರಿ ಮತ್ತು ಇದು ಕೆಲಸದ ರೂಪರೇಖೆಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಇದಲ್ಲದೆ, ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು AI ಗೆ ನೀಡಬಹುದು ಮತ್ತು "ಇದನ್ನು ವಿವರಿಸಿ", "ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಸೇರಿಸಿ", "ಇದನ್ನು ಹೆಚ್ಚು ಓದುವಂತೆ ಮಾಡಿ" ಎಂದು ಹೇಳಬಹುದು. ಇದು ಕಲಿಕೆಯ ರೇಖೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಜೂನಿಯರ್ ತಂಡದ ಸದಸ್ಯರನ್ನು ವೇಗಕ್ಕೆ ತರುತ್ತದೆ.

ಆದರೆ ಅಧಿಕಾರದೊಂದಿಗೆ ಜವಾಬ್ದಾರಿ ಬರುತ್ತದೆ. ಹೆಚ್ಚಿನ ಸಮಯ, AI- ರಚಿತವಾದ ಸ್ಕ್ರಿಪ್ಟ್ "ಸಂತೋಷದ ಹಾದಿ" ಯನ್ನು ಸರಿಯಾಗಿ ಬರೆಯುತ್ತದೆ (ಎಲ್ಲವೂ ಸರಿಯಾಗಿದ್ದರೆ); ಆದರೆ ಇದು ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳಬಹುದು (ಫೈಲ್ ಕಾಣೆಯಾಗಿದೆ, ಡಿಸ್ಕ್ ತುಂಬಿದೆ, ನೆಟ್‌ವರ್ಕ್ ಡೌನ್) ಅಥವಾ ಅಪಾಯಕಾರಿ ಊಹೆಗಳನ್ನು ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ಮೂರು ಹಂತಗಳಲ್ಲಿ AI ಯೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಉತ್ಪಾದನೆಯ ಕುರಿತು ಯೋಚಿಸಿ: ಉತ್ಪಾದಿಸಿ, ಗಟ್ಟಿಗೊಳಿಸು, ಪರಿಶೀಲಿಸು.

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

1. ಉದ್ದೇಶ ಮತ್ತು ನಿರ್ಬಂಧವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಬರೆಯಿರಿ. ಯಾವ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್, ಯಾವ ಶೆಲ್ ಆವೃತ್ತಿ, ಯಾವ ಫೈಲ್ ಪಥಗಳು, ಯಾವ ಹಕ್ಕುಗಳು? "Ubuntu 22.04, Bash 5, sudo ರೂಟ್ ಅಲ್ಲ, /opt/app/logs ಅಡಿಯಲ್ಲಿ ಮಾತ್ರ ರನ್ ಮಾಡಿ". ಅಸ್ಪಷ್ಟ ಬೇಡಿಕೆಯು ಅಪಾಯಕಾರಿ ಊಹೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.
2. ಸುರಕ್ಷತಾ ರೇಲಿಂಗ್‌ಗಳಿಗಾಗಿ ಕೇಳಿ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು "ವೈಫಲ್ಯದಲ್ಲಿ ನಿಲ್ಲಿಸಿ" (ಬ್ಯಾಶ್‌ನಲ್ಲಿ ಹೊಂದಿಸಿ -euo ಪೈಪ್‌ಫೇಲ್), ವಿನಾಶಕಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳ ದೃಢೀಕರಣಕ್ಕಾಗಿ ಪ್ರಾಂಪ್ಟ್, ಕಾರ್ಯಾಚರಣೆಯ ಮೊದಲು ಬ್ಯಾಕಪ್ ಮತ್ತು ಡ್ರೈ-ರನ್ ಮೋಡ್ ಅಗತ್ಯವಿದೆ. ಈ ಗಾರ್ಡ್ರೈಲ್‌ಗಳು AI ಬೈಪಾಸ್‌ಗಳನ್ನು ಎಡ್ಜ್ ಸ್ಟೇಟ್‌ಗಳನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತವೆ.
3. ಇಂಪೋಟೆಂಟ್ ಎಂದು ಬರೆಯಿರಿ. ಎರಡನೇ ಬಾರಿ ರನ್ ಮಾಡಿದಾಗ ಸ್ಕ್ರಿಪ್ಟ್ ಯಾವುದೇ ದೋಷಗಳು ಅಥವಾ ಹಾನಿಯನ್ನು ಉಂಟುಮಾಡಬಾರದು. "ಬಳಕೆದಾರರು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಬಿಟ್ಟುಬಿಡಿ", "ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿ, ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಅದನ್ನು ಮುಟ್ಟಬೇಡಿ" ಎಂಬ ತರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಿ. ಇದು ಯಾಂತ್ರೀಕರಣವನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಮತ್ತೆ ಮತ್ತೆ ಚಲಾಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
4. ಓದಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ. ತಯಾರಿಸಿದ ಪ್ರತಿ ಸಾಲನ್ನು ಓದಿ. ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಗಳನ್ನು (rm, Remove-Item, DROP) ಪ್ರತ್ಯೇಕವಾಗಿ ಗುರುತಿಸಲು AI ಅನ್ನು ಕೇಳಿ.
5. ಡ್ರೈ ರನ್ನೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ. ಮೊದಲಿಗೆ, ನಿಜವಾದ ಕಾರ್ಯಾಚರಣೆಗಳ ಬದಲಿಗೆ "ಏನು ಮಾಡಬೇಕೆಂದು ಹೇಳುವುದು" ಮೋಡ್ನಲ್ಲಿ ಅದನ್ನು ರನ್ ಮಾಡಿ. ಔಟ್‌ಪುಟ್ ನೀವು ನಿರೀಕ್ಷಿಸುವಂತಿದ್ದರೆ, ನೈಜ ಮೋಡ್‌ಗೆ ಬದಲಾಯಿಸಿ - ಮತ್ತು ಮೊದಲು ಪರೀಕ್ಷಾ ಯಂತ್ರದಲ್ಲಿ.
6. ನಿಮ್ಮ ಪುನರಾಗಮನವನ್ನು ತಯಾರಿಸಿ. ಸ್ಕ್ರಿಪ್ಟ್ ಬ್ಯಾಕಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆಯೇ? ಬ್ಯಾಕಪ್ ಅನ್ನು ಹೇಗೆ ಮರುಸ್ಥಾಪಿಸುವುದು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆಯೇ? ಲಾಗಿಂಗ್ ಇದೆಯೇ, ಅದು ನಂತರ ಏನು ಮಾಡುತ್ತಿದೆ ಎಂದು ನೀವು ನೋಡಬಹುದೇ?

ಸಲಹೆ: ಪ್ರತಿ ಡಿಸ್ಟ್ರಕ್ಟರ್ ಸ್ಕ್ರಿಪ್ಟ್ DRY_RUN=true ವೇರಿಯೇಬಲ್ ಮತ್ತು --apply ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಏನನ್ನೂ ಅಳಿಸದೆಯೇ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಬರೆಯುವುದು ಪೂರ್ವನಿಯೋಜಿತ ನಡವಳಿಕೆಯಾಗಿದೆ; --ಅನ್ವಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನೀಡಿದರೆ ಮಾತ್ರ ನಿಜವಾದ ಅಳಿಸುವಿಕೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲಿ. ಈ ಒಂದು ಅಭ್ಯಾಸವು ವೃತ್ತಿಜೀವನದ ದೀರ್ಘ ವಿಪತ್ತುಗಳನ್ನು ತಡೆಯುತ್ತದೆ.

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

ಪ್ರಕರಣ 1 - ಐಡೆಂಪೊಟೆನ್ಸಿ 3 ಗಂಟೆಗಳ ಕಾಲ ಉಳಿಸಲಾಗಿದೆ. ನಿರ್ವಾಹಕರು 25 ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಅದೇ ಮಾನಿಟರಿಂಗ್ ಏಜೆಂಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆದಿದ್ದಾರೆ. ಮೊದಲ ಆವೃತ್ತಿಯು ಅಸಮರ್ಥವಾಗಿರಲಿಲ್ಲ: ಏಜೆಂಟ್ ಅನ್ನು ಈಗಾಗಲೇ ಸ್ಥಾಪಿಸಿದ್ದರೆ ಅದು ಎರಡನೇ ರನ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಮುರಿಯಿತು. ಇಂಜಿನಿಯರ್ AI ಅನ್ನು "ಅದನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ಅದು ಇದ್ದರೆ ಅದನ್ನು ಬಿಟ್ಟುಬಿಡಿ" ಎಂಬ ತರ್ಕವನ್ನು ಸೇರಿಸಿದರು. ಮುಂದಿನ ನಿರ್ವಹಣಾ ವಿಂಡೋದಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಆಕಸ್ಮಿಕವಾಗಿ ಎರಡು ಬಾರಿ ಪ್ರಚೋದಿಸಿತು ಆದರೆ ಅದು ಯಾವುದೇ ಹಾನಿ ಮಾಡಲಿಲ್ಲ. ಐಡೆಂಪೊಟೆನ್ಸಿ 25-ಸರ್ವರ್ ಚೇತರಿಕೆಯನ್ನು ಅನಗತ್ಯ ಮಾಡಿದೆ.

ಪ್ರಕರಣ 2 - ಡ್ರೈ-ರನ್ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಉಳಿಸಲಾಗಿದೆ. ಒಂದು ತಂಡವು ಹಳೆಯ ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ಶುದ್ಧೀಕರಿಸಿದ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದೆ. ವೇರಿಯೇಬಲ್ ಖಾಲಿಯಾಗಿದ್ದರೆ, ಮಾರ್ಗವು / ಬದಲಿಗೆ / ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳು/ — ಒಂದು ಶ್ರೇಷ್ಠ ಅಪಾಯವಾಗಿದೆ. ಎಂಜಿನಿಯರ್ ಇದನ್ನು ಮೊದಲು DRY_RUN ಮೋಡ್‌ನಲ್ಲಿ ಓಡಿಸಿದರು, ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ rm -rf / ಗೆ ಹೋಲುವ ರೇಖೆಯನ್ನು ನೋಡಿದಾಗ ಫ್ರೀಜ್ ಮಾಡಿದರು ಮತ್ತು ವೇರಿಯಬಲ್ ಚೆಕ್ ಅನ್ನು ಸೇರಿಸಿದರು (: "${BACKUP_DIR:?ಖಾಲಿಯಾಗಬಾರದು}"). ಡ್ರೈ ರನ್ನಿಂಗ್ ದೋಷವನ್ನು ಹಿಡಿದಿದ್ದು ಅದು ಉತ್ಪಾದನೆಗೆ ಹೋಗುವ ಮೊದಲು ಸಂಪೂರ್ಣ ಡಿಸ್ಕ್ ಅನ್ನು ಅಳಿಸಿಹಾಕುತ್ತದೆ.

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

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

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

ನಿಮ್ಮ ಪಾತ್ರ: ಹಿರಿಯ ಲಿನಕ್ಸ್ ಆಟೊಮೇಷನ್ ಎಂಜಿನಿಯರ್. ಉಬುಂಟು 22.04 / ಬ್ಯಾಷ್ 5 ಗಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಿರಿ. ಉದ್ದೇಶ:[ಉದ್ದೇಶ]. ನಿಯಮಗಳು:- "set -euo pipefail" ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ.- ": ${VAR:?}" ಜೊತೆಗೆ ಅಗತ್ಯವಿರುವ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ.- ಡಿಫಾಲ್ಟ್ DRY_RUN=true ಜೊತೆಗೆ ವಿನಾಶಕಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ; ನಿಜವಾದ ಅಪ್ಲಿಕೇಶನ್ --ಅನ್ವಯ ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ರನ್ ಆಗಲಿ. - ಪ್ರತಿ ಹಂತವನ್ನು stdout ಗೆ ಲಾಗ್ ಮಾಡಿ, ದೋಷದಲ್ಲಿ ಅರ್ಥಪೂರ್ಣ ಸಂದೇಶದೊಂದಿಗೆ ನಿಲ್ಲಿಸಿ. - ಅದನ್ನು ಶಕ್ತಿಹೀನಗೊಳಿಸಿ (ಇದರಿಂದ ಎರಡನೇ ಓಟದಲ್ಲಿ ಹಾನಿಯಾಗುವುದಿಲ್ಲ). ನಂತರ: ಸಂಭಾವ್ಯ ವಿನಾಶಕಾರಿ ರೇಖೆಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಗುರುತಿಸಿ ಮತ್ತು ಉತ್ಪಾದನೆಯ ಮೊದಲು ನಾನು ಪರೀಕ್ಷಿಸಬೇಕಾದ 3 ಪ್ರಕರಣಗಳನ್ನು ಬರೆಯಿರಿ.

2) ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಗಟ್ಟಿಗೊಳಿಸುವುದು:

ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉತ್ಪಾದನೆಗೆ ಸಿದ್ಧಗೊಳಿಸಿ: (1) ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಲಾಗಿಂಗ್ ಅನ್ನು ಸೇರಿಸಿ, (2) ಅದನ್ನು ಐಡೆಮ್ಪೋಟೆಂಟ್ ಮಾಡಿ, (3) ಡ್ರೈ-ರನ್‌ನ ಹಿಂದೆ ವಿನಾಶಕಾರಿ ಆಜ್ಞೆಗಳನ್ನು ಹಾಕಿ, (4) ಹಾರ್ಡ್-ಕೋಡೆಡ್ ಪಾತ್‌ಗಳು ಮತ್ತು ರಹಸ್ಯಗಳನ್ನು ವೇರಿಯೇಬಲ್‌ಗೆ ಹೊರತೆಗೆಯಿರಿ. ನೀವು ಬದಲಾಯಿಸಿದ ಪ್ರತಿ ಸಾಲನ್ನು ಮತ್ತು ಏಕೆ ಎಂದು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವಿವರಿಸಿ. ಸ್ಕ್ರಿಪ್ಟ್: [ಸ್ಕ್ರಿಪ್ಟ್]

3) ಪವರ್‌ಶೆಲ್ ಸುರಕ್ಷಿತ ಆಟೊಮೇಷನ್:

ನಿಮ್ಮ ಪಾತ್ರ: ವಿಂಡೋಸ್ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ತಜ್ಞರು. PowerShell 5.1 ಹೊಂದಾಣಿಕೆಯ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಿರಿ. ಉದ್ದೇಶ: [ಉದ್ದೇಶ]. ನಿಯಮಗಳು:- "$ErrorActionPreference = 'Stop'" ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ.- ಡಿಸ್ಟ್ರಕ್ಟರ್ cmdlets ಗೆ -WhatIf ಬೆಂಬಲವನ್ನು ಸೇರಿಸಿ (ಡೀಫಾಲ್ಟ್ WhatIf).- ಪ್ರತಿ ಕ್ರಿಯೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ/ಕ್ಯಾಚ್, ಲಾಗ್ ದೋಷದೊಂದಿಗೆ ಸುತ್ತಿ.- ರುಜುವಾತು ಹಾರ್ಡ್‌ಕೋಡಿಂಗ್; ಪ್ಯಾರಾಮೀಟರ್ ಅಥವಾ ಸುರಕ್ಷಿತ ಇನ್ಪುಟ್ ಬಳಸಿ. ವಿನಾಶಕಾರಿ ರೇಖೆಗಳನ್ನು ಗುರುತಿಸಿ ಮತ್ತು ರದ್ದುಗೊಳಿಸುವ ಹಂತಗಳನ್ನು ಬರೆಯಿರಿ.

4) ಕ್ರಾನ್/ಶೆಡ್ಯೂಲ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಡಿಕೋಡಿಂಗ್ ಮತ್ತು ಪರಿಶೀಲನೆ:

ಕೆಳಗಿನ ಕ್ರಾನ್ ಹೇಳಿಕೆಯನ್ನು ಸರಳ ಟರ್ಕಿಶ್ ಭಾಷೆಯಲ್ಲಿ ವಿವರಿಸಿ ಮತ್ತು ಮುಂದಿನ 3 ರನ್‌ಟೈಮ್‌ಗಳನ್ನು ಬರೆಯಿರಿ: [ಅಭಿವ್ಯಕ್ತಿ] ಅಲ್ಲದೆ, ನನ್ನ ಗುರಿ "[ಉದ್ದೇಶ]" ಆಗಿದ್ದರೆ, ಈ ಹೇಳಿಕೆ ಸರಿಯಾಗಿದೆಯೇ ಅಥವಾ ನೀವು ಸೂಚಿಸುವ ಪರಿಹಾರವಿದೆಯೇ? ಸಮಯದ ಅವಧಿಯ ಪರಿಣಾಮವನ್ನು ಸಹ ಗಮನಿಸಿ.

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

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್:

ಲಾಗ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನನಗೆ ಬರೆಯಿರಿ.

ಈ ಪ್ರಾಂಪ್ಟ್ ಅಪಾಯಕಾರಿ: ಯಾವ OS, ಯಾವ ಡೈರೆಕ್ಟರಿ, ಯಾವ ವಯಸ್ಸಿನ ಮಿತಿ, ಯಾವ ಭದ್ರತಾ ಸಿಬ್ಬಂದಿ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ. AI ಒಂದು-ಲೈನರ್, ವಿನಾಶಕಾರಿ ಮತ್ತು ಪರಿಶೀಲಿಸಲಾಗದ rm ಅನ್ನು ತಲುಪಿಸಬಹುದು.

ಶಕ್ತಿಯುತ ಪ್ರಾಂಪ್ಟ್:

ನಿಮ್ಮ ಪಾತ್ರ: ಹಿರಿಯ ಲಿನಕ್ಸ್ ಆಟೊಮೇಷನ್ ಎಂಜಿನಿಯರ್. ಉಬುಂಟು 22.04 / ಬ್ಯಾಷ್‌ಗಾಗಿ ಲಾಗ್ ಕ್ಲೀನಿಂಗ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಿರಿ. 30 ದಿನಗಳಿಗಿಂತ ಹಳೆಯದಾದ /opt/app/logs ಅಡಿಯಲ್ಲಿ .log ಫೈಲ್‌ಗಳನ್ನು ಮಾತ್ರ ಅಳಿಸಿ. ನಿಯಮಗಳು: ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್; BACKUP_DIR ಮತ್ತು LOG_DIR ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ (ಖಾಲಿ ಇದ್ದರೆ ನಿಲ್ಲಿಸಿ); ಅಳಿಸುವ ಮೊದಲು ಫೈಲ್ ಪಟ್ಟಿಯನ್ನು ಲಾಗ್ ಮಾಡಿ; DRY_RUN=true ಡೀಫಾಲ್ಟ್ ಆಗಿರಲಿ, ನಿಜವಾದ ಅಳಿಸುವಿಕೆ --ಅನ್ವಯಿಸಿ; ಅದು ನಿರ್ಭಯವಾಗಿರಲಿ. ವಿನಾಶಕಾರಿ ಸಾಲುಗಳನ್ನು ಗುರುತಿಸಿ ಮತ್ತು ನಾನು ಪರೀಕ್ಷಿಸಬೇಕಾದ 3 ಸನ್ನಿವೇಶಗಳನ್ನು ಬರೆಯಿರಿ.

ವೈಶಿಷ್ಟ್ಯ

ದುರ್ಬಲ/ವೇಗದ ಸ್ಕ್ರಿಪ್ಟ್

ಗಟ್ಟಿಯಾದ ಲಿಪಿ

ನಿರ್ವಹಣೆ ದೋಷ

ಇಲ್ಲ, ಮೌನ ವೈಫಲ್ಯ

ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್, ಪ್ರಯತ್ನಿಸಿ/ಹಿಡಿಯಿರಿ

ವಿನಾಶಕಾರಿ ಕ್ರಿಯೆ

ನೇರವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಡ್ರೈ-ರನ್ + ಓಪನ್ ಚೆಕ್ ಫ್ಲ್ಯಾಗ್

ಮರುಪ್ರಾರಂಭಿಸಿ

ಹಾನಿ ಉಂಟುಮಾಡಬಹುದು

ಅಸಮರ್ಥ, ಸುರಕ್ಷಿತ

ರಹಸ್ಯ ನಿರ್ವಹಣೆ

ಹಾರ್ಡ್ ಕೋಡೆಡ್

ವೇರಿಯಬಲ್/ಹಿಡನ್ ಇನ್‌ಪುಟ್

ರದ್ದುಮಾಡು

ಯಾವುದೂ ಇಲ್ಲ

ಬ್ಯಾಕಪ್ + ಮರುಸ್ಥಾಪನೆ ಹಂತ

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

• ಡ್ರೈ-ರನ್ ಇಲ್ಲದೆ ವಿನಾಶಕಾರಿ ಸ್ಕ್ರಿಪ್ಟ್ ರನ್ ಆಗುತ್ತಿದೆ. ಡ್ರೈ ಮೋಡ್ ವೆಚ್ಚಗಳ ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಮೊದಲು rm, ತೆಗೆದುಹಾಕಿ-ಐಟಂ, ಡ್ರಾಪ್ ಹೊಂದಿರುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನೋಡಲಾಗುತ್ತಿಲ್ಲ.
• ಶೂನ್ಯ ವೇರಿಯಬಲ್ ಪರಿಶೀಲನೆಯನ್ನು ಬಿಟ್ಟುಬಿಡಿ. ಖಾಲಿ ಪಾಥ್ ವೇರಿಯೇಬಲ್ / ಬದಲಿಗೆ / ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ಮಾಡುತ್ತದೆ; : "${VAR:?}" ನೊಂದಿಗೆ ಪರಿಶೀಲಿಸಲು ಮರೆಯದಿರಿ.
• ಐಡೆಂಪೊಟೆನ್ಸಿಯನ್ನು ಮರೆತುಬಿಡುವುದು. ಎರಡು ಬಾರಿ ರನ್ ಮಾಡಿದಾಗ ಸ್ಕ್ರಿಪ್ಟ್ ಒಡೆಯುತ್ತದೆ, ಯಾಂತ್ರೀಕೃತಗೊಂಡವು ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲ.
• ಹಾರ್ಡ್-ಕೋಡಿಂಗ್ ರಹಸ್ಯಗಳು. ನೀವು ಆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹಂಚಿಕೊಂಡಾಗ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪಾಸ್‌ವರ್ಡ್ ಮತ್ತು ಕೀಲಿಯನ್ನು ಬರೆಯುವುದು ಸೋರಿಕೆಯಾಗುತ್ತದೆ.
• ಉತ್ಪಾದನೆಯಲ್ಲಿ ಪರೀಕ್ಷೆ. ನಿರ್ಮಾಣದಲ್ಲಿ ಮೊದಲ ಓಟವನ್ನು ಮಾಡುವುದು ಎಂದರೆ ವೇದಿಕೆಯಲ್ಲಿ ಪೂರ್ವಾಭ್ಯಾಸ ಮಾಡುವುದು; ಮೊದಲು ಪರೀಕ್ಷಾ ಯಂತ್ರ.

ಗಮನ: "ಅದು ಕೆಲಸ ಮಾಡಿದೆ, ಅಂದರೆ ಅದು ಸರಿಯಾಗಿದೆ" ಎಂಬ ಕಾರಣಕ್ಕಾಗಿ AI ನೀಡಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಬೇಡಿ. ಅದು ಕೆಲಸ ಮಾಡುವುದರಿಂದ ಅದು ವಿನಾಶಕಾರಿಯಲ್ಲ ಎಂದು ಅರ್ಥವಲ್ಲ. ಸ್ಕ್ರಿಪ್ಟ್ ಸಂತೋಷದ ಹಾದಿಯಲ್ಲಿ ಚಲಿಸಬಹುದು ಮತ್ತು ಅಂಚಿನ ಸ್ಥಿತಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಅಳಿಸಬಹುದು; ನಿಜವಾದ ಪರೀಕ್ಷೆಯು ಅಂಚಿನ ಪ್ರಕರಣಗಳು.

ಸಾರಾಂಶದಲ್ಲಿ

ಆಟೊಮೇಷನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಪುನರಾವರ್ತನೆಯನ್ನು ನಿವಾರಿಸುತ್ತದೆ ಮತ್ತು ಮಾನವ ದೋಷವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ; ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುವಲ್ಲಿ, ವಿವರಿಸುವಲ್ಲಿ ಮತ್ತು ಗಟ್ಟಿಯಾಗಿಸುವಲ್ಲಿ AI ನಂಬಲಾಗದಷ್ಟು ವೇಗವಾಗಿದೆ. ಆದರೆ ಸ್ಕ್ರಿಪ್ಟ್ ಕೆಲಸ ಮಾಡುವ ಶಕ್ತಿಯಾಗಿದೆ: ಅದು ತಪ್ಪಾಗಿದ್ದರೆ, ಅದು ಅಳಿಸುತ್ತದೆ, ನಿಲ್ಲುತ್ತದೆ, ಅಡ್ಡಿಪಡಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ "ಉತ್ಪಾದನೆ, ಗಟ್ಟಿಗೊಳಿಸು, ಪರಿಶೀಲಿಸು" ಚಕ್ರವನ್ನು ಸ್ಥಾಪಿಸಿ. ಪ್ರತಿ ವಿನಾಶಕಾರಿ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದೋಷ ನಿರ್ವಹಣೆ, ಐಡೆಂಪೊಟೆನ್ಸಿ, ಡ್ರೈ-ರನ್ ಮತ್ತು ಫಾಲ್‌ಬ್ಯಾಕ್ ಅನ್ನು ಸೇರಿಸಿ. ವೇರಿಯೇಬಲ್‌ಗೆ ರಹಸ್ಯಗಳನ್ನು ಹೊರತೆಗೆಯಿರಿ, ಪರೀಕ್ಷಾ ಯಂತ್ರದಲ್ಲಿ ಮೊದಲ ರನ್ ಮಾಡಿ. AI ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯುತ್ತದೆ; ಅದನ್ನು ಓದುವುದು, ಪರೀಕ್ಷಿಸುವುದು ಮತ್ತು ಅದನ್ನು ನಡೆಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ನಿಮ್ಮ ಕೆಲಸ.

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

ನಿಮ್ಮ ಕೆಲಸದಲ್ಲಿ ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪುನರಾವರ್ತಿಸುವ ಕಾರ್ಯವನ್ನು ಆಯ್ಕೆಮಾಡಿ (ಉದಾ. ಲಾಗ್ ಕ್ಲೀನಪ್, ಬಳಕೆದಾರ ತೆರೆಯುವಿಕೆ, ಆರೋಗ್ಯ ತಪಾಸಣೆ). ಮೇಲಿನ "ಸೆಕ್ಯೂರ್ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್" ಅಥವಾ "ಪವರ್‌ಶೆಲ್ ಸೆಕ್ಯೂರ್ ಆಟೊಮೇಷನ್" ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ AI ನಿಂದ ಔಟ್‌ಲೈನ್ ಅನ್ನು ವಿನಂತಿಸಿ. ರಚಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಲೈನ್ ಅನ್ನು ಸಾಲಿನ ಮೂಲಕ ಓದಿ ಮತ್ತು ವಿನಾಶಕಾರಿ ಸಾಲುಗಳನ್ನು ಗುರುತಿಸಿ. ಪರೀಕ್ಷಾ ಯಂತ್ರದಲ್ಲಿ ಮೊದಲು ಡ್ರೈ-ರನ್ ಮೋಡ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಿ, ನಿಮ್ಮ ನಿರೀಕ್ಷೆಯೊಂದಿಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ. ನಂತರ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು AI ಗೆ ಮರಳಿ ನೀಡಿ ಮತ್ತು ಅದನ್ನು "ಗಟ್ಟಿಯಾಗಿಸುವ" ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ ಸಂಸ್ಕರಿಸಿ ಮತ್ತು ಎರಡು ಆವೃತ್ತಿಗಳ ನಡುವಿನ 5 ವ್ಯತ್ಯಾಸಗಳನ್ನು ಗಮನಿಸಿ.

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

• [ ] ನಾನು ಪ್ರಾಂಪ್ಟ್‌ನಲ್ಲಿ OS, ಶೆಲ್ ಆವೃತ್ತಿ, ಮಾರ್ಗಗಳು ಮತ್ತು ಹಕ್ಕುಗಳಂತಹ ನಿರ್ಬಂಧಗಳನ್ನು ಸೇರಿಸಿದ್ದೇನೆಯೇ?
• [ ] ಸೆಟ್ -euo ಪೈಪ್‌ಫೇಲ್ / $ErrorActionPreference='Stop' ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ದೋಷ-ಸಹಿಷ್ಣುವಾಗಿದೆಯೇ?
• [ ] ಡ್ರೈ-ರನ್/-ವಾಟ್ಇಫ್ ಹಿಂದೆ ವಿನಾಶಕಾರಿ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಸ್ಪಷ್ಟವಾದ ಚೆಕ್ ಫ್ಲ್ಯಾಗ್ ಅಗತ್ಯವಿದೆಯೇ?
• [ ] ಸ್ಕ್ರಿಪ್ಟ್ ಅಸಮರ್ಥವಾಗಿದೆಯೇ (ಎರಡನೇ ಓಟದಲ್ಲಿ ಸುರಕ್ಷಿತವಾಗಿದೆ)?
• [ ] ನಾನು ರಹಸ್ಯಗಳನ್ನು ಹಾರ್ಡ್ ಕೋಡಿಂಗ್ ಮಾಡುವ ಬದಲು ವೇರಿಯಬಲ್/ರಹಸ್ಯ ಇನ್‌ಪುಟ್‌ಗೆ ಹೊರತೆಗೆದಿದ್ದೇನೆಯೇ?
• [ ] ನಾನು ಪರೀಕ್ಷಾ ಯಂತ್ರದಲ್ಲಿ ಮೊದಲ ಓಟವನ್ನು ಮಾಡಿದ್ದೇನೆ ಮತ್ತು ರಿಟರ್ನ್ ಯೋಜನೆಯನ್ನು ಸಿದ್ಧಪಡಿಸಿದ್ದೇನೆಯೇ?