CutomGPT: Assets Discovery Custom Patterns automatisch generieren

Das Aufkommen großer Sprachmodelle (LLMs) und generativer KI-Technologien stellt einen bedeutenden Fortschritt bei den Fähigkeiten des maschinellen Lernens dar und ermöglicht ein breites Spektrum an Anwendungen – von der Content-Erstellung bis zum Kundensupport.

Atlassian integriert diese sich weiterentwickelnde Technologie aktiv über „Atlassian Intelligence“ in viele seiner Produkte, darunter Jira Service Management (JSM), Confluence und Bitbucket . Das ist zwar für verschiedene Aufgaben wie das Erstellen und Bearbeiten von Confluence-Seiten oder das Verfassen von Bitbucket-Commit-Nachrichten äußerst hilfreich, doch wir sind überzeugt, dass noch Potenzial für spezialisiertere Anwendungsfälle besteht.

Um die Machbarkeit solcher spezialisierten Lösungen zu bewerten, haben wir einen individuellen Assistant entwickelt, der Custom Patterns für Jira Assets Discovery erstellen kann.

Was ist Jira Assets Discovery?

Jira Assets Discovery ist eine kostenlose Jira-Marketplace-App von Atlassian für Jira Service Management. Sie unterstützt Unternehmen dabei, ihre Assets direkt im Service-Management-Tool zu verwalten und nachzuverfolgen. So lassen sich sämtliche Hardware-, Software- und sonstigen Assets im Unternehmen automatisch erkennen, verfolgen und verwalten.

Bei diesem Prozess werden alle Geräte im Unternehmensnetzwerk mithilfe von Scan Patterns gescannt. Ein Pattern besteht aus einem Shell-Befehl zum Abrufen von Systeminformationen sowie kurzen C#-Codeabschnitten, die die Befehlszeilenausgabe in Objekte umwandeln, welche in Assets für JSM importiert werden können.

Wenn beispielsweise Informationen über die zuletzt angemeldeten Benutzer benötigt werden, führt ein Pattern den Befehl last aus. Eine beispielhafte Befehlsausgabe könnte so aussehen:

mark     pts/0        10.10.0.7   Fri Feb 21 21:23   still logged inmark     pts/0        10.10.0.7   Tue Feb 18 22:34 - 00:05  (01:31)lisa     :0           :0          Thu Feb 13 09:19   gone - no logoutreboot   system boot  4.15.0-74-g Fri Jan 24 08:03 - 08:03  (00:00)

Anschließend wird das Skript ausgeführt, um jeden Eintrag aus der resultierenden Befehlszeilenausgabe zu verarbeiten. Dadurch werden Instanzen des HostInfo-Objekts von Atlassian erstellt, bei denen das Feld LastUser gesetzt ist, sodass sie in JSM importiert werden können.

Dieses System bietet große Flexibilität, da sich damit durch das Schreiben von Patterns beliebige Systeminformationen erfassen lassen, die über Shell-Befehle verfügbar sind. Wenn ein Unternehmen beispielsweise proprietäre Datenbanken für spezielle Speicheranforderungen nutzt, können individuelle Patterns erstellt werden, um Informationen über diese Datenbanken automatisch abzurufen.

Wie erstelle ich Custom Patterns, wenn ich kein C# beherrsche?

Diese Methode eignet sich hervorragend, um maßgeschneiderte Lösungen für die Anforderungen unserer Kunden zu entwickeln, bringt jedoch auch einige Nachteile mit sich. Diese ergeben sich vor allem aus den erforderlichen Kenntnissen in C#, den benötigten Shell-Befehlen und der C#-Bibliothek von Assets Discovery, wenn nicht standardmäßige Inventaranforderungen umgesetzt werden sollen.

