Tworzenie serwera statusu pull requestu przy użyciu Node.js

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

Przepływ pracy pull request (PR) daje deweloperom możliwość uzyskania opinii na temat kodu od kolegów oraz narzędzi automatycznych. Narzędzia i usługi innych firm mogą uczestniczyć w przepływie pracy nad żądaniami scalenia, korzystając z interfejsu API stanu żądania scalenia. Ten artykuł przeprowadzi Cię przez proces konfiguracji serwera do zarządzania statusami w celu weryfikacji pull requestów (PR) w repozytorium Git w Azure DevOps Services. Aby uzyskać więcej informacji na temat stanu pull requestu, zobacz Dostosowywanie i rozszerzanie przepływów pracy pull requestów ze statusem pull requestu.

Warunki wstępne

Kategoria	Wymagania
Organizacja	Organizacja w usłudze Azure DevOps z repozytorium Git.
Narzędzia	- programu Visual Studio Code lub innego wybranego edytora kodu. - Node.js. Pobieranie zawiera instalator, który można uruchomić w celu zainstalowania środowiska uruchomieniowego Node.js na komputerze lokalnym. Podczas instalowania Node.jspamiętaj, aby zaznaczyć część instalacyjną menedżera pakietów npm, która jest domyślnie wybrana.
Uwierzytelnianie	Token identyfikatora Entra firmy Microsoft z zakresem Kod (stan) umożliwiającym zmianę statusu PR (Pull Request). Aby uzyskać więcej informacji, zobacz Microsoft Entra authentication.

Tworzenie podstawowego serwera internetowego przy użyciu platformy Express

W krokach w tej sekcji użyto Express, która jest uproszczoną strukturą internetową dla Node.js, która udostępnia wiele metod narzędzi HTTP, które upraszczają tworzenie serwera internetowego. Ta struktura zapewnia podstawowe funkcje potrzebne do nasłuchiwania zdarzeń pull request.

W wierszu polecenia utwórz nowy folder projektu dla serwera internetowego.
```
mkdir pr-server
cd pr-server
```
Użyj polecenia npm init, aby utworzyć nowy plik package.json dla projektu.
```
npm init
```
Wybierz pozycję Wprowadź, aby zaakceptować wartości domyślne dla wszystkich opcji z wyjątkiem punktu wejścia. Zmień ją na app.js
```
entry point: (index.js) app.js
```
Zainstaluj platformę Express w katalogu pr-server przy użyciu następującego polecenia. Spowoduje to zainstalowanie programu Express i zapisanie go na liście zależności.
```
npm install express
```
Utwórz aplikację Express, aby rozwijać serwer statusu PR. Poniższe kroki są oparte na przykładzie usługi Express Hello world.

a. Otwórz folder projektu w programie Visual Studio Code, uruchamiając następujące polecenie z pr-server folderu .
```
code .
```
b. Utwórz nowy plik (Ctrl + N) i wklej następujący przykładowy kod, aby utworzyć podstawowy serwer Express.
```
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. Zapisz plik jako app.js.
Uruchom podstawowy serwer internetowy przy użyciu następującego polecenia:
```
node app.js
```
Sprawdź, czy serwer jest uruchomiony, przechodząc do http://localhost:3000/.

Nasłuchiwanie żądań HTTP POST

Serwer internetowy będzie odbierać żądania POST z usług Azure DevOps Services, dlatego musisz obsługiwać te żądania na serwerze.

Na końcu pliku app.js dodaj następujący kod i zapisz plik.

app.post('/', function (req, res) {
    res.send('Received the POST')
})

Uruchom ponownie serwer internetowy przy użyciu następującego polecenia:
```
node app.js
```

Konfigurowanie haka usługi dla zdarzeń pull request.

Punkty zaczepienia usług to funkcja usług Azure DevOps Services, która może powiadamiać usługi zewnętrzne o wystąpieniu niektórych zdarzeń. W tym przykładzie skonfiguruj dwa hooki serwisowe dla zdarzeń pull request, aby serwer stanu był powiadamiany. Pierwszy dotyczy zdarzenia utworzenia żądania ściągnięcia , a drugi dotyczy zaktualizowania żądania ściągnięcia .

Aby otrzymywać powiadomienia o webhooku usługi, udostępnij port do publicznego internetu. Narzędzie ngrok jest przydatne w tym celu w środowisku projektowym.

Pobierz i rozpakuj odpowiednią wersję ngrok dla swojej platformy.
Użyj narzędzia ngrok, aby rozpocząć nasłuchiwanie na tym samym porcie co przykładowy serwer — port 3000. Uruchom następujące polecenie w nowym oknie polecenia.
```
ngrok http 3000
```
Ngrok tworzy publiczny adres URL, który przekierowuje do localhost:3000. Zanotuj adres URL, ponieważ jest potrzebny w następnym kroku. Wygląda to jak w poniższym przykładzie:
```
http://c3c1bffa.ngrok.io
```
Przejdź do projektu w usłudze Azure DevOps, na przykład https://dev.azure.com/<your account>/<your project name>
W menu nawigacji najedź kursorem na ikonę koła zębatego i wybierz pozycję Service Hooks.
Jeśli jest to pierwszy punkt zaczepienia usługi, wybierz pozycję + Utwórz subskrypcję.

Jeśli masz już skonfigurowane inne punkty zaczepienia usługi, wybierz plus (+), aby utworzyć nową subskrypcję punktu zaczepienia usługi.
W oknie dialogowym Nowa subskrypcja usługi wybierz pozycję Web Hooks z listy usług, a następnie wybierz Dalej.
Wybierz pozycję Żądanie ściągnięcia utworzone z listy wyzwalaczy zdarzeń, a następnie wybierz pozycję Dalej.
Na stronie Akcja wprowadź adres URL z narzędzia ngrok w polu URL. Wybierz pozycję Test, aby wysłać zdarzenie testowe do serwera.

W oknie konsoli ngrok sygnał przychodzący POST zwraca 200 OK, wskazując, że serwer odebrał zdarzenie webhooka usługi.
```
HTTP Requests
-------------

