Automatisieren der JIRA-Ticketerstellung mit einer Flask-API: Ein Leitfaden zur GitHub-Webhook-Integration

Optimieren Sie Ihren Workflow, indem Sie mithilfe von Python und Flask automatisch JIRA-Tickets aus GitHub-Problemkommentaren generieren

? Einführung

Willkommen in der Welt von DevOps! Heute tauchen wir in ein spannendes Projekt ein, das Jira und GitHub für eine nahtlose Integration verbindet. Das Ziel dieses Projekts besteht darin, die Erstellung von Jira-Tickets direkt aus GitHub-Problemkommentaren zu automatisieren, um Zeit zu sparen und den manuellen Aufwand für Entwickler zu reduzieren.

So gehen wir dieses Projekt an:

• Richten Sie eine Flask-API ein: Wir starten eine auf t2.micro Ubuntu basierende EC2-Instanz, um unsere Flask-Anwendung zu hosten.
• Jira konfigurieren: Wir erstellen ein Projekt auf Jira und verwenden dessen API für die Ticketerstellung.
• APIs integrieren: Durch die Bereitstellung eines Jira-API-Tokens für unsere Flask-App ermöglichen wir ihr die Interaktion mit Jira.

Sobald alles eingerichtet ist, fungiert unsere Flask-App als Webhook-API für GitHub. Jedes Mal, wenn ein Entwickler /jira einen Kommentar zu einem GitHub-Problem abgibt, erstellt das Programm automatisch ein entsprechendes Jira-Ticket, das im Jira-Dashboard sichtbar ist. Aufregend, oder? Fangen wir an!

---

? Voraussetzungen

Bevor Sie in das Projekt eintauchen, stellen Sie sicher, dass Sie Folgendes bereit haben:

• GitHub- und Jira-Konten: Sie benötigen aktive Konten auf beiden Plattformen, um die Integration zu konfigurieren.
• Flask installiert: Stellen Sie sicher, dass Flask in Ihrer Python-Umgebung eingerichtet ist. Wenn nicht, können Sie es installieren mit:

pip install flask

• Grundlegendes Verständnis von EC2 und Flask: Wenn Sie mit dem Einrichten einer EC2-Instanz und dem Erstellen einfacher Flask-Anwendungen vertraut sind, können Sie reibungslos vorankommen.

Wenn diese Voraussetzungen erfüllt sind, sind Sie bereit, dieses Projekt in Gang zu bringen!

---

? Einrichten der EC2-Instanz und der Flask-Anwendung

Beginnen wir das Projekt mit der Erstellung und Einrichtung einer EC2-Instanz zum Hosten unserer Flask-Anwendung. Befolgen Sie diese Schritte:

Schritt 1: Erstellen Sie die EC2-Instanz

• Navigieren Sie zum AWS EC2 Dashboard und erstellen Sie eine neue t2.micro Ubuntu-basierte Instanz.
• Nennen Sie die Instanz jira-github-integration.

• Laden Sie die Schlüsselpaardatei für den SSH-Zugriff herunter.
• Öffnen Sie Port 5000 in der Sicherheitsgruppe, um auf die Flaschenanwendung zuzugreifen.

Schritt 2: SSH in die Instanz
Verwenden Sie die heruntergeladene Schlüsselpaardatei, um eine SSH-Verbindung zur Instanz herzustellen:

pip install flask

Schritt 3: Python-Umgebung einrichten
Führen Sie die folgenden Befehle aus, um Python und Flask zu installieren:

ssh -i your-key.pem ubuntu@<instance-public-ip>

Dadurch werden alle notwendigen Abhängigkeiten für das Projekt eingerichtet.

Schritt 4: Erstellen Sie die Flask-Anwendung

• Erstellen Sie eine neue Datei mit dem Namen github_jira.py:

sudo apt update  
sudo apt install python3-pip python3-venv  
python3 -m venv myvenv  
source myvenv/bin/activate  # Activate the virtual environment  
pip3 install flask          # Install Flask in the virtual environment

Fügen Sie der Datei den folgenden Inhalt hinzu:

nano github_jira.py

---

? Generieren eines Atlassian-API-Tokens

Bevor wir das Skript github_jira.py ausführen, benötigen wir zwei wichtige Informationen:

• Atlassian API-Token
• Ihr Atlassian-Domainname

Schritte zum Generieren des Atlassian-API-Tokens:

• Melden Sie sich bei Ihrem Atlassian-Konto an:
• Besuchen Sie Atlassian und melden Sie sich mit Ihren Zugangsdaten an.

Navigieren Sie zu den Kontoeinstellungen:

• Klicken Sie oben rechts auf Ihr Profilbild oder Ihren Avatar.
• Wählen Sie Kontoeinstellungen aus dem Dropdown-Menü aus.
• Gehen Sie zur Registerkarte „Sicherheit“:
• Klicken Sie auf der Seite „Kontoeinstellungen“ auf die Registerkarte „Sicherheit“.
• Klicken Sie im Abschnitt „API-Tokens“ auf „API-Token erstellen“.