Dadurch haben unsere Kunden oft Schwierigkeiten, ihre eigenen Anforderungen umzusetzen, oder benötigen Unterstützung bei der Implementierung. Unsere Erfahrung zeigt: Auch wenn unsere Kunden häufig über Skripting-Erfahrung verfügen – meist in anderen Sprachen als C# – oder sogar C# beherrschen, fehlt ihnen die Zeit, um den Umgang mit der von Atlassian bereitgestellten Bibliothek zu erlernen. Gleichzeitig wissen sie genau, welche Anforderungen ihre Systeme erfüllen müssen, beispielsweise welche Informationen über ihre Systeme verfügbar sein sollen.

Benötigt wird ein Tool, das diese Anforderungen in vollständige Patterns übersetzt und dabei den Bedarf an umfangreichen Kenntnissen oder Erfahrungen mit C# beziehungsweise Programmierung im Allgemeinen minimiert.

ChatGPT zum Schreiben von Custom Patterns einsetzen

Da der für das Verarbeiten der Shell-Befehle erforderliche C#-Code recht kurz ist, haben wir versucht, ChatGPT mit der Erstellung einer passenden Implementierung auf Basis eines definierten Anforderungssatzes zu beauftragen.

Die Ergebnisse waren leider, gelinde gesagt, ziemlich unbefriedigend. GPT konnte zwar effizient kurze Ausschnitte von reinem C#-Code erzeugen, doch es wurde deutlich, dass es nicht ausreichend mit der Dokumentation zur C#-Bibliothek von Atlassian trainiert worden war.

Um auf unser letztes Benutzerbeispiel zurückzukommen: Standardmäßig erkannte GPT, dass sich der Befehl last zum Abrufen der Daten verwenden lässt. Allerdings hatte es keinerlei Verständnis dafür, welche Felder eine Pattern-XML enthalten sollte, und das Pattern enthielt überhaupt keinen C#-Code. Selbst nachdem wir darauf hingewiesen hatten, dass ein Pattern C#-Code zur Verarbeitung enthalten muss, konnte GPT-4 keine sinnvolle Lösung liefern.

Einführung: Discovery Custom Pattern Assistant

Um das Problem zu lösen, mussten wir ChatGPT die erforderliche Dokumentation bereitstellen. Glücklicherweise führte OpenAI zu diesem Zeitpunkt CustomGPTs ein, mit denen sich eigene Wissensdateien hinzufügen und „Actions“ ausführen lassen.

Individuelles Wissen

Wenn ein Benutzer eine Frage stellt, führt ChatGPT zunächst eine Textähnlichkeitssuche in der bereitgestellten Wissensdatenbank durch und fügt die Suchergebnisse unbemerkt an die Frage des Benutzers an. Dadurch kann der Chatbot Informationen nutzen, auf die er nicht speziell trainiert wurde, um Fragen zu beantworten.

Da ChatGPT das Hochladen mehrerer Wissensdateien unterstützt, haben wir unsere Daten in drei Dateien aufgeteilt:

• Allgemeine Dokumentation zu Assets Discovery und Custom Patterns aus der Atlassian-Dokumentation

• Unsere umfassende Dokumentation zu den tatsächlichen C#-Klassen der Bibliothek

• Eine Liste von Compilerfehlern und den jeweiligen Lösungen für häufige, durch ChatGPT verursachte Fehler

Nachdem wir dieses relevante Wissen bereitgestellt hatten, zeigte sich eine deutliche Verbesserung: Während die AI zuvor nicht wusste, wie sie die Bibliothek verwenden sollte, nutzte sie nun Klassen korrekt und erstellte passende Objekte.

Diese Ergebnisse waren im Vergleich zu vorher bereits vielversprechend. Nach dem Ansatz „Vertrauen ist gut, Kontrolle ist besser“ für AI fügten wir die generierten Patterns in Assets Discovery ein. Die Ergebnisse waren deutlich besser als zuvor, variierten jedoch weiterhin. Die meisten Fehler bei den Patterns waren auf Compilerfehler zurückzuführen, die meist trivial waren. Ein Compiler übersetzt C#-Quellcode in maschinenlesbaren Code und prüft ihn während der Kompilierung auf Fehler.

