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 findest du 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 unter 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 Apps 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:
-
Wenn Bundler noch nicht installiert ist, führst du den folgenden Befehl am Terminal aus:
gem install bundler
-
Wenn du noch keine Gem-Datei für deine App hast, führst du den folgenden Befehl am Terminal aus:
bundle init
-
Wenn du noch keine Datei „Gemfile.lock“ für deine App hast, führst du den folgenden Befehl am Terminal aus:
bundle install
-
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 von geheimen Clientschlüsseln.
-
Klicke auf GitHub in der oberen rechten Ecke einer beliebigen Seite auf dein Profilfoto.
-
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:
- Klicke Sie auf Ihre Organisationen.
- Klicken Sie rechts neben der Organisation auf Einstellungen.
-
Klicke auf der linken Seitenleiste auf Entwicklereinstellungen.
-
Klicke auf der linken Randleiste auf GitHub Apps .
-
Wähle neben der GitHub App, die du verwenden möchtest, Bearbeiten aus.
-
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. -
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. -
Erstelle eine Datei namens
.env
auf derselben Ebene wie dieGemfile
. -
Wenn dein Projekt noch keine
.gitignore
-Datei enthält, erstelle eine.gitignore
-Datei auf derselben Ebene wie dieGemfile
. -
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. -
Füge der
.env
-Datei den folgenden Inhalt hinzu. ErsetzeYOUR_CLIENT_ID
durch die Client-ID deiner App. ErsetzeYOUR_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.
-
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 mitapp.rb
benannt. -
Füge oberhalb von
app.rb
die folgenden Abhängigkeiten hinzu:Ruby require "sinatra" require "dotenv/load" require "net/http" require "json"
require "sinatra" require "dotenv/load" require "net/http" require "json"
Die Abhängigkeiten
sinatra
unddotenv/load
verwenden die zuvor installierten Gems.net/http
undjson
sind in der Ruby-Standardbibliothek enthalten. -
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")
CLIENT_ID = ENV.fetch("CLIENT_ID") CLIENT_SECRET = ENV.fetch("CLIENT_SECRET")
-
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="http(s)://HOSTNAME/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>' erb link end
get "/" do link = '<a href="http(s)://HOSTNAME/login/oauth/authorize?client_id=<%= CLIENT_ID %>">Login with GitHub</a>' erb link end
-
Füge in der Datei
app.rb
den folgenden Code hinzu, um Anforderungen an die Rückruf-URL deiner App zu verarbeiten und dencode
-Parameter aus der Anforderung abzurufen. ErsetzeCALLBACK_URL
durch die Rückruf-URL deiner App (ohne die Domäne). Wenn deine Rückruf-URL beispielsweisehttp://localhost:4567/github/callback
lautet, ersetzt duCALLBACK_URL
durch/github/callback
.Ruby get "CALLBACK_URL" do code = params["code"] render = "Successfully authorized! Got code #{code}." erb render end
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. -
Überprüfe optional den Fortschritt:
app.rb
sieht nun wie folgt aus, wobeiCALLBACK_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="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
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
-
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. -
Navigiere im Browser zu
http://localhost:4567
. Es sollte ein Link mit dem Text „Mit GitHub anmelden“ angezeigt werden. -
Klicken Sie auf den Link „Mit GitHub anmelden“.
Wenn du die App nicht autorisiert hast, solltest du durch Auswählen des Links zu
http(s)://HOSTNAME/login/oauth/authorize?client_id=CLIENT_ID
umgeleitet werden. Dabei istCLIENT_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 findest du unter Überprüfen und Widerrufen der Autorisierung von GitHub-Apps.
-
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.
-
Beende den Server am Terminal, an dem Sinatra ausgeführt wird, durch Drücken von STRG+C.
-
-
Ersetze den Inhalt der Datei
app.rb
durch den folgenden Code, wobeiCALLBACK_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 dencode
-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("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
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
- Die
-
Überprüfe optional den Fortschritt:
- 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. - Navigiere im Browser zu
http://localhost:4567
. Es sollte ein Link mit dem Text „Mit GitHub anmelden“ angezeigt werden. - Klicken Sie auf den Link „Mit GitHub anmelden“.
- Wenn du dazu aufgefordert wirst, autorisierst du deine App.
- 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“.
- Beende den Server am Terminal, an dem Sinatra ausgeführt wird, durch Drücken von STRG+C.
- Führe im Terminal in dem Verzeichnis, in dem
-
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("http(s)://HOSTNAME/api/v3/user") result = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http| body = {"access_token" => token}.to_json auth = "Bearer #{token}" headers = {"Accept" => "application/json", "Content-Type" => "application/json", "Authorization" => auth} http.send_request("GET", uri.path, body, headers) end 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| body = {"access_token" => token}.to_json auth = "Bearer #{token}" headers = {"Accept" => "application/json", "Content-Type" => "application/json", "Authorization" => auth} http.send_request("GET", uri.path, body, 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
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
-
Ü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 befolgst.
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
.
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| body = {"access_token" => token}.to_json auth = "Bearer #{token}" headers = {"Accept" => "application/json", "Content-Type" => "application/json", "Authorization" => auth} http.send_request("GET", uri.path, body, 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|
body = {"access_token" => token}.to_json
auth = "Bearer #{token}"
headers = {"Accept" => "application/json", "Content-Type" => "application/json", "Authorization" => auth}
http.send_request("GET", uri.path, body, 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 app.rb
gespeichert ist und du die Standard-URL http://localhost:4567
für lokale Sinatra-Anwendungen verwendest.
-
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. -
Navigiere im Browser zu
http://localhost:4567
. Es sollte ein Link mit dem Text „Mit GitHub anmelden“ angezeigt werden. -
Klicken Sie auf den Link „Mit GitHub anmelden“.
Wenn du die App nicht autorisiert hast, solltest du durch Auswählen des Links zu
http(s)://HOSTNAME/login/oauth/authorize?client_id=CLIENT_ID
umgeleitet werden. Dabei istCLIENT_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 findest du unter Überprüfen und Widerrufen der Autorisierung von GitHub-Apps.
-
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)“.
-
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 Apps 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
http(s)://HOSTNAME/login/oauth/authorize
denredirect_uri
-Abfrageparameter, um Benutzer*innen zur gewünschten Rückruf-URL umzuleiten. Weitere Informationen findest du 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 http(s)://HOSTNAME/login/oauth/authorize
herstellst, kannst du auch zusätzliche Abfrageparameter übergeben. Weitere Informationen findest du 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 findest du 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 findest du 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 findest du unter Best Practices beim Erstellen einer GitHub-App.
Bewährte Methode befolgen
Du solltest Best Practices für deine GitHub App befolgen. Weitere Informationen findest du unter Best Practices beim Erstellen einer GitHub-App.