Erstellen einer Schaltfläche "Anmelden mit GitHub" mit einer GitHub-App

Einführung

In diesem Tutorial wird veranschaulicht, wie man die Schaltfläche „Mit GitHub anmelden“ für eine Website erstellt. Die Website verwendet eine GitHub App, um ein Benutzerzugriffstoken über den Webanwendungsfluss zu generieren. Anschließend verwendet die Website das Benutzerzugriffstoken, um API-Anforderungen im Namen der authentifizierten Benutzer*innen zu senden.

In diesem Tutorial wird Ruby verwendet. Du kannst aber den Webanwendungsfluss mit jeder Programmiersprache verwenden, die für die Webentwicklung geeignet ist.

Informationen zum Webanwendungsfluss und zu Benutzerzugriffstoken

Deine App muss ein Benutzerzugriffstoken verwenden, wenn du die Aktionen der App einemr Benutzerin zuordnen möchtest. Weitere Informationen finden Sie unter AUTOTITLE.

Es gibt zwei Möglichkeiten, ein Benutzerzugriffstoken für eine GitHub App zu generieren: Webanwendungsfluss und Gerätefluss. Wenn deine App Zugriff auf eine Weboberfläche hat, solltest du den Webanwendungsfluss verwenden. Wenn deine App keinen Zugriff auf eine Weboberfläche hat, solltest du stattdessen den Gerätefluss verwenden. Weitere Informationen findest du unter AUTOTITLE und AUTOTITLE.

Voraussetzungen

In diesem Tutorial wird davon ausgegangen, dass du bereits eine GitHub App registriert hast. Weitere Informationen zum Registrieren einer GitHub App findest du unter AUTOTITLE.

Bevor du dieses Tutorial ausführst, musst du eine Rückruf-URL für deine App festlegen. In diesem Tutorial wird ein lokaler Sinatra-Server mit der standardmäßigen URL verwendet. Wenn du beispielsweise die Standard-URL für eine lokale Sinatra-Anwendung verwendest, kann deine Rückruf-URL so aussehen. Wenn du bereit bist, deine App bereitzustellen, kannst du die Rückruf-URL in deine tatsächliche Serveradresse ändern. Weitere Informationen zum Aktualisieren der Rückruf-URL für deine App findest du unter AUTOTITLE und AUTOTITLE.

In diesem Tutorial wird davon ausgegangen, dass du über grundlegende Kenntnisse von Ruby und dem Ruby-Vorlagensystem ERB verfügst. Weitere Informationen findest du unter Ruby und ERB.

Abhängigkeiten installieren

In diesem Tutorial wird das RubyGem Sinatra verwendet, um eine Webanwendung mit Ruby zu erstellen. Weitere Informationen findest du in der Infodatei zu Sinatra.

In diesem Tutorial wird das RubyGem dotenv verwendet, um auf in die einer -Datei gespeicherten Werte zuzugreifen. Weitere Informationen findest du in der Infodatei zu dotenv.

Für dieses Tutorial musst du die Gems Sinatra und dotenv in deinem Ruby-Projekt installieren. Dazu kannst du z. B. Bundler verwenden:

1. Wenn Bundler noch nicht installiert ist, führst du den folgenden Befehl am Terminal aus:

   gem install bundler
   

2. Wenn du noch keine Gem-Datei für deine App hast, führst du den folgenden Befehl am Terminal aus:

   bundle init
   

3. Wenn du noch keine Datei „Gemfile.lock“ für deine App hast, führst du den folgenden Befehl am Terminal aus:

   bundle install
   

4. Installiere die Gems, indem du die folgenden Befehle am Terminal ausführst:

   bundle add sinatra
   

   bundle add dotenv
   

Speichern der Client-ID und des geheimen Clientschlüssels

In diesem Tutorial erfährst du, wie du die Client-ID und den geheimen Clientschlüssel in Umgebungsvariablen speicherst und mit darauf zugreifst. Wenn du deine App bereitstellst, solltest du anpassen, wie die Client-ID und der geheime Clientschlüssel gespeichert werden. Weitere Informationen findest du unter Sicheres Speichern deines geheimen Clientschlüssels.

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.

3. Klicke in der linken Randleiste auf Developer settings.

4. Klicke auf der linken Randleiste auf GitHub Apps .

5. Klicke neben der GitHub App, mit der du arbeiten möchtest, auf Bearbeiten.

6. Suche auf der Einstellungsseite der App nach der Client-ID für deine App. Du fügst sie in einem der folgenden Schritte einer -Datei hinzu. Beachte, dass sich die Client-ID von der App-ID unterscheidet.

