# Erstellen einer Schaltfläche "Anmelden mit GitHub" mit einer GitHub-App
Befolgen Sie dieses Tutorial, um Ruby-Code zu schreiben und über den Webanwendungs-Flow ein Benutzerzugriffs-Token für Ihre GitHub App zu generieren.
## Einführung
In diesem Lernprogramm wird veranschaulicht, wie Sie eine Schaltfläche "Anmelden mit GitHub" für eine Website erstellen. Die Website wird GitHub App verwenden, um über den Webanwendungsfluss ein Benutzerzugriffstoken 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 einem*r Benutzer*in zuordnen möchtest. Weitere Informationen finden Sie unter [Authentifizieren mit einer GitHub App im Namen eines Benutzers](/de/enterprise-server@3.18/apps/creating-github-apps/authenticating-with-a-github-app/authenticating-with-a-github-app-on-behalf-of-a-user).
Es gibt zwei Möglichkeiten zum Generieren eines Benutzerzugriffstokens für einen GitHub App: 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](/de/enterprise-server@3.18/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app) und [Erstellen einer CLI mit einer GitHub-App](/de/enterprise-server@3.18/apps/creating-github-apps/writing-code-for-a-github-app/building-a-cli-with-a-github-app).
## Voraussetzungen
Dieses Tutorial setzt voraus, dass Sie bereits ein GitHub App registriert haben. Weitere Informationen zum Registrieren eines GitHub AppEintrags finden Sie unter [Registrieren einer GitHub-App](/de/enterprise-server@3.18/apps/creating-github-apps/registering-a-github-app/registering-a-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](/de/enterprise-server@3.18/apps/maintaining-github-apps/modifying-a-github-app-registration) und [Informationen zur Rückruf-URL für die Benutzerautorisierung](/de/enterprise-server@3.18/apps/creating-github-apps/registering-a-github-app/about-the-user-authorization-callback-url).
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](https://www.ruby-lang.org) und [ERB](https://github.com/ruby/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](https://github.com/sinatra/sinatra#readme).
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](https://github.com/bkeepers/dotenv#readme).
Für dieses Tutorial musst du die Gems Sinatra und dotenv in deinem Ruby-Projekt installieren. Dazu kannst du z. B. [Bundler](https://bundler.io/) verwenden:
1. Wenn Bundler noch nicht installiert ist, führst du den folgenden Befehl am Terminal aus:
```shell
gem install bundler
```
2. Wenn du noch keine Gem-Datei für deine App hast, führst du den folgenden Befehl am Terminal aus:
```shell
bundle init
```
3. Wenn du noch keine Datei „Gemfile.lock“ für deine App hast, führst du den folgenden Befehl am Terminal aus:
```shell
bundle install
```
4. Installiere die Gems, indem du die folgenden Befehle am Terminal ausführst:
```shell
bundle add sinatra
```
```shell
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](#securely-store-your-client-secret).
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**.
* Für eine App im Besitz eines Unternehmens:
1. Klicken Sie auf **Enterprise-Einstellungen**.
3. Navigieren Sie zu den GitHub App-Einstellungen.
* Für eine App, die einem persönlichen Konto oder einer Organisation gehört:
1. Klicke in der linken Randleiste auf ** Developer settings** und dann auf **GitHub Apps**.
* Für eine App im Besitz eines Unternehmens:
1. Klicken Sie in der linken Randleiste auf **Einstellungen**, und dann auf **GitHub Apps**.
4. Klicken Sie neben dem/der GitHub App, mit dem/der Sie arbeiten möchten, auf **Bearbeiten**.
5. 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.
6. 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.
7. Erstelle eine Datei namens `.env` auf derselben Ebene wie die `Gemfile`.
8. Wenn dein Projekt noch keine `.gitignore`-Datei enthält, erstelle eine `.gitignore`-Datei auf derselben Ebene wie die `Gemfile`.
9. Füge der `.env`-Datei `.gitignore` hinzu. Dadurch verhinderst du, dass du deinen geheimen Clientschlüssel versehentlich committest. Weitere Informationen zu `.gitignore`-Dateien findest du unter [Ignorieren von Dateien](/de/enterprise-server@3.18/get-started/git-basics/ignoring-files).
10. 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.
```text
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 Benutzer*innen auffordern, deine App zu autorisieren. Nachdem Benutzer*innen 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](#full-code-example).
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 copy
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 copy
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 copy
get "/" do
link = 'Login with GitHub'
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/github/callback` lautet, ersetzt du `CALLBACK_URL` durch `/github/callback`.
```ruby copy
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 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 = 'Login with GitHub'
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 "Anmelden mit GitHub" angezeigt werden.
3. Klicken Sie auf den Link "Anmelden mit GitHub".
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 ist `CLIENT_ID` die Client-ID deiner App. Dies ist eine GitHub Seite, auf der Benutzer 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](/de/enterprise-server@3.18/apps/using-github-apps/reviewing-and-revoking-authorization-of-github-apps).
4. Die Callback-URL-Seite, die Sie erreichen, indem Sie auf den Link "Anmelden mit GitHub" klicken und dann – falls Sie dazu aufgefordert werden – die App autorisieren, sollte einen Text ähnlich dem folgenden anzeigen: "Erfolgreich autorisiert! Der Code agc622abb6135be5d1f2 wurde erhalten.
5. Beende den Server am Terminal, an dem Sinatra ausgeführt wird, durch Drücken von STRG+C.
6. 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 funktion `parse_response` analysiert 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 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 = 'Login with GitHub'
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. Ü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 "Anmelden mit GitHub" angezeigt werden.
3. Klicken Sie auf den Link "Anmelden mit GitHub".
4. Wenn du dazu aufgefordert wirst, autorisierst du deine App.
5. Die Callback-URL-Seite, die Sie erreichen, indem Sie auf den Link "Anmelden mit GitHub" klicken und dann – falls Sie dazu aufgefordert werden – die App autorisieren, sollte einen Text ähnlich dem folgenden anzeigen: "Erfolgreich autorisiert! Habe den Code 4acd44861aeda86dacce erhalten und 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.
8. 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 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
```
Aktualisieren Sie den Callback-Handler, damit er die Funktion `user_info` aufruft und den Namen des Benutzers sowie dessen GitHub Anmeldung anzeigt. Vergiss nicht, `CALLBACK_URL` durch die Rückruf-URL deiner App (ohne die Domäne) zu ersetzen.
```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. Ü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](#testing) 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/github/callback` lautet, ersetzt du `CALLBACK_URL` durch `/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 = 'Login with GitHub'
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 "Anmelden mit GitHub" angezeigt werden.
3. Klicken Sie auf den Link "Anmelden mit GitHub".
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 ist `CLIENT_ID` die Client-ID deiner App. Dies ist eine GitHub Seite, auf der Benutzer 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](/de/enterprise-server@3.18/apps/using-github-apps/reviewing-and-revoking-authorization-of-github-apps).
4. Die Callback-URL-Seite, die Sie erreichen, indem Sie auf den Link "Anmelden mit GitHub" klicken und dann – falls Sie dazu aufgefordert werden – die App autorisieren, sollte einen Text ähnlich dem folgenden anzeigen: "Erfolgreich autorisiert! 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. 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 `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](/de/enterprise-server@3.18/apps/maintaining-github-apps/modifying-a-github-app-registration) und [Informationen zur Rückruf-URL für die Benutzerautorisierung](/de/enterprise-server@3.18/apps/creating-github-apps/registering-a-github-app/about-the-user-authorization-callback-url).
### 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 [Ändern einer GitHub App-Registrierung](/de/enterprise-server@3.18/apps/maintaining-github-apps/modifying-a-github-app-registration).
* Verwende beim Verknüpfen mit `http(s)://HOSTNAME/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](/de/enterprise-server@3.18/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).
* 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 finden Sie unter [Generieren eines Benutzerzugriffstokens für eine GitHub App](/de/enterprise-server@3.18/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).
Im Gegensatz zu OAuth apps verwenden GitHub Apps keine Bereiche, daher geben Sie Bereiche zur Laufzeit nicht über den Parameter `scope` an. Stattdessen verwenden sie fein abgestimmte Berechtigungen, die während der App-Erstellung festgelegt wurden. Ein Benutzerzugriffstoken hat nur Zugriff auf eine Ressource, wenn der Benutzer und die App über diesen Zugriff verfügen.
### 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](/de/enterprise-server@3.18/apps/creating-github-apps/registering-a-github-app/choosing-permissions-for-a-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 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 [Aktualisieren von Benutzerzugriffstoken](/de/enterprise-server@3.18/apps/creating-github-apps/authenticating-with-a-github-app/refreshing-user-access-tokens).
Wenn Sie künftig weiter mit den APIs von GitHub interagieren möchten, sollten Sie das Token zur späteren 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 [Bewährte Methoden zum Erstellen einer GitHub-App](/de/enterprise-server@3.18/apps/creating-github-apps/about-creating-github-apps/best-practices-for-creating-a-github-app).
### Bewährte Methode befolgen
Sie sollten darauf abzielen, bei Ihrem GitHub App die Best Practices zu befolgen. Weitere Informationen finden Sie unter [Bewährte Methoden zum Erstellen einer GitHub-App](/de/enterprise-server@3.18/apps/creating-github-apps/about-creating-github-apps/best-practices-for-creating-a-github-app).