In diesem Dokument wird erläutert, wie Webserveranwendungen mithilfe von Google API-Clientbibliotheken oder Google OAuth 2.0-Endpunkten OAuth 2.0-Autorisierung für den Zugriff auf die YouTube Data API implementieren.
Mit OAuth 2.0 können Nutzer bestimmte Daten für eine Anwendung freigeben, während ihre Nutzernamen, Passwörter und andere Informationen privat bleiben. Beispielsweise kann eine Anwendung OAuth 2.0 verwenden, um die Berechtigung zum Hochladen von Videos auf den YouTube-Kanal eines Nutzers zu erhalten.
Dieser OAuth 2.0-Vorgang bezieht sich speziell auf die Nutzerautorisierung. Es wurde für Anwendungen entwickelt, die vertrauliche Informationen speichern und den Status aufrechterhalten können. Eine ordnungsgemäß autorisierte Webserveranwendung kann auf eine API zugreifen, während der Nutzer mit der Anwendung interagiert oder nachdem er die Anwendung verlassen hat.
Webserveranwendungen verwenden häufig auch
Dienstkonten zum Autorisieren von API-Anfragen, insbesondere wenn Cloud APIs aufgerufen werden, um auf projektbasierte Daten statt auf nutzerspezifische Daten zuzugreifen. Webserveranwendungen können Dienstkonten in Verbindung mit der Nutzerautorisierung verwenden.
Die YouTube Data API unterstützt den Dienstkontoablauf nur für YouTube-Rechteinhaber, die mehrere YouTube-Kanäle besitzen und verwalten.
Insbesondere können Rechteinhaber Dienstkonten verwenden, um API-Methoden aufzurufen, die den Anfrageparameter onBehalfOfContentOwner
unterstützen.
Clientbibliotheken
In den sprachspezifischen Beispielen auf dieser Seite werden Google API-Clientbibliotheken verwendet, um die OAuth 2.0-Autorisierung zu implementieren. Zum Ausführen der Codebeispiele müssen Sie zuerst die Clientbibliothek für Ihre Sprache installieren.
Wenn Sie eine Google API-Clientbibliothek verwenden, um den OAuth 2.0-Ablauf Ihrer Anwendung zu verarbeiten, führt die Clientbibliothek viele Aktionen aus, die die Anwendung andernfalls selbst ausführen müsste. Damit wird beispielsweise festgelegt, wann die Anwendung gespeicherte Zugriffstokens verwenden oder aktualisieren kann und wann die Anwendung die Einwilligung noch einmal einholen muss. Die Clientbibliothek generiert außerdem korrekte Weiterleitungs-URLs und unterstützt die Implementierung von Weiterleitungs-Handlern, die Autorisierungscodes gegen Zugriffstokens austauschen.
Google API-Clientbibliotheken für serverseitige Anwendungen sind in den folgenden Sprachen verfügbar:
Voraussetzungen
Die APIs für Ihr Projekt aktivieren
Jede Anwendung, die Google APIs aufruft, muss diese APIs im API Consoleaktivieren.
So aktivieren Sie eine API für Ihr Projekt:
- Open the API Library in Google API Console.
- If prompted, select a project, or create a new one.
- Auf der Seite Bibliothek kannst du die YouTube Data API finden und aktivieren. Suchen Sie alle anderen APIs, die Ihre Anwendung verwendet, und aktivieren Sie diese ebenfalls.
Anmeldedaten für die Autorisierung erstellen
Jede Anwendung, die OAuth 2.0 für den Zugriff auf Google APIs verwendet, benötigt Autorisierungsanmeldedaten, die die Anwendung beim OAuth 2.0-Server von Google identifizieren. In den folgenden Schritten wird erläutert, wie Sie Anmeldedaten für Ihr Projekt erstellen. Ihre Anwendungen können dann mit den Anmeldedaten auf APIs zugreifen, die Sie für das Projekt aktiviert haben.
- Go to the Credentials page.
- Klicken Sie auf Anmeldedaten erstellen > OAuth-Client-ID.
- Wählen Sie den Anwendungstyp Webanwendung aus.
- Füllen Sie das Formular aus und klicken Sie auf Erstellen. Für Anwendungen, die Sprachen und Frameworks wie PHP, Java, Python, Ruby und .NET verwenden, müssen autorisierte Weiterleitungs-URIs angegeben werden. Die Weiterleitungs-URIs sind die Endpunkte, an die der OAuth 2.0-Server Antworten senden kann. Diese Endpunkte müssen den Validierungsregeln von Google entsprechen.
Zu Testzwecken können Sie URIs angeben, die auf den lokalen Computer verweisen, z. B.
http://localhost:8080
. Beachten Sie daher, dass in allen Beispielen in diesem Dokumenthttp://localhost:8080
als Weiterleitungs-URI verwendet wird.Wir empfehlen, die Authentifizierungsendpunkte Ihrer Anwendung so zu gestalten, dass Ihre Anwendung keine Autorisierungscodes für andere Ressourcen auf der Seite offenlegt.
Laden Sie nach dem Erstellen Ihrer Anmeldedaten die Datei client_secret.json aus dem API Consoleherunter. Speichern Sie die Datei sicher an einem Speicherort, auf den nur Ihre Anwendung zugreifen kann.
Zugriffsbereiche identifizieren
Mit Bereichen kann Ihre Anwendung nur Zugriff auf die benötigten Ressourcen anfordern und Nutzer können gleichzeitig den Umfang des Zugriffs steuern, den sie Ihrer Anwendung gewähren. Daher kann eine umgekehrte Beziehung zwischen der Anzahl der angeforderten Bereiche und der Wahrscheinlichkeit, die Nutzereinwilligung einzuholen, bestehen.
Bevor Sie mit der Implementierung der OAuth 2.0-Autorisierung beginnen, sollten Sie die Bereiche identifizieren, auf die Ihre Anwendung eine Zugriffsberechtigung benötigt.
Wir empfehlen außerdem, dass Ihre Anwendung den Zugriff auf Autorisierungsbereiche über einen inkrementellen Autorisierungsprozess anfordert, bei dem Ihre Anwendung den Zugriff auf Nutzerdaten im Kontext anfordert. Mit dieser Best Practice können Nutzer leichter nachvollziehen, warum Ihre Anwendung den angeforderten Zugriff benötigt.
Für Version 3 der YouTube Data API werden die folgenden Umfänge verwendet:
Sucher | |
---|---|
https://www.googleapis.com/auth/youtube | YouTube-Konto verwalten |
https://www.googleapis.com/auth/youtube.channel-memberships.creator | Eine Liste der aktuell aktiven Mitglieder des Kanals, ihre Stufe und ihr Eintrittsdatum abrufen |
https://www.googleapis.com/auth/youtube.force-ssl | Ihre YouTube-Videos, -Bewertungen, -Kommentare und -Untertitel ansehen, bearbeiten oder dauerhaft löschen |
https://www.googleapis.com/auth/youtube.readonly | YouTube-Konto abrufen |
https://www.googleapis.com/auth/youtube.upload | YouTube-Videos verwalten |
https://www.googleapis.com/auth/youtubepartner | Ihre Inhalte und zugehörigen Content bei YouTube abrufen und verwalten |
https://www.googleapis.com/auth/youtubepartner-channel-audit | Private Informationen aus dem YouTube-Kanal abrufen, die während des Prüfprozesses durch einen YouTube-Partner relevant sind |
Das Dokument OAuth 2.0 API-Bereiche enthält eine vollständige Liste der Bereiche, die Sie für den Zugriff auf Google APIs verwenden können.
Sprachspezifische Anforderungen
Zum Ausführen der Codebeispiele in diesem Dokument benötigen Sie ein Google-Konto, Zugriff auf das Internet und einen Webbrowser. Wenn Sie eine der API-Clientbibliotheken verwenden, müssen Sie auch die folgenden sprachspezifischen Anforderungen beachten.
PHP
Zum Ausführen der PHP-Codebeispiele in diesem Dokument ist Folgendes erforderlich:
- PHP 5.6 oder höher mit installierter Befehlszeile und JSON-Erweiterung
- Tool zur Abhängigkeitsverwaltung in Composer
-
Google APIs-Clientbibliothek für PHP:
composer require google/apiclient:^2.10
Python
Zum Ausführen der Python-Codebeispiele in diesem Dokument benötigen Sie Folgendes:
- Python 2.6 oder höher
- Das pip-Paketverwaltungstool.
- Die Google APIs-Clientbibliothek für Python:
pip install --upgrade google-api-python-client
google-auth
,google-auth-oauthlib
undgoogle-auth-httplib2
für die Nutzerautorisierung.pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
- Das Python-Webanwendungs-Framework von Flask.
pip install --upgrade flask
- Die HTTP-Bibliothek
requests
.pip install --upgrade requests
Ruby
Zum Ausführen der Ruby-Codebeispiele in diesem Dokument benötigen Sie Folgendes:
- Ruby 2.6 oder höher
-
Die Google-Authentifizierungsbibliothek für Ruby:
gem install googleauth
-
Das Sinatra Ruby-Framework für Webanwendungen
gem install sinatra
Node.js
Zum Ausführen der Node.js-Codebeispiele in diesem Dokument ist Folgendes erforderlich:
- Die Wartung „Langzeitsupport“, die aktive Version „Langzeitsupport“ oder der aktuelle Release von Node.js.
-
Der Node.js-Client der Google APIs:
npm install googleapis crypto express express-session
HTTP/REST
Du musst keine Bibliotheken installieren, um OAuth 2.0-Endpunkte direkt aufrufen zu können.
OAuth 2.0-Zugriffstokens abrufen
Die folgenden Schritte zeigen, wie deine Anwendung mit dem OAuth 2.0-Server von Google interagiert, um die Einwilligung eines Nutzers einzuholen, eine API-Anfrage im Namen des Nutzers auszuführen. Ihre Anwendung muss diese Einwilligung haben, bevor sie eine Google API-Anfrage ausführen kann, die eine Nutzerautorisierung erfordert.
Die folgende Liste fasst diese Schritte kurz zusammen:
- Ihre Anwendung ermittelt die erforderlichen Berechtigungen.
- Ihre Anwendung leitet den Nutzer zusammen mit der Liste der angeforderten Berechtigungen an Google weiter.
- Der Nutzer entscheidet, ob er Ihrer Anwendung die Berechtigungen erteilen möchte.
- Ihre Anwendung findet heraus, was der Nutzer entschieden hat.
- Wenn der Nutzer die angeforderten Berechtigungen gewährt hat, ruft Ihre Anwendung Tokens ab, die für API-Anfragen im Namen des Nutzers erforderlich sind.
Schritt 1: Autorisierungsparameter festlegen
Der erste Schritt besteht darin, die Autorisierungsanfrage zu erstellen. Diese Anfrage legt Parameter fest, die Ihre Anwendung identifizieren und die Berechtigungen definieren, die der Nutzer Ihrer Anwendung gewähren soll.
- Wenn Sie eine Google-Clientbibliothek für die OAuth 2.0-Authentifizierung und -Autorisierung verwenden, erstellen und konfigurieren Sie ein Objekt, das diese Parameter definiert.
- Wenn Sie den Google OAuth 2.0-Endpunkt direkt aufrufen, generieren Sie eine URL und legen die Parameter für diese URL fest.
Die unten aufgeführten Registerkarten definieren die unterstützten Autorisierungsparameter für Webserveranwendungen. Die sprachspezifischen Beispiele zeigen auch, wie mithilfe einer Clientbibliothek oder Autorisierungsbibliothek ein Objekt konfiguriert wird, das diese Parameter festlegt.
PHP
Mit dem folgenden Code-Snippet wird ein Google\Client()
-Objekt erstellt, das die Parameter in der Autorisierungsanfrage definiert.
Das Objekt verwendet Informationen aus der Datei client_secret.json, um Ihre Anwendung zu identifizieren. (Weitere Informationen zu dieser Datei finden Sie unter Anmeldedaten für die Autorisierung erstellen.) Das Objekt identifiziert auch die Bereiche, für die Ihre Anwendung die Berechtigung anfordert, sowie die URL zum Authentifizierungsendpunkt Ihrer Anwendung, der die Antwort des OAuth 2.0-Servers von Google verarbeitet. Schließlich werden mit dem Code die optionalen Parameter access_type
und include_granted_scopes
festgelegt.
Mit diesem Code wird beispielsweise Offlinezugriff angefordert, um das YouTube-Konto eines Nutzers zu verwalten:
$client = new Google\Client(); // Required, call the setAuthConfig function to load authorization credentials from // client_secret.json file. $client->setAuthConfig('client_secret.json'); // Required, to set the scope value, call the addScope function $client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL); // Required, call the setRedirectUri function to specify a valid redirect URI for the // provided client_id $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); // Recommended, offline access will give you both an access and refresh token so that // your app can refresh the access token without user interaction. $client->setAccessType('offline'); // Recommended, call the setState function. Using a state value can increase your assurance that // an incoming connection is the result of an authentication request. $client->setState($sample_passthrough_value); // Optional, if your application knows which user is trying to authenticate, it can use this // parameter to provide a hint to the Google Authentication Server. $client->setLoginHint('hint@example.com'); // Optional, call the setPrompt function to set "consent" will prompt the user for consent $client->setPrompt('consent'); // Optional, call the setIncludeGrantedScopes function with true to enable incremental // authorization $client->setIncludeGrantedScopes(true);
Python
Das folgende Code-Snippet verwendet das Modul google-auth-oauthlib.flow
, um die Autorisierungsanfrage zu erstellen.
Der Code erstellt ein Flow
-Objekt, das Ihre Anwendung anhand von Informationen aus der Datei client_secret.json identifiziert, die Sie nach dem Erstellen von Anmeldedaten für die Autorisierung heruntergeladen haben. Das Objekt identifiziert auch die Bereiche, für die Ihre Anwendung die Berechtigung anfordert, sowie die URL zum Authentifizierungsendpunkt Ihrer Anwendung, der die Antwort des OAuth 2.0-Servers von Google verarbeitet. Schließlich legt der Code die optionalen Parameter access_type
und include_granted_scopes
fest.
Mit diesem Code wird beispielsweise Offlinezugriff angefordert, um das YouTube-Konto eines Nutzers zu verwalten:
import google.oauth2.credentials import google_auth_oauthlib.flow # Required, call the from_client_secrets_file method to retrieve the client ID from a # client_secret.json file. The client ID (from that file) and access scopes are required. (You can # also use the from_client_config method, which passes the client configuration as it originally # appeared in a client secrets file but doesn't access the file itself.) flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/youtube.force-ssl']) # Required, indicate where the API server will redirect the user after the user completes # the authorization flow. The redirect URI is required. The value must exactly # match one of the authorized redirect URIs for the OAuth 2.0 client, which you # configured in the API Console. If this value doesn't match an authorized URI, # you will get a 'redirect_uri_mismatch' error. flow.redirect_uri = 'https://www.example.com/oauth2callback' # Generate URL for request to Google's OAuth 2.0 server. # Use kwargs to set optional request parameters. authorization_url, state = flow.authorization_url( # Recommended, enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Optional, enable incremental authorization. Recommended as a best practice. include_granted_scopes='true', # Optional, if your application knows which user is trying to authenticate, it can use this # parameter to provide a hint to the Google Authentication Server. login_hint='hint@example.com', # Optional, set prompt to 'consent' will prompt the user for consent prompt='consent')
Ruby
Konfigurieren Sie mit der erstellten Datei „client_secrets.json“ ein Clientobjekt in Ihrer Anwendung. Wenn Sie ein Clientobjekt konfigurieren, geben Sie die Bereiche an, auf die Ihre Anwendung zugreifen muss, sowie die URL zum Authentifizierungsendpunkt Ihrer Anwendung, der die Antwort des OAuth 2.0-Servers verarbeitet.
Mit diesem Code wird beispielsweise Offlinezugriff angefordert, um das YouTube-Konto eines Nutzers zu verwalten:
require 'google/apis/youtube_v3' require "googleauth" require 'googleauth/stores/redis_token_store' client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json') scope = 'https://www.googleapis.com/auth/youtube.force-ssl' token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')
Ihre Anwendung verwendet das Clientobjekt, um OAuth 2.0-Vorgänge auszuführen, z. B. URLs für Autorisierungsanfragen zu generieren und Zugriffstokens auf HTTP-Anfragen anzuwenden.
Node.js
Mit dem folgenden Code-Snippet wird ein google.auth.OAuth2
-Objekt erstellt, das die Parameter in der Autorisierungsanfrage definiert.
Dieses Objekt verwendet Informationen aus Ihrer Datei client_secret.json, um Ihre Anwendung zu identifizieren. Wenn Sie einen Nutzer um Berechtigungen zum Abrufen eines Zugriffstokens bitten möchten, leiten Sie ihn auf eine Einwilligungsseite weiter. So erstellen Sie eine URL für die Einwilligungsseite:
const {google} = require('googleapis'); const crypto = require('crypto'); const express = require('express'); const session = require('express-session'); /** * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI * from the client_secret.json file. To get these credentials for your application, visit * https://console.cloud.google.com/apis/credentials. */ const oauth2Client = new google.auth.OAuth2( YOUR_CLIENT_ID, YOUR_CLIENT_SECRET, YOUR_REDIRECT_URL ); // Access scopes for read-only Drive activity. const scopes = [ 'https://www.googleapis.com/auth/drive.metadata.readonly' ]; // Generate a secure random state value. const state = crypto.randomBytes(32).toString('hex'); // Store state in the session req.session.state = state; // Generate a url that asks permissions for the Drive activity scope const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true, // Include the state parameter to reduce the risk of CSRF attacks. state: state });
Wichtiger Hinweis: Der refresh_token
wird nur bei der ersten Autorisierung zurückgegeben.
Weitere Informationen
HTTP/REST
Der OAuth 2.0-Endpunkt von Google befindet sich bei https://accounts.google.com/o/oauth2/v2/auth
. Auf diesen Endpunkt kann nur über HTTPS zugegriffen werden. Einfache HTTP-Verbindungen werden abgelehnt.
Der Google-Autorisierungsserver unterstützt die folgenden Abfragestringparameter für Webserveranwendungen:
Parameter | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
client_id |
Erforderlich
Die Client-ID für Ihre Anwendung. Sie finden diesen Wert in der API Console- Credentials page. |
||||||||||||||||
redirect_uri |
Erforderlich
Legt fest, wohin der API-Server den Nutzer weiterleitet, nachdem er den Autorisierungsvorgang abgeschlossen hat. Der Wert muss genau mit einem der autorisierten Weiterleitungs-URIs für den OAuth 2.0-Client übereinstimmen, die du in der API Console- Credentials pagedes Clients konfiguriert hast. Wenn dieser Wert mit keinem autorisierten Weiterleitungs-URI für die angegebene Das Schema |
||||||||||||||||
response_type |
Erforderlich
Bestimmt, ob der Google OAuth 2.0-Endpunkt einen Autorisierungscode zurückgibt. Legen Sie den Parameterwert für Webserveranwendungen auf |
||||||||||||||||
scope |
Erforderlich
Eine durch Leerzeichen getrennte Liste von Bereichen, die die Ressourcen identifizieren, auf die Ihre Anwendung im Namen des Nutzers zugreifen könnte. Diese Werte bilden die Grundlage für den Zustimmungsbildschirm, den Google dem Nutzer anzeigt. Mit Bereichen kann Ihre Anwendung nur Zugriff auf die benötigten Ressourcen anfordern und Nutzer können gleichzeitig den Umfang des Zugriffs steuern, den sie Ihrer Anwendung gewähren. Daher besteht eine umgekehrte Beziehung zwischen der Anzahl der angeforderten Bereiche und der Wahrscheinlichkeit, die Nutzereinwilligung einzuholen. Für Version 3 der YouTube Data API werden die folgenden Umfänge verwendet:
Das Dokument OAuth 2.0 API-Bereiche enthält eine vollständige Liste der Bereiche, die Sie für den Zugriff auf Google APIs verwenden können. Wir empfehlen, dass Ihre Anwendung Zugriff auf Autorisierungsbereiche wann immer möglich im Kontext anfordert. Wenn Sie den Zugriff auf Nutzerdaten im Kontext über eine inkrementelle Autorisierung anfordern, helfen Sie Nutzern, leichter zu verstehen, warum Ihre Anwendung den angeforderten Zugriff benötigt. |
||||||||||||||||
access_type |
Empfohlen
Gibt an, ob Ihre Anwendung Zugriffstokens aktualisieren kann, wenn der Nutzer nicht im Browser vorhanden ist. Gültige Parameterwerte sind Legen Sie den Wert auf |
||||||||||||||||
state |
Empfohlen
Gibt einen beliebigen Stringwert an, mit dem Ihre Anwendung den Status zwischen Ihrer Autorisierungsanfrage und der Antwort des Autorisierungsservers aufrechterhält.
Der Server gibt genau den Wert zurück, den du als Sie können diesen Parameter für verschiedene Zwecke verwenden, z. B. um den Nutzer zur richtigen Ressource in Ihrer Anwendung weiterzuleiten, Nonces zu senden und websiteübergreifende Anfragefälschungen zu minimieren. Da Ihr |
||||||||||||||||
include_granted_scopes |
Optional
Anwendungen können die inkrementelle Autorisierung verwenden, um Zugriff auf zusätzliche Bereiche im Kontext anzufordern. Wenn Sie den Wert dieses Parameters auf |
||||||||||||||||
enable_granular_consent |
Optional
Die Standardeinstellung ist Wenn Google detaillierte Berechtigungen für eine Anwendung aktiviert, hat dieser Parameter keine Wirkung mehr. |
||||||||||||||||
login_hint |
Optional
Wenn Ihre Anwendung weiß, welcher Nutzer sich authentifizieren möchte, kann sie mit diesem Parameter einen Hinweis für den Google-Authentifizierungsserver bereitstellen. Der Server verwendet den Hinweis, um den Anmeldevorgang zu vereinfachen. Dazu wird entweder das E-Mail-Feld im Anmeldeformular vorab ausgefüllt oder die entsprechende Mehrfachanmeldungssitzung ausgewählt. Legen Sie als Parameterwert eine E-Mail-Adresse oder eine |
||||||||||||||||
prompt |
Optional
Eine durch Leerzeichen getrennte Liste von Eingabeaufforderungen, die dem Nutzer angezeigt werden. Beachten Sie dabei die Groß- und Kleinschreibung. Wenn Sie diesen Parameter nicht angeben, wird der Nutzer nur dann aufgefordert, wenn Ihr Projekt den Zugriff anfordert. Weitere Informationen finden Sie unter Aufforderung zur erneuten Einwilligung. Folgende Werte sind möglich:
|
Schritt 2: Weiterleitung zum OAuth 2.0-Server von Google
Leite den Nutzer zum OAuth 2.0-Server von Google weiter, um den Authentifizierungs- und Autorisierungsprozess zu starten. Dies geschieht in der Regel, wenn Ihre Anwendung zum ersten Mal auf die Daten des Nutzers zugreifen muss. Im Fall der inkrementellen Autorisierung erfolgt dieser Schritt auch, wenn Ihre Anwendung zuerst auf zusätzliche Ressourcen zugreifen muss, für die sie noch keine Zugriffsberechtigung hat.
PHP
- Generiere eine URL, um den Zugriff vom OAuth 2.0-Server von Google anzufordern:
$auth_url = $client->createAuthUrl();
- Leite den Nutzer zu
$auth_url
weiter:header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
Python
In diesem Beispiel wird gezeigt, wie der Nutzer mithilfe des Flask-Webanwendungs-Frameworks zur Autorisierungs-URL weitergeleitet wird:
return flask.redirect(authorization_url)
Ruby
- Generiere eine URL, um den Zugriff vom OAuth 2.0-Server von Google anzufordern:
auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)
- Leite den Nutzer zu
auth_uri
weiter.
Node.js
-
Verwenden Sie die generierte URL
authorizationUrl
aus der MethodegenerateAuthUrl
in Schritt 1, um den Zugriff vom OAuth 2.0-Server von Google anzufordern. -
Leite den Nutzer zu
authorizationUrl
weiter.res.redirect(authorizationUrl);
HTTP/REST
Sample redirect to Google's authorization server
The sample URL below requests offline access
(access_type=offline
) to a scope that permits access to view
the user's YouTube account. It uses incremental authorization to ensure that
the new access token covers any scopes to which the user previously granted
the application access. The URL also sets values for the required
redirect_uri
, response_type
, and
client_id
parameters as well as for the state
parameter. The URL contains line breaks and spaces for readability.
https://accounts.google.com/o/oauth2/v2/auth?
scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly&
access_type=offline&
include_granted_scopes=true&
state=state_parameter_passthrough_value&
redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
response_type=code&
client_id=client_id
Nachdem Sie die Anfrage-URL erstellt haben, leiten Sie den Nutzer dorthin weiter.
Der OAuth 2.0-Server von Google authentifiziert den Nutzer und holt die Einwilligung des Nutzers ein, damit Ihre Anwendung auf die angeforderten Bereiche zugreifen darf. Die Antwort wird mithilfe der von Ihnen angegebenen Weiterleitungs-URL an Ihre Anwendung zurückgesendet.
Schritt 3: Google fordert den Nutzer zur Einwilligung auf
In diesem Schritt entscheidet der Nutzer, ob er Ihrer Anwendung den angeforderten Zugriff gewähren möchte. In dieser Phase zeigt Google ein Einwilligungsfenster mit dem Namen Ihrer Anwendung und den Google API-Diensten an, für die die Berechtigung mit den Autorisierungsanmeldedaten des Nutzers angefordert wird. Außerdem wird eine Zusammenfassung der Zugriffsbereiche angezeigt, die gewährt werden sollen. Der Nutzer kann dann zustimmen, Zugriff auf einen oder mehrere Bereiche zu gewähren, die von Ihrer Anwendung angefordert werden, oder die Anfrage ablehnen.
Deine Anwendung muss in dieser Phase nichts weiter tun, da sie auf die Antwort vom OAuth 2.0-Server von Google wartet, die angibt, ob ein Zugriff gewährt wurde. Diese Antwort wird im folgenden Schritt erklärt.
Fehler
Bei Anfragen an den OAuth 2.0-Autorisierungsendpunkt von Google werden möglicherweise nutzerseitige Fehlermeldungen anstelle der erwarteten Authentifizierungs- und Autorisierungsabläufe angezeigt. Häufige Fehlercodes und Lösungsvorschläge sind unten aufgeführt.
admin_policy_enforced
Mindestens ein Bereich kann aufgrund der Richtlinien seines Google Workspace-Administrators nicht mit dem Google-Konto autorisiert werden. Im Hilfeartikel Zugriff externer und interner Apps auf Google Workspace-Daten steuern finden Sie weitere Informationen dazu, wie ein Administrator den Zugriff auf alle Bereiche oder auf vertrauliche und eingeschränkte Bereiche einschränken kann, bis der Zugriff auf Ihre OAuth-Client-ID explizit gewährt wird.
disallowed_useragent
Der Autorisierungsendpunkt wird in einem eingebetteten User-Agent angezeigt, der gemäß den OAuth 2.0-Richtlinien von Google unzulässig ist.
Android
Android-Entwicklern kann diese Fehlermeldung angezeigt werden, wenn sie Autorisierungsanfragen in android.webkit.WebView
öffnen.
Entwickler sollten stattdessen Android-Bibliotheken wie Google Log-in for Android oder AppAuth for Android der OpenID Foundation verwenden.
Bei Webentwicklern kann dieser Fehler auftreten, wenn eine Android-App einen allgemeinen Weblink in einem eingebetteten User-Agent öffnet und ein Nutzer von deiner Website zum OAuth 2.0-Autorisierungsendpunkt von Google navigiert. Entwickler sollten das Öffnen allgemeiner Links im Standard-Link-Handler des Betriebssystems zulassen. Dazu gehören sowohl Handler für Android-App-Links als auch die Standard-Browser-App. Eine unterstützte Option ist auch die Bibliothek mit benutzerdefinierten Android-Tabs.
iOS
Bei iOS- und macOS-Entwicklern kann dieser Fehler auftreten, wenn sie Autorisierungsanfragen in WKWebView
öffnen.
Entwickler sollten stattdessen iOS-Bibliotheken wie Google Log-in für iOS oder AppAuth für iOS von OpenID Foundation verwenden.
Bei Webentwicklern kann dieser Fehler auftreten, wenn eine iOS- oder macOS-App einen allgemeinen Weblink in einem eingebetteten User-Agent öffnet und ein Nutzer von deiner Website zum OAuth 2.0-Autorisierungsendpunkt von Google wechselt. Entwickler sollten das Öffnen allgemeiner Links im Standard-Link-Handler des Betriebssystems zulassen. Dieser umfasst sowohl universelle Links-Handler als auch die Standard-Browser-App. Eine unterstützte Option ist auch die SFSafariViewController
-Bibliothek.
org_internal
Die OAuth-Client-ID in der Anfrage ist Teil eines Projekts, das den Zugriff auf Google-Konten in einer bestimmten Google Cloud-Organisation einschränkt. Weitere Informationen zu dieser Konfigurationsoption finden Sie im Hilfeartikel "OAuth-Zustimmungsbildschirm einrichten" im Abschnitt Nutzertyp.
invalid_client
Der OAuth-Clientschlüssel ist falsch. Überprüfen Sie die OAuth-Clientkonfiguration, einschließlich der für diese Anfrage verwendeten Client-ID und des Secret.
invalid_grant
Beim Aktualisieren eines Zugriffstokens oder bei Verwendung der inkrementellen Autorisierung ist das Token möglicherweise abgelaufen oder ungültig. Authentifizieren Sie den Nutzer noch einmal und bitten Sie um seine Einwilligung, um neue Tokens zu erhalten. Wenn dieser Fehler weiterhin auftritt, prüfen Sie, ob Ihre Anwendung richtig konfiguriert wurde und Sie die richtigen Tokens und Parameter in Ihrer Anfrage verwenden. Andernfalls wurde das Nutzerkonto möglicherweise gelöscht oder deaktiviert.
redirect_uri_mismatch
Der in der Autorisierungsanfrage übergebene redirect_uri
stimmt mit keinem autorisierten Weiterleitungs-URI für die OAuth-Client-ID überein. Prüfen Sie autorisierte Weiterleitungs-URIs in Google API Console Credentials page.
Der Parameter redirect_uri
kann sich auf den OAuth-Out-of-Band-Vorgang (OOB) beziehen, der eingestellt wurde und nicht mehr unterstützt wird. Informationen dazu, wie du deine Integration aktualisierst, findest du in der Migrationsanleitung.
invalid_request
Mit deiner Anfrage ist ein Fehler aufgetreten. Dafür kann es mehrere Gründe geben:
- Die Anfrage war nicht richtig formatiert
- In der Anfrage fehlen erforderliche Parameter
- In der Anfrage wird eine Autorisierungsmethode verwendet, die von Google nicht unterstützt wird. Prüfen, ob Ihre OAuth-Integration eine empfohlene Integrationsmethode verwendet
Schritt 4: Die Antwort des OAuth 2.0-Servers verarbeiten
Der OAuth 2.0-Server antwortet auf die Zugriffsanfrage deiner Anwendung mit der in der Anfrage angegebenen URL.
Wenn der Nutzer die Zugriffsanfrage genehmigt, enthält die Antwort einen Autorisierungscode. Wenn der Nutzer die Anfrage nicht genehmigt, enthält die Antwort eine Fehlermeldung. Der Autorisierungscode oder die Fehlermeldung, die an den Webserver zurückgegeben wird, wird im Abfragestring wie folgt angezeigt:
Eine Fehlerantwort:
https://oauth2.example.com/auth?error=access_denied
Eine Antwort mit einem Autorisierungscode:
https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7
Beispiel für eine OAuth 2.0-Serverantwort
Sie können diesen Vorgang testen, indem Sie auf die folgende Beispiel-URL klicken. Diese fordert Lesezugriff auf Metadaten für Dateien in Ihrem Google Drive-Konto an:
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly& access_type=offline& include_granted_scopes=true& state=state_parameter_passthrough_value& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& response_type=code& client_id=client_id
Nach Abschluss des OAuth 2.0-Vorgangs solltest du zu http://localhost/oauth2callback
weitergeleitet werden, was wahrscheinlich zum Fehler 404 NOT FOUND
führt, es sei denn, dein lokaler Computer stellt eine Datei unter dieser Adresse bereit. Im nächsten Schritt werden weitere Details zu den Informationen bereitgestellt, die im URI zurückgegeben werden, wenn der Nutzer zu Ihrer Anwendung zurückgeleitet wird.
Schritt 5: Autorisierungscode gegen Aktualisierungs- und Zugriffstokens austauschen
Nachdem der Webserver den Autorisierungscode erhalten hat, kann er ihn gegen ein Zugriffstoken austauschen.
PHP
Mit der Methode authenticate
tauschen Sie einen Autorisierungscode gegen ein Zugriffstoken aus:
$client->authenticate($_GET['code']);
Sie können das Zugriffstoken mit der Methode getAccessToken
abrufen:
$access_token = $client->getAccessToken();
Python
Verwende auf deiner Callback-Seite die google-auth
-Bibliothek, um die Antwort des Autorisierungsservers zu prüfen. Verwenden Sie dann die Methode flow.fetch_token
, um den Autorisierungscode in dieser Antwort gegen ein Zugriffstoken auszutauschen:
state = flask.session['state'] flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/youtube.force-ssl'], state=state) flow.redirect_uri = flask.url_for('oauth2callback', _external=True) authorization_response = flask.request.url flow.fetch_token(authorization_response=authorization_response) # Store the credentials in the session. # ACTION ITEM for developers: # Store user's access and refresh tokens in your data store if # incorporating this code into your real app. credentials = flow.credentials flask.session['credentials'] = { 'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'client_id': credentials.client_id, 'client_secret': credentials.client_secret, 'scopes': credentials.scopes}
Ruby
Verwende auf deiner Callback-Seite die googleauth
-Bibliothek, um die Antwort des Autorisierungsservers zu prüfen. Verwenden Sie die Methode authorizer.handle_auth_callback_deferred
, um den Autorisierungscode zu speichern und zur URL zurückzuleiten, die die Autorisierung ursprünglich angefordert hat. Dadurch wird der Austausch des Codes verzögert, indem die Ergebnisse vorübergehend in der Nutzersitzung zwischengespeichert werden.
target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url
Node.js
Mit der Methode getToken
tauschen Sie einen Autorisierungscode gegen ein Zugriffstoken aus:
const url = require('url'); // Receive the callback from Google's OAuth 2.0 server. app.get('/oauth2callback', async (req, res) => { let q = url.parse(req.url, true).query; if (q.error) { // An error response e.g. error=access_denied console.log('Error:' + q.error); } else if (q.state !== req.session.state) { //check state value console.log('State mismatch. Possible CSRF attack'); res.end('State mismatch. Possible CSRF attack'); } else { // Get access and refresh tokens (if access_type is offline) let { tokens } = await oauth2Client.getToken(q.code); oauth2Client.setCredentials(tokens); });
HTTP/REST
Rufen Sie den Endpunkt https://oauth2.googleapis.com/token
auf und legen Sie die folgenden Parameter fest, um einen Autorisierungscode gegen ein Zugriffstoken auszutauschen:
Felder | |
---|---|
client_id |
Die Client-ID aus dem API Console Credentials page. |
client_secret |
Der von API Console Credentials pageabgerufene Clientschlüssel. |
code |
Der Autorisierungscode, der von der ursprünglichen Anfrage zurückgegeben wurde. |
grant_type |
Wie in der OAuth 2.0-Spezifikation definiert, muss der Wert in diesem Feld auf authorization_code gesetzt sein. |
redirect_uri |
Einer der Weiterleitungs-URIs, die für Ihr Projekt in der API Console
Credentials page für die angegebene client_id aufgeführt sind. |
Das folgende Snippet zeigt eine Beispielanfrage:
POST /token HTTP/1.1 Host: oauth2.googleapis.com Content-Type: application/x-www-form-urlencoded code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7& client_id=your_client_id& client_secret=your_client_secret& redirect_uri=https%3A//oauth2.example.com/code& grant_type=authorization_code
Google reagiert auf diese Anfrage mit der Rückgabe eines JSON-Objekts, das ein kurzlebiges Zugriffstoken und ein Aktualisierungstoken enthält.
Das Aktualisierungstoken wird nur zurückgegeben, wenn Ihre Anwendung den Parameter access_type
in der ersten Anfrage an den Autorisierungsserver von Google auf offline
gesetzt hat.
Die Antwort umfasst die folgenden Felder:
Felder | |
---|---|
access_token |
Das Token, das Ihre Anwendung sendet, um eine Google API-Anfrage zu autorisieren. |
expires_in |
Die verbleibende Lebensdauer des Zugriffstokens in Sekunden. |
refresh_token |
Ein Token, mit dem Sie ein neues Zugriffstoken abrufen können. Aktualisierungstokens sind gültig, bis der Nutzer den Zugriff widerruft.
Auch hier ist dieses Feld nur in dieser Antwort vorhanden, wenn du den access_type -Parameter in der ersten Anfrage an den Autorisierungsserver von Google auf offline festlegst.
|
scope |
Die durch access_token gewährten Zugriffsbereiche, ausgedrückt als Liste von durch Leerzeichen getrennten Strings mit Groß- und Kleinschreibung. |
token_type |
Der Typ des zurückgegebenen Tokens. Derzeit ist der Wert dieses Felds immer auf Bearer festgelegt. |
Das folgende Snippet zeigt eine Beispielantwort:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "token_type": "Bearer", "scope": "https://www.googleapis.com/auth/youtube.force-ssl", "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI" }
Fehler
Wenn Sie den Autorisierungscode gegen ein Zugriffstoken austauschen, wird anstelle der erwarteten Antwort möglicherweise der folgende Fehler angezeigt. Häufige Fehlercodes und Lösungsvorschläge sind unten aufgeführt.
invalid_grant
Der angegebene Autorisierungscode ist ungültig oder hat das falsche Format. Fordere einen neuen Code an, indem du den OAuth-Prozess neu startest, um den Nutzer noch einmal um Einwilligung zu bitten.
Google APIs aufrufen
PHP
Verwenden Sie das Zugriffstoken, um Google APIs aufzurufen. Führen Sie dazu die folgenden Schritte aus:
- Wenn Sie ein Zugriffstoken auf ein neues
Google\Client
-Objekt anwenden müssen, wenn Sie das Zugriffstoken beispielsweise in einer Nutzersitzung gespeichert haben, verwenden Sie die MethodesetAccessToken
:$client->setAccessToken($access_token);
- Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Zum Erstellen eines Dienstobjekts stellen Sie dem Konstruktor ein autorisiertes
Google\Client
-Objekt für die aufzurufende API bereit. So rufen Sie beispielsweise die YouTube Data API auf:$youtube = new Google_Service_YouTube($client);
- Senden Sie Anfragen über die vom Dienstobjekt bereitgestellte Schnittstelle an den API-Dienst.
So rufen Sie beispielsweise Daten zum YouTube-Kanal des autorisierten Nutzers ab:
$channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));
Python
Nach dem Erhalt eines Zugriffstokens kann Ihre Anwendung dieses Token verwenden, um API-Anfragen im Namen eines bestimmten Nutzerkontos oder Dienstkontos zu autorisieren. Erstellen Sie mit den nutzerspezifischen Anmeldedaten ein Dienstobjekt für die API, die Sie aufrufen möchten, und verwenden Sie dieses Objekt dann, um autorisierte API-Anfragen zu senden.
- Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Zum Erstellen eines Dienstobjekts rufen Sie die Methode
build
dergoogleapiclient.discovery
-Bibliothek mit dem Namen und der Version der API sowie den Nutzeranmeldedaten auf: So rufen Sie beispielsweise Version 3 der YouTube Data API auf:from googleapiclient.discovery import build youtube = build('youtube', 'v3', credentials=credentials)
- Senden Sie Anfragen über die vom Dienstobjekt bereitgestellte Schnittstelle an den API-Dienst.
So rufen Sie beispielsweise Daten zum YouTube-Kanal des autorisierten Nutzers ab:
channel = youtube.channels().list(mine=True, part='snippet').execute()
Ruby
Nachdem Sie ein Zugriffstoken erhalten haben, kann Ihre Anwendung damit API-Anfragen im Namen eines bestimmten Nutzerkontos oder Dienstkontos stellen. Erstellen Sie mit den nutzerspezifischen Anmeldedaten ein Dienstobjekt für die API, die Sie aufrufen möchten, und verwenden Sie dieses Objekt dann, um autorisierte API-Anfragen zu senden.
- Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten.
So rufst du beispielsweise Version 3 der YouTube Data API auf:
youtube = Google::Apis::YoutubeV3::YouTubeService.new
- Legen Sie die Anmeldedaten für den Dienst fest:
youtube.authorization = credentials
- Senden Sie Anfragen über die vom Dienstobjekt bereitgestellte Schnittstelle an den API-Dienst.
So rufen Sie beispielsweise Daten zum YouTube-Kanal des autorisierten Nutzers ab:
channel = youtube.list_channels(part, :mine => mine)
Alternativ kann die Autorisierung für einzelne Methoden bereitgestellt werden. Dazu muss einer Methode der Parameter options
übergeben werden:
channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })
Node.js
Nachdem Sie ein Zugriffstoken abgerufen und auf das Objekt OAuth2
festgelegt haben, können Sie mit dem Objekt Google APIs aufrufen. Ihre Anwendung kann dieses Token verwenden, um API-Anfragen im Namen eines bestimmten Nutzerkontos oder Dienstkontos zu autorisieren. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten.
const { google } = require('googleapis'); // Example of using Google Drive API to list filenames in user's Drive. const drive = google.drive('v3'); drive.files.list({ auth: oauth2Client, pageSize: 10, fields: 'nextPageToken, files(id, name)', }, (err1, res1) => { if (err1) return console.log('The API returned an error: ' + err1); const files = res1.data.files; if (files.length) { console.log('Files:'); files.map((file) => { console.log(`${file.name} (${file.id})`); }); } else { console.log('No files found.'); } });
HTTP/REST
Nachdem Ihre Anwendung ein Zugriffstoken abgerufen hat, können Sie mit dem Token im Namen eines bestimmten Nutzerkontos eine Google API aufrufen, wenn die für die API erforderlichen Zugriffsbereiche gewährt wurden. Fügen Sie dazu das Zugriffstoken in eine Anfrage an die API ein, indem Sie entweder einen access_token
-Abfrageparameter oder einen Authorization
-HTTP-Header-Bearer
-Wert angeben. Nach Möglichkeit ist der HTTP-Header zu empfehlen, da Abfragestrings in der Regel in Serverlogs sichtbar sind. In den meisten Fällen kannst du Aufrufe von Google APIs mithilfe einer Clientbibliothek einrichten (z. B. beim Aufrufen der YouTube Data API).
Die YouTube Data API unterstützt nur Dienstkonten für YouTube-Rechteinhaber, die mehrere YouTube-Kanäle wie Labels und Filmstudios besitzen und verwalten.
Im OAuth 2.0 Playground können Sie alle Google APIs ausprobieren und ihre Bereiche ansehen.
Beispiele für HTTP GET
Ein Aufruf des
youtube.channels
-Endpunkts (die YouTube Data API) über den HTTP-Header Authorization: Bearer
könnte so aussehen: Beachten Sie, dass Sie Ihr eigenes Zugriffstoken angeben müssen:
GET /youtube/v3/channels?part=snippet&mine=true HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
Hier sehen Sie einen Aufruf derselben API für den authentifizierten Nutzer mit dem Abfragestringparameter access_token
:
GET https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true
Beispiele für curl
Sie können diese Befehle mit der curl
-Befehlszeilenanwendung testen. Hier ein Beispiel, in dem die HTTP-Header-Option verwendet wird (bevorzugt):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true
Alternativ können Sie die Parameteroption für den Abfragestring verwenden:
curl https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true
Vollständiges Beispiel
Im folgenden Beispiel wird ein Objekt im JSON-Format ausgegeben, das Informationen zum YouTube-Kanal eines Nutzers anzeigt, nachdem der Nutzer die Anwendung authentifiziert und autorisiert hat, das YouTube-Konto des Nutzers zu verwalten.
PHP
So führen Sie das Beispiel aus:
- Fügen Sie im API Consoleder Liste der Weiterleitungs-URLs die URL des lokalen Computers hinzu, z. B.
http://localhost:8080
. - Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Beispiel:
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- Installieren Sie die Google API-Clientbibliothek für PHP mit Composer:
composer require google/apiclient:^2.10
- Erstellen Sie die Dateien
index.php
undoauth2callback.php
mit dem folgenden Inhalt. - Führen Sie das Beispiel mit einem Webserver aus, der für PHP konfiguriert ist. Wenn Sie PHP 5.6 oder höher verwenden, können Sie den integrierten Testwebserver von PHP verwenden:
php -S localhost:8080 ~/php-oauth2-example
index.php
<?php require_once __DIR__.'/vendor/autoload.php'; session_start(); $client = new Google\Client(); $client->setAuthConfig('client_secrets.json'); $client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL); if (isset($_SESSION['access_token']) && $_SESSION['access_token']) { $client->setAccessToken($_SESSION['access_token']); $youtube = new Google_Service_YouTube($client); $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine)); echo json_encode($channel); } else { $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'; header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL)); }
oauth2callback.php
<?php require_once __DIR__.'/vendor/autoload.php'; session_start(); $client = new Google\Client(); $client->setAuthConfigFile('client_secrets.json'); $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); $client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL); if (! isset($_GET['code'])) { // Generate and set state value $state = bin2hex(random_bytes(16)); $client->setState($state); $_SESSION['state'] = $state; $auth_url = $client->createAuthUrl(); header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL)); } else { // Check the state value if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) { die('State mismatch. Possible CSRF attack.'); } $client->authenticate($_GET['code']); $_SESSION['access_token'] = $client->getAccessToken(); $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/'; header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL)); }
Python
In diesem Beispiel wird das Flask-Framework verwendet. Unter http://localhost:8080
wird eine Webanwendung ausgeführt, mit der du den OAuth 2.0-Vorgang testen kannst. Wenn Sie diese URL aufrufen, sollten Sie vier Links sehen:
- API-Anfrage testen:Dieser Link verweist auf eine Seite, auf der versucht wird, eine Beispiel-API-Anfrage auszuführen. Falls erforderlich, wird der Autorisierungsvorgang gestartet. Wenn der Vorgang erfolgreich war, wird auf der Seite die API-Antwort angezeigt.
- Authentifizierung direkt testen:Dieser Link verweist auf eine Seite, auf der versucht wird, den Nutzer durch den Autorisierungsvorgang weiterzuleiten. Die App fordert die Berechtigung an, autorisierte API-Anfragen im Namen des Nutzers zu senden.
- Aktuelle Anmeldedaten widerrufen:Dieser Link verweist auf eine Seite, auf der Berechtigungen, die der Nutzer der Anwendung bereits erteilt hat, aufgehoben werden.
- Anmeldedaten für Flask-Sitzung löschen:Über diesen Link werden Autorisierungsanmeldedaten gelöscht, die in der Flask-Sitzung gespeichert sind. So lässt sich nachvollziehen, was passieren würde, wenn ein Nutzer, der Ihrer App bereits die Berechtigung erteilt hat, versucht würde, eine API-Anfrage in einer neuen Sitzung auszuführen. Außerdem sehen Sie dort die API-Antwort, die Ihre App erhalten würde, wenn ein Nutzer Ihrer App erteilte Berechtigungen widerrufen würde und Ihre App trotzdem versucht, eine Anfrage mit einem widerrufenen Zugriffstoken zu autorisieren.
# -*- coding: utf-8 -*- import os import flask import requests import google.oauth2.credentials import google_auth_oauthlib.flow import googleapiclient.discovery # This variable specifies the name of a file that contains the OAuth 2.0 # information for this application, including its client_id and client_secret. CLIENT_SECRETS_FILE = "client_secret.json" # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account and requires requests to use an SSL connection. SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl'] API_SERVICE_NAME = 'youtube' API_VERSION = 'v3' app = flask.Flask(__name__) # Note: A secret key is included in the sample so that it works. # If you use this code in your application, replace this with a truly secret # key. See https://flask.palletsprojects.com/quickstart/#sessions. app.secret_key = 'REPLACE ME - this value is here as a placeholder.' @app.route('/') def index(): return print_index_table() @app.route('/test') def test_api_request(): if 'credentials' not in flask.session: return flask.redirect('authorize') # Load credentials from the session. credentials = google.oauth2.credentials.Credentials( **flask.session['credentials']) youtube = googleapiclient.discovery.build( API_SERVICE_NAME, API_VERSION, credentials=credentials) channel = youtube.channels().list(mine=True, part='snippet').execute() # Save credentials back to session in case access token was refreshed. # ACTION ITEM: In a production app, you likely want to save these # credentials in a persistent database instead. flask.session['credentials'] = credentials_to_dict(credentials) return flask.jsonify(**channel) @app.route('/authorize') def authorize(): # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps. flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( CLIENT_SECRETS_FILE, scopes=SCOPES) # The URI created here must exactly match one of the authorized redirect URIs # for the OAuth 2.0 client, which you configured in the API Console. If this # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch' # error. flow.redirect_uri = flask.url_for('oauth2callback', _external=True) authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true') # Store the state so the callback can verify the auth server response. flask.session['state'] = state return flask.redirect(authorization_url) @app.route('/oauth2callback') def oauth2callback(): # Specify the state when creating the flow in the callback so that it can # verified in the authorization server response. state = flask.session['state'] flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( CLIENT_SECRETS_FILE, scopes=SCOPES, state=state) flow.redirect_uri = flask.url_for('oauth2callback', _external=True) # Use the authorization server's response to fetch the OAuth 2.0 tokens. authorization_response = flask.request.url flow.fetch_token(authorization_response=authorization_response) # Store credentials in the session. # ACTION ITEM: In a production app, you likely want to save these # credentials in a persistent database instead. credentials = flow.credentials flask.session['credentials'] = credentials_to_dict(credentials) return flask.redirect(flask.url_for('test_api_request')) @app.route('/revoke') def revoke(): if 'credentials' not in flask.session: return ('You need to <a href="/authorize">authorize</a> before ' + 'testing the code to revoke credentials.') credentials = google.oauth2.credentials.Credentials( **flask.session['credentials']) revoke = requests.post('https://oauth2.googleapis.com/revoke', params={'token': credentials.token}, headers = {'content-type': 'application/x-www-form-urlencoded'}) status_code = getattr(revoke, 'status_code') if status_code == 200: return('Credentials successfully revoked.' + print_index_table()) else: return('An error occurred.' + print_index_table()) @app.route('/clear') def clear_credentials(): if 'credentials' in flask.session: del flask.session['credentials'] return ('Credentials have been cleared.<br><br>' + print_index_table()) def credentials_to_dict(credentials): return {'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'client_id': credentials.client_id, 'client_secret': credentials.client_secret, 'scopes': credentials.scopes} def print_index_table(): return ('<table>' + '<tr><td><a href="/test">Test an API request</a></td>' + '<td>Submit an API request and see a formatted JSON response. ' + ' Go through the authorization flow if there are no stored ' + ' credentials for the user.</td></tr>' + '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' + '<td>Go directly to the authorization flow. If there are stored ' + ' credentials, you still might not be prompted to reauthorize ' + ' the application.</td></tr>' + '<tr><td><a href="/revoke">Revoke current credentials</a></td>' + '<td>Revoke the access token associated with the current user ' + ' session. After revoking credentials, if you go to the test ' + ' page, you should see an <code>invalid_grant</code> error.' + '</td></tr>' + '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' + '<td>Clear the access token currently stored in the user session. ' + ' After clearing the token, if you <a href="/test">test the ' + ' API request</a> again, you should go back to the auth flow.' + '</td></tr></table>') if __name__ == '__main__': # When running locally, disable OAuthlib's HTTPs verification. # ACTION ITEM for developers: # When running in production *do not* leave this option enabled. os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' # Specify a hostname and port that are set as a valid redirect URI # for your API project in the Google API Console. app.run('localhost', 8080, debug=True)
Ruby
In diesem Beispiel wird das Framework Sinatra verwendet.
require 'google/apis/youtube_v3' require 'sinatra' require 'googleauth' require 'googleauth/stores/redis_token_store' configure do enable :sessions set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json') set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback') end get '/' do user_id = settings.client_id.id credentials = settings.authorizer.get_credentials(user_id, request) if credentials.nil? redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request) end youtube = Google::Apis::YoutubeV3::YouTubeService.new channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client }) "<pre>#{JSON.pretty_generate(channel.to_h)}</pre>" end get '/oauth2callback' do target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url end
Node.js
So führen Sie das Beispiel aus:
-
Fügen Sie im API Consoleder Liste der Weiterleitungs-URLs die URL des lokalen Computers hinzu, z. B.
http://localhost
. - Achten Sie darauf, dass die Wartung „Langzeitsupport“, eine aktive Version von Langzeitsupport oder der aktuelle Release von Node.js installiert ist.
-
Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Beispiel:
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example
-
Install the
Google API Client
Library
for Node.js using npm:
npm install googleapis
-
Erstellen Sie die Dateien
main.js
mit dem unten stehenden Inhalt. -
Führen Sie das Beispiel aus:
node .\main.js
main.js
const http = require('http'); const https = require('https'); const url = require('url'); const { google } = require('googleapis'); const crypto = require('crypto'); const express = require('express'); const session = require('express-session'); /** * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI. * To get these credentials for your application, visit * https://console.cloud.google.com/apis/credentials. */ const oauth2Client = new google.auth.OAuth2( YOUR_CLIENT_ID, YOUR_CLIENT_SECRET, YOUR_REDIRECT_URL ); // Access scopes for read-only Drive activity. const scopes = [ 'https://www.googleapis.com/auth/drive.metadata.readonly' ]; /* Global variable that stores user credential in this code example. * ACTION ITEM for developers: * Store user's refresh token in your data store if * incorporating this code into your real app. * For more information on handling refresh tokens, * see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens */ let userCredential = null; async function main() { const app = express(); app.use(session({ secret: 'your_secure_secret_key', // Replace with a strong secret resave: false, saveUninitialized: false, })); // Example on redirecting user to Google's OAuth 2.0 server. app.get('/', async (req, res) => { // Generate a secure random state value. const state = crypto.randomBytes(32).toString('hex'); // Store state in the session req.session.state = state; // Generate a url that asks permissions for the Drive activity scope const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true, // Include the state parameter to reduce the risk of CSRF attacks. state: state }); res.redirect(authorizationUrl); }); // Receive the callback from Google's OAuth 2.0 server. app.get('/oauth2callback', async (req, res) => { // Handle the OAuth 2.0 server response let q = url.parse(req.url, true).query; if (q.error) { // An error response e.g. error=access_denied console.log('Error:' + q.error); } else if (q.state !== req.session.state) { //check state value console.log('State mismatch. Possible CSRF attack'); res.end('State mismatch. Possible CSRF attack'); } else { // Get access and refresh tokens (if access_type is offline) let { tokens } = await oauth2Client.getToken(q.code); oauth2Client.setCredentials(tokens); /** Save credential to the global variable in case access token was refreshed. * ACTION ITEM: In a production app, you likely want to save the refresh token * in a secure persistent database instead. */ userCredential = tokens; // Example of using Google Drive API to list filenames in user's Drive. const drive = google.drive('v3'); drive.files.list({ auth: oauth2Client, pageSize: 10, fields: 'nextPageToken, files(id, name)', }, (err1, res1) => { if (err1) return console.log('The API returned an error: ' + err1); const files = res1.data.files; if (files.length) { console.log('Files:'); files.map((file) => { console.log(`${file.name} (${file.id})`); }); } else { console.log('No files found.'); } }); } }); // Example on revoking a token app.get('/revoke', async (req, res) => { // Build the string for the POST request let postData = "token=" + userCredential.access_token; // Options for POST request to Google's OAuth 2.0 server to revoke a token let postOptions = { host: 'oauth2.googleapis.com', port: '443', path: '/revoke', method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(postData) } }; // Set up the request const postReq = https.request(postOptions, function (res) { res.setEncoding('utf8'); res.on('data', d => { console.log('Response: ' + d); }); }); postReq.on('error', error => { console.log(error) }); // Post the request with data postReq.write(postData); postReq.end(); }); const server = http.createServer(app); server.listen(80); } main().catch(console.error);
HTTP/REST
In diesem Python-Beispiel werden das Flask und die Requests-Bibliothek verwendet, um den OAuth 2.0-Webfluss zu demonstrieren. Wir empfehlen die Verwendung der Google API-Clientbibliothek für Python für diesen Ablauf. Im Beispiel auf dem Tab „Python“ wird die Clientbibliothek verwendet.
import json import flask import requests app = flask.Flask(__name__) CLIENT_ID = '123456789.apps.googleusercontent.com' CLIENT_SECRET = 'abc123' # Read from a file or environmental variable in a real app SCOPE = 'https://www.googleapis.com/auth/youtube.force-ssl' REDIRECT_URI = 'http://example.com/oauth2callback' @app.route('/') def index(): if 'credentials' not in flask.session: return flask.redirect(flask.url_for('oauth2callback')) credentials = json.loads(flask.session['credentials']) if credentials['expires_in'] <= 0: return flask.redirect(flask.url_for('oauth2callback')) else: headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])} req_uri = 'https://www.googleapis.com/youtube/v3/channels/list' r = requests.get(req_uri, headers=headers) return r.text @app.route('/oauth2callback') def oauth2callback(): if 'code' not in flask.request.args: state = str(uuid.uuid4()) flask.session['state'] = state auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code' '&client_id={}&redirect_uri={}&scope={}&state={}').format(CLIENT_ID, REDIRECT_URI, SCOPE, state) return flask.redirect(auth_uri) else: if 'state' not in flask.request.args or flask.request.args['state'] != flask.session['state']: return 'State mismatch. Possible CSRF attack.', 400 auth_code = flask.request.args.get('code') data = {'code': auth_code, 'client_id': CLIENT_ID, 'client_secret': CLIENT_SECRET, 'redirect_uri': REDIRECT_URI, 'grant_type': 'authorization_code'} r = requests.post('https://oauth2.googleapis.com/token', data=data) flask.session['credentials'] = r.text return flask.redirect(flask.url_for('index')) if __name__ == '__main__': import uuid app.secret_key = str(uuid.uuid4()) app.debug = False app.run()
Validierungsregeln für Weiterleitungs-URIs
Google wendet die folgenden Validierungsregeln auf Weiterleitungs-URIs an, damit Entwickler ihre Anwendungen schützen können. Ihre Weiterleitungs-URIs müssen diesen Regeln entsprechen. In Abschnitt 3 von RFC 3986 finden Sie eine Definition für Domain, Host, Pfad, Abfrage, Schema und Nutzerinformationen.
Validierungsregeln | |
---|---|
Schema |
Weiterleitungs-URIs müssen das HTTPS-Schema und nicht das einfache HTTP verwenden. Localhost-URIs (einschließlich Localhost-IP-Adress-URIs) sind von dieser Regel ausgenommen. |
Organisator |
Hosts dürfen keine unformatierten IP-Adressen sein. Localhost-IP-Adressen sind von dieser Regel ausgenommen. |
Domain |
“googleusercontent.com” sein.goo.gl ) enthalten, es sei denn, die Domain ist der Anwendung. Wenn eine Anwendung mit einer Shortener-Domain an diese Domain weitergeleitet wird, muss der Weiterleitungs-URI entweder “/google-callback/” im Pfad enthalten oder mit “/google-callback” enden. |
Nutzerinformationen |
Weiterleitungs-URIs dürfen die Unterkomponente „Nutzerinformationen“ nicht enthalten. |
Pfad |
Weiterleitungs-URIs dürfen keinen Pfaddurchlauf (auch Verzeichnis-Backtracking genannt) enthalten, der durch |
Abfrage |
Weiterleitungs-URIs dürfen keine offenen Weiterleitungen enthalten. |
Fragment |
Weiterleitungs-URIs dürfen die Fragmentkomponente nicht enthalten. |
Zeichen |
Weiterleitungs-URIs dürfen folgende Zeichen nicht enthalten:
|
Inkrementelle Autorisierung
Im OAuth 2.0-Protokoll fordert Ihre Anwendung die Autorisierung für den Zugriff auf Ressourcen an, die durch Bereiche gekennzeichnet sind. Es hat sich bewährt, die Autorisierung für Ressourcen anzufordern, wenn Sie diese benötigen. Dazu unterstützt der Autorisierungsserver von Google die inkrementelle Autorisierung. Mit dieser Funktion können Sie Bereiche nach Bedarf anfordern. Wenn der Nutzer die Berechtigung für den neuen Bereich erteilt, wird ein Autorisierungscode zurückgegeben, der gegen ein Token ausgetauscht werden kann, das alle Bereiche enthält, die der Nutzer dem Projekt gewährt hat.
Angenommen, eine App hilft Nutzern, interessante lokale Ereignisse zu identifizieren. Mit der App können sich Nutzer Videos zu den Ereignissen ansehen, sie bewerten und Playlists zu Playlists hinzufügen. Nutzer können die App auch verwenden, um ihren Google-Kalendern Termine hinzuzufügen.
In diesem Fall benötigt die Anwendung zum Zeitpunkt der Anmeldung möglicherweise keinen Zugriff auf Bereiche und fordert auch keinen Zugriff darauf an. Wenn der Nutzer jedoch ein Video bewerten, einer Playlist ein Video hinzufügen oder eine andere YouTube-Aktion ausführen wollte, könnte die App Zugriff auf den Bereich https://www.googleapis.com/auth/youtube.force-ssl
anfordern.
Entsprechend könnte die Anwendung Zugriff auf den Bereich https://www.googleapis.com/auth/calendar
anfordern, wenn der Nutzer versucht, einen Kalendertermin hinzuzufügen.
Zum Implementieren der inkrementellen Autorisierung führen Sie den normalen Ablauf zum Anfordern eines Zugriffstokens aus. Achten Sie aber darauf, dass die Autorisierungsanfrage zuvor gewährte Bereiche enthält. Auf diese Weise entfällt die Verwaltung mehrerer Zugriffstokens für Ihre Anwendung.
Die folgenden Regeln gelten für ein Zugriffstoken, das über eine inkrementelle Autorisierung abgerufen wird:
- Das Token kann für den Zugriff auf Ressourcen verwendet werden, die einem der Bereiche entsprechen, die in die neue kombinierte Autorisierung gerollt werden.
- Wenn Sie das Aktualisierungstoken für die kombinierte Autorisierung verwenden, um ein Zugriffstoken abzurufen, stellt das Zugriffstoken die kombinierte Autorisierung dar und kann für jeden der in der Antwort enthaltenen
scope
-Werte verwendet werden. - Die kombinierte Autorisierung umfasst alle Bereiche, die der Nutzer dem API-Projekt gewährt hat, auch wenn die Berechtigungen von verschiedenen Clients angefordert wurden. Wenn ein Nutzer beispielsweise über den Desktopclient einer Anwendung Zugriff auf einen Bereich und dann über einen mobilen Client einem anderen Bereich gewährt hat, umfasst die kombinierte Autorisierung beide Bereiche.
- Wenn Sie ein Token widerrufen, das eine kombinierte Autorisierung darstellt, wird gleichzeitig der Zugriff auf alle Bereiche dieser Autorisierung im Namen des zugehörigen Nutzers widerrufen.
Für die sprachspezifischen Codebeispiele in Schritt 1: Autorisierungsparameter festlegen und die beispielhafte HTTP/REST-Weiterleitungs-URL in Schritt 2: Auf den OAuth 2.0-Server von Google weiterleiten wird die inkrementelle Autorisierung verwendet. Die Codebeispiele unten zeigen auch den Code, den Sie für die inkrementelle Autorisierung hinzufügen müssen.
PHP
$client->setIncludeGrantedScopes(true);
Python
Legen Sie in Python das Schlüsselwortargument include_granted_scopes
auf true
fest, damit eine Autorisierungsanfrage zuvor gewährte Bereiche enthält. Es ist gut möglich, dass include_granted_scopes
nicht das einzige Schlüsselwortargument ist, das Sie festlegen, wie im folgenden Beispiel gezeigt.
authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true')
Ruby
auth_client.update!( :additional_parameters => {"include_granted_scopes" => "true"} )
Node.js
const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true });
HTTP/REST
In diesem Beispiel fordert die aufrufende Anwendung zusätzlich zu jedem anderen Zugriff, den der Nutzer der Anwendung bereits gewährt hat, den Zugriff zum Abrufen der YouTube Analytics-Daten des Nutzers an.
GET https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly& access_type=offline& state=security_token%3D138rk%3Btarget_url%3Dhttp...index& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& response_type=code& client_id=client_id& include_granted_scopes=true
Refreshing an access token (offline access)
Access tokens periodically expire and become invalid credentials for a related API request. You can refresh an access token without prompting the user for permission (including when the user is not present) if you requested offline access to the scopes associated with the token.
- If you use a Google API Client Library, the client object refreshes the access token as needed as long as you configure that object for offline access.
- If you are not using a client library, you need to set the
access_type
HTTP query parameter tooffline
when redirecting the user to Google's OAuth 2.0 server. In that case, Google's authorization server returns a refresh token when you exchange an authorization code for an access token. Then, if the access token expires (or at any other time), you can use a refresh token to obtain a new access token.
Requesting offline access is a requirement for any application that needs to access a Google
API when the user is not present. For example, an app that performs backup services or
executes actions at predetermined times needs to be able to refresh its access token when the
user is not present. The default style of access is called online
.
Server-side web applications, installed applications, and devices all obtain refresh tokens during the authorization process. Refresh tokens are not typically used in client-side (JavaScript) web applications.
PHP
If your application needs offline access to a Google API, set the API client's access type to
offline
:
$client->setAccessType("offline");
Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie mit dem API-Client weiterhin im Namen des Nutzers auf Google APIs zugreifen, wenn der Nutzer offline ist. Das Clientobjekt aktualisiert das Zugriffstoken nach Bedarf.
Python
Legen Sie in Python das Schlüsselwortargument access_type
auf offline
fest, damit Sie das Zugriffstoken aktualisieren können, ohne beim Nutzer noch einmal eine Berechtigung anfordern zu müssen. Es ist gut möglich, dass access_type
nicht das einzige Schlüsselwortargument ist, das Sie festlegen, wie im folgenden Beispiel gezeigt.
authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true')
Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie mit dem API-Client weiterhin im Namen des Nutzers auf Google APIs zugreifen, wenn der Nutzer offline ist. Das Clientobjekt aktualisiert das Zugriffstoken nach Bedarf.
Ruby
Wenn die Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf offline
fest:
auth_client.update!( :additional_parameters => {"access_type" => "offline"} )
Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie mit dem API-Client weiterhin im Namen des Nutzers auf Google APIs zugreifen, wenn der Nutzer offline ist. Das Clientobjekt aktualisiert das Zugriffstoken nach Bedarf.
Node.js
Wenn die Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf offline
fest:
const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true });
Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie mit dem API-Client weiterhin im Namen des Nutzers auf Google APIs zugreifen, wenn der Nutzer offline ist. Das Clientobjekt aktualisiert das Zugriffstoken nach Bedarf.
Zugriffstokens laufen ab. Diese Bibliothek verwendet automatisch ein Aktualisierungstoken, um ein neues Zugriffstoken abzurufen, wenn es bald abläuft. Mit dem Token-Ereignis können Sie ganz einfach dafür sorgen, dass immer die neuesten Tokens gespeichert werden:
oauth2Client.on('tokens', (tokens) => { if (tokens.refresh_token) { // store the refresh_token in your secure persistent database console.log(tokens.refresh_token); } console.log(tokens.access_token); });
Dieses Tokenereignis tritt nur bei der ersten Autorisierung auf. Du musst access_type
auf offline
setzen, wenn du die Methode generateAuthUrl
aufrufst, um das Aktualisierungstoken zu empfangen. Wenn Sie Ihrer App die erforderlichen Berechtigungen bereits gewährt haben, ohne die entsprechenden Einschränkungen für den Empfang eines Aktualisierungstokens festzulegen, müssen Sie die Anwendung noch einmal autorisieren, um ein neues Aktualisierungstoken zu erhalten.
Wenn Sie die refresh_token
zu einem späteren Zeitpunkt festlegen möchten, können Sie die Methode setCredentials
verwenden:
oauth2Client.setCredentials({ refresh_token: `STORED_REFRESH_TOKEN` });
Sobald der Client ein Aktualisierungstoken hat, werden die Zugriffstokens abgerufen und beim nächsten Aufruf an die API automatisch aktualisiert.
HTTP/REST
Zum Aktualisieren eines Zugriffstokens sendet Ihre Anwendung eine HTTPS-POST
-Anfrage an den Autorisierungsserver von Google (https://oauth2.googleapis.com/token
) mit den folgenden Parametern:
Felder | |
---|---|
client_id |
Die Client-ID, die von der API Consoleabgerufen wird. |
client_secret |
Der von API Consoleabgerufene Clientschlüssel. |
grant_type |
Wie in der OAuth 2.0-Spezifikation definiert, muss der Wert dieses Felds auf refresh_token festgelegt sein. |
refresh_token |
Das vom Autorisierungscode-Austausch zurückgegebene Aktualisierungstoken. |
Das folgende Snippet zeigt eine Beispielanfrage:
POST /token HTTP/1.1 Host: oauth2.googleapis.com Content-Type: application/x-www-form-urlencoded client_id=your_client_id& client_secret=your_client_secret& refresh_token=refresh_token& grant_type=refresh_token
Solange der Nutzer den der Anwendung gewährten Zugriff nicht widerrufen hat, gibt der Tokenserver ein JSON-Objekt zurück, das ein neues Zugriffstoken enthält. Das folgende Snippet zeigt eine Beispielantwort:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "token_type": "Bearer" }
Beachten Sie, dass es Limits für die Anzahl der ausgegebenen Aktualisierungstokens gibt: ein Limit pro Client/Nutzer-Kombination und ein weiteres pro Nutzer für alle Clients. Sie sollten Aktualisierungstokens langfristig speichern und so lange verwenden, wie sie gültig sind. Wenn Ihre Anwendung zu viele Aktualisierungstokens anfordert, kann diese Grenze überschritten werden. In diesem Fall funktionieren ältere Aktualisierungstokens nicht mehr.
Token widerrufen
In einigen Fällen möchte ein Nutzer den Zugriff auf eine Anwendung widerrufen. Nutzer können den Zugriff in den Kontoeinstellungen widerrufen. Weitere Informationen finden Sie im Supportdokument zu Websites und Apps von Drittanbietern mit Zugriff auf Ihr Konto im Abschnitt Zugriff auf Websites oder Apps entfernen.
Es ist auch möglich, den Zugriff einer Anwendung programmatisch zu widerrufen. Der programmatische Widerruf ist in Fällen wichtig, in denen ein Nutzer das Abo beendet oder eine Anwendung entfernt oder sich die für eine Anwendung erforderlichen API-Ressourcen erheblich geändert haben. Mit anderen Worten: Ein Teil des Entfernungsprozesses kann eine API-Anfrage umfassen, mit der sichergestellt wird, dass die der Anwendung zuvor gewährten Berechtigungen entfernt werden.
PHP
Wenn Sie ein Token programmatisch widerrufen möchten, rufen Sie revokeToken()
auf:
$client->revokeToken();
Python
Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine Anfrage an https://oauth2.googleapis.com/revoke
, die das Token als Parameter enthält und den Content-Type
-Header festlegt:
requests.post('https://oauth2.googleapis.com/revoke', params={'token': credentials.token}, headers = {'content-type': 'application/x-www-form-urlencoded'})
Ruby
Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine HTTP-Anfrage an den Endpunkt oauth2.revoke
:
uri = URI('https://oauth2.googleapis.com/revoke') response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)
Das Token kann ein Zugriffstoken oder ein Aktualisierungstoken sein. Wenn das Token ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken hat, wird auch das Aktualisierungstoken widerrufen.
Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der Statuscode der Antwort 200
. Bei Fehlerbedingungen wird der Statuscode 400
zusammen mit einem Fehlercode zurückgegeben.
Node.js
Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine HTTPS-POST-Anfrage an den Endpunkt /revoke
:
const https = require('https'); // Build the string for the POST request let postData = "token=" + userCredential.access_token; // Options for POST request to Google's OAuth 2.0 server to revoke a token let postOptions = { host: 'oauth2.googleapis.com', port: '443', path: '/revoke', method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(postData) } }; // Set up the request const postReq = https.request(postOptions, function (res) { res.setEncoding('utf8'); res.on('data', d => { console.log('Response: ' + d); }); }); postReq.on('error', error => { console.log(error) }); // Post the request with data postReq.write(postData); postReq.end();
Der Tokenparameter kann ein Zugriffstoken oder ein Aktualisierungstoken sein. Wenn das Token ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken hat, wird auch das Aktualisierungstoken widerrufen.
Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der Statuscode der Antwort 200
. Bei Fehlerbedingungen wird der Statuscode 400
zusammen mit einem Fehlercode zurückgegeben.
HTTP/REST
Wenn Sie ein Token programmatisch widerrufen möchten, stellt Ihre Anwendung eine Anfrage an https://oauth2.googleapis.com/revoke
und fügt das Token als Parameter ein:
curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \ https://oauth2.googleapis.com/revoke?token={token}
Das Token kann ein Zugriffstoken oder ein Aktualisierungstoken sein. Wenn das Token ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken hat, wird auch das Aktualisierungstoken widerrufen.
Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der HTTP-Statuscode der Antwort 200
. Bei Fehlerbedingungen wird der HTTP-Statuscode 400
zusammen mit einem Fehlercode zurückgegeben.