Enterprise Server 3.20 ist derzeit als Release Candidate verfügbar.

Erstellen einer GitHub-App, die auf Webhook-Ereignisse reagiert

Hier erfährst du, wie du eine GitHub App erstellst, die eine API-Anforderung als Reaktion auf ein Webhookereignis sendet.

In diesem Artikel

Einführung

In diesem Tutorial wird veranschaulicht, wie du Code schreibst, um eine GitHub App zu erstellen, die als Reaktion auf ein Webhookereignis eine API-Anforderung sendet. Insbesondere wenn ein Pull Request in einem Repository geöffnet wird, auf das der App Zugriff gewährt wurde, empfängt die App ein Pull Request-Webhookereignis. Anschließend verwendet die App die API von GitHub, um dem Pull Request einen Kommentar hinzuzufügen.

In diesem Tutorial verwendest du deinen Computer oder Codespace als Server, während du deine App entwickelst. Sobald die App für die Verwendung in der Produktion bereit ist, solltest du deine App auf einem dedizierten Server bereitstellen.

In diesem Tutorial wird JavaScript verwendet, du kannst jedoch jede Programmiersprache verwenden, die du auf deinem Server ausführen kannst.

Informationen zu Webhooks

Wenn du eine GitHub App registrierst, kannst du eine Webhook-URL angeben und Webhookereignisse abonnieren. Wenn die Aktivität auf GitHub ein Ereignis auslöst, das deine App abonniert hat, sendet GitHub ein Webhookereignis an die Webhook-URL deiner App.

Du kannst beispielsweise deine GitHub App auf das Pull-Request-Webhook-Ereignis abonnieren. Wenn ein Pull Request in einem Repository geöffnet wird, auf das der App Zugriff gewährt wurde, sendet GitHub ein Pull Request-Webhookereignis an die Webhook-URL deiner App. Wenn mehrere Aktionen das Ereignis auslösen können, enthält die Ereignisnutzlast ein -Feld, das angibt, welche Art von Aktion das Ereignis ausgelöst hat. In diesem Beispiel wäre der Wert von , da das Ereignis ausgelöst wurde, weil ein Pull Request geöffnet wurde.

Wenn deine App auf einem Server ausgeführt wird, der auf diese Webhookereignisse lauscht, kann deine App eine Aktion ausführen, wenn sie ein Webhookereignis empfängt. Beispielsweise kann deine App die GitHub-API verwenden, um einen Kommentar an den Pull Request zu senden, wenn sie ein Pull Request-Webhookereignis empfängt.

Weitere Informationen finden Sie unter AUTOTITLE. Weitere Informationen zu möglichen Webhookereignissen und -aktionen findest du unter AUTOTITLE.

Voraussetzungen

In diesem Tutorial muss dein Computer oder Codespace Node.js Version 20 oder höher und npm Version 6.12.0 oder höher ausführen. Weitere Informationen findest du unter Node.js.

In diesem Tutorial wird vorausgesetzt, dass du über grundlegende Kenntnisse der JavaScript- und ES6-Syntax verfügst.

Einrichten

Die folgenden Abschnitte führen dich durch die Einrichtung der folgenden Komponenten:

  • ein Repository zum Speichern des Codes für Ihre App
  • eine Möglichkeit zum lokalen Empfang von Webhooks
  • eine GitHub App-Registrierung, die Pull Request-Webhookereignisse abonniert hat, über die Berechtigung zum Hinzufügen von Kommentaren zu Pull Requests verfügt und eine Webhook-URL verwendet, die Sie lokal empfangen können

Erstellen eines Repositorys zum Speichern des Codes für deine App

  1. Erstelle ein Repository zum Speichern des Codes für deine App. Weitere Informationen finden Sie unter AUTOTITLE.
  2. Klone dein Repository aus dem vorherigen Schritt. Weitere Informationen finden Sie unter AUTOTITLE. Du kannst einen lokalen Klon oder GitHub Codespaces verwenden.
  3. Navigiere in einem Terminal zu dem Verzeichnis, in dem dein Klon gespeichert ist.
  4. Wenn das Verzeichnis noch keine -Datei enthält, füge eine -Datei hinzu. Du fügst dieser Datei später Inhalte hinzu. Weitere Informationen zu Dateien finden Sie unter AUTOTITLE.

In späteren Schritten fügst du diesem Repository weiteren Code hinzu.

Eine Webhook-Proxy-URL abrufen

