Ubuntu Docker கண்டெய்னர்களில் scaling_cur_freq & scaling_max_freq பிழையைத் தீர்க்கிறது

உபுண்டு டோக்கர் கொள்கலன்களில் அதிர்வெண் அளவிடுதல் பிழைகளை சரிசெய்தல்

Ubuntu 20.04 தளத்தில் Docker கொள்கலன்களுடன் பணிபுரியும் போது, ​​குறிப்பாக வெளிப்புற திட்டங்கள் சம்பந்தப்பட்டவை, எதிர்பாராத பிழைகள் ஏற்படலாம். போன்ற கோப்புகளைக் கண்டறிய கணினி முயற்சிக்கும் போது இதுபோன்ற ஒரு சிக்கல் ஏற்படுகிறது அளவிடுதல்_சுருள்_அதிர்வெண் மற்றும் அளவிடுதல்_அதிகபட்சம்_அதிர்வெண் ஆனால் தோல்வியடைந்து, செயல்படுத்துவதில் பிழைகளை ஏற்படுத்துகிறது.

லினக்ஸில் அதிர்வெண் அளவிடுதல் வழிமுறைகள் உங்களுக்குத் தெரியாவிட்டால் அல்லது நீங்கள் தனியுரிம கொள்கலனை இயக்கினால், இந்தச் சிக்கல் குறிப்பாக குழப்பமாக இருக்கும். பல பயனர்கள் குறிப்பிட்ட கட்டளைகளை இயக்க முயற்சிக்கும்போது அல்லது டோக்கர் கொள்கலனைத் தொடங்கும்போது இதை எதிர்கொள்கின்றனர்.

கன்டெய்னர் செய்யப்பட்ட சூழல் மற்றும் ஹோஸ்ட் இயந்திரத்தின் வன்பொருள், குறிப்பாக CPU அதிர்வெண் அளவிடுதல் அம்சங்கள் ஆகியவற்றுக்கு இடையேயான தொடர்புகளில் சிக்கலின் மையமானது எப்போதும் கொள்கலன்களில் அணுக முடியாதது. இதற்கான தீர்வுகள் பெரும்பாலும் மழுப்பலாக மற்றும் பல்வேறு ஆதாரங்களில் சிதறிக்கிடக்கின்றன.

இந்த வழிகாட்டியில், இந்த பிழை ஏன் நிகழ்கிறது, இது உங்கள் டோக்கர் அமைப்பு அல்லது அடிப்படையான லினக்ஸ் சூழலுடன் தொடர்புடையதா மற்றும் என்ன சாத்தியமான தீர்வுகளைப் பயன்படுத்தலாம் என்பதை ஆராய்வோம். AWS EC2 Linux நிகழ்வுகளில் Chrome நிறுவலில் இதே போன்ற சிக்கலைப் பற்றி விவாதிப்போம் மற்றும் அவற்றின் திருத்தம் ஏன் இங்கு பொருந்தாது.

அதிர்வெண் அளவிடுதல் பிழை தீர்வுகளை பகுப்பாய்வு செய்தல்

முன்னர் வழங்கப்பட்ட ஸ்கிரிப்ட்கள் போன்ற CPU அலைவரிசை அளவிடுதல் கோப்புகள் விடுபட்ட சிக்கலைத் தீர்க்க உதவுகின்றன அளவிடுதல்_சுருள்_அதிர்வெண் மற்றும் அளவிடுதல்_அதிகபட்சம்_அதிர்வெண், டோக்கர் கொள்கலன்களில் சில செயல்முறைகளுக்கு அவசியமானவை. இந்த கோப்புகள் பொதுவாக இதில் காணப்படுகின்றன /sys/devices/system/cpu/cpu0/cpufreq அடைவு, ஆனால் கொள்கலன் சூழல்களில், குறிப்பாக உபுண்டு 20.04 இல், அவை கிடைக்காமல் போகலாம். பாஷ் ஸ்கிரிப்ட் இந்தக் கோப்புகளின் இருப்பை சரிபார்த்து, அவை விடுபட்டிருந்தால் ஸ்டப்களை உருவாக்குவதன் மூலம் இதை நிவர்த்தி செய்கிறது. இந்த விடுபட்ட கணினி கோப்புகள் தொடர்பான பிழைகளை சந்திக்காமல் கொள்கலன் அதன் செயல்பாடுகளை தொடர முடியும் என்பதை இது உறுதி செய்கிறது.

ஷெல் ஸ்கிரிப்ட் தேவையான கோப்புகளை சுழற்ற ஒரு லூப்பைப் பயன்படுத்துகிறது, மேலும் ஏதேனும் விடுபட்டால், அவற்றைப் பயன்படுத்தி உருவாக்குகிறது தொடுதல் கட்டளை. இந்த அணுகுமுறை எளிமையானது ஆனால் பயனுள்ளது, கணினியில் விரிவான மாற்றங்கள் தேவைப்படாமல் கோப்புகள் தேவைப்படும்போது கிடைக்கும் என்பதை உறுதி செய்கிறது. அதிர்வெண் அளவிடுதல் சரியாக உள்ளமைக்கப்படாத பிற சூழல்களுக்கு ஸ்கிரிப்டை எளிதாக மாற்றியமைக்கவும் இது அனுமதிக்கிறது. பதிவுசெய்தல் அல்லது கூடுதல் பிழை சரிபார்ப்பு அம்சங்களைச் சேர்ப்பதன் மூலம், உற்பத்திச் சூழல்களுக்கு ஸ்கிரிப்டை மேலும் மேம்படுத்தலாம்.