Das bedeutet, dass es sich um einen automatisierten Prozess handelt, der entweder ein ausführungsbereites kompiliertes Programm oder eine Liste von Fehlern einschließlich ihrer Positionen im Code liefert. Wenn wir unserem Custom GPT die Fähigkeit geben, seinen eigenen Code zu kompilieren, kann es seine Ergebnisse automatisch überprüfen. Bei einem Fehler kann es seinen Code anhand der ermittelten Fehler entsprechend anpassen.

Custom Actions

Actions ermöglichen es CustomGPTs, Webanfragen an ein benutzerdefiniertes Backend zu senden. Dadurch können sie flexibel eigene Tools nutzen, etwa um aktuelle Wetterdaten bereitzustellen oder komplexe physikalische Simulationen durchzuführen.

Um generierten Code automatisch auf Compilerfehler zu prüfen, implementierten wir ein eigenes Backend mit einem Endpoint, der ein C#-Snippet empfängt und versucht, es zu kompilieren. Die Antwort enthält entweder eine Erfolgsbestätigung oder erkannte Fehler.

Direkt in der ChatGPT-Oberfläche erstellten wir zwei Actions für die Interaktion mit unserem benutzerdefinierten Backend: eine für die Kompilierung von C#-Code und eine für die Validierung der XML-Pattern-Datei, die den C#-Code sowie einige Metadatenfelder enthält.

Nachdem wir unserem ChatGPT die Möglichkeit gegeben hatten, seinen eigenen Code sowohl zu kompilieren als auch selbst zu prüfen, bewerteten wir unseren Assistenten erneut und erzielten schließlich Ergebnisse, die unsere Erwartungen übertrafen.

Alles zusammenführen

Nachdem nun alle Komponenten für einen erfolgreichen Custom Pattern Bot vorhanden waren, bestand der letzte Schritt darin, System Messages zu implementieren. Diese liefern Hintergrundinformationen sowie ein allgemeines Schema, das erklärt, wie die Erstellung von Patterns funktioniert.

Leistungsbewertung des virtuellen Agenten

In der verlinkten Chat-Session übernahmen wir die Rolle eines erfahrenen Jira-/JSM-Nutzers, jedoch ohne weiteren Hintergrund zu C# oder zum Erstellen von Kunden-Patterns.

Wir starteten eine Unterhaltung und baten um die Erstellung eines Custom Patterns auf Grundlage bestimmter Anforderungen:

<?xml version="1.0" encoding="utf-8"?><ScanPattern xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">  <Version>1.0</Version>  <PatternID>MacOS-LastUserLogin</PatternID>  <OrderNr>0</OrderNr>  <ProcessType>SSHExecute</ProcessType>  <PatternType>Custom</PatternType>  <Command>    <![CDATA[    last -1 -t console    ]]>  </Command>  <Processing>    <![CDATA[    using System;    using Insight.Discovery.InfoClasses;    using Insight.Discovery.ProviderClasses; // Include the ProviderClasses Namespace    using Insight.Discovery.InfoClasses.CommandResult.ResultTypes; // For handling SSH command results    namespace Insight.Discovery {      public class PatternExec {        public void PerformAction(object[] parameters) {          HostInfo hostInfo = (HostInfo)parameters[2]; // Cast the third parameter to HostInfo          // Cast the first parameter to SSHExecuteResult and implicitly assign to string          string sshOutput = ((SSHExecuteResult)parameters[0]);          // Processing the SSH output to extract the last logged-in user          if (!string.IsNullOrEmpty(sshOutput)) {            var lines = sshOutput.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);            if (lines.Length > 0) {              var lastLoginInfo = lines[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);              if (lastLoginInfo.Length > 0) {                string lastUser = lastLoginInfo[0];                // Setting the LastUser property of the HostInfo object                hostInfo.LastUser = lastUser;              }            }          }        }      }    }     ]]>  </Processing></ScanPattern>

