Erstellen eines Pullanforderungsstatusservers mit Node.js

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

Der Pull-Anforderungsworkflow (PR) bietet Entwicklern die Möglichkeit, Feedback zu ihrem Code von Peers und von automatisierten Tools zu erhalten. Nicht-Microsoft-Tools und -Dienste können mit der PR-Status-APIam PR-Workflow teilnehmen. Dieser Artikel führt Sie durch den Prozess der Erstellung eines Statusservers zum Überprüfen von PRs in einem Git-Repository von Azure DevOps Services. Weitere Informationen zu PR-Status finden Sie unter Anpassen und Erweitern von Pull Request-Workflows mit Pull Request-Status.

Voraussetzungen

Kategorie	Anforderungen
Organisation	Eine Organisation in Azure DevOps mit einem Git-Repository.
Werkzeuge	- Visual Studio Code oder anderer Code-Editor Ihrer Wahl. - Node.js. Der Download enthält ein Installationsprogramm, das Sie ausführen können, um die Node.js Laufzeit auf Ihrem lokalen Computer zu installieren. Achten Sie beim Installieren von Node.jsdarauf, den npm-Paket-Manager Teil der Installation beizubehalten, der standardmäßig ausgewählt ist.
Authentifizierung	Microsoft Entra ID Token mit dem Code (Status) Bereich, um die Berechtigung zur Änderung des PR-Status zu erhalten. Weitere Informationen finden Sie unter Microsoft Entra-Authentifizierung.

Erstellen eines einfachen Webservers mit Express

In den Schritten in diesem Abschnitt wird Expressverwendet, bei dem es sich um ein einfaches Webframework für Node.js handelt, das viele HTTP-Hilfsmethoden bereitstellt, die das Erstellen eines Webservers vereinfachen. Dieses Framework bietet Ihnen die grundlegenden Funktionen, die zum Hören von PR-Ereignissen erforderlich sind.

Erstellen Sie in der Befehlszeile einen neuen Projektordner für Ihren Webserver.
```
mkdir pr-server
cd pr-server
```
Verwenden Sie den Befehl npm init, um eine neue package.json Datei für das Projekt zu erstellen.
```
npm init
```
Wählen Sie und geben Sie ein, um die Standardwerte für alle Optionen außer dem Einstiegspunkt zu akzeptieren. Ändern sie es zu app.js
```
entry point: (index.js) app.js
```
Installieren Sie Express im verzeichnis pr-server mit dem folgenden Befehl. Dadurch wird Express installiert und in der Abhängigkeitenliste gespeichert.
```
npm install express
```
Erstellen Sie eine Express-App als Grundlage für den PR-Statusserver. Die folgenden Schritte basieren auf dem Beispiel "Express Hello world".

a) Öffnen Sie den Projektordner in Visual Studio Code, indem Sie den folgenden Befehl aus dem pr-server Ordner ausführen.
```
code .
```
b. Erstellen Sie eine neue Datei (Ctrl + N) , und fügen Sie den folgenden Beispielcode ein, um einen einfachen Express-Server zu erstellen.
```
const express = require('express')
const app = express()

app.get('/', function (req, res) {
res.send('Hello World!')
})

app.listen(3000, function () {
console.log('Example app listening on port 3000!')
})
```
c. Speichern Sie die Datei als app.js.
Führen Sie den grundlegenden Webserver mit dem folgenden Befehl aus:
```
node app.js
```
Überprüfen Sie, ob der Server ausgeführt wird, indem Sie zu http://localhost:3000/ wechseln.

Auf HTTP POST-Anforderungen lauschen

Der Webserver empfängt POST Anforderungen von Azure DevOps Services, daher müssen Sie diese Anforderungen auf Ihrem Server verarbeiten.

Fügen Sie am Ende der app.js-Datei den folgenden Code hinzu, und speichern Sie die Datei.
```
app.post('/', function (req, res) {
    res.send('Received the POST')
})
```
Führen Sie den Webserver mit dem folgenden Befehl erneut aus:
```
node app.js
```

Konfigurieren eines Diensthakens für PR-Ereignisse

