GitHub Actions और Python के साथ एक होम CI / CD का निर्माण

एक शाम, जब मैं काम से घर आया, तो मैंने थोड़ा होमवर्क करने का फैसला किया। मैंने कई संपादन किए और तुरंत उनके साथ प्रयोग करना चाहता था। लेकिन प्रयोगों से पहले, मुझे वीपीएस में जाना था, परिवर्तनों को धक्का देना, कंटेनर को फिर से बनाना और इसे चलाना। फिर मैंने फैसला किया कि यह निरंतर वितरण से निपटने का समय था।

शुरुआत में, मेरे पास सर्कल सीआई, ट्रैविस या जेनकिंस के बीच एक विकल्प था। मैंने इस तरह के एक शक्तिशाली उपकरण की आवश्यकता की कमी के कारण जेनकिन्स को लगभग तुरंत खारिज कर दिया। ट्रैविस के बारे में त्वरित पढ़ने के बाद, मैं इस निष्कर्ष पर पहुंचा कि इसमें इकट्ठा और परीक्षण करना सुविधाजनक है, लेकिन आप इसके साथ किसी भी वितरण की कल्पना नहीं कर सकते। मैंने YouTube पर अत्यधिक विज्ञापन से सर्कल CI के बारे में सीखा। मैंने उदाहरणों के साथ प्रयोग करना शुरू कर दिया, लेकिन कुछ बिंदु पर मुझसे गलती हुई और मेरे पास शाश्वत परीक्षण था, जिसने मुझे बहुत सारे कीमती मिनटों की सभा में ले लिया (सामान्य तौर पर, चिंता न करने की पर्याप्त सीमा है, लेकिन इसने मुझे मारा)। खोज को फिर से उठाते हुए, मैं गितुब क्रियाओं पर अड़ गया। गेट स्टार्टेड उदाहरणों के साथ खेलने के बाद, मुझे एक सकारात्मक धारणा मिली, और दस्तावेज़ीकरण पर त्वरित नज़र डालने के बाद, मैं इस नतीजे पर पहुंचा कि यह बहुत अच्छा है कि मैं एक ही स्थान पर विधानसभा, संग्रह और व्यावहारिक रूप से परियोजनाओं को तैनात करने के लिए रहस्य रख सकूं। चमकती आँखों के साथ, उसने जल्दी से वांछित योजना तैयार की, और गियर ख़त्म हो गए।

सबसे पहले, हम परीक्षण करने की कोशिश करेंगे। एक प्रयोगात्मक के रूप में, मैंने 2 समापन बिंदुओं के साथ फ्लास्क पर एक सरल वेब सर्वर लिखा:

from flask import Flask from flask import request, jsonify app = Flask(__name__) def validate_post_data(data: dict) -> bool: if not isinstance(data, dict): return False if not data.get('name') or not isinstance(data['name'], str): return False if data.get('age') and not isinstance(data['age'], int): return False return True @app.route('/', methods=['GET']) def hello(): return 'Hello World!' @app.route('/api', methods=['GET', 'POST']) def api(): """ /api entpoint GET - returns json= {'status': 'test'} POST - { name - str not null age - int optional } :return: """ if request.method == 'GET': return jsonify({'status': 'test'}) elif request.method == 'POST': if validate_post_data(request.json): return jsonify({'status': 'OK'}) else: return jsonify({'status': 'bad input'}), 400 def main(): app.run(host='0.0.0.0', port=8080) if __name__ == '__main__': main() 

और कुछ परीक्षण:

 import unittest import app as tested_app import json class FlaskAppTests(unittest.TestCase): def setUp(self): tested_app.app.config['TESTING'] = True self.app = tested_app.app.test_client() def test_get_hello_endpoint(self): r = self.app.get('/') self.assertEqual(r.data, b'Hello World!') def test_post_hello_endpoint(self): r = self.app.post('/') self.assertEqual(r.status_code, 405) def test_get_api_endpoint(self): r = self.app.get('/api') self.assertEqual(r.json, {'status': 'test'}) def test_correct_post_api_endpoint(self): r = self.app.post('/api', content_type='application/json', data=json.dumps({'name': 'Den', 'age': 100})) self.assertEqual(r.json, {'status': 'OK'}) self.assertEqual(r.status_code, 200) r = self.app.post('/api', content_type='application/json', data=json.dumps({'name': 'Den'})) self.assertEqual(r.json, {'status': 'OK'}) self.assertEqual(r.status_code, 200) def test_not_dict_post_api_endpoint(self): r = self.app.post('/api', content_type='application/json', data=json.dumps([{'name': 'Den'}])) self.assertEqual(r.json, {'status': 'bad input'}) self.assertEqual(r.status_code, 400) def test_no_name_post_api_endpoint(self): r = self.app.post('/api', content_type='application/json', data=json.dumps({'age': 100})) self.assertEqual(r.json, {'status': 'bad input'}) self.assertEqual(r.status_code, 400) def test_bad_age_post_api_endpoint(self): r = self.app.post('/api', content_type='application/json', data=json.dumps({'name': 'Den', 'age': '100'})) self.assertEqual(r.json, {'status': 'bad input'}) self.assertEqual(r.status_code, 400) if __name__ == '__main__': unittest.main() 