7. Wähle auf der Einstellungsseite der App Neuen geheimen Clientschlüssel generieren aus. Du fügst den geheimen Clientschlüssel in einem folgenden Schritt einer -Datei hinzu.

8. Erstelle eine Datei namens auf derselben Ebene wie die .

9. Wenn dein Projekt noch keine -Datei enthält, erstelle eine -Datei auf derselben Ebene wie die .

10. Füge zu deiner hinzu. Dadurch verhinderst du, dass du deinen geheimen Clientschlüssel versehentlich committest. Weitere Informationen zu Dateien finden Sie unter AUTOTITLE.

11. Füge der -Datei den folgenden Inhalt hinzu. Ersetze durch die Client-ID deiner App. Ersetze durch den geheimen Clientschlüssel deiner App.

    CLIENT_ID="YOUR_CLIENT_ID"
    CLIENT_SECRET="YOUR_CLIENT_SECRET"
    

Hinzufügen von Code zum Generieren eines Benutzerzugriffstokens

Um Benutzerzugriffstoken abzurufen, musst du zunächst die Benutzerinnen auffordern, deine App zu autorisieren. Nachdem Benutzerinnen deine App autorisiert haben, werden sie zur Rückruf-URL deiner App umgeleitet. Die Anforderung an die Rückruf-URL enthält einen -Abfrageparameter. Wenn deine App eine Anforderung zur Bereitstellung dieser Rückruf-URL erhält, kannst du den -Parameter gegen ein Benutzerzugriffstoken austauschen.

Diese Schritte führen dich durch das Schreiben von Code zum Generieren eines Benutzerzugriffstokens. Um direkt zum endgültigen Code zu springen, sieh dir das vollständige Codebeispiel an.

1. Erstelle im selben Verzeichnis wie die -Datei eine Ruby-Datei, die den Code enthält, der ein Benutzerzugriffstoken generiert. In diesem Tutorial wird die Datei benannt.

2. Füge oberhalb von die folgenden Abhängigkeiten hinzu:

   Ruby

   require "sinatra"
   require "dotenv/load"
   require "net/http"
   require "json"
   

   Die Abhängigkeiten und verwenden die zuvor installierten Gems. und sind in der Ruby-Standardbibliothek enthalten.

3. Füge den folgenden Code zu , um die Client-ID und das Client-Geheimnis deiner App aus der -Datei abzurufen.

   Ruby

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

4. Füge in der Datei den folgenden Code hinzu, um einen Link anzuzeigen, über den Benutzer*innen aufgefordert werden, deine App zu authentifizieren.

   Ruby

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

5. Füge in der Datei den folgenden Code hinzu, um Anforderungen an die Rückruf-URL deiner App zu verarbeiten und den -Parameter aus der Anforderung abzurufen. Ersetze durch die Rückruf-URL deiner App (ohne die Domäne). Wenn deine Rückruf-URL beispielsweise lautet, ersetzt du durch .

   Ruby

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

   Derzeit rendert der Code nur eine Nachricht zusammen mit dem -Parameter. In den folgenden Schritten erweiterst du diesen Codeblock.

6. Überprüfe optional den Fortschritt:

   sieht nun wie folgt aus, wobei die Rückruf-URL für deine App ohne die Domäne ist:

   Ruby

   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. Führe im Terminal in dem Verzeichnis, in dem gespeichert ist, aus. Es sollte ein lokaler Sinatra-Server gestartet werden.

   2. Navigiere im Browser zu . Es sollte ein Link mit dem Text „Mit GitHub anmelden“ angezeigt werden.

   3. Klicken Sie auf den Link „Mit GitHub anmelden“.

      Wenn du die App nicht autorisiert hast, solltest du durch Auswählen des Links zu umgeleitet werden. Dabei ist die Client-ID deiner App. Dies ist eine GitHub-Seite, auf der Benutzer*innen aufgefordert werden, Ihre App zu autorisieren. Wenn du die Schaltfläche auswählst, um deine App zu autorisieren, wirst du zur Rückruf-URL deiner App umgeleitet.

      Wenn du deine App zuvor bereits autorisiert hattest und die Autorisierung nicht widerrufen wurde, kannst du die Autorisierungsaufforderung überspringen und stattdessen direkt zur Rückruf-URL navigieren. Du kannst eine vorherige Autorisierung widerrufen, wenn du die Autorisierungsaufforderung anzeigen möchtest. Weitere Informationen finden Sie unter AUTOTITLE.

   4. Auf der Seite mit der Rückruf-URL, die du durch Auswählen des Links „Mit GitHub anmelden“ erreichst, und auf der du dann die App autorisierst, wenn du dazu aufgefordert wirst, sollte ein Text wie „Erfolgreich autorisiert!“ angezeigt werden. Der Code agc622abb6135be5d1f2 wurde erhalten.

   5. Im Terminal, in dem Sinatra läuft, kannst du den Server stoppen, indem du Strg+C drückst.

