Skip to main content

Esta versão do GitHub Enterprise Server será descontinuada em 2024-08-29. Nenhum lançamento de patch será feito, mesmo para questões críticas de segurança. Para obter melhor desempenho, segurança aprimorada e novos recursos, atualize para a última versão do GitHub Enterprise Server. Para obter ajuda com a atualização, entre em contato com o suporte do GitHub Enterprise.

Criar um Aplicativo GitHub que responde a eventos de webhook

Saiba como criar um GitHub App que faz uma solicitação de API em resposta a um evento de webhook.

Introdução

Este tutorial demonstra como escrever o código para criar um GitHub App que faz uma solicitação de API em resposta a um evento de webhook. Especificamente, quando uma solicitação de pull é aberta em um repositório ao qual o aplicativo recebeu acesso, o aplicativo receberá um evento de webhook de solicitação de pull. Em seguida, o aplicativo usará a API do GitHub para adicionar um comentário à solicitação de pull.

Neste tutorial, você usará seu computador ou codespace como um servidor enquanto desenvolve o aplicativo. Depois que o aplicativo estiver pronto para uso em produção, você deverá implantar seu aplicativo em um servidor dedicado.

Este tutorial usa JavaScript, mas você pode usar qualquer linguagem de programação que possa ser executada no servidor.

Sobre webhooks

Ao registrar um GitHub App, você pode especificar uma URL de webhook e assinar os eventos de webhook. Quando a atividade em GitHub disparar um evento no qual seu aplicativo está inscrito, GitHub enviará um evento de webhook para a URL de webhook do aplicativo.

Por exemplo, você pode assinar seu GitHub App no evento de webhook de solicitação de pull. Quando uma solicitação de pull é aberta em um repositório ao qual o aplicativo recebeu acesso, GitHub enviará um evento de webhook de solicitação de pull para a URL de webhook do aplicativo. Se várias ações puderem disparar o evento, a carga do evento incluirá um campo action para indicar qual tipo de ação disparou o evento. Neste exemplo, o valor de action seria opened, pois o evento foi disparado porque foi aberta uma solicitação de pull.

Se o aplicativo estiver em execução em um servidor que está escutando esses eventos de webhook, o aplicativo poderá executar uma ação ao receber um evento de webhook. Por exemplo, o aplicativo pode usar a API do GitHub para postar um comentário na solicitação de pull ao receber um evento de webhook de solicitação de pull.

Para obter mais informações, confira "Usar webhooks com aplicativos GitHub". Para obter informações sobre os possíveis eventos e ações de webhook, confira "Eventos e cargas de webhook".

Pré-requisitos

Este tutorial exige que seu computador ou codespace execute Node.js versão 20 ou superior e npm versão 6.12.0 ou superior. Para obter mais informações, confira Node.js.

Este tutorial pressupõe que você tenha uma compreensão básica da sintaxe do JavaScript e do ES6.

Instalação

As seções a seguir o conduzirão na configuração dos seguintes componentes:

  • um repositório para armazenar o código do seu aplicativo
  • uma maneira de receber webhooks localmente
  • um registro GitHub App que está inscrito em eventos de webhook de "solicitações de pull", tem permissão para adicionar comentários a solicitações de pull e usa uma URL de webhook que você pode receber localmente

Criar o repositório para armazenar o código do seu aplicativo

  1. Crie o repositório para armazenar o código do seu aplicativo. Para obter mais informações, confira "Criar um repositório".
  2. Clone o repositório da etapa anterior. Para obter mais informações, confira "Clonar um repositório". Você pode usar um clone local ou GitHub Codespaces.
  3. No terminal, navegue até o diretório em que o clone está armazenado.
  4. Se o diretório ainda não incluir o arquivo .gitignore, adicione o arquivo .gitignore. Você adicionará conteúdo a esse arquivo mais tarde. Para obter mais informações sobre os arquivos .gitignore, confira "Ignorar arquivos".

Você adicionará mais código a esse repositório nas etapas posteriores.

Obter a URL de proxy de webhook

Para desenvolver seu aplicativo localmente, você pode usar a URL de proxy de webhook para encaminhar webhooks de GitHub para seu computador ou codespace. Este tutorial usa o Smee.io para fornecer a URL de proxy de webhook e encaminhar os webhooks.

  1. No navegador, navegue até https://smee.io/.
  2. Clique em Iniciar um novo canal.
  3. Copie a URL completa em "URL de Proxy de Webhook". Você usará esta URL em uma etapa posterior.

Registrar um GitHub App

Para este tutorial, você deve ter um registro do GitHub App que:

  • Tem webhooks ativos
  • Usa uma URL de webhook que você pode receber localmente
  • Tem a permissão do repositório de "Solicitação de pull"
  • Assina o evento de webhook de "Solicitação de pull"

As etapas a seguir orientarão você no registro do GitHub App com essas configurações. Para saber mais sobre as configurações do GitHub App, confira "Registrar um Aplicativo GitHub".

  1. No canto superior direito de qualquer página do GitHub, clique na foto do seu perfil.
  2. Acesse as configurações da sua conta.
    • Para um aplicativo de propriedade de uma conta pessoal, clique em Configurações.
    • Para um aplicativo de propriedade de uma organização:
      1. Clique em Suas organizações.
      2. À direita da organização, clique em Configurações.
  3. Na barra lateral esquerda, clique em Configurações do desenvolvedor.
  4. Na barra lateral esquerda, clique em GitHub Apps .
  5. Clique em Novo Aplicativo do GitHub.
  6. Em "Nome do GitHub App", insira um nome para seu aplicativo. Por exemplo, USERNAME-webhook-test-app em que USERNAME é o nome de usuário do GitHub.
  7. Em "URL da home page", insira a URL do seu aplicativo. Por exemplo, você pode usar a URL do repositório criado para armazenar o código do aplicativo.
  8. Ignore as seções "Identificar e autorizar usuários" e "Pós-instalação" deste tutorial. Para saber mais sobre essas configurações, confira "Registrar um Aplicativo GitHub".
  9. Verifique se Ativo está marcado em "Webhooks".
  10. Em "URL de Webhook", insira a URL de proxy de webhook da etapa anterior. Para obter mais informações, confira "Obter uma URL de proxy de webhook".
  11. Em "Segredo do webhook", insira uma cadeia de caracteres aleatória. Você usará esta cadeia de caracteres mais tarde.
  12. Em "Permissões de repositório", ao lado de "Solicitações de pull", selecione Leitura e gravação.
  13. Em "Assinar os eventos", selecione Solicitação de pull.
  14. Em "Em que local este GitHub App pode ser instalado?", selecione Somente nesta conta. Você poderá alterar isso mais tarde se quiser publicar o aplicativo.
  15. Clique em Criar Aplicativo do GitHub.

Escrever o código do aplicativo

As seções a seguir o orientarão sobre como escrever o código para fazer com que o aplicativo responda a eventos de webhook.

Instalar dependências

Este tutorial usa o módulo octokit do GitHub para lidar com eventos de webhook e fazer solicitações de API. Para obter mais informações sobre o Octokit.js, confira "Scripts com a API REST e o JavaScript" e o arquivo LEIAME do Octokit.js.

Este tutorial usa o módulo dotenv para ler as informações sobre seu aplicativo no arquivo .env. Para obter mais informações, confira dotenv.

Este tutorial usa o Smee.io para encaminhar webhooks do GitHub para o servidor local. Para obter mais informações, confira smee-client.

  1. No terminal, navegue até o diretório em que o clone está armazenado.
  2. Execute npm init --yes para criar o arquivo package.json usando os padrões npm.
  3. Execute npm install octokit.
  4. Execute npm install dotenv.
  5. Execute npm install smee-client --save-dev. Como você usará apenas o Smee.io para encaminhar os webhooks enquanto estiver desenvolvendo o aplicativo, essa é uma dependência de desenvolvimento.
  6. Adicione node_modules ao arquivo .gitignore.

Armazenar as informações e credenciais de identificação do aplicativo

Este tutorial mostrará como armazenar as credenciais do aplicativo e identificar as informações como variáveis de ambiente no arquivo .env. Quando você implantar seu aplicativo, o ideal será alterar a forma como armazena as credenciais. Para obter mais informações, confira "Implantar seu aplicativo".

Verifique se está em um computador seguro antes de executar essas etapas, pois você armazenará suas credenciais localmente.

  1. No seu terminal, navegue até o diretório em que o clone está armazenado.

  2. Crie um arquivo chamado .env no nível superior desse diretório.

  3. Adicione .env ao arquivo .gitignore. Isso impedirá você de fazer um commit acidental das credenciais do aplicativo.

  4. Adicione o conteúdo a seguir ao arquivo .env. Substitua YOUR_HOSTNAME pelo nome de sua instância do GitHub Enterprise Server. Você atualizará os outros valores em uma etapa posterior.

    Text
    APP_ID="YOUR_APP_ID"
    WEBHOOK_SECRET="YOUR_WEBHOOK_SECRET"
    PRIVATE_KEY_PATH="YOUR_PRIVATE_KEY_PATH"
    ENTERPRISE_HOSTNAME="YOUR_HOSTNAME"
    
  5. Navegue até a página configurações do seu aplicativo:

    1. No canto superior direito de qualquer página do GitHub, clique na foto do seu perfil.

    2. Acesse as configurações da sua conta.

      • Para um aplicativo de propriedade de uma conta pessoal, clique em Configurações.
      • Para um aplicativo de propriedade de uma organização:
        1. Clique em Suas organizações.
        2. À direita da organização, clique em Configurações.
    3. Na barra lateral esquerda, clique em Configurações do desenvolvedor.

    4. Na barra lateral esquerda, clique em GitHub Apps .

    5. Ao lado do nome do aplicativo, clique em Editar.

  6. Na página de configurações do aplicativo, ao lado de "ID do aplicativo", localize a ID do aplicativo para o seu aplicativo.

  7. No arquivo .env, substitua YOUR_APP_ID pela ID do seu aplicativo.

  8. Na página de configurações do aplicativo, em "Chaves privadas", clique em Gerar uma chave privada. Você verá uma chave privada no formato PEM baixado no seu computador. Para obter mais informações, confira "Como gerenciar chaves privadas para Aplicativos GitHub".

  9. Se você estiver usando um codespace, mova o arquivo PEM baixado para o codespace para que ele possa acessar o arquivo.

  10. No arquivo .env, substitua YOUR_PRIVATE_KEY_PATH pelo caminho completo para a chave privada, incluindo a extensão .pem.

  11. No arquivo .env, substitua YOUR_WEBHOOK_SECRET pelo segredo do webhook do seu aplicativo. Se você esqueceu o segredo do webhook, em "Segredo do webhook (opcional)", clique em Alterar segredo. Insira um novo segredo e clique em Salvar alterações.

Adicionar código para responder a eventos de webhook

No nível superior do diretório onde seu clone está armazenado, crie um arquivo JavaScript para manter o código de seu aplicativo. Este tutorial dará ao arquivo o nome app.js.

Adicione o código a seguir a app.js. O código inclui anotações que explicam cada parte.

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

Adicionar um script para executar o código em seu aplicativo

  1. Ao objeto scripts no seu arquivo package.json, adicione um script chamado server que executa node app.js. Por exemplo:

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

    Se você chamou o arquivo que contém o código do seu aplicativo de algo diferente de app.js, substitua app.js pelo caminho relativo ao arquivo que contém o código do seu aplicativo.

  2. No arquivo package.json, adicione uma chave de nível superior type com o valor module. Por exemplo:

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

Seu arquivo package.json deve ter esta aparência. O valor name e os números de versão em dependencies e devDependencies podem aparecer diferentes para você.

  {
  "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"
  }
}

Testando

Siga estas etapas para testar o aplicativo que você criou acima.

Instale seu aplicativo

Para que seu aplicativo deixe um comentário sobre solicitações de pull em um repositório, ele deve ser instalado na conta que possui o repositório e ter acesso ao mesmo. Como seu aplicativo é privado, ele só pode ser instalado na conta que possui o aplicativo.

  1. Na conta que possui o aplicativo que você criou, crie um repositório para instalar o aplicativo. Para obter mais informações, confira "Criar um repositório".

  2. Navegue até a página configurações do seu aplicativo:

    1. No canto superior direito de qualquer página do GitHub, clique na foto do seu perfil.

    2. Acesse as configurações da sua conta.

      • Para um aplicativo de propriedade de uma conta pessoal, clique em Configurações.
      • Para um aplicativo de propriedade de uma organização:
        1. Clique em Suas organizações.
        2. À direita da organização, clique em Configurações.
    3. Na barra lateral esquerda, clique em Configurações do desenvolvedor.

    4. Na barra lateral esquerda, clique em GitHub Apps .

    5. Ao lado do nome do aplicativo, clique em Editar.

  3. Clique em Página pública.

  4. Clique em Instalar.

  5. Selecione Selecionar apenas repositórios.

  6. Selecione o menu suspenso Selecionar repositórios e clique no repositório escolhido no início desta seção.

  7. Clique em Instalar.

Iniciar o servidor

Para teste, você usará seu computador ou o codespace como servidor. Seu aplicativo só responderá a webhooks quando o servidor estiver em execução.

  1. No terminal, navegue até o diretório em que o código do aplicativo está armazenado.

  2. Para receber webhooks encaminhados do Smee.io, execute npx smee -u WEBHOOK_PROXY_URL -t http://localhost:3000/api/webhook. Substitua WEBHOOK_PROXY_URL pela URL de proxy de webhook anterior. Se você esqueceu a URL, poderá encontrá-la no campo "URL do webhook" na página de configurações do aplicativo.

    Você deverá ver uma saída semelhante a esta, em que WEBHOOK_PROXY_URL é a URL de proxy de webhook:

    Forwarding WEBHOOK_PROXY_URL to http://localhost:3000/api/webhook
    Connected WEBHOOK_PROXY_URL
    
  3. Em uma segunda janela de terminal, navegue até o diretório em que o código do aplicativo está armazenado.

  4. Execute npm run server. Seu terminal deve dizer: Server is listening for events at: http://localhost:3000/api/webhook.

Testar seu aplicativo

Agora que o servidor está executando e recebendo eventos de webhooks encaminhados, teste o aplicativo abrindo uma solicitação de pull no repositório que você selecionou ao instalar o aplicativo.

  1. Abra uma solicitação de pull no repositório escolhido quando você instalou o aplicativo. Para obter mais informações, confira "Como criar uma solicitação de pull".

    Use o repositório selecionado ao instalar o aplicativo, não o repositório em que o código do aplicativo está armazenado. Para obter mais informações, confira "Instalar o aplicativo".

  2. Navegue até a URL de proxy de webhook no smee.io. Você deve ver um evento pull_request. Isso indica que GitHub enviou com êxito um evento de solicitação de pull quando você criou a solicitação de pull.

  3. No terminal em que npm run server foi executado, você deverá ver algo como "Recebeu um evento de solicitação de pull para #1" em que o inteiro após o # é o número da solicitação de pull que você abriu.

  4. Na linha do tempo da sua solicitação de pull, você deverá ver um comentário do seu aplicativo.

  5. Em ambas as janelas do terminal, insira Ctrl+C para interromper o servidor e parar de escutar por webhooks encaminhados.

Próximas etapas

Agora que você tem um aplicativo que responde a eventos de webhook, convém expandir o código do aplicativo, implantá-lo e torná-lo público.

Modificar o código do aplicativo

Este tutorial demonstrou como postar um comentário em uma solicitação de pull quando a solicitação de pull foi aberta. Você pode atualizar o código para responder a diferentes tipos de eventos de webhook ou para fazer algo diferente em resposta ao evento de webhook.

Lembre-se de atualizar as permissões do aplicativo se ele precisar de permissões adicionais para as solicitações de API que você deseja fazer ou os eventos de webhook que você deseja receber. Para obter mais informações, confira "Escolhendo permissões para um Aplicativo GitHub".

Este tutorial armazenou todo o código em um só arquivo, mas o ideal é mover funções e componentes para arquivos separados.

Implante seu aplicativo

Este tutorial demonstrou como desenvolver o aplicativo localmente. Quando estiver pronto para implantar o aplicativo, você precisará fazer alterações para atendê-lo e manter a credencial do aplicativo segura. As etapas que você executar dependem do servidor que você usa, mas as seções a seguir oferecem diretrizes gerais.

Hospedar o aplicativo em um servidor

Este tutorial usou seu computador ou o codespace como servidor. Depois que o aplicativo estiver pronto para uso em produção, você deverá implantar seu aplicativo em um servidor dedicado. Por exemplo, você pode usar o Serviço de Aplicativo do Azure.

Atualizar a URL do webhook

Depois de ter um servidor configurado para receber o tráfego de webhook de GitHub, atualize a URL do webhook nas configurações do aplicativo. Você não deve usar o Smee.io para encaminhar os webhooks em produção.

Atualizar as constantes port e host

Ao implantar o aplicativo, você desejará alterar o host e a porta onde o servidor está escutando.

Por exemplo, você pode definir a variável de ambiente PORT no servidor para indicar a porta em que o servidor deve escutar. Você pode definir a variável de ambiente NODE_ENV no servidor como production. Em seguida, você pode atualizar o local em que o código define as constantes port e host para que o servidor ouça todos os adaptadores de rede disponíveis (0.0.0.0) em vez do adaptador de rede local (localhost) na porta de implantação:

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

Proteger as credenciais do aplicativo

Você nunca deve divulgar a chave privada ou o segredo do webhook do aplicativo. Este tutorial armazenou as credenciais do aplicativo em um arquivo .env gitignored. Ao implantar seu aplicativo, você deve escolher uma forma segura de armazenar as credenciais e atualizar o código para obter o valor de acordo. Por exemplo, você pode armazenar as credenciais com um serviço de gerenciamento de segredos, como o Azure Key Vault. Quando o aplicativo é executado, ele pode recuperar as credenciais e armazená-las em variáveis de ambiente no servidor em que seu aplicativo está implantado.

Para obter mais informações, confira "Práticas recomendadas para criar um aplicativo do GitHub".

Compartilhar o aplicativo

Se você quiser compartilhar seu aplicativo com outros usuários e organizações, torne o aplicativo público. Para obter mais informações, confira "Tornar um aplicativo do GitHub público ou privado".

Seguir as práticas recomendadas

Você deve ter como objetivo seguir as melhores práticas com seu GitHub App. Para obter mais informações, confira "Práticas recomendadas para criar um aplicativo do GitHub".