POST /                         200 OK
```
W oknie Powiadomienie testowe wybierz kartę Odpowiedź, aby wyświetlić szczegóły odpowiedzi z serwera. Powinna zostać wyświetlona długość zawartości wynosząca 17, zgodna z długością ciągu z obsługi POST (na przykład "Odebrano POST").
Zamknij okno Powiadomienia testowego i wybierz Zakończ, aby utworzyć hook serwisowy.

Ponownie wykonaj kroki 3–9, ale tym razem skonfiguruj zaktualizowane wydarzenie żądania ściągnięcia.

Ważny

Pamiętaj, aby wykonać poprzednie kroki dwa razy i utworzyć punkty zaczepienia usługi zarówno dla zdarzenia utworzenia żądania pobrania , jak i zaktualizowania żądania pobrania .

Wysyłanie statusu do pull requestów

Teraz, gdy serwer może odbierać zdarzenia punktu zaczepienia usługi po utworzeniu nowych żądań ściągnięcia, zaktualizuj go, aby przywrócić stan żądania ściągnięcia do żądania ściągnięcia.

Żądania punktów zaczepienia usługi obejmują ładunek JSON opisujący zdarzenie. Dla ułatwienia analizy kodu JSON zwróconego przez hak serwisowy, zainstaluj pakiet body-parser.
```
npm install body-parser
```
Zaktualizuj app.js, aby użyć parsera treści do analizowania application/json.
```
var bodyParser = require('body-parser')

app.use(bodyParser.json())
```
Aby uprościć wykonywanie wywołań interfejsu API REST do usługi Azure Repos, zainstaluj pakiet azure-devops-node-api.
```
npm install azure-devops-node-api 
```

Zaktualizuj app.js, aby używać pakietu azure-devops-node-api, skonfiguruj szczegóły połączenia ze swoim kontem i uzyskaj wystąpienie interfejsu API systemu Git.

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

Utwórz zmienną środowiskową dla adresu URL kolekcji, zastępując <your account> nazwą organizacji usługi Azure DevOps.
```
setx COLLECTIONURL "https://dev.azure.com/<your account>"
```
Pobierz token identyfikatora Entra firmy Microsoft, który ma być używany przez aplikację. Tokeny identyfikatora Microsoft Entra ID to zalecana metoda uwierzytelniania dla interfejsów API REST usługi Azure DevOps. Te tokeny można uzyskać za pomocą następujących sposobów:
- Opcja 1. Interfejs wiersza polecenia platformy Azure (na potrzeby programowania/testowania)
```
az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798 --query "accessToken" --output tsv
```
- Opcja 2. Jednostka usługi (dla środowiska produkcyjnego)
  1. Rejestrowanie aplikacji w Microsoft Entra ID
  2. Stworzyć tajny klucz klienta dla aplikacji
  3. Udzielanie aplikacji odpowiednich uprawnień w usłudze Azure DevOps
  4. Użyj poświadczeń podmiotu usługi do programowego uzyskiwania tokenów.
Aby uzyskać więcej informacji, zobacz Microsoft Entra authentication.
Utwórz zmienną środowiskową dla tokenu identyfikatora Entra firmy Microsoft.
```
setx TOKEN "your-entra-id-token-here"
```

Programowe uzyskiwanie tokenów identyfikatora Entra firmy Microsoft (zalecane w środowisku produkcyjnym)

W przypadku aplikacji produkcyjnych należy programowo uzyskać tokeny identyfikatora Entra firmy Microsoft zamiast używać tokenów statycznych. Oto jak zaimplementować tę funkcję przy użyciu biblioteki Microsoft Authentication Library (MSAL) dla Node.js:

Zainstaluj pakiet MSAL Node:
```
npm install @azure/msal-node
```

Tworzenie modułu dostawcy tokenów (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 };

Zaktualizuj element app.js, aby używać dostawcy tokenów.

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

Zaktualizuj funkcję post(), aby odczytać szczegóły PR z ładunku wyzwalacza usługi. Potrzebujesz tych wartości, aby przesłać stan zwrotny.
```
var repoId = req.body.resource.repository.id
var pullRequestId = req.body.resource.pullRequestId
var title = req.body.resource.title
```
Zbuduj obiekt stanu na PR.

State to wyliczenie typu GitStatusState. Użyj succeeded, aby wskazać, że PR przeszedł pomyślnie sprawdzanie stanu i jest gotowy do scalenia.

description jest ciągiem znaków wyświetlanym użytkownikowi w sekcji Stan oraz w kanale aktywności w widoku szczegółów żądania ściągnięcia.

targetUrl to adres URL używany do utworzenia linku do tekstu opisu w sekcji Stan i źródle aktywności, gdzie użytkownicy mogą znaleźć więcej informacji na temat stanu, na przykład raport z budowy lub przebieg testów. Jeśli nie określono żadnego adresu URL, opis będzie wyświetlany jako tekst bez linku.

Kontekst name i genre są używane do kategoryzowania stanu i odróżnienia go od innych usług ogłaszania stanu.
```
    var prStatus = {
        "state": "succeeded",
        "description": "Ready for review",
        "targetUrl": "https://visualstudio.microsoft.com",
        "context": {
            "name": "wip-checker",
            "genre": "continuous-integration"
        }
    }
```
Zamiast od razu publikować stan succeeded, sprawdź tytuł PR, aby zobaczyć, czy użytkownik wskazał, że PR jest w toku, dodając WIP do tytułu. Jeśli tak, zmień status i wyślij go z powrotem do PR.
```
    if (title.includes("WIP")) {
        prStatus.state = "pending"
        prStatus.description = "Work in progress"
    }
```
Na koniec opublikuj stan przy użyciu metody createPullRequestStatus(). Wymaga to obiektu statusu, identyfikatora repozytorium i identyfikatora żądania ściągnięcia. Wyprowadź odpowiedź na konsolę Node.js, aby zobaczyć wynik wysłania danych.
```
vstsGit.createPullRequestStatus(prStatus, repoId, pullRequestId).then( result => {
    console.log(result)
})
```

Wynikowa metoda powinna wyglądać mniej więcej tak:

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

Zapisz app.js i uruchom ponownie aplikację node.
```
node app.js
```

Utworzyć nowy pull request na potrzeby testowania serwera stanu

Teraz, gdy serwer jest uruchomiony i nasłuchuje powiadomień o hookach serwisowych, utwórz pull request, aby go przetestować.

Uruchom w widoku plików. Edytuj plik readme.md w repozytorium (lub inny plik, jeśli nie masz readme.md).
Wprowadź edycję i zatwierdź zmiany w repozytorium.
Pamiętaj, aby zatwierdzić zmiany w nowej gałęzi, aby można było utworzyć pull request w następnym kroku.
Wybierz link Utwórz pull request.
Dodaj WIP w tytule, aby przetestować działanie aplikacji. Wybierz Utwórz, aby stworzyć żądanie scalenia.
Gdy PR zostanie utworzony, sekcja stanu pokazuje wpis Praca w toku, który łączy się z adresem URL określonym w ładunku.
Zaktualizuj tytuł PR i usuń tekst WIP oraz zwróć uwagę, że status zmienia się z Praca w toku na Gotowe do przeglądu.

dokumentacja interfejsu API REST
Konfigurowanie zasad gałęzi dla usługi zewnętrznej

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-17