ಉಬುಂಟು ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ಸ್ಕೇಲಿಂಗ್_ಕರ್_ಫ್ರೆಕ್ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್_ಮ್ಯಾಕ್ಸ್_ಫ್ರೆಕ್ ದೋಷವನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತಿದೆ

ಉಬುಂಟು ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ಆವರ್ತನ ಸ್ಕೇಲಿಂಗ್ ದೋಷಗಳನ್ನು ನಿವಾರಿಸುವುದು

ಉಬುಂಟು 20.04 ಬೇಸ್‌ನಲ್ಲಿ ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವಿಶೇಷವಾಗಿ ಬಾಹ್ಯ ಯೋಜನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವಾಗ, ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳು ಉಂಟಾಗಬಹುದು. ಸಿಸ್ಟಮ್ ಫೈಲ್‌ಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಅಂತಹ ಒಂದು ಸಮಸ್ಯೆ ಸಂಭವಿಸುತ್ತದೆ ಸ್ಕೇಲಿಂಗ್_ಕರ್_ಫ್ರೆಕ್ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್_max_freq ಆದರೆ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಮರಣದಂಡನೆ ದೋಷಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.

Linux ನಲ್ಲಿ ಆವರ್ತನ ಸ್ಕೇಲಿಂಗ್ ಕಾರ್ಯವಿಧಾನಗಳ ಬಗ್ಗೆ ನಿಮಗೆ ಪರಿಚಯವಿಲ್ಲದಿದ್ದರೆ ಅಥವಾ ನೀವು ಸ್ವಾಮ್ಯದ ಕಂಟೇನರ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತಿದ್ದರೆ ಈ ಸಮಸ್ಯೆಯು ವಿಶೇಷವಾಗಿ ಗೊಂದಲಕ್ಕೊಳಗಾಗಬಹುದು. ನಿರ್ದಿಷ್ಟ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಥವಾ ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಅನೇಕ ಬಳಕೆದಾರರು ಇದನ್ನು ಎದುರಿಸುತ್ತಾರೆ.

ಧಾರಕ ಪರಿಸರ ಮತ್ತು ಹೋಸ್ಟ್ ಯಂತ್ರದ ಹಾರ್ಡ್‌ವೇರ್, ನಿರ್ದಿಷ್ಟವಾಗಿ CPU ಆವರ್ತನ ಸ್ಕೇಲಿಂಗ್ ವೈಶಿಷ್ಟ್ಯಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯಲ್ಲಿ ಸಮಸ್ಯೆಯ ತಿರುಳು ಇರುತ್ತದೆ, ಇವುಗಳನ್ನು ಯಾವಾಗಲೂ ಕಂಟೇನರ್‌ಗಳಲ್ಲಿ ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ. ಇದಕ್ಕೆ ಪರಿಹಾರಗಳು ಅನೇಕವೇಳೆ ಅಸ್ಪಷ್ಟವಾಗಿರುತ್ತವೆ ಮತ್ತು ವಿವಿಧ ಮೂಲಗಳಲ್ಲಿ ಹರಡಿರುತ್ತವೆ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ಈ ದೋಷ ಏಕೆ ಸಂಭವಿಸುತ್ತದೆ, ಅದು ನಿಮ್ಮ ಡಾಕರ್ ಸೆಟಪ್ ಅಥವಾ ಆಧಾರವಾಗಿರುವ ಲಿನಕ್ಸ್ ಪರಿಸರಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ ಮತ್ತು ಯಾವ ಸಂಭಾವ್ಯ ಪರಿಹಾರಗಳನ್ನು ಅನ್ವಯಿಸಬಹುದು ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. AWS EC2 Linux ನಿದರ್ಶನಗಳಲ್ಲಿ Chrome ಸ್ಥಾಪನೆಯೊಂದಿಗೆ ನಾವು ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಯನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳ ಪರಿಹಾರವು ಇಲ್ಲಿ ಏಕೆ ಅನ್ವಯಿಸುವುದಿಲ್ಲ.

ಫ್ರೀಕ್ವೆನ್ಸಿ ಸ್ಕೇಲಿಂಗ್ ದೋಷ ಪರಿಹಾರಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲಾಗುತ್ತಿದೆ

ಈ ಹಿಂದೆ ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಕಾಣೆಯಾದ CPU ಆವರ್ತನ ಸ್ಕೇಲಿಂಗ್ ಫೈಲ್‌ಗಳ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಸ್ಕೇಲಿಂಗ್_ಕರ್_ಫ್ರೆಕ್ ಮತ್ತು ಸ್ಕೇಲಿಂಗ್_max_freq, ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ಕೆಲವು ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಇದು ಅತ್ಯಗತ್ಯ. ಈ ಫೈಲ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕಂಡುಬರುತ್ತವೆ /sys/devices/system/cpu/cpu0/cpufreq ಡೈರೆಕ್ಟರಿ, ಆದರೆ ಧಾರಕ ಪರಿಸರದಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಉಬುಂಟು 20.04 ನಲ್ಲಿ, ಅವು ಲಭ್ಯವಿಲ್ಲದಿರಬಹುದು. ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಫೈಲ್‌ಗಳ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಮತ್ತು ಅವುಗಳು ಕಾಣೆಯಾಗಿದ್ದರೆ ಸ್ಟಬ್‌ಗಳನ್ನು ರಚಿಸುವ ಮೂಲಕ ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಈ ಕಾಣೆಯಾದ ಸಿಸ್ಟಮ್ ಫೈಲ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ದೋಷಗಳನ್ನು ಎದುರಿಸದೆಯೇ ಕಂಟೇನರ್ ತನ್ನ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಮುಂದುವರಿಯಬಹುದು ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

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

