Perfekt erstellen Sie einen Slack-Bot, um GitHub-Aktionen über Hubot aufzurufen

Tutorials

Wenn Sie GitHub Actions als Ihre Build- und Release-Pipeline verwenden und Ihr Team auch Slack nutzt, wussten Sie, dass Sie Slack überhaupt nicht verlassen müssen? Erstellen Sie einen Slack-Bot, um GitHub Actions-Workflows direkt aus Slack automatisch aufzurufen!

In diesem Tutorial erfahren Sie, wie Sie einen neuen Slack-Chatbot einrichten, der das Bot-Building-Tool namens Hubot verwendet und automatisch einen GitHub Actions-Workflow startet, um Code auf einem Server bereitzustellen.

Legen wir los!

Voraussetzungen

In diesem Tutorial wird eine praktische Demonstration durchgeführt. Wenn Sie mitmachen möchten, stellen Sie bitte sicher, dass Sie folgendes haben:

  • A Slack Workspace
  • A GitHub account and a GitHub personal token
  • A Linux server to deploy code to – This tutorial will use Ubuntu 19.
  • A local Linux machine – This tutorial will use Ubuntu so that all local commands will be Linux. If you’re running another operating system, the commands may be slightly different.
  • SSH-Zugangsdaten, um sich mit dem Server zu verbinden, auf den Sie den Code bereitstellen werden.
  • A code editor of your choice that understands YAML like Visual Studio Code.

Verwandt:Automatisierung von Client-seitigen Git-Aktionen mit Git Hooks

Projekt erstellen und GitHub Actions-Workflow erstellen

Bevor Sie GitHub Actions-Workflows schnell aus Slack aufrufen können, müssen Sie zuerst den Workflow erstellen.

Um den Workflow zu erstellen, erstellen wir einen Projektordner, um alle Dateien zu speichern, mit denen Sie arbeiten werden.

Verwandt:Wie man Visual Studio Code GitHub Setup in Gang bringt!

1. Öffnen Sie Ihre bevorzugte Terminalanwendung.

2. Führen Sie jetzt die folgende Befehlsreihe aus, um den Projektordner namens Hubot zu erstellen und in ihn zu navigieren. 

mkdir ~/Hubot # Erstellen Sie ein Verzeichnis namens Hubot
cd ~/Hubot    # Wechseln Sie zum Verzeichnis Hubot

3. Führen Sie anschließend npm init aus, um eine Node.JS package.json Datei zu erstellen. Durch das Ausführen von npm init wird ein Standard-Node.JS-Projekt erstellt, das die package.json Datei enthält, die verschiedene Informationen über das Projekt und alle abhängigen NPM-Pakete enthält. 

npm init      # Initialisiert die package.json-Datei

4. Erstellen Sie nun ein Workflows Verzeichnis und die deploy.yml Workflow-Datei. Die Workflow-Datei ist eine Reihe von Schritten, die in einer Sequenz definiert sind, der GitHub Actions folgen wird.

mkdir .github/workflows && touch deploy.yml

5. Als nächstes definieren Sie jede der GitHub-Geheimnisse, die Ihr Workflow lesen wird. Der Workflow, den Sie gleich erstellen werden, wird auf diese Geheimnisse verweisen. Da Sie Ihre Serveradresse, Ihren Benutzernamen, Ihr Passwort und Ihren Port Ihres Servers für SSH benötigen werden, erstellen Sie GitHub-Geheimnisse.

Besuchen Sie diese URL https://github.com/yourusername/yourrepository/settings/secrets/actions, wo Sie Ihre GitHub-Geheimnisse hinzufügen werden. Ersetzen Sie yourusername durch Ihren GitHub-Benutzernamen und yourrepository durch Ihr GitHub-Repository.

Klicken Sie auf die Schaltfläche Neues Repository-Geheimnis, wie unten gezeigt, um Informationen über das Geheimnis, das Sie hinzufügen, auszufüllen.

Adding GitHub Secrets

6. Füllen Sie jetzt das Feld Name und Wert des Geheimnisses aus und klicken Sie dann auf Geheimnis hinzufügen, um es zu speichern. Die Seite wird zur GitHub-Geheimnisseite umgeleitet, wo Sie alle Ihre Geheimnisse sehen werden. Um weitere Geheimnisse hinzuzufügen, klicken Sie auf die Schaltfläche Neues Repository-Geheimnis, wie Sie es zuvor getan haben.

Vergewissern Sie sich, dass Sie Geheimnisse für die angegebenen Variablen mit genau dem gleichen Namen speichern, auf den Sie sich später beziehen werden, nämlich HOST, USERNAME, PASSWORD und PORT.