Dienst-Hooks sind ein Azure DevOps Services-Feature, das externe Dienste benachrichtigen kann, wenn bestimmte Ereignisse auftreten. Richten Sie für dieses Beispiel zwei Dienst-Hooks für PR-Ereignisse ein, damit der Statusserver benachrichtigt werden kann. Der erste ist für das Pull Request erstellt-Ereignis und der zweite für das Pull Request aktualisiert-Ereignis.

Um die Service Hook-Benachrichtigungen zu empfangen, machen Sie einen Port im öffentlichen Internet verfügbar. Das ngrok-Hilfsprogramm ist nützlich, um dies in einer Entwicklungsumgebung zu tun.

Laden Sie die entsprechende ngrok-Version für Ihre Plattform herunter, und entpacken Sie sie.
Verwenden Sie ngrok, um mit dem Überwachen desselben Ports wie ihr Beispielserver – Port 3000 – zu beginnen. Führen Sie den folgenden Befehl in einem neuen Befehlsfenster aus.
```
ngrok http 3000
```
Ngrok erstellt eine öffentliche URL, die an localhost:3000weitergeleitet wird. Notieren Sie sich die URL, wie Sie sie im nächsten Schritt benötigen. Es sieht wie im folgenden Beispiel aus:
```
http://c3c1bffa.ngrok.io
```
Navigieren Sie zu Ihrem Projekt in Azure DevOps, z. B. https://dev.azure.com/<your account>/<your project name>
Zeigen Sie im Navigationsmenü mit dem Mauszeiger auf das Zahnrad, und wählen Sie Service Hooks aus.
Wenn es sich um Ihren ersten Diensthaken handelt, wählen Sie +Abonnement erstellen.

Wenn Sie bereits andere Diensthaken konfiguriert haben, wählen Sie das Plus-(+) aus, um ein neues Service hook-Abonnement zu erstellen.
Wählen Sie im Dialogfeld "Neues Service Hooks-Abonnement" Web Hooks aus der Liste der Dienste aus, und wählen Sie dann Weiteraus.
Wählen Sie in der Liste der Ereignistrigger Pull Request erstellt aus, und wählen Sie dann Weiter aus.
Geben Sie auf der Seite "Aktion" die URL von ngrok in das Feld URL ein. Wählen Sie Test- aus, um ein Testereignis an Ihren Server zu senden.

Im ngrok-Konsolenfenster wird ein eingehender POST angezeigt, der 200 OK zurückgibt, was darauf hinweist, dass Ihr Server das Service Hook-Ereignis empfangen hat.
```
HTTP Requests
-------------

POST /                         200 OK
```
Wählen Sie im Fenster "Testbenachrichtigung" die Registerkarte "Antwort" aus, um die Details der Antwort vom Server anzuzeigen. Es sollte eine Inhaltslänge von 17 angezeigt werden, die der Länge der Zeichenfolge von Ihrem POST-Handler entspricht (z. B. "Received the POST").
Schließen Sie das Fenster „Testbenachrichtigung“, und wählen Sie Fertig stellen aus, um den Service Hook zu erstellen.

Führen Sie die Schritte 3 bis 9 erneut aus, aber konfigurieren Sie dieses Mal das Pull Request aktualisiert-Ereignis.

Wichtig

Stellen Sie sicher, dass Sie die vorherigen Schritte zweimal ausführen, und Service Hooks sowohl für das Pull Request erstellt-Ereignis als auch für das Pull Request aktualisiert-Ereignis erstellen.

Bereitstellen des Status in PRs

Nachdem Ihr Server nun Service Hook-Ereignisse empfangen kann, wenn neue PRs erstellt werden, aktualisieren Sie ihn so, dass er den Status an den PR zurückpostet.

Service hook-Anforderungen enthalten eine JSON-Nutzlast, die das Ereignis beschreibt. Um den vom Diensthaken zurückgegebenen JSON zu analysieren, installieren Sie das Body-Parser--Paket.
```
npm install body-parser
```
Aktualisieren Sie app.js, um den Body-Parser zum Analysieren von application/jsonzu verwenden.
```
var bodyParser = require('body-parser')

app.use(bodyParser.json())
```
Um die Erstellung von REST-API-Aufrufen an Azure Repos zu vereinfachen, installieren Sie das azure-devops-node-api--Paket.
```
npm install azure-devops-node-api 
```

Aktualisieren Sie app.js, um das Azure-devops-node-api-Paket zu verwenden, richten Sie die Details für eine Verbindung mit Ihrem Konto ein, und rufen Sie eine Instanz der Git-API ab.