कवरेज आउटपुट:

 coverage report Name Stmts Miss Cover ------------------------------------------------------------------ src/app.py 28 2 93% src/tests.py 37 0 100% ------------------------------------------------------------------ TOTAL 65 2 96% 

अब हमारी पहली कार्रवाई बनाएँ, जो परीक्षण चलाएगी। प्रलेखन के अनुसार, सभी कार्यों को एक विशेष निर्देशिका में संग्रहीत किया जाना चाहिए:

 $ mkdir -p .github/workflows $ touch .github/workflows/test_on_push.yaml 

मैं चाहता हूं कि यह कार्रवाई किसी भी शाखा में किसी भी पुश इवेंट पर चले, सिवाय रिलीज़ (टैग के, क्योंकि अलग-अलग परीक्षण होंगे):

 on: push: tags: - '!refs/tags/*' branches: - '*' 

फिर हम एक ऐसा कार्य बनाते हैं जो उबंटू के नवीनतम उपलब्ध संस्करण में चलेगा:

 jobs: run_tests: runs-on: [ubuntu-latest] 

चरणों में, हम कोड की जांच करेंगे, अजगर स्थापित करेंगे, निर्भरताएं स्थापित करेंगे, परीक्षण चलाएंगे और कवरेज प्रदर्शित करेंगे:

 steps: #   - uses: actions/checkout@master #  python   - uses: actions/setup-python@v1 with: python-version: '3.8' architecture: 'x64' - name: Install requirements #   run: pip install -r requirements.txt - name: Run tests run: coverage run src/tests.py - name: Tests report run: coverage report 

 name: Run tests on any Push event #    push    ,    . #      on: push: tags: - '!refs/tags/*' branches: - '*' jobs: run_tests: runs-on: [ubuntu-latest] steps: #   - uses: actions/checkout@master #  python   - uses: actions/setup-python@v1 with: python-version: '3.8' architecture: 'x64' - name: Install requirements #   run: pip install -r requirements.txt - name: Run tests run: coverage run src/tests.py - name: Tests report run: coverage report 

आइए कमिट बनाने की कोशिश करें और देखें कि हमारी कार्रवाई कैसे काम करती है।

क्रियाएँ इंटरफ़ेस में परीक्षण पास करना

हुर्रे, हम पहली कार्रवाई बनाने और इसे चलाने में कामयाब रहे! आइए किसी तरह के परीक्षण को तोड़ने की कोशिश करें और आउटपुट को देखें:

एक्शन इंटरफ़ेस में टेस्ट क्रैश

परीक्षण विफल रहे। संकेतक लाल हो गया और यहां तक ​​कि मेल में एक सूचना भी मिली। आपको क्या चाहिए! लक्ष्य योजना के 8 में से 3 बिंदुओं को पूरा किया जा सकता है। अब हमारे डॉकटर छवियों के संयोजन, भंडारण से निपटने का प्रयास करें।

नोट! आगे हमें एक डॉकटर खाते की आवश्यकता है

सबसे पहले, हम एक सरल डॉकरफाइल लिखेंगे जिसमें हमारे आवेदन को निष्पादित किया जाएगा।

 #     FROM python:3.8-alpine #        /app  COPY ./ /app #    RUN apk update && pip install -r /app/requirements.txt --no-cache-dir #   (  Distutils) RUN pip install -e /app #      EXPOSE 8080 #       CMD web_server #    distutils      #CMD python /app/src/app.py 

