Début avec des robots Slack

Slack est un outil populaire pour encourager une meilleure communication entre les membres de l'équipe. Il est livré avec une multitude de fonctionnalités et de services utiles, notamment des intégrations tierces et une prise en charge WebHook. Slack Webhooks peut être amusant et utile, et ils sont faciles à configurer. Dans ce tutoriel, nous allons configurer un serveur simple à l'aide de Node.js et Heroku qui répondra aux messages de votre équipe de Slack en tant que «bot». La familiarité avec JavaScript et Git sera utile. Si vous n'avez pas utilisé Git auparavant, jetez un œil à Git pour que les débutants commencent. L'accès à un compte Slack est également supposé, mais ne vous inquiétez pas - ils sont gratuits!

Les plats clés

• Slack Bots Simplified: la configuration d'un bot Slack consiste à créer une intégration via l'interface Web de Slack, à configurer des webhooks et à utiliser Node.js et Express pour créer un serveur qui interagit avec les messages Slack.
• Déploiement de Node.js et Heroku: utilisez un cadre express pour la configuration du serveur et Heroku pour le déploiement du bot, garantissant que le bot est accessible en ligne.
• Logique d'interaction bot: développez la logique du bot pour répondre aux commandes spécifiques dans Slack, telles que saluer les utilisateurs ou les commandes de traitement comme les rouleaux de dés, avec des réponses formatées dans JSON.
• Capacités de bot en expansion: explorez d'autres intégrations telles que les commandes de slash et les webhooks entrants pour améliorer les fonctionnalités des bot, permettant des réponses plus interactives et dynamiques dans les canaux lâches.
• Développement et intégration continues: encourager le développement continu en s'intégrant à diverses API (par exemple, GitHub, Yelp) pour élargir l'utilité du bot, ce qui en fait un outil polyvalent pour la collaboration et la productivité de l'équipe.

Création d'une nouvelle intégration de mou

À partir de l'interface Web Slack, ouvrez le menu dans le coin supérieur gauche à côté du nom de votre équipe et sélectionnez Configurer les intégrations. Ici, vous pouvez voir un tableau de bord avec toutes les intégrations à votre disposition. Faites défiler vers le bas dans les intégrations et personnalisations de bricolage et ajoutez un webhook sortant. Lisez la brève description, puis cliquez sur Ajouter une intégration sortante de webhooks.

Vous verrez la configuration sortante de webhook et un exemple de ce à quoi les charges utiles de la demande et de la réponse devraient ressembler. Notre premier bot saluera simplement l'utilisateur lorsqu'il est appelé. Pour ce faire, nous permettons au crochet d'écouter le mot de déclenchement «bonjour» sur n'importe quelle chaîne. Nous ne connaissons pas encore l'URL à laquelle elle publiera, donc nous reviendrons sur cette page plus tard.

Création d'un serveur Web

Nous utiliserons Express 4 sur Node.js pour créer un serveur Web simple.

Créez un nouveau répertoire pour votre application et exécutez NPM init pour générer votre fichier package.json. Dans votre package.json les dépendances, incluez "Express": "^ 4.x.x" et "Body-Parser": "^ 1.x.x". Le package de carrosserie sera utilisé pour analyser la charge utile envoyée de Slack. Créez le fichier serveur nommé app.js. Ici, nous aurons besoin des modules nécessaires, ajouter le middleware de l'analyseur corporel, le gestionnaire d'erreurs et un itinéraire de test. Ensuite, nous disons au serveur de commencer à écouter.

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Exécutez le serveur avec l'application Node et vérifiez que la visite http: // localhost: 3000 répond avec "Hello World!".

Écriture de la logique bot

Créez un fichier nommé hellobot.js

Ce module sera là où vit notre logique de bot. Il comprendra une fonction exportée qui renvoie un message à Slack avec le code d'état 200. Nous commencerons par analyser les données que Slack envoie à notre serveur, puis nous répondrons avec une charge utile correctement formatée. Pour ce faire, révisons notre webhook sortant sous des intégrations configurées. L'exemple de données sortant nous montre toutes les informations que Slack envoie lorsqu'un webhook est déclenché.

