இந்த வலைப்பதிவில் உள்ள அனைவருக்கும் வணக்கம்! Red Hat OpenShift இல் நவீன வலை பயன்பாடுகளை எவ்வாறு வரிசைப்படுத்துவது என்பதைக் காட்டும் தொடரின் மூன்றாவது இடுகை இதுவாகும்.
முந்தைய இரண்டு இடுகைகளில், ஒரு சில படிகளில் நவீன வலைப் பயன்பாடுகளை எவ்வாறு வரிசைப்படுத்துவது மற்றும் புதிய S2I படத்தைப் பயன்படுத்தி, NGINX போன்ற ஆஃப்-தி-ஷெல்ஃப் HTTP சர்வர் படத்துடன், உற்பத்தி வரிசைப்படுத்தல்களை ஒழுங்கமைக்க சங்கிலி உருவாக்கங்களைப் பயன்படுத்துவது எப்படி என்பதைக் காண்பித்தோம். .
OpenShift இயங்குதளத்தில் உங்கள் பயன்பாட்டிற்கான டெவலப்மென்ட் சர்வரை எவ்வாறு இயக்குவது மற்றும் அதை உள்ளூர் கோப்பு முறைமையுடன் ஒத்திசைப்பது எப்படி என்பதையும், OpenShift பைப்லைன்கள் என்றால் என்ன என்பதையும், இணைக்கப்பட்ட அசெம்பிளிகளுக்கு மாற்றாக அவற்றை எவ்வாறு பயன்படுத்தலாம் என்பதையும் இன்று காண்பிப்போம்.
வளர்ச்சி சூழலாக OpenShift
வளர்ச்சி பணிப்பாய்வு
ஏற்கனவே கூறியது போல் , நவீன வலைப் பயன்பாடுகளுக்கான பொதுவான வளர்ச்சி செயல்முறையானது உள்ளூர் கோப்புகளில் ஏற்படும் மாற்றங்களைக் கண்காணிக்கும் ஒருவித "மேம்பாடு சேவையகம்" ஆகும். அவை நிகழும்போது, பயன்பாட்டு உருவாக்கம் தூண்டப்படுகிறது, பின்னர் அது உலாவிக்கு புதுப்பிக்கப்படும்.
பெரும்பாலான நவீன கட்டமைப்புகளில், அத்தகைய "வளர்ச்சி சேவையகம்" தொடர்புடைய கட்டளை வரி கருவிகளில் கட்டமைக்கப்பட்டுள்ளது.
உள்ளூர் உதாரணம்
முதலில், உள்நாட்டில் பயன்பாடுகளை இயக்கும் போது இது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம். விண்ணப்பத்தை உதாரணமாக எடுத்துக் கொள்வோம் முந்தைய கட்டுரைகளில் இருந்து, ஏறக்குறைய அதே பணிப்பாய்வு கருத்துக்கள் மற்ற அனைத்து நவீன கட்டமைப்புகளிலும் பொருந்தும்.
எனவே, எங்கள் எதிர்வினை எடுத்துக்காட்டில் "dev சேவையகத்தை" தொடங்க, பின்வரும் கட்டளையை உள்ளிடுவோம்:
$ npm run start
டெர்மினல் விண்டோவில் இது போன்ற ஒன்றைக் காண்போம்:
எங்கள் பயன்பாடு இயல்புநிலை உலாவியில் திறக்கும்:
இப்போது, கோப்பில் மாற்றங்களைச் செய்தால், பயன்பாடு உலாவியில் புதுப்பிக்கப்பட வேண்டும்.
சரி, உள்ளூர் பயன்முறையில் வளர்ச்சியுடன் எல்லாம் தெளிவாக உள்ளது, ஆனால் OpenShift இல் அதை எவ்வாறு அடைவது?
OpenShift இல் டெவலப்மெண்ட் சர்வர்
நீங்கள் நினைவில் வைத்திருந்தால், உள்ளே , S2I படத்தின் ரன் கட்டம் என்று அழைக்கப்படுவதைப் பார்த்தோம், இயல்புநிலையாக, சர்வ் மாட்யூல் எங்கள் இணையப் பயன்பாட்டைச் செயல்படுத்துவதற்குப் பொறுப்பாகும்.
இருப்பினும், நீங்கள் நெருக்கமாகப் பார்த்தால் அந்த எடுத்துக்காட்டில் இருந்து, இது $NPM_RUN சூழல் மாறியைக் கொண்டுள்ளது, இது உங்கள் கட்டளையை இயக்க அனுமதிக்கிறது.
எடுத்துக்காட்டாக, எங்கள் பயன்பாட்டைப் பயன்படுத்துவதற்கு நாம் nodeshift தொகுதியைப் பயன்படுத்தலாம்:
$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app
குறிப்பு: மேலே உள்ள உதாரணம் பொதுவான கருத்தை விளக்குவதற்காக சுருக்கப்பட்டுள்ளது.
இங்கே நாங்கள் எங்கள் வரிசைப்படுத்தலில் NPM_RUN சூழல் மாறியைச் சேர்த்துள்ளோம், இது நூல் தொடக்கக் கட்டளையை இயக்குவதற்கான இயக்க நேரத்தைக் கூறுகிறது, இது எங்கள் OpenShift பாட்க்குள் ரியாக்ட் டெவலப்மெண்ட் சேவையகத்தைத் தொடங்குகிறது.
இயங்கும் பாட்டின் பதிவைப் பார்த்தால், அது இப்படி இருக்கும்:
நிச்சயமாக, உள்ளூர் குறியீட்டை குறியீட்டுடன் ஒத்திசைக்கும் வரை இவை அனைத்தும் ஒன்றுமில்லை, இது மாற்றங்களுக்காகவும் கண்காணிக்கப்படுகிறது, ஆனால் தொலை சேவையகத்தில் வாழ்கிறது.
தொலைநிலை மற்றும் உள்ளூர் குறியீட்டை ஒத்திசைத்தல்
அதிர்ஷ்டவசமாக, nodeshift எளிதாக ஒத்திசைக்க உதவும், மேலும் மாற்றங்களைக் கண்காணிக்க வாட்ச் கட்டளையைப் பயன்படுத்தலாம்.
எனவே எங்கள் பயன்பாட்டிற்கான மேம்பாட்டு சேவையகத்தை வரிசைப்படுத்த கட்டளையை இயக்கிய பிறகு, பின்வரும் கட்டளையைப் பாதுகாப்பாகப் பயன்படுத்தலாம்:
$ npx nodeshift watch
இதன் விளைவாக, நாங்கள் சற்று முன்பு உருவாக்கிய இயங்கும் பாட் உடன் ஒரு இணைப்பு உருவாக்கப்படும், தொலைநிலை கிளஸ்டருடன் எங்கள் உள்ளூர் கோப்புகளின் ஒத்திசைவு செயல்படுத்தப்படும், மேலும் எங்கள் உள்ளூர் கணினியில் உள்ள கோப்புகள் மாற்றங்களுக்கு கண்காணிக்கத் தொடங்கும்.
எனவே, நாம் இப்போது src/App.js கோப்பைப் புதுப்பித்தால், கணினி இந்த மாற்றங்களுக்கு எதிர்வினையாற்று, ரிமோட் கிளஸ்டருக்கு நகலெடுத்து டெவலப்மென்ட் சர்வரைத் தொடங்கும், அது உலாவியில் எங்கள் பயன்பாட்டைப் புதுப்பிக்கும்.
படத்தை முடிக்க, இந்த முழு கட்டளைகளும் எப்படி இருக்கும் என்பதைக் காண்பிப்போம்:
$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000
$ npx nodeshift watch --strictSSL=false
வாட்ச் கட்டளை என்பது oc rsync கட்டளையின் மேல் உள்ள சுருக்கமாகும், இது எவ்வாறு செயல்படுகிறது என்பதைப் பற்றி மேலும் அறியலாம் .
ரியாக்டிற்கு இது ஒரு எடுத்துக்காட்டு, ஆனால் அதே முறையை மற்ற கட்டமைப்புகளுடன் பயன்படுத்தலாம், தேவையான NPM_RUN சூழல் மாறியை அமைக்கவும்.
ஓபன்ஷிப்ட் பைப்லைன்ஸ்
அடுத்து நாம் OpenShift Pipelines போன்ற ஒரு கருவியைப் பற்றி பேசுவோம், சங்கிலியால் கட்டப்பட்ட கட்டிடங்களுக்கு மாற்றாக அதை எவ்வாறு பயன்படுத்தலாம்.
OpenShift பைப்லைன்கள் என்றால் என்ன
OpenShift Pipelines என்பது கிளவுட்-நேட்டிவ் CI/CD தொடர்ச்சியான ஒருங்கிணைப்பு மற்றும் டெலிவரி அமைப்பாகும், இது Tekton ஐப் பயன்படுத்தி குழாய்களை ஒழுங்கமைக்க வடிவமைக்கப்பட்டுள்ளது. Tekton என்பது ஒரு நெகிழ்வான ஓப்பன் சோர்ஸ் குபெர்னெட்ஸ்-நேட்டிவ் சிஐ/சிடி கட்டமைப்பாகும், இது பல்வேறு தளங்களில் (குபெர்னெட்ஸ், சர்வர்லெஸ், விர்ச்சுவல் மெஷின்கள் போன்றவை) உள்ளடங்கிய லேயரில் இருந்து சுருக்கம் செய்வதன் மூலம் தானியங்குபடுத்தலை அனுமதிக்கிறது.
இந்தக் கட்டுரையைப் புரிந்துகொள்வதற்கு பைப்லைன்கள் பற்றிய சில அறிவு தேவைப்படுகிறது, எனவே நீங்கள் முதலில் படிக்குமாறு நாங்கள் கடுமையாக பரிந்துரைக்கிறோம் .
உங்கள் பணிச்சூழலை அமைத்தல்
இந்த கட்டுரையில் உள்ள எடுத்துக்காட்டுகளுடன் விளையாட, முதலில் உங்கள் பணிச்சூழலை தயார் செய்ய வேண்டும்:
- OpenShift 4 கிளஸ்டரை நிறுவி கட்டமைக்கவும். எங்கள் எடுத்துக்காட்டுகள் CodeReady Containers (CRD) ஐப் பயன்படுத்துகின்றன, அதற்கான நிறுவல் வழிமுறைகளைக் காணலாம். .
- கிளஸ்டர் தயாரான பிறகு, நீங்கள் அதில் பைப்லைன் ஆபரேட்டரை நிறுவ வேண்டும். பயப்பட வேண்டாம், இது எளிதானது, நிறுவல் வழிமுறைகள் .
- பதிவிறக்க Tamil (tkn) .
- ஒரு பயன்பாட்டை உருவாக்க create-react-app கட்டளை வரி கருவியை இயக்கவும், அதை நீங்கள் பயன்படுத்துவீர்கள் (இது ஒரு எளிய பயன்பாடு ).
- (விரும்பினால்) npm நிறுவல் மற்றும் npm தொடக்கத்துடன் மாதிரி பயன்பாட்டை உள்நாட்டில் இயக்க களஞ்சியத்தை குளோன் செய்யவும்.
பயன்பாட்டுக் களஞ்சியத்தில் k8s கோப்புறையும் இருக்கும், அதில் பயன்பாட்டை வரிசைப்படுத்தப் பயன்படுத்தப்படும் Kubernetes/OpenShift YAMLகள் இருக்கும். இதில் நாம் உருவாக்கும் பணிகள், கிளஸ்டர் பணிகள், வளங்கள் மற்றும் பைப்லைன்கள் இருக்கும் .
ஆரம்பிக்கலாம்
எங்கள் உதாரணத்திற்கான முதல் படி, OpenShift கிளஸ்டரில் ஒரு புதிய திட்டத்தை உருவாக்குவதாகும். இந்த திட்டத்தை webapp-pipeline என்று அழைப்போம் மற்றும் பின்வரும் கட்டளையுடன் அதை உருவாக்கலாம்:
$ oc new-project webapp-pipeline
இந்தத் திட்டப் பெயர் பின்னர் குறியீட்டில் தோன்றும், எனவே இதற்கு வேறு ஏதாவது பெயரிட முடிவு செய்தால், அதற்கேற்ப உதாரணக் குறியீட்டைத் திருத்த மறக்காதீர்கள். இந்த கட்டத்தில் இருந்து தொடங்கி, நாங்கள் மேல்-கீழே செல்ல மாட்டோம், ஆனால் கீழ்-மேலே: அதாவது, முதலில் கன்வேயரின் அனைத்து கூறுகளையும் உருவாக்குவோம், அதன் பிறகுதான் கன்வேயர் தானே.
எனவே, முதலில் ...
பணிகள்
இரண்டு பணிகளை உருவாக்குவோம், இது எங்கள் பைப்லைனில் பயன்பாட்டைப் பயன்படுத்த உதவும். முதல் பணி - apply_manifests_task - எங்கள் பயன்பாட்டின் k8s கோப்புறையில் உள்ள குபெர்னெட்ஸ் ஆதாரங்களின் (சேவை, வரிசைப்படுத்தல் மற்றும் வழி) YAML ஐப் பயன்படுத்துவதற்குப் பொறுப்பாகும். இரண்டாவது பணி - update_deployment_task - ஏற்கனவே வரிசைப்படுத்தப்பட்ட படத்தை எங்கள் பைப்லைன் உருவாக்கிய படத்திற்கு புதுப்பிப்பதற்கு பொறுப்பாகும்.
இது இன்னும் தெளிவாக இல்லை என்றால் கவலைப்பட வேண்டாம். உண்மையில், இந்த பணிகள் பயன்பாடுகள் போன்றவை, மேலும் சிறிது நேரம் கழித்து அவற்றை இன்னும் விரிவாகப் பார்ப்போம். இப்போதைக்கு, அவற்றை உருவாக்குவோம்:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml
பின்னர், tkn CLI கட்டளையைப் பயன்படுத்தி, பணிகள் உருவாக்கப்பட்டனவா என்பதைச் சரிபார்ப்போம்:
$ tkn task ls
NAME AGE
apply-manifests 1 minute ago
update-deployment 1 minute ago
குறிப்பு: இவை உங்கள் தற்போதைய திட்டத்திற்கான உள்ளூர் பணிகள்.
கிளஸ்டர் பணிகள்
கிளஸ்டர் பணிகள் அடிப்படையில் எளிய பணிகளைப் போலவே இருக்கும். அதாவது, இது ஒரு குறிப்பிட்ட பணியை இயக்கும்போது ஒரு வழியில் அல்லது வேறு வழியில் இணைக்கப்பட்ட படிகளின் மறுபயன்பாட்டு தொகுப்பு ஆகும். வித்தியாசம் என்னவென்றால், கிளஸ்டருக்குள் எல்லா இடங்களிலும் ஒரு கிளஸ்டர் பணி உள்ளது. பைப்லைன் ஆபரேட்டரைச் சேர்க்கும்போது தானாகவே உருவாக்கப்படும் கிளஸ்டர் பணிகளின் பட்டியலைப் பார்க்க, மீண்டும் tkn CLI கட்டளையைப் பயன்படுத்துவோம்:
$ tkn clustertask ls
NAME AGE
buildah 1 day ago
buildah-v0-10-0 1 day ago
jib-maven 1 day ago
kn 1 day ago
maven 1 day ago
openshift-client 1 day ago
openshift-client-v0-10-0 1 day ago
s2i 1 day ago
s2i-go 1 day ago
s2i-go-v0-10-0 1 day ago
s2i-java-11 1 day ago
s2i-java-11-v0-10-0 1 day ago
s2i-java-8 1 day ago
s2i-java-8-v0-10-0 1 day ago
s2i-nodejs 1 day ago
s2i-nodejs-v0-10-0 1 day ago
s2i-perl 1 day ago
s2i-perl-v0-10-0 1 day ago
s2i-php 1 day ago
s2i-php-v0-10-0 1 day ago
s2i-python-3 1 day ago
s2i-python-3-v0-10-0 1 day ago
s2i-ruby 1 day ago
s2i-ruby-v0-10-0 1 day ago
s2i-v0-10-0 1 day ago
இப்போது இரண்டு கிளஸ்டர் பணிகளை உருவாக்குவோம். முதலாவது S2I படத்தை உருவாக்கி உள் OpenShift பதிவேட்டில் அனுப்பும்; இரண்டாவது, நாங்கள் ஏற்கனவே உள்ளடக்கமாக உருவாக்கிய பயன்பாட்டைப் பயன்படுத்தி, NGINX அடிப்படையில் எங்கள் படத்தை உருவாக்குவது.
படத்தை உருவாக்கி அனுப்பவும்
முதல் பணியை உருவாக்கும் போது, இணைக்கப்பட்ட கூட்டங்களைப் பற்றி முந்தைய கட்டுரையில் ஏற்கனவே செய்ததை மீண்டும் செய்வோம். எங்கள் பயன்பாட்டை "உருவாக்க" S2I படத்தை (ubi8-s2i-web-app) நாங்கள் பயன்படுத்தினோம், மேலும் OpenShift உள் பதிவேட்டில் சேமிக்கப்பட்ட ஒரு படத்துடன் முடிந்தது என்பதை நினைவில் கொள்க. இப்போது இந்த S2I இணையப் பயன்பாட்டுப் படத்தைப் பயன்படுத்தி எங்கள் பயன்பாட்டிற்கான DockerFileஐ உருவாக்குவோம், பின்னர் Buildah ஐப் பயன்படுத்தி உண்மையான உருவாக்கத்தை உருவாக்கி அதன் விளைவாக வரும் படத்தை OpenShift உள் பதிவேட்டில் தள்ளுவோம், ஏனெனில் நீங்கள் NodeShift ஐப் பயன்படுத்தி உங்கள் பயன்பாடுகளை வரிசைப்படுத்தும்போது OpenShift சரியாகவே செய்கிறது. .
இதெல்லாம் எங்களுக்கு எப்படித் தெரிந்தது என்று கேட்கிறீர்களா? இருந்து , நாங்கள் அதை நகலெடுத்து நமக்காக மாற்றியமைத்தோம்.
எனவே, இப்போது s2i-web-app கிளஸ்டர் பணியை உருவாக்குவோம்:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml
இதை நாங்கள் விரிவாக பகுப்பாய்வு செய்ய மாட்டோம், ஆனால் OUTPUT_DIR அளவுருவில் மட்டுமே கவனம் செலுத்துவோம்:
params:
- name: OUTPUT_DIR
description: The location of the build output directory
default: build
முன்னிருப்பாக, இந்த அளவுரு உருவாக்கத்திற்கு சமம், இதில்தான் ரியாக்ட் அசெம்பிள் செய்யப்பட்ட உள்ளடக்கத்தை வைக்கிறது. மற்ற கட்டமைப்புகள் வெவ்வேறு பாதைகளைப் பயன்படுத்துகின்றன, எடுத்துக்காட்டாக, எம்பரில் இது தொலைவில் உள்ளது. எங்கள் முதல் கிளஸ்டர் பணியின் வெளியீடு, நாங்கள் சேகரித்த HTML, JavaScript மற்றும் CSS ஆகியவற்றைக் கொண்ட ஒரு படமாக இருக்கும்.
NGINX அடிப்படையில் ஒரு படத்தை உருவாக்கவும்
எங்கள் இரண்டாவது கிளஸ்டர் பணியைப் பொறுத்தவரை, நாங்கள் ஏற்கனவே உருவாக்கிய பயன்பாட்டின் உள்ளடக்கத்தைப் பயன்படுத்தி, அது எங்களுக்காக ஒரு NGINX- அடிப்படையிலான படத்தை உருவாக்க வேண்டும். முக்கியமாக, இது முந்தைய பகுதியின் பகுதியாகும், அங்கு நாம் சங்கிலியால் கட்டப்பட்ட கட்டிடங்களைப் பார்த்தோம்.
இதைச் செய்ய, நாங்கள் - மேலே உள்ளதைப் போலவே - ஒரு கிளஸ்டர் பணி webapp-build-runtime ஐ உருவாக்குவோம்:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml
இந்த கிளஸ்டர் பணிகளுக்கான குறியீட்டை நீங்கள் பார்த்தால், அதில் நாம் பணிபுரியும் Git களஞ்சியத்தையோ அல்லது நாம் உருவாக்கும் படங்களின் பெயர்களையோ குறிப்பிடவில்லை என்பதை நீங்கள் காணலாம். Git க்கு சரியாக எதை மாற்றுகிறோம் அல்லது இறுதிப் படம் வெளியீடாக இருக்க வேண்டிய ஒரு குறிப்பிட்ட படத்தை மட்டும் குறிப்பிடுகிறோம். அதனால்தான் மற்ற பயன்பாடுகளுடன் பணிபுரியும் போது இந்த கிளஸ்டர் பணிகளை மீண்டும் பயன்படுத்த முடியும்.
இங்கே நாம் மனதார அடுத்த கட்டத்திற்கு செல்கிறோம்...
Ресурсы
எனவே, நாங்கள் சொன்னது போல், கிளஸ்டர் பணிகள் முடிந்தவரை பொதுவானதாக இருக்க வேண்டும் என்பதால், உள்ளீடாகவும் (Git களஞ்சியமாக) மற்றும் வெளியீட்டாகவும் (இறுதிப் படங்கள்) பயன்படுத்தப்படும் ஆதாரங்களை உருவாக்க வேண்டும். நமக்குத் தேவையான முதல் ஆதாரம் Git, எங்கள் பயன்பாடு இருக்கும் இடத்தில், இது போன்ற ஒன்று:
# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: web-application-repo
spec:
type: git
params:
- name: url
value: https://github.com/nodeshift-starters/react-pipeline-example
- name: revision
value: master
இங்கு பைப்லைன் ரிசோர்ஸ் என்பது ஜிட் வகை. params பிரிவில் உள்ள url விசை ஒரு குறிப்பிட்ட களஞ்சியத்தை சுட்டிக்காட்டுகிறது மற்றும் முதன்மை கிளையை குறிப்பிடுகிறது (இது விருப்பமானது, ஆனால் முழுமைக்காக எழுதுகிறோம்).
இப்போது நாம் படத்திற்கான ஆதாரத்தை உருவாக்க வேண்டும், அங்கு s2i-web-app பணியின் முடிவுகள் சேமிக்கப்படும், இது இவ்வாறு செய்யப்படுகிறது:
# This resource is the result of running "npm run build", the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: built-web-application-image
spec:
type: image
params:
- name: url
value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest
இங்கே பைப்லைன் ரிசோர்ஸ் என்பது வகைப் படமாகும், மேலும் url அளவுருவின் மதிப்பு உள் OpenShift படப் பதிவேட்டைக் குறிக்கிறது, குறிப்பாக webapp-pipeline பெயர்வெளியில் உள்ள ஒன்று. நீங்கள் வேறு பெயர்வெளியைப் பயன்படுத்தினால், இந்த அமைப்பை மாற்ற மறக்காதீர்கள்.
இறுதியாக, நமக்குத் தேவையான கடைசி ஆதாரமும் வகைப் படமாக இருக்கும், மேலும் இது வரிசைப்படுத்தலின் போது பயன்படுத்தப்படும் இறுதி NGINX படமாக இருக்கும்:
# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: runtime-web-application-image
spec:
type: image
params:
- name: url
value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest
மீண்டும், இந்த ஆதாரம் webapp-pipeline namespace இல் உள்ள உள் OpenShift பதிவேட்டில் படத்தைச் சேமிக்கிறது என்பதை நினைவில் கொள்ளவும்.
இந்த அனைத்து ஆதாரங்களையும் ஒரே நேரத்தில் உருவாக்க, உருவாக்கு கட்டளையைப் பயன்படுத்துகிறோம்:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml
ஆதாரங்கள் இப்படி உருவாக்கப்பட்டுள்ளன என்பதை உறுதிப்படுத்திக் கொள்ளலாம்:
$ tkn resource ls
கன்வேயர் குழாய்
இப்போது எங்களிடம் தேவையான அனைத்து கூறுகளும் உள்ளன, பின்வரும் கட்டளையுடன் அதை உருவாக்குவதன் மூலம் அவற்றிலிருந்து ஒரு பைப்லைனை வரிசைப்படுத்தலாம்:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml
ஆனால் இந்த கட்டளையை இயக்குவதற்கு முன், இந்த கூறுகளைப் பார்ப்போம். முதலாவது பெயர்:
apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
name: build-and-deploy-react
ஸ்பெக் பிரிவில் நாம் முன்பு உருவாக்கிய ஆதாரங்களின் குறிப்பைக் காண்கிறோம்:
spec:
resources:
- name: web-application-repo
type: git
- name: built-web-application-image
type: image
- name: runtime-web-application-image
type: image
எங்கள் பைப்லைன் முடிக்க வேண்டிய பணிகளை நாங்கள் உருவாக்குகிறோம். முதலில், நாம் ஏற்கனவே உருவாக்கிய s2i-web-app பணியை இது செயல்படுத்த வேண்டும்:
tasks:
- name: build-web-application
taskRef:
name: s2i-web-app
kind: ClusterTask
இந்த பணி உள்ளீடு (கிர் ஆதாரம்) மற்றும் வெளியீடு (உள்ளமைக்கப்பட்ட-வலை-பயன்பாடு-பட ஆதாரம்) அளவுருக்களை எடுக்கும். நாங்கள் சுய கையொப்பமிடப்பட்ட சான்றிதழ்களைப் பயன்படுத்துவதால், TLS ஐச் சரிபார்க்காமல் இருக்க, நாங்கள் அதற்கு ஒரு சிறப்பு அளவுருவையும் அனுப்புகிறோம்:
resources:
inputs:
- name: source
resource: web-application-repo
outputs:
- name: image
resource: built-web-application-image
params:
- name: TLSVERIFY
value: "false"
அடுத்த பணி ஏறக்குறைய அதே தான், இங்கு மட்டும் நாம் ஏற்கனவே உருவாக்கிய webapp-build-runtime cluster task அழைக்கப்படுகிறது:
name: build-runtime-image
taskRef:
name: webapp-build-runtime
kind: ClusterTask
முந்தைய பணியைப் போலவே, நாங்கள் ஒரு ஆதாரத்தில் செல்கிறோம், ஆனால் இப்போது அது உள்ளமைக்கப்பட்ட-வலை-பயன்பாட்டு-படம் (எங்கள் முந்தைய பணியின் வெளியீடு). ஒரு வெளியீட்டாக மீண்டும் படத்தை அமைக்கிறோம். இந்தப் பணி முந்தைய பணிக்குப் பிறகு செயல்படுத்தப்பட வேண்டும் என்பதால், நாங்கள் runAfter புலத்தைச் சேர்க்கிறோம்:
resources:
inputs:
- name: image
resource: built-web-application-image
outputs:
- name: image
resource: runtime-web-application-image
params:
- name: TLSVERIFY
value: "false"
runAfter:
- build-web-application
எங்கள் இணைய பயன்பாட்டின் k8s கோப்பகத்தில் இருக்கும் சேவை, வழி மற்றும் வரிசைப்படுத்தல் YAML கோப்புகளைப் பயன்படுத்துவதற்கு அடுத்த இரண்டு பணிகள் பொறுப்பாகும், மேலும் புதிய படங்களை உருவாக்கும் போது இந்த வரிசைப்படுத்தலைப் புதுப்பிக்கவும். கட்டுரையின் ஆரம்பத்தில் இந்த இரண்டு கிளஸ்டர் பணிகளை வரையறுத்துள்ளோம்.
கன்வேயரைத் தொடங்குதல்
எனவே, எங்கள் பைப்லைனின் அனைத்து பகுதிகளும் உருவாக்கப்பட்டு, பின்வரும் கட்டளையுடன் அதை இயக்குவோம்:
$ tkn pipeline start build-and-deploy-react
இந்த கட்டத்தில், கட்டளை வரி ஊடாடலாகப் பயன்படுத்தப்படுகிறது, மேலும் அதன் ஒவ்வொரு கோரிக்கைக்கும் பதிலளிக்கும் வகையில் பொருத்தமான ஆதாரங்களை நீங்கள் தேர்ந்தெடுக்க வேண்டும்: git வளத்திற்கு, web-application-repo ஐத் தேர்ந்தெடுக்கவும், பின்னர் முதல் பட ஆதாரத்திற்கு, உள்ளமைக்கப்பட்ட வலை-பயன்பாடு -படம், மற்றும் இறுதியாக, இரண்டாவது பட ஆதாரத்திற்கு -இயக்க நேரம்-வலை-பயன்பாடு-படம்:
? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr
இப்போது பின்வரும் கட்டளையைப் பயன்படுத்தி பைப்லைனின் நிலையை சரிபார்க்கலாம்:
$ tkn pipeline logs -f
பைப்லைன் தொடங்கி, பயன்பாடு பயன்படுத்தப்பட்டதும், பின்வரும் கட்டளையுடன் வெளியிடப்பட்ட வழியைக் கோரலாம்:
$ oc get route react-pipeline-example --template='http://{{.spec.host}}'
அதிக காட்சிப்படுத்தலுக்கு, பிரிவில் உள்ள வலை கன்சோலின் டெவலப்பர் பயன்முறையில் எங்கள் பைப்லைனை நீங்கள் பார்க்கலாம் பைப்லைன்ஸ், படத்தில் காட்டப்பட்டுள்ளபடி. 1.
வரைபடம். 1. இயங்கும் குழாய்களின் ஆய்வு.
இயங்கும் பைப்லைனில் கிளிக் செய்தால் படம் 2 இல் காட்டப்பட்டுள்ளபடி கூடுதல் விவரங்கள் காண்பிக்கப்படும்.
அரிசி. 2. குழாய் பற்றிய கூடுதல் தகவல்.
மேலும் தகவலுக்குப் பிறகு, பார்வையில் இயங்கும் பயன்பாடுகளைக் காணலாம் கட்டமைப்பியல், படம் 3 இல் காட்டப்பட்டுள்ளது.
படம் 3. தொடங்கப்பட்ட நெற்று.
ஐகானின் மேல் வலது மூலையில் உள்ள வட்டத்தில் கிளிக் செய்வதன் மூலம் படம் 4 இல் காட்டப்பட்டுள்ளபடி, எங்கள் பயன்பாடு திறக்கும்.
அரிசி. 4. ரியாக்ட் அப்ளிகேஷனை இயக்குகிறது.
முடிவுக்கு
எனவே, OpenShift இல் உங்கள் பயன்பாட்டிற்கான மேம்பாட்டு சேவையகத்தை எவ்வாறு இயக்குவது மற்றும் அதை உள்ளூர் கோப்பு முறைமையுடன் ஒத்திசைப்பது என்பதை நாங்கள் காண்பித்தோம். OpenShift பைப்லைன்களைப் பயன்படுத்தி சங்கிலியால் கட்டப்பட்ட டெம்ப்ளேட்டை எவ்வாறு உருவகப்படுத்துவது என்பதையும் நாங்கள் பார்த்தோம். இந்த கட்டுரையில் உள்ள அனைத்து எடுத்துக்காட்டு குறியீடுகளையும் காணலாம் .
கூடுதல் ஆதாரங்கள் (EN)
- இலவச மின் புத்தகம்
- பற்றிய பிற கட்டுரைகள் Red Hat இணையதளத்தில்
வரவிருக்கும் வெபினார் பற்றிய அறிவிப்புகள்
Red Hat OpenShift கன்டெய்னர் பிளாட்ஃபார்ம் மற்றும் Kubernetes ஐப் பயன்படுத்தி சொந்த அனுபவத்தைப் பற்றிய வெள்ளிக்கிழமை வெபினார்களின் தொடரைத் தொடங்குகிறோம்:
ஆதாரம்: www.habr.com