Erstellen Sie ein neues API-Token:

• Geben Sie eine Beschreibung an (z. B. GitHub Jira Integration) und legen Sie bei Aufforderung ein Ablaufdatum für das Token fest.
• Klicken Sie auf Erstellen und Ihr API-Token wird generiert.

Kopieren Sie das API-Token:

• Klicken Sie auf die Schaltfläche „Kopieren“, um das Token zu kopieren.
• Fügen Sie das Token in die Variable API_TOKEN in Ihrem github_jira.py-Skript ein:

 import requests
 from requests.auth import HTTPBasicAuth
 import json
 from flask import Flask, request

 app = Flask(__name__)

 # Define a route that handles POST requests
 @app.route('/createJira', methods=['POST'])
 def createJira():
     # The comment's body field in the GitHub payload
     comment_data = request.json.get("comment", {})
     comment_body = comment_data.get("body", "")

     # Check if the body field of the comment is "/jira"
     if comment_body == "/jira":
         print("Condition met. Proceeding with POST request...")

         # Jira API details
         url = "https://<Your-Atlassian-domain>/rest/api/3/issue"
         API_TOKEN = "<YOUR_API_TOKEN>"
         auth = HTTPBasicAuth("<YOUR_EMAIL_ADDRESSS_CONNECTED_TO_THE_ACCOUNT>", API_TOKEN)

         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json"
         }

         payload = json.dumps({
             "fields": {
                 "description": {
                     "content": [
                         {
                             "content": [
                                 {
                                     "text": "Order entry fails when selecting supplier.",
                                     "type": "text"
                                 }
                             ],
                             "type": "paragraph"
                         }
                     ],
                     "type": "doc",
                     "version": 1
                 },
                 "project": {
                     "key": "<YOUR_KEY>"
                 },
                 "issuetype": {
                     "id": "<YOUR_ISSUE_ID>"
                 },
                 "summary": "Main order flow broken",
             },
             "update": {}
         })

         # POST request to create an issue in Jira
         response = requests.post(url, data=payload, headers=headers, auth=auth)
         print("POST request response:", response.status_code, response.text)

         # Return the response back
         return json.dumps(json.loads(response.text), sort_keys=True, indent=4, separators=(",", ": "))
     else:
         print("No matching comment found. POST request will not be made.")
         return json.dumps({"error": "No matching comment found. POST request was not made."}, sort_keys=True, indent=4, separators=(",", ": "))

 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=5000)

Fügen Sie Ihre Atlassian-Domain hinzu:
Ersetzen Sie in der URL-Variablen mit Ihrem Atlassian-Domainnamen. Wenn die URL Ihres Jira-Dashboards beispielsweise https://yourworkspace.atlassian.net lautet, verwenden Sie yourworkspace.atlassian.net als Domäne.

---

? Konfigurieren erforderlicher Felder im github_jira.py-Skript

Bevor Sie das Skript ausführen, müssen Sie einige wichtige Felder in der Datei github_jira.py aktualisieren, um sicherzustellen, dass die Integration nahtlos mit Ihrem Jira-Konto funktioniert.

1. HTTP-Basisauthentifizierung (E-Mail-Adresse)
Ersetzen Sie den ersten Parameter in HTTPBasicAuth durch die E-Mail-Adresse, die mit Ihrem Jira-Konto verknüpft ist.

API_TOKEN = "<Your-Generated-API-Token>"

2. Projektschlüssel

• Der Projektschlüssel identifiziert eindeutig das Jira-Projekt, in dem die Tickets erstellt werden.
• So finden Sie Ihren Projektschlüssel:
• Gehen Sie zum Jira-Dashboard.
• Suchen Sie auf der Registerkarte „Projekte“ das Projekt, für das Tickets erstellt werden.
• Der Projektschlüssel wird in einfachen Klammern (()) angezeigt. Im Projekt Project ABC (SCRUM) lautet der Schlüssel beispielsweise SCRUM.

Ersetzen Sie das Feld „Schlüssel“ unter „Felder“ im Skript:

pip install flask

3. Problemtyp-ID

• Die Problemtyp-ID ist eine eindeutige Kennung für den Problemtyp (z. B. Fehler, Story, Aufgabe).
• So finden Sie die Problem-ID:
• Klicken Sie in Ihrem Jira-Dashboard auf die drei Punkte in der oberen rechten Ecke und wählen Sie Benutzerdefinierte Felder verwalten.

• Navigieren Sie in den Projekteinstellungen im linken Menü zu Problemtypen.
• Klicken Sie auf Story oder den Problemtyp, den Sie verwenden möchten.
• Sehen Sie sich die URL in Ihrem Browser an. Am Ende der URL finden Sie einen numerischen Wert (z. B. 10005). Dies ist Ihre Problemtyp-ID.

Ersetzen Sie das Feld „id“ unter „issuetype“ im Skript:

ssh -i your-key.pem ubuntu@<instance-public-ip>

Beispiel für aktualisierte Felder im Skript:

