Erstellen der Schaltfläche „Mit GitHub anmelden“ mit einer GitHub-App

Befolge dieses Tutorial, um Ruby-Code zu schreiben, der ein Benutzerzugriffstoken über den Webanwendungsfluss für deine GitHub App generiert.

In diesem Artikel

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 Authentifizieren mit einer GitHub-App im Namen von Benutzer*innen.

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 Generieren eines Benutzerzugriffstokens für eine GitHub-App und Erstellen einer CLI mit einer GitHub-App.

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 Registrieren einer GitHub-App.

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 Standard-URL http://localhost:4567 verwendet. Wenn du beispielsweise die Standard-URL für eine lokale Sinatra-Anwendung verwendest, kann deine Rückruf-URL http://localhost:4567/github/callback lauten. 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 Ändern einer GitHub-App-Registrierung und Informationen zur Rückruf-URL für die Benutzerautorisierung.

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.

Installieren von Abhängigkeiten

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 .env-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 ENV.fetch 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 auf der linken Seitenleiste auf Entwicklereinstellungen.

  4. Klicke auf der linken Randleiste auf GitHub Apps .

  5. Wähle neben der GitHub App, die du verwenden möchtest, Bearbeiten aus.

  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 .env-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 .env-Datei hinzu.

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

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

  10. Füge der .gitignore-Datei .env hinzu. Dadurch verhinderst du, dass du deinen geheimen Clientschlüssel versehentlich committest. Weitere Informationen zu .gitignore-Dateien findest du unter Ignorieren von Dateien.

  11. Füge der .env-Datei den folgenden Inhalt hinzu. Ersetze YOUR_CLIENT_ID durch die Client-ID deiner App. Ersetze YOUR_CLIENT_SECRET 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 code-Abfrageparameter. Wenn deine App eine Anforderung zur Bereitstellung dieser Rückruf-URL erhält, kannst du den code-Parameter gegen ein Benutzerzugriffstoken austauschen.

Diese Schritte führen dich durch das Schreiben von Code zum Generieren eines Benutzerzugriffstokens. Den endgültigen Code findest du im vollständigen Codebeispiel.

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

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

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

    Die Abhängigkeiten sinatra und dotenv/load verwenden die zuvor installierten Gems. net/http und json sind in der Ruby-Standardbibliothek enthalten.

  3. Füge in der Datei app.rb den folgenden Code hinzu, um die Client-ID und den geheimen Clientschlüssel deiner App aus der .env-Datei abzurufen.

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

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

    Ruby
    get "/" do
  link = '<a href="https://github.com/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>'
  erb link
end

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

    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 code-Parameter. In den folgenden Schritten erweiterst du diesen Codeblock.

  6. Überprüfe optional den Fortschritt:

    app.rb sieht nun wie folgt aus, wobei CALLBACK_URL 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="https://github.com/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 app.rb gespeichert ist, ruby app.rb aus. Es sollte ein lokaler Sinatra-Server gestartet werden.

    2. Navigiere im Browser zu http://localhost:4567. 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 https://github.com/login/oauth/authorize?client_id=CLIENT_ID umgeleitet werden. Dabei ist CLIENT_ID 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 Überprüfen und Widerrufen der Autorisierung von GitHub-Apps.

    4. Auf der Seite unter der Rückruf-URL, die Sie durch Klicken auf den Link „Mit GitHub anmelden“ erreichen und nachdem Sie die App autorisiert haben, wenn Sie dazu aufgefordert werden, sollte ein Text ähnlich wie „Erfolgreich autorisiert!“ angezeigt werden. Code agc622abb6135be5d1f2 erhalten“ angezeigt werden.

    5. Beende den Server am Terminal, an dem Sinatra ausgeführt wird, durch Drücken von STRG+C.

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

    Dieser Code fügt Logik hinzu, um den code-Parameter durch ein Benutzerzugriffstoken auszutauschen:

    • Die parse_response-Funktion parst die Antwort von der GitHub-API.
    • Die exchange_code-Funktion ersetzt den code-Parameter durch ein Benutzerzugriffstoken.
    • Der Handler für die Rückruf-URL-Anforderung ruft jetzt exchange_code 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("https://github.com/login/oauth/access_token"),
    URI.encode_www_form(params),
    {"Accept" => "application/json"}
  )

  parse_response(result)
end

