# Criando um botão "Logon com GitHub" com um aplicativo GitHub

Siga este tutorial para escrever o código Ruby para gerar um token de acesso do usuário por meio do fluxo de aplicativo Web para seu GitHub App.

## Introdução

Este tutorial demonstra como criar um botão "Logon com GitHub" para um site. O site usará um GitHub App para gerar um token de acesso do usuário por meio do fluxo do aplicativo Web. Em seguida, o site usa o token de acesso do usuário para fazer solicitações de API em nome do usuário autenticado.

Este tutorial usa o Ruby, mas você pode usar o fluxo de aplicativo Web com qualquer linguagem de programação usada para o desenvolvimento na Web.

### Sobre o fluxo de aplicações web e tokens de acesso do usuário

Seu aplicativo deve usar um token de acesso do usuário se você quiser atribuir as ações do aplicativo a um usuário. Para saber mais, confira [Autenticação com um aplicativo GitHub em nome de um usuário](/pt/enterprise-server@3.21/apps/creating-github-apps/authenticating-with-a-github-app/authenticating-with-a-github-app-on-behalf-of-a-user).

Há duas maneiras de gerar um token de acesso de usuário para um GitHub App: fluxo de aplicativo Web e fluxo de dispositivo. Se o aplicativo tiver acesso a uma interface da Web, você deverá usar o fluxo do aplicativo Web. Se o aplicativo não tiver acesso a uma interface da Web, use o fluxo do dispositivo. Para saber mais, confira [Gerando um token de acesso do usuário para um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app) e [Criando uma CLI com um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/writing-code-for-a-github-app/building-a-cli-with-a-github-app).

## Pré-requisitos

Este tutorial pressupõe que você já registrou um GitHub App. Para obter mais informações sobre como registrar um GitHub App, consulte [Registrando um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/registering-a-github-app/registering-a-github-app).

Antes de seguir este tutorial, você precisa definir uma URL de retorno de chamada para o aplicativo. Este tutorial usa um servidor local do Sinatra com a URL padrão `http://localhost:4567`. Por exemplo, para trabalhar com a URL padrão de um aplicativo local do Sinatra, a URL de retorno de chamada pode ser `http://localhost:4567/github/callback`. Quando estiver pronto para implantar seu aplicativo, altere a URL de retorno de chamada para usar o endereço do servidor dinâmico. Para obter mais informações sobre como atualizar a URL de retorno de chamada do seu aplicativo, confira [Modificando um registro de aplicativo GitHub](/pt/enterprise-server@3.21/apps/maintaining-github-apps/modifying-a-github-app-registration) e [Sobre a URL de retorno de chamada de autorização do usuário](/pt/enterprise-server@3.21/apps/creating-github-apps/registering-a-github-app/about-the-user-authorization-callback-url).

