Een statusserver voor pull-aanvragen maken met Node.js

2025-10-08

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

De pull-aanvraagwerkstroom (PR) biedt ontwikkelaars de mogelijkheid om feedback te krijgen over hun code van peers en van geautomatiseerde hulpprogramma's. Niet-Microsoft-hulpprogramma's en -services kunnen deelnemen aan de PR-werkstroom met behulp van de Status-API. In dit artikel wordt u begeleid bij het maken van een statusserver om PR's te valideren in een Git-opslagplaats van Azure DevOps Services. Voor meer informatie over de status van pull-aanvragen, zie Werkstromen voor pull-aanvragen aanpassen en uitbreiden met de status van pull-aanvragen.

Voorwaarden

Categorie	Vereisten
Organisatie	Een organisatie in Azure DevOps met een Git-opslagplaats.
Gereedschappen	- Visual Studio Code of andere code-editor van uw keuze. - Node.js. De download bevat een installatieprogramma dat u kunt uitvoeren om de Node.js runtime op uw lokale computer te installeren. Wanneer u Node.jsinstalleert, moet u ervoor zorgen dat u het onderdeel van de npm-pakketbeheerder behoudt als onderdeel van de installatie, dat standaard is geselecteerd.
Authenticatie	Microsoft Entra ID-token met het bereik Code (status) om toestemming te krijgen om de PR-status te wijzigen. Zie Microsoft Entra-verificatie voor meer informatie.

Een eenvoudige webserver maken met Express

In de stappen in deze sectie wordt gebruikgemaakt van Express. Dit is een lichtgewicht webframework voor Node.js dat veel METHODEN voor HTTP-hulpprogramma's biedt die het maken van een webserver vereenvoudigen. Dit framework biedt u de basisfuncties die nodig zijn om te luisteren naar pr-gebeurtenissen.

Maak vanaf de commandoregel een nieuwe projectmap voor uw webserver.
```
mkdir pr-server
cd pr-server
```
Gebruik de opdracht npm init om een nieuw package.json-bestand voor het project te maken.
```
npm init
```
Selecteer Enter om de standaardwaarden voor alle opties te accepteren, met uitzondering van het toegangspunt. Wijzig deze in app.js
```
entry point: (index.js) app.js
```
Installeer Express in de pr-server map met behulp van de volgende opdracht. Hiermee wordt Express geïnstalleerd en opgeslagen in de lijst met afhankelijkheden.
```
npm install express
```
Maak een Express-app waarop u kunt voortbouwen voor de PR-statusserver. De volgende stappen zijn gebaseerd op het voorbeeld van Express Hello world.

een. Open de projectmap in Visual Studio Code door de volgende opdracht uit te voeren vanuit de pr-server map.
```
code .
```
b. Maak een nieuw bestand (Ctrl + N) en plak de volgende voorbeeldcode om een eenvoudige Express-server te maken.
```
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!')
})
```
Hoofdstuk c. Sla het bestand op als app.js.
Voer de basiswebserver uit met behulp van de volgende opdracht:
```
node app.js
```
Controleer of de server draait door naar http://localhost:3000/te gaan.

Luisteren naar HTTP POST-aanvragen

De webserver ontvangt POST aanvragen van Azure DevOps Services, dus u moet deze aanvragen op uw server afhandelen.

Voeg aan het einde van het app.js-bestand de volgende code toe en sla het bestand op.
```
app.post('/', function (req, res) {
    res.send('Received the POST')
})
```
Voer de webserver opnieuw uit met behulp van de volgende opdracht:
```
node app.js
```

Een servicehook configureren voor pr-gebeurtenissen

Servicehook is een Azure DevOps Services-functie waarmee externe services kunnen worden gewaarschuwd wanneer bepaalde gebeurtenissen optreden. Stel voor dit voorbeeld twee servicehook in voor pr-gebeurtenissen, zodat de statusserver op de hoogte kan worden gesteld. De eerste gebeurtenis is voor de pull-aanvraag die is gemaakt en de tweede gebeurtenis is voor de pull-aanvraag die is bijgewerkt.

Als u meldingen van de servicehook wilt ontvangen, stelt u een poort beschikbaar op het openbare internet. Het hulpprogramma ngrok is handig om dit in een ontwikkelomgeving te doen.