Um deine App lokal zu entwickeln, kannst du eine Webhook-Proxy-URL verwenden, um Webhooks von GitHub an deinen Computer oder Codespace weiterzuleiten. In diesem Tutorial wird „Smee.io“ verwendet, um eine Webhook-Proxy-URL bereitzustellen und Webhooks weiterzuleiten.

  1. Navigiere im Browser zu .
  2. Klicke auf Neuen Kanal starten.
  3. Kopiere die vollständige URL unter „Webhook-Proxy-URL“. Du verwendest diese URL in einem späteren Schritt.

Registrieren von GitHub App

Für dieses Tutorial benötigst du eine GitHub App-Registrierung mit folgenden Eigenschaften:

  • Hat aktive Webhooks
  • Verwendung einer Webhook-URL, die du lokal empfangen kannst
  • Hat die „Pull-Request“-Berechtigung für das Repository
  • Abonniert das Webhook-Ereignis „Pull request“

Die folgenden Schritte führen dich durch das Registrieren einer GitHub App mit diesen Einstellungen. Weitere Informationen zu GitHub App-Einstellungen findest du unter AUTOTITLE.

  1. Klicke auf GitHub in der oberen rechten Ecke einer beliebigen Seite auf dein Profilfoto.

  2. Navigieren Sie zu den Einstellungen für Ihr Konto.

    • Klicken Sie bei einer App, die zu einem persönlichen Konto gehört, auf Einstellungen.
    • Für eine App im Besitz einer Organisation:
      1. Klicke Sie auf Ihre Organisationen.
      2. Klicken Sie rechts neben der Organisation auf Einstellungen.
    • Für eine App im Besitz eines Unternehmens:
      1. Klicken Sie auf Enterprise-Einstellungen.

  3. Navigieren Sie zu den GitHub App-Einstellungen.

    • Für eine App, die einem persönlichen Konto oder einer Organisation gehört:
      1. Klicke in der linken Randleiste auf Developer settings und dann auf GitHub Apps.
    • Für eine App im Besitz eines Unternehmens:
      1. Klicken Sie in der linken Randleiste auf Einstellungen, und dann auf GitHub Apps.

  4. Klicken Sie auf neuen GitHub App.

  5. Geben Sie unter „Name der GitHub App“ einen Namen für Ihre App ein. Beispielsweise , wobei dein GitHub-Benutzername ist.

  6. Gib unter „Homepage-URL“ eine URL für deine App ein. Du kannst beispielsweise die URL des Repositorys verwenden, das du erstellt hast, um den Code für deine App zu speichern.

  7. Überspringe die Abschnitte „Identifizieren und Autorisieren von Benutzern“ und „Nach der Installation“ dieses Tutorials. Weitere Informationen zu diesen Einstellungen findest du unter AUTOTITLE.

  8. Stelle sicher, dass unter „Webhooks“ die Option Aktiv ausgewählt ist.

  9. Gib unter „Webhook-URL“ deine Webhook-Proxy-URL von früher ein. Weitere Informationen findest du unter Abrufen einer Webhookproxy-URL.

  10. Gib unter „Webhookgeheimnis“ eine zufällige Zeichenfolge ein. Du wirst diese Zeichenfolge später noch verwenden.

  11. Wähle unter „Repository-Berechtigungen“ neben „Pull Requests“ die Option Lesen und Schreiben aus.

  12. Wähle unter „Ereignisse abonnieren“ die Option Pull Request aus.

  13. Wählen Sie unter „Wo kann diese GitHub App installiert werden?“ die Option Nur in diesem Konto aus. Sie können dies später ändern, wenn Sie Ihre App veröffentlichen möchten.

    Hinweis

    Wenn Ihre GitHub App unter einem Unternehmen registriert ist, gilt dieser Schritt nicht.

  14. Klicken Sie auf Erstellen von GitHub App.

Schreiben von Code für deine App

Die folgenden Abschnitte führen dich durch das Schreiben von Code, damit deine App auf Webhookereignisse reagiert.

Abhängigkeiten installieren

In diesem Tutorial wird das -Modul von GitHub verwendet, um Webhookereignisse zu verarbeiten und API-Anforderungen zu stellen. Weitere Informationen zu Octokit.js findest du unter AUTOTITLE und in der Infodatei zu Octokit.js.

In diesem Tutorial wird das -Modul verwendet, um Informationen zu deiner App aus einer -Datei zu lesen. Weitere Informationen findest du unter dotenv.