कंटेनर को हब पर भेजने के लिए, डॉकटर को लॉग इन करना आवश्यक होगा, लेकिन जब से मैं पूरी दुनिया को खाते के लिए पासवर्ड नहीं सीखना चाहता हूं, मैं गिटहब में निर्मित रहस्यों का उपयोग करूंगा। सामान्य तौर पर, केवल पासवर्ड को रहस्यों में डाला जा सकता है, और बाकी को * .yaml में हार्डकोड किया जाएगा, और यह काम करेगा। लेकिन मैं बदलाव के बिना अपने कार्यों को कॉपी-पेस्ट करना चाहता हूं, और रहस्यों से सभी विशिष्ट जानकारी खींचना चाहता हूं।

जीथब राज

DOCKER_LOGIN - hub.docker.com में लॉगिन करें
DOCKER_PWD - पासवर्ड
DOCKER_NAME - इस परियोजना के लिए docker रिपॉजिटरी का नाम (अग्रिम में बनाया जाना चाहिए)

ठीक है, तैयारी हो गई है, अब अपनी दूसरी कार्रवाई बनाते हैं:

 $ touch .github/workflows/pub_on_release.yaml 

हम लॉन्च ट्रिगर के अपवाद के साथ पिछली कार्रवाई से परीक्षण की प्रतिलिपि बनाते हैं (मुझे नहीं पता था कि कार्यों को कैसे आयात किया जाए)। हम इसे "लॉन्च पर लॉन्च" से बदलते हैं:

 on: release: types: [published] 

महत्वपूर्ण! यह सही स्थिति बनाने के लिए बहुत महत्वपूर्ण है
उदाहरण के लिए, यदि on.release प्रकार निर्दिष्ट नहीं करता है, तो यह घटना कम से कम 2 घटनाओं को ट्रिगर करती है: प्रकाशित और बनाई गई। यानी 2 विधानसभा प्रक्रियाएं तुरंत शुरू की जाएंगी।

अब उसी फ़ाइल में हम पहले के आधार पर एक और कार्य करेंगे:

 build_and_pub: needs: [run_tests] 

जरूरतों - का कहना है कि यह कार्य तब तक शुरू नहीं होगा जब तक run_tests समाप्त नहीं होती

महत्वपूर्ण! यदि आपके पास कई एक्शन फाइलें हैं, और उनके भीतर कई कार्य हैं, तो वे सभी अलग-अलग वातावरण में एक साथ चलते हैं। प्रत्येक कार्य के लिए एक अलग वातावरण बनाया जाता है, अन्य कार्यों से स्वतंत्र। यदि आप आवश्यकताओं को निर्दिष्ट नहीं करते हैं, तो परीक्षण कार्य और विधानसभाओं को एक साथ और स्वतंत्र रूप से लॉन्च किया जाएगा।

पर्यावरण चर जोड़ें जिसमें हमारे रहस्य होंगे:

 env: LOGIN: ${{ secrets.DOCKER_LOGIN }} NAME: ${{ secrets.DOCKER_NAME }} 

अब हमारे कार्य के चरण, उनमें हमें डॉकटर में लॉग इन करना होगा, कंटेनर को इकट्ठा करना होगा और इसे रजिस्ट्री में प्रकाशित करना होगा:

 steps: - name: Login to docker.io run: echo ${{ secrets.DOCKER_PWD }} | docker login -u ${{ secrets.DOCKER_LOGIN }} --password-stdin - uses: actions/checkout@master - name: Build image run: docker build -t $LOGIN/$NAME:${GITHUB_REF:11} -f Dockerfile . - name: Push image to docker.io run: docker push $LOGIN/$NAME:${GITHUB_REF:11} 

$ {GITHUB_REF: 11} एक github वैरिएबल है जो उस घटना के संदर्भ में एक पंक्ति संग्रहीत करता है जिसके लिए ट्रिगर ने काम किया है (शाखा का नाम, टैग, आदि), अगर हमारे पास "v0.0.0" प्रारूप का टैग है, तो आपको पहले 11 को ट्रिम करने की आवश्यकता है वर्ण, फिर "0.0.0" रहता है।

कोड को पुश करें और एक नया टैग बनाएं। और हम देखते हैं कि हमारे कंटेनर को सफलतापूर्वक इकट्ठा किया गया था और रजिस्ट्री को भेजा गया था, और हमने कहीं भी अपना पासवर्ड नहीं दिखाया।

एक्शन इंटरफ़ेस में बिल्ड और शिप कंटेनर

हब की जाँच करें:

कंटेनर डूकर हब में संग्रहीत