7. Ersetze den Inhalt der Datei durch den folgenden Code, wobei die Rückruf-URL für deine App ohne die Domäne ist.

   Dieser Code fügt Logik zum Austausch des Parameters gegen ein Benutzerzugriffstoken hinzu.

   • Die funktion parse_response analysiert die Antwort von der GitHub-API.
   • Die -Funktion ersetzt den -Parameter durch ein Benutzerzugriffstoken.
   • Der Handler für die Rückruf-URL-Anforderung ruft jetzt auf, um den Codeparameter durch ein Benutzerzugriffstoken zu ersetzen.
   • Auf der Rückrufseite wird daraufhin Text angezeigt, der angibt, dass ein Token generiert wurde. Wenn die Tokengenerierung nicht erfolgreich war, weist die Seite auf diesen Fehler hin.
   Ruby

   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
   

8. Überprüfe optional den Fortschritt:

   1. Führe im Terminal in dem Verzeichnis, in dem gespeichert ist, aus. Es sollte ein lokaler Sinatra-Server gestartet werden.
   2. Navigiere im Browser zu . Es sollte ein Link mit dem Text „Mit GitHub anmelden“ angezeigt werden.
   3. Klicken Sie auf den Link „Mit GitHub anmelden“.
   4. Wenn du dazu aufgefordert wirst, autorisierst du deine App.
   5. Auf der Seite mit der Rückruf-URL, die du durch Auswählen des Links „Mit GitHub anmelden“ erreichst, und auf der du dann die App autorisierst, wenn du dazu aufgefordert wirst, sollte ein Text wie „Erfolgreich autorisiert!“ angezeigt werden. Habe den Code 4acd44861aeda86dacce erhalten und gegen ein Benutzerzugriffstoken ausgetauscht, das auf 2zU5kQziE endet.
   6. Im Terminal, in dem Sinatra läuft, kannst du den Server stoppen, indem du Strg+C drückst.

9. Nachdem du nun über ein Benutzerzugriffstoken verfügst, kannst du das Token verwenden, um API-Anforderungen im Namen der jeweiligen Benutzer*innen zu senden. Beispiel:

   Füge diese Funktion in der Datei hinzu, um Informationen über den Benutzer über den REST-API-Endpunkt abzurufen:

   Ruby

   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
   

   Aktualisiere den Rückrufhandler, um die -Funktion aufzurufen und den Benutzernamen und die GitHub-Anmeldung anzuzeigen. Vergiss nicht, durch die Rückruf-URL deiner App (ohne die Domäne) zu ersetzen.

   Ruby

   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
   

10. Überprüfe deinen Code anhand des vollständigen Codebeispiels im nächsten Abschnitt. Du kannst deinen Code testen, indem du die Schritte im Abschnitt Testen unterhalb des vollständigen Codebeispiels ausführst.

Vollständiges Codebeispiel

Dies ist das vollständige Codebeispiel, das im vorherigen Abschnitt beschrieben wurde.

Ersetze durch die Rückruf-URL deiner App (ohne die Domäne). Wenn deine Rückruf-URL beispielsweise lautet, ersetzt du durch .

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

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

Testen

In diesem Tutorial wird davon ausgegangen, dass dein App-Code in einer Datei namens gespeichert ist und du die Standard-URL für lokale Sinatra-Anwendungen verwendest.

1. Führe im Terminal in dem Verzeichnis, in dem gespeichert ist, aus. Es sollte ein lokaler Sinatra-Server gestartet werden.

2. Navigiere im Browser zu . Es sollte ein Link mit dem Text „Mit GitHub anmelden“ angezeigt werden.

3. Klicken Sie auf den Link „Mit GitHub anmelden“.

   Wenn du die App nicht autorisiert hast, solltest du durch Auswählen des Links zu umgeleitet werden. Dabei ist die Client-ID deiner App. Dies ist eine GitHub-Seite, auf der Benutzer*innen aufgefordert werden, Ihre App zu autorisieren. Wenn du die Schaltfläche auswählst, um deine App zu autorisieren, wirst du zur Rückruf-URL deiner App umgeleitet.

   Wenn du deine App zuvor bereits autorisiert hattest und die Autorisierung nicht widerrufen wurde, kannst du die Autorisierungsaufforderung überspringen und stattdessen direkt zur Rückruf-URL navigieren. Du kannst eine vorherige Autorisierung widerrufen, wenn du die Autorisierungsaufforderung anzeigen möchtest. Weitere Informationen finden Sie unter AUTOTITLE.