Download en pak de juiste ngrok-release uit voor uw platform.
Gebruik ngrok om te beginnen met luisteren op dezelfde poort als uw voorbeeldserver - poort 3000. Voer de volgende opdracht uit in een nieuw opdrachtvenster.
```
ngrok http 3000
```
Ngrok maakt een openbare URL die wordt doorgestuurd naar localhost:3000. Noteer de URL, zoals u in de volgende stap nodig hebt. Het ziet er als volgt uit:
```
http://c3c1bffa.ngrok.io
```
Blader naar uw project in Azure DevOps, bijvoorbeeld https://dev.azure.com/<your account>/<your project name>
Beweeg in het navigatiemenu de cursor over het tandwiel en selecteer Service Hooks.
Als dit uw eerste servicehook is, selecteert u + Abonnement maken.

Als u al andere servicehook hebt geconfigureerd, selecteert u het plusteken (+) om een nieuw servicehookabonnement te maken.
Selecteer in het dialoogvenster Nieuw servicekoppelingsabonnement Webkoppeling in de lijst met services en selecteer vervolgens Volgende.
Selecteer pull-aanvraag die is gemaakt in de lijst met gebeurtenistriggers en selecteer vervolgens Volgende.
Voer op de pagina Actie de URL van ngrok in het vak URL in. Selecteer Test om een test gebeurtenis naar uw server te verzenden.

In het consolevenster van ngrok retourneert een binnenkomende POST een 200 OK, waarmee wordt aangegeven dat uw server de servicehookgebeurtenis heeft ontvangen.
```
HTTP Requests
-------------

POST /                         200 OK
```
Selecteer in het venster Testmelding het tabblad Antwoord om de details van het antwoord van uw server te bekijken. U ziet nu een inhoudslengte van 17 die overeenkomt met de lengte van de tekenreeks van uw POST-handler (bijvoorbeeld 'De POST ontvangen').
Sluit het testnotificatievenster en selecteer Voltooien om de servicehook te maken.

Voer de stappen 3 tot en met 9 opnieuw uit, maar configureer deze keer de gebeurtenis bijgewerkte pull request.

Belangrijk

Zorg ervoor dat u de voorgaande stappen twee keer doorloopt en servicehooks maakt voor zowel de gebeurtenis pull-verzoek aangemaakt als de gebeurtenis pull-verzoek bijgewerkt.

Status plaatsen naar pull requests

Nu uw server service hook gebeurtenissen kan ontvangen wanneer er nieuwe pull-aanvragen worden gemaakt, werkt u deze bij om de status terug te sturen naar de pull-aanvraag.

Servicehookaanvragen bevatten een JSON-nettolading die de gebeurtenis beschrijft. Als u de JSON wilt parseren die door de servicehook wordt geretourneerd, installeert u het body-parser-pakket.
```
npm install body-parser
```
Werk app.js bij om body-parser te gebruiken voor het parsen van application/json.
```
var bodyParser = require('body-parser')

app.use(bodyParser.json())
```
Installeer het azure-devops-node-api--pakket om het maken van REST API-aanroepen naar Azure-opslagplaatsen te vereenvoudigen.
```
npm install azure-devops-node-api 
```

Werk app.js bij om het azure-devops-node-api-pakket te gebruiken, de details voor een verbinding met uw account in te stellen en een exemplaar van de Git-API op te halen.

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()

Maak een omgevingsvariabele voor uw verzamelings-URL, waarbij u <your account> vervangt door de naam van uw Azure DevOps-organisatie.
```
setx COLLECTIONURL "https://dev.azure.com/<your account>"
```
Haal een Microsoft Entra ID-token op dat uw app moet gebruiken. Microsoft Entra ID-tokens zijn de aanbevolen verificatiemethode voor Azure DevOps REST API's. U kunt deze tokens op de volgende manieren ophalen:
- Optie 1: Azure CLI (voor ontwikkeling/testen)
```
az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798 --query "accessToken" --output tsv
```
- Optie 2: Service Principal (voor productie)
  1. Een sollicitatie in ID Microsoft Entra registreren
  2. Een clientgeheim voor de toepassing maken
  3. Bied de toepassing de juiste machtigingen in Azure DevOps.
  4. Gebruik de inloggegevens van de serviceprincipal om programmatisch tokens op te halen
