In diesem Dokument wird erläutert, wie Webserveranwendungen Google API-Clientbibliotheken oder Google OAuth 2.0-Endpunkte zur Implementierung der OAuth 2.0-Zugriffsberechtigung der YouTube Data API.
Mit OAuth 2.0 können Nutzer bestimmte Daten für eine Anwendung freigeben, Nutzernamen, Passwörter und andere Informationen privat bleiben. Eine Anwendung kann beispielsweise OAuth 2.0 verwenden, um eine Berechtigung anzufordern. um die YouTube-Daten eines Kanals abzurufen.
Dieser OAuth 2.0-Vorgang bezieht sich speziell auf die Nutzerautorisierung. Es wurde für Anwendungen entwickelt, die vertrauliche Informationen speichern und den Status bewahren können. Ein ordnungsgemäß autorisierter Webserver Anwendung auf eine API zugreifen kann, während der Nutzer mit der Anwendung oder nach dem Nutzer interagiert hat die Anwendung verlassen.
Webserver-Anwendungen verwenden häufig auch Dienstkonten verwenden, um API-Anfragen zu autorisieren, insbesondere beim Aufrufen von Cloud APIs für den Zugriff und nicht auf benutzerspezifische Daten. Webserveranwendungen können den Dienst Konten in Verbindung mit der Nutzerautorisierung verwenden.
Die YouTube Live Streaming API unterstützt den Dienstkontoablauf nicht. Da es keine Möglichkeit gibt,
ein Dienstkonto mit einem YouTube-Konto zu verknüpfen,
Einen NoLinkedYouTubeAccount
-Fehler generieren.
Clientbibliotheken
Die sprachspezifischen Beispiele auf dieser Seite verwenden Google API-Clientbibliotheken OAuth 2.0-Autorisierung Zum Ausführen der Codebeispiele müssen Sie zuerst den Clientbibliothek für Ihre Sprache.
Wenn Sie eine Google API-Clientbibliothek verwenden, um den OAuth 2.0-Vorgang Ihrer Anwendung zu verarbeiten, führt viele Aktionen aus, die die Anwendung andernfalls selbst ausführen müsste. Für Damit wird bestimmt, wann die Anwendung gespeicherte Zugriffstokens sowie wann die Anwendung erneut die Einwilligung einholen muss. Die Clientbibliothek generiert auch richtige Weiterleitungen, URLs und hilft bei der Implementierung von Weiterleitungs-Handlern, die Autorisierungscodes gegen Zugriffstoken austauschen.
Google API-Clientbibliotheken für serverseitige Anwendungen sind in den folgenden Sprachen verfügbar:
Vorbereitung
Die APIs für Ihr Projekt aktivieren
Jede Anwendung, die Google APIs aufruft, muss diese APIs im API Console
So aktivieren Sie eine API für Ihr Projekt:
- Open the API Library in den Google API Console.
- If prompted, select a project, or create a new one.
- Auf der Seite „Mediathek“ kannst du die YouTube Data API finden und aktivieren. Suchen Sie nach weiteren APIs, die Ihre Anwendung verwenden wird, 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, muss über Anmeldedaten zur Autorisierung verfügen. über die die Anwendung beim OAuth 2.0-Server von Google identifiziert wird. 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. Anwendungen, die Programmiersprachen und Frameworks verwenden
wie PHP, Java, Python, Ruby und .NET 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 vor diesem Hintergrund, dass alle In den Beispielen in diesem Dokument wirdhttp://localhost:8080
als Weiterleitungs-URI verwendet.Wir empfehlen Ihnen, die Authentifizierungsendpunkte Ihrer App so zu gestalten, dass Ihre Anwendung keine Autorisierungscodes für andere Ressourcen auf der Seite.
Laden Sie nach dem Erstellen Ihrer Anmeldedaten die Datei client_secret.json aus dem API ConsoleSpeichern Sie die Datei sicher an einem Ort, auf die Ihre Anwendung zugreifen kann.
Zugriffsbereiche identifizieren
Mithilfe von Bereichen kann Ihre Anwendung nur Zugriff auf die benötigten Ressourcen anfordern. So können Nutzer den Umfang des Zugriffs, den sie auf Ihre Anwendung gewähren, steuern. Das heißt, es gibt kann eine inverse Beziehung zwischen der Anzahl der angeforderten Zugriffsbereiche und der Wahrscheinlichkeit Einholen der Nutzereinwilligung
Bevor Sie mit der Implementierung der OAuth 2.0-Autorisierung beginnen, sollten Sie die Bereiche identifizieren auf die deine App eine Zugriffsberechtigung benötigt.
Wir empfehlen außerdem, dass Ihre Anwendung den Zugriff auf Autorisierungsbereiche über eine inkrementelle Autorisierung, bei der Ihre Anwendung fordert Zugriff auf Nutzerdaten im Kontext an. Diese Best Practice hilft Nutzenden, die 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 eine 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 die Internet und einen Webbrowser. Wenn Sie eine der API-Clientbibliotheken verwenden, lesen Sie auch die sprachspezifischen Anforderungen zu erfüllen.
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 Paketverwaltungstool pip.
- 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
Sie müssen keine Bibliotheken installieren, um OAuth 2.0 direkt aufrufen zu können. Endpunkten.
OAuth 2.0-Zugriffstokens abrufen
Die folgenden Schritte zeigen, wie Ihre Anwendung mit dem OAuth 2.0-Server von Google interagiert, um Zustimmung des Nutzers, eine API-Anfrage im Namen des Nutzers auszuführen. Ihre App muss Folgendes enthalten: Einwilligung erteilen, bevor eine Google API-Anfrage ausgeführt werden kann, die eine Nutzerautorisierung erfordert.
Die folgende Liste fasst diese Schritte kurz zusammen:
- Ihre Anwendung ermittelt die erforderlichen Berechtigungen.
- Der Nutzer wird von Ihrer Anwendung zusammen mit der Liste der angeforderten Dokumente an Google weitergeleitet. Berechtigungen.
- 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 ausführen
Schritt 1: Autorisierungsparameter festlegen
Als Erstes erstellen Sie die Autorisierungsanfrage. Diese Anfrage legt Parameter fest, Ihre Anwendung identifizieren und die Berechtigungen definieren, denen der Nutzer Ihre Anwendung.
- Wenn Sie eine Google-Clientbibliothek für die OAuth 2.0-Authentifizierung und -Autorisierung verwenden, ein Objekt erstellen und konfigurieren, das diese Parameter definiert.
- Wenn Sie den Google OAuth 2.0-Endpunkt direkt aufrufen, generieren Sie eine URL und legen den Parameter für diese URL.
Die unten aufgeführten Registerkarten definieren die unterstützten Autorisierungsparameter für Webserveranwendungen. Die sprachspezifische Beispiele zeigen auch, wie Sie mit einer Client-Bibliothek oder Autorisierungsbibliothek Konfigurieren Sie ein Objekt, das diese Parameter festlegt.
PHP
Das folgende Code-Snippet erstellt ein Google\Client()
-Objekt, das die
-Parameter in der Autorisierungsanfrage.
Das Objekt verwendet Informationen aus der Datei client_secret.json, um Ihr
. (Weitere Informationen finden Sie unter Anmeldedaten erstellen.
dieser Datei.) Das Objekt identifiziert auch die Bereiche, die Ihre Anwendung Berechtigungen anfordert
für den Zugriff und die URL zum Authentifizierungsendpunkt Ihrer Anwendung, der die Antwort von
OAuth 2.0-Server von Google Schließlich legt der Code die optionalen access_type
- und
include_granted_scopes
-Parameter.
So fordern Sie beispielsweise Offlinezugriff an, um die YouTube-Daten eines Nutzers abzurufen:
$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
Im folgenden Code-Snippet wird das Modul google-auth-oauthlib.flow
verwendet, um
in der Autorisierungsanfrage.
Der Code erstellt ein Flow
-Objekt, das Ihre Anwendung mithilfe von
aus der Datei client_secret.json, die Sie nach dem Herunterladen
Anmeldedaten für die Autorisierung erstellen. Dieses Objekt identifiziert auch den
Bereiche, für die Ihre Anwendung die Berechtigung anfordert, sowie die URL zum
auth-Endpunkt, der die Antwort des OAuth 2.0-Servers von Google verarbeitet. Der Code
legt die optionalen Parameter access_type
und include_granted_scopes
fest.
So fordern Sie beispielsweise Offlinezugriff an, um die YouTube-Daten eines Nutzers abzurufen:
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 mithilfe der von Ihnen erstellten Datei „client_secrets.json“ ein Clientobjekt in Ihrem . Beim Konfigurieren eines Clientobjekts geben Sie die Bereiche an, -Zugriff sowie die URL zum Authentifizierungsendpunkt Ihrer Anwendung, an dem die Antwort verarbeitet wird. vom OAuth 2.0-Server gesendet werden.
So fordern Sie beispielsweise Offlinezugriff an, um die YouTube-Daten eines Nutzers abzurufen:
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. das Generieren von Autorisierungsanforderungs-URLs und Anwenden von Zugriffstokens auf HTTP-Anfragen
Node.js
Mit dem folgenden Code-Snippet wird ein google.auth.OAuth2
-Objekt erstellt, das die
-Parameter in der Autorisierungsanfrage.
Dieses Objekt verwendet Informationen aus Ihrer Datei client_secret.json, um Ihre Anwendung zu identifizieren. Bis Sie um Berechtigungen zum Abrufen eines Zugriffstokens von einem Nutzer bitten, leiten Sie ihn auf eine Zustimmungsseite 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 beim ersten
Autorisierung. Mehr Details
<ph type="x-smartling-placeholder"></ph>
hier.
HTTP/REST
Der OAuth 2.0-Endpunkt von Google befindet sich bei https://accounts.google.com/o/oauth2/v2/auth
. Dieses
Auf den Endpunkt kann nur über HTTPS zugegriffen werden. Einfache HTTP-Verbindungen werden abgelehnt.
Der Google-Autorisierungsserver unterstützt die folgenden Abfragestringparameter für das Web Serveranwendungen:
Parameter | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
client_id |
Erforderlich
Die Client-ID für Ihre Anwendung. Sie finden diesen Wert in der API Console Credentials page. |
||||||||||||||||
redirect_uri |
Erforderlich
Bestimmt, wohin der API-Server den Nutzer weiterleitet, nachdem der Nutzer das
Autorisierungsablauf. Der Wert muss genau mit einem der autorisierten Weiterleitungs-URIs für
den OAuth 2.0-Client, den Sie im Client
API Console
Credentials page. Stimmt dieser Wert nicht mit einem
autorisierten Weiterleitungs-URI für die angegebene Beachten Sie, dass 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
A durch Leerzeichen getrennt Liste mit Bereichen zur Identifizierung der Ressourcen, auf die Ihre Anwendung im im Namen des Nutzers. Diese Werte bilden die Grundlage für den Zustimmungsbildschirm, den Google den Nutzern anzeigt. Nutzer. Mithilfe von Bereichen kann Ihre Anwendung nur Zugriff auf die benötigten Ressourcen anfordern Gleichzeitig können die Nutzer steuern, wie viel Zugriff sie auf Ihre . Daher besteht eine inverse Beziehung zwischen der Anzahl der angeforderten Bereiche und wie wahrscheinlich es ist, Nutzereinwilligungen einzuholen. Für Version 3 der YouTube Data API werden die folgenden Umfänge verwendet:
Das Dokument OAuth 2.0 API-Bereiche enthält Informationen zu 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 im Kontext anfordert wenn möglich. Indem der Zugriff auf Nutzerdaten im Kontext angefordert wird, über inkrementelle Autorisierung können Sie den Nutzern warum Ihre Anwendung den angeforderten Zugriff benötigt. |
||||||||||||||||
access_type |
Empfohlen
Gibt an, ob Ihre Anwendung Zugriffstokens aktualisieren kann, wenn der Nutzer nicht anwesend ist
im Browser. Gültige Parameterwerte sind Legen Sie den Wert auf |
||||||||||||||||
state |
Empfohlen
Gibt einen String-Wert an, mit dem Ihre Anwendung den Status zwischen Ihren
Autorisierungsanfrage und
die Antwort des Autorisierungsservers.
Der Server gibt genau den Wert zurück, den Sie als Sie können diesen Parameter für verschiedene Zwecke verwenden, z. B. um den Nutzer zum
richtige Ressource in Ihrer Anwendung zu finden, Nonces zu senden und websiteübergreifende Anfragen zu reduzieren
Fälschung. Da Ihr |
||||||||||||||||
include_granted_scopes |
Optional
Ermöglicht es Anwendungen, die inkrementelle Autorisierung zu nutzen, um Zugriff auf zusätzliche
Bereiche im Kontext. Wenn Sie den Wert dieses Parameters auf |
||||||||||||||||
enable_granular_consent |
Optional
Die Standardeinstellung ist Wenn Google detaillierte Berechtigungen für eine Anwendung aktiviert, führt dieser Parameter nicht dazu, Wirkung zeigen. |
||||||||||||||||
login_hint |
Optional
Wenn Ihre Anwendung erkennt, welcher Nutzer sich authentifizieren möchte, kann sie diesen Parameter verwenden. ein, um dem Google-Authentifizierungsserver einen Hinweis zu geben. Der Server verwendet den Hinweis, den Anmeldevorgang vereinfachen, indem Sie entweder das E-Mail-Feld im Anmeldeformular vorab ausfüllen oder die entsprechende Mehrfachanmeldung aus. Legen Sie als Parameterwert eine E-Mail-Adresse oder |
||||||||||||||||
prompt |
Optional
Eine durch Leerzeichen getrennte Liste von Eingabeaufforderungen, die dem Nutzer angezeigt werden. Beachten Sie dabei die Groß- und Kleinschreibung. Wenn Sie keine Wenn Sie diesen Parameter angeben, wird der Nutzer nur beim ersten Mal zur Ausführung Ihres Projekts aufgefordert. fordert Zugriff an. Weitere Informationen finden Sie unter . Bitte um die erneute Einwilligung. Folgende Werte sind möglich:
|
Schritt 2: Weiterleitung zum OAuth 2.0-Server von Google
den Nutzer zum OAuth 2.0-Server von Google weiterleiten, um die Authentifizierung zu starten, und Autorisierungsprozess. Dies geschieht in der Regel, wenn Ihre Anwendung zum ersten Mal auf den Daten der Nutzenden. Bei einer inkrementellen Autorisierung wenn Ihre Anwendung zuerst auf zusätzliche Ressourcen zugreifen muss, haben noch keine Zugriffsberechtigung.
PHP
- Generieren Sie eine URL, um den Zugriff vom OAuth 2.0-Server von Google anzufordern:
$auth_url = $client->createAuthUrl();
- Leite den Nutzer an
$auth_url
weiter:header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
Python
In diesem Beispiel wird gezeigt, wie der Nutzer über das Flask-Web zur Autorisierungs-URL weitergeleitet wird Anwendungsframework:
return flask.redirect(authorization_url)
Ruby
- Generieren Sie 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 Schritt 1generateAuthUrl
, um den Zugriff vom OAuth 2.0-Server von Google anzufordern. -
Leite den Nutzer zu
authorizationUrl
weiter.res.redirect(authorizationUrl);
HTTP/REST
Beispiel für eine Weiterleitung zum Autorisierungsserver von Google
Im Folgenden sehen Sie eine Beispiel-URL mit Zeilenumbrüchen und Leerzeichen zur besseren Lesbarkeit. Die URL-Anfragen
Zugriff auf einen Bereich, der den Zugriff zum Abrufen der YouTube-Daten des Nutzers ermöglicht. Es werden inkrementelle
Autorisierung (include_granted_scopes=true
), um sicherzustellen, dass das neue Zugriffstoken
deckt alle Bereiche ab, auf die der Nutzer zuvor der Anwendung Zugriff gewährt hat. Mehrere weitere
werden im Beispiel ebenfalls festgelegt.
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.force-ssl& access_type=offline& include_granted_scopes=true& response_type=code& state=state_parameter_passthrough_value& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& 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 Zustimmung des Nutzers für Ihre Anwendung, um auf die angeforderten Bereiche zuzugreifen. Die Antwort wird an Ihre Anwendung zurückgesendet unter Verwendung der von Ihnen angegebenen Weiterleitungs-URL.
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 angezeigt wird, zeigt Google ein Einwilligungsfenster an, in dem der Name Ihrer Anwendung und die Google API Dienste, für die er die Berechtigung zum Zugriff mit den Autorisierungsanmeldedaten des Nutzers anfordert, und Eine Zusammenfassung der Zugriffsbereiche, die gewährt werden sollen. Die kann der Nutzer zustimmen, um Zugriff auf einen oder mehrere Bereiche zu gewähren, die von Ihrer Anwendung angefordert oder die Anfrage ablehnen.
Ihre Anwendung muss in dieser Phase nichts weiter tun, da sie auf die Antwort von OAuth 2.0-Server von Google gibt an, ob Zugriff gewährt wurde. Diese Antwort wird in folgenden Schritt ausführen.
Fehler
Bei Anfragen an den OAuth 2.0-Autorisierungsendpunkt von Google können nutzerseitige Fehlermeldungen angezeigt werden statt der erwarteten Authentifizierungs- und Autorisierungsabläufe. Häufige Fehlercodes und Vorschläge Lösungen finden Sie unten.
admin_policy_enforced
Das Google-Konto kann einen oder mehrere Bereiche, die aufgrund der Richtlinien von angefordert werden, nicht autorisieren. Ihrem Google Workspace-Administrator. Google Workspace-Admin-Hilfeartikel lesen <ph type="x-smartling-placeholder"></ph> Festlegen, welche Drittanbieter- und Interne Apps greifen auf Google Workspace-Daten zu. finden Sie weitere Informationen dazu, wie ein Administrator den Zugriff auf alle Bereiche oder vertrauliche und eingeschränkten Bereichen, bis ausdrücklich Zugriff auf Ihre OAuth-Client-ID gewährt wird.
disallowed_useragent
Der Autorisierungsendpunkt wird in einem eingebetteten User-Agent angezeigt, der vom OAuth 2.0-Richtlinien
Android
Android-Entwicklern kann diese Fehlermeldung angezeigt werden, wenn sie Autorisierungsanfragen in
android.webkit.WebView
Entwickler sollten stattdessen Android-Bibliotheken wie
Google Log-in für Android oder OpenID Foundation
AppAuth für Android
Bei Webentwicklern kann dieser Fehler auftreten, wenn eine Android-App einen allgemeinen Weblink in einem eingebetteter User-Agent und ein Nutzer navigiert von Googles OAuth 2.0-Autorisierungsendpunkt für Ihre Website. Entwickler sollten das Öffnen allgemeiner Links im Standard-Link-Handler der Betriebssystem, das sowohl Android-App-Links oder der Standard-Browser-App. Die Benutzerdefinierte Tabs für Android ist ebenfalls eine unterstützte Option.
iOS
Bei iOS- und macOS-Entwicklern kann dieser Fehler auftreten, wenn Autorisierungsanfragen in
WKWebView
Entwickler sollten stattdessen iOS-Bibliotheken wie
Google Log-in für iOS oder OpenID Foundation
AppAuth für iOS
Bei Webentwicklern kann dieser Fehler auftreten, wenn eine iOS- oder macOS-App einen allgemeinen Weblink in
einem eingebetteten User-Agent und ein Nutzer navigiert von Googles OAuth 2.0-Autorisierungsendpunkt
für Ihre Website. Entwickler sollten das Öffnen allgemeiner Links im Standard-Link-Handler der
Betriebssystem, das sowohl
Universelle Links
oder der Standard-Browser-App. Die
SFSafariViewController
ist ebenfalls eine unterstützte Option.
org_internal
Die OAuth-Client-ID in der Anfrage ist Teil eines Projekts, das den Zugriff auf Google-Konten in einem spezifisch <ph type="x-smartling-placeholder"></ph> Google Cloud-Organisation. Weitere Informationen zu dieser Konfigurationsoption finden Sie in der Nutzertyp im Hilfeartikel OAuth-Zustimmungsbildschirm einrichten.
invalid_client
Der OAuth-Clientschlüssel ist falsch. Lesen Sie die OAuth-Client Konfiguration, einschließlich der für diese Anfrage verwendeten Client-ID und des Secrets.
invalid_grant
Beim Aktualisieren eines Zugriffstokens oder bei Verwendung von inkrementelle Autorisierung: Das Token ist möglicherweise abgelaufen oder wurde für ungültig erklärt wurden. Authentifizieren Sie den Nutzer noch einmal und bitten Sie um seine Einwilligung, um neue Tokens zu erhalten. Wenn Sie fortfahren Um diesen Fehler zu sehen, vergewissern Sie sich, dass Ihre Anwendung richtig konfiguriert ist und Verwenden Sie in Ihrer Anfrage die richtigen Tokens und Parameter. Andernfalls hat das Nutzerkonto möglicherweise gelöscht oder deaktiviert wurden.
redirect_uri_mismatch
Die in der Autorisierungsanfrage übergebene redirect_uri
stimmt mit keinem autorisierten
Weiterleitungs-URI für die OAuth-Client-ID. Überprüfen Sie die autorisierten Weiterleitungs-URIs in der
Google API Console Credentials page
Der Parameter redirect_uri
kann sich auf den OAuth-Out-of-Band-Vorgang (OOB) beziehen, der eine
und wird nicht mehr unterstützt. Weitere Informationen finden Sie im
Migrationsanleitung, um Ihre
invalid_request
Mit deiner Anfrage ist ein Fehler aufgetreten. Dafür kann es verschiedene 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. OAuth bestätigen Für die Integration wird eine empfohlene Integrationsmethode verwendet.
Schritt 4: Die Antwort des OAuth 2.0-Servers verarbeiten
Der OAuth 2.0-Server antwortet auf die Zugriffsanfrage Ihrer Anwendung mit der angegebenen URL in der Anfrage.
Wenn der Nutzer die Zugriffsanfrage genehmigt, enthält die Antwort einen Autorisierungscode. Wenn Wenn der Nutzer die Anfrage nicht genehmigt, enthält die Antwort eine Fehlermeldung. Die Autorisierungscode oder Fehlermeldung, die an den Webserver zurückgegeben wird, erscheint in der Anfrage wie unten dargestellt:
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, die Anfragen Lesezugriff auf Metadaten für Dateien in Google Drive:
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.force-ssl& access_type=offline& include_granted_scopes=true& response_type=code& state=state_parameter_passthrough_value& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& client_id=client_id
Nach Abschluss des OAuth 2.0-Vorgangs werden Sie zu folgender URL weitergeleitet:
http://localhost/oauth2callback
, was wahrscheinlich zu einem
404 NOT FOUND
-Fehler, es sei denn, Ihr lokaler Computer stellt unter dieser Adresse eine Datei bereit. Die
Der nächste Schritt enthält weitere Details zu den Informationen, die im URI zurückgegeben werden, wenn der Nutzer
zu Ihrer Anwendung zurückgeleitet.
Schritt 5: Autorisierungscode gegen Aktualisierung und Zugriff austauschen Tokens
Nachdem der Webserver den Autorisierungscode erhalten hat, kann er den Autorisierungscode austauschen um ein Zugriffstoken zu erhalten.
PHP
Verwende die authenticate
, um einen Autorisierungscode gegen ein Zugriffstoken auszutauschen
:
$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 Autorisierung zu bestätigen
Serverantwort. Tauschen Sie dann die Autorisierung mit der Methode flow.fetch_token
aus.
Code in dieser Antwort für ein Zugriffstoken:
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 den Autorisierungsserver zu überprüfen
Antwort. Verwenden Sie die Methode authorizer.handle_auth_callback_deferred
, um den
und kehren zu der URL zurück, die die Autorisierung ursprünglich angefordert hat. Dieses
den Austausch des Codes hinauszögern, indem die Ergebnisse vorübergehend in der Sitzung des Nutzers zwischengespeichert werden.
target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url
Node.js
Verwende die getToken
, um einen Autorisierungscode gegen ein Zugriffstoken auszutauschen
:
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 zum Austausch eines Autorisierungscodes gegen ein Zugriffstoken die Methode
https://oauth2.googleapis.com/token
und legen Sie die folgenden Parameter fest:
Felder | |
---|---|
client_id |
Die Client-ID aus dem API Console Credentials page. |
client_secret |
Der von API Consoleabgerufene Clientschlüssel Credentials page. |
code |
Der Autorisierungscode, der von der ursprünglichen Anfrage zurückgegeben wurde. |
grant_type |
Wie in OAuth 2.0 definiert
Spezifikation, muss der Wert dieses Felds auf authorization_code festgelegt sein. |
redirect_uri |
Einer der Weiterleitungs-URIs, die für Ihr Projekt im
API Console
Credentials page für das angegebene
client_id |
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 einen kurzlebigen Zugriff enthält.
und ein Aktualisierungstoken.
Beachten Sie, dass das Aktualisierungstoken nur zurückgegeben wird, wenn Ihre Anwendung den access_type
festgelegt hat.
offline
in der ursprünglichen Anfrage an die
Autorisierungsserver.
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 zum
Der Nutzer widerruft den Zugriff.
Dieses Feld ist in dieser Antwort nur vorhanden, wenn Sie den access_type
in der ersten Anfrage an den Autorisierungsserver von Google auf offline gesetzt.
|
scope |
Die von access_token gewährten Zugriffsbereiche als Liste von
Durch Leerzeichen getrennte Zeichenfolgen, bei denen die Groß-/Kleinschreibung zu beachten ist. |
token_type |
Der Typ des zurückgegebenen Tokens. Derzeit ist der Wert dieses Felds immer auf
Bearer |
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
Beim Austausch des Autorisierungscodes gegen ein Zugriffstoken kann Folgendes auftreten: und nicht der erwarteten Antwort. Häufige Fehlercodes und Lösungsvorschläge sind (siehe unten).
invalid_grant
Der angegebene Autorisierungscode ist ungültig oder hat das falsche Format. Fordern Sie einen neuen Code bis zum Starten des OAuth-Prozesses, um den Nutzer um seine Zustimmung zu bitten noch einmal.
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 beispielsweise das Zugriffstoken in einer Nutzersitzung gespeichert haben, verwenden Sie die MethodesetAccessToken
-Methode:$client->setAccessToken($access_token);
- Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Sie erstellen ein Dienstobjekt, indem Sie
Bereitstellung eines autorisierten
Google\Client
-Objekts für den Konstruktor für die API die Sie anrufen möchten. So rufst du beispielsweise die YouTube Data API auf:$youtube = new Google_Service_YouTube($client);
- Stellen Sie Anfragen an den API-Dienst mithilfe der
Schnittstelle, die vom Dienstobjekt bereitgestellt wird.
Um beispielsweise das YouTube Data API zu verwenden, um eine Liste von Liveübertragungen für den authentifizierten Nutzer abzurufen,
Kanal des Nutzers:
$broadcasts = $youtube->liveBroadcasts->listLiveBroadcasts('id,snippet', [ 'mine' => true ]);
Python
Nach Erhalt eines Zugriffstokens kann Ihre Anwendung dieses Token zur Autorisierung von API-Anfragen auf im Namen eines bestimmten Nutzerkontos oder Dienstkontos. Nutzerspezifische Anmeldedaten für die Autorisierung verwenden um ein Dienstobjekt für die aufzurufende API zu erstellen, und verwenden dieses Objekt dann, um autorisierten API-Anfragen an.
- Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Sie erstellen ein Dienstobjekt, indem Sie
durch Aufrufen der
build
-Methode dergoogleapiclient.discovery
-Bibliothek mit dem Name und Version der API sowie die Nutzeranmeldedaten: So rufst du beispielsweise Version 3 der YouTube Data API auf:from googleapiclient.discovery import build youtube = build('youtube', 'v3', credentials=credentials)
- Stellen Sie Anfragen an den API-Dienst mithilfe der
Schnittstelle, die vom Dienstobjekt bereitgestellt wird.
Um beispielsweise das YouTube Data API zu verwenden, um eine Liste von Liveübertragungen für den authentifizierten Nutzer abzurufen,
Kanal des Nutzers:
broadcasts = youtube.liveBroadcasts().list(part='id,snippet', mine=True).execute()
Ruby
Nach Erhalt eines Zugriffstokens kann Ihre Anwendung dieses Token verwenden, um API-Anfragen an im Namen eines bestimmten Nutzerkontos oder Dienstkontos. Nutzerspezifische Anmeldedaten für die Autorisierung verwenden um ein Dienstobjekt für die aufzurufende API zu erstellen, und verwenden dieses Objekt dann, um autorisierten API-Anfragen an.
- 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
- Stellen Sie Anfragen an den API-Dienst mithilfe der
Benutzeroberfläche
vom Dienstobjekt bereitgestellt.
Um beispielsweise das YouTube Data API zu verwenden, um eine Liste von Liveübertragungen für den authentifizierten Nutzer abzurufen,
Kanal des Nutzers:
broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)
Alternativ kann die Autorisierung für einzelne Methoden bereitgestellt werden, indem das Schlüssel/Wert-Paar
options
-Parameter einer Methode zu:
broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)
Node.js
Nachdem Sie ein Zugriffstoken abgerufen und auf das OAuth2
-Objekt festgelegt haben, verwenden Sie das Objekt
zum Aufrufen von Google APIs. Ihre Anwendung kann dieses Token verwenden, um API-Anfragen im Namen von
einem bestimmten Benutzer- oder Dienstkonto. 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 erhalten hat, können Sie mit diesem Token Aufrufe an eine Google
API für eine bestimmte
Nutzerkonto, wenn die von der API erforderlichen Zugriffsbereiche gewährt wurden. Fügen Sie dazu
Das Zugriffstoken in einer Anfrage an die API durch Einfügen einer access_token
-Abfrage
oder einen Bearer
-Wert für den Authorization
-HTTP-Header. Wenn möglich,
der HTTP-Header ist zu bevorzugen, da Abfragezeichenfolgen in Serverprotokollen in der Regel sichtbar sind. In den meisten
können Sie Aufrufe von Google APIs mithilfe einer Clientbibliothek einrichten (z. B.
YouTube Live Streaming API aufrufen.
Beachte, dass die YouTube Live Streaming API den Dienstkontovorgang nicht unterstützt. Da wir
ist keine Möglichkeit, ein Dienstkonto mit einem YouTube-Konto zu verknüpfen,
generiert den Fehler NoLinkedYouTubeAccount
.
Sie können alle Google APIs testen und ihre Bereiche auf der OAuth 2.0 Playground.
Beispiele für HTTP GET
Ein Aufruf an die
<ph type="x-smartling-placeholder"></ph>
liveBroadcasts.list
.
(YouTube Live Streaming API) über das Authorization: Bearer
-HTTP-Protokoll.
könnte wie folgt aussehen. Beachten Sie, dass Sie Ihr eigenes Zugriffstoken angeben müssen:
GET /youtube/v3/liveBroadcasts?part=id%2Csnippet&mine=true HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
Im Folgenden sehen Sie einen Aufruf derselben API für den authentifizierten Nutzer mithilfe der access_token
Abfragestringparameter:
GET https://www.googleapis.com/youtube/v3/liveBroadcasts?access_token=access_token&part=id%2Csnippet&mine=true
Beispiele für curl
Sie können diese Befehle mit der curl
-Befehlszeilenanwendung testen. Hier ist ein
Beispiel mit HTTP-Header-Option (bevorzugt):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/liveBroadcasts?part=id%2Csnippet&mine=true
Alternativ können Sie die Parameteroption für den Abfragestring verwenden:
curl https://www.googleapis.com/youtube/v3/liveBroadcasts?access_token=access_token&part=id%2Csnippet&mine=true
Vollständiges Beispiel
Im folgenden Beispiel wird ein Objekt im JSON-Format mit Liveübertragungen ausgegeben für den YouTube-Kanal des authentifizierten Nutzers, nachdem der Nutzer um diese Daten abzurufen.
PHP
So führen Sie das Beispiel aus:
- Fügen Sie im API Consoledie URL des lokalen Computers zum
Liste mit Weiterleitungs-URLs. Fügen Sie beispielsweise
http://localhost:8080
hinzu. - Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Beispiel:
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- Google API-Client installieren
Bibliothek für PHP mit Composer verwenden:
composer require google/apiclient:^2.10
- Erstellen Sie die Dateien
index.php
undoauth2callback.php
mit dem Inhalt. unten. - 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 Test-Webserver 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); $broadcasts = $youtube->liveBroadcasts->listLiveBroadcasts('id,snippet', [ 'mine' => true ]); echo json_encode($broadcasts); } 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. Es
führt unter http://localhost:8080
eine Webanwendung aus, mit der Sie OAuth 2.0 testen können.
Ablauf. 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 auszuführen. Falls erforderlich, wird der Autorisierungsvorgang gestartet. Wenn der Vorgang erfolgreich war, wird auf der Seite API-Antwort.
- Authentifizierung direkt testen:Dieser Link verweist auf eine Seite, über die versucht wird, den Nutzer den Autorisierungsvorgang durchlaufen. Die App fordert die Berechtigung an, Autorisierte API-Anfragen im Namen des Nutzers senden
- Aktuelle Anmeldedaten widerrufen: Dieser Link verweist auf eine Seite, die widerruft Berechtigungen, die der Nutzer der Anwendung bereits gewährt hat.
- Löschen Sie die Anmeldedaten für die Flask-Sitzung: Über diesen Link werden die Anmeldedaten für die Autorisierung gelöscht, die in der Flask-Sitzung gespeichert sind. So sehen Sie, was passieren würde, wenn ein Nutzer, erteilte Berechtigung für deine App hat versucht, eine API-Anfrage in einer neuen Sitzung auszuführen. Außerdem können Sie damit sehen Sie die API-Antwort, die Ihre App erhalten würde, wenn ein Nutzer Ihrem Konto Berechtigungen App ausgeführt haben und die App trotzdem versucht hat, 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) broadcasts = youtube.liveBroadcasts().list(part='id,snippet', mine=True).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(**broadcasts) @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 broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true) "<pre>#{JSON.pretty_generate(broadcasts.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 in der API Consoledie URL der
lokalen Computer hinzu. Fügen Sie beispielsweise
http://localhost
. - Achten Sie darauf, dass Sie die Wartung „Langzeitsupport“, eine aktive Version von „Langzeitsupport“ oder die aktuelle Version von Node.js wurde installiert.
-
Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Beispiel:
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example
-
Installieren Sie die
Google API-Client
Mediathek
für Node.js mit 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 wird das Flask-Framework verwendet. und der Requests-Bibliothek, um das OAuth 2.0-Web-Flow. Wir empfehlen die Verwendung der Google API-Clientbibliothek für Python für diesen Ablauf. Der Parameter auf dem Tab "Python" dagegen 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://youtube.googleapis.com/youtube/v3/liveBroadcasts' 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, um Entwickler zu unterstützen um ihre Anwendungen zu schützen. Ihre Weiterleitungs-URIs müssen diesen Regeln entsprechen. Weitere Informationen finden Sie unter RFC 3986, Abschnitt 3 für die Definition von Domain, Host, Pfad, Suchanfrage, Schema und Nutzerinformationen (siehe unten).
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. |
Moderator:in |
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,
gehört die App der App. Wenn eine App, die eine Shortener-Domain besitzt,
an diese Domain weiterleiten möchten, muss der Weiterleitungs-URI entweder
“/google-callback/” im Pfad oder enden mit
“/google-callback” . |
Nutzerinformationen |
Weiterleitungs-URIs dürfen die Unterkomponente „Nutzerinformationen“ nicht enthalten. |
Pfad |
Weiterleitungs-URIs dürfen keinen Pfaddurchlauf (auch Verzeichnis-Backtracking genannt) enthalten.
das durch ein |
Abfrage |
Weiterleitungs-URIs dürfen keine offene Weiterleitungen. |
Fragment |
Weiterleitungs-URIs dürfen die Fragmentkomponente nicht enthalten. |
Zeichen |
Weiterleitungs-URIs dürfen folgende Zeichen nicht enthalten:
<ph type="x-smartling-placeholder">
|
Inkrementelle Autorisierung
Im OAuth 2.0-Protokoll fordert Ihre App eine Autorisierung für den Zugriff auf Ressourcen an. Diese sind die durch den Umfang identifiziert werden. Es hat sich bewährt, die Autorisierung anzufordern. genau dann, wenn Sie sie brauchen. Dafür gibt der Autorisierungsserver von Google unterstützt inkrementelle Autorisierung. Mit dieser Funktion können Sie Bereiche bei Bedarf anfordern. Erteilt der Nutzer die Berechtigung für den neuen Bereich, wird ein Autorisierungscode zurückgegeben, der möglicherweise gegen ein Token ausgetauscht werden, das alle Bereiche enthält, die der Nutzer dem Projekt gewährt hat.
Angenommen, eine App ruft Daten für den YouTube-Kanal des authentifizierten Nutzers ab und
ermöglicht es einem Nutzer, YouTube Analytics-Daten über einen speziellen Ablauf abzurufen. In diesem Fall müssen Sie bei der Anmeldung
kann es sein, dass die App nur Zugriff auf den https://www.googleapis.com/auth/youtube.force-ssl
anfordert
Umfang. Versucht der Nutzer jedoch, auf Analytics-Daten für seinen Kanal zuzugreifen,
Fordern Sie Zugriff auf den Bereich https://www.googleapis.com/auth/yt-analytics.readonly
an.
Zum Implementieren der inkrementellen Autorisierung führen Sie den normalen Ablauf zum Anfordern eines Zugriffs aus. Token, aber achten Sie darauf, dass die Autorisierungsanfrage zuvor gewährte Bereiche enthält. Dieses ermöglicht es Ihrer App, nicht mehrere Zugriffstokens verwalten zu müssen.
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 den neue kombinierte Autorisierung.
- Wenn Sie das Aktualisierungstoken für die kombinierte Autorisierung zum Abrufen eines Zugriffstokens verwenden, wird der
steht für die kombinierte Autorisierung und kann für alle
scope
-Werte in der Antwort enthalten. - Die kombinierte Autorisierung umfasst alle Bereiche, die der Nutzer dem API-Projekt gewährt hat, auch wenn die Erteilungen von verschiedenen Kunden angefordert wurden. Wenn ein Nutzer z. B. Zugriff auf einem Bereich über den Desktop-Client einer Anwendung und einem anderen App über einen mobilen Client senden würde, würde die kombinierte Autorisierung beide Bereiche umfassen.
- Wenn Sie ein Token widerrufen, das eine kombinierte Autorisierung darstellt, kann auf all diese Die Zugriffsbereiche der Autorisierung für den zugeordneten Nutzer werden gleichzeitig widerrufen.
Die sprachspezifischen Codebeispiele in Schritt 1: Autorisierung festlegen Parameter und der Beispiel-HTTP/REST-Weiterleitungs-URL in Schritt 2: Bei Weiterleitungen zum OAuth 2.0-Server von Google wird die inkrementelle Autorisierung verwendet. Codebeispiele Unten sehen Sie auch den Code, den Sie hinzufügen müssen, um die inkrementelle Autorisierung zu verwenden.
PHP
$client->setIncludeGrantedScopes(true);
Python
Legen Sie in Python das Schlüsselwortargument include_granted_scopes
auf true
fest:
Prüfen Sie, ob eine Autorisierungsanfrage zuvor gewährte Bereiche enthält. Es ist sehr möglich, dass
include_granted_scopes
ist nicht das einzige Schlüsselwortargument, das Sie festlegen, da
wie im folgenden Beispiel dargestellt.
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 Zugriff zum Abrufen des YouTube-Daten des Nutzers zusätzlich zu jedem anderen Zugriff, den der Nutzer die der Anwendung bereits gewährt wurden.
GET https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.force-ssl& 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 die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.
Python
Legen Sie in Python das Schlüsselwortargument access_type
auf offline
fest, um sicherzustellen,
dass Sie das Zugriffstoken aktualisieren können, ohne den Nutzer erneut zur Eingabe
Berechtigung. Es ist gut möglich, dass access_type
nicht das einzige Keyword ist.
-Arguments, 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 die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.
Ruby
Wenn Ihre Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf
offline
:
auth_client.update!( :additional_parameters => {"access_type" => "offline"} )
Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.
Node.js
Wenn Ihre Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf
offline
:
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 die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.
Zugriffstokens laufen ab. Diese Bibliothek verwendet automatisch ein Aktualisierungstoken, um einen neuen Zugriff zu erhalten wenn es bald abläuft. Eine einfache Möglichkeit, immer die neuesten Tokens zu speichern ist die Verwendung des Token-Ereignisses:
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. Sie müssen Ihre
access_type
an offline
beim Aufrufen von generateAuthUrl
, 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
Autorisieren Sie die Anwendung noch einmal, 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 automatisch abgerufen und aktualisiert. im nächsten Aufruf an die API ein.
HTTP/REST
Zum Aktualisieren eines Zugriffstokens sendet Ihre Anwendung eine HTTPS-POST
-Anfrage
an den Autorisierungsserver von Google (https://oauth2.googleapis.com/token
) senden,
enthält die folgenden Parameter:
Felder | |
---|---|
client_id |
Die Client-ID, die von der API Consoleabgerufen wird. |
client_secret |
Der von API Consoleabgerufene Clientschlüssel. |
grant_type |
Als
die in den
OAuth 2.0-Spezifikation,
Der Wert dieses Feldes muss 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, kann der Tokenserver gibt ein JSON-Objekt zurück, das ein neues Zugriffstoken enthält. Das folgende Snippet zeigt ein Beispiel Antwort:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "token_type": "Bearer" }
Beachten Sie, dass die Anzahl der Aktualisierungstokens, die ausgestellt werden, begrenzt ist. ein Limit pro Client/Nutzer-Kombination und eine weitere pro Nutzer für alle Clients. Aktualisierungstokens speichern und verwenden Sie sie, solange sie gültig sind. Wenn Ihre Anwendung zu viele Aktualisierungstokens anfordert, können diese Limits erreicht werden. In diesem Fall sind ältere Aktualisierungstokens funktioniert nicht mehr.
Token widerrufen
In einigen Fällen möchte ein Nutzer den Zugriff auf eine Anwendung widerrufen. Ein Nutzer kann den Zugriff widerrufen. unter Kontoeinstellungen. Weitere Informationen finden Sie in der Entfernen Website- oder App-Zugriff auf der Seite „Websites und Apps von Drittanbietern“ Apps mit Zugriff auf Ihr Konto finden Sie weitere Informationen.
Es ist auch möglich, den Zugriff einer Anwendung programmatisch zu widerrufen. Der programmatische Widerruf ist wichtig, wenn ein Nutzer ein Abonnement beendet, oder die für eine App erforderlichen API-Ressourcen haben sich wesentlich geändert. Mit anderen Worten: Ein Teil des Entfernungsprozesses kann eine API-Anfrage umfassen, um sicherzustellen, dass die zuvor die der Anwendung gewährt wurden, entfernt.
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
, der das Token als Parameter enthält und den Parameter festlegt
Content-Type
-Header:
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 die oauth2.revoke
Endpunkt:
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, 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 angezeigt.
Node.js
Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine HTTPS-POST-Anfrage an /revoke
Endpunkt:
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, 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 angezeigt.
HTTP/REST
Zum programmatischen Widerrufen eines Tokens sendet Ihre Anwendung eine Anfrage an
https://oauth2.googleapis.com/revoke
und enthält das Token als Parameter:
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. Handelt es sich bei dem Token um ein Zugriffstoken mit einem entsprechendes Aktualisierungstoken, wird auch das Aktualisierungstoken widerrufen.
Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der HTTP-Statuscode der Antwort:
200
Für Fehlerbedingungen wird der HTTP-Statuscode 400
zusammen mit
mit einem Fehlercode.
Den produktübergreifenden Kontoschutz implementieren
Zusätzlicher Schritt zum Schutz der Nutzerdaten für Google-Konten wird die kontoübergreifende Schutz durch den produktübergreifenden Kontoschutz von Google Mit diesem Dienst können Sie Benachrichtigungen zu Sicherheitsereignissen abonnieren, die Ihrer Anwendung Informationen über größere Änderungen am Nutzerkonto vorgenommen hat. Anhand dieser Informationen können Sie dann wie Sie auf Ereignisse reagieren.
Der produktübergreifende Kontoschutz von Google sendet beispielsweise folgende Ereignistypen an Ihre App:
-
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked
-
https://schemas.openid.net/secevent/oauth/event-type/token-revoked
-
https://schemas.openid.net/secevent/risc/event-type/account-disabled
Weitere Informationen finden Sie in der <ph type="x-smartling-placeholder"></ph> Nutzerkonten mit der Seite zum produktübergreifenden Kontoschutz schützen finden Sie weitere Informationen zur Implementierung des produktübergreifenden Kontoschutzes und eine vollständige Liste der verfügbaren Ereignisse.