Filling up Information for a GitHub Secret
Viewing All GitHub Secrets

7. Öffnen Sie schließlich die ~/Hubot/.github/workflows/deploy.yml Arbeitsflussdatei in Ihrem Code-Editor und kopieren/einfügen Sie den folgenden Code. Der unten stehende Code ist der Workflow, der ausgeführt wird, wenn Sie später den Workflow über Slack auslösen.

Wenn Sie den Workflow aufrufen, werden ein paar Aktionen stattfinden:

  • GitHub Actions wird die folgende Workflow-Datei analysieren, um sich über SSH in den Ziel-host einzuloggen, der im geheimen Wert HOST definiert ist, mit dem Benutzernamen USERNAME und dem Passwort PASSWORD, die als Secrets definiert sind.
  • Dann wird der Workflow den Inhalt des GitHub-Repositorys für einen bestimmten Branch ($branchName) herunterladen, indem er git pull origin$branchName ausführt. Stellen Sie sicher, dass der Branch-Name den Code enthält, den Sie bereitstellen möchten.
  • Sie werden ein Workflow Package aus dem Github Marketplace namens ssh-remote-commands verwenden. Dieses Paket hat einen praktischen Wrapper, mit dem Sie nur den Host, den Benutzernamen, das Passwort, den Port und den auszuführenden Befehl für die Produktion angeben müssen.

Stellen Sie sicher, dass Ihr Server Git installiert hat und über die erforderlichen Anmeldeinformationen verfügt, um den Code aus dem GitHub-Repository zu ziehen

# Name, auf das programmatisch viel Bezug genommen wird 
name: deploy 
on:
  # Das Ereignis respository_dispatch bedeutet bei jedem API-Auslöser, 
  # dass diese gesamte Datei ausgeführt wird
  repository_dispatch: 
    types: [deploy-service]