const vsts = require("azure-devops-node-api")

const collectionURL = process.env.COLLECTIONURL    
const token = process.env.TOKEN

var authHandler = vsts.getBearerHandler(token)
var connection = new vsts.WebApi(collectionURL, authHandler)
var vstsGit = connection.getGitApi()

Erstellen Sie eine Umgebungsvariable für Ihre Sammlungs-URL, indem Sie <your account> durch den Namen Ihrer Azure DevOps-Organisation ersetzen.
```
setx COLLECTIONURL "https://dev.azure.com/<your account>"
```
Holen Sie ein Microsoft Entra-ID-Token für Ihre App. Microsoft Entra-ID-Token sind die empfohlene Authentifizierungsmethode für Azure DevOps-REST-APIs. Sie können diese Token wie folgt abrufen:
- Option 1: Azure CLI (für Entwicklung/Tests)
```
az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798 --query "accessToken" --output tsv
```
- Option 2: Service Principal (für Produktionsumgebungen)
  1. Registrieren einer Anwendung in Microsoft Entra ID
  2. Erstellen eines geheimen Clientschlüssels für die Anwendung
  3. Erteilen der anwendung entsprechenden Berechtigungen in Azure DevOps
  4. Verwenden Sie die Anmeldeinformationen des Dienstprinzipals, um Token programmgesteuert abzurufen.
Weitere Informationen finden Sie unter Microsoft Entra-Authentifizierung.
Erstellen Sie eine Umgebungsvariable für Ihr Microsoft Entra-ID-Token.
```
setx TOKEN "your-entra-id-token-here"
```

Microsoft Entra ID Token programmgesteuert abrufen (empfohlen für die Produktion)

Für Produktionsanwendungen sollten Sie Microsoft Entra-ID-Token programmgesteuert abrufen, anstatt statische Token zu verwenden. Hier erfahren Sie, wie Sie dies mithilfe der Microsoft Authentication Library (MSAL) für Node.jsimplementieren:

Installieren Sie das MSAL Node-Paket:
```
npm install @azure/msal-node
```

Erstellen eines Tokenanbietermoduls (tokenProvider.js):

const { ConfidentialClientApplication } = require('@azure/msal-node');

const clientConfig = {
    auth: {
        clientId: process.env.CLIENT_ID,
        clientSecret: process.env.CLIENT_SECRET,
        authority: `https://login.microsoftonline.com/${process.env.TENANT_ID}`
    }
};

const cca = new ConfidentialClientApplication(clientConfig);

async function getAccessToken() {
    const clientCredentialRequest = {
        scopes: ['499b84ac-1321-427f-aa17-267ca6975798/.default']
    };

    try {
        const response = await cca.acquireTokenByClientCredential(clientCredentialRequest);
        return response.accessToken;
    } catch (error) {
        console.error('Error acquiring token:', error);
        throw error;
    }
}

module.exports = { getAccessToken };

Aktualisieren Sie Ihr app.js so, dass es den Tokenanbieter verwendet.

const { getAccessToken } = require('./tokenProvider');

// Instead of using a static token, get a fresh token
app.post("/", async function (req, res) {
    try {
        const token = await getAccessToken();
        var authHandler = vsts.getBearerHandler(token);
        var connection = new vsts.WebApi(collectionURL, authHandler);

        // ... rest of your POST handler code
    } catch (error) {
        console.error('Authentication error:', error);
        res.status(500).send('Authentication failed');
    }
});

Aktualisieren Sie die post()-Funktion, um die PR-Details aus der Service Hook-Nutzlast zu lesen. Sie benötigen diese Werte, um den Status zurückzusenden.
```
var repoId = req.body.resource.repository.id
var pullRequestId = req.body.resource.pullRequestId
var title = req.body.resource.title
```
Erstellen Sie das status-Objekt, das in dem PR bereitgestellt werden soll.

State ist eine Enumeration vom Typ GitStatusState. Verwenden Sie succeeded, um anzugeben, dass die PR die Statusüberprüfung bestanden hat und zum Zusammenführen bereit ist.

description ist ein Zeichenfolgenwert, der dem Benutzer im Abschnitt „Status“ sowie im Aktivitätsfeed in der PR-Detailansicht angezeigt wird.