பைதான் தீர்வு அந்நிய அணுகுமுறை மூலம் வேறுபட்ட அணுகுமுறையை எடுக்கிறது os.path.isfile() தேவையான கோப்புகள் உள்ளனவா என்பதைச் சரிபார்க்கும் முறை. அவர்கள் அவ்வாறு செய்யவில்லை என்றால், அது பிழையை எளிதாக சரிசெய்வதற்காக கோப்பில் பதிவு செய்கிறது. இந்த முறை விரிவான பதிவு தேவைப்படும் சூழ்நிலைகளுக்கு மிகவும் பொருத்தமானது, அல்லது திட்டம் ஒரு பெரிய பைதான் அடிப்படையிலான அமைப்பில் ஒருங்கிணைக்க வேண்டும். கூடுதலாக, பைத்தானின் மட்டுத்தன்மை மற்றும் வாசிப்புத்திறன் இந்த தீர்வை பல திட்டங்களில் அளவிடுவதை எளிதாக்குகிறது, குறிப்பாக பல கோப்புகள் சரிபார்க்கப்பட வேண்டும் அல்லது உருவாக்கப்பட வேண்டும் என்றால்.

இறுதியாக, Dockerfile தீர்வு டோக்கர் கொள்கலனின் உருவாக்க கட்டத்தில் கோப்பு உருவாக்கும் செயல்முறையை தானியங்குபடுத்துகிறது. கன்டெய்னர் தொடங்கும் முன், எந்த இயக்க நேர சிக்கல்களையும் தவிர்த்து, தேவையான கோப்பகங்கள் மற்றும் கோப்புகள் எப்போதும் இருப்பதை இது உறுதி செய்கிறது. போன்ற கட்டளைகளைப் பயன்படுத்துவதன் மூலம் இயக்கவும் மற்றும் chmod, Dockerfile அனுமதிகளையும் கோப்பு உருவாக்கத்தையும் நேரடியாக கொள்கலனின் சூழலில் நிர்வகிக்கிறது. கணினி உள்ளமைவு வேறுபடக்கூடிய பல்வேறு சேவையகங்கள் அல்லது கிளவுட் சூழல்களில் சீரான வரிசைப்படுத்தலை உறுதி செய்வதற்கு இந்த முறை சிறந்தது. இந்த அணுகுமுறைகளை இணைப்பது பொதுவான கன்டெய்னரைஸ்டு லினக்ஸ் சிக்கலுக்கு வலுவான தீர்வுகளை வழங்குகிறது.

#!/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 அதிர்வெண் அளவிடுதல் மற்றும் கொள்கலன் வரம்புகளைப் புரிந்துகொள்வது

இன் மற்றொரு முக்கியமான அம்சம் அளவிடுதல்_சுருள்_அதிர்வெண் மற்றும் அளவிடுதல்_அதிகபட்சம்_அதிர்வெண் வன்பொருள் தொடர்புகளை, குறிப்பாக லினக்ஸ் சூழல்களில் CPU அலைவரிசை அளவிடுதலுடன், டோக்கர் கொள்கலன்கள் எவ்வாறு கையாளுகின்றன என்பது பிரச்சினை. இந்த அளவிடுதல் கோப்புகள் லினக்ஸ் கர்னலின் CPU கவர்னர் அம்சத்தின் ஒரு பகுதியாகும், இது CPU செயல்திறனை மாறும் வகையில் சரிசெய்கிறது. இருப்பினும், டோக்கர் கொள்கலன்கள் பெரும்பாலும் இந்த வன்பொருள் ஆதாரங்களுக்கு நேரடி அணுகலைக் கொண்டிருக்கவில்லை, இது பிழைப் பதிவில் காணப்படுவது போல் கோப்பு பிழைகளை இழக்க வழிவகுக்கிறது.

ஒரு பொதுவான லினக்ஸ் சூழலில், CPU அளவிடுதல் பொறிமுறையை மாற்றலாம் அல்லது அணுகலாம் /sys அடைவு. இருப்பினும், கன்டெய்னரைஸ் செய்யப்பட்ட சூழலில், வெளிப்படையாக உள்ளமைக்கப்படாவிட்டால், இந்த அணுகல் தடைசெய்யப்படும். ஹோஸ்ட் மெஷினின் CPU அம்சங்களுடன் ப்ராஜெக்ட்கள் ஊடாட வேண்டும் என எதிர்பார்க்கும் போது, ​​இந்த வரம்புதான் டோக்கரை அடிக்கடி தோல்வியடையச் செய்கிறது. சரியான அணுகல் அல்லது முன்மாதிரி இல்லாமல், கொள்கலன் போன்ற முக்கியமான கோப்புகளைக் கண்டறிய முடியாது என்று தெரிவிக்கலாம் அளவிடுதல்_சுருள்_அதிர்வெண்.

இந்தச் சிக்கல்களைத் தீர்க்க, லினக்ஸ் CPU கவர்னர்களை எவ்வாறு கையாளுகிறது மற்றும் டோக்கர் எவ்வாறு வன்பொருள் வளங்களைத் தனிமைப்படுத்துகிறது என்பதைப் புரிந்துகொள்வது முக்கியம். கன்டெய்னருக்குள் கைமுறையாக கோப்பு ஸ்டப்களை உருவாக்குவது முதல் அதிக நேரடி வன்பொருள் அணுகலை அனுமதிக்க டோக்கர் இயக்க நேர உள்ளமைவை மாற்றுவது வரை தீர்வுகள் இருக்கலாம். நேரடி வன்பொருள் தொடர்பு தேவைப்படும் கணினிகளில் கொள்கலன்களை உருவாக்கும்போது அல்லது வரிசைப்படுத்தும்போது டெவலப்பர்கள் இந்த வரம்புகளை கவனத்தில் கொள்ள வேண்டும்.