Development மற்றும் operations இரண்டும் இணைந்து ஒருசேர நடைபெறும் நிகழ்வுகளின் தொடர்ச்சிகளே DevOps என்று அழைக்கப்படுகிறது. வாடிக்கையாளர்கள் கேட்கின்ற விஷயத்தை உருவாக்கித் தருபவருக்கு developer என்று பெயர். இவர் தம்முடைய இடத்தில் (local server) உருவாக்கிய ஒன்றை, வாடிக்கையாளர்களுடைய இடத்தில் (Production server) சிறப்பாக இயங்குமாறு செய்யும் குழுவிற்கு Operations team என்று பெயர். இவ்விரண்டு வேலையையும் ஒருவரே செய்தால் அவரே Devops Engineer என்று அழைக்கப்படுவார். எடுத்துக்காட்டாக உணவகங்களில் நாம் கேட்கின்ற இட்லி, தோசை போன்றவற்றை ஓரிடத்தில் உட்கார்ந்து செய்து கொடுப்பவரை டெவலப்பர் எனலாம். அவர் செய்து கொடுத்ததை நாம் சாப்பிடுவதற்கு ஏற்ற வகையில் ஒரு தட்டில் வைத்து அதனுடன் சட்னி சாம்பார் போன்றவற்றையும் சேர்த்து நம்முடைய டேபிளில் கொண்டு வந்து வைக்கும் சர்வர் போன்றோரை ஆப்பரேஷன்ஸ் டீம் எனலாம். இவ்விரண்டு வேலைகளும் தனித்தனியே நடைபெறாமல் ஒரு சில உணவகங்களில் உள்ள செல்ஃப் சர்வீஸ் முறையை DevOps-க்கு உதாரணமாகக் கூறலாம்.
செல்ஃப் சர்வீஸ் முறையில் டெவலப்பர் தோசையை உருவாக்கியவுடன், அவரே அதனை ஒரு தட்டில் இட்டு அதனோடு சட்னி-சாம்பார் போன்ற துணை உணவுப் பொருட்களையும் சேர்த்து உண்பதற்கு ஏற்ற வகையில் உணவுத்தட்டை தயார் செய்வார். அதேபோல் டெவலப்பர் அப்ளிகேஷனை உருவாக்கியவுடன் அதற்குத் தேவையான துணை packages,os என எல்லாவற்றையும் சேர்த்து ஒரு container-ல் இட்டு, docker என்ற ஒன்றைத் தயார் செய்வர். உணவையும், உணவுத்தட்டையும் தயார் செய்தபின், அதற்கான டோக்கன் எண்ணை அறிவிப்புப் பலகையில் வெளிப்படுத்தி ‘சாப்பிடுவதற்குத் தயாரான நிலையில் தோசை உள்ளது’ என்பதை பயனருக்குத் தெரிவிப்பார். அதேபோல் அப்ளிகேசனையும், அதற்கான docker-ஐயும் உருவாக்கியபின், Jenkins மூலம் வேண்டிய இடத்தில் (dev/test/stg/prod environments) நிறுவி, ‘பயன்படுத்துவதற்குத் தயாரான நிலையில் அப்ளிகேஷன் உள்ளது’ என்பதை பயனர்களுக்குத் தெரிவிப்பார். ஆகவே development + operations இரண்டும் இணைந்து DevOps என்று அழைக்கப்படுகிறது. இவற்றை தனித்தனியாக செய்யாமல் தானியக்க முறையில் தொடர் நிகழ்வுகளாக அமைப்பதன் முக்கியத்துவத்தை அறிய முதலில் ஒரு மென்பொருள் உருவாக்கத்தில் உள்ள முக்கியப் படிநிலைகளை நன்கு புரிந்து கொள்ள வேண்டும். இவை பின்வருமாறு.
1.முதலில் வாடிக்கையாளருக்கு என்னென்ன தேவை என்பதை அவரிடமிருந்து எழுத்துவடிவில் பெற்றுக் கொண்டு அதனை ஆராய்வது ‘Requirements gathering and Analysis’ எனப்படும்.
2.அடுத்ததாக எப்படி செய்யப் போகிறோம் எனத் திட்டமிடுவது ‘Project Planning’ எனப்படும்.
3.பின்னர் நிரல்கள் எழுதி தேவையானவற்றை உருவாக்கிக் கொடுப்பதே ‘Development’ ஆகும். குழுவாக இணைந்து நிரலாளர்கள் வேலை செய்யும்போது, ஒவ்வொருவரும் அவரவர்களுடைய நிரலைப் பகிர்ந்து கொள்வதற்கு SVN, GIT போன்றவற்றைப் பயன்படுத்துகின்றனர். இத்தகைய நிரல்களை ஒருங்கிணைத்து, அவற்றின் செயல்பாடுகளையெல்லாம் சோதித்து, அதில் திருப்தி ஏற்பட்டவுடன் ஒருங்கிணைந்த நிரலை இறுதியாக GIT-ல் பகிர்வர்.
4. GIT-ல் இருக்கும் நிரலை பயன்படுத்தும் வகையிலான அப்ளிக்கேஷனாக மாற்றும் செயலுக்கு build என்று பெயர். Operations குழுவில் இருக்கும் ஒருவர் GIT-லிருந்து நிரலை எடுத்து build செய்து அதனை test environment-ல் நிறுவிக் கொடுப்பர்.
5. Tester என்பவர் அப்ளிகேஷனை சோதித்து வழுக்களையெல்லாம் issue trackerல் பதிவிடுவர். இவற்றையெல்லாம் திருத்தி, திருத்தப்பட்ட நிரலை மீண்டும் GIT-ல் பதிவேற்றுவர் டெவலப்பர். இந்தப் புதிய நிரலை எடுத்து மீண்டும் அப்ளிகேஷனை உருவாக்கி டெஸ்டிங் டீமிடம் கொடுப்பர் ஆப்பரேஷன்ஸ் டீம். இச்சுழற்சியே மீண்டும் மீண்டும் நிகழ்ந்து டெஸ்டரை திருப்தி படுத்தியவுடன் அடுத்த நிலைக்குச் செல்கிறது அப்ளிகேஷன்.
6. டெஸ்டர் அனுமதி கொடுத்தவுடன், நேரடியாக production-ல் சென்று நிறுவாமல், staging என்ற இடத்தில் build செய்து கொடுப்பர் ஆப்பரேஷன்ஸ் டீம். Production சூழல் மாதிரியே உள்ள இந்தச் சூழலில் மீண்டும் ஒருமுறை சோதனை ஓட்டம் (trial run) நிகழ்த்தப்படுகிறது. UAT test, mock test, functional test, regression test போன்ற அனைத்து வகையான சோதனைகளும் மனிதர்கள் மூலமாகவும் தானியக்க முறையிலும் நிகழ்த்தப்பட்டு பிழைகள் கண்டறியப்படுகின்றன. டெஸ்டிங் போது வராத பிழைகள் கூட இந்த environment-ல் வர வாய்ப்பு உள்ளது. ஏனெனில் இது production-ஐ ஒத்தவாறு அமைக்கப்பட்டுள்ளது. ஆகவே பிழைகளை Issue tracker-ல் பதிவிடுவது, பிழை நீக்கம், திருத்தப்பட்ட நிரல்களின் கிட் பதிவேற்றம், மீண்டும் build செய்து environment-ல் நிறுவுதல், மீண்டும் சோதனை, சோதனை, சோதனை மேல் சோதனை என அனைத்தும் இங்கு நிகழ்த்தப்படுகின்றன.
7. கடைசியாக எல்லாப் பிழைகளும் நீக்கப்பட்டபின், production environment-ல் பயன்பாட்டுக்காக நிறுவப்படுகிறது. இங்கும் சில சோதனைகள் நடத்தி சரிபார்த்த பின்னரே அனைவருக்கும் அறிவிக்கப்படுகிறது.
பண்டைய காலங்களில் ‘வாட்டர் ஃபால் மாடல்’ என்ற முறை பயன்படுத்தப்பட்ட போது மேற்கண்ட அனைத்து செயல்களும் ஒன்றன்பின் ஒன்றாக திகழும். இதனால் ஏற்படும் கால விரயம் மிக அதிகம். ஆனால் தற்போதோ Agile எனும் அதிவேக முறையில் மேற்கண்ட அனைத்தும் இரு வார கால sprint-க்குள் நடைபெறுகின்றன. இதில் உருவாக்கப்படும் அளவிற்குத்தான் requirements-ம் தரப்படுகின்றன. ஆகவே இக்குறுகிய காலத்தில் டெவலப்மெண்ட், டெஸ்டிங், ஆபரேஷன்ஸ் ஆகிய மூன்று குழுக்கள் ஒன்றிணைந்து அதிவிரைவாக செயல்பட வேண்டியது அவசியமாகிறது. இதில் production deployment அடிக்கடி நடக்காவிட்டாலும் கூட, அடிக்கடி நடக்கின்ற dev, test, staging deployment ஆகியவற்றை தானியக்கம் செய்வதன்மூலம் நேர விரயத்தைக் குறைக்கலாம். இதற்கான automation-தான் DevOps என்று அழைக்கப்படுகிறது. மேற்கண்ட படிநிலைகளில் டெவலப்பர் நிரல் எழுதி முடித்த உடனேயே, தாமாக டெவ், டெஸ்ட் அல்லது ஸ்டேஜ்-ல் deploy- ஆகி சோதனைகளை நடத்தி, சோதனை முடிவுகளை குழுவுக்கு அறிவிக்கும் தானியக்க தொடர் செயல்களையே DevOps என்கிறோம். இதில் ஈடுபடுகின்ற முக்கிய மென்பொருட்கள் பின்வருமாறு:
Version control system – CVS, SVN, Mercurial, GIT
Build systems – Jenkins, shell script
Continuous Integration & Continuous Deployment (CI & CD) – Docker, Kubernetes
Testing – Selenium
Alerting – Prometheus, Email, SMS
இனிவரும் பகுதிகளில் ஒரு அப்ளிகேஷனை எவ்வாறு உருவாக்குவது, அதற்கான நிரல்களை எவ்வாறு GIT-ல் சேமிப்பது, Docker file-ஐ எவ்விதம் எழுதுவது, ஜென்கின்ஸ் மூலம் எப்படி அதனை பில்டு செய்து ஒரு சர்வரில் ஹோஸ்ட் செய்வது போன்ற அனைத்தையும் ஒன்றன் பின் ஒன்றாகக் காணலாம்.