gort
v0.9.2
Gort est un framework de chatbot conçu dès le départ pour les chatops.
Gort apporte la puissance de la ligne de commande là où vous collaborez avec votre équipe : votre fenêtre de discussion. Sa prise en charge ouverte de l'ensemble de commandes permet aux développeurs d'implémenter des fonctionnalités dans le langage de leur choix, tandis qu'un contrôle d'accès puissant signifie que vous pouvez collaborer en toute confiance, même sur les tâches les plus sensibles. En mettant l'accent sur l'extensibilité et l'adaptabilité, vous pouvez réagir rapidement aux imprévus, sans que votre équipe ne perde de visibilité.
La documentation officielle peut être trouvée ici : The Gort Guide.
Gort a été initialement conçu comme une réimplémentation Go de Cog d'Operable, et bien qu'il reste fortement inspiré par Cog, Gort a largement suivi son propre chemin.
Au cours de notre discussion initiale sur la conception, nous avons constaté que de nombreuses fonctionnalités de Cog, aussi innovantes soient-elles, restaient largement inutilisées et que la base de code était devenue difficile à étendre et à maintenir. De plus, son langage d’implémentation – Elixir – comptait relativement peu de développeurs compétents. La solution, qui a été discutée pendant de nombreux mois sur l'espace de travail Cog Slack, consistait à réécrire Cog à partir de zéro dans Go, en supprimant certaines fonctionnalités les moins utilisées et en réduisant la complexité du processus.
Cela nous a donné l’occasion de réfléchir et éventuellement de redéfinir ce que Cog était censé être. Choisir les fonctionnalités qui ont du sens et écarter celles qui ne le sont pas. De cette manière, Gort peut être décrit davantage comme un « successeur spirituel » de Cog que comme une réimplémentation fidèle.
La philosophie de conception de Gort met l'accent sur la flexibilité et la sécurité en vous permettant de créer des commandes dans le langage de votre choix, en utilisant des outils avec lesquels vous êtes déjà à l'aise et en contrôlant étroitement qui peut les utiliser et comment.
Plus précisément :
Chacun d’eux est décrit plus en détail ci-dessous.
Les utilisateurs interagissent principalement avec Gort via des commandes , qui sont déclenchées par un caractère de commande ( ! par défaut) mais qui sont par ailleurs conceptuellement identiques aux commandes saisies sur la ligne de commande.
Par exemple, l'utilisation d'une commande echo pourrait ressembler à ceci :
Comme indiqué, le résultat des commandes réussies est relayé par Gort.
Plus d'informations sur les commandes peuvent être trouvées dans le Guide Gort :
Les commandes Gort sont créées sous forme d'images de conteneur, ce qui signifie que vous pouvez les créer dans n'importe quelle langue avec laquelle vous êtes à l'aise.
De plus, étant donné que votre exécutable reçoit toutes les entrées de discussion exactement comme si elles étaient saisies sur la ligne de commande, vous pouvez utiliser n'importe quel interpréteur de ligne de commande de votre choix. Les commandes peuvent même être implémentées sous forme de scripts Bash ou en utilisant des commandes existantes, comme curl !
Plus d'informations sur l'écriture de commandes peuvent être trouvées dans le Guide Gort :
Dans Gort, un ensemble d'une ou plusieurs commandes associées peut être installé sous forme de « ensemble de commandes ».
Un bundle est représenté en YAML, spécifiant quel exécutable utiliser pour chaque commande et qui est autorisé à exécuter chaque commande.
Un fichier bundle très simple est présenté ci-dessous.
---
gort_bundle_version : 1
name : echo
version : 0.0.1
image : ubuntu:20.04
author : Matt Titmus <[email protected]>
homepage : https://guide.getgort.io
description : A test bundle.
long_description : |-
This is an example bundle. It lets you echo text using the "echo"
command that's built into Ubuntu 20.04.
permissions :
- can_echo
commands :
echo :
description : " Echos back anything sent to it. "
executable : [ "/bin/echo" ]
rules :
- must have echo:can_echo Cela montre un bundle appelé echo , qui définit une commande (également appelée echo ) et une autorisation appelée can_echo . Une fois installé, tout utilisateur disposant de l'autorisation echo:can_echo peut l'exécuter dans Slack.
Plus d’informations sur les bundles peuvent être trouvées dans le Guide Gort :
Dans Gort, les utilisateurs peuvent être mappés de manière unique aux utilisateurs d'un ou plusieurs fournisseurs de chat. Les utilisateurs de Gort peuvent être membres d'un ou plusieurs groupes , qui à leur tour peuvent avoir un certain nombre de rôles pouvant être considérés comme des ensembles d'autorisations accordées. Par exemple, l'utilisateur dave peut faire partie d'un groupe appelé developers . Ce groupe peut être associé à un rôle nommé deployers qui contient un certain nombre d'autorisations, dont une appelée production_deploy .
Plus d’informations sur les autorisations et les règles peuvent être trouvées dans le Guide Gort :
Un système de règles sophistiqué peut être appliqué pour chaque commande définissant qui peut l'utiliser. Ceux-ci peuvent être assez granulaires et sont même capables de prendre des décisions d'autorisation basées sur les valeurs d'indicateurs ou de paramètres spécifiques.
Les règles sont attribuées au niveau du bundle et peuvent être assez sophistiquées. Ci-dessous, nous avons un sous-ensemble d'un ensemble appelé deploy .
name : deploy
version : 0.0.1
permissions :
- production_deploy
commands :
deploy :
description : " Deploys to the chosen environment. "
executable : [ "/bin/deploy" ]
rules :
- with arg[0] == "production" must have deploy:production_deploy Comme vous pouvez le voir, l'exemple ci-dessus inclut une commande, également appelée deploy . Sa seule règle affirme que tout utilisateur passant "production" comme paramètre doit avoir l'autorisation production_deploy (à partir du bundle deploy ).
Plus d’informations sur les autorisations et les règles peuvent être trouvées dans le Guide Gort :
Gort fournit un système de modèles sophistiqué qui vous permet de contrôler la présentation de toute information envoyée aux utilisateurs, y compris les messages système, ainsi que les sorties de commandes et les messages d'erreur.
De plus, les modèles peuvent être définis au niveau de l'application dans la configuration, ou au niveau du bundle ou même au niveau de la commande dans les configurations de bundle individuelles.
Les modèles Gort utilisent la syntaxe des modèles de Go pour formater la sortie de manière indépendante du chat. Par exemple, un modèle de commande très simple pourrait ressembler à ceci :
{{ text | monospace true }}{{ .Response.Out }}{{ endtext }}
Ce modèle émet la réponse de la commande ( .Response.Out ) sous forme de texte à espacement fixe, qui peut ressembler à ce qui suit :
Un modèle légèrement plus compliqué, celui-ci un modèle d'erreur de commande (en fait le modèle par défaut), est présenté ci-dessous.
{{ header | color "#FF0000" | title .Response.Title }}
{{ text }}The pipeline failed planning the invocation:{{ endtext }}
{{ text | monospace true }}{{ .Request.Bundle.Name }}:{{ .Request.Command.Name }} {{ .Request.Parameters }}{{ endtext }}
{{ text }}The specific error was:{{ endtext }}
{{ text | monospace true }}{{ .Response.Out }}{{ endtext }}
Celui-ci comprend un en-tête avec une couleur et un titre, ainsi qu'une alternance de texte à espacement fixe et standard. Dans ce cas, cela formatera une erreur de commande semblable à ce qui suit :
Vous remarquerez quelques références à .Response : ce sont des références à l' enveloppe de réponse , une structure de données accessible à partir de n'importe quel modèle qui met à disposition toutes les données et métadonnées autour d'une requête, d'une exécution et d'une réponse de commande.
Plus d’informations sur la journalisation d’audit peuvent être trouvées dans le Guide Gort :
Gort prend en charge Slack et Discord en tant que fournisseurs de chat de première classe.
Chaque fournisseur de chat pris en charge dispose d'une section dédiée dans la configuration. Notez que chacun d'entre eux est une liste, vous pouvez donc non seulement interagir avec Slack et Discord à partir du même contrôleur Gort, mais vous pouvez également interagir avec plusieurs instances de chacun si vous le souhaitez !
Une fois que vous avez créé un utilisateur de bot selon les instructions fournies dans Gort Quick Start, les administrateurs n'ont qu'à créer un utilisateur Gort (si ce n'est pas déjà fait) et mapper cet utilisateur Gort à un ID utilisateur de fournisseur de chat, comme indiqué. ci-dessous:
$ gort user create mtitmus --email [email protected] --name " Matt Titmus " --password REDACTED
User " mtitmus " created.
$ gort user list
USER NAME FULL NAME EMAIL
admin Gort Administrator gort@localhost
mtitmus Matt Titmus [email protected]
$ gort user map mtitmus Slack U012P123456
User " mtitmus " mapped to " Slack:U012P123456 " .
$ gort user info mtitmus
Name mtitmus
Full Name Matt Titmus
Email [email protected]
Groups < undefined >
ADAPTER ID MAPPING
Slack U012P123456À partir de là, toutes les commandes saisies par l'utilisateur du chat mappé sont associées à cet utilisateur Gort !
Toutes les activités de commande sont à la fois émises sous forme d'événements de journal à haute cardinalité (illustrés ci-dessous) et enregistrées dans un journal d'audit conservé dans la base de données de Gort.
Prenons, par exemple, un utilisateur exécutant la commande !bundle list depuis Slack :
Cela générera une sortie de journal similaire à celle-ci :
INFO [49594] Triggering command adapter.name=Gort bundle.default=false bundle.name=gort bundle.version=0.0.1
command.executable="[/bin/gort bundle]" command.name=bundle
command.params=list gort.user.name=admin provider.channel.id=C1238A01234
provider.channel.name=gort-dev [email protected]
provider.user.id=U012P123456 trace.id=476b3089c8ce0d38a2915a3b58fde032
Comme vous pouvez le constater, ce riche événement comprend :
Notez que cet exemple utilise un format « lisible par l'homme » pour plus de lisibilité. En mode production, Gort génère des événements de journal codés en JSON.
Plus d’informations sur la journalisation d’audit peuvent être trouvées dans le Guide Gort :
Pour plus d'informations, consultez le guide de démarrage rapide dans le guide Gort.
Le binaire gort sert également de CLI d’administration du contrôleur.
Le client gort utilise un fichier de configuration au format YAML, classiquement situé dans le fichier profile dans un répertoire .gort de votre répertoire personnel. C'est ici que vous pouvez stocker les informations d'identification de connexion pour permettre gort d'interagir avec l'API REST du contrôleur Gort.
Un exemple de fichier .gort/profile pourrait ressembler à ceci :
defaults :
profile : gort
gort :
url : https://gort.mycompany.com:4000
password : " seekrit#password "
user : me
preprod :
url : https://gort.preprod.mycompany.com:4000
password : " anotherseekrit#password "
user : me Les commentaires commencent par un caractère # ; si votre mot de passe contient un # , entourez le mot de passe entier entre guillemets, comme illustré ci-dessus.
Vous pouvez stocker plusieurs "profils" dans ce fichier, avec un nom différent pour chacun (ici, nous avons gort et preprod ). Celui qui est noté comme valeur par défaut (dans la section defaults ) sera utilisé par gort . Cependant, vous pouvez transmettre l'option --profile=$PROFILE à gort pour utiliser un ensemble d'informations d'identification différent.
Bien que vous puissiez ajouter des profils à ce fichier manuellement, vous pouvez également utiliser la commande gort profile create pour vous aider.
L'exécutable gort contient un certain nombre de commandes et sous-commandes. L'aide est disponible pour chacun d'entre eux en passant l'option --help . Commencez par gort --help et continuez à partir de là.
Gort est dans un état de développement actif et intense. Les dates auxquelles les différents jalons ont été atteints sont indiquées ci-dessous. Le nombre et l’orientation des jalons présents et futurs sont susceptibles de changer.