Vous pouvez voir que certaines des données peuvent être utiles pour l'authentification ou le routage, mais pour l'instant, nous allons simplement nous concentrer sur la propriété user_name. En utilisant cette valeur, nous pouvons renvoyer une salutation personnalisée à l'utilisateur.

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Ici, nous créons notre objet BotPayload. La seule propriété nécessaire est botpayload.text, qui définit ce que notre bot affiche lorsque nous répondrons. Ajoutez la propriété texte avec une salutation à l'utilisateur et répondez avec JSON et un code d'état de 200. Notez que la réponse de notre bot est notre mot de déclenchement sortant de WebHook! Pour éviter une boucle infinie, nous pouvons vérifier le nom de l'utilisateur du corps. Tous les crochets publient comme «Slackbot», même si le nom apparaît différemment dans le chat. Nous pouvons utiliser ce fait pour empêcher notre crochet de répondre à lui-même.

de retour dans app.js, nécessite le module bot en haut.

<span>var hellobot = require('./hellobot');</span>

Ensuite, ajoutez un itinéraire qui écoute un message à / bonjour.

app<span>.post('/hello', hellobot);</span>

faisons un test rapide. Exécutez à nouveau l'application à l'aide de l'application Node, et dans une autre fenêtre de terminal, utilisez Curl pour vous assurer que l'application répond comme nous le nous attendons. (Remarque: puisque notre bot ne cherche qu'une seule valeur ici, il n'est pas nécessaire d'inclure toute la charge utile de Slack dans notre test).

curl -X POST --data "user_name=foobar" http://localhost:3000/hello

Si notre application fonctionne, nous devrions voir une réponse qui ressemble à ceci:

<span>{"text":"Hello, foobar!"}</span>

Maintenant, il est temps de mettre notre bot en ligne.

Déploiement de l'application sur Heroku

Heroku est un service pratique qui vous aide à obtenir un serveur Web en ligne gratuitement en très peu de temps. Les déploiements sont effectués en poussant votre code à leur serveur GIT où il est automatiquement déployé et exécuté. Créez un compte sur Heroku ou connectez-vous si vous avez déjà un compte.

Une fois que vous vous êtes connecté, vous verrez votre tableau de bord Heroku. Cliquez en haut à droite pour créer une nouvelle application. Suivez les instructions fournies pour vous connecter à Heroku sur votre ordinateur. Le déploiement est facile, mais il y a beaucoup à savoir la première fois que vous déployez une application. Assurez-vous de suivre ce guide lorsque vous créez votre application. Nous allons faire des doubles chèques en cours de route, mais il y a beaucoup de bonnes informations qui se trouvent en dehors de la portée de cet article.

Avant de déployer notre bot, nous devrons dire à Heroku comment exécuter l'application. Cela se fait en créant un ProCfile. Votre Profile n'a besoin que d'une seule ligne:

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Une fois que vous avez fait cela, vous pouvez commettre vos modifications et pousser à Heroku. Heroku installe automatiquement les modules de nœud et vous verrez les résultats de votre déploiement. Si tout s'est bien passé, vous verrez un lien vers votre application en bas. Copiez cette URL, puis visitez à nouveau la page de configuration de votre webhook sortant. Ajoutez l'URL que vous avez copiée au champ de saisie URL (S) avec la route / Hello Alust et modifiez le nom et l'icône du crochet si vous le souhaitez.

Il y a une étape de plus pour obtenir le bot en ligne: nous devons lui donner un dyno. Dans le terminal, entrez:

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Cela dit à Heroku de donner à votre application un travailleur Web. Prudent; Votre application ne reçoit qu'un dyno gratuit par mois!

Votre bot devrait être en ligne maintenant, alors retournez dans Slack et testez-le!

Si vous n'avez pas obtenu de réponse, revenez en arrière et vérifiez votre code. Vous pouvez utiliser les journaux Heroku Command Command Terminal pour voir des détails sur les demandes ainsi que sur toutes les instructions console.log () que vous avez ajoutées.

Pas trop difficile, n'est-ce pas? Nous avons réussi à installer un webhook dans Slack, avons déployé notre application à Heroku et a fait parler les deux! Un peu plus de travail qu'un simple programme «Hello World», mais beaucoup plus enrichissant. Maintenant que nous avons notre serveur en cours d'exécution, nous pouvons facilement ajouter plus de crochets et de réponses. Hellobot est assez sympathique, mais ce n'est pas si utile. Dans la section suivante, nous utiliserons les autres types de webhook de Slack pour créer une commande de chat à rouleau de dés.

DICEBOT - Utilisation de commandes Slack et de webhooks entrants

Dans la dernière section, nous avons utilisé un webhook sortant qui a écouté discuter pour un mot de déclenchement, envoyé un message à notre serveur et affiché la réponse. Dans cette section, nous utiliserons deux autres outils pour créer des intégrations personnalisées: les commandes de slash et les webhooks entrants. Visitez la page Configurer les intégrations et jetez un œil aux autres options sous les intégrations et personnalisations DIY. Commençons par ajouter l'intégration des commandes de slash. Lisez la brève description, définissez la commande sur «/ roll» et ajoutez l'intégration. La page suivante montre la configuration. Vous pouvez voir que les données sortantes ressemblent à la ligne Web sortante que nous avons configurée plus tôt. Nous utiliserons l'application que nous avons créée dans la dernière section pour cette section, afin que nous puissions utiliser la même URL, mais cette fois, nous publierons sur l'itinéraire / rouleau.

Notez que l'intégration de la commande SLASH peut répondre à l'utilisateur, mais uniquement en privé. À quoi sert un rouleau de dés si seulement vous pouvez voir les dés? Slack suggère d'utiliser un webhook entrant en tandem avec des commandes de barre oblique pour envoyer des messages pour discuter. Revenez à la page Configurer les intégrations et ajoutez un webhook entrant. Lisez la description, sélectionnez un canal et ajoutez le crochet. Ne vous inquiétez pas de la chaîne que vous avez choisie; Nous pouvons spécifier le canal dans la réponse de notre bot. Parce que nous pouvons choisir le canal dans notre application, cela signifie que nous pouvons également utiliser cette intégration pour tous les autres robots que nous créons. Le WEBHOOK entrant n'a pas beaucoup de configuration, mais il a beaucoup d'informations importantes pour construire les charges utiles de réponse de notre bot. La partie la plus importante est l'URL Webhook. Nous publierons cela à partir de notre application afin d'envoyer des messages à Slack.

Répondre aux commandes de slash du serveur

Étant donné que nous avons pointé notre commande de slash sur l'itinéraire / rouleau, nous pouvons ajouter cette voie à notre serveur aux côtés de HelloBot. Nous utiliserons une URL secrète pour notre crochet entrant, donc c'est une bonne idée de le garder caché au cas où vous voudriez rendre votre code public. Une bonne façon de le faire est d'utiliser la configuration d'Héroku Vars.

Ajoutons également de la demande à notre package à utiliser avec le crochet entrant:

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

Maintenant, nous allons ajouter DICEBOT.js. DICEBOT exportera une fonction, mais nous aurons besoin de deux fonctions supplémentaires: une pour publier sur le webhook entrant, et une pour lancer les dés.

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Comme de nombreux joueurs de table le savent, il y a beaucoup plus de types de dés que les dés à six faces. D'autres dés ont quatre côtés, huit côtés, dix côtés, vingt côtés et plus encore! Une notation spéciale est utilisée lors du lancement de ces dés: D . Ainsi, rouler deux dés à six faces est considéré comme «2d6». Nous pouvons permettre aux utilisateurs de rouler plusieurs dés en utilisant cette notation, mais nous devrons vérifier les entrées correctes de l'utilisateur.

Commençons par initialiser certaines variables et analyser l'entrée. Nous allons définir certaines valeurs par défaut au cas où l'utilisateur souhaite omettre l'entrée.

<span>var express = require('express');
</span><span>var bodyParser = require('body-parser');
</span>
<span>var app = express();
</span><span>var port = process.env.PORT || 3000;
</span>
<span>// body parser middleware
</span>app<span>.use(bodyParser.urlencoded({ extended: true }));
</span>
<span>// test route
</span>app<span>.get('/', function (req<span>, res</span>) { res.status(200).send('Hello world!') });
</span>
<span>// error handler
</span>app<span>.use(function (err<span>, req, res, next</span>) {
</span>  <span>console.error(err.stack);
</span>  res<span>.status(400).send(err.message);
</span><span>});
</span>
app<span>.listen(port, function () {
</span>  <span>console.log('Slack bot listening on port ' + port);
</span><span>});</span>

L'expression régulière ci-dessus est assez fiable pour l'analyse des jets de dés et limite les valeurs à des nombres à deux chiffres uniquement afin que l'utilisateur ne puisse pas devenir fou. Si l'utilisateur a gâché sa syntaxe, nous renvoyons un indice.

Rouler les dés avec l'entrée utilisateur est assez facile. Voir ce fil pour une explication du fonctionnement d'un jet aléatoire. Pour des rouleaux vraiment aléatoires, vous pouvez contacter l'API Random.org. Écrivons la fonction Roll.

module<span>.exports = function (req<span>, res, next</span>) {
</span>  <span>var userName = req.body.user_name;
</span>  <span>var botPayload = {
</span>    <span>text : 'Hello, ' + userName + '!'
</span>  <span>};
</span>
  <span>// avoid infinite loop
</span>  <span>if (userName !== 'slackbot') {
</span>    <span>return res.status(200).json(botPayload);
</span>  <span>} else {
</span>    <span>return res.status(200).end();
</span>  <span>}
</span><span>}</span>

Ensuite, dans notre fonction principale, nous ferons des rouleaux et construire un message pour répondre. Incluons le nom du rouleau afin que les autres utilisateurs puissent voir qui a utilisé la commande / roll.

<span>var hellobot = require('./hellobot');</span>

Nous avons ajouté le message à la propriété botpayload.text avec un peu de formatage de Slack autour du total pour le rendre audacieux. Nous pouvons également configurer le nom, l'icône et le canal en utilisant la charge utile de réponse. Nous allons définir la chaîne en fonction de la chaîne à partir de la commande de l'utilisateur. Slack suggère d'utiliser le nom de la chaîne dans la charge utile, mais cela signifie que nous devions le présenter avec "#". Au lieu de cela, nous pouvons utiliser l'ID de canal, qui nous permettra de publier dans les canaux publics ainsi que dans des groupes privés. Pour l'icône, un emoji pratique pratique existe, bien que vous puissiez fournir une meilleure image en utilisant icon_url.

app<span>.post('/hello', hellobot);</span>

La charge utile a l'air bien. Écrivons la fonction Envoyer. J'ai choisi de stocker uniquement les jetons de chemin dans la configuration d'Heroku. Assurez-vous d'envoyer le corps en tant que chaîne de JSON.

curl -X POST --data "user_name=foobar" http://localhost:3000/hello

Dans notre fonction principale, nous lancerons la demande d'envoi. Si cela fonctionne, nous pouvons répondre à la commande Slash avec un 200 vide. Sinon, nous pouvons utiliser les valeurs de notre rappel Send () pour créer une erreur. Cela déclenchera le gestionnaire d'erreurs dans app.js et renvoie 400, ce qui informera l'utilisateur de l'erreur.

<span>{"text":"Hello, foobar!"}</span>

Exécutez notre serveur et bouclons-le à nouveau. Cette fois, nous devrons inclure le canal_id. Vous pouvez utiliser le testeur API Slack pour trouver le bon canal_id. Étant donné que le webhook entrant a déjà été configuré, il devrait entendre notre serveur l'appeler. Nous devrons également inclure le chemin Web de WEBHook entrant dans notre environnement car l'application n'est pas encore sur Heroku.

web: node app

heroku ps:scale web=1

a l'air bien! Déployons-le.

redéployer à Heroku

Étant donné que nous avons utilisé les Vars de la configuration d'Heroku pour stocker le jeton de notre webhook, n'oubliez pas de le définir dans le menu des paramètres de l'application.

Ensuite, utilisez GIT pour ajouter les nouveaux fichiers, commettre vos modifications et appuyer sur votre télécommande Heroku. Heroku installera les modules de nœud et démarrera le serveur. Avant de le tester, commençons à regarder les journaux en temps réel: HEROKU LOGS -T

Avec nos crochets tous configurés, notre commande Roll doit être prête à partir. Essayez quelques rouleaux! Si quelque chose ne fonctionnait pas, vous pouvez utiliser les journaux Heroku pour déboguer. Pour voir l'application terminée dans son intégralité, consultez ce repo GitHub.

Développement continu

Ces deux robots démontrent tous les outils dont vous avez besoin pour commencer à écrire vos propres robots de chat et intégrations. Vous pouvez intégrer de nombreux services dans des bots, ou vous pouvez essayer de faire un partenaire de conversation convaincant. Les modules API et Node existent pour que vous puissiez atteindre ces deux objectifs.

Quelques autres idées pour les robots:

• un bot qui utilise l'API GitHub pour vous montrer des demandes d'ouverture de traction
• un bot qui utilise l'API Yelp pour aider votre équipe à décider du déjeuner
• un bot qui vous recherche Google
• un bot qui vous ne parle qu'avec des mots à la mode et un jargon

Si vous trouvez de bonnes idées, partagez votre code! Les robots sont amusants à faire, et ils n'ont jamais été aussi faciles à créer.

Les questions fréquemment posées (FAQ) sur les bots Slack

Comment puis-je créer un bot Slack?

La création d'un bot Slack implique quelques étapes. Tout d'abord, vous devez vous rendre sur le site Web de l'API Slack et créer un nouvel utilisateur de bot. Vous devrez donner un nom à votre bot et choisir un espace de travail où il fonctionnera. Après avoir créé le bot, vous recevrez un jeton d'accès à user de Bot, que vous utiliserez pour authentifier votre bot dans votre code. Ensuite, vous pouvez commencer à écrire le code de votre bot à l'aide d'un langage de programmation comme JavaScript ou Python. Vous utiliserez l'API Slack pour envoyer et recevoir des messages.

Quelles sont les fonctionnalités utiles que je peux ajouter à mon bot Slack?

Il existe de nombreuses fonctionnalités que vous pouvez ajouter à votre bot Slack en fonction sur ce que vous voulez qu'il fasse. Par exemple, vous pouvez programmer votre bot pour répondre à des commandes ou des mots clés spécifiques, envoyer des messages planifiés ou même vous intégrer à d'autres API pour extraire des données provenant de sources externes. Vous pouvez également ajouter des éléments interactifs comme des boutons ou des menus déroulants aux messages de votre bot.

Comment puis-je tester mon bot Slack?

Vous pouvez tester votre bot Slack en l'invitant à une chaîne de votre canal dans votre Espace de travail et interagissant avec lui. Vous pouvez envoyer des messages au bot et vérifier s'il répond correctement. Vous pouvez également utiliser les méthodes de l'API Slack pour les tests, telles que les méthodes API.test et Auth.test.

Puis-je utiliser mon bot Slack dans plusieurs espaces de travail?

Oui, vous pouvez utiliser Votre bot Slack dans plusieurs espaces de travail. Vous devrez installer le bot dans chaque espace de travail où vous souhaitez qu'il fonctionne. Chaque espace de travail aura son propre token d'accès à user de bot, que vous utiliserez pour authentifier votre bot dans cet espace de travail.

Comment puis-je améliorer les performances de mon bot Slack?

Il existe plusieurs façons d'améliorer les performances de votre bot Slack. Une façon consiste à optimiser votre code en réduisant les appels API ou le traitement inutiles. Vous pouvez également utiliser la mise en cache pour stocker des données que votre bot utilise fréquemment, en réduisant le besoin d'appels API répétés. De plus, vous pouvez utiliser des techniques de programmation asynchrones pour permettre à votre bot d'effectuer plusieurs tâches en même temps.

Comment puis-je faire en sorte que mon bot mou avec les utilisateurs?

Vous pouvez faire de votre bot Slack Interagissez avec les utilisateurs en le programmant pour répondre aux messages ou aux commandes. Vous pouvez utiliser l'événement de message pour écouter les messages entrants et la méthode Chat.PostMessage pour envoyer des messages. Vous pouvez également ajouter des éléments interactifs comme des boutons aux messages de votre bot, quels utilisateurs peuvent cliquer pour déclencher des actions.

Puis-je intégrer mon bot Slack avec d'autres services?

Oui, vous pouvez intégrer votre Slack bot avec d'autres services. Slack fournit une variété d'API et de fonctionnalités qui vous permettent de vous intégrer à des services externes. Par exemple, vous pouvez utiliser des webhooks entrants pour recevoir des données d'autres services ou des webhooks sortants pour envoyer des données à d'autres services.

Comment puis-je gérer les erreurs dans mon bot Slack?

Vous pouvez gérer Erreurs dans votre bot Slack en utilisant des techniques de gestion des erreurs dans votre langage de programmation. Par exemple, dans JavaScript, vous pouvez utiliser les instructions Try ... Catch pour attraper et gérer les erreurs. Vous pouvez également utiliser l'événement d'erreur pour écouter les erreurs qui se produisent pendant que votre bot est en cours d'exécution.

Puis-je personnaliser l'apparence de mon bot Slack?

Oui, vous pouvez personnaliser l'apparence de Votre bot Slack. Vous pouvez définir une icône personnalisée et un nom pour votre bot lorsque vous le créez. Vous pouvez également personnaliser l'apparence des messages de votre bot en utilisant des pièces jointes ou des blocs, qui vous permettent d'ajouter de la couleur, des images et d'autres formatations.

Comment puis-je assurer la sécurité de mon bot mou?

Vous pouvez assurer la sécurité de votre bot Slack en suivant les meilleures pratiques pour le développement de BOT. Cela comprend le secret de votre utilisateur de Bot User et ne le partage avec personne. Vous devez également valider toutes les données que votre bot reçoit pour vous assurer qu'elle provient d'une source de confiance. De plus, vous devez régulièrement mettre à jour le code de votre bot pour corriger toutes les vulnérabilités de sécurité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!