सब कुछ काम करता है, लेकिन सबसे मुश्किल काम रहता है - तैनाती। यहां आपको पहले से ही एक वीपीएस और एक सफेद आईपी पते की आवश्यकता होगी जहां हम कंटेनर को तैनात करेंगे और जहां आप हुक भेज सकते हैं। सिद्धांत रूप में, वीपीएस या होम सर्वर के किनारे, आप ताज पर एक स्क्रिप्ट चला सकते हैं, जो एक नई छवि के मामले में इसे आग देगा, या किसी तरह टेलीग्राम बॉट के साथ खेलेंगे। निश्चित रूप से ऐसा करने के कई तरीके हैं। लेकिन मैं बाहरी आईपी के साथ काम करूंगा। स्मार्ट नहीं होने के लिए, मैंने फ्लास्क में एक साधारण एपीआई के साथ एक छोटी वेब सेवा लिखी।
संक्षेप में, 1 समापन बिंदु "/" है।
एक GET अनुरोध मेजबान पर सभी सक्रिय कंटेनरों के साथ जौन देता है।
POST - प्रारूप में डेटा प्राप्त करता है:

 { "owner": "  ", "repository": "  ", "tag": "v0.0.1", #    "ports": {"8080": 8080, “443”: 443} #      } 

मेजबान पर क्या होता है:

1. प्राप्त json से एक नई छवि का नाम
2. एक नई छवि उभड़ा हुआ है
3. यदि चित्र डाउनलोड किया गया है, तो वर्तमान कंटेनर को रोक दिया जाता है और हटा दिया जाता है
4. बंदरगाहों के प्रकाशन (-p ध्वज) के साथ एक नया कंटेनर लॉन्च किया गया है

Docker के साथ सभी कार्य docker-py लाइब्रेरी का उपयोग करके किया जाता है

इंटरनेट पर इस तरह की सेवा को बिना किसी न्यूनतम सुरक्षा के प्रकाशित करना बहुत गलत होगा, और मैंने एपीआई कुंजी का एक सादृश्य बनाया, सेवा पर्यावरण चर से टोकन पढ़ती है, और फिर हेडर के साथ तुलना करती है {प्राधिकरण: CI_RKEN}

 # coding=utf-8 import os import sys import logging import logging.config import logging.handlers from flask import Flask from flask import request, jsonify import docker log = logging.getLogger(__name__) app = Flask(__name__) docker_client = docker.from_env() MY_AUTH_TOKEN = os.getenv('CI_TOKEN', None) #       def init_logging(): """   :return: """ log_format = f"[%(asctime)s] [ CI/CD server ] [%(levelname)s]:%(name)s:%(message)s" formatters = {'basic': {'format': log_format}} handlers = {'stdout': {'class': 'logging.StreamHandler', 'formatter': 'basic'}} level = 'INFO' handlers_names = ['stdout'] loggers = { '': { 'level': level, 'propagate': False, 'handlers': handlers_names }, } logging.basicConfig(level='INFO', format=log_format) log_config = { 'version': 1, 'disable_existing_loggers': False, 'formatters': formatters, 'handlers': handlers, 'loggers': loggers } logging.config.dictConfig(log_config) def get_active_containers(): """     :return: """ containers = docker_client.containers.list() result = [] for container in containers: result.append({ 'short_id': container.short_id, 'container_name': container.name, 'image_name': container.image.tags, 'created': container.attrs['Created'], 'status': container.status, 'ports': container.ports, }) return result def get_container_name(item: dict) -> [str, str]: """   image  POST  :param item: :return: """ if not isinstance(item, dict): return '' owner = item.get('owner') repository = item.get('repository') tag = item.get('tag', 'latest').replace('v', '') if owner and repository and tag: return f'{owner}/{repository}:{tag}', repository if repository and tag: return f'{repository}:{tag}', repository return '', '' def kill_old_container(container_name: str) -> bool: """    ,   :param container_name: :return: """ try: #    container = docker_client.containers.get(container_name) #  container.kill() except Exception as e: #       log.warning(f'Error while delete container {container_name}, {e}') return False finally: #   ,     log.debug(docker_client.containers.prune()) log.info(f'Container deleted. container_name = {container_name}') return True def deploy_new_container(image_name: str, container_name: str, ports: dict = None): try: #   image  docker hub'a log.info(f'pull {image_name}, name={container_name}') docker_client.images.pull(image_name) log.debug('Success') kill_old_container(container_name) log.debug('Old killed') #    docker_client.containers.run(image=image_name, name=container_name, detach=True, ports=ports) except Exception as e: log.error(f'Error while deploy container {container_name}, \n{e}') return {'status': False, 'error': str(e)}, 400 log.info(f'Container deployed. container_name = {container_name}') return {'status': True}, 200 @app.route('/', methods=['GET', 'POST']) def MainHandler(): """ GET -      POST -      : { "owner": "gonfff", "repository": "ci_example", "tag": "v0.0.1", "ports": {"8080": 8080} } :return: """ if request.headers.get('Authorization') != MY_AUTH_TOKEN: return jsonify({'message': 'Bad token'}), 401 if request.method == 'GET': return jsonify(get_active_containers()) elif request.method == 'POST': log.debug(f'Recieved {request.data}') image_name, container_name = get_container_name(request.json) ports = request.json.get('ports') if request.json.get('ports') else None result, status = deploy_new_container(image_name, container_name, ports) return jsonify(result), status def main(): init_logging() if not MY_AUTH_TOKEN: log.error('There is no auth token in env') sys.exit(1) app.run(host='0.0.0.0', port=5000) if __name__ == '__main__': main() 

इस एप्लिकेशन के लिए, मैंने इसे सिस्टम पर इंस्टॉल करने के लिए setup.py भी किया। आप इसका उपयोग करके स्थापित कर सकते हैं:

 $ python3 setup.sy install 

बशर्ते कि आपने फ़ाइलें डाउनलोड कर ली हैं और इस एप्लिकेशन की निर्देशिका में हैं।
स्थापना के बाद, आपको एप्लिकेशन को एक सेवा के रूप में सक्षम करना होगा ताकि यह सर्वर रिबूट के मामले में स्वयं शुरू हो, इसके लिए हम सिस्टम का उपयोग करते हैं
यहाँ एक उदाहरण विन्यास फाइल है:

 [Unit] Description=Deployment web server After=network-online.target [Service] Type=simple RestartSec=3 ExecStart=/usr/local/bin/ci_example Environment=CI_TOKEN=#<I generate it with $(openssl rand -hex 20)> [Install] WantedBy=multi-user.target 

यह केवल इसे चलाने के लिए बनी हुई है:

 $ sudo systemctl daemon-reload $ sudo systemctl enable ci_example.service $ sudo systemctl start ci_example.service 

आप कमांड का उपयोग करके वेब डिलीवरी सर्वर का लॉग देख सकते हैं

 $ sudo systemctl status ci_example.service 

सर्वर भाग तैयार है, यह केवल हमारी कार्रवाई के लिए एक हुक जोड़ने के लिए बना हुआ है। ऐसा करने के लिए, हमारे सर्वर के आईपी पते और CI_TOKEN के रहस्यों को जोड़ें जो हमने एप्लिकेशन इंस्टॉल करते समय उत्पन्न किए थे।
पहले तो मैं जीथब मार्केटप्लेस से कर्ल के लिए तैयार किए गए एक्शन का उपयोग करना चाहता था, लेकिन दुर्भाग्य से, यह POST अनुरोध के शरीर से उद्धरणों को हटा देता है, जिससे json को पार्स करना असंभव हो गया। यह स्पष्ट रूप से मेरे अनुकूल नहीं था, और मैंने उबंटू में निर्मित कर्ल (जिस पर मैं कंटेनर इकट्ठा करता है) का उपयोग करने का फैसला किया, जो संयोगवश प्रदर्शन पर सकारात्मक प्रभाव डालता था, क्योंकि इसके लिए अतिरिक्त कंटेनर के संयोजन की आवश्यकता नहीं होती है:

 deploy: needs: [build_and_pub] runs-on: [ubuntu-latest] steps: - name: Set tag to env run: echo ::set-env name=TAG::$(echo ${GITHUB_REF:11}) - name: Send webhook for deploy run: "curl --silent --show-error --fail -X POST ${{ secrets.DEPLOYMENT_SERVER }} -H 'Authorization: ${{ secrets.DEPLOYMENT_TOKEN }}' -H 'Content-Type: application/json' -d '{\"owner\": \"${{ secrets.DOCKER_LOGIN }}\", \"repository\": \"${{ secrets.DOCKER_NAME }}\", \"tag\": \"${{ env.TAG }}\", \"ports\": {\"8080\": 8080}}'" 

नोट: - स्विच स्विच को निर्दिष्ट करना बहुत महत्वपूर्ण है, अन्यथा कोई भी अनुरोध सफल होगा, भले ही प्रतिक्रिया में कोई त्रुटि प्राप्त हुई हो।
यह भी ध्यान देने योग्य है कि अनुरोध में उपयोग किए जाने वाले चर वास्तव में चर नहीं हैं, लेकिन विशेष कार्यों को GITHUB_REF के अपवाद के साथ बुलाया जाता है, यही कारण है कि लंबे समय तक मुझे समझ नहीं आया कि अनुरोध सही तरीके से काम क्यों नहीं कर रहा था। लेकिन इससे एक फंक्शन बना, सब कुछ काम कर गया।

 name: Publish on Docker Hub and Deploy on: release: types: [published] #       jobs: run_tests: #          runs-on: [ubuntu-latest] steps: #   - uses: actions/checkout@master #  python   - uses: actions/setup-python@v1 with: python-version: '3.8' architecture: 'x64' - name: Install requirements #   run: pip install -r requirements.txt - name: Run tests #   run: coverage run src/tests.py - name: Tests report run: coverage report build_and_pub: #      needs: [run_tests] runs-on: [ubuntu-latest] env: LOGIN: ${{ secrets.DOCKER_LOGIN }} NAME: ${{ secrets.DOCKER_NAME }} steps: - name: Login to docker.io #     docker.io run: echo ${{ secrets.DOCKER_PWD }} | docker login -u ${{ secrets.DOCKER_LOGIN }} --password-stdin #   - uses: actions/checkout@master - name: Build image #  image        hub.docker .. login/repository:version run: docker build -t $LOGIN/$NAME:${GITHUB_REF:11} -f Dockerfile . - name: Push image to docker.io #    registry run: docker push $LOGIN/$NAME:${GITHUB_REF:11} deploy: #         registry,      #    curl   needs: [build_and_pub] runs-on: [ubuntu-latest] steps: - name: Set tag to env run: echo ::set-env name=RELEASE_VERSION::$(echo ${GITHUB_REF:11}) - name: Send webhook for deploy run: "curl --silent --show-error --fail -X POST ${{ secrets.DEPLOYMENT_SERVER }} -H 'Authorization: ${{ secrets.DEPLOYMENT_TOKEN }}' -H 'Content-Type: application/json' -d '{\"owner\": \"${{ secrets.DOCKER_LOGIN }}\", \"repository\": \"${{ secrets.DOCKER_NAME }}\", \"tag\": \"${{ env.RELEASE_VERSION }}\", \"ports\": {\"8080\": 8080}}'" 

ठीक है, हमने इसे एक साथ रखा है, अब हम एक नई रिलीज़ बनाएंगे और क्रियाओं को देखेंगे।

अनुप्रयोग अनुप्रयोग इंटरफ़ेस परिनियोजन के लिए Webhook

सब कुछ बदल गया, हम तैनाती सेवा के लिए एक GET अनुरोध करते हैं (मेजबान पर सभी सक्रिय कंटेनर प्रदर्शित करता है):

वीपीएस कंटेनर पर तैनात

अब हम अपने तैनात आवेदन के लिए अनुरोध भेजेंगे:

तैनात कंटेनर के लिए अनुरोध प्राप्त करें

तैनात कंटेनर के लिए पोस्ट अनुरोध

निष्कर्ष
GitHub Actions एक बहुत ही सुविधाजनक और लचीला उपकरण है जिसके साथ आप कई ऐसे काम कर सकते हैं जो आपके जीवन को सरल बना सकते हैं। यह सब कल्पना पर निर्भर करता है।
वे सेवाओं के साथ एकीकरण परीक्षण का समर्थन करते हैं।
इस परियोजना की एक तार्किक निरंतरता के रूप में, आप कंटेनर को लॉन्च करने के लिए कस्टम मापदंडों को पारित करने की क्षमता को जोड़ने के लिए जोड़ सकते हैं।
भविष्य में जब मैं अध्ययन और k8 के साथ प्रयोग करूँ तो पतवार चार्ट की तैनाती के लिए इस परियोजना को एक आधार के रूप में लेने की कोशिश करूँगा

यदि आपके पास किसी प्रकार का होम प्रोजेक्ट है, तो GitHub Actions रिपॉजिटरी के साथ काम करना बहुत सरल कर सकता है।

सिंटेक्स विवरण यहाँ पाया जा सकता है।
सभी परियोजना स्रोत