In diesem Tutorial wird „Smee.io“ verwendet, um Webhooks von GitHub an deinen lokalen Server weiterzuleiten. Weitere Informationen findest du unter smee-client.

  1. Navigiere in einem Terminal zu dem Verzeichnis, in dem dein Klon gespeichert ist.
  2. Führe den entsprechenden Befehl aus, um eine entsprechende Datei mit den npm-Standardwerten zu erstellen.
  3. Führe aus .
  4. Führe aus .
  5. Führe aus . Da du während der Entwicklung deiner App nur „Smee.io“ zum Weiterleiten von Webhooks verwendest, ist dies eine Entwicklungsabhängigkeit.
  6. Füge zu deiner hinzu.

Speichere die identifizierenden Informationen und Anmeldeinformationen deiner App

In diesem Tutorial erfährst du, wie du die Anmeldeinformationen deiner App und identifizierende Informationen als Umgebungsvariablen in einer -Datei speichern kannst. Wenn du deine App bereitstellst, musst du die Art und Weise ändern, in der die Anmeldeinformationen gespeichert werden. Weitere Informationen findest du unter Bereitstellen deiner App.

Stelle sicher, dass du dich auf einem sicheren Computer befindest, bevor du diese Schritte ausführst, da du deine Anmeldeinformationen lokal speicherst.

  1. Navigiere in deinem Terminal zu dem Verzeichnis, in dem dein Klon gespeichert ist.

  2. Erstelle eine Datei namens [Dateiname] auf der obersten Verzeichnisebene.

  3. Füge zu deiner hinzu. Dadurch vermeidest du, versehentlich die Zugangsdaten deiner App zu veröffentlichen.

  4. Füge der -Datei den folgenden Inhalt hinzu. Ersetze durch den Namen von Ihre GitHub Enterprise Server-Instance. Du aktualisierst die anderen Werte in einem späteren Schritt.

    Text
    APP_ID="YOUR_APP_ID"
WEBHOOK_SECRET="YOUR_WEBHOOK_SECRET"
PRIVATE_KEY_PATH="YOUR_PRIVATE_KEY_PATH"
ENTERPRISE_HOSTNAME="YOUR_HOSTNAME"

  5. Navigiere zur Seite „Einstellungen“ für deine App:

    1. Klicke auf GitHub in der oberen rechten Ecke einer beliebigen Seite auf dein Profilfoto.

    2. Navigieren Sie zu den Einstellungen für Ihr Konto.

      • Klicken Sie bei einer App, die zu einem persönlichen Konto gehört, auf Einstellungen.
      • Für eine App im Besitz einer Organisation:
        1. Klicke Sie auf Ihre Organisationen.
        2. Klicken Sie rechts neben der Organisation auf Einstellungen.
      • Für eine App im Besitz eines Unternehmens:
        1. Klicken Sie auf Enterprise-Einstellungen.

    3. Klicke in der linken Randleiste auf Developer settings.

    4. Klicke auf der linken Randleiste auf GitHub Apps .

    5. Klicke neben dem Namen deiner App auf Bearbeiten.

  6. Suche auf der Einstellungenseite deiner App neben „App-ID“ die App-ID für deine App.

  7. Ersetze in deiner Datei die vorhandene Zeichenfolge mit der App-ID deiner App.

  8. Klicke auf der Einstellungenseite deiner App unter „Private Schlüssel“ auf Privaten Schlüssel generieren. Es wird ein privater Schlüssel im PEM-Format auf deinen Computer heruntergeladen. Weitere Informationen finden Sie unter AUTOTITLE.

  9. Wenn du einen Codespace verwendest, verschiebe die heruntergeladene PEM-Datei in deinen Codespace, damit dein Codespace auf die Datei zugreifen kann.

  10. Ersetze in deiner -Datei durch den vollständigen Pfad zu deinem privaten Schlüssel, einschließlich der -Erweiterung.

  11. Ersetze in deiner Datei die Platzhalter durch das Webhook-Geheimnis für deine App. Wenn du dein Webhookgeheimnis vergessen hast, klicke unter „Webhookgeheimnis (optional)“ auf Geheimnis ändern. Gib ein neues Geheimnis ein, und klicke dann auf Änderungen speichern.

Hinzufügen von Code zum Reagieren auf Webhookereignisse