4. Auf der Seite mit der Rückruf-URL, die du durch Auswählen des Links „Mit GitHub anmelden“ erreichst, und auf der du dann die App autorisierst, wenn du dazu aufgefordert wirst, sollte ein Text wie „Erfolgreich autorisiert!“ angezeigt werden. Willkommen, Mona Lisa (Octocat)“.

5. Im Terminal, in dem Sinatra läuft, kannst du den Server stoppen, indem du Strg+C drückst.

Nächste Schritte

Sicheres Speichern von geheimen Clientschlüsseln

Du solltest geheime Clientschlüssel deiner Apps niemals veröffentlichen. In diesem Tutorial wurde der geheime Clientschlüssel in einer gitignored-Datei () gespeichert und mit auf den Wert zugegriffen. Wenn du deine App bereitstellst, solltest du eine sichere Methode zum Speichern des geheimen Clientschlüssels auswählen und deinen Code aktualisieren, um den Wert entsprechend abzurufen.

Du kannst das Geheimnis z. B. in einer Umgebungsvariable auf dem Server speichern, auf dem deine Anwendung bereitgestellt wird. Sie können auch einen Geheimverwaltungsdienst wie Azure Key Vault verwenden.

Aktualisieren Sie die Callback-URL für die Bereitstellung

In diesem Tutorial wurde eine Rückruf-URL verwendet, die mit . beginnt. ist jedoch nur lokal auf deinem Computer verfügbar, wenn du den Sinatra-Server startest. Bevor du deine App bereitstellst, sollten du die Rückruf-URL in die ändern, die du in der Produktion verwendest. Weitere Informationen zum Aktualisieren der Rückruf-URL für deine App findest du unter AUTOTITLE und AUTOTITLE.

Verarbeitung mehrerer Callback-URLs

In diesem Tutorial wurde eine einzelne Rückruf-URL verwendet, deine App kann jedoch bis zu 10 Rückruf-URLs aufweisen. Wenn du mehrere Rückruf-URLs verwenden möchtest

• Füge deiner App die zusätzlichen Rückruf-URLs hinzu. Weitere Informationen zum Hinzufügen von Rückruf-URLs findest du unter AUTOTITLE.
• Beim Verlinken mit , verwende den Abfrageparameter, um Benutzer*innen zur gewünschten Rückruf-URL umzuleiten. Weitere Informationen finden Sie unter AUTOTITLE.
• Verarbeite in deinem App-Code jede Rückruf-URL ähnlich dem Codeblock ab .

Weitere Parameter angeben

Wenn du eine Verknüpfung mit herstellst, kannst du auch zusätzliche Abfrageparameter übergeben. Weitere Informationen finden Sie unter AUTOTITLE.

Im Gegensatz zu einem herkömmlichen OAuth-Token verwendet das Benutzerzugriffstoken keine Bereiche, sodass du keine Bereiche über den -Parameter angeben kannst. Stattdessen werden differenzierte Berechtigungen verwendet. Ein Benutzerzugriffstoken verfügt nur über Berechtigungen, die sowohl die Benutzer*innen als auch die App besitzen.

Anpassen des Codes an die Anforderungen deiner App

In diesem Tutorial wurde gezeigt, wie du Informationen zu authentifizierten Benutzer*innen anzeigst. Du kannst diesen Code aber anpassen, um andere Aktionen auszuführen. 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. 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.

Sicheres Speichern von Token

In diesem Tutorial wird ein Benutzerzugriffstoken generiert. Sofern du das Ablaufdatum für Benutzerzugriffstoken nicht deaktiviert hast, läuft das Benutzerzugriffstoken nach acht Stunden ab. Du erhältst auch ein Aktualisierungstoken, mit dem ein Benutzerzugriffstoken erneut generiert werden kann. Weitere Informationen finden Sie unter AUTOTITLE.

Wenn du weitere Aktionen mit den APIs von GitHub planst, solltest du das Token für die zukünftige Verwendung speichern. Wenn du das Benutzerzugriffstoken oder das Aktualisierungstoken speichern möchtest, musst du es sicher speichern. Du solltest das Token niemals veröffentlichen.

Weitere Informationen finden Sie unter AUTOTITLE.

Bewährte Methode befolgen

Sie sollten bewährte Verfahren für Ihre GitHub App befolgen. Weitere Informationen finden Sie unter AUTOTITLE.