Die targetUrl ist eine URL, die verwendet wird, um einen Link für den Beschreibungstext im Statusabschnitt und Aktivitätsfeed zu erstellen. Hier können Benutzer weitere Informationen zum Status abrufen, z. B. einen Buildbericht oder einen Testlauf. Wenn keine URL angegeben ist, wird die Beschreibung als Text ohne Link angezeigt.

Die Kontexte name und genre werden verwendet, um den Status zu kategorisieren und von anderen Diensten zu unterscheiden, die einen Status posten.
```
    var prStatus = {
        "state": "succeeded",
        "description": "Ready for review",
        "targetUrl": "https://visualstudio.microsoft.com",
        "context": {
            "name": "wip-checker",
            "genre": "continuous-integration"
        }
    }
```
Anstatt den succeeded Status sofort zu veröffentlichen, prüfen Sie den PR-Titel, um festzustellen, ob der Benutzer angegeben hat, ob es sich bei der PR um eine laufende Arbeit handelt, indem Sie WIP- zum Titel hinzufügen. Wenn ja, ändern Sie den Status, der an den PR zurückgepostet wird.
```
    if (title.includes("WIP")) {
        prStatus.state = "pending"
        prStatus.description = "Work in progress"
    }
```
Veröffentlichen Sie schließlich den Status mithilfe der createPullRequestStatus()-Methode. Es erfordert das Statusobjekt, die Repository-ID und die Pullanforderungs-ID. Geben Sie die Antwort auf der Node-Konsole aus, damit Sie das Ergebnis der Anfrage sehen können.
```
vstsGit.createPullRequestStatus(prStatus, repoId, pullRequestId).then( result => {
    console.log(result)
})
```

Die resultierende Methode sollte etwa wie folgt aussehen:

app.post("/", async function (req, res) {
    try {
        // Get the details about the PR from the service hook payload
        var repoId = req.body.resource.repository.id
        var pullRequestId = req.body.resource.pullRequestId
        var title = req.body.resource.title

        // Build the status object that we want to post.
        // Assume that the PR is ready for review...
        var prStatus = {
            "state": "succeeded",
            "description": "Ready for review",
            "targetUrl": "https://visualstudio.microsoft.com",
            "context": {
                "name": "wip-checker",
                "genre": "continuous-integration"
            }
        }

        // Check the title to see if there is "WIP" in the title.
        if (title.includes("WIP")) {
            // If so, change the status to pending and change the description.
            prStatus.state = "pending"
            prStatus.description = "Work in progress"
        }

        // Get the Git API instance and post the status to the PR
        const gitApi = await vstsGit
        const result = await gitApi.createPullRequestStatus(prStatus, repoId, pullRequestId)
        console.log(result)

        res.send("Received the POST")
    } catch (error) {
        console.error('Error processing PR status:', error)
        res.status(500).send('Error processing request')
    }
})

Speichern Sie app.js, und starten Sie die Knoten-App neu.
```
node app.js
```

Erstellen eines neuen PR zum Testen des Statusservers

Nachdem Ihr Server nun läuft und auf Servicehook-Benachrichtigungen wartet, erstellen Sie eine Pull-Anfrage, um die Funktionalität zu testen.

Beginnen Sie in der Dateiansicht. Bearbeiten Sie die readme.md Datei in Ihrem Repository (oder eine andere Datei, wenn Sie keine readme.md haben).
Nehmen Sie eine Bearbeitung vor, und committen Sie die Änderungen in das Repository.
Stellen Sie sicher, dass Sie die Änderungen in einen neuen Branch committen, damit Sie im nächsten Schritt einen PR erstellen können.
Wählen Sie den Link Pull Request erstellen aus.
Fügen Sie WIP- im Titel hinzu, um die Funktionalität der App zu testen. Wählen Sie Erstellen aus, um den PR zu erstellen.
Nachdem der PR erstellt wurde, wird der Statusabschnitt mit dem WIP-Eintrag (In Bearbeitung) angezeigt, der mit der in der Payload angegebenen URL verknüpft ist.
Aktualisieren Sie den PR-Titel, und entfernen Sie den WIP--Text, und beachten Sie, dass sich der Status von Arbeit in Bearbeitung in Bereit zur Überprüfungändert.

Feedback

War diese Seite hilfreich?

Last updated on 2025-12-17