Transcription
1. Intro: Go est un langage back-end incroyablement
puissant qui peut être un atout pour le kit d'outils de
tout développeur C'est performant. Il a intégré sérialisation et la
désérialisation JSON, il
intègre des tests et bien plus encore. Dans ce cours,
nous allons repartir de zéro, en
créant un nouveau dossier, élaborant un projet G, en
écrivant tout le code correspondant, en
écrivant des tests pour le écrivant des tests pour Dockerisation de l'application,
puis finalement
automatisation d'un pipeline CICD de test
et de création de
flux de travail avec CircleCI À la fin du
cours, j'espère que vous aurez un
aperçu pratique et pratique de la façon dont vous pouvez créer des applications go
dockerisées,
y compris J'espère que vous vous joindrez à
moi dans ce cours, Go for real world applications.
2. Pourquoi aller: Avant même de commencer à
parler de ce que notre application va
faire ou de toute autre programmation, je voudrais expliquer rapidement pourquoi nous avons même choisi G comme langue de
choix. Alors pourquoi choisirions-nous G ? Tout d'abord, il est
extrêmement performant. À ce stade, j'ai écrit au
moins une douzaine d'applications
Go, et
je n'ai jamais eu besoin de rechercher quelconque problème de condition de course
ou de performance. Et l'une d'entre elles était une API
pour une start-up assez importante. Nous avions environ 10 000 utilisateurs
et, à certains moments, 1 000
à 2 000 utilisateurs simultanés. Et même à cette époque, nous n'avons jamais eu
de problèmes de performances majeurs, et cela s'exécutait sur une machine virtuelle à
quatre cœurs. Go est également extrêmement compact. Ainsi, l'application s'exécute
généralement à partir d'un seul fichier
principal point go, et cela peut être fait simplement en émettant go run main point go. Comme nous le verrons plus loin dans
le cours, c'est extrêmement puissant lorsque nous voulons
dockeriser notre application Il est très simple de transporter
et d'exécuter une application Go. Go est également extrêmement testable. Il dispose d'un
framework de test intégré. Nous importerions donc
ce package de test. Nous transmettons cela à
notre fonction de test. Ensuite, il suffit d' appeler la fonction
que nous voulons tester. Et dans ce cas, j'ai renvoyé une erreur
à partir de cette fonction. Si l'erreur n'est pas nulle, c'est « go for not
null » ou « empty ». Ensuite, nous utilisons ce pointeur
vers le framework de test, et nous émettons une erreur.
C'est donc intégré. Nous n'avons besoin d'aucune configuration
externe. Nous n'avons pas besoin de bibliothèques
externes. Il est intégré au langage. Go est également extrêmement convivial
pour les API. J'ai donc un exemple ici pour vous
montrer comment cela fonctionne dans Go. Donc, si nous
supposons que nous avons une sorte de réponse JSON provenant
d'une API comme celle-ci, nous pouvons utiliser le package JSON
ainsi que l'identifiant JSON
lorsque nous définissons un type ici, appelons une API,
c'est une structure. Et nous savons que
notre réponse a un certain type int et
un tableau de chaînes. C'est un tableau de chaînes. Nous utilisons cet identifiant JSON. Maintenant, la magie
opère lorsque nous utilisons ces identifiants et que nous utilisons
le package JSON intégré Supposons que
nous ayons déjà la réponse de l'API, une
sorte de résultat binaire Nous pouvons simplement appeler JSON
Unmarshal et Golang sérialisera
ce résultat binaire dans Et lorsqu'il voit ces clés, il sait qu'il doit mettre ces valeurs dans chacune de
ces parties de cette structure. Ensuite, nous avons supposé
qu'il n'y avait aucune erreur, rassemblant la
réponse. Si nous déconnectons un int,
nous en obtiendrions cinq et
si nous faisions une nous en obtiendrions cinq et boucle sur le
tableau de chaînes, nous obtiendrions les A, B
et C. Encore une fois, nous n'avons pas besoin de
fichiers de configuration, de bibliothèques externes Nous utilisons simplement la bibliothèque
JSON intégrée avec la méthode
Unmarshal, et Golang gère
toute la sérialisation
et la désérialisation du
JSON dès la sortie de la boîte Les déplacements sont également extrêmement uniformes. Ainsi, lorsque vous écrivez, utilisez
un éditeur de code moderne
tel que Visual Studio Code, go met en forme lors de la sauvegarde
selon ses propres règles intégrées. Cela signifie que
peu importe où vous
lisez le code G, il
s'agisse d'un package
externe,
d'un package tiers code de
vos coéquipiers, vous verrez toujours
les mêmes modèles, indentations et
espacements sur n'importe quel code G. Cela permet de
lire très facilement les autres projets Go. Cela vous permet également, à vous et à
votre équipe, d'éviter de débattre des règles de formatage telles que les onglets, les espaces
et toutes ces choses Ces règles sont également
intégrées au langage Go. Donc en résumé, G est
très performant. Il est très rapide, du moins d'après toutes les expériences que j'ai
eues avec lui, il est très compact. Vous n'avez besoin que de votre
seul point principal pour le fichier. C'est facilement testable. Les tests sont fournis avec
le langage lui-même. Il est très convivial pour les API. Cette sérialisation
et cette désérialisation JSON également prêtes
à l'emploi avec
le langage, et elles Ces règles de formatage et de
formatage sont
également incluses dans le langage l'ensemble, G est un choix très judicieux pour tout logiciel principal que
vous pourriez avoir besoin de créer. Ainsi, avec un aperçu
de base de ce qu'est G et de
certains de ses avantages,
dans la leçon suivante, nous pouvons commencer à
examiner l'application
que nous allons créer, puis nous pouvons enfin commencer
à coder l'application.
3. API Allergy: ce cours, nous
allons créer une application qui nous envoie
des messages et nous
avertit quotidiennement des niveaux de
pollen attendus dans l'air. Si vous êtes comme moi, il se peut
que vous souffriez du rhume des foins entre la
mi-mai et la mi-juin de chaque année, moins dans l'
hémisphère nord. Et ne t'inquiète pas. Même si vous n'avez aucune
allergie, je vous promets que le contenu
et les modèles de ce cours sont extrêmement utiles,
quel que soit le type d'
application Go que vous utilisez. Donc, là où je vis en Autriche, l'
université de médecine de Vienne possède un excellent site qui prédit les
niveaux de pollen pour la journée explorant et en inspectant les
appels d'API pour ce site, j'ai trouvé les points de terminaison qui
produisent toutes les données Il y a principalement deux points de terminaison
que nous utiliserons. La première consiste à obtenir des données de charge
horaire, qui ont une
clé de réussite et le résultat. Plus important encore,
voici ce tableau horaire. Donc, pour chaque heure, cela donnera une valeur attendue
du pollen dans l'air, comprise entre zéro et, je crois, huit ou neuf. Le deuxième point de terminaison
que nous
utiliserons dans ce cours est
d'obtenir des données cartographiques actuelles. Nous utiliserons celui-ci
pour les moyennes historiques. Comme vous pouvez le voir
ici, nous avons également une clé de réussite. Nous
avons quelques résultats. Et pour chaque résultat, nous avons une date, la date
actuelle ou, dans ce cas, ce qui s'est réellement passé
à cette date cette année, puis la moyenne historique. Cependant, nous sommes le 16 mai en ce
moment, et comme vous pouvez le voir, le courant est nul, et même pour hier,
le courant est nul. Ces données sont donc un
peu retardées. Cependant, comme je l'ai mentionné, nous l'utiliserons principalement
pour les valeurs moyennes. Nous allons donc envoyer à la
fois la valeur attendue pour la journée à partir de ces données horaires et également la
moyenne historique de la journée. Ainsi, avec un aperçu
et une idée de ce que
sera notre application dans la prochaine leçon, nous aborderons brièvement les exigences
techniques que nous voulons que notre application remplisse, puis nous pourrons enfin
commencer à écrire du code.
4. Exigences d'application: Lors de la dernière leçon, nous avons examiné l'API sur les allergies que nous
allions utiliser et la provenance de
ces données. Dans cette leçon, nous
aborderons brièvement les exigences de l'application à un niveau plus technique avant
de commencer à coder. de vue du
flux d'applications,
à une heure quotidienne spécifiée,
nous voulons donc à une heure quotidienne spécifiée, point de vue du
flux d'applications,
à une heure quotidienne spécifiée,
nous voulons donc appeler ces paramètres
d'allergie Nous allons analyser
cette réponse JSON de chaque appel, puis effectuer travail de
formatage
pour la transformer en un joli message
lisible par l'homme Enfin, nous voulons envoyer ce gentil message
via les webhooks de Slack Toutes les fonctions que nous
écrivons doivent être testées. L'application doit être
exécutée à partir d'un conteneur Docker. Le conteneur Docker doit être redémarré en cas
de panne ou de crash Un pipeline automatisé doit être créé pour exécuter tous
les tests que nous avons écrits
, puis publier le conteneur
Docker au cas où tous
ces tests seraient réussis Enfin, les
différentes valeurs importantes
utilisées dans l' application,
telles que les points de terminaison de l'API, l'URL du webhook Slack, l'heure de Cron Job et
le fuseau horaire de la tâche
Crown, heure de Cron Job et
le fuseau horaire de la tâche
Crown doivent toutes être configurables Ainsi, tout au long de ce cours, nous aborderons
et répondrons étape par étape à toutes
ces exigences. Dans la leçon suivante,
nous allons enfin
commencer à élaborer
notre application go
5. Install Go et extension Visual Studio Go sion: Commencez, nous devrions tous vérifier que G est installé. Pour vérifier
que G est installé, je vais simplement
publier la version G. Et je peux voir que j'ai G 1,20 0,2. Si cette commande ne
renvoie rien ou une erreur, vous
devez probablement
installer G sur votre système. Vous pouvez accéder à go point dev
slash dClash Install, contient
les instructions
d'installation pour Linux, Mac et Windows Pour le reste
de ce cours, je suppose que
vous codez
avec moi dans le code Visual Studio. Je vous recommande donc également d'installer l'extension G. Pour trouver l'extension G, rendez-vous dans l'
onglet des extensions et recherchez G. Cela devrait être
le premier résultat, et bien sûr, je l'ai
déjà installée. Cette extension est
un guichet unique pour tout ce dont vous avez
besoin pour modifier le code G. Il s'agit d'un inter, d'un
testeur, d'un débogueur
et d'un format combinés pour G. Une fois que vous aurez
installé cette extension, nous pourrons commencer à élaborer notre projet G.
6. Échafaudage du projet: Lors de la dernière leçon, nous nous sommes assurés
que G était installé, et nous avons également installé l'extension
Visual Studio Code G. Nous allons maintenant structurer notre application. Généralement, lorsque vous
démarrez un nouveau projet G, vous créez un nouveau
dossier pour cette application. Dans ce cas, je l'appellerais
Allergy Cron et vous
émettriez le cron DR Allergy Cependant, comme je suis déjà
dans le répertoire des cours, j'ai un dossier ici pour le projet et je n'en
créerai pas un nouveau. L'étape suivante serait alors d' initialiser un module
pour le projet Je prends généralement le même nom
que le nom du dossier lui-même. Dans votre cas, ce
serait un problème d'allergie. Ici, nous allons donc l'initialiser en fonction du nom de
ce dossier La commande pour
initialiser un module G est Gomd init puis, dans
notre cas, Go nous dira qu'il
a créé un nouveau fichier go dot mod. Nous pouvons accéder à ce
fichier gomd et voir ce qu'il contient. Pour l'instant, comme nous n'avons pas installé de package
supplémentaire, il contient juste le nom du module et la version go qui
a été utilisée pour le créer. Ensuite, nous pouvons créer
le fichier principal, c'est-à-dire toucher le point principal. Et si vous n'étiez encore
que dans un environnement terminal, éditeur n'était ouvert. Vous pouvez bien sûr
ouvrir le point principal avec la commande Ouvrir. Ou si vous souhaitez l'ouvrir dans
le code Visual Studio, vous pouvez émettre
le code main point go. Après toute cette configuration, nous sommes enfin prêts à
commencer à écrire du code G.
7. Concevoir le travail de l'utilisateur Job: la dernière leçon,
nous avons élaboré notre nouveau projet G, initialisant un module G, qui nous a laissé
ce fichier go point mod,
et nous avons créé un fichier point go
principal vide Dans cette leçon,
nous allons commencer par aborder la première exigence technique, à savoir qu'
une tâche
cron quotidienne se déclenche exactement
au même moment Chaque fichier go possède une
déclaration de package tout en haut. Dans ce cas, il s'
agit du package Min. Dans ce cas, vous avez peut-être
quelques importations ici. Et dans le cas
du fichier point go principal, nous aurons notre fonction principale, qui est simplement
la fonction principale. Maintenant, pour Crown Jobs et G, j'aime utiliser la populaire bibliothèque
Rob Fig Cron Cette bibliothèque nous
permet également de définir le Cron Job en fonction
d'un fuseau horaire spécifique Donc, je vais d'abord utiliser package horaire de
Go pour
charger le fuseau horaire, puis nous pourrons configurer la
tâche principale dans ce fuseau horaire. Nous obtenons donc un emplacement et une erreur, qui proviennent du
temps, de l'emplacement du chargement. Et comme je suis en Autriche, je veux l'Europe, Vienne. Ensuite, bien sûr, nous
devons vérifier si l'erreur n'est pas nulle, puis nous allons
paniquer avec cette erreur, sinon nous
pouvons continuer. Maintenant, pour configurer un Crown
Job avec ce package, il suffit d'
appeler un nouveau fournisseur avec sa localisation, et nous allons
transmettre cette adresse. Maintenant, nous voyons qu'avec l'inter, dès que je fais
référence à ce cron, l'inter sait quel
paquet je veux utiliser Le seul problème ici est que ce package n'est pas encore
dans notre fichier mod. Donc, si nous survolons
l'importation ici, Go se plaint qu'
aucun module ne fournit
ce package Mais heureusement, le Linter nous
fournit une solution rapide, qui consiste simplement à installer ou à utiliser la commande go get package Donc, si nous cliquons simplement sur
le fait que le package est installé. Vous devriez voir
votre fichier mod modifié, puis nous pourrons
continuer avec notre code ici. Pour ne pas dépasser le chronométrage
réel de Cron, nous devons ajouter Cron Job
point et Funk, ce qui prend l'identifiant cron de
type Unix standard nous devons ajouter Cron Job
point et Funk, ce qui prend
l'identifiant cron de
type Unix standard à six caractères. Et ce sont précisément
les secondes, les minutes, les heures, le jour du mois, le mois lui-même
et le jour de la semaine. Dans notre cas, je pense qu'
une heure raisonnable, du moins pour moi, est 8
h 00 tous les matins. Je vais donc spécifier à la fois zéro
pour les secondes et les minutes, puis huit pour l'heure. Et puis le deuxième paramètre de cette publicité est la fonction que nous voulons
réellement exécuter Et pour l'instant, je vais juste y
mettre une fonction vide. Je peux nettoyer ce commentaire
d'importation, et nous pouvons enregistrer notre fichier. Une autre chose que je tiens
à souligner ici est la
capacité des extensions Visual Studio Go à se formater automatiquement. Donc, si nous avons un espacement
bâclé ici ou quelque chose comme ça,
dès que nous enregistrons, dans mon cas, sur un Mac Command S,
nous constatons que l'inter formate
automatiquement ce Je dois également mentionner que
pour ces fuseaux horaires, ils sont recherchés
à partir de ce on appelle la base de données des fuseaux
horaires de l'Iana. J'ai trouvé un joli site web
appelé Nota time, qui répertorie les
différents fuseaux horaires Ainsi, où que vous soyez
dans le monde, n'hésitez pas à
parcourir ce tableau
et à définir le fuseau horaire en
fonction de l'endroit où vous vous trouvez ou du moment où vous souhaitez que
votre Cron Job se déclenche Nous devons également nous assurer que
notre tâche cron est lancée. Nous avons donc ajouté la fonction, mais nous devons explicitement
appeler cronjob point SAT Et puis, si nous
devions le laisser, lorsque nous exécuterions
la fonction principale, elle s'exécuterait simplement
ici puis sortirait. Nous devons donc bloquer
le thread principal pour que le processus go
continue de
fonctionner afin maintenir cette tâche
cron active après l'avoir
démarrée,
et le cron continuera à fonctionner jusqu'à
chaque jour où il atteindra ce créneau horaire de 8 heures du matin Dans cette leçon, nous avons commencé à
écrire notre fichier point go principal. Nous avons appris que chaque fichier go commence par une déclaration de
package. Ensuite, il y a généralement
quelques importations ,
puis vos fonctions. Dans ce cas, c'est un cas un
peu particulier. Le fichier point go principal
a toujours une fonction principale. Et nous avons commencé à écrire le
corps de notre fonction principale. Nous avons chargé le fuseau horaire de Vienne, et nous avons utilisé ce
fuseau horaire de localisation dans notre tâche cron, et nous avons configuré la tâche Cron pour qu'elle se
déclenche à 8 h 00 tous les jours. Nous avons découvert une fonctionnalité intéressante de
la façon dont le format de
code Visual Studio peut automatiquement corriger et formater
l'indentation de notre code Nous avons également discuté des différentes possibilités
que vous pouvez intégrer à cette fonction de localisation de chargement afin que vous puissiez définir le
fuseau horaire que vous souhaitez. la leçon suivante, nous aborderons création d'une fonction
utilitaire HTTP, afin de commencer à voir
comment nous allons appeler les URL d'API que nous
ajouterons éventuellement dans le corps de la fonction
ici de notre tâche Crown
8. Construire une fonction d'utilitaire HTTP générique: dernière leçon, nous avons
commencé à échafauder notre fichier point go principal et
à configurer la tâche cron qui pourrait lancer nos différentes
tâches à 8 h 00,
dans le fuseau horaire de Vienne. dans Nous allons maintenant écrire une
fonction HTP générique qui sera utilisée à la fois pour les
appels d'API sur les allergies et pour l'envoi de
notre message Slack Maintenant, cette fonction
est assez complexe et utilise les fonctionnalités
génériques de G. Je n'entrerai pas trop dans les détails la façon dont la fonction
a été construite. J'ai un article de
blog distinct qui décrit les détails de
sa mise en œuvre, et vous êtes invités à le lire séparément. Pour commencer à utiliser
cette fonction, nous allons créer un nouveau
dossier appelé Utils et un nouveau fichier appelé make
http request point go Le package ici sera Utils. Et pour notre fonction,
faites une demande HDP. Cela prend un type générique. Ensuite, nous transmettrons l'URL complète, qui est une chaîne,
la méthode HTTP que nous attendons, qui
est également une chaîne. Tous les en-têtes
dont l'appel a besoin, à savoir une chaîne
et un mappage de chaînes Les paramètres de requête qui
sont de type valeurs RL, le corps, qui est un lecteur IO, et la réponse de type T, et nous renverrons ce
type ou une erreur. La première chose que nous allons faire
dans le cadre de cette fonction est d'initialiser notre client HTTP Et nous allons convertir
la chaîne URL en un objet URL complet avec Rl
point pars avec cette URL complète. Si l'erreur n'est pas nulle, nous
retournerons simplement notre type de
réponse et l'erreur. Si la méthode est G, nous devons ajouter tous les paramètres
de requête
qui ont été transmis Donc, je vais d'abord obtenir la
requête à partir de l'objet URL, et nous devons
parcourir ces paires
clé-valeur dans
les paramètres de la requête. Et nous allons définir
la clé et la valeur. Pour chaque paramètre.
Ensuite, nous allons définir la requête brute sur la
requête intégrée codée par un fou que nous avons créée ici. Nous pouvons également définir le corps en faisant
une nouvelle demande, en
transmettant la méthode, la version sous forme de chaîne de l'URL et le corps. Si l'erreur n'est pas nulle, encore une fois, nous renvoyons le
type de réponse et l'erreur. Maintenant que nous
avons reçu notre demande, nous devons définir les en-têtes. En ce qui concerne la clé et
la valeur de ces en-têtes, nous allons définir la valeur de l'en-tête Enfin, nous pouvons faire
leur demande proprement dite, et c'est littéralement avec le point do function du client. Encore une fois, si l'erreur n'est pas nulle, nous renvoyons ce
type de réponse et l'erreur. Nous vérifierons également si
la réponse elle-même est nulle. Nous renverrons le type de réponse et une erreur indiquant que l'appel de l'URL
a renvoyé une réponse vide, et nous voulons transmettre cette version sous forme de chaîne
de l'objet URL. Sinon, si nous
continuons ici, nous voulons lire le corps. Et encore une fois, si l'
erreur n'est pas nulle,
renvoyez cette erreur de type de réponse reportez la fermeture de ce corps Et nous voulons également vérifier si le code d'état n'est pas
le code d'état o. Type de réponse, et nous allons également
créer une erreur personnalisée ici. Formatage similaire ici. Vous pouvez ajouter une nouvelle
ligne avec le code d'état, une autre nouvelle ligne avec les données de réponse
réelles. Ensuite, nous voulons saisir
la chaîne URL, le code d'état réel et ces données de réponse. Maintenant, si nous sommes arrivés jusqu'ici, nous pouvons enfin démobiliser les données de réponse dans
l'objet de réponse, qui est le type T que nous attendons Nous allons donc déclarer l'objet de
réponse, et nous allons
essayer de démobiliser les données de réponse dans
l'objet de réponse Si l'erreur n'est pas nouvelle, modifiez le type de réponse
et l'erreur elle-même. Enfin, nous pouvons renvoyer en toute sécurité l'
objet de réponse complet avec une erreur NL. Maintenant, lorsque j'enregistre ici,
l'extension Visual Studio Go
importe automatiquement toutes les
bibliothèques que nous utilisons. Donc IO, la bibliothèque HDP, la bibliothèque d'URL, les
chaînes, etc. Donc, avec un peu d'effort, nous avons une fonction
générique très puissante, et j'aime utiliser cette
fonction pour presque tous les
appels HTTP REST standard que je dois effectuer. Comme nous l'avons vu, il est implémenté manière à pouvoir fonctionner pour get put, post et toutes sortes
de verbes HTTP Ainsi, cette puissante
fonction étant désormais implémentée, dans la leçon suivante, nous allons
appeler l'API des allergies. Nous définirons également les types qui seront considérés comme ce type générique. Nous savons donc que la réponse JCN sera correctement sérialisée, puis que nous pourrons la consommer
plus bas dans notre code G.
9. Appeler et analyser l'API Allergy: dernière leçon, nous avons créé cette fonction de requête
HDP générique assez puissante, et maintenant dans cette leçon, nous allons l'utiliser en appelant l'API d'allergie de l'Université de
médecine de Vienne Pour commencer, nous allons
créer un nouveau dossier. Appelé Allergy API et nouveau fichier go Allergy
Underscore api point go Et ce package est identique au nom
du dossier et du fichier,
Allergy Underscore API Maintenant, la première chose
à faire est définir les types que nous allons transmettre à notre fonction
générique
ici afin que le JSON,
lorsqu'il n'est pas marshalé, connaisse
le type dans ici afin que le JSON,
lorsqu'il n'est pas marshalé, lequel il doit être
démarshalé lequel il doit être
démarshalé Et en repensant à ces
deux appels d'API distincts, nous avons nos données de charge horaire, qui ont en quelque sorte cette structure
globale avec les clés de succès et de résultat,
puis dans le résultat, nous avons un autre objet,
qui propose une option totale, sorte d'option
personnalisée, et puis le plus important pour nous, le tableau horaire, qui
est un tableau d'entiers Pour obtenir les données graphiques actuelles, nous avons également une structure
similaire. Nous avons un gros objet qui possède les clés du succès et du résultat. Mais alors, le résultat
ici est directement un tableau avec un
objet répétitif dont la date est en cours, la saison
moyenne et la date et l'heure. Et encore une fois,
le plus important pour nous, c'est la moyenne. Nous allons prendre
ce point de terminaison pour la partie moyenne historique du message que nous envoyons. Commençons donc par les types
de données de charge horaire. Je vais donc d'abord
définir la réponse, qui a ici un rôle clé dans le succès
et le résultat. Je vais donc définir cela
comme une réponse horaire à la charge. Il s'agit d'un Strup et
nous avons notre succès, qui est un int, et l'identifiant JSON ici
est un succès en minuscules Et le résultat, dont nous avons
besoin pour définir un nouveau type, une nouvelle structure pour
ce type imbriqué, je vais l'appeler résultat de charge
horaire Et nous devons également
définir la clé JSON qui est le résultat en minuscules Maintenant que ce type
utilise cette autre structure, j'aime généralement mettre
le type ci-dessus ici Et qu'est-ce que nous avons ? Nous avons le total et le total
horaire est un entier. total en minuscules et
les heures du JSON sont une tranche d'ins,
et le JSON est une valeur horaire et le JSON est Et quand je l'enregistre à nouveau ici, les Linters mettent tout
en forme belle et nette en colonnes Nous pouvons maintenant passer
aux données du graphique. De même, nous avons
la réponse aux données du graphique. Et jetons un coup d'œil à ça. En outre, les clés du succès et des résultats. Le succès est donc un atout. Et le résultat, ou devrais-je dire, pluriel des
résultats se trouve dans un tableau, et ce type devra
être un autre type personnalisé, que j'appellerai le résultat des données du
graphique actuel Et nous devons également
spécifier la clé JSON. Je vais prendre ceci et
définir le type ici. Et tout ce dont nous avons vraiment
besoin, c'est de la date, qui pour l'instant prendra la forme
d'une chaîne, et la moyenne, qui est un flottant. Nous avons donc la date et la moyenne je peux enregistrer, et cela devrait être tout ce dont nous avons besoin pour les
saisies personnalisées. Nous allons maintenant écrire une fonction
distincte pour chaque point de terminaison de l'API. La première, nous pouvons appeler
obtenir des données de charge horaire. Et le second, nous appellerons
obtenir les données cartographiques actuelles. Maintenant, pour les deux, nous nous
attendons à ce qu'ils renvoient un pointeur de chaîne et une erreur. Et cette chaîne sera
finalement le message qui sera transmis à notre messagerie
Slack Et nous savons que le but ici est d' appeler notre fonction générique ici. Nous aurons donc une réponse
et une erreur de can import ce package Utils
que nous venons de créer dans la leçon précédente et
la requête HTTP make Nous n'avons plus besoin de spécifier
le type explicitement. Golan en déduira cela pour nous. Et pour l'URL,
nous l'avons ici. C'est ce point d'index pP. Nous pouvons le mettre dedans. Nous savons qu'il
s'agira d'une demande de réception. Nous n'avons pas besoin de
transmettre d'en-têtes. Nous devrons transmettre
certains paramètres de requête. Il n'y a aucun corps à passer et le type de réponse est la réponse à la charge
horaire. Et si l'erreur
n'est pas NL, nous renverrons une chaîne Nil et
l'erreur pour le moment, passons à ces paramètres de
requête. Ce type correspond aux valeurs d'URL. Et nous pouvons ajouter tous les
paramètres dont nous avons besoin. Il y en a donc pas mal
ici pour cette heure. Nous avons un EID, un type d'action peut fournir
un pays postal, etc. Nous allons donc fournir tous
ces paramètres de requête. Nous sommes donc sûrs que
notre requête Get fonctionne exactement comme dans le navigateur. Nous allons donc ajouter cet EID Le type est ZIP Le code postal est 6 800. Le pays est l'Autriche A.
Et il y a aussi ce drapeau pour le Cure JSON, et c'en est un. Peut importer ce package d'URL. Passons maintenant
au formatage et à création de cette chaîne
que nous voulons renvoyer. À partir des données présentées ici, nous avons donc la gamme complète de la charge
horaire attendue. Nous allons donc parcourir ce tableau en
boucle, établir une moyenne,
puis créer une chaîne mentionnant
cette moyenne. Nous allons donc d'abord définir
une charge moyenne. Ensuite, nous allons faire une boucle sur la plage dont nous savons qu'elle se situe dans la
partie horaire du résultat. s'agit donc simplement d'un plus
égal à la valeur horaire, puis la
charge moyenne devient la charge moyenne divisée par
la durée de toutes les heures. Une autre chose que j'ai
remarquée en parcourant l'API, c'est qu'
elle effectue une sorte
de normalisation des données. Ce n'est pas indiqué ici,
mais ces chiffres peuvent aller jusqu'à huit ou neuf, mais ils n'indiquent qu'un classement 0 à 4 sur l'
interface utilisateur réelle du site Web Donc, pour l'instant, pour
imiter cette fonctionnalité, nous allons simplement
diviser la moyenne, nous l'appellerons charge moyenne
échelonnée,
et il s' agira simplement de cette charge
moyenne divisée par deux Le message formaté
que nous allons envoyer, nous allons prendre le
package de format, sprint F, et nous dirons que la charge pollinique moyenne pour
aujourd'hui est une moyenne échelonnée, et nous retournerons ce message
formaté sans erreur L'implémentation pour obtenir les données graphiques
actuelles
est assez similaire. Je vais en fait
copier tout cela, puis nous pourrons apporter des
modifications en conséquence. Et j'ai commis une
petite erreur ici. Il s'agit de la clé d'action, et l'EID est en fait l'interface de l'application Vous pouvez l'ajouter ici. Maintenant, dans ce
cas, l'action consiste, comme nous pouvons le voir ici dans l'URL
, à obtenir les données graphiques actuelles. L'identifiant complet, c'est en fait
pour le type de plante. Dans ce cas, je l'ai
fait pour mon allergie, qui concerne les herbes ou le foin. Nous pouvons toujours transmettre le code postal. Nous ne nous intéressons qu'
aux données de saison, et c'est ce qui nous
indique les données de saison. Et nous voulons également que ce drapeau
JCN pur soit activé. L'URL est identique.
La méthode est la même. Bien entendu, nous transmettons toujours les paramètres de
la requête, et il ne nous reste plus qu'à
changer le type de réponse, qui est le type de réponse actuel des données du
graphique. Maintenant, bien sûr, G
va se plaindre ici parce que la forme de la
réponse est différente. Ce que nous voulons faire
avec cette méthode, c'est examiner tous ces résultats en
boucle
jusqu'à ce que nous trouvions une date correspondante, puis nous voulons imprimer la moyenne historique
pour la date actuelle. Je vais définir une variable
appelée current YY MMDD. C'est le point temporel maintenant, puis nous devons le formater en utilisant
le style Go
de formatage des chaînes. Nous définirons un historique
moyen qui initialisera
un zéro, puis nous passerons revue ces résultats et
trouverons la date correspondante Donc, si la date du résultat
est égale à cette date actuelle, nous savons que la moyenne historique
est cette moyenne des résultats. De même, comme nous l'avons fait ci-dessus, nous devrions créer
une moyenne
échelonnée Nous allons prendre un int cast de cette valeur puisque nous ne voulons que
zéro
à quatre, et nous allons simplement arrondir le résultat
historique moyen divisé par deux, puis nous pouvons créer
notre message formaté Dans ce cas, nous
dirons que, par le passé, la
charge pollinique moyenne d'aujourd'hui est, et nous allons inclure
cette moyenne échelonnée Nous économisons l'hiver, nous allons importer ces packages, et tout devrait être prêt. Dans cette leçon,
nous avons donc commencé à
réfléchir à la manière dont nous pouvons appeler ces deux points de terminaison et désérialiser le JSON
qu' Nous avons commencé par
examiner la structure du JSON et par définir les types nécessaires et
les parties nécessaires de ce JSON que nous devons utiliser
pour créer nos messages. Nous avons ensuite commencé à écrire les fonctions réelles
qui appellent le point de
terminaison, en utilisant notre requête make HTP que nous avons créée
dans la leçon précédente Une fois que nous avons obtenu la réponse, nous faisons un peu de
calcul et de formatage. Et pour chaque fonction, nous renvoyons finalement
la chaîne
formatée, que nous pourrons
envoyer via Slack Dans la leçon suivante, nous allons prendre cette chaîne de retour et l'envoyer Slack via des webhooks
10. Créer une application Slack et une fonction de messagerie: la dernière leçon, nous avons
défini certains types et écrit deux fonctions pour
appeler l'API Allergy, effectuer des calculs et finalement renvoyer une chaîne
correctement formatée, que nous avons dit que nous transmettrions
ensuite à Slack afin de pouvoir envoyer
le message via Pour envoyer nos
messages via Slack, nous avons d'abord besoin d'une application Slack Ensuite, nous devrons activer les webhooks entrants pour cette application, puis enfin, nous
aurons une URL que nous pourrons réellement publier pour
envoyer le message Nous reviendrons ensuite ici
dans le code et écrirons une autre fonction utilitaire pour envoyer n'importe quel message
à notre application Slack Pour commencer à
créer une application Slack, rendez-vous sur api dotslaq.com rendez-vous ici
et cliquez sur vos applications Vous devrez vous connecter
pour accéder à Je vais me connecter ici avec Google. Et je veux le compte
Full Stack Craft de mon entreprise. Et nous pouvons simplement
cliquer sur Annuler ici. Maintenant que nous sommes connectés
, nous pouvons
retourner sur api dotslag.com Puis cliquez sur vos applications. Une fois que nous sommes sur la page de liste des
applications, cliquez sur Créer une nouvelle application. Et nous voulons créer
notre application à partir de zéro. Je vais m'appeler
Allergy Cron Bot. Et encore une fois, je le veux dans mon
propre Fullstack Craft Works. Sur la page résultante, nous
voulons ensuite ajouter les webhooks entrants Et nous voulons simplement mettre
cet interrupteur en position activée, et nous verrons
du code apparaître ici Maintenant, nous voulons
ajouter un nouveau webhook, nous allons
donc cliquer ici, et nous devons choisir une chaîne
sur laquelle il pourra publier Pour l'instant, je vais choisir
Général et cliquer sur AAO. Si une
application Slack est déjà ouverte, que ce soit sur le Web ou sur
la version de bureau, nous devrions voir que l'
intégration a été ajoutée Donc, en général, je vois que j'ai ajouté mon bot Allergy Crown. De retour dans l'interface utilisateur Web, vous pouvez voir que Slack a
créé une URL de webhook pour nous, et nous pouvons donc la copier
immédiatement Vous pouvez également
copier leur exemple ici. C'est un exemple de Hello World. Et juste dans le terminal, je vais coller cet exemple, devrait démarrer
sans problème. Et si nous passons à Slack, nous voyons effectivement ce message
Hello World provenant de notre toute nouvelle application Slack Pour l'instant, nous allons simplement copier l'URL elle-même et
passer à notre projet G. Nous allons créer une fonction utilitaire laquelle nous pouvons envoyer un message. Je vais donc appeler ce fichier,
envoyer un message à Slack. Il s'agit du package Utils et de la fonction ici,
envoyer un message Slack Nous allons simplement accepter un message, qui est une chaîne, et il
renverra une erreur, le cas échéant. Tout ce que nous avons à faire ici
est de créer un corps, et nous allons utiliser
le package JSON et créer une carte de chaînes
avec ce paramètre de texte, et ce sera
le message que nous transmettrons à la fonction Si l'erreur n'est pas nulle, nous la renverrons. Ensuite, nous pouvons utiliser notre requête
make HTP. Ce sera notre URL. Nous allons publier à ce sujet. Les en-têtes, nous n'avons pas besoin de
fournir de paramètres de requête. Nous pouvons également partir en tant que Nil. Nous créons un tampon
à partir de notre corps, et nous pouvons simplement avoir une chaîne
vide comme type. Nous n'
obtenons pas vraiment de réponse. Nous obtiendrions simplement un
code 200 en cas de succès. Il n'y a
donc rien à analyser. Et d'ici, nous
pouvons ramener Nil. Et si je sauvegarde ce fichier, le Linter importera
le package JSON, et tout devrait être prêt Cette URL est
techniquement secrète,
car si quelqu'un s'en
emparait, il pourrait spammer votre
chaîne Slack Pour l'instant, nous allons le laisser
codé en dur , mais dans une leçon ultérieure, nous collecterons toutes ces valeurs codées en dur et les
placerons dans un fichier d'
environnement. Pour résumer, dans cette leçon, nous avons créé une nouvelle application Slack et nous avons activé
les webhooks entrants Après avoir sélectionné la chaîne à
laquelle nous voulions envoyer un message, Slack a généré une URL sur
laquelle nous pouvons publier qui transmettra finalement et
qui transmettra finalement
le message à cette chaîne De retour dans notre code G, nous avons écrit un message
Slack (UTIL) concis que nous pouvons ensuite utiliser pour transférer ce que nous avons analysé à partir de
l'API
sur les allergies Dans la leçon suivante,
nous allons combiner toutes
les fonctions que nous avons
réécrites dans main point go, puis nous serons prêts pour la toute première fois à
exécuter notre application.
11. Terminer la tâche Cron: dernière leçon, nous avons
créé une application Slack et cette fonction utilitaire d'envoi de
messages Slack qui permet d'envoyer à Slack les
messages
générés par les fonctions de notre API sur les
allergies Dans cette leçon, nous allons
enfin combiner toutes ces fonctions que
nous avons écrites dans main point go. cadre de cette fonction Cron,
je vais donc appeler nos données de charge
horaire G pour obtenir données graphiques
actuelles
, puis transmettre ce
message combiné à Slack Nous avons donc reçu notre message
moyen quotidien. Et cela provient de
l'API sur les allergies. Obtenez des données de charge horaire. Si l'erreur n'est pas nulle, nous allons paniquer Et nous allons également obtenir la moyenne
historique. De même, si l'air
n'est pas mauvais, nous paniquerons. Ensuite, le message
Slack que nous enverrons combinera ces
deux messages, et nous mettrons simplement un nouveau
caractère de ligne entre les deux Avec ces éléments combinés, nous pouvons appeler notre fonction Envoyer un message Slack
avec ce message Slack Et encore une fois, si l'
erreur n'est pas nulle, c' Utils qui
va paniquer Je peux l'importer. Et juste pour le moment, pour le débogage, je vais me
déconnecter car nous avons
envoyé le message Slack avec succès , et nous ajouterons le message Slack
lui-même Je peux sauver ça, et nous
devrions être prêts à partir. Pour passer rapidement en revue cette leçon, nous sommes finalement revenus à notre fichier point go
principal, et nous avons appelé les données Get de charge
horaire et
les données graphique G current pour contenir à la fois un message de moyenne quotidienne et un message de moyenne
historique Nous les avons combinés
avec une nouvelle gamme, puis nous avons appelé notre nouvelle fonction de message
Send Slack, qui complète finalement le flux fonctionnel complet
de notre application Dans la leçon suivante,
nous modifierons la durée de la tâche cron pour qu'elle se déclenche
plus ou moins immédiatement, puis nous exécuterons
notre application
12. Exécuter l'application: Lors de la dernière leçon, nous avons
terminé le corps de la fonction qui se
déclenchera réellement à l'heure cron spécifiée Maintenant que nous sommes prêts à
exécuter notre application, nous devons la mettre à jour les prochaines heures et
minutes afin de
voir rapidement le démarrage de la tâche
cron et tester le corps réel ici pour voir si
tout fonctionne Donc, à la date
d'enregistrement actuelle, elle est de 1209, donc je vais passer à 1210, puis nous pourrons
appeler notre fonction avec go run main point go Et nous devrions nous attendre à ce
que
ces API soient appelées et que
notre message Slack soit envoyé dès 1210 ces API soient appelées et que
notre message Slack soit Donc, en effet, nous ne voyons qu'
une coche après 1210. Nous recevons le
message Slack suivant qui est envoyé. La
charge pollinique moyenne d'aujourd'hui est de un, et historiquement, la charge
pollinique moyenne d'aujourd'hui est de deux. Nous pouvons également voir
ici, dans notre application Slack que nous recevons exactement le
même message Notre application fonctionne donc
exactement comme prévu. Jusqu'à présent, ce que nous avons intégré
dans ce cours répond aux exigences techniques
que nous avons spécifiées en termes de flux
et de fonctionnement de l'application. Il obtient les données de l'API, convertit en une belle chaîne lisible par
l'homme, puis envoie ce
message via Slack Cependant, il reste encore de
nombreuses optimisations que nous pouvons apporter pour en faire
une application davantage adaptée aux entreprises. Dans les leçons à venir, nous examinerons des éléments
tels que la suppression ces chaînes et
leur placement dans un environnement, ainsi que des éléments
qui devraient vraiment être laissés à un fichier d'
environnement, tel URL de Slack et
le
point de terminaison de l'API sur les allergies Une fois cela fait, nous passerons aux
tests, puis à mise en
œuvre d'un pipeline CICD
automatisé
13. Tests de rédaction: dernière leçon, nous avons lancé
notre application, et nous avons constaté qu'en effet, tout
fonctionne comme prévu. C'est bien beau,
mais que se passera-t-il si l'API change
ou si quelque chose de bizarre se produit dans notre application et
qu'elle tombe en panne ? Nous voulons probablement
savoir si l'une de nos fonctions est
interrompue sans avoir à exécuter l'application dans un environnement
de production complet. Dans cette leçon, nous allons donc écrire des tests pour chacune des
fonctions que nous avons écrites. Plus précisément, la fonction Envoyer un message
Slack
ainsi que les deux fonctions de l'
API sur les allergies, à savoir l'obtention des données de charge horaire et
l'obtention des données graphiques actuelles Nous n'écrirons pas explicitement
de test pour la requête HTP M car cette
fonction est en fait appelée par les trois autres pour
lesquelles nous allons écrire des tests Donc, par proxy, si nous écrivons un test pour ces
trois fonctions, nous testerons également, à notre tour, par proxy la fonction de requête
make HTP Pour commencer à
écrire nos tests, nous allons créer un dossier
appelé tests. Et je vais créer deux fichiers, un pour chacun
des modules ou fonctions
que nous allons tester. Nous allons donc faire
un test d'API pour les allergies, ainsi que notre test d'
envoi de message Slack Et note 4, allez
reconnaître ces fichiers
comme de véritables tests. Ils doivent se terminer par le suffixe «
point de soulignement Donc, dans le cadre de chacun d'entre eux, il s'
agit de notre test de package. Nous savons que nous allons avoir
besoin du module de test, le module de test intégré de G. Et pour
le nom de la fonction, il existe une règle selon laquelle le nom
doit commencer par test. Nous avons donc besoin du suffixe du
test de soulignement ici et
du nom de la fonction commençant par le mot
test majuscule pour go afin de
reconnaître pleinement le
fichier et les fonctions contenues dans les fichiers pour
que le test soit valide Je vais donc l'appeler
API test Allergy, et nous devons transmettre un pointeur vers ce module de
test. Laissez-le vide pour le moment
et faites de même ici. Pour notre test des messages Slack, il s'agit de tests de packages Importez le module de test. Et j'appellerai ce test
envoyer un message Slack, et nous transmettrons un pointeur
vers ce module de test Maintenant, pour
tester réellement nos fonctions, nous allons appeler les fonctions de données de charge
horaire G et de données
graphiques. Et maintenant, nous appelons notre fonction comme nous le ferions
n'importe où ailleurs dans notre code. Je vais donc d'abord appeler cela
obtenir des données de charge horaire, puis nous procéderons à
diverses vérifications sur l'erreur et le message
pour terminer notre test. Donc, si l'erreur n'est pas nouvelle, nous voulons utiliser
la fonction T point f, et nous pouvons dire erreur lors de l'
obtention des données de charge horaire. Nous pouvons transmettre l'erreur réelle. Vous devez également vérifier
si le message est nul. Il s'agit également d'un cas d'erreur. Et dans ce cas, nous allons simplement dire erreur lors de l'
obtention des données de charge horaire. Le message est nul et nous pouvons également vérifier si le message
lui-même est une chaîne vide. Ce n'est probablement pas non plus un
très bon résultat
de notre fonction. Erreur donc lors de l'obtention des données de charge
horaire. Le message est vide. Et presque pareil pour
obtenir les données graphiques actuelles. J'ai reçu notre message, notre
erreur et les mêmes vérifications. Donc, si l'erreur n'est pas nulle,
vous pouvez réellement la copier. Assurez-vous simplement de modifier
le message ici. C'est donc clair lorsque
nous effectuons nos tests. Nous vérifierons également si le message est nul ou
s'il est vide, et je
remplacerai simplement cette chaîne
de charge horaire par les données graphiques actuelles. Maintenant, dans le cadre du test Envoyer un message
Slack, seule une erreur est renvoyée
par cette fonction Util, et je vais simplement appeler le message Envoyer Slack
avec message Si l'erreur
n'est pas égale à Nil, nous dirons erreur lors de
l'envoi du message Slack, et nous allons
saisir l'erreur réelle Nous allons
maintenant utiliser la commande intégrée go test
pour exécuter ces tests J'aime donc passer quelques
drapeaux lorsque je fais mon test. Le premier est P, qui définit le nombre de tests
parallèles à un. En d'autres termes, cela
exécuterait vos tests en série. Et j'aime bien ce format car vos tests s'exécuteront
toujours dans le même ordre et vous obtiendrez toujours le résultat
attendu quant à la
façon dont ils s'exécutent. Ainsi, au fil du temps, vous pourrez vous habituer
à l'apparence de cette sortie. Si vous avez une très, très
grande base de code,
vous pouvez bien sûr envisager de la
modifier pour exécuter plusieurs
tests en parallèle. J'ajoute également le drapeau V, qui permet une sortie détaillée. Et c'est utile car en cas
de problème, vous obtenez plus de résultats et vous
pouvez trouver l'erreur plus rapidement. Nous devons également transmettre le dossier dans lequel nous
voulons exécuter nos tests. Dans ce cas, il s'agit
du dossier des tests. Donc, ensemble, la
commande est de tester P one, puis pour le Verbose,
puis le dossier de tests Et si nous sommes
bons dans notre travail, lorsque nous exécuterons cette commande, nous espérons
que tous les tests seront réussis. En effet, nos deux tests, l'API Test Allergy et le message Slack de
Test Sens, ont
tous deux été réussis, et nos
tests semblent bons résumer,
nous avons donc écrit les tests pour la plupart des fonctions que
nous avons écrites dans notre base de code Nous les avons placés dans le dossier de test et nous avons expliqué comment
être un test valide pour G,
G doit voir à la fois le test de
soulignement à la fin et le nom de la fonction
dans
le fichier de test
pour commencer par un test en majuscules Nous avons ensuite écrit nos tests. Nous les avons exécutés avec
la commande G test avec quelques indicateurs supplémentaires, et nous avons constaté que tous
nos tests étaient réussis. la prochaine leçon,
nous verrons
comment dockeriser notre application
14. Décortiquer l'application: dernière leçon, nous avons écrit
des tests pour notre application, et nous avons constaté que
les tests étaient effectivement réussis. Dans cette leçon,
nous verrons
comment dockeriser notre application Comme GO compile
en un seul binaire, il n'y a pas trop d'
étapes complexes à
effectuer pour que notre application
GO fonctionne correctement dans Docker Nous devrons définir deux fichiers,
à le fichier Docker lui-même,
puis le fichier Docker
Compose, qui nous
permettra d'exécuter notre conteneur avec un outil tel que Docker Compose, lequel nous pouvons gérer et
orchestrer Je vais donc
commencer par le fichier Docker, et je vais le mettre ici,
à la racine de notre projet Il s'agit simplement d'un fichier Docker. Et je vais commencer par
le conteneur alpin Gang, et je vais prendre le conteneur 1.2
Golang Cela provient donc de Golang
1.2 sur Alpine. Ensuite, nous allons
définir le Wd comme une application, et c'est une pratique
courante. Nous ne créons
ni ne créons de fichiers dans la racine
même de ce conteneur, mais définir
notre propre espace de est
généralement considéré
comme une application dans ce conteneur, et c'est là que nous allons
faire la création proprement dite. Nous voulons donc copier
tout ce que nous avons ici dans notre base de code dans
ce dossier d'application, et ce, point par point. Ensuite, nous allons réellement
créer notre application. Nous allons donc faire Go Build O, et nous l'appellerons Allergy
Cron, puis pour l'exécuter, comme mentionné, G
créera un seul binaire, et nous n'aurons qu'à
exécuter ce binaire Ce Dockerfile
serait donc déjà suffisant pour créer un conteneur que nous
pouvons créer puis exécuter,
mais pour le rendre plus convivial
avec Docker Compose, afin
que nous puissions l'exécuter immédiatement
avec Docker Compose, nous allons également définir un Yamofle à points
Docker Compose nous allons également définir un Yamofle à points
Docker Donc, tout comme pour le Dockerfile, je vais mettre directement à la racine,
le Docker Compose Dot Yamofle et j'utiliserai la dernière version C'est 3,9. Ensuite, nous
définissons nos services. Nous avons le cron anti-allergie, qui est notre seul service Ensuite, nous définirons
le contexte de construction. C'est juste là, ce qui signifie que
Docker Compose
recherchera ce fichier Docker directement dans notre racine et utilisera
ce Ensuite, nous pouvons également définir
la politique de redémarrage, et je vais la définir
avec une valeur stop less stop. Cela signifie donc que si notre conteneur tombe en
panne pour une raison quelconque, Docker le détectera et
redémarrera le conteneur pour Maintenant, pour voir si nous avons tout
configuré
correctement dans ces deux fichiers, nous pouvons à la fois créer
puis exécuter notre conteneur. Donc, d'abord, pour créer
le conteneur, je vais utiliser la commande
Docker Compose, et nous voulons construire Et comme c'est la toute
première fois que nous développons notre application dans le cadre
d'un double contrôle de sécurité, je n'émettrai aucun dossier, ce qui signifie que tout ce qui est nécessaire pour créer le conteneur sera fraîchement téléchargé sur Internet. Nous n'allons utiliser
aucun fichier local ici. Une fois cela fait, nous
pouvons également exécuter Docker Compose. Et dans ce cas, nous voulons démarrer et je vais également transmettre le drapeau D, qui est le drapeau détaché, ce qui signifie que
Docker démarrera notre conteneur en arrière-plan et nous rendra notre terminal Si nous ne passons pas ce drapeau D, nous commencerons à voir les journaux de notre conteneur
ajoutés directement,
et le fait de quitter ou de quitter environnement
du terminal sortirait également de notre Nous passons donc ce D pour que le conteneur reste
opérationnel en arrière-plan. Donc, si tout fonctionne correctement, nous devrions voir un joli vert apparaître ici à la fin de
toutes les sorties de compilation. Et nous pouvons vérifier que
le conteneur
fonctionne réellement avec la commande
Docker PsA Et nous voyons en effet
notre allergie Cron courir créée
il y a 18 secondes en hausse de 15 secondes. Nous avons donc créé et
exécuté
avec succès notre application go
dans un conteneur Docker récapituler, nous définissons à la
fois un fichier Docker et
un fichier Docker Compose pour permettre à notre application d'être exécutée avec la commande Docker Nous avons tous deux créé puis exécuté notre application
en arrière-plan, et nous constatons, en effet, notre application s'exécute dans son conteneur sur
notre système local. Dans la leçon suivante,
nous verrons brièvement comment redémarrer notre conteneur
avec un temps d'arrêt minimal
15. Redémarrer le conteneur avec un temps d'arrêt minimal: Lors de la dernière leçon, nous avons créé les deux fichiers de configuration
nécessaires pour créer un conteneur Docker
lui-même, puis exécuter ce conteneur Docker
avec Docker Compose Dans cette leçon, nous verrons
rapidement comment
remplacer un conteneur en cours d'exécution
avec un temps d'arrêt minimal. fait, il s'agit de reconstruire l'application
et de la remplacer. Et encore une fois, cela utilise
cette commande Docker Compose. Nous allons
recompiler sans cache. Et émettez la commande up détachée et surtout
avec force recreate. Nous passons ce drapeau afin de
nous assurer que Docker remplacera toujours le conteneur
existant par le conteneur nouvellement construit Donc, si nous émettons cette commande, nous constatons à nouveau qu'elle se termine. Et si je vérifie nos
conteneurs avec PSA, nous constatons effectivement que la nouvelle version créée
il y a 10 secondes est en hausse de 7 secondes. Il vient donc d'être remplacé. Maintenant, pour une
application Cron Job comme celle-ci,
cette commande est probablement
suffisante pour vos besoins Mais gardez à l'esprit qu'il ne s'agit
pas d'une méthode sans temps d'arrêt. Il s'agit simplement d'une méthode de
temps d'arrêt minimale. Vous auriez des temps d'arrêt pendant les courts instants
nécessaires au remplacement du conteneur par
Docker Pour une
candidature de type Cron Job comme celle-ci, il est simplement important de ne
pas remplacer ce conteneur au moment
où votre Crown Job est en cours d'exécution Si vous faites quelque chose de plus compliqué qui ne
nécessitait aucun temps d'arrêt, vous devez
faire quelque chose de plus complexe, comme créer
plusieurs conteneurs, changer d'
équilibreur de charge, etc. Mais ce type de stratégie entre pas dans le
cadre de ce cours. Mais en résumé,
si vous savez ce que fait votre
application et quand vous pouvez
remplacer ce conteneur en toute sécurité, cette méthode fonctionne assez bien pour de nombreux types
d'applications. Dans la leçon suivante, nous
reviendrons sur le codage et l'amélioration du message
que nous envoyons via Slack
16. Ajouter un formatage sophistiqué aux messages Slack ages: Dans la dernière leçon, nous avons brièvement expliqué comment reconstruire
et remplacer un conteneur
avec un temps d'arrêt très minimal. Dans cette leçon,
nous reviendrons sur code et verrons comment améliorer le formatage
des messages Slack
que nous envoyons Donc, si nous accédons à notre fichier API sur les
allergies, nous pouvons nous rappeler que nous envoyons deux messages Slack assez simples Il serait peut-être intéressant
d'ajouter un peu plus de couleur et peut-être
même quelques emojis afin que le sentiment de
notre message puisse être affiché
plus rapidement et de
manière plus intéressante Nous allons donc
modifier ce message initial. Nous allons laisser le message
historique tel quel. Mais pour les données
réelles en temps réel, nous allons améliorer le
formatage de ce message. En bas de page,
je vais définir
une nouvelle fonction
appelée Formater les données sur les allergies. Et il ne s'agit
ici que d'une fonction en
minuscules , car nous n'avons pas
besoin de l'exporter Il sera simplement utilisé
dans ce fichier. Je vais transmettre
la charge moyenne échelonnée que nous avons qui est un int, et nous allons
renvoyer une chaîne Ce que nous avons actuellement est notre message formaté
et il ressemble à ceci La charge pollinique moyenne d' aujourd'hui et nous répercutons cette charge moyenne
échelonnée Mais nous allons à la
fois préfixer et suffixer ce message pour le
rendre un peu plus sophistiqué Nous pouvons le faire avec un boîtier de
commutation et ce que je vais faire, c'est activer
la charge moyenne échelonnée Et d'une part, c'est
un cas plutôt modéré. Nous allons donc le préfixer avec cet
emoji en forme de cercle jaune et mettre OK, puis un espace, puis le message
existant que nous avons Et nous voulons peut-être
plafonner le niveau à un niveau faible
ou modéré. Ensuite, dans le cas où il s'agit de deux, nous pouvons augmenter la couleur pour passer à une sorte de
couleur d'avertissement orange et dire quelque chose comme attention à nouveau avec
notre message formaté Et dans ce cas,
c'est moyen, et nous allons terminer avec
cet emoji orange Puis quatre ou trois.
Nous allons mettre du rouge et mettre à nouveau un avertissement avec ce message formaté en
indiquant qu'il est haut
et terminé par l'emoji rouge Maintenant, s'il s'agit du
niveau le plus élevé, qui est de quatre, alors nous allons mettre trois de ces emojis rouges et
envoyer alerte avec notre message
formaté Et insistez beaucoup sur
ces cas les plus élevés ici. Et nous allons également conclure avec trois de ces cercles emogi
rouges Alors si c'est le cas, si c'est
zéro, nous allons échouer, et nous allons également prendre la
valeur par défaut et renvoyer cet emogi vert puis dire gentil » avec le
message formaté, le Juste pour que la ponctuation
soit cohérente, nous pourrons fermer le
crochet de notre interrupteur Alors maintenant, au lieu de
notre format ici, nous allons nous en débarrasser
puisqu'il figure déjà dans notre nouvelle fonction. Nous allons appeler
la fonction de données sur les allergies au format et transmettre cette charge moyenne
échelonnée Maintenant, si nous l'enregistrons, nous
pouvons tester notre application. Donc, pour le moment, c'est 318. Nous allons augmenter
notre cron à 319. Ce seront donc 15
et 19 ans, je crois. Et nous pouvons publier
Go Run Docco principal. Et en effet, juste après 319, nous recevons une copie de
ce que nous avons envoyé via Slack avec notre nouveau message sympa Et aujourd'hui, il fait chaud et sec, donc je dois faire
attention un peu. Le niveau est élevé aujourd'hui. Pour passer en revue cette leçon,
nous avons consulté notre fichier API sur les
allergies et nous avons remplacé le
premier message que nous
envoyons par cette nouvelle fonction de données sur les
allergies au format nouveau. Et nous avons ajouté du texte
supplémentaire ici, ainsi que des emojis
qui reflètent mieux le sentiment des informations
que nous envoyons Et dans l'ensemble, je trouve que c'est plutôt
joli et qu'il est plus facile de déterminer immédiatement
la nature du
message. Il ne reste donc que
quelques leçons. Dans la leçon suivante,
nous verrons comment déplacer toutes ces valeurs codées en dur, telles l'URL et le fuseau horaire Cron, ainsi que l'intervalle Cron, et les placer dans un fichier M. Une fois que nous l'aurons fait et que assurés que notre application
fonctionne toujours, nous utiliserons
CircleCI pour créer un pipeline CICD qui testera,
développera et déploiera automatiquement notre
application
17. Déplacer des valeurs secrets et codées en dur vers un fichier env: dernière leçon, nous avons créé cette fonction de
formatage des données sur les allergies afin d'
améliorer le formatage et de
rendre les messages de Slack un
peu plus colorés Dans cette leçon,
nous allons prendre toutes ces valeurs codées en dur, telles que l'URL de l'API, ainsi que l'emplacement
et le calendrier cron , et les placer
dans un fichier d'environnement Donc, pour commencer,
je vais créer un fichier N, donc point N. Et immédiatement, nous voulons créer un fichier Get Ignore et ajouter
ce fichier N au G Ignore. Il s'agit d'une pratique courante, car vous aurez généralement au moins une ou
plusieurs valeurs secrètes que vous ne souhaitez pas archiver
dans votre dépôt Git. Je vais donc créer ce
Get Ignore et je vais juste
ajouter le fichier M. Alors, qu'avons-nous réellement pour nos variables d'environnement ? Nous avons l'URL racine de
l'API Allergy ici. Nous avons également l'URL de notre webhook
Slack, notre fuseau horaire Cron ainsi que la chaîne de calendrier Ajoutons donc tous ces éléments
à notre fichier d'environnement. Nous avons donc l'URL de notre webhook
Slack. Je peux le coller dedans. J'ai la
racine de l'URL de notre API pour les allergies, je vais l'appeler. C'est ce type. J'ai
notre fuseau horaire de Cron C'est ici. Et le
calendrier cron. Et c'est celui-ci. Et pendant que je suis ici,
je vais
revenir à la valeur
initiale que nous avions à 8 h 00. nous avions Maintenant, pour que le
moteur d'exécution Gang
puisse réellement voir ou avoir ces valeurs
dans l'environnement, nous devons nous assurer que
ce fichier d'environnement est chargé dans l'environnement d'exécution. Pour ce faire, nous pouvons utiliser le
populaire package Johogo point Nv. Il s'agit donc de github.com, Joho et go point v. Et nous
pouvons le récupérer ici Et juste en haut
de notre fonction principale, nous pouvons le charger. Cela renvoie une erreur, et c'est juste go point N dot load. Et nous n'avons pas besoin de
transmettre de paramètres. Il recherchera par défaut
notre fichier point N. Bien sûr, nous voulons
vérifier si l'erreur n'est pas nulle, alors nous allons
avoir un message fatal ici. Erreur lors du chargement du fichier. Maintenant, nous devons réellement prendre la valeur de ces variables d'
environnement. Cela peut être fait
avec l'appel s.gn. Nous les avons donc chargés
dès le départ,
et ils devraient
ensuite être disponibles dans notre environnement. Nous avons donc OS GNV. Et ce sera
le fuseau horaire de Cron. Et pour celui-ci,
nous avons OS GNN. Voici Cron Schedule. De même, ici, dans l'API OSG N, vous devez également l'ajouter ci-dessous, je crois, ou au-dessus et également dans notre fonction slack Voici OSG N. et l'URL de notre
webhook Slack. Maintenant, nous devrons également ajouter ce chargement de l'environnement
dans notre test. Maintenant que nous avons
refactorisé le code, le code exécuté
dans le
cadre de ces tests
devrait également contenir ces
variables d'environnement C'est donc légèrement différent dans le test car nous
ne sommes pas à la racine Nous ne pouvons pas simplement appeler
le chargement par défaut, mais nous devons transmettre explicitement le chemin de retour à l'
environnement à la racine. Je vais le copier en
haut de nos deux tests. Et nous devons simplement suivre cette voie de
manière explicite. Et importez les packages Godot
end et log ici. Et pareil pour
l'autre test. Importez-les. Et nous avons
déjà défini l'erreur maintenant, donc c'est juste l'égal normal. Et cela devrait
suffire pour les tests. Pour les examiner rapidement, nous avons créé un fichier point N pour toutes les différentes valeurs codées en
dur que nous utilisions
dans notre application. Nous avons également créé un
fichier get Ignore pour être sûrs ignorer ce point N car
il contient effectivement des secrets. Dans ce cas, le plus important
est l'URL de ce webhook. Nous ne voulons pas que
quelqu'un y arrive,
sinon il pourrait
publier sur notre chaîne. Nous avons examiné notre
code et remplacé ces valeurs codées en dur par leurs noms d'
environnement respectifs. Et nous avons également ajouté à nos tests le mode de chargement de la variable d'
environnement. Donc, dans le cas de notre test passons
explicitement
le chemin vers notre extrémité, qui se trouve dans les dossiers supérieurs. Nous utilisons donc la notation
Unix à points pour accéder à ce dossier racine
depuis notre dossier de test En fin de compte, il s'agit d'
un très bon modèle car, directement dans ce fichier M, vous voyez immédiatement certaines des valeurs clés
les plus importantes
pour le fonctionnement de notre application, à savoir le
fuseau horaire et le calendrier, mais également si l'URL devait changer ou si vous deviez
trouver un autre fournisseur, vous pourriez modifier
cette URL et écrire un autre client pour cette API. De plus, par exemple, si
vous deviez modifier l'URL de
votre webhook pour une autre chaîne ou
si l'équipe change, vous pourriez également la
remplacer rapidement ici et vous qu'elle est utilisée dans votre base de code,
où qu'elle se Maintenant que nous avons
dockerisé notre application, nous avons nettoyé
les messages Slack et nous avons également
nettoyé les valeurs codées en dur Au cours de la
prochaine leçon, il est enfin temps de créer un pipeline CICD
complet pour créer notre application et la
déployer sur Docker Hub Enfin, nous allons
terminer le cours en extrayant le conteneur nouvellement
créé de Docker Hub et en l'exécutant une dernière fois pour vérifier que
tout fonctionne toujours
18. Créer une filière CI CD avec Circle CI: Dans la dernière leçon, nous avons
créé un fichier d'environnement pour stocker toutes les
valeurs codées en dur et les secrets de notre application et nous avons remplacé
ces valeurs
codées en dur les noms des variables
d'environnement de l'application. Et c'était vraiment la dernière
étape pour que nous soyons prêts à
emballer et à automatiser la façon
dont nous construisons notre conteneur. Dans cette leçon,
nous allons donc créer un pipeline de CD CI complet qui
compilera puis testera notre application avec les
tests que nous avons écrits. Ensuite, si ces tests sont réussis, il déploiera ou téléchargera notre
conteneur sur Docker Hub À la fin, nous allons
extraire ce conteneur et l'
exécuter comme test final pour vérifier
que tout fonctionne. Donc, pour commencer avec CircleCI, nous devons d'abord créer un
dossier appelé Circle CI,
et dans ce dossier, un fichier yaml à points de configuration Maintenant, la première chose que
vous devez faire dans votre fichier yamal à points de configuration, similaire à la composition de Docker,
est de fournir la version Actuellement, cette version ou
la dernière version est 2.1. Et nous allons également répertorier un orbe. Désormais, les orbes sont des
commandes ou des tâches préemballées dont l'exécution
est très courante Par exemple, ils
ont un orbe nodal. Ils ont un orbe souple, ce qui
vous fait gagner du temps. Au lieu d'
écrire des commandes bash explicites pour accomplir des tâches, ils ont Par exemple, envoyez un message Slack, et il vous suffit de
transmettre le message sous forme de chaîne Vous n'êtes pas obligé de publier cette déclaration
curl ou
des choses comme ça Dans notre cas, le seul orbe dont nous avons besoin est pour le hub Docker, et cela peut être fait
en spécifiant Docker, et nous allons prendre la dernière
version de cet orbe Docker,
qui est nous avons besoin est pour le hub Docker,
et cela peut être fait
en spécifiant Docker,
et nous allons prendre la dernière
version de cet orbe Docker,
qui est 2.2 0.0. reste plus
que deux parties principales d'un fichier yaml à points de configuration Il existe à la fois des tâches
et des flux de travail. Les tâches sont différentes
étapes que vous pouvez utiliser une ou plusieurs fois
dans vos flux de travail. Vous pouvez donc les considérer comme des éléments de base individuels, et les flux
de travail se combinent et indiquent dans quel ordre et comment
ces tâches doivent être exécutées. Ainsi, les flux de travail sont généralement répertoriés plus haut dans
le point de configuration yam Mais comme nous allons procéder
étape par étape, nous allons d'abord écrire les tâches, puis les flux de travail par
la suite. Cela a un peu plus
de sens du point de vue étape par étape. Nous allons donc commencer par
définir nos métiers. Et pour l'instant, nous
n'avons vraiment qu'un seul travail, celui de tester
notre application. Je vais donc simplement l'appeler test, nous devons spécifier
un répertoire de travail. Et dans le monde de Circle CI, ce dépôt est le
symbole spécial du référentiel
local Et nous allons
utiliser une image Docker, et nous allons
utiliser l'image GO Ensuite, nous pouvons définir
les étapes de ce que nous voulons réellement
faire dans le cadre de ce travail. Donc, d'abord, nous
allons, bien sûr, vérifier le code, et nous
pouvons mettre en cache notre fichier go sum. Cela accélérera les
builds suivants. Et nous
allons vérifier certaines de nos options et
nous installerons également des
dépendances à partir de cela. vérifier certaines de nos options et nous installerons également des
dépendances à partir de cela. Vous devez émettre GGet, puis
nous enregistrerons ce cache. Ce sera donc le cas
plus tard, si nous installons de nouveaux packages ou modifierons les versions de ceux-ci, cela sera
reflété avec précision dans cette clé que nous avons
définie pour notre cache. Et nous devons également
définir la voie à suivre. Cela a donc été principalement tiré d'un exemple que CircleCI a sur son site pour les recommandations
et les meilleures pratiques pour une application Go Et je mettrai un lien vers cela
dans les ressources de la leçon. Maintenant, nous devons également créer
notre fichier d'environnement car nous savons que notre application ne peut pas fonctionner sans ces variables d'
environnement. Nous allons donc passer à
une autre étape. Le nom est create point N file. La commande peut utiliser le canal pour effectuer plusieurs étapes ou
plusieurs commandes. Nous allons d'abord
créer ce fichier. Ensuite, nous allons utiliser Echo pour faire
écho à toutes les
variables d'environnement dont nous avons besoin. Pour nous évader dans l'environnement
CircleCI, nous utilisons cette syntaxe, les crochets avec
le signe dollar, et nous allons simplement prendre
les mêmes noms que ceux que nous avons dans notre application Nous verrons comment les définir
ultérieurement dans l'interface utilisateur de CircleCI. Et nous allons simplement l'ajouter
à ce nouveau fichier. Je vais donc le copier
plusieurs fois, et nous savons que nous avons la racine de l'URL de
l'API sur les allergies. Nous avons également notre fuseau horaire cron, et nous avons également cette chaîne de calendrier
cron
et une fois celle-ci terminée, nous allons
lancer des Je vais donc simplement appeler
cela des tests d'exécution. Et la commande que nous avons tirée de la
leçon précédente est go test. Nous allons définir cet indicateur parallèle
ainsi que le drapeau Verbose, et nous voulons l'exécuter dans
le dossier des tests Nous avons donc défini notre test de travail
unique, et nous devons maintenant
définir les flux de travail. Donc,
comme je l'ai mentionné, le schéma normal est que les flux de travail
dépassent les tâches Nous allons
donc revenir ici et spécifier
également nos flux de travail. Nous n'
avons donc qu'un seul flux
de travail, qui sera le flux de
production, et nous devons spécifier les tâches. Et nous avons notre travail de test, et nous allons également
filtrer sur la branche. Et nous ne voulons que
la branche principale. Et puis le deuxième travail que nous voulons sera
d'utiliser cet orbe Docker ici Et ce
sera Docker Publish. Et l'image sera à la
fois notre nom d'utilisateur et le nom du dépôt, que
nous définirons également ultérieurement dans l'interface utilisateur Web de CircleCI
avec nos autres variables avec Nous y reviendrons donc
dans quelques instants. Maintenant, nous devons également définir
l'ordre de ces tâches. Si nous ne spécifiez aucune commande, CircleCI, nous les
exécuterons simplement en parallèle. Cela peut être utile en
fonction de ce que vous faites. Mais bien entendu, dans notre cas, nous voulons nous
assurer que ces tests sont
réussis avant de les
publier dans notre conteneur. ce faire, il faut utiliser
la directive requires, et nous exigeons, bien entendu, que le travail de test soit terminé. Et nous voulons également filtrer
sur la branche principale. Maintenant, il y a beaucoup de code
Yamil dans ce fichier, et il n'est pas clair si nous avons erreurs ou des
problèmes de syntaxe, mais heureusement, CircleCI fournit un outil CLI où nous pouvons vérifier
ce J'ajouterai dans les ressources de la leçon le lien vers leur
documentation officielle sur la façon dont
vous pouvez l'installer. Je l'ai déjà
installé sur mon système et le moyen de
vérifier la configuration est
d'utiliser CircleCI Config CircleCI Nous pouvons voir ici que j'ai oublié qu' il ressemble au point-virgule Et je vais réexécuter cette vérification, et j'ai également oublié un S. Et enfin, il semble que
nous ayons une configuration valide ici. Nous obtenons donc que c'est valide. Nous pouvons donc déjà constater qu'il est très pratique de
trouver des
fautes de frappe ou des problèmes de formatage
dans notre fichier de configuration Maintenant, à ce stade de votre code, il serait probablement judicieux de
bifurquer et de créer
une branche développée. d'abord, en exigeant
que vous ayez initialisé le dépôt Git
et en supposant que vous soyez toujours sur la branche
principale ou principale, vous
devez, bien
entendu, publier, B develop et
tout valider dans cette branche Ensuite, vous devez fusionner lorsque vous êtes prêt, fusionner avec votre branche principale
ou principale, puis cela
lancerait ce cas, il faudrait que ce soit la branche
principale, sinon CircleCI ne ferait rien Il attend des validations cette branche principale,
comme nous l'avons spécifié. Mais si vous avez, par exemple, utilisé la convention de
dénomination principale, vous devrez la remplacer par master pour que
CircleCI puisse faire quoi que ce soit
sur
cette CircleCI puisse faire quoi que ce soit
sur Dans mon cas, je suis déjà dans le référentiel
spécifique au cours et j'ai un nom de branche personnalisé. Donc pour l'instant, je vais
laisser les choses telles quelles, et nous allons accéder aux applications Web Docker Hub et
CircleCI et applications Web Docker Hub et
CircleCI et configurer ce dont nous avons besoin Alors, dans Doctor Hubb, connectez-vous ou créez un compte Si vous n'en avez
pas, ils sont gratuits. Et nous allons simplement cliquer sur
Créer un dépôt ici, et j'appellerai le
mien Allergy Cron Nous pouvons simplement cliquer sur Créer ici. Et maintenant, nous avons un dépôt vers
lequel nous pouvons envoyer des messages. Ensuite, nous allons nous rendre sur circleci.com et
cliquer sur Et sur la page de connexion ici, puisque le dépôt, dans mon cas, se trouve sur Github, je vais me
connecter avec GitHub Si vous avez décidé de
suivre Bitbucket par
exemple, vous pouvez vous connecter avec Bitbucket Je fais donc partie
de plusieurs organisations, mais le référentiel dans lequel nous avons codé se trouve sur
mon compte personnel. Je vais donc le sélectionner et vous
verrez tous vos référentiels
dans votre profil GitHub Et, bien sûr, je veux
suivre ce cours pour les
applications du monde réel, et nous pouvons cliquer sur Configurer le projet. Donc, avant que CircleCI puisse
trouver le fichier Arc fig, je dois revenir ici dans le code et valider cette branche Je vais donc tout ajouter. Je vais valider quelque chose comme si
CircleCI Config était terminé. Je vais insister sur le fait que je dois
définir le nom de la leçon avec
le nom de la branche. Ici, je devrais être capable de
spécifier la branche de la leçon 18, et nous verrons que CircleCI
va même parcourir notre code et trouver
cette configuration C'est donc vraiment
un bon service. J'aime vraiment utiliser CircleCI.
Ils rendent les choses très faciles. Donc dans votre cas, selon l'endroit où
vous l'avez poussé, si vous l'avez poussé vers
la branche développée, si vous l'avez poussé vers la branche principale ou la branche
principale,
vous pouvez le
spécifier ici, et j'espère que CircleCI trouvera votre point de configuration Donc, une fois que cela est trouvé, vous pouvez simplement cliquer sur
Configurer le projet. Et il essaiera même de
lancer le tout premier flux de travail. Mais bien sûr, comme
le commit était destiné à la branche de la leçon 18, il voit dans la configuration : OK, il n'y a rien à
faire pour la leçon 18, et il
indiquera simplement qu'il n'y a pas de flux de travail. Maintenant que notre projet
CircleCI est configuré, nous devons ajouter toutes
ces
variables d'environnement à l'environnement CircleCI réel Pour ce faire, nous pouvons accéder
aux
paramètres du projet ici et aux variables d'
environnement. Et nous pouvons ajouter nos paires de variables d'
environnement à valeur clé. Et nous savons que nous avons l'URL de
notre webhook Slack. Et nous pouvons continuer en ajoutant toutes les variables dont nous savons avoir besoin pour
notre application. J'ai un fuseau horaire. J'ai le calendrier de Cron. Et maintenant, nous devons également en ajouter
quelques-uns pour notre intégration à Docker
Hub Nous devons donc ajouter le
nom d'utilisateur Docker, le login Docker, qui sont en
fait identiques, le passe Docker et
le nom
du dépôt Docker Donc, dans mon cas, mon Docker Hub est le compte de notre entreprise,
Full Stack Craft Je vais donc l'utiliser à la
fois pour le nom d'utilisateur Docker. Et aussi les variables d'
environnement de connexion Docker. Le nom du dépôt Docker est
le nom que vous avez fourni
pour votre Et dans mon cas,
c'est Allergy Cron. Et enfin, le mot de passe
Docker. Bien sûr, je ne vais pas
le montrer ici. Nous avons donc maintenant défini toutes
les variables d'environnement
dont nous avons besoin pour exécuter le pipeline CICD en revenir au code,
puisque dans mon cas, j'ai déjà une branche principale que je ne veux pas gâcher, je vais créer une
branche distincte appelée Pipeline et également mettre à jour ce filtre de branche dans le fichier Yam point de configuration, puis nous pourrons
tester le pipeline Je vais donc simplement le modifier
en Pipeline. Et n'oubliez pas,
bien sûr, que dans votre cas, vous pouvez laisser cela au Maine
ou à la succursale sur laquelle vous
souhaitez que votre
pipeline du CICD soit alimenté Je vais donc créer
cette nouvelle branche avec G checkout B Pipeline. Je peux en effet voir que nous sommes sur
la branche du pipeline. Je vais tout ajouter. Et j'ajouterai un message Quelque chose comme une branche de
pipeline personnalisée, et nous pourrons le pousser. Maintenant, de retour dans CircleCI, nous devrions voir que le
flux de production démarre bel parce que CircleCI voit
ce Nous pouvons cliquer ici
pour voir nos deux offres d'emploi. Nous avons donc notre travail de test et
notre travail publié par Docker. Et même dans les
tâches elles-mêmes, vous pouvez voir toutes les
étapes et le résultat. Il semble donc que nos
tests soient réussis. Il s'agit du résultat habituel que nous avons vu dans
la leçon précédente. Ensuite, bien sûr, de retour
dans le flux de travail, nous passerons
à cette publication Docker, et nous verrons comment cela se passe On dirait que cela a également été un
succès. Et en effet, sur Docker Hub, nous constatons qu'il a été
publié il y a quelques secondes, donc notre pipeline CICD a parfaitement
fonctionné Maintenant, bien que notre build et notre flux de travail
semblent fonctionner, si nous devions extraire notre conteneur Docker
et essayer de l'exécuter, G
se plaindrait de ne pas trouver la variable d'
environnement Nous avons oublié l'étape clé
de notre pipeline CICD à conserver cette
variable d'environnement entre ces deux tâches ce faire, à
la fin de notre travail de test, nous pouvons spécifier cette
commande persist to workspace et nous voulons spécifier que
la racine est ici, et nous allons simplement conserver le fichier point m
que nous créons ici. Ensuite, dans notre commande
Docker publish, nous devons spécifier que lorsque nous publions ou
créons ce conteneur, nous voulons l'attacher à
cette racine actuelle Et puis, lors de la création de Docker, il aura ce fichier d'
environnement dans son espace de travail de construction Donc, une chose très importante
que je tiens à souligner ici est qu'il s'agit d'un
petit risque de sécurité. Veuillez donc noter que
dans ce cas, s'agit d'un conteneur
répertorié publiquement et que le fichier se trouvera
à l'intérieur du conteneur. Cela convient donc aux variables
publiques telles que fuseau horaire Cron et
la chaîne de calendrier Cron, mais
ce n'est pas
le cas pour les secrets
tels que notre webhook Slack Dans ce cas, je vous
suggère de
créer un fichier séparé et de le transmettre lors de l'exécution votre conteneur Docker,
où qu'il se Cependant, ces spécificités de
la gestion des secrets ont tendance à être
très différentes d'une organisation
à l' Je vais donc laisser cela en dehors
du cadre de ce cours. Pour l'instant, nous allons simplement
illustrer comment inclure ce fichier dans notre CICD. Mais veuillez noter qu'il s'agit d'un problème de sécurité potentiel. Une dernière petite modification
que nous devons apporter ici dans notre fichier amo configuré consiste à échapper à cette variable d'environnement cron
schedule Parce que nous avons ces
astérisques ici, lorsque CircleCI
les échappe, nous avons un comportement
étrange Donc, pour y remédier, il suffit de placer cette
variable entre guillemets doubles, qui résoudra le problème de
répercussion de cette valeur
dans notre fichier final En guise de test final
pour notre conteneur, je vais modifier ce calendrier des couronnes
dans les prochaines minutes, puis nous pourrons retirer
notre conteneur, le faire fonctionner et nous assurer que tout
fonctionne et fonctionne,
en effet, au moment où
nous avons défini notre calendrier cron Il est donc environ 4 h 18 en ce moment. Je vais donc le supprimer
et le rajouter. Faisons-le pour 225. C'est donc la 25e minute, 14e heure, puis les
astérisques pour toutes les autres Je peux le rajouter. Et de retour au projet ici, je vais réexécuter le
dernier flux de travail pour assurer que le conteneur est reconstruit avec cette nouvelle variable. Il suffit donc d'attendre ici que
le pipeline soit terminé, puis nous pourrons accéder
à Doctor Hub, obtenir notre identifiant de conteneur et exécuter ce conteneur. Le pipeline est donc terminé, et si nous passons ici, à Docker Hub, nous
voyons notre nouvelle image
vient d'être publiée Nous cliquons dessus. Nous
pouvons obtenir l'identifiant complet. Je vais copier ça.
Ensuite, pour l'exécuter, nous pouvons lancer Docker Run Ensuite, nous voulons le document détaché et l'identifiant
complet du conteneur. Il va être téléchargé pour
nous et commencer à l'exécuter. Nous pouvons donc vérifier qu'
il fonctionne avec P A. Nous voyons qu'il fonctionne
et qu'aucun journal n'est encore enregistré, mais nous pensons qu'à 14 h 25, nous devrions recevoir une
copie enregistrée de notre message Slack
et, bien sûr, du message
Slack OK, donc 225 vient de passer. Jetons un coup d'œil à notre slack ici. En effet, nous avons bien compris ce message. Il pleut donc un peu aujourd'hui. La charge en pollen est légèrement
inférieure à la moyenne. Quelques bonnes choses que je dois savoir. Et si nous revenons
ici à nos journaux Docker, nous obtenons cette copie
du message
envoyé
depuis le message de journal que nous avons mis en point
principal pour revenir
en arrière Alors, félicitations. Vous avez atteint la fin de la dernière
leçon de codage technique de ce cours. Il ne reste qu'une leçon, c'est le
genre d'Outro et de leçon
récapitulative qui passe en revue ce que
nous avons abordé dans ce cours,
ainsi que sur l'endroit où
vous pouvez trouver le code, le livre et toute autre ressource
supplémentaire
pour le
19. Outro: Alors félicitations. C'est ça. C'est la fin de ce cours
pour les
applications dans le monde réel. J'espère que vous avez aimé
le prendre autant que j'ai aimé le préparer. Pour rappel, il existe une version PDF
de ce cours. J'ajouterai le lien vers ce lien
dans les ressources de la leçon. Il existe également le
référentiel GitHub pour ce cours où chaque leçon correspond à tout ce que nous avons fait
dans cette leçon Ils sont nommés par branche. C'est donc tout ce que j'
ai de mon côté. Amusez-vous bien à écrire du code G, et je
vous recontacterai tous la prochaine fois. O.