ಪೈಥಾನ್ ಪರಿಹಾರವು ಸನ್ನೆ ಮಾಡುವ ಮೂಲಕ ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ os.path.isfile() ಅಗತ್ಯ ಫೈಲ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ವಿಧಾನ. ಅವರು ಮಾಡದಿದ್ದರೆ, ಸುಲಭವಾದ ದೋಷನಿವಾರಣೆಗಾಗಿ ಅದು ದೋಷವನ್ನು ಫೈಲ್‌ಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ. ವಿವರವಾದ ಲಾಗಿಂಗ್ ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅಥವಾ ಯೋಜನೆಯು ದೊಡ್ಡ ಪೈಥಾನ್-ಆಧಾರಿತ ಸಿಸ್ಟಮ್‌ಗೆ ಸಂಯೋಜಿಸಬೇಕಾದ ಸಂದರ್ಭಗಳಿಗೆ ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪೈಥಾನ್‌ನ ಮಾಡ್ಯುಲಾರಿಟಿ ಮತ್ತು ರೀಡಬಿಲಿಟಿ ಈ ಪರಿಹಾರವನ್ನು ಬಹು ಯೋಜನೆಗಳಾದ್ಯಂತ ಅಳೆಯಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಬಹು ಫೈಲ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾದರೆ ಅಥವಾ ರಚಿಸಬೇಕಾದರೆ.

ಅಂತಿಮವಾಗಿ, ಡಾಕರ್‌ಫೈಲ್ ಪರಿಹಾರವು ಡಾಕರ್ ಕಂಟೇನರ್‌ನ ನಿರ್ಮಾಣ ಹಂತದಲ್ಲಿ ಫೈಲ್ ರಚನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ. ಕಂಟೇನರ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು ಅಗತ್ಯವಿರುವ ಡೈರೆಕ್ಟರಿಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳು ಯಾವಾಗಲೂ ಇರುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಯಾವುದೇ ರನ್‌ಟೈಮ್ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಮುಂತಾದ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ರನ್ ಮತ್ತು chmod, ಡಾಕರ್‌ಫೈಲ್ ಅನುಮತಿಗಳನ್ನು ಮತ್ತು ಫೈಲ್ ರಚನೆಯನ್ನು ನೇರವಾಗಿ ಕಂಟೇನರ್‌ನ ಪರಿಸರದಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತದೆ. ಸಿಸ್ಟಮ್ ಕಾನ್ಫಿಗರೇಶನ್ ಭಿನ್ನವಾಗಿರಬಹುದಾದ ವಿವಿಧ ಸರ್ವರ್‌ಗಳು ಅಥವಾ ಕ್ಲೌಡ್ ಪರಿಸರದಲ್ಲಿ ಸ್ಥಿರವಾದ ನಿಯೋಜನೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ವಿಧಾನವು ಸೂಕ್ತವಾಗಿದೆ. ಈ ವಿಧಾನಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು ಸಾಮಾನ್ಯ ಕಂಟೈನರೈಸ್ಡ್ ಲಿನಕ್ಸ್ ಸಮಸ್ಯೆಗೆ ದೃಢವಾದ ಪರಿಹಾರಗಳನ್ನು ನೀಡುತ್ತದೆ.

#!/bin/bash
# Check if the required files exist
FREQ_PATH="/sys/devices/system/cpu/cpu0/cpufreq"
REQUIRED_FILES=("scaling_cur_freq" "scaling_max_freq")
# Loop through each file and create a stub if it's missing
for FILE in "${REQUIRED_FILES[@]}"; do
    if [[ ! -f "$FREQ_PATH/$FILE" ]]; then
        echo "File $FILE not found, creating a stub."
        sudo touch "$FREQ_PATH/$FILE"
        echo "Stub created for $FILE."
    else
        echo "$FILE exists."
    fi
done
# End of script

import os
import logging
# Set up logging
logging.basicConfig(filename='freq_check.log', level=logging.INFO)
freq_files = ['/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq',
              '/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq']
# Function to check file existence
def check_files():
    for file in freq_files:
        if os.path.isfile(file):
            logging.info(f'{file} exists.')
        else:
            logging.error(f'{file} is missing.')
# Call the function
check_files()

FROM ubuntu:20.04
RUN apt-get update && apt-get install -y sudo
# Create necessary directories and files if they don't exist
RUN mkdir -p /sys/devices/system/cpu/cpu0/cpufreq/
RUN touch /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq
RUN touch /sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq
# Set permissions to avoid access issues
RUN chmod 644 /sys/devices/system/cpu/cpu0/cpufreq/*
# Ensure the container runs a basic command on start
CMD ["/bin/bash"]

CPU ಫ್ರೀಕ್ವೆನ್ಸಿ ಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ಕಂಟೈನರ್ ಮಿತಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

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

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

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