நெட்வொர்க்கிங் துறையில் பைத்தான் ஆட்டோமேஷன்
பைத்தான் அடிப்படை கட்டமைப்புகள்
நெட்வொர்க் ஆட்டோமேஷனுக்கு பைத்தான்
CCNA மற்றும் சப்நெட்டிங் தெரிந்த உங்களுக்கு, பல நெட்வொர்க் சாதனங்களை ஒரே நேரத்தில் நிர்வகிப்பது எவ்வளவு கடினம் என்று தெரியும். ஒவ்வொரு ரூட்டராக லாகின் செய்து, கட்டளைகளை டைப் செய்வது நேரத்தை வீணாக்கும். இங்கேதான் பைத்தான் ஒரு சக்திவாய்ந்த கருவியாக உதவுகிறது. உங்கள் நெட்வொர்க்கை நிர்வகிக்கும் பணிகளை தானியக்கமாக்க தேவையான பைத்தானின் அடிப்படைகளை இப்போது பார்ப்போம்.
சாதனத்தின் தகவல்களை சேமித்தல்
நெட்வொர்க்கிங்கில், நாம் சாதனத்தின் பெயர், IP முகவரி, மாடல் எண் போன்ற பல தகவல்களைக் கையாளுகிறோம். பைத்தானில், இந்தத் தகவல்களை 'variables' எனப்படும் மாறிகளில் சேமிக்கலாம்.
ஒவ்வொரு வகை தகவலுக்கும் ஒரு குறிப்பிட்ட 'data type' உள்ளது. உதாரணமாக, சாதனத்தின் பெயரை (எ.கா: "Router1") ஒரு 'string' ஆகவும், அதன் இன்டர்ஃபேஸ் எண்ணை (எ.கா: 1) ஒரு 'integer' ஆகவும் சேமிப்போம்.
# சாதனத்தின் பெயர் மற்றும் IP முகவரியை மாறிகளில் சேமித்தல்
hostname = "core-router-01"
ip_address = "192.168.1.1"
interface_count = 24
print(hostname)
print(ip_address)
print(interface_count)
ஒரு சாதனத்தின் தகவலைச் சேமிப்பது எளிது. ஆனால், உங்களிடம் நூற்றுக்கணக்கான ரூட்டர்கள் இருந்தால் என்ன செய்வது? ஒவ்வொரு ரூட்டருக்கும் தனித்தனி மாறி உருவாக்குவது சிறந்த வழி அல்ல. இதற்குத்தான் 'lists' மற்றும் 'dictionaries' உதவுகின்றன.
பல சாதனங்களை நிர்வகித்தல்
ஒரு ஷாப்பிங் லிஸ்ட்டைப் போலவே, பைத்தானில் உள்ள 'List' என்பது பல பொருட்களை ஒரே இடத்தில் வரிசையாகச் சேமிக்கப் பயன்படுகிறது. நாம் பல சாதனங்களின் IP முகவரிகளை ஒரு லிஸ்ட்டில் சேமிக்கலாம்.
# பல IP முகவரிகளைக் கொண்ட ஒரு லிஸ்ட்
router_ips = ["10.1.1.1", "10.1.1.2", "10.1.1.3", "10.1.1.4"]
# லிஸ்ட்டின் முதல் IP முகவரியை அணுகுதல் (இண்டெக்ஸ் 0-வில் தொடங்கும்)
print(router_ips[0])
லிஸ்ட்கள் IP முகவரிகளுக்குச் சிறந்தவை. ஆனால் ஒரு சாதனத்தைப் பற்றிய பலவிதமான தகவல்களை (பெயர், மாடல், OS பதிப்பு) ஒன்றாகச் சேமிக்க விரும்பினால், Dictionaries மிகவும் பயனுள்ளதாக இருக்கும். ஒரு அகராதியில் ஒரு சொல்லுக்கு அர்த்தம் இருப்பது போல, பைத்தான் டிஷ்னரியில் ஒரு 'key' உடன் ஒரு 'value' இணைக்கப்பட்டிருக்கும்.
# ஒரு சாதனத்தின் தகவல்களை டிஷ்னரியில் சேமித்தல்
device_details = {
"hostname": "branch-router-22",
"ip": "203.0.113.5",
"vendor": "Cisco",
"os": "IOS-XE",
"model": "ISR 4331"
}
# சாதனத்தின் IP முகவரியை அணுகுதல்
print(device_details["ip"])
செயல்களைத் தானியக்கமாக்குதல்
இப்போது நம்மிடம் பல சாதனங்களின் IP முகவரிகள் ஒரு லிஸ்ட்டில் உள்ளன. அவை ஒவ்வொன்றையும் பிங் (ping) செய்ய வேண்டும் என்று வைத்துக்கொள்வோம். ஒவ்வொன்றாக டைப் செய்வதற்குப் பதிலாக, 'for loop' பயன்படுத்தலாம். இது ஒரு லிஸ்ட்டில் உள்ள ஒவ்வொரு பொருளுக்கும் ஒரே செயலை மீண்டும் மீண்டும் செய்யும்.
router_ips = ["10.1.1.1", "10.1.1.2", "10.1.1.3"]
# ஒவ்வொரு IP முகவரிக்கும் ஒரு செயலைச் செய்தல்
for ip in router_ips:
# f-string ஐப் பயன்படுத்தி ஒரு டைனமிக் கட்டளையை உருவாக்குகிறோம்
ping_command = f"ping {ip}"
print(f"Executing: {ping_command}")
# இங்கே உண்மையான பிங் செய்யும் குறியீடு எழுதப்படும்
மேலே உள்ள எடுத்துக்காட்டில், for ip in router_ips: என்பது லிஸ்ட்டில் உள்ள ஒவ்வொரு IP முகவரியையும் ip என்ற மாறிக்கு ஒதுக்குகிறது. பிறகு, எனப்படும் ஒரு சிறப்பு வகை string-ஐப் பயன்படுத்தி, ஒவ்வொரு IP-க்கும் ஒரு ping கட்டளையை உருவாக்குகிறோம். இது உங்கள் வேலையை எவ்வளவு எளிதாக்குகிறது என்று பாருங்கள். நூற்றுக்கணக்கான சாதனங்களுக்கு ஒரே கட்டளையை அனுப்ப இந்த லூப் சில வினாடிகள் மட்டுமே எடுக்கும்.
இந்த அடிப்படைக் கூறுகள் - மாறிகள், லிஸ்ட்கள், டிஷ்னரிகள் மற்றும் லூப்கள் - நெட்வொர்க் ஆட்டோமேஷனுக்கான அடித்தளமாகும். இவற்றைப் பயன்படுத்தி, நீங்கள் எளிமையான ஸ்கிரிப்ட்களை உருவாக்கி, உங்கள் அன்றாடப் பணிகளை எளிதாக்கலாம்.