# Es können mehrere Jobs vorhanden sein, aber derzeit 
# wird dieses Tutorial nur auf einem arbeiten
jobs:
  deploy:
    name: Deploy
    # Der Name des Basisimages, in dem alle Codes in YAML ausgeführt werden
    runs-on: ubuntu-latest
    steps:
    - name: executing remote ssh commands using password
      # appleboy/ssh-action@master ist ein Open-Source-Paket 
      # das sich über SSH auf einen Server einloggt und das Skript ausführt
      uses: appleboy/ssh-action@master
      # Dies sind im Allgemeinen die Variablen, die das Paket benötigt 
      # um sich auf dem Server anzumelden und das Skript auszuführen
      with:
       # Die Secrets sind die Variablen von 
       # https://docs.github.com/en/actions/security-guides/encrypted-secrets

       # Ihr Host des Servers, der in den GitHub-Secrets unter demselben Namen HOST gespeichert ist
        host: ${{ secrets.HOST }} 
        # Ihr Benutzername für den Server-Login 
        # der in den GitHub-Secrets unter dem Namen USERNAME gespeichert ist
        username: ${{ secrets.USERNAME }} 
        # Ihr Server-Passwort für den Login 
        # das in den GitHub-Secrets unter dem Namen PASSWORD gespeichert ist        
        password: ${{ secrets.PASSWORD }} 
        # Der Port Ihres Servers für den Login 
        # der in den GitHub-Secrets unter dem Namen PORT gespeichert ist
        port: ${{ secrets.PORT }}  
        # deploy-app.sh kann beliebig sein, z. B. können Sie Code vom GitHub abrufen
        # und Ihren Webserver oder Warteschlangen neu starten, alles Mögliche
        # Stellen Sie sicher, dass Sie das Repo auf Ihrem Server geklont haben  
        # Sie können so viele Skripte ausführen, wie Sie möchten
        script: git pull origin {{ github.event.client_payload.branch

Ausführen des Workflows manuell

Sie haben nun den GitHub Actions-Workflow erstellt, der über Slack aufgerufen werden soll. Aber zu diesem Zeitpunkt befindet sich Ihr Code nur auf Ihrem lokalen Rechner. Um den Workflow auszulösen, müssen Sie den Code auf GitHub hochladen.

Das Ausführen der folgenden Befehlsreihe gibt git an, von wo der Code gepusht und gepullt werden soll, in diesem Beispiel aus Ihrem entfernten GitHub-Repository. Ersetzen Sie in dem Befehl git remote add origin unten yourusername und yourrepository durch Ihren GitHub-Benutzernamen und das Repository

# Öffnen Sie github.com und erstellen Sie ein Repository
git init # Initialisiert git
git remote add origin https://github.com/yourusername/yourrepository.git
git add . # Fügt neu erstellte Dateien hinzu, die von git verfolgt werden sollen
git commit -m "Created GitHub workflow file"
git push -u origin master

Lassen Sie uns zunächst testen, ob Ihr Code funktioniert. Rufen Sie Ihren Code manuell mithilfe des beliebten curl-Dienstprogramms auf.

Führen Sie den folgenden Befehl aus, um eine POST-Anforderung an Ihr GitHub-Repository https://github.com/username/repository/dispatches URL zu senden, um GitHub anzuweisen, eine Workflow-Datei deploy.yml auszulösen, die Sie zuvor erstellt haben. Ersetzen Sie username durch Ihren tatsächlichen GitHub-Benutzernamen und repository durch Ihr GitHub-Repository.

Ersetzen Sie $github_personal_token im folgenden Code durch Ihren persönlichen Token.

# Führt eine POST-Anfrage an die URL https://github.com/username/repository/dispatches durch 
curl-X POST  https://github.com/username/repository/dispatches \
# Fügt einen Header für die Annahme des Inhalts Typs hinzu
-H 'Accept: application/vnd.github.everest-preview+json' \
# Fügt einen Header für die Autorisierung hinzu
-H "Authorization: token $github_personal_token" \
# Fügt JSON-Inhalt in den Body der POST-Anfrage ein, sodass Sie mehrere Parameter senden können 
# aus diesem Datenabschnitt und Sie können verschiedene Aktionen basierend auf Argumenten ausführen
--data '{"event_type": "deploy-service", "client_payload": {"environment": "'"$1"'", "ref": "'"$2"'"}}' # Sie können den Namen der Umgebung und die Referenz als Branch-Namen übergeben, damit Sie wissen, auf welchem Server welcher Branch bereitgestellt werden soll

Slack-Bot mit Hubot erstellen

Da Sie in der Lage waren, den GitHub Action Workflow manuell auszulösen, ist das ein guter Anfang. Versuchen wir jetzt, die gleichen manuellen Schritte über einen Slack-Bot zu automatisieren. Sie erstellen einen Slack-Bot, der auf Ihren Befehl hört und die GitHub-Aktion mit Argumenten auslöst.

Sie haben zwei Möglichkeiten, einen Slack-Bot zu erstellen, entweder von Grund auf oder ein vorgefertigtes Hubot-Paket für Slack-Arbeitsbereiche. In diesem Tutorial verwenden Sie ein vorgefertigtes Bot-Paket namens Hubot. Hubot ist ein Open-Source-Automatisierungstool, das sich mit Chat-Diensten wie Slack, Discord, Gitter, TeamSpeak usw. integriert.

Das Erstellen eines benutzerdefinierten Bots ohne die Verwendung einer App wie Hubot dauert viel Zeit. Warum? Weil Sie alle Einrichtungsprozesse , das Abhören von Webhooks und das Hosting des Bots selbst durchführen müssen. In diesem Tutorial verwenden Sie die Hubot Slack-App, um all diese Prozesse zu vereinfachen.

Installation von Hubot mit Npm

Da Sie Hubot verwenden, um einen Slack-Bot zu erstellen, laden Sie zuerst Hubot auf Ihren lokalen Computer herunter und installieren ihn. Hubot wird der Connector sein, der Slack und GitHub-Aktionen verbindet.

1. Navigieren Sie in Ihrem Terminal (cd) zu Ihrem Projektverzeichnis (~/Hubot). 

cd ~/Hubot

2. Installieren Sie das yo– und das generator-hubot-Paket global (-g) auf Ihrem lokalen Computer mit dem folgenden Befehl npm install. Das yo-Paket hilft Ihnen beim Installieren neuer Projekte, indem es Projekte in jeder Sprache (Web, Java, Python, C# usw.) generiert. Das Paket generator-hubot verwendet das Paket yo, um alle Abhängigkeiten zusammen mit den ersten Einrichtungen zu installieren.

Nach der Installation können Sie den Befehl yo von überall ausführen, da er global installiert wurde.

npm install -g yo generator-hubot

3. Erstellen Sie nun ein grundlegendes Hubot Grundgerüst mit dem folgenden Befehl. Ein Grundgerüst ist ein Abschnitt des Codes, der an vielen Stellen eingefügt wird. Ohne ein Grundgerüst müssen Sie immer den Code von Grund auf schreiben.

Der folgende Befehl erstellt ein grundlegendes Hubot-Grundgerüst in Ihrem Projektverzeichnis. Das Hubot-Grundgerüst verknüpft Slack (--adapter=slack), damit der Bot Nachrichten im Slack-Kanal hören und darauf antworten kann. yo hubot --adapter=slack

yo hubot --adapter=slack

Hinzufügen von Hubot zu Ihrem Slack-Arbeitsbereich

Jetzt, da Hubot auf Ihrem lokalen Computer installiert ist, müssen Sie Hubot so konfigurieren, dass er mit Slack kommuniziert.

Installieren wir Hubot in Ihrem Slack-Arbeitsbereich.

1. Öffnen Sie Ihren Webbrowser und navigieren Sie zu Ihren Slack-Admin-Einstellungen mit der URL, wie https://workspacename.slack.com/admin/settings. Ersetzen Sie workspacename durch Ihren tatsächlichen Slack-Arbeitsbereichsnamen.

Klicken Sie auf Apps konfigurieren auf der linken Seite, wie unten gezeigt, damit Sie nach Hubot im Marktplatz suchen können. Slack verfügt über einen Marktplatz, auf dem Sie vorgefertigte Anwendungen finden können.

Accessing Slack Admin Settings

2. Klicken Sie auf die Suchleiste und geben Sie dann hubot ein, um Hubot im Marktplatz zu suchen, und wählen Sie Hubot aus.

Klicken Sie nun auf die Schaltfläche Zu Slack hinzufügen, wie unten gezeigt, um Hubot zu Ihrem Slack-Arbeitsbereich hinzuzufügen.

Searching Hubot and Adding it to Slack Workspace

3. Schließlich geben Sie einige allgemeine Informationen zu Ihrem Bot ein, wie den Namen (deployerhubot) und das Symbol. Beachten Sie den API-Token, den Sie später in Hubot Deployer verwenden werden, um den Bot aus Ihrem zuvor erstellten Hubot-Projekt zu aktivieren.

Setting up Bot Information and Taking Note of the API Token

Testen der Integration des GitHub Actions Workflows mit Slack

Sie haben jetzt Hubot in Ihrem Slack-Arbeitsbereich installiert. Testen Sie den Bot, indem Sie Nachrichten an den Kanal senden und auf ihn hören. Aktivieren Sie jedoch zuerst den Bot.

1. Führen Sie den folgenden Befehl im Stammverzeichnis des Projekts aus, um den Bot für Slack zu aktivieren (--adapter slack) aus Ihrem Hubot-Repository (./bin/hubot). Ersetzen Sie unbedingt $token durch den API-Token, den Sie zuvor notiert haben

HUBOT_SLACK_TOKEN=$token ./bin/hubot --adapter slack

2. Führen Sie den unten stehenden Befehl aus, um den Bot (botusername) in Ihren Slack-Kanal einzuladen (/invite). Ersetzen Sie botusername durch den Namen des Bots, den Sie im dritten Schritt des Abschnitts „Hubot zu Ihrem Slack-Arbeitsbereich hinzufügen“ registriert haben. 

/invite deployerhubot

Nennen Sie jetzt einen Bot mit einem Text in Slack, wie @deployerhubot ping, um zu testen, ob die Integration funktioniert. Wenn der Bot mit PONG antwortet, wie unten gezeigt, sind Sie bereit.

Testing Hubot and Slack Integration

Wenn der Bot nicht antwortet, gehen Sie in Ihrem GitHub-Repository in Ihrem Webbrowser zu dem Actions-Tab. Sie können erkennen, welcher Workflow fehlgeschlagen ist, da er ein rundes rotes Häkchen darauf hat. Klicken Sie auf den fehlgeschlagenen Workflow, um herauszufinden, was den Fehler verursacht hat, und beheben Sie ihn.

Viewing Failed Workflows

Unten sehen Sie, dass der Fehler beim Ausführen von Remote-SSH-Befehlen mit Passwort auftritt. Nachdem Sie den Arbeitsablauf behoben haben, kehren Sie zu Schritt 3 zurück und prüfen Sie, ob der Bot mit „PONG“ antwortet.

Navigating to GitHub repository to fix failed workflow

Starten eines GitHub Actions-Workflows von Slack

Jetzt, da Sie Ihren Slack Bot aktiviert haben, ist es an der Zeit, den GitHub Actions-Workflow von Slack aus zu starten!

Sie benötigen die Flexibilität, den angegebenen Branch auf einen bestimmten Server bereitzustellen, z.B. indem Sie den Code vom angegebenen Branch abrufen. Sie bringen dem Bot bei, automatisch zu antworten, wenn jemand ***@*bot deploy API feature-x to production in einen Slack Channel eingibt. Sie können den Umgebungsnamen validieren, in dem später nur bestimmte Umgebungen und Branches bereitgestellt werden können.

Um die Antworten des Bots zu automatisieren:

1. Erstellen Sie ein Verzeichnis namens ~/Hubot/scripts. Das Verzeichnis ~/Hubot/scripts ist der Speicherort, an dem Sie ein Skript speichern, das Ihren GitHub-Workflow auslöst.

2. Erstellen Sie in Ihrem Code-Editor eine Datei mit dem Namen bot.js im Verzeichnis ~/Hubot/scripts. Kopieren Sie den untenstehenden Code und fügen Sie ihn in die Datei bot.js ein.

Der folgende Code ermöglicht es dem Bot, auf die Chat-Nachrichten im Slack Channel zu hören und dann den Workflow auszulösen, um eine Antwort an den Slack Channel zu senden.

const validServices = ['api','app'];
const validEnvironments = ['production'];
robot.hear (`@${process.env.BOT_ID}`,async (bot) => {
    // Der Bot interessiert sich nur für das Zuhören von Nachrichten 
    // wie @deploy api featurex to production 
    // Einrichten von wiederverwendbaren Variablen
	  const payload = bot.message.text.split(" ")
    const service = payload[2];
    const branch = payload[3];
    const environment = payload[5];
    const username = bot.message.user.name;
    // Benutzer darüber informieren, dass wir die Verarbeitung durchführen
    bot.send(`Roger that! Please wait.`);
// Überprüfen, ob der verwendete Befehl gültig ist oder nicht 
// weil der Benutzer auch ungültige Befehle verwenden kann 
if(!validateCommand(bot,username,service,branch,environment)) {
      return;
    }
    // Wenn der Befehl gültig erscheint, dann einen Workflow auslösen
    await triggerWorkflow(bot,username,service,environment,branch)
    
    // Benutzer darüber informieren, dass der Workflow erfolgreich ausgelöst wurde
    bot.send(`Github Action has been triggered successfully`);
  })
  const validateCommand = (bot,username,service,branch,environment) => {
    // Die Dienste begrenzen, da Benutzer Dienste verwenden können, die nicht aufgeführt sind 
    // Der versucht, den Workflow auszulösen und einen Fehler erhält
    if(!validServices.includes(service)) {
       bot.send(`${service} is not availble, Only ${validServices.join(', ')} are available`);
      return false;
      }
      // Die Umgebung begrenzen, da Benutzer eine ungültige Liste von Umgebungen verwenden können 
      if(!validEnvironments.includes(environment)) {
        bot.send(`${environment} is not availble. Only ${validEnvironments.join(', ')} are available`);
        return false;
      }
      return true;
  }

  const triggerWorkflow = (bot,username,service,environment,branch) => {
    try {
      // Dies ist der gleiche manuelle Workflow-Auslösecode 
      // von curl zu tatsächlichem JavaScript-Post-Request konvertiert
      const data = await axios.post(`https://api.github.com/repos/yourusername/yourreponame/dispatches`,{
        'event_type': 'deploy-service',
        'client_payload': {'environment': environment, 'ref': branch}
      },{headers:{
      Authorization: `token ${token}`,
      }})
    }
      catch(e) {
        bot.send(`Sorry @${username} could not trigger github action. Please check my logs ${e.message}`);
      }
  }

3. Schließlich senden Sie die Nachricht @botusername deploy api staging to dev in Slack, und Sie werden eine ähnliche Antwort sehen, wie unten gezeigt.

Workflow-Dateien können durch verschiedene GitHub-Ereignisse ausgelöst werden, wie das Hochladen von Code in einen bestimmten Zweig, das Erstellen von Tags, das Erstellen von Pull-Anfragen, das Anfordern bestimmter URLs und vieles mehr.

send the @botusername deploy api staging to dev message in slack

Fazit

Im Verlauf dieses Tutorials haben Sie mehr über den GitHub-Workflow erfahren, angefangen von der manuellen Auslösung von Slack-Antworten mit Codes bis hin zum Erstellen eines Chatbots. Sie haben auch gelernt, dass das Hinzufügen eines Chatbots in Slack Ihnen ermöglicht, Aufgaben zu automatisieren, indem Sie GitHub-Workflowaktionen aufrufen.

Wollen Sie dieses neu erworbene Wissen vielleicht auf die nächste Stufe heben, indem Sie einen Erinnerungsbot hinzufügen oder interaktive Nachrichten erstellen?

Source:
https://adamtheautomator.com/create-slack-bot/