Un soir, en rentrant du travail, j'ai décidé de faire un peu de devoirs. J'ai fait plusieurs modifications et j'ai immédiatement voulu les expérimenter. Mais avant les expériences, je devais aller dans le VPS, pousser les changements, reconstruire le conteneur et l'exécuter. J'ai alors décidé qu'il était temps de s'occuper de la livraison continue.
Au départ, j'avais le choix entre Circle CI, Travis ou Jenkins. J'ai exclu Jenkins presque immédiatement en raison du manque de besoin d'un outil aussi puissant. Après une lecture rapide de Travis, je suis arrivé à la conclusion qu'il est pratique de l'assembler et de le tester, mais vous ne pouvez pas imaginer de livraison avec. J'ai découvert Circle CI grâce à des publicités trop intrusives sur YouTube. J'ai commencé à expérimenter avec des exemples, mais à un moment donné je me suis trompé et j'ai eu des tests éternels, ce qui m'a pris beaucoup de précieuses minutes de montage (en général, il y a une limite suffisante pour ne pas s'inquiéter, mais ça m'a frappé). Reprenant la recherche, je suis tombé sur Github Actions. Après avoir joué avec les exemples de prise en main, j'ai eu une impression positive et après un rapide coup d'œil à la documentation, je suis arrivé à la conclusion qu'il est très cool de pouvoir garder des secrets pour l'assemblage, collecter et déployer pratiquement des projets en un seul endroit. Avec des yeux brillants, il dessina rapidement le schéma souhaité et les engrenages tournèrent.
Tout d'abord, nous allons essayer de faire le test. À titre expérimental, j'ai écrit un serveur Web simple sur Flask avec 2 points de terminaison:
Lister une application Web simplefrom 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()
Et quelques tests:
Liste des tests d'application 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() ) 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() : 'test'}) 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() : 'entrée mauvaise'}) 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()
Sortie de couverture:
coverage report Name Stmts Miss Cover ------------------------------------------------------------------ src/app.py 28 2 93% src/tests.py 37 0 100% ------------------------------------------------------------------ TOTAL 65 2 96%
Créez maintenant notre première action, qui exécutera les tests. Selon la documentation, toutes les actions doivent être stockées dans un répertoire spécial:
$ mkdir -p .github/workflows $ touch .github/workflows/test_on_push.yaml
Je veux que cette action s'exécute sur n'importe quel événement push dans n'importe quelle branche, à l'exception des versions (balises, car il y aura des tests séparés):
on: push: tags: - '!refs/tags/*' branches: - '*'
Ensuite, nous créons une tâche qui s'exécutera dans la dernière version disponible d'Ubuntu:
jobs: run_tests: runs-on: [ubuntu-latest]
Dans les étapes, nous allons vérifier le code, installer python, installer les dépendances, exécuter les tests et afficher la couverture:
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 en 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
Tous ensemble 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
Essayons de créer un commit et voyons comment fonctionne notre action.
Réussite des tests dans l'interface Actions
Hourra, nous avons réussi à créer la première action et à l'exécuter! Essayons de casser une sorte de test et regardons la sortie:
Les tests se bloquent dans l'interface Actions
Les tests ont échoué. L'indicateur est devenu rouge et a même reçu une notification par courrier. Ce dont vous avez besoin! 3 points sur 8 du programme cible peuvent être considérés comme remplis. Essayons maintenant de traiter l'assemblage, le stockage de nos images de docker.
Remarque! Ensuite, nous avons besoin d'un compte Docker
Tout d'abord, nous allons écrire un Dockerfile simple dans lequel notre application sera exécutée.
Dockerfile # 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 les # 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 répertoire # 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
Pour envoyer un conteneur au hub, il sera nécessaire de se connecter au docker, mais comme je ne veux pas que le monde entier apprenne le mot de passe du compte, je vais utiliser les secrets intégrés à GitHub. En général, seuls les mots de passe peuvent être mis dans des secrets, et le reste sera codé en dur dans * .yaml, et cela fonctionnera. Mais je voudrais copier-coller mes actions sans changements, et extraire toutes les informations spécifiques des secrets.
Github Secrets
DOCKER_LOGIN - connectez-vous sur hub.docker.com
DOCKER_PWD - Mot de passe
DOCKER_NAME - nom du référentiel docker pour ce projet (doit être créé à l'avance)
D'accord, la préparation est terminée, créons maintenant notre deuxième action:
$ touch .github/workflows/pub_on_release.yaml
Nous copions les tests de l'action précédente, à l'exception du déclencheur de lancement (je n'ai pas trouvé comment importer les actions). Nous le remplaçons par «Launch on release»:
on: release: types: [published]
IMPORTANT! Il est très important de faire la bonne condition sur.
Par exemple, si on.release ne spécifie pas de types, cet événement déclenche au moins 2 événements: publié et créé. Autrement dit, 2 processus d'assemblage seront lancés immédiatement.
Maintenant, dans le même fichier, nous ferons une autre tâche en fonction du premier:
build_and_pub: needs: [run_tests]
besoins - indique que cette tâche ne démarrera pas avant la fin de run_tests
IMPORTANT! Si vous avez plusieurs fichiers avec l'action, et dans quelques problèmes ils commencent tous en même temps dans des environnements différents. Un environnement distinct est créé pour chaque tâche, indépendamment des autres tâches. si vous ne spécifiez pas de besoins, la tâche de test et les assemblages seront lancés simultanément et indépendamment les uns des autres.
Ajoutez des variables d'environnement dans lesquelles nos secrets seront:
env: LOGIN: ${{ secrets.DOCKER_LOGIN }} NAME: ${{ secrets.DOCKER_NAME }}
Maintenant, les étapes de notre tâche, en elles, nous devons nous connecter au docker, collecter le conteneur et le publier dans le registre:
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} est une variable github qui stocke une ligne avec une référence à l'événement pour lequel le déclencheur a fonctionné (nom de branche, balise, etc.), si nous avons des balises au format "v0.0.0" alors vous devez couper les 11 premiers caractères, "0.0.0" reste.
Poussez le code et créez une nouvelle balise. Et nous voyons que notre conteneur a été assemblé avec succès et envoyé au registre, et nous n'avons allumé notre mot de passe nulle part.
Créer et expédier un conteneur dans l'interface Actions
Vérifiez le moyeu:
Conteneur stocké dans le docker hub
Tout fonctionne, mais la tâche la plus difficile reste - le déploiement. Ici, vous aurez déjà besoin d'un VPS et d'une adresse IP blanche où nous déploierons le conteneur et où vous pourrez envoyer le crochet. En théorie, du côté du VPS ou du serveur domestique, vous pouvez exécuter un script sur la couronne, qui dans le cas d'une nouvelle image la déclencherait, ou jouer d'une manière ou d'une autre avec le bot de télégramme. Il y a probablement plusieurs façons de procéder. Mais je vais travailler avec une adresse IP externe. Afin de ne pas être intelligent, j'ai écrit un petit service web dans Flask avec une API simple.
En bref, il y a point final 1 « / ».
Une demande GET renvoie json avec tous les conteneurs actifs sur l'hôte.
POST - reçoit les données au format:
{ "owner": " ", "repository": " ", "tag": "v0.0.1", # "ports": {"8080": 8080, “443”: 443} # }
Que se passe-t-il sur l'hôte:
- du json reçu le nom de la nouvelle image est recueilli
- une nouvelle image est bombée
- si l'image a été téléchargée, le conteneur actuel est arrêté et supprimé
- un nouveau conteneur est lancé, avec la publication des ports (drapeau -p)
Tout le travail avec docker se fait à l'aide de la bibliothèque docker-py
Il serait très erroné de publier un tel service sur Internet sans aucune protection minimale, et j'ai créé un semblant de clé API, le service lit le jeton à partir des variables d'environnement, puis le compare avec l'en-tête {Autorisation: CI_TOKEN}
Liste des serveurs Web pour le déploiement
Pour cette application, j'ai également fait setup.py pour l'installer sur le système. Vous pouvez l'installer en utilisant:
$ python3 setup.sy install
à condition que vous ayez téléchargé les fichiers et que vous soyez dans le répertoire de cette application.
Après l'installation, vous devez activer l'application en tant que service afin qu'elle démarre d'elle-même en cas de redémarrage du serveur, pour cela nous utilisons systemd
Voici un exemple de fichier de configuration:
[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
Il ne reste plus qu'à l'exécuter:
$ sudo systemctl daemon-reload $ sudo systemctl enable ci_example.service $ sudo systemctl start ci_example.service
Vous pouvez afficher le journal du serveur de diffusion Web à l'aide de
$ sudo systemctl status ci_example.service
La partie serveur est prête, il ne reste plus qu'à ajouter un hook à notre action. Pour ce faire, ajoutez les secrets de l'adresse IP de notre serveur et du CI_TOKEN que nous avons généré lors de l'installation de l'application.
Au début, je voulais utiliser une action prête à l'emploi pour curl sur le marché github, mais malheureusement, cela supprime les citations du corps de la demande POST, ce qui a rendu impossible l'analyse de json. Cela ne me convenait évidemment pas, et j'ai décidé d'utiliser la boucle intégrée dans ubuntu (sur laquelle je collecte des conteneurs), ce qui a d'ailleurs eu un effet positif sur les performances, car elle ne nécessite pas l'assemblage d'un conteneur supplémentaire:
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}}'" = TAG :: $ (echo $ {GITHUB_REF: 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}}'"
Remarque: il est très important de spécifier le commutateur --fail, sinon toute demande réussira, même si une erreur a été reçue en réponse.
Il convient également de noter que les variables utilisées dans la demande ne sont pas vraiment des variables, mais des fonctions spéciales appelées à l'exception de GITHUB_REF, c'est pourquoi pendant longtemps je n'ai pas pu comprendre pourquoi la demande ne fonctionnait pas correctement. Mais après en avoir fait une fonction, tout a fonctionné.
Action construit et déploie 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}}'" ] 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}}'" - 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}}'" l' 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}}'"
D'accord, nous avons rassemblé tous ensemble, créer maintenant une nouvelle version et de regarder les jeux d'action.
Interface Webhook pour l'application Actions de déploiement
Tout s'est avéré, nous faisons une requête GET au service de déploiement (affiche tous les conteneurs actifs sur l'hôte):
Déployé sur le conteneur VPS
Nous allons maintenant envoyer des demandes à notre application déployée:
GET demande de déploiement d' un conteneur
Demande POST au conteneur déployé
Conclusions
GitHub Actions est un outil très pratique et flexible avec lequel vous pouvez faire beaucoup de choses qui peuvent grandement vous simplifier la vie. Tout dépend de l'imagination.
Ils prennent en charge les tests d'intégration avec les services.
Comme suite logique de ce projet, vous pouvez ajouter à webhook la possibilité de passer des paramètres personnalisés pour lancer le conteneur.
À l'avenir, j'essaierai de prendre comme base ce projet de déploiement de cartes de barre lorsque j'étudierai et expérimenterai avec des k8
Si vous avez une sorte de projet personnel, les actions GitHub peuvent simplifier considérablement le travail avec le référentiel.
Les détails de la syntaxe peuvent être trouvés ici.
Toutes les sources de projets