get "/" do
  link = '<a href="https://github.com/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 app.rb gespeichert ist, ruby app.rb aus. Es sollte ein lokaler Sinatra-Server gestartet werden.
    2. Navigiere im Browser zu http://localhost:4567. 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 unter der Rückruf-URL, die Sie durch Klicken auf den Link „Mit GitHub anmelden“ erreichen und nachdem Sie die App autorisiert haben, wenn Sie dazu aufgefordert werden, sollte ein Text ähnlich wie „Erfolgreich autorisiert!“ angezeigt werden. Code 4acd44861aeda86dacce gegen ein Benutzerzugriffstoken ausgetauscht, das auf 2zU5kQziE endet“.
    6. Beende den Server am Terminal, an dem Sinatra ausgeführt wird, durch Drücken von STRG+C.

  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 app.rb hinzu, um über den REST-API-Endpunkt /user Informationen zu den Benutzer*innen abzurufen:

    Ruby
    def user_info(token)
  uri = URI("https://api.github.com/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 user_info-Funktion aufzurufen und den Benutzernamen und die GitHub-Anmeldung anzuzeigen. Vergiss nicht, CALLBACK_URL 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 CALLBACK_URL durch die Rückruf-URL deiner App (ohne die Domäne). Wenn deine Rückruf-URL beispielsweise http://localhost:4567/github/callback lautet, ersetzt du CALLBACK_URL durch /github/callback.

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("https://github.com/login/oauth/access_token"),
    URI.encode_www_form(params),
    {"Accept" => "application/json"}
  )

  parse_response(result)
end

def user_info(token)
  uri = URI("https://api.github.com/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="https://github.com/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 app.rb gespeichert ist und du die Standard-URL http://localhost:4567 für lokale Sinatra-Anwendungen verwendest.

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

  2. Navigiere im Browser zu http://localhost:4567. 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 https://github.com/login/oauth/authorize?client_id=CLIENT_ID umgeleitet werden. Dabei ist CLIENT_ID 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 Überprüfen und Widerrufen der Autorisierung von GitHub-Apps.

  4. Auf der Seite unter der Rückruf-URL, die Sie durch Klicken auf den Link „Mit GitHub anmelden“ erreichen und nachdem Sie die App autorisiert haben, wenn Sie dazu aufgefordert werden, sollte ein Text ähnlich wie „Erfolgreich autorisiert!“ angezeigt werden. Willkommen, Mona Lisa (Octocat)“.

  5. Beende den Server am Terminal, an dem Sinatra ausgeführt wird, durch Drücken von STRG+C.

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 (.env) gespeichert und mit ENV.fetch 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. Du kannst auch einen Geheimnisverwaltungsdienst wie Azure Key Vault verwenden.

Aktualisieren der Rückruf-URL für die Bereitstellung

In diesem Tutorial wurde eine Rückruf-URL verwendet, die mit http://localhost:4567 beginnt. http://localhost:4567 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 Ändern einer GitHub-App-Registrierung und Informationen zur Rückruf-URL für die Benutzerautorisierung.

Behandeln mehrerer Rückruf-URLs

In diesem Tutorial wurde eine einzelne Rückruf-URL verwendet, deine App kann jedoch bis zu 10 Rückruf-URLs aufweisen. So verwendest du mehrere Rückruf-URLs

  • Füge deiner App die zusätzlichen Rückruf-URLs hinzu. Weitere Informationen zum Hinzufügen von Rückruf-URLs findest du unter Ändern einer GitHub-App-Registrierung.
  • Verwende beim Verknüpfen mit https://github.com/login/oauth/authorize den redirect_uri-Abfrageparameter, um Benutzer*innen zur gewünschten Rückruf-URL umzuleiten. Weitere Informationen finden Sie unter Generieren eines Benutzerzugriffstokens für eine GitHub-App.
  • Verarbeite in deinem App-Code jede Rückruf-URL ähnlich dem Codeblock ab get "CALLBACK_URL" do.

Weitere Parameter angeben

Wenn du eine Verknüpfung mit https://github.com/login/oauth/authorize herstellst, kannst du auch zusätzliche Abfrageparameter übergeben. Weitere Informationen finden Sie unter Generieren eines Benutzerzugriffstokens für eine GitHub-App.

Im Gegensatz zu einem herkömmlichen OAuth-Token verwendet das Benutzerzugriffstoken keine Bereiche, sodass du keine Bereiche über den scope-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 Auswählen von Berechtigungen für eine GitHub-App.

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 den Flow 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 Aktualisieren von Benutzerzugriffstoken.

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 Best Practices beim Erstellen einer GitHub-App.

Bewährte Methode befolgen

Du solltest Best Practices für deine GitHub App befolgen. Weitere Informationen finden Sie unter Best Practices beim Erstellen einer GitHub-App.