ಡೀಬಗ್ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಹುಲ್ಲಿನ ಬಣವೆಯಲ್ಲಿ ಸೂಜಿಯನ್ನು ಹುಡುಕುವಂತಿದೆ, ವಿಶೇಷವಾಗಿ ರಚನೆ, ಲಾಗಿಂಗ್ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಸಕಾಲಿಕವಾಗಿ ಪರಿಗಣಿಸದೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್‌ಬೇಸ್‌ನಲ್ಲಿ ಹೊಸ ಸೇರ್ಪಡೆಗಳು ಕಾಣಿಸಿಕೊಂಡಾಗ. ನಿಮ್ಮ ಸ್ವಂತ ತಪ್ಪುಗಳಿಂದಾಗಿ ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಸಂಕೀರ್ಣ ರಾಶಿಯನ್ನು ನಿರ್ವಹಿಸುವಾಗ ನೀವು ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಿಮ್ಮನ್ನು ಕಂಡುಕೊಳ್ಳಬಹುದು.
ತಂಡದ ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಉತ್ತಮವಾಗಿ ಬರೆಯಲು, ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಶಿಫಾರಸುಗಳೊಂದಿಗೆ ಲೇಖನವನ್ನು ಅನುವಾದಿಸಲಾಗಿದೆ. ಇದನ್ನು ನಂಬಿ ಅಥವಾ ಬಿಡಿ, ಪ್ರತಿ ಬಾರಿಯೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕ್ಲೀನ್, ಬಳಸಲು ಸಿದ್ಧವಾಗಿರುವ ಬ್ಯಾಷ್ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವ ತೃಪ್ತಿಯನ್ನು ಯಾವುದೂ ಮೀರಿಸುತ್ತದೆ.
ಲೇಖನದಲ್ಲಿ, ಲೇಖಕರು ಕಳೆದ ಕೆಲವು ವರ್ಷಗಳಿಂದ ಅವರು ಕಲಿತದ್ದನ್ನು ಹಂಚಿಕೊಂಡಿದ್ದಾರೆ, ಹಾಗೆಯೇ ಕೆಲವು ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು ಅವನನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತವೆ. ಇದು ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಪ್ರತಿಯೊಬ್ಬ ಸಾಫ್ಟ್‌ವೇರ್ ಡೆವಲಪರ್, ತಮ್ಮ ವೃತ್ತಿಜೀವನದ ಕೆಲವು ಹಂತದಲ್ಲಿ, ದಿನನಿತ್ಯದ ಕೆಲಸ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ.
ಟ್ರ್ಯಾಪ್ ಹ್ಯಾಂಡ್ಲರ್ಗಳು
ನಾನು ಎದುರಿಸಿದ ಹೆಚ್ಚಿನ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯದಲ್ಲಿ ಏನಾದರೂ ಅನಿರೀಕ್ಷಿತವಾದಾಗ ಪರಿಣಾಮಕಾರಿ ಕ್ಲೀನಪ್ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಎಂದಿಗೂ ಬಳಸುವುದಿಲ್ಲ.
ಆಶ್ಚರ್ಯಗಳು ಹೊರಗಿನಿಂದ ಉದ್ಭವಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ ಕೋರ್ನಿಂದ ಸಂಕೇತವನ್ನು ಸ್ವೀಕರಿಸುವುದು. ಉತ್ಪಾದನಾ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸಾಕಷ್ಟು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಂತಹ ಪ್ರಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಈ ರೀತಿಯ ಸನ್ನಿವೇಶಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಲು ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಗಮನ ನಿರ್ವಾಹಕರನ್ನು ಬಳಸುತ್ತೇನೆ:
function handle_exit() {
// Add cleanup code here
// for eg. rm -f "/tmp/${lock_file}.lock"
// exit with an appropriate status code
}
// trap <HANDLER_FXN> <LIST OF SIGNALS TO TRAP>
trap handle_exit 0 SIGHUP SIGINT SIGQUIT SIGABRT SIGTERM
trap ಶೆಲ್ ಬಿಲ್ಟ್-ಇನ್ ಕಮಾಂಡ್ ಆಗಿದ್ದು, ಯಾವುದೇ ಸಿಗ್ನಲ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಕ್ಲೀನಪ್ ಕಾರ್ಯವನ್ನು ನೋಂದಾಯಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಅಂತಹ ನಿರ್ವಾಹಕರೊಂದಿಗೆ ವಿಶೇಷ ಕಾಳಜಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕು SIGINT, ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಥಗಿತಗೊಳ್ಳಲು ಕಾರಣವಾಗುತ್ತದೆ.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು ಮಾತ್ರ ಹಿಡಿಯಬೇಕು EXIT, ಆದರೆ ಕಲ್ಪನೆಯೆಂದರೆ ನೀವು ಪ್ರತಿಯೊಂದು ಸಿಗ್ನಲ್‌ಗಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು.
ಅಂತರ್ನಿರ್ಮಿತ ಸೆಟ್ ಕಾರ್ಯಗಳು - ದೋಷದ ಮೇಲೆ ವೇಗದ ಮುಕ್ತಾಯ
ದೋಷಗಳು ಸಂಭವಿಸಿದ ತಕ್ಷಣ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಮತ್ತು ತ್ವರಿತವಾಗಿ ಮರಣದಂಡನೆಯನ್ನು ನಿಲ್ಲಿಸಲು ಬಹಳ ಮುಖ್ಯ. ಈ ರೀತಿಯ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವುದನ್ನು ಮುಂದುವರಿಸುವುದಕ್ಕಿಂತ ಕೆಟ್ಟದ್ದೇನೂ ಇಲ್ಲ:
rm -rf ${directory_name}/*
ವೇರಿಯಬಲ್ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ directory_name ನಿರ್ಧರಿಸಲಾಗಿಲ್ಲ.
ಅಂತಹ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವುದು ಮುಖ್ಯವಾಗಿದೆ set, ಉದಾಹರಣೆಗೆ set -o errexit, set -o pipefail ಅಥವಾ set -o nounset ಸ್ಕ್ರಿಪ್ಟ್ ಆರಂಭದಲ್ಲಿ. ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಯಾವುದೇ ಶೂನ್ಯವಲ್ಲದ ನಿರ್ಗಮನ ಕೋಡ್, ವ್ಯಾಖ್ಯಾನಿಸದ ವೇರಿಯೇಬಲ್‌ಗಳ ಬಳಕೆ, ಪೈಪ್‌ನಲ್ಲಿ ರವಾನಿಸಲಾದ ಅಮಾನ್ಯ ಆಜ್ಞೆಗಳು ಮತ್ತು ಮುಂತಾದವುಗಳನ್ನು ಎದುರಿಸಿದ ತಕ್ಷಣ ನಿರ್ಗಮಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಈ ಕಾರ್ಯಗಳು ಖಚಿತಪಡಿಸುತ್ತವೆ:
#!/usr/bin/env bash
set -o errexit
set -o nounset
set -o pipefail
function print_var() {
echo "${var_value}"
}
print_var
$ ./sample.sh
./sample.sh: line 8: var_value: unbound variable
ಗಮನಿಸಿ: ಅಂತಹ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳು set -o errexit, "ರಾ" ರಿಟರ್ನ್ ಕೋಡ್ (ಶೂನ್ಯವನ್ನು ಹೊರತುಪಡಿಸಿ) ಇದ್ದ ತಕ್ಷಣ ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ನಿರ್ಗಮಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ಕಸ್ಟಮ್ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಪರಿಚಯಿಸುವುದು ಉತ್ತಮ, ಉದಾಹರಣೆಗೆ:
#!/bin/bash
error_exit() {
line=$1
shift 1
echo "ERROR: non zero return code from line: $line -- $@"
exit 1
}
a=0
let a++ || error_exit "$LINENO" "let operation returned non 0 code"
echo "you will never see me"
# run it, now we have useful debugging output
$ bash foo.sh
ERROR: non zero return code from line: 9 -- let operation returned non 0 code
ಈ ರೀತಿಯಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯುವುದರಿಂದ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳ ನಡವಳಿಕೆಯ ಬಗ್ಗೆ ಹೆಚ್ಚು ಜಾಗರೂಕರಾಗಿರಲು ನಿಮ್ಮನ್ನು ಒತ್ತಾಯಿಸುತ್ತದೆ ಮತ್ತು ಅದು ನಿಮಗೆ ಆಶ್ಚರ್ಯವನ್ನುಂಟುಮಾಡುವ ಮೊದಲು ದೋಷದ ಸಾಧ್ಯತೆಯನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ.
ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಶೆಲ್ ಚೆಕ್
ಅಂತಹದನ್ನು ಸಂಯೋಜಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ವಿರುದ್ಧ ನಿಮ್ಮ ಬ್ಯಾಷ್ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿ.
ಸಿಂಟ್ಯಾಕ್ಸ್, ಸೆಮ್ಯಾಂಟಿಕ್ಸ್ ಮತ್ತು ಕೋಡ್‌ನಲ್ಲಿನ ಕೆಲವು ದೋಷಗಳ ಕುರಿತು ವರದಿಗಳನ್ನು ಪಡೆಯಲು ನಾನು ಅದನ್ನು ನನ್ನ ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿ ಪರಿಸರದಲ್ಲಿ ಬಳಸುತ್ತೇನೆ ಮತ್ತು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ ನಾನು ತಪ್ಪಿಸಿಕೊಂಡಿರಬಹುದು. ಇದು ನಿಮ್ಮ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗೆ ಸ್ಥಿರವಾದ ವಿಶ್ಲೇಷಣಾ ಸಾಧನವಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಬಳಸಲು ನಾನು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.
ನಿಮ್ಮ ಸ್ವಂತ ನಿರ್ಗಮನ ಕೋಡ್‌ಗಳನ್ನು ಬಳಸುವುದು
POSIX ನಲ್ಲಿ ರಿಟರ್ನ್ ಕೋಡ್‌ಗಳು ಕೇವಲ ಶೂನ್ಯ ಅಥವಾ ಒಂದಲ್ಲ, ಆದರೆ ಶೂನ್ಯ ಅಥವಾ ಶೂನ್ಯವಲ್ಲದ ಮೌಲ್ಯ. ವಿವಿಧ ದೋಷ ಪ್ರಕರಣಗಳಿಗಾಗಿ ಕಸ್ಟಮ್ ದೋಷ ಕೋಡ್‌ಗಳನ್ನು (201-254 ರ ನಡುವೆ) ಹಿಂತಿರುಗಿಸಲು ಈ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿ.
ಯಾವ ರೀತಿಯ ದೋಷ ಸಂಭವಿಸಿದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸಲು ನಿಮ್ಮದನ್ನು ಸುತ್ತುವ ಇತರ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಂದ ಈ ಮಾಹಿತಿಯನ್ನು ಬಳಸಬಹುದು:
#!/usr/bin/env bash
SUCCESS=0
FILE_NOT_FOUND=240
DOWNLOAD_FAILED=241
function read_file() {
if ${file_not_found}; then
return ${FILE_NOT_FOUND}
fi
}
ಗಮನಿಸಿ: ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಅತಿಕ್ರಮಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ದಯವಿಟ್ಟು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸುವ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳೊಂದಿಗೆ ವಿಶೇಷವಾಗಿ ಜಾಗರೂಕರಾಗಿರಿ.
ಲಾಗಿಂಗ್ ಕಾರ್ಯಗಳು
ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಫಲಿತಾಂಶಗಳನ್ನು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಂದರವಾದ ಮತ್ತು ರಚನಾತ್ಮಕ ಲಾಗಿಂಗ್ ಮುಖ್ಯವಾಗಿದೆ. ಇತರ ಉನ್ನತ ಮಟ್ಟದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಂತೆ, ನನ್ನ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ನಾನು ಯಾವಾಗಲೂ ಸ್ಥಳೀಯ ಲಾಗಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತೇನೆ, ಉದಾಹರಣೆಗೆ __msg_info, __msg_error ಹೀಗೆ.
ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ ಮೂಲಕ ಪ್ರಮಾಣಿತ ಲಾಗಿಂಗ್ ರಚನೆಯನ್ನು ಒದಗಿಸಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ:
#!/usr/bin/env bash
function __msg_error() {
[[ "${ERROR}" == "1" ]] && echo -e "[ERROR]: $*"
}
function __msg_debug() {
[[ "${DEBUG}" == "1" ]] && echo -e "[DEBUG]: $*"
}
function __msg_info() {
[[ "${INFO}" == "1" ]] && echo -e "[INFO]: $*"
}
__msg_error "File could not be found. Cannot proceed"
__msg_debug "Starting script execution with 276MB of available RAM"
ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ನನ್ನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಹೊಂದಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ __init, ಅಂತಹ ಲಾಗರ್ ವೇರಿಯೇಬಲ್‌ಗಳು ಮತ್ತು ಇತರ ಸಿಸ್ಟಮ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಅಥವಾ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳಿಗೆ ಹೊಂದಿಸಲಾಗುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಆಹ್ವಾನದ ಸಮಯದಲ್ಲಿ ಈ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಆಜ್ಞಾ ಸಾಲಿನ ಆಯ್ಕೆಗಳಿಂದ ಹೊಂದಿಸಬಹುದು.
ಉದಾಹರಣೆಗೆ, ಈ ರೀತಿಯ ಏನಾದರೂ:
$ ./run-script.sh --debug
ಅಂತಹ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಸಿಸ್ಟಮ್-ವೈಡ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಅಗತ್ಯವಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳಿಗೆ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ ಅಥವಾ ಅಗತ್ಯವಿದ್ದರೆ ಸೂಕ್ತವಾದ ಯಾವುದನ್ನಾದರೂ ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಕೆದಾರ ಇಂಟರ್‌ಫೇಸ್ ಮತ್ತು ಬಳಕೆದಾರನು ಪರಿಶೀಲಿಸಬೇಕಾದ ಸಂರಚನೆಗಳ ನಡುವಿನ ವ್ಯಾಪಾರ-ವಹಿವಾಟಿನಲ್ಲಿ ಏನನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು ಮತ್ತು ಏನು ಮಾಡಬಾರದು ಎಂಬ ಆಯ್ಕೆಯನ್ನು ಆಧರಿಸಿರುತ್ತೇನೆ.
ಮರುಬಳಕೆ ಮತ್ತು ಕ್ಲೀನ್ ಸಿಸ್ಟಮ್ ಸ್ಥಿತಿಗಾಗಿ ಆರ್ಕಿಟೆಕ್ಚರ್
ಮಾಡ್ಯುಲರ್/ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೋಡ್
├── framework
│ ├── common
│ │ ├── loggers.sh
│ │ ├── mail_reports.sh
│ │ └── slack_reports.sh
│ └── daily_database_operation.sh
ನಾನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಬಯಸುವ ಹೊಸ ಯೋಜನೆ/ಬ್ಯಾಶ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ನಾನು ಬಳಸಬಹುದಾದ ಪ್ರತ್ಯೇಕ ರೆಪೊಸಿಟರಿಯನ್ನು ನಾನು ಇರಿಸುತ್ತೇನೆ. ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಯಾವುದನ್ನಾದರೂ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಆ ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಬಯಸುವ ಇತರ ಯೋಜನೆಗಳಿಂದ ಹಿಂಪಡೆಯಬಹುದು. ಯೋಜನೆಗಳನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ಸಂಘಟಿಸುವುದು ಇತರ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಗಾತ್ರವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ಬೇಸ್ ಚಿಕ್ಕದಾಗಿದೆ ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಸುಲಭವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ, ಎಲ್ಲಾ ಲಾಗಿಂಗ್ ಕಾರ್ಯಗಳು __msg_info, __msg_error ಮತ್ತು ಸ್ಲಾಕ್ ವರದಿಗಳಂತಹ ಇತರವುಗಳು ಪ್ರತ್ಯೇಕವಾಗಿ ಒಳಗೊಂಡಿರುತ್ತವೆ common/* ಮತ್ತು ಇತರ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಸಂಪರ್ಕಪಡಿಸಿ daily_database_operation.sh.
ಶುದ್ಧ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಿಟ್ಟುಬಿಡಿ
ಸ್ಕ್ರಿಪ್ಟ್ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ನೀವು ಯಾವುದೇ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತಿದ್ದರೆ, ಅಂತಹ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಯಾದೃಚ್ಛಿಕ ಹೆಸರಿನೊಂದಿಗೆ ಹಂಚಿಕೊಂಡ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಸೂಚಿಸಲಾಗುತ್ತದೆ, ಉದಾ. /tmp/AlRhYbD97/*. ಡೈರೆಕ್ಟರಿ ಹೆಸರನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನೀವು ಯಾದೃಚ್ಛಿಕ ಪಠ್ಯ ಜನರೇಟರ್ಗಳನ್ನು ಬಳಸಬಹುದು:
rand_dir_name="$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1)"
ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ಅಂತಹ ಡೈರೆಕ್ಟರಿಗಳ ಶುಚಿಗೊಳಿಸುವಿಕೆಯನ್ನು ಮೇಲೆ ಚರ್ಚಿಸಿದ ಹುಕ್ ಹ್ಯಾಂಡ್ಲರ್ಗಳಲ್ಲಿ ಒದಗಿಸಬಹುದು. ತಾತ್ಕಾಲಿಕ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಕಾಳಜಿ ವಹಿಸದಿದ್ದರೆ, ಅವುಗಳು ಸಂಗ್ರಹಗೊಳ್ಳುತ್ತವೆ ಮತ್ತು ಕೆಲವು ಹಂತದಲ್ಲಿ ಪೂರ್ಣ ಡಿಸ್ಕ್ನಂತಹ ಅನಿರೀಕ್ಷಿತ ಸಮಸ್ಯೆಗಳನ್ನು ಹೋಸ್ಟ್ನಲ್ಲಿ ಉಂಟುಮಾಡುತ್ತವೆ.
ಲಾಕ್ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸುವುದು
ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಹೋಸ್ಟ್ನಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಒಂದು ನಿದರ್ಶನ ಮಾತ್ರ ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಲಾಕ್ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಬಹುದು.
ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಲಾಕ್ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುತ್ತೇನೆ /tmp/project_name/*.lock ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಆರಂಭದಲ್ಲಿ ಅವರ ಉಪಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ. ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಆಕರ್ಷಕವಾಗಿ ಕೊನೆಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಮಾನಾಂತರವಾಗಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಮತ್ತೊಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಕ ಸಿಸ್ಟಮ್ ಸ್ಥಿತಿಗೆ ಅನಿರೀಕ್ಷಿತ ಬದಲಾವಣೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಕೊಟ್ಟಿರುವ ಹೋಸ್ಟ್ನಲ್ಲಿ ಸಮಾನಾಂತರವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅದೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅಗತ್ಯವಿದ್ದರೆ ಲಾಕ್ ಫೈಲ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲ.
ಅಳೆಯಿರಿ ಮತ್ತು ಸುಧಾರಿಸಿ
ದೈನಂದಿನ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಂತಹ ದೀರ್ಘಾವಧಿಯವರೆಗೆ ರನ್ ಆಗುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳೊಂದಿಗೆ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳು ವಿಶಿಷ್ಟವಾಗಿ ಹಂತಗಳ ಅನುಕ್ರಮವನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ: ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುವುದು, ವೈಪರೀತ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು, ಡೇಟಾವನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು, ಸ್ಥಿತಿ ವರದಿಗಳನ್ನು ಕಳುಹಿಸುವುದು ಇತ್ಯಾದಿ.
ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಾನು ಯಾವಾಗಲೂ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ಸಣ್ಣ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಾಗಿ ಒಡೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ ಮತ್ತು ಅವುಗಳ ಸ್ಥಿತಿ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಇದನ್ನು ಬಳಸಿ ವರದಿ ಮಾಡುತ್ತೇನೆ:
time source "${filepath}" "${args}">> "${LOG_DIR}/RUN_LOG" 2>&1
ನಂತರ ನಾನು ಇದರೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ನೋಡಬಹುದು:
tac "${LOG_DIR}/RUN_LOG.txt" | grep -m1 "real"
ಆಪ್ಟಿಮೈಸೇಶನ್ ಅಗತ್ಯವಿರುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಸಮಸ್ಯೆ/ನಿಧಾನ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಇದು ನನಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಅದೃಷ್ಟ!
ಇನ್ನೇನು ಓದಬೇಕು:
ಮೂಲ: www.habr.com