Das GPT verstand seine Aufgabe und erklärte zunächst, welcher Shell-Befehl verwendet werden kann, um die Informationen vom Zielsystem abzurufen. Außerdem erläuterte es, welche C#-Version und Sprachfeatures verwendet werden sollten.

Im nächsten Schritt baten wir unser GPT, den C#-Code zu kompilieren, um ihn auf Syntax- und Compilerfehler zu prüfen, und anschließend die XML-Pattern-Datei zu validieren, um sicherzustellen, dass alle erforderlichen Konfigurationselemente vorhanden sind.

Die Kompilierung war erfolgreich. In der XML-Datei wurde jedoch fälschlicherweise der Pattern-Typ auf Custom gesetzt – was auf den ersten Blick sinnvoll erscheint, da wir ein benutzerdefiniertes Pattern schreiben. Custom ist jedoch kein gültiger Pattern-Typ. Nach der Überprüfung erkannte es das Problem schnell und schlug mehrere gültige Pattern-Typen vor, die zum aktuellen Pattern passen könnten.

Getreu unserer Rolle als nicht technischer Benutzer baten wir einfach darum, den Pattern-Typ auszuwählen, den das GPT für am passendsten hält.

<?xml version= "1.0" encoding= "utf-8"?><ScanPattern xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd= "http://www.w3.org/2001/XMLSchema">" <Version>1.0</Version>" <PatternID>MacOS-LastUserLogin</PatternID>     <OrderNr>0</OrderNr>      <ProcessType>SSHExecute</ProcessType>      <PatternType>User</PatternType>     <Command>         <![CDATA[ last -1 -t console ]]>     </Command>     <Processing>         <![CDATA[             using System;            using Insight.Discovery.InfoClasses;            using Insight.Discovery.ProviderClasses; // Include the ProviderClasses Namespace            using Insight.Discovery.InfoClasses.CommandResult.ResultTypes; // For handling SSH command results            namespace Insight.Discovery {            public class PatternExec {                public void PerformAction(object[] parameters) {                HostInfo hostInfo = (HostInfo)parameters[2]; // Cast the third parameter to HostInfo                // Cast the first parameter to SSHExecuteResult and implicitly assign to string                string sshOutput = ((SSHExecuteResult)parameters[0]);                // Processing the SSH output to extract the last logged-in user                if (!string.IsNullOrEmpty(sshOutput)) {                    var lines = sshOutput.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);                    if (lines.Length > 0) {                    var lastLoginInfo = lines[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);                    if (lastLoginInfo.Length > 0) {                        string lastUser = lastLoginInfo[0];                        // Setting the LastUser property of the HostInfo object                        hostInfo.LastUser = lastUser;                    }                    }                }            }        }        ]]>     </Processing></ScanPattern>

Das Pattern wählte einen Pattern-Typ aus und validierte das generierte Pattern erfolgreich erneut. Die Ausführung des Patterns auf einem MacBook bestätigte zudem, dass es den zuletzt angemeldeten Benutzer korrekt erkennt und in den resultierenden HostInfo festlegt.

Bei der Prüfung der Daten sahen wir jedoch, dass als letzter Benutzer „jiradiscovery“ festgelegt wurde – also der SSH-Benutzer, der zur Ausführung der Patterns verwendet wird. Das ist genau das, wonach wir gefragt hatten: der zuletzt angemeldete Benutzer – aber offensichtlich nicht das, was wir wollten:

Nachdem wir ChatGPT das Problem erklärt hatten, verstand es den Fehler und schlug eine Lösung vor, kompilierte und validierte sie. Die Verwendung des neuen, verfeinerten Patterns in Discovery bestätigte, dass es die Daten nun korrekt erfasst.

Als letzten Schritt baten wir den Assistant, Logging für Debugging-Zwecke sowie Dokumentation für Programmieranfänger hinzuzufügen. So wird es für jeden, der künftig mit der Wartung des Patterns beauftragt wird, deutlich einfacher zu verstehen sein, was es tut:

<?xml version="1.0" encoding="utf-8"?>
<ScanPattern xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Version>1.0</Version>
  <PatternID>MacOS-LastUserLogin</PatternID>
  <OrderNr>0</OrderNr>
  <ProcessType>SSHExecute</ProcessType>
  <PatternType>User</PatternType>
  <Command>
    <![CDATA[
    last -1 -t console
    ]]>
  </Command>
  <Processing>
    <![CDATA[
    using System;
    using Insight.Discovery.InfoClasses;
    using Insight.Discovery.ProviderClasses; // Needed for executing commands on the host
    using Insight.Discovery.InfoClasses.CommandResult.ResultTypes; // To handle the results from SSH commands
    using Insight.Discovery.Tools; // To use logging services
    namespace Insight.Discovery {
      public class PatternExec {
        public void PerformAction(object[] parameters) {
          // Obtain the HostInfo object from the parameters array. This object represents the host we are currently scanning.
          HostInfo hostInfo = (HostInfo)parameters[2];
          // The SSH command's output is obtained from the parameters array and implicitly converted to a string.
          string sshOutput = ((SSHExecuteResult)parameters[0]);
          // Log the obtained SSH output for debugging purposes.
          LogService.Instance.LogDebug($"SSH Output: {sshOutput}");
          // Check if the SSH output is not empty or null.
          if (!string.IsNullOrEmpty(sshOutput)) {
            // Split the output into lines for processing.
            var lines = sshOutput.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
            // Iterate through each line in the SSH output.
            foreach (var line in lines) {
              // Split each line into parts to analyze the login information.
              var loginInfo = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
              // Check if the line has content and the user is not 'jiradiscovery'.
              if (loginInfo.Length > 0 && loginInfo[0] != "jiradiscovery") {
                string lastUser = loginInfo[0]; // The first part is assumed to be the username.
                // Log the found user for verification.
                LogService.Instance.LogDebug($"Last logged-in user found: {lastUser}");
                // Assign the found username to the LastUser property of the HostInfo object.
                hostInfo.LastUser = lastUser;
                // Stop processing after the first matching user is found.
                break;
              }
            }
          } else {
            // Log a warning if the SSH command did not return any output.
            LogService.Instance.LogWarning("SSH command did not return any output.");
          }
        }
      }
    }
    ]]>
  </Processing>
</ScanPattern>

Zukünftige Verbesserungen für das Custom GPT

Die aktuelle Version profitiert erheblich von der Möglichkeit, zu kompilieren und Fehler zu erkennen. Allerdings lassen sich nicht alle Fehler auf diese Weise entdecken. Diese Art von Fehlern wird als „Runtime Errors“ bezeichnet, da sie erst während der Laufzeit auftreten.

Glücklicherweise gibt es eine Lösung, um solche Fehler zu erfassen: automatisiertes Testing. Künftig wird CustomGPT in der Lage sein zu prüfen, ob ein Pattern korrekte Ergebnisse liefert, ohne dass es auf einem Zielgerät bereitgestellt und getestet werden muss.

Nach der erfolgreichen Kompilierung eines Patterns stellt euch das Custom GPT einen Shell-Befehl bereit, den ihr auf einem der Zielhosts ausführen könnt. Nach der Ausführung müsst ihr die von diesem Rechner erzeugte Ausgabe zurück in das Chatfenster einfügen. Anschließend führt das GPT automatisierte Tests durch, um sicherzustellen, dass der generierte Code die bereitgestellte Ausgabe korrekt verarbeitet, und nimmt bei Fehlern die notwendigen Änderungen vor.