Zie Microsoft Entra-verificatie voor meer informatie.
Maak een omgevingsvariabele voor uw Microsoft Entra ID-token.
```
setx TOKEN "your-entra-id-token-here"
```

Programmatisch Microsoft Entra ID-tokens verkrijgen (aanbevolen voor productie)

Voor productietoepassingen moet u programmatisch Microsoft Entra ID-tokens verkrijgen in plaats van statische tokens te gebruiken. U kunt dit als volgt implementeren met behulp van de Microsoft Authentication Library (MSAL) voor Node.js:

Installeer het MSAL Node-pakket:
```
npm install @azure/msal-node
```

Een tokenprovidermodule maken (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 };

Werk uw app.js gegevens bij om de tokenprovider te gebruiken:

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');
    }
});

Werk de post()-functie bij om de PR-details van de payload van de servicehook te lezen. U hebt deze waarden nodig om de status terug te plaatsen.
```
var repoId = req.body.resource.repository.id
var pullRequestId = req.body.resource.pullRequestId
var title = req.body.resource.title
```
Bouw het statusobject om te plaatsen op de pull request.

State is een opsomming van het type GitStatusState. Gebruik succeeded om aan te geven dat de PR de statuscontrole heeft doorgegeven en klaar is om te mergen.

De description is een tekenreekswaarde die aan gebruikers wordt weergegeven in de Status-sectie en activiteitsfeed in de detailweergave van de pull request.

De targetUrl is een URL die wordt gebruikt om een koppeling te maken voor de beschrijvingstekst in de sectie Status en activiteitsfeed, waar gebruikers meer informatie kunnen krijgen over de status, bijvoorbeeld een buildrapport of testuitvoering. Als er geen URL is opgegeven, wordt de beschrijving weergegeven als tekst zonder koppeling.

De context name en genre worden gebruikt om de status te categoriseren en te onderscheiden van andere services die de status plaatsen.
```
    var prStatus = {
        "state": "succeeded",
        "description": "Ready for review",
        "targetUrl": "https://visualstudio.microsoft.com",
        "context": {
            "name": "wip-checker",
            "genre": "continuous-integration"
        }
    }
```
In plaats van onmiddellijk de succeeded-status te plaatsen, controleert u de titel van de PR om te zien of de gebruiker heeft aangegeven dat de PR een werk in uitvoering is door WIP aan de titel toe te voegen. Als dat het geval is, wijzig dan de status die terug naar de pull-aanvraag is gepost.
```
    if (title.includes("WIP")) {
        prStatus.state = "pending"
        prStatus.description = "Work in progress"
    }
```
Plaats ten slotte de status met behulp van de methode createPullRequestStatus(). Hiervoor zijn het statusobject, de opslagplaats-id en de pull-aanvraag-id vereist. Voer het antwoord uit naar de knooppuntconsole, zodat u het resultaat van het bericht kunt zien.
```
vstsGit.createPullRequestStatus(prStatus, repoId, pullRequestId).then( result => {
    console.log(result)
})
```

De resulterende methode moet er ongeveer als volgt uitzien:

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')
    }
})

Sla app.js op en start de knooppunt-app opnieuw.
```
node app.js
```

Een nieuwe pull-aanvraag maken voor het testen van de statusserver

Nu uw server draait en luistert naar servicehook-meldingen, maakt u een pull-aanvraag aan om deze te testen.

Begin in de bestandsweergave. Bewerk het readme.md bestand in uw opslagplaats (of een ander bestand als u geen readme.md hebt).
Breng een bewerking aan en voer de wijzigingen door in de opslagplaats.
Zorg ervoor dat je de wijzigingen doorvoert in een nieuwe vertakking, zodat je in de volgende stap een pull request kunt maken.
Selecteer de Een pull-aanvraag maken koppeling.
Voeg WIP- toe aan de titel om de functionaliteit van de app te testen. Selecteer Maken om de pull request te maken.
Zodra de pull-aanvraag is gemaakt, wordt de statussectie weergegeven met de vermelding Bezig die is gekoppeld aan de URL die in de payload is opgegeven.
Werk de titel van de pull request bij en verwijder de WIP tekst en houd er rekening mee dat de status verandert van Werk in uitvoering naar Klaar voor beoordeling.