sudo apt update  
sudo apt install python3-pip python3-venv  
python3 -m venv myvenv  
source myvenv/bin/activate  # Activate the virtual environment  
pip3 install flask          # Install Flask in the virtual environment

Letzter Schritt: Führen Sie das Skript aus
Sobald diese Felder aktualisiert sind, führen Sie das Skript aus mit:

nano github_jira.py

Ihr Skript ist jetzt vollständig konfiguriert und bereit, GitHub-Kommentare in die Jira-Ticketerstellung zu integrieren!

---

? Hinzufügen des Webhooks zum Abschließen der Integration

Da unser Skript nun fertig ist, besteht der letzte Schritt darin, einen Webhook in Ihrem GitHub-Repository zu konfigurieren. Dieser Webhook wartet auf bestimmte Ereignisse (in diesem Fall auf die Ausgabe von Kommentaren) und löst die Flask-Anwendung aus.

Schritte zum Hinzufügen des Webhooks:

• Navigieren Sie zum GitHub-Repository:
• Öffnen Sie das GitHub-Repository, in dem Sie dieses Projekt testen möchten. Auf Repository-Einstellungen zugreifen:
• Klicken Sie im Repository-Menü auf die Registerkarte „Einstellungen“.
• Wählen Sie in der linken Navigationsleiste im Abschnitt „Code und Automatisierung“ Webhooks aus.

Neuen Webhook hinzufügen:

• Klicken Sie auf die Schaltfläche Webhook hinzufügen.
• Konfigurieren Sie den Webhook:
• Payload-URL: Geben Sie die URL Ihrer Flask-Anwendung ein. Dies sollte den öffentlichen DNS Ihrer EC2-Instanz und die Route für den Flask-Endpunkt umfassen:

pip install flask

• Inhaltstyp:
  Wählen Sie application/json aus dem Dropdown-Menü aus.

• Trigger:
  Wählen Sie die Option „Lassen Sie mich einzelne Ereignisse auswählen“.
  Aktivieren Sie das Kontrollkästchen nur für Problemkommentare.

Webhook speichern:

• Klicken Sie auf die Schaltfläche „Webhook hinzufügen“, um Ihre Einstellungen zu speichern.

Testen der Integration

• Erstellen Sie ein Problem auf GitHub:
• Navigieren Sie zur Registerkarte „Probleme“ Ihres Repositorys.
• Klicken Sie auf Neue Ausgabe, geben Sie einen Titel und eine Beschreibung ein und speichern Sie sie.
• Kommentieren Sie zum Problem:
• Öffnen Sie das erstellte Problem und fügen Sie einen Kommentar mit /jira hinzu.

Beobachten Sie die Magie:

• Der Webhook löst eine POST-Anfrage aus und sendet sie an den Flask-Server.
• Die Flask-Anwendung verarbeitet die Anfrage und erstellt mithilfe der Jira-API ein Jira-Ticket.

Überprüfen Sie im Jira-Dashboard:

• Öffnen Sie Ihr Jira-Dashboard und navigieren Sie zu dem in Ihrem Skript angegebenen Projekt.
• Sie sollten ein neu erstelltes Ticket sehen, das dem GitHub-Problemkommentar entspricht.

---

? Abschluss

Herzlichen Glückwunsch! ? Sie haben ein praktisches Projekt zur Integration von GitHub und Jira erfolgreich abgeschlossen. Durch die Nutzung einer Flask-Anwendung als Vermittler haben wir den Prozess der Erstellung von Jira-Tickets direkt aus GitHub-Problemkommentaren automatisiert.

In diesem Projekt haben wir Folgendes behandelt:

• Einrichten einer EC2-Instanz zum Hosten einer Flask-App.
• Konfigurieren der Flask-App für die Interaktion mit der Jira-API.
• Erstellen und Hinzufügen eines GitHub-Webhooks, um den Workflow auszulösen.
• Beobachtung der nahtlosen Erstellung von Jira-Tickets aus GitHub-Kommentaren.

Diese Integration vereinfacht die Zusammenarbeit zwischen Entwicklern und Projektmanagern, indem sie den manuellen Aufwand reduziert und sicherstellt, dass wichtige Aufgaben nicht untergehen. Es ist eine praktische Demonstration, wie Automatisierung die Produktivität in einem DevOps-Workflow steigern kann.

Bauen Sie gerne auf dieser Grundlage auf, um die Integration weiter anzupassen oder zusätzliche Anwendungsfälle zu erkunden, wie z. B. die Automatisierung des GitHub Pull Request-Trackings in Jira oder die Integration anderer Tools in Ihren Workflow.

Wir hoffen, dass Sie dieses Projekt informativ und ansprechend fanden. ? Für einen informativeren Blog folgen Sie mir auf Hashnode, X(Twitter) und LinkedIn.

Viel Spaß beim Codieren und Automatisieren! ?

Das obige ist der detaillierte Inhalt vonAutomatisieren der JIRA-Ticketerstellung mit einer Flask-API: Ein Leitfaden zur GitHub-Webhook-Integration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!