Erstelle auf der obersten Ebene des Verzeichnisses, in dem der Klon gespeichert ist, eine JavaScript-Datei, die den Code für deine App enthalten soll. In diesem Tutorial wird die Datei benannt.

Füge den folgenden Code hinzu. Der Code enthält Anmerkungen, die die einzelnen Teile erläutern.

JavaScript
import dotenv from "dotenv";
import {App, Octokit} from "octokit";
import {createNodeMiddleware} from "@octokit/webhooks";
import fs from "fs";
import http from "http";

These are the dependencies for this file.

You installed the dotenv and octokit modules earlier. The @octokit/webhooks is a dependency of the octokit module, so you don't need to install it separately. The fs and http dependencies are built-in Node.js modules.

dotenv.config();

This reads your .env file and adds the variables from that file to the process.env object in Node.js.

const appId = process.env.APP_ID;
const webhookSecret = process.env.WEBHOOK_SECRET;
const privateKeyPath = process.env.PRIVATE_KEY_PATH;
const enterpriseHostname = process.env.ENTERPRISE_HOSTNAME;

This assigns the values of your environment variables to local variables.

const privateKey = fs.readFileSync(privateKeyPath, "utf8");

This reads the contents of your private key file.

const app = new App({
  appId: appId,
  privateKey: privateKey,
  webhooks: {
    secret: webhookSecret
  },
  Octokit: Octokit.defaults({
    baseUrl: `https://${enterpriseHostname}/api/v3`,
  }),
});

This creates a new instance of the Octokit App class.

const messageForNewPRs = "Thanks for opening a new PR! Please follow our contributing guidelines to make your PR easier to review.";

This defines the message that your app will post to pull requests.

async function handlePullRequestOpened({octokit, payload}) {
  console.log(`Received a pull request event for #${payload.pull_request.number}`);
  try {
    await octokit.request("POST /repos/{owner}/{repo}/issues/{issue_number}/comments", {
      owner: payload.repository.owner.login,
      repo: payload.repository.name,
      issue_number: payload.pull_request.number,
      body: messageForNewPRs,
      headers: {
        "x-github-api-version": "2022-11-28",
      },
    });
  } catch (error) {
    if (error.response) {
      console.error(`Error! Status: ${error.response.status}. Message: ${error.response.data.message}`)
    }
    console.error(error)
  }
};

This adds an event handler that your code will call later. When this event handler is called, it will log the event to the console. Then, it will use GitHub's REST API to add a comment to the pull request that triggered the event.

app.webhooks.on("pull_request.opened", handlePullRequestOpened);

This sets up a webhook event listener. When your app receives a webhook event from GitHub with a X-GitHub-Event header value of pull_request and an action payload value of opened, it calls the handlePullRequestOpened event handler that is defined above.

app.webhooks.onError((error) => {
  if (error.name === "AggregateError") {
    console.error(`Error processing request: ${error.event}`);
  } else {
    console.error(error);
  }
});

This logs any errors that occur.

const port = 3000;
const host = 'localhost';
const path = "/api/webhook";
const localWebhookUrl = `http://${host}:${port}${path}`;

This determines where your server will listen.

For local development, your server will listen to port 3000 on localhost. When you deploy your app, you will change these values. For more information, see Deploy your app.

const middleware = createNodeMiddleware(app.webhooks, {path});

This sets up a middleware function to handle incoming webhook events.

Octokit's createNodeMiddleware function takes care of generating this middleware function for you. The resulting middleware function will:

  • Check the signature of the incoming webhook event to make sure that it matches your webhook secret. This verifies that the incoming webhook event is a valid GitHub event.
  • Parse the webhook event payload and identify the type of event.
  • Trigger the corresponding webhook event handler.
http.createServer(middleware).listen(port, () => {
  console.log(`Server is listening for events at: ${localWebhookUrl}`);
  console.log('Press Ctrl + C to quit.')
});

This creates a Node.js server that listens for incoming HTTP requests (including webhook payloads from GitHub) on the specified port. When the server receives a request, it executes the middleware function that you defined earlier. Once the server is running, it logs messages to the console to indicate that it is listening.

// These are the dependencies for this file.
//
// You installed the `dotenv` and `octokit` modules earlier. The `@octokit/webhooks` is a dependency of the `octokit` module, so you don't need to install it separately. The `fs` and `http` dependencies are built-in Node.js modules.
import dotenv from "dotenv";
import {App, Octokit} from "octokit";
import {createNodeMiddleware} from "@octokit/webhooks";
import fs from "fs";
import http from "http";

// This reads your `.env` file and adds the variables from that file to the `process.env` object in Node.js.
dotenv.config();

// This assigns the values of your environment variables to local variables.
const appId = process.env.APP_ID;
const webhookSecret = process.env.WEBHOOK_SECRET;
const privateKeyPath = process.env.PRIVATE_KEY_PATH;
const enterpriseHostname = process.env.ENTERPRISE_HOSTNAME;

// This reads the contents of your private key file.
const privateKey = fs.readFileSync(privateKeyPath, "utf8");

// This creates a new instance of the Octokit App class.
const app = new App({
  appId: appId,
  privateKey: privateKey,
  webhooks: {
    secret: webhookSecret
  },
  Octokit: Octokit.defaults({
    baseUrl: `https://${enterpriseHostname}/api/v3`,
  }),
});

// This defines the message that your app will post to pull requests.
const messageForNewPRs = "Thanks for opening a new PR! Please follow our contributing guidelines to make your PR easier to review.";

// This adds an event handler that your code will call later. When this event handler is called, it will log the event to the console. Then, it will use GitHub's REST API to add a comment to the pull request that triggered the event.
async function handlePullRequestOpened({octokit, payload}) {
  console.log(`Received a pull request event for #${payload.pull_request.number}`);

  try {
    await octokit.request("POST /repos/{owner}/{repo}/issues/{issue_number}/comments", {
      owner: payload.repository.owner.login,
      repo: payload.repository.name,
      issue_number: payload.pull_request.number,
      body: messageForNewPRs,
      headers: {
        "x-github-api-version": "2022-11-28",
      },
    });
  } catch (error) {
    if (error.response) {
      console.error(`Error! Status: ${error.response.status}. Message: ${error.response.data.message}`)
    }
    console.error(error)
  }
};

// This sets up a webhook event listener. When your app receives a webhook event from GitHub with a `X-GitHub-Event` header value of `pull_request` and an `action` payload value of `opened`, it calls the `handlePullRequestOpened` event handler that is defined above.
app.webhooks.on("pull_request.opened", handlePullRequestOpened);

// This logs any errors that occur.
app.webhooks.onError((error) => {
  if (error.name === "AggregateError") {
    console.error(`Error processing request: ${error.event}`);
  } else {
    console.error(error);
  }
});

// This determines where your server will listen.
//
// For local development, your server will listen to port 3000 on `localhost`. When you deploy your app, you will change these values. For more information, see [Deploy your app](#deploy-your-app).
const port = 3000;
const host = 'localhost';
const path = "/api/webhook";
const localWebhookUrl = `http://${host}:${port}${path}`;

// This sets up a middleware function to handle incoming webhook events.
//
// Octokit's `createNodeMiddleware` function takes care of generating this middleware function for you. The resulting middleware function will:
//
// - Check the signature of the incoming webhook event to make sure that it matches your webhook secret. This verifies that the incoming webhook event is a valid GitHub event.
// - Parse the webhook event payload and identify the type of event.
// - Trigger the corresponding webhook event handler.
const middleware = createNodeMiddleware(app.webhooks, {path});

// This creates a Node.js server that listens for incoming HTTP requests (including webhook payloads from GitHub) on the specified port. When the server receives a request, it executes the `middleware` function that you defined earlier. Once the server is running, it logs messages to the console to indicate that it is listening.
http.createServer(middleware).listen(port, () => {
  console.log(`Server is listening for events at: ${localWebhookUrl}`);
  console.log('Press Ctrl + C to quit.')
});

Hinzufügen eines Skripts zum Ausführen des Codes für deine App

  1. Füge dem -Objekt in deiner Datei ein Skript mit dem Namen hinzu, das ausführt. Beispiel:

    JSON
    "scripts": {
  "server": "node app.js"
}

    Wenn du die Datei, die den Code deiner App enthält, mit einem anderen Namen als versehen hast, ersetze durch den relativen Pfad zu der Datei, die den Code deiner App enthält.

  2. Füge in deiner Datei einen Schlüssel auf oberster Ebene mit dem entsprechenden Wert hinzu. Beispiel:

       {
    // rest of the JSON object,
    "version": "1.0.0",
    "description": "",
    "type": "module",
    // rest of the JSON object,
  }

Deine -Datei sollte in etwa wie folgt aussehen. Der Wert und die Versionsnummern unter und können bei dir abweichen.

  {
  "name": "github-app-webhook-tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "server": "node app.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "dotenv": "^16.0.3",
    "octokit": "^2.0.14"
  },
  "devDependencies": {
    "smee-client": "^1.2.3"
  }
}

Testen

Führe die folgenden Schritte aus, um die App zu testen, die du oben erstellt hast.

Installieren der App

Damit deine App einen Kommentar zu Pull Requests in einem Repository hinterlassen kann, muss sie in dem Konto installiert werden, das das Repository besitzt, und ihr muss Zugriff auf dieses Repository gewährt werden. Da deine App privat ist, kann sie nur auf dem Konto installiert werden, das Besitzer der App ist.

  1. Erstelle in dem Konto, das Besitzer der von dir erstellten App ist, ein neues Repository zum Installieren der App. Weitere Informationen finden Sie unter AUTOTITLE.

  2. Navigiere zur Seite „Einstellungen“ für deine App:

    1. Klicke auf GitHub in der oberen rechten Ecke einer beliebigen Seite auf dein Profilfoto.

    2. Navigieren Sie zu den Einstellungen für Ihr Konto.

      • Klicken Sie bei einer App, die zu einem persönlichen Konto gehört, auf Einstellungen.
      • Für eine App im Besitz einer Organisation:
        1. Klicke Sie auf Ihre Organisationen.
        2. Klicken Sie rechts neben der Organisation auf Einstellungen.
      • Für eine App im Besitz eines Unternehmens:
        1. Klicken Sie auf Enterprise-Einstellungen.

    3. Klicke in der linken Randleiste auf Developer settings.

    4. Klicke auf der linken Randleiste auf GitHub Apps .

    5. Klicke neben dem Namen deiner App auf Bearbeiten.

  3. Klicke auf Öffentliche Seite.

  4. Klicke auf Installieren.

  5. Nur ausgewählte Repositorys.

  6. Wähle das Dropdownmenü Repositorys auswählen aus, und klicke auf das Repository, das du am Anfang dieses Abschnitts ausgewählt hast.

  7. Klicke auf Installieren.

Starte deinen Server

Zum Testen verwendest du deinen Computer oder Codespace als Server. Deine App reagiert nur auf Webhooks, wenn dein Server läuft.

  1. Navigiere in einem Terminal zu dem Verzeichnis, in dem der Code deiner App gespeichert ist.

  2. Führe den Befehl „run“ aus, um weitergeleitete Webhooks von „Smee.io“ zu empfangen. Ersetze durch deine Webhook-Proxy-URL von früher. Wenn du deine URL vergessen hast, findest du sie im Feld "Webhook-URL" auf der Einstellungenseite deiner App.

    Du solltest eine Ausgabe sehen, die etwa so aussieht, wobei deine Webhook-Proxy-URL ist.

    Forwarding WEBHOOK_PROXY_URL to http://localhost:3000/api/webhook
Connected WEBHOOK_PROXY_URL

  3. Navigiere in einem zweiten Terminalfenster zu dem Verzeichnis, in dem der Code deiner App gespeichert ist.

  4. Führe aus . Auf deinem Terminal sollte Folgendes angezeigt werden: .

Testen deiner App

Da dein Server jetzt ausgeführt wird und weitergeleitete Webhooksereignisse empfängt, teste deine App, indem du einen Pull Request für das Repository öffnest, das du bei der Installation der App ausgewählt hast.

  1. Öffne einen Pull Request für das Repository, das du bei der Installation deiner App ausgewählt hast. Weitere Informationen finden Sie unter AUTOTITLE.

    Verwende unbedingt das Repository, das du bei der Installation deiner App ausgewählt hast, und nicht das Repository, in dem der Code deiner App gespeichert ist. Weitere Informationen findest du unter Installieren deiner App.

  2. Navigiere zu deiner Webhook-Proxy-URL auf „smee.io“. Es sollte ein -Ereignis angezeigt werden. Dies zeigt, dass GitHub beim Erstellen eines Pull Requests erfolgreich ein Pull Request-Ereignis gesendet hat.

  3. In dem Terminal, in dem Sie den Befehl ausgeführt haben, sollte etwas wie „Pull-Request-Ereignis für #1 empfangen“ angezeigt werden, wobei die ganze Zahl nach dem # die Nummer des Pull Requests ist, den Sie geöffnet haben.

  4. Auf der Zeitachse deines Pull Requests sollte ein Kommentar deiner App angezeigt werden.

  5. Gib in beiden Terminalfenstern "Ctrl+C" ein, um deinen Server zu beenden und den Empfang von weitergeleiteten Webhooks zu beenden.

Nächste Schritte

Da du nun über eine App verfügst, die auf Webhookereignisse reagiert, solltest du den Code deiner App erweitern, deine App bereitstellen und sie öffentlich machen.

Ändern des App-Codes

In diesem Tutorial wurde gezeigt, wie du einen Kommentar zu einem Pull Request postest, wenn ein Pull Request geöffnet wurde. Du kannst den Code aktualisieren, um auf verschiedene Arten von Webhookereignissen zu reagieren, oder etwas anderes als Reaktion auf das Webhookereignis zu tun.

Denke daran, die Berechtigungen deiner App zu aktualisieren, wenn deine App zusätzliche Berechtigungen für die API-Anforderungen benötigt, die du erstellen möchtest, oder die Webhookereignisse, die du empfangen möchtest. Weitere Informationen finden Sie unter AUTOTITLE.

In diesem Tutorial wurde der gesamte Code in einer einzelnen Datei gespeichert. Möglicherweise möchtest du jedoch Funktionen und Komponenten auf separate Dateien aufteilen.

Bereitstellen Ihrer App

In diesem Tutorial wurde gezeigt, wie du deine App lokal entwickelst. Wenn du bereit bist, deine App bereitzustellen, musst du Änderungen vornehmen, um deine App zu bedienen und die Anmeldeinformationen deiner App zu schützen. Welche Schritte du ausführst, hängt vom verwendeten Server ab, aber die folgenden Abschnitte enthalten allgemeine Anleitungen.

Hosten deiner App auf einem Server

In diesem Tutorial wurde dein Computer oder Codespace als Server verwendet. Sobald die App für die Verwendung in der Produktion bereit ist, solltest du deine App auf einem dedizierten Server bereitstellen. Sie können z. B. Azure App Service verwenden.

Aktualisieren der Webhook-URL

Sobald du über einen Server verfügst, der für den Empfang von Webhookdatenverkehr von GitHub eingerichtet ist, aktualisiere die Webhook-URL in deinen App-Einstellungen. Du solltest „Smee.io“ nicht verwenden, um deine Webhooks in der Produktion weiterzuleiten.

Aktualisieren der und -Konstanten

Wenn du deine App bereitstellst, solltest du den Host und Port ändern, wo dein Server lauscht.

Beispielsweise kannst du eine Umgebungsvariable auf deinem Server festlegen, um den Port anzugeben, an dem dein Server lauschen soll. Du kannst eine Umgebungsvariable auf deinem Server auf festlegen. Anschließend kannst du die Stelle aktualisieren, wo dein Code die Konstanten und definiert, sodass dein Server auf alle verfügbaren Netzwerkschnittstellen () statt auf die lokale Netzwerkschnittstelle () deines Bereitstellungsports lauscht:

JavaScript
const port = process.env.PORT || 3000;
const host = process.env.NODE_ENV === 'production' ? '0.0.0.0' : 'localhost';

Schütze die Anmeldeinformationen deiner App

Du solltest niemals den privaten Schlüssel deiner App oder das Webhookgeheimnis veröffentlichen. In diesem Tutorial wurden die Anmeldeinformationen deiner App in einer von Git ignorierten -Datei gespeichert. Wenn du deine App bereitstellst, solltest du eine sichere Methode zum Speichern der Anmeldeinformationen auswählen und deinen Code aktualisieren, um den Wert entsprechend abzurufen. Beispielsweise können Sie die Anmeldeinformationen mit einem Geheimverwaltungsdienst wie Azure Key Vault speichern. Wenn deine App ausgeführt wird, kann sie die Anmeldeinformationen abrufen und in Umgebungsvariablen auf dem Server speichern, auf dem deine App bereitgestellt wird.

Weitere Informationen finden Sie unter AUTOTITLE.

Teilen Sie Ihre App

Wenn du deine App für andere Benutzer und Organisationen freigeben möchtest, mache deine App öffentlich. Weitere Informationen finden Sie unter AUTOTITLE.

Bewährte Methode befolgen

Du solltest Best Practices für deine GitHub App befolgen. Weitere Informationen finden Sie unter AUTOTITLE.