Este tutorial pressupõe que você tenha uma compreensão básica do Ruby e do sistema de modelos do Ruby, o ERB. Para obter mais informações, confira [Ruby](https://www.ruby-lang.org) e [ERB](https://github.com/ruby/erb).

## Instalar dependências

Este tutorial usa o Ruby gem Sinatra para criar um aplicativo Web com o Ruby. Para obter mais informações, confira [o LEIAME do Sinatra](https://github.com/sinatra/sinatra#readme).

Este tutorial usa o Ruby Gem dotenv para acessar valores armazenados em um arquivo `.env`. Para obter mais informações, confira [o LEIAME do dotenv](https://github.com/bkeepers/dotenv#readme).

Para seguir este tutorial, você precisa instalar os gems Sinatra e dotenv no projeto Ruby. Por exemplo, faça isso com o [Bundler](https://bundler.io/):

1. Caso ainda não tenha o Bundler instalado, execute o seguinte comando no terminal:

   ```shell
   gem install bundler
   ```

2. Caso ainda não tenha um Gemfile para seu aplicativo, execute o seguinte comando no terminal:

   ```shell
   bundle init
   ```

3. Caso ainda não tenha um Gemfile.lock para seu aplicativo, execute o seguinte comando no terminal:

   ```shell
   bundle install
   ```

4. No terminal, instale os gems executando os seguintes comandos:

   ```shell
   bundle add sinatra
   ```

   ```shell
   bundle add dotenv
   ```

## Armazenar a ID do cliente e o segredo do cliente

Este tutorial mostrará como armazenar a ID do cliente e o segredo do cliente em variáveis de ambiente e acessá-los com `ENV.fetch`. Quando você implantar seu aplicativo, o ideal será alterar a forma como armazena a ID do cliente e o segredo do cliente. Para obter mais informações, confira [Armazenar o segredo do cliente com segurança](#securely-store-your-client-secret).

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**.
   * Para um aplicativo de propriedade de uma empresa:
     1. Clique em **Configurações da empresa**.

3. Navegue até as configurações GitHub App.
   * Para um aplicativo pertencente a uma conta pessoal ou a uma organização:
     1. Na barra lateral esquerda, clique em **<svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-code" aria-label="code" role="img"><path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"></path></svg> Developer settings** e clique em **GitHub Apps**.
   * Para um aplicativo de propriedade de uma empresa:
     1. Na barra lateral esquerda,  clique em **Configurações**, depois clique em **GitHub Apps**.

4. Ao lado de GitHub App com o qual você deseja trabalhar, clique em **Editar**.

5. Na página de configurações do aplicativo, encontre a ID do cliente para seu aplicativo. Você a adicionará a um arquivo `.env` em uma etapa posterior. Observe que a ID do cliente é diferente da ID do aplicativo.

6. Na página de configurações do aplicativo, clique em **Gerar um novo segredo do cliente**. Você adicionará o segredo do cliente a um arquivo `.env` em uma etapa posterior.

7. Crie um arquivo chamado `.env` no mesmo nível do `Gemfile`.

8. Se o projeto ainda não tiver um arquivo `.gitignore`, crie um arquivo `.gitignore` no mesmo nível do `Gemfile`.

9. Adicione `.env` ao arquivo `.gitignore`. Isso impedirá você de fazer um commit acidental do segredo do cliente. Para obter mais informações sobre os arquivos `.gitignore`, confira [Ignorar arquivos](/pt/enterprise-server@3.21/get-started/git-basics/ignoring-files).

10. Adicione o conteúdo a seguir ao arquivo `.env`. Substitua `YOUR_CLIENT_ID` pela ID do cliente do aplicativo. Substitua `YOUR_CLIENT_SECRET` pelo segredo do cliente do seu aplicativo.

    ```text
    CLIENT_ID="YOUR_CLIENT_ID"
    CLIENT_SECRET="YOUR_CLIENT_SECRET"
    ```

## Adicionar o código para gerar um token de acesso do usuário

Para obter um token de acesso do usuário, primeiro, você precisa solicitar que o usuário autorize seu aplicativo. Quando um usuário autoriza seu aplicativo, ele é redirecionado para a URL de retorno de chamada do aplicativo. A solicitação para a URL de callback inclui um parâmetro de consulta `code`. Quando seu aplicativo recebe uma solicitação para processar essa URL de callback, você pode trocar o parâmetro `code` por um token de acesso do usuário.

Estas etapas orientam você na escrita do código usado para gerar um token de acesso do usuário. Para ir para o código final, confira [Exemplo de código completo](#full-code-example).

1. No mesmo diretório do arquivo `.env`, crie um arquivo Ruby para manter o código que vai gerar um token de acesso do usuário. Este tutorial dará ao arquivo o nome `app.rb`.

2. No início do `app.rb`, adicione estas dependências:

   ```ruby copy
   require "sinatra"
   require "dotenv/load"
   require "net/http"
   require "json"
   ```

   As dependências `sinatra` e `dotenv/load` usam os gems que você instalou anteriormente.
   `net/http` e `json` fazem parte da biblioteca padrão do Ruby.

3. Adicione o código a seguir a `app.rb` para obter o ID de cliente do seu aplicativo e o segredo de cliente do arquivo `.env`.

   ```ruby copy
   CLIENT_ID = ENV.fetch("CLIENT_ID")
   CLIENT_SECRET = ENV.fetch("CLIENT_SECRET")
   ```

4. Adicione o código a seguir a `app.rb` para exibir um link que solicitará aos usuários que autentiquem seu aplicativo.

   ```ruby copy
   get "/" do
     link = '<a href="http(s)://HOSTNAME/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>'
     erb link
   end
   ```

5. Adicione o código a seguir a `app.rb` para processar as solicitações à URL de retorno de chamada do aplicativo e obter o parâmetro `code` da solicitação. Substitua `CALLBACK_URL` pela URL de retorno de chamada do seu aplicativo, menos o domínio. Por exemplo, se a URL de retorno de chamada for `http://localhost/github/callback`, substitua `CALLBACK_URL` por `/github/callback`.

   ```ruby copy
   get "CALLBACK_URL" do
     code = params["code"]
     render = "Successfully authorized! Got code #{code}."
     erb render
   end
   ```

   Atualmente, o código só renderiza uma mensagem com o parâmetro `code`. As etapas a seguir expandirão esse bloco de código.

6. Opcionalmente, verifique seu progresso:

`app.rb` agora tem esta aparência, sendo que `CALLBACK_URL` é a URL de retorno de chamada do seu aplicativo, menos o domínio:

```ruby copy
require "sinatra"
require "dotenv/load"
require "net/http"
require "json"

CLIENT_ID = ENV.fetch("CLIENT_ID")
CLIENT_SECRET = ENV.fetch("CLIENT_SECRET")

get "/" do
  link = '<a href="http(s)://HOSTNAME/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>'
  erb link
end

get "CALLBACK_URL" do
  code = params["code"]
  render = "Successfully authorized! Got code #{code}."
  erb render
end
```

1. No terminal, no diretório em que `app.rb` está armazenado, execute `ruby app.rb`. Um servidor local do Sinatra deve ser iniciado.

2. No navegador, navegue até `http://localhost:4567`. Você deve ver um link com o texto "Entrar com GitHub".

3. Clique no link "Fazer login com GitHub".

   Caso não tenha autorizado o aplicativo, se você clicar no link, será levado para `http(s)://HOSTNAME/login/oauth/authorize?client_id=CLIENT_ID`, sendo que `CLIENT_ID` é a ID do cliente do aplicativo. Esta é uma GitHub página que solicita aos usuários que autorizem seu aplicativo. Se você clicar no botão para autorizar seu aplicativo, será direcionado para a URL de callback do aplicativo.

   Se você autorizou seu aplicativo anteriormente e a autorização não foi revogada, o prompt de autorização é ignorado e leva você diretamente para a URL de retorno de chamada. Você poderá revogar sua autorização anterior se quiser ver a solicitação de autorização. Para saber mais, confira [Revisão e revogação da autorização de aplicativos GitHub](/pt/enterprise-server@3.21/apps/using-github-apps/reviewing-and-revoking-authorization-of-github-apps).

4. A página da URL de retorno de chamada, acessada com um clique no link "Fazer logon com o GitHub" e com a autorização do aplicativo, se solicitado, exibirá um texto semelhante a "Autorizado com sucesso! Código recebido: agc622abb6135be5d1f2.

5. No terminal em que o Sinatra está em execução, interrompa o servidor inserindo <kbd>CTRL</kbd>+<kbd>C</kbd>.

6. Substitua o conteúdo de `app.rb` pelo código a seguir, sendo que `CALLBACK_URL` é a URL de retorno de chamada do seu aplicativo, menos o domínio.

   Esse código adiciona a lógica para trocar o parâmetro `code` por um token de acesso do usuário:

   * A função `parse_response` analisa a resposta da API de GitHub.
   * A função `exchange_code` troca o parâmetro `code` por um token de acesso do usuário.
   * O manipulador para a solicitação de URL de retorno de chamada agora chama `exchange_code` para trocar o parâmetro de código por um token de acesso do usuário.
   * A página de callback agora mostra um texto informando que um token foi gerado. Se a geração do token não tiver sido bem-sucedida, a página indicará essa falha.

   ```ruby copy
   require "sinatra"
   require "dotenv/load"
   require "net/http"
   require "json"

   CLIENT_ID = ENV.fetch("CLIENT_ID")
   CLIENT_SECRET = ENV.fetch("CLIENT_SECRET")

   def parse_response(response)
     case response
     when Net::HTTPOK
       JSON.parse(response.body)
     else
       puts response
       puts response.body
       {}
     end
   end

   def exchange_code(code)
     params = {
       "client_id" => CLIENT_ID,
       "client_secret" => CLIENT_SECRET,
       "code" => code
     }
     result = Net::HTTP.post(
       URI("http(s)://HOSTNAME/login/oauth/access_token"),
       URI.encode_www_form(params),
       {"Accept" => "application/json"}
     )

     parse_response(result)
   end

   get "/" do
     link = '<a href="http(s)://HOSTNAME/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>'
     erb link
   end

   get "CALLBACK_URL" do
     code = params["code"]

     token_data = exchange_code(code)

     if token_data.key?("access_token")
       token = token_data["access_token"]

       render = "Successfully authorized! Got code #{code} and exchanged it for a user access token ending in #{token[-9..-1]}."
       erb render
     else
       render = "Authorized, but unable to exchange code #{code} for token."
       erb render
     end
   end
   ```

7. Opcionalmente, verifique seu progresso:
   1. No terminal, no diretório em que `app.rb` está armazenado, execute `ruby app.rb`. Um servidor local do Sinatra deve ser iniciado.
   2. No navegador, navegue até `http://localhost:4567`. Você deve ver um link com o texto "Entrar com GitHub".
   3. Clique no link "Fazer login com GitHub".
   4. Se precisar fazer isso, autorize seu aplicativo.
   5. A página da URL de retorno de chamada, acessada com um clique no link "Fazer logon com o GitHub" e com a autorização do aplicativo, se solicitado, exibirá um texto semelhante a "Autorizado com sucesso! Código 4acd44861aeda86dacce recebido e trocado por um token de acesso do usuário que termina em 2zU5kQziE".
   6. No terminal em que o Sinatra está em execução, interrompa o servidor inserindo <kbd>CTRL</kbd>+<kbd>C</kbd>.

8. Agora que você tem um token de acesso do usuário, use o token para fazer solicitações de API em nome do usuário. Por exemplo:

   Adicione esta função a `app.rb` para obter informações sobre o usuário com o endpoint `/user` da REST API:

   ```ruby copy
   def user_info(token)
     uri = URI("http(s)://HOSTNAME/api/v3/user")

     result = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
       auth = "Bearer #{token}"
       headers = {"Accept" => "application/json", "Content-Type" => "application/json", "Authorization" => auth}

       http.send_request("GET", uri.path, nil, headers)
     end

     parse_response(result)
   end
   ```

   Atualize o manipulador de callback para chamar a função `user_info` e exibir o nome e o GitHub login do usuário. Lembre-se de substituir `CALLBACK_URL` pela URL de retorno de chamada do seu aplicativo, menos o domínio.

   ```ruby copy
   get "CALLBACK_URL" do
     code = params["code"]

     token_data = exchange_code(code)

     if token_data.key?("access_token")
       token = token_data["access_token"]

       user_info = user_info(token)
       handle = user_info["login"]
       name = user_info["name"]

       render = "Successfully authorized! Welcome, #{name} (#{handle})."
       erb render
     else
       render = "Authorized, but unable to exchange code #{code} for token."
       erb render
     end
   end
   ```

9. Verifique o código em relação ao exemplo de código completo na próxima seção. Teste o código seguindo as etapas descritas na seção [Teste](#testing) abaixo do exemplo de código completo.

## Exemplo de código completo

Este é o exemplo de código completo descrito na seção anterior.

Substitua `CALLBACK_URL` pela URL de retorno de chamada do seu aplicativo, menos o domínio. Por exemplo, se a URL de retorno de chamada for `http://localhost/github/callback`, substitua `CALLBACK_URL` por `/github/callback`.

```ruby copy
require "sinatra"
require "dotenv/load"
require "net/http"
require "json"

CLIENT_ID = ENV.fetch("CLIENT_ID")
CLIENT_SECRET = ENV.fetch("CLIENT_SECRET")

def parse_response(response)
  case response
  when Net::HTTPOK
    JSON.parse(response.body)
  else
    puts response
    puts response.body
    {}
  end
end

def exchange_code(code)
  params = {
    "client_id" => CLIENT_ID,
    "client_secret" => CLIENT_SECRET,
    "code" => code
  }
  result = Net::HTTP.post(
    URI("http(s)://HOSTNAME/login/oauth/access_token"),
    URI.encode_www_form(params),
    {"Accept" => "application/json"}
  )

  parse_response(result)
end

def user_info(token)
  uri = URI("http(s)://HOSTNAME/api/v3/user")

  result = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
    auth = "Bearer #{token}"
    headers = {"Accept" => "application/json", "Content-Type" => "application/json", "Authorization" => auth}

    http.send_request("GET", uri.path, nil, headers)
  end

  parse_response(result)
end

get "/" do
  link = '<a href="http(s)://HOSTNAME/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>'
  erb link
end

get "CALLBACK_URL" do
  code = params["code"]

  token_data = exchange_code(code)

  if token_data.key?("access_token")
    token = token_data["access_token"]

    user_info = user_info(token)
    handle = user_info["login"]
    name = user_info["name"]

    render = "Successfully authorized! Welcome, #{name} (#{handle})."
    erb render
  else
    render = "Authorized, but unable to exchange code #{code} for token."
    erb render
  end
end
```

## Testando

Este tutorial pressupõe que o código do aplicativo esteja armazenado em um arquivo chamado `app.rb` e que você esteja usando a URL padrão para um aplicativo local do Sinatra, `http://localhost:4567`.

1. No terminal, no diretório em que `app.rb` está armazenado, execute `ruby app.rb`. Um servidor local do Sinatra deve ser iniciado.

2. No navegador, navegue até `http://localhost:4567`. Você deve ver um link com o texto "Entrar com GitHub".

3. Clique no link "Fazer login com GitHub".

   Caso não tenha autorizado o aplicativo, se você clicar no link, será levado para `http(s)://HOSTNAME/login/oauth/authorize?client_id=CLIENT_ID`, sendo que `CLIENT_ID` é a ID do cliente do aplicativo. Esta é uma GitHub página que solicita aos usuários que autorizem seu aplicativo. Se você clicar no botão para autorizar seu aplicativo, será direcionado para a URL de callback do aplicativo.

   Se você autorizou seu aplicativo anteriormente e a autorização não foi revogada, o prompt de autorização é ignorado e leva você diretamente para a URL de retorno de chamada. Você poderá revogar sua autorização anterior se quiser ver a solicitação de autorização. Para saber mais, confira [Revisão e revogação da autorização de aplicativos GitHub](/pt/enterprise-server@3.21/apps/using-github-apps/reviewing-and-revoking-authorization-of-github-apps).

4. A página da URL de retorno de chamada, acessada com um clique no link "Fazer logon com o GitHub" e com a autorização do aplicativo, se solicitado, exibirá um texto semelhante a "Autorizado com sucesso! Bem-vinda, Mona Lisa (octocat)".

5. No terminal em que o Sinatra está em execução, interrompa o servidor inserindo <kbd>CTRL</kbd>+<kbd>C</kbd>.

## Próximas etapas

### Armazenar o segredo do cliente com segurança

Você nunca deve divulgar o segredo do cliente do aplicativo. Este tutorial armazenou o segredo do cliente em um arquivo `.env` ignorado pelo Git e acessou o valor com `ENV.fetch`. Ao implantar seu aplicativo, você deve escolher uma forma segura de armazenar o segredo do cliente e atualizar o código para obter o valor de acordo.

Por exemplo, você pode armazenar o segredo em uma variável de ambiente no servidor em que o aplicativo foi implantado. Você também pode usar um serviço de gerenciamento de segredos como Azure Key Vault.

### Atualizar a URL de retorno de chamada para implantação

Este tutorial usou uma URL de retorno de chamada que começa com `http://localhost:4567`. No entanto, `http://localhost:4567` só estará disponível localmente para o computador quando você iniciar o servidor do Sinatra. Antes de implantar seu aplicativo, você deve atualizar a URL de retorno de chamada para usar a URL de retorno de chamada que você usa em produção. Para obter mais informações sobre como atualizar a URL de retorno de chamada do seu aplicativo, confira [Modificando um registro de aplicativo GitHub](/pt/enterprise-server@3.21/apps/maintaining-github-apps/modifying-a-github-app-registration) e [Sobre a URL de retorno de chamada de autorização do usuário](/pt/enterprise-server@3.21/apps/creating-github-apps/registering-a-github-app/about-the-user-authorization-callback-url).

### Processar várias URLs de retorno de chamada

Este tutorial usou uma só URL de retorno de chamada, mas seu aplicativo pode ter até dez URLs de retorno de chamada. Caso você deseje usar várias URLs de callback:

* Adicione as URLs de retorno de chamada adicionais à sua aplicação. Para obter mais informações sobre como adicionar URLs de retorno, veja [Modificando um registro de aplicativo GitHub](/pt/enterprise-server@3.21/apps/maintaining-github-apps/modifying-a-github-app-registration).
* Ao vinculá-la ao `http(s)://HOSTNAME/login/oauth/authorize`, use o parâmetro de consulta `redirect_uri` para redirecionar os usuários para a URL de retorno de chamada desejada. Para saber mais, confira [Gerando um token de acesso do usuário para um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app#using-the-web-application-flow-to-generate-a-user-access-token).
* No código do aplicativo, processe cada URL de retorno de chamada, semelhante ao bloco de código que começa com `get "CALLBACK_URL" do`.

### Especificar parâmetros adicionais

Ao vinculá-la ao `http(s)://HOSTNAME/login/oauth/authorize`, você pode transmitir parâmetros de consulta adicionais. Para saber mais, confira [Gerando um token de acesso do usuário para um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app#using-the-web-application-flow-to-generate-a-user-access-token).

Ao contrário de OAuth apps, GitHub Apps não usam escopos, portanto, você não especifica escopos em tempo de execução por meio do parâmetro `scope`. Em vez disso, eles usam permissões refinadas definidas durante a criação do aplicativo. Um token de acesso do usuário só terá acesso a um recurso se o usuário e o aplicativo tiverem esse acesso.

### Ajustar o código de acordo com as necessidades do aplicativo

Este tutorial demonstrou como exibir informações sobre o usuário autenticado, mas você pode ajustar esse código para executar outras ações. Lembre-se de atualizar as permissões do aplicativo se o aplicativo precisar de permissões adicionais para as solicitações de API que você deseja fazer. Para saber mais, confira [Escolhendo permissões para um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/registering-a-github-app/choosing-permissions-for-a-github-app).

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

### Armazenar tokens com segurança

Este tutorial gera um token de acesso do usuário. A menos que você tenha optado por não expirar os tokens de acesso do usuário, o token de acesso do usuário expirará após oito horas. Você também receberá um token de atualização que pode regenerar um token de acesso do usuário. Para saber mais, confira [Atualizar tokens de acesso do usuário](/pt/enterprise-server@3.21/apps/creating-github-apps/authenticating-with-a-github-app/refreshing-user-access-tokens).

Se você planeja interagir ainda mais com GitHubas APIs, deve armazenar o token para uso futuro. Se optar por armazenar o token de acesso do usuário ou atualizar o token, armazene-o com segurança. Você nunca deve divulgar o token.

Para saber mais, confira [Práticas recomendadas para criar um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/about-creating-github-apps/best-practices-for-creating-a-github-app).

### Seguir as práticas recomendadas

Você deve procurar seguir as práticas recomendadas com seu GitHub App. Para saber mais, confira [Práticas recomendadas para criar um aplicativo GitHub](/pt/enterprise-server@3.21/apps/creating-github-apps/about-creating-github-apps/best-practices-for-creating-a-github-app).