Verwenden von OAuth 2.0 für Webserveranwendungen

In diesem Dokument wird beschrieben, wie Webserveranwendungen Google API-Clientbibliotheken oder Google OAuth 2.0-Endpunkte verwenden, um die OAuth 2.0-Autorisierung für den Zugriff auf Google APIs zu implementieren.

Mit OAuth 2.0 können Nutzer bestimmte Daten mit einer Anwendung teilen, während ihre Nutzernamen, Passwörter und anderen Daten privat bleiben. Beispielsweise kann eine Anwendung OAuth 2.0 verwenden, um Nutzern die Berechtigung zum Speichern von Dateien in Google Drive einzuholen.

Dieser OAuth 2.0-Vorgang ist speziell für die Nutzerautorisierung vorgesehen. Sie ist für Anwendungen konzipiert, die vertrauliche Informationen speichern und ihren Zustand 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 außerdem häufig Dienstkonten, um API-Anfragen zu autorisieren, insbesondere wenn Sie Cloud APIs für den Zugriff auf projektbasierte Daten statt für nutzerspezifische Daten aufrufen. Webserveranwendungen können Dienstkonten in Verbindung mit der Nutzerautorisierung verwenden.

Clientbibliotheken

In den sprachspezifischen Beispielen auf dieser Seite werden die 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 für den OAuth 2.0-Vorgang Ihrer Anwendung verwenden, führt die Clientbibliothek viele Aktionen aus, die ansonsten von der Anwendung ausgeführt werden müssten. Beispielsweise wird festgelegt, wann die Anwendung gespeicherte Zugriffstokens verwenden oder aktualisieren darf und wann die Anwendung eine Einwilligung einholen muss. Die Clientbibliothek generiert auch korrekte Weiterleitungs-URLs und unterstützt die Implementierung von Weiterleitungs-Handlern, die Autorisierungscodes für Zugriffstokens 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 in API Consoleaktivieren.

So aktivieren Sie eine API für Ihr Projekt:

  1. Open the API Library in der Google API Console.
  2. If prompted, select a project, or create a new one.
  3. Hier API Library werden alle verfügbaren APIs nach Produktfamilie und Beliebtheit gruppiert. Wenn die API, die Sie aktivieren möchten, nicht in der Liste angezeigt wird, können Sie die Suchfunktion verwenden oder in der zugehörigen Produktfamilie auf Alle ansehen klicken.
  4. Wählen Sie die gewünschte API aus und klicken Sie dann auf die Schaltfläche Aktivieren.
  5. If prompted, enable billing.
  6. If prompted, read and accept the API's Terms of Service.

Anmeldedaten für die Autorisierung erstellen

Alle Anwendungen, die OAuth 2.0 verwenden, müssen auf Google-Anmeldedaten zugreifen, mit denen die Anwendung über den OAuth 2.0-Server von Google identifiziert werden kann. In den folgenden Schritten wird erläutert, wie Sie Anmeldedaten für Ihr Projekt erstellen. Ihre Anwendungen können dann die Anmeldedaten verwenden, um auf APIs zuzugreifen, die Sie für dieses Projekt aktiviert haben.

  1. Go to the Credentials page.
  2. Klicken Sie auf Anmeldedaten erstellen > OAuth-Client-ID.
  3. Wählen Sie den Anwendungstyp Webanwendung aus.
  4. 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.

    Für Tests können Sie URIs angeben, die auf den lokalen Computer verweisen, z. B. http://localhost:8080. Hinweis: In allen Beispielen in diesem Dokument wird http://localhost:8080 als Weiterleitungs-URI verwendet.

    Wir empfehlen, Authentifizierungsendpunkte Ihrer App zu entwerfen, damit Ihre Anwendung keine Autorisierungscodes für andere Ressourcen auf der Seite freigibt.

Laden Sie nach dem Erstellen Ihrer Anmeldedaten die Datei client_secret.json aus der API Consoleherunter. Speichern Sie die Datei an einem sicheren Ort, auf den nur Ihre Anwendung zugreifen kann.

Zugriffsbereiche identifizieren

Mithilfe von Bereichen kann Ihre Anwendung nur Zugriff auf die erforderlichen Ressourcen anfordern und Nutzern gleichzeitig die Kontrolle über die Zugriffsrechte für ihre Anwendung geben. Daher besteht möglicherweise eine umgekehrte Beziehung zwischen der Anzahl der angeforderten Bereiche und der Wahrscheinlichkeit, die Nutzereinwilligung einzuholen.

Bevor Sie mit der Implementierung von OAuth 2.0-Autorisierung beginnen, sollten Sie die Bereiche identifizieren, für die Ihre Anwendung Zugriffsberechtigungen benötigt.

Wir empfehlen außerdem, dass Ihre Anwendung den Zugriff auf Autorisierungsbereiche über eine schrittweise Autorisierung anfordert, bei der Ihre Anwendung Zugriff auf Nutzerdaten im Kontext anfordert. Mit dieser Best Practice können Nutzer besser verstehen, warum ihre Anwendung den erforderlichen Zugriff benötigt.

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, lesen Sie auch die folgenden sprachspezifischen Anforderungen.

PHP

Zum Ausführen der PHP-Codebeispiele in diesem Dokument benötigen Sie Folgendes:

  • PHP 5.4 oder höher mit installierter Befehlszeile und JSON-Erweiterung
  • Das Tool Composer für die Abhängigkeitsverwaltung.
  • Die Google APIs-Clientbibliothek für PHP:

    php composer.phar require google/apiclient:^2.0

Python

Zum Ausführen der Python-Codebeispiele in diesem Dokument benötigen Sie Folgendes:

  • Python 2.6 oder höher
  • Das Tool pip zur Paketverwaltung
  • Die Google APIs-Clientbibliothek für Python:
    pip install --upgrade google-api-python-client
  • google-auth, google-auth-oauthlib und google-auth-httplib2 für die Nutzerautorisierung.
    pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
  • Das Flask-Python-Webanwendungsframework.
    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.2.2 oder höher
  • Die Google APIs-Clientbibliothek für Ruby:

    gem install google-api-client
  • Das Sinatra Ruby-Webanwendungs-Framework.

    gem install sinatra

Node.js

Zum Ausführen der Node.js-Codebeispiele in diesem Dokument benötigen Sie Folgendes:

  • Der Wartungs-LTS, der aktive LTS-Wert oder der aktuelle Release von Node.js
  • Google APIs-Node.js-Client:

    npm install googleapis

HTTP/REST

Sie müssen keine Bibliotheken installieren, um die OAuth 2.0-Endpunkte direkt aufrufen zu können.

OAuth 2.0-Zugriffstokens abrufen

Die folgenden Schritte zeigen, wie Ihre Anwendung mit dem OAuth 2.0-Server von Google interagiert, um eine Einwilligung des Nutzers zum Ausführen einer API-Anfrage im Namen des Nutzers einzuholen. Ihre Anwendung muss diese Einwilligung haben, bevor sie eine Google API-Anfrage ausführen kann, für die eine Nutzerautorisierung erforderlich ist.

In der Liste unten werden diese Schritte schnell zusammengefasst:

  1. Die Anwendung identifiziert die erforderlichen Berechtigungen.
  2. Ihre Anwendung leitet den Nutzer zusammen mit der Liste der angeforderten Berechtigungen an Google weiter.
  3. Der Nutzer entscheidet, ob er Ihrer App Berechtigungen erteilen möchte.
  4. Ihre Anwendung erfährt, was der Nutzer entschieden hat.
  5. Wenn der Nutzer die angeforderten Berechtigungen gewährt hat, ruft deine Anwendung Tokens ab, die zur Ausführung von API-Anfragen im Namen des Nutzers erforderlich sind.

Schritt 1: Autorisierungsparameter festlegen

Der erste Schritt besteht darin, die Autorisierungsanfrage zu erstellen. Mit dieser Anfrage werden Parameter festgelegt, die Ihre Anwendung identifizieren und die Berechtigungen definieren, die der Nutzer für Ihre Anwendung erhält.

  • 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 folgenden Tabs definieren die unterstützten Autorisierungsparameter für Webserveranwendungen. In den sprachspezifischen Beispielen wird auch gezeigt, wie Sie mit einer Clientbibliothek oder Autorisierungsbibliothek ein Objekt konfigurieren, das diese Parameter festlegt.

PHP

Das Code-Snippet unten erstellt ein Google_Client()-Objekt, das die Parameter in der Autorisierungsanfrage definiert.

Dieses Objekt verwendet Informationen zur Datei client_secret.json, um Ihre Anwendung zu identifizieren. Weitere Informationen zu dieser Datei finden Sie unter Anmeldedaten erstellen. Das Objekt identifiziert auch die Bereiche, in denen deine Anwendung Zugriffsberechtigungen anfordert, sowie die URL zum Authentifizierungsendpunkt deiner Anwendung, die die Antwort vom Google-OAuth 2.0-Server verarbeitet. Abschließend werden die optionalen Parameter access_type und include_granted_scopes festgelegt.

Für diesen Code wird beispielsweise schreibgeschützter Offlinezugriff auf ein Google Drive-Konto eines Nutzers angefordert:

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
// 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');
// Using "consent" ensures that your application always receives a refresh token.
// If you are not using offline access, you can omit this.
$client->setApprovalPrompt("consent");
$client->setIncludeGrantedScopes(true);   // incremental auth

Die Anfrage enthält die folgenden Informationen:

Parameter
client_id Pflichtfeld

Die Client-ID Ihrer Anwendung. Diesen Wert findest du im API Console Credentials page.

In PHP rufen Sie die Funktion setAuthConfig auf, um Autorisierungsanmeldedaten aus einer client_secret.json-Datei zu laden.

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
redirect_uri Pflichtfeld

Legt fest, wohin der API-Server den Nutzer weiterleitet, nachdem er die Autorisierung abgeschlossen hat. Der Wert muss genau mit einem der autorisierten Weiterleitungs-URIs für den OAuth 2.0-Client übereinstimmen, den Sie in Ihrem API Console- Credentials pagekonfiguriert haben. Wenn dieser Wert nicht mit einem autorisierten Weiterleitungs-URI für die angegebene client_id übereinstimmt, wird der Fehler redirect_uri_mismatch angezeigt.

Beachten Sie, dass die Schemas für http und https sowie der nachgestellte Schrägstrich ('/') alle übereinstimmen müssen.

Rufen Sie die Funktion setRedirectUri auf, um diesen Wert in PHP festzulegen. Sie müssen einen gültigen Weiterleitungs-URI für die angegebene client_id angeben.

$client->setRedirectUri('https://oauth2.example.com/code');
scope Pflichtfeld

Eine durch Leerzeichen getrennte Liste von Bereichen, die die Ressourcen angibt, auf die Ihre Anwendung im Namen des Nutzers zugreifen kann. Diese Werte geben den Einwilligungsbildschirm an, den Google für den Nutzer anzeigt.

Bereiche ermöglichen es Ihrer Anwendung, nur Zugriff auf die erforderlichen Ressourcen anzufordern, während sie gleichzeitig den Nutzern die Kontrolle über den Zugriff gewähren, den sie Ihrer Anwendung gewähren. Daher besteht eine umgekehrte Beziehung zwischen der Anzahl der angeforderten Bereiche und der Wahrscheinlichkeit, die Nutzereinwilligung einzuholen.

Mit der Funktion addScope kannst du diesen Wert in PHP festlegen:

$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);

Ihre Anwendung sollte möglichst im Kontext Zugriff auf Autorisierungsbereiche anfordern. Wenn Sie den Zugriff auf Nutzerdaten kontextbezogen über eine inkrementelle Autorisierung anfordern, können Sie besser 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 online, der Standardwert, und offline.

Legen Sie den Wert auf offline fest, wenn Ihre Anwendung Zugriffstokens aktualisieren muss, wenn der Nutzer nicht im Browser vorhanden ist. Dies ist die Methode zum Aktualisieren von Zugriffstokens, die weiter unten in diesem Dokument beschrieben wird. Dieser Wert weist den Google-Autorisierungsserver an, ein Aktualisierungstoken und ein Zugriffstoken zurückzugeben, wenn Ihre Anwendung zum ersten Mal einen Autorisierungscode gegen Token austauscht.

Mit der Funktion setAccessType kannst du diesen Wert in PHP festlegen:

$client->setAccessType('offline');
state Empfohlen

Gibt einen beliebigen Stringwert an, den Ihre Anwendung zur Aufrechterhaltung des Status zwischen Ihrer Autorisierungsanfrage und der Antwort des Autorisierungsservers verwendet. Der Server gibt den genauen Wert zurück, den du als name=value-Paar in der URL-Abfragekomponente (?) von redirect_uri sendest, nachdem der Nutzer der Zugriffsanfrage deiner Anwendung zugestimmt oder sie abgelehnt hat.

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 eine websiteübergreifende Anfragefälschung zu verringern. Da Ihr redirect_uri erraten werden kann, können Sie mit einem state-Wert die Sicherheit erhöhen, dass eine eingehende Verbindung das Ergebnis einer Authentifizierungsanfrage ist. Wenn du einen zufälligen String generiert oder den Hash eines Cookies oder eines anderen Werts generierst, der den Clientstatus erfasst, kannst du die Antwort validieren. So lässt sich zusätzlich prüfen, ob die Anfrage und die Antwort vom selben Browser stammen, und so Schutz vor Angriffen wie websiteübergreifende Anfragefälschung bieten. In der Dokumentation zu OpenID Connect findest du ein Beispiel zum Erstellen und Bestätigen eines state-Tokens.

Mit der Funktion setState kannst du diesen Wert in PHP festlegen:

$client->setState($sample_passthrough_value);
include_granted_scopes Optional

Ermöglicht Anwendungen, die schrittweise Autorisierung zu verwenden, um Zugriff auf zusätzliche Bereiche im Kontext anzufordern. Wenn Sie den Wert dieses Parameters auf true festlegen und die Autorisierungsanfrage erteilt wird, deckt das neue Zugriffstoken auch alle Bereiche ab, auf die der Nutzer zuvor der Anwendung Zugriff gewährt hat. Beispiele finden Sie im Abschnitt zur inkrementellen Autorisierung.

Mit der Funktion setIncludeGrantedScopes kannst du diesen Wert in PHP festlegen:

$client->setIncludeGrantedScopes(true);
login_hint Optional

Wenn die Anwendung weiß, welcher Nutzer sich authentifizieren möchte, kann er mit diesem Parameter einen Hinweis für den Google-Authentifizierungsserver bereitstellen. Der Server nutzt den Hinweis, um den Anmeldevorgang zu vereinfachen. Dazu wird das E-Mail-Feld im Anmeldeformular vorausgefüllt oder die entsprechende Sitzung mit Mehrfachanmeldung ausgewählt.

Geben Sie als Parameterwert eine E-Mail-Adresse oder eine sub-ID an, die der Google-ID des Nutzers entspricht.

Mit der Funktion setLoginHint kannst du diesen Wert in PHP festlegen:

$client->setLoginHint('None');
prompt Optional

Eine Liste mit durch Leerzeichen voneinander getrennten Groß-/Kleinschreibung, die dem Nutzer angezeigt wird. Wenn Sie diesen Parameter nicht angeben, wird der Nutzer nur dann aufgefordert, wenn für Ihr Projekt zum ersten Mal Zugriff angefordert wird. Weitere Informationen finden Sie unter Erneute Einwilligung einholen.

Mit der Funktion setApprovalPrompt kannst du diesen Wert in PHP festlegen:

$client->setApprovalPrompt('consent');

Folgende Werte sind möglich:

none Es werden keine Bildschirme zur Authentifizierung oder Zustimmung angezeigt. Darf nicht mit anderen Werten angegeben werden.
consent Bitten Sie den Nutzer um seine Einwilligung.
select_account Nutzer auffordern, ein Konto auszuwählen

Python

Im folgenden Code-Snippet wird die Autorisierungsanfrage mit dem Modul google-auth-oauthlib.flow erstellt.

Der Code erstellt ein Flow-Objekt, das deine Anwendung anhand der Informationen aus der Datei client_secret.json identifiziert, die du nach dem Erstellen von Anmeldedaten für die Autorisierung heruntergeladen hast. Dieses Objekt identifiziert auch die Bereiche, in denen Ihre Anwendung Zugriffsberechtigungen anfordert, sowie die URL zum Authentifizierungsendpunkt Ihrer Anwendung, die die Antwort vom Google-OAuth 2.0-Server verarbeitet. Abschließend werden die optionalen Parameter access_type und include_granted_scopes festgelegt.

Für diesen Code wird beispielsweise schreibgeschützter Offlinezugriff auf ein Google Drive-Konto eines Nutzers angefordert:

import google.oauth2.credentials
import google_auth_oauthlib.flow

# Use the client_secret.json file to identify the application requesting
# authorization. The client ID (from that file) and access scopes are required.
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

# 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(
    # 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')

Die Anfrage enthält die folgenden Informationen:

Parameter
client_id Pflichtfeld

Die Client-ID Ihrer Anwendung. Diesen Wert findest du im API Console Credentials page.

Rufen Sie in Python die Methode from_client_secrets_file auf, um die Client-ID aus einer Datei client_secret.json abzurufen. Alternativ kannst du auch die Methode from_client_config verwenden, mit der die Clientkonfiguration genau so weitergegeben wird, wie sie in einer Client-Secret-Datei enthalten ist. Der Zugriff auf die Datei selbst erfolgt aber nicht.

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])
redirect_uri Pflichtfeld

Legt fest, wohin der API-Server den Nutzer weiterleitet, nachdem er die Autorisierung abgeschlossen hat. Der Wert muss genau mit einem der autorisierten Weiterleitungs-URIs für den OAuth 2.0-Client übereinstimmen, den Sie in Ihrem API Console- Credentials pagekonfiguriert haben. Wenn dieser Wert nicht mit einem autorisierten Weiterleitungs-URI für die angegebene client_id übereinstimmt, wird der Fehler redirect_uri_mismatch angezeigt.

Beachten Sie, dass die Schemas für http und https sowie der nachgestellte Schrägstrich ('/') alle übereinstimmen müssen.

Wenn du diesen Wert in Python festlegen möchtest, lege die redirect_uri-Property flow fest:

flow.redirect_uri = 'https://oauth2.example.com/code'
scope Pflichtfeld

Eine Liste von Bereichen, die die Ressourcen identifizieren, auf die Ihre Anwendung im Namen des Nutzers zugreifen kann. Diese Werte geben den Einwilligungsbildschirm an, den Google für den Nutzer anzeigt.

Bereiche ermöglichen es Ihrer Anwendung, nur Zugriff auf die erforderlichen Ressourcen anzufordern, während sie gleichzeitig den Nutzern die Kontrolle über den Zugriff gewähren, den sie Ihrer Anwendung gewähren. Daher besteht eine umgekehrte Beziehung zwischen der Anzahl der angeforderten Bereiche und der Wahrscheinlichkeit, die Nutzereinwilligung einzuholen.

Verwenden Sie in Python die Methode, mit der Sie client_id festlegen, um eine Liste der Bereiche anzugeben.

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

Ihre Anwendung sollte möglichst im Kontext Zugriff auf Autorisierungsbereiche anfordern. Wenn Sie den Zugriff auf Nutzerdaten kontextbezogen über eine inkrementelle Autorisierung anfordern, können Sie besser 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 online, der Standardwert, und offline.

Legen Sie den Wert auf offline fest, wenn Ihre Anwendung Zugriffstokens aktualisieren muss, wenn der Nutzer nicht im Browser vorhanden ist. Dies ist die Methode zum Aktualisieren von Zugriffstokens, die weiter unten in diesem Dokument beschrieben wird. Dieser Wert weist den Google-Autorisierungsserver an, ein Aktualisierungstoken und ein Zugriffstoken zurückzugeben, wenn Ihre Anwendung zum ersten Mal einen Autorisierungscode gegen Token austauscht.

Legen Sie in Python den Parameter access_type fest, indem Sie access_type als Keyword-Argument angeben, wenn die Methode flow.authorization_url aufgerufen wird:

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')
state Empfohlen

Gibt einen beliebigen Stringwert an, den Ihre Anwendung zur Aufrechterhaltung des Status zwischen Ihrer Autorisierungsanfrage und der Antwort des Autorisierungsservers verwendet. Der Server gibt den genauen Wert zurück, den du als name=value-Paar in der URL-Abfragekomponente (?) von redirect_uri sendest, nachdem der Nutzer der Zugriffsanfrage deiner Anwendung zugestimmt oder sie abgelehnt hat.

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 eine websiteübergreifende Anfragefälschung zu verringern. Da Ihr redirect_uri erraten werden kann, können Sie mit einem state-Wert die Sicherheit erhöhen, dass eine eingehende Verbindung das Ergebnis einer Authentifizierungsanfrage ist. Wenn du einen zufälligen String generiert oder den Hash eines Cookies oder eines anderen Werts generierst, der den Clientstatus erfasst, kannst du die Antwort validieren. So lässt sich zusätzlich prüfen, ob die Anfrage und die Antwort vom selben Browser stammen, und so Schutz vor Angriffen wie websiteübergreifende Anfragefälschung bieten. In der Dokumentation zu OpenID Connect findest du ein Beispiel zum Erstellen und Bestätigen eines state-Tokens.

Lege in Python den Parameter state fest, indem du state als Keyword-Argument festlegst, wenn die Methode flow.authorization_url aufgerufen wird:

authorization_url, state = flow.authorization_url(
    access_type='offline',
    state=sample_passthrough_value,
    include_granted_scopes='true')
include_granted_scopes Optional

Ermöglicht Anwendungen, die schrittweise Autorisierung zu verwenden, um Zugriff auf zusätzliche Bereiche im Kontext anzufordern. Wenn Sie den Wert dieses Parameters auf true festlegen und die Autorisierungsanfrage erteilt wird, deckt das neue Zugriffstoken auch alle Bereiche ab, auf die der Nutzer zuvor der Anwendung Zugriff gewährt hat. Beispiele finden Sie im Abschnitt zur inkrementellen Autorisierung.

Legen Sie in Python den Parameter include_granted_scopes fest, indem Sie include_granted_scopes als Keyword-Argument angeben, wenn die Methode flow.authorization_url aufgerufen wird:

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')
login_hint Optional

Wenn die Anwendung weiß, welcher Nutzer sich authentifizieren möchte, kann er mit diesem Parameter einen Hinweis für den Google-Authentifizierungsserver bereitstellen. Der Server nutzt den Hinweis, um den Anmeldevorgang zu vereinfachen. Dazu wird das E-Mail-Feld im Anmeldeformular vorausgefüllt oder die entsprechende Sitzung mit Mehrfachanmeldung ausgewählt.

Geben Sie als Parameterwert eine E-Mail-Adresse oder eine sub-ID an, die der Google-ID des Nutzers entspricht.

Legen Sie in Python den Parameter login_hint fest, indem Sie login_hint als Keyword-Argument angeben, wenn die Methode flow.authorization_url aufgerufen wird:

authorization_url, state = flow.authorization_url(
    access_type='offline',
    login_hint='None',
    include_granted_scopes='true')
prompt Optional

Eine Liste mit durch Leerzeichen voneinander getrennten Groß-/Kleinschreibung, die dem Nutzer angezeigt wird. Wenn Sie diesen Parameter nicht angeben, wird der Nutzer nur dann aufgefordert, wenn für Ihr Projekt zum ersten Mal Zugriff angefordert wird. Weitere Informationen finden Sie unter Erneute Einwilligung einholen.

Lege in Python den Parameter prompt fest, indem du prompt als Keyword-Argument festlegst, wenn die Methode flow.authorization_url aufgerufen wird:

authorization_url, state = flow.authorization_url(
      access_type='offline',
      prompt='consent',
      include_granted_scopes='true')

Folgende Werte sind möglich:

none Es werden keine Bildschirme zur Authentifizierung oder Zustimmung angezeigt. Darf nicht mit anderen Werten angegeben werden.
consent Bitten Sie den Nutzer um seine Einwilligung.
select_account Nutzer auffordern, ein Konto auszuwählen

Ruby

Verwenden Sie die von Ihnen erstellte Datei „client_secrets.json“, um ein Clientobjekt in Ihrer Anwendung zu konfigurieren. Wenn Sie ein Clientobjekt konfigurieren, geben Sie die Bereiche an, auf die Ihre Anwendung zugreifen muss. Außerdem geben Sie die URL zu dem Authentifizierungsendpunkt Ihrer Anwendung an, der die Antwort vom OAuth 2.0-Server verarbeitet.

Für diesen Code wird beispielsweise schreibgeschützter Offlinezugriff auf ein Google Drive-Konto eines Nutzers angefordert:

require 'google/apis/drive_v2'
require 'google/api_client/client_secrets'

client_secrets = Google::APIClient::ClientSecrets.load
auth_client = client_secrets.to_authorization
auth_client.update!(
  :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
  :redirect_uri => 'http://www.example.com/oauth2callback',
  :additional_parameters => {
    "access_type" => "offline",         # offline access
    "include_granted_scopes" => "true"  # incremental auth
  }
)

Ihre Anwendung verwendet das Clientobjekt für OAuth 2.0-Vorgänge, beispielsweise das Generieren von Autorisierungsanfragen-URLs und das Anwenden von Zugriffstokens auf HTTP-Anfragen.

Node.js

Das Code-Snippet unten erstellt ein google.auth.OAuth2-Objekt, das die Parameter in der Autorisierungsanfrage definiert.

Dieses Objekt verwendet Informationen zur Datei „client_secret.json“, um Ihre Anwendung zu identifizieren. Wenn Sie die Berechtigungen eines Nutzers zum Abrufen eines Zugriffstokens anfordern möchten, werden Sie auf eine Einwilligungsseite weitergeleitet. So erstellen Sie die URL einer Einwilligungsseite:

const {google} = require('googleapis');

/**
 * 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 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
});

Wichtiger Hinweis: refresh_token wird nur bei der ersten Autorisierung zurückgegeben. Weitere Informationen

HTTP/REST

Der OAuth 2.0-Endpunkt von Google befindet sich unter 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 Pflichtfeld

Die Client-ID Ihrer Anwendung. Diesen Wert findest du im API Console Credentials page.

redirect_uri Pflichtfeld

Legt fest, wohin der API-Server den Nutzer weiterleitet, nachdem er die Autorisierung abgeschlossen hat. Der Wert muss genau mit einem der autorisierten Weiterleitungs-URIs für den OAuth 2.0-Client übereinstimmen, den Sie in Ihrem API Console- Credentials pagekonfiguriert haben. Wenn dieser Wert nicht mit einem autorisierten Weiterleitungs-URI für die angegebene client_id übereinstimmt, wird der Fehler redirect_uri_mismatch angezeigt.

Beachten Sie, dass die Schemas für http und https sowie der nachgestellte Schrägstrich ('/') alle übereinstimmen müssen.

response_type Pflichtfeld

Legt fest, ob der Google OAuth 2.0-Endpunkt einen Autorisierungscode zurückgibt.

Legen Sie den Parameterwert für Webserveranwendungen auf code fest.

scope Pflichtfeld

Eine durch Leerzeichen getrennte Liste von Bereichen, die die Ressourcen angibt, auf die Ihre Anwendung im Namen des Nutzers zugreifen kann. Diese Werte geben den Einwilligungsbildschirm an, den Google für den Nutzer anzeigt.

Bereiche ermöglichen es Ihrer Anwendung, nur Zugriff auf die erforderlichen Ressourcen anzufordern, während sie gleichzeitig den Nutzern die Kontrolle über den Zugriff gewähren, den sie Ihrer Anwendung gewähren. Daher besteht eine umgekehrte Beziehung zwischen der Anzahl der angeforderten Bereiche und der Wahrscheinlichkeit, die Nutzereinwilligung einzuholen.

Ihre Anwendung sollte möglichst im Kontext Zugriff auf Autorisierungsbereiche anfordern. Wenn Sie den Zugriff auf Nutzerdaten kontextbezogen über eine inkrementelle Autorisierung anfordern, können Sie besser 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 online, der Standardwert, und offline.

Legen Sie den Wert auf offline fest, wenn Ihre Anwendung Zugriffstokens aktualisieren muss, wenn der Nutzer nicht im Browser vorhanden ist. Dies ist die Methode zum Aktualisieren von Zugriffstokens, die weiter unten in diesem Dokument beschrieben wird. Dieser Wert weist den Google-Autorisierungsserver an, ein Aktualisierungstoken und ein Zugriffstoken zurückzugeben, wenn Ihre Anwendung zum ersten Mal einen Autorisierungscode gegen Token austauscht.

state Empfohlen

Gibt einen beliebigen Stringwert an, den Ihre Anwendung zur Aufrechterhaltung des Status zwischen Ihrer Autorisierungsanfrage und der Antwort des Autorisierungsservers verwendet. Der Server gibt den genauen Wert zurück, den du als name=value-Paar in der URL-Abfragekomponente (?) von redirect_uri sendest, nachdem der Nutzer der Zugriffsanfrage deiner Anwendung zugestimmt oder sie abgelehnt hat.

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 eine websiteübergreifende Anfragefälschung zu verringern. Da Ihr redirect_uri erraten werden kann, können Sie mit einem state-Wert die Sicherheit erhöhen, dass eine eingehende Verbindung das Ergebnis einer Authentifizierungsanfrage ist. Wenn du einen zufälligen String generiert oder den Hash eines Cookies oder eines anderen Werts generierst, der den Clientstatus erfasst, kannst du die Antwort validieren. So lässt sich zusätzlich prüfen, ob die Anfrage und die Antwort vom selben Browser stammen, und so Schutz vor Angriffen wie websiteübergreifende Anfragefälschung bieten. In der Dokumentation zu OpenID Connect findest du ein Beispiel zum Erstellen und Bestätigen eines state-Tokens.

include_granted_scopes Optional

Ermöglicht Anwendungen, die schrittweise Autorisierung zu verwenden, um Zugriff auf zusätzliche Bereiche im Kontext anzufordern. Wenn Sie den Wert dieses Parameters auf true festlegen und die Autorisierungsanfrage erteilt wird, deckt das neue Zugriffstoken auch alle Bereiche ab, auf die der Nutzer zuvor der Anwendung Zugriff gewährt hat. Beispiele finden Sie im Abschnitt zur inkrementellen Autorisierung.

login_hint Optional

Wenn die Anwendung weiß, welcher Nutzer sich authentifizieren möchte, kann er mit diesem Parameter einen Hinweis für den Google-Authentifizierungsserver bereitstellen. Der Server nutzt den Hinweis, um den Anmeldevorgang zu vereinfachen. Dazu wird das E-Mail-Feld im Anmeldeformular vorausgefüllt oder die entsprechende Sitzung mit Mehrfachanmeldung ausgewählt.

Geben Sie als Parameterwert eine E-Mail-Adresse oder eine sub-ID an, die der Google-ID des Nutzers entspricht.

prompt Optional

Eine Liste mit durch Leerzeichen voneinander getrennten Groß-/Kleinschreibung, die dem Nutzer angezeigt wird. Wenn Sie diesen Parameter nicht angeben, wird der Nutzer nur dann aufgefordert, wenn für Ihr Projekt zum ersten Mal Zugriff angefordert wird. Weitere Informationen finden Sie unter Erneute Einwilligung einholen.

Folgende Werte sind möglich:

none Es werden keine Bildschirme zur Authentifizierung oder Zustimmung angezeigt. Darf nicht mit anderen Werten angegeben werden.
consent Bitten Sie den Nutzer um seine Einwilligung.
select_account Nutzer auffordern, ein Konto auszuwählen

Schritt 2: Weiterleitung an den OAuth 2.0-Server von Google

Leite den Nutzer an den OAuth 2.0-Server von Google weiter, um die Authentifizierung und Autorisierung zu starten. Das passiert normalerweise, wenn deine Anwendung zuerst auf die Daten des Nutzers zugreifen muss. Bei der schrittweisen Autorisierung tritt dieser Schritt auch auf, wenn Ihre Anwendung zuerst auf zusätzliche Ressourcen zugreifen muss, auf die sie noch keine Zugriffsberechtigung hat.

PHP

  1. Generiere eine URL, um Zugriff vom OAuth 2.0-Server von Google anzufordern:
    $auth_url = $client->createAuthUrl();
  2. Nutzer zu $auth_url weiterleiten:
    header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

In diesem Beispiel wird gezeigt, wie der Nutzer mithilfe des Flask-Webanwendungs-Frameworks an die Autorisierungs-URL weitergeleitet wird:

return flask.redirect(authorization_url)

Ruby

  1. Generiere eine URL, um Zugriff vom OAuth 2.0-Server von Google anzufordern:
    auth_uri = auth_client.authorization_uri.to_s
  2. Leite den Nutzer zu auth_uri weiter.

Node.js

  1. Verwende die generierte URL authorizationUrl aus Schritt 1 generateAuthUrl, um den Zugriff über den OAuth 2.0-Server von Google anzufordern.
  2. Leite den Nutzer zu authorizationUrl weiter.
    res.writeHead(301, { "Location": authorizationUrl });

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=https%3A//oauth2.example.com/code&
 client_id=client_id

Nachdem Sie die Anfrage-URL erstellt haben, müssen Sie den Nutzer daran weiterleiten.

Der OAuth 2.0-Server von Google authentifiziert den Nutzer und fordert vom Nutzer die Einwilligung für den Zugriff auf die angeforderten Bereiche an. Die Antwort wird mit der von Ihnen angegebenen Weiterleitungs-URL an Ihre Anwendung zurückgesendet.

Schritt 3: Google fordert den Nutzer auf, seine Einwilligung zu geben

In diesem Schritt entscheidet der Nutzer, ob er Ihrer Anwendung den angeforderten Zugriff gewähren möchte. In dieser Phase zeigt Google ein Einwilligungsfenster an, in dem der Name Ihrer Anwendung und die Google API-Dienste angezeigt werden, für die er die Berechtigungsanfrage anfordert. Dabei werden die Anmeldedaten des Nutzers für die Autorisierung und eine Zusammenfassung der zu gewährenden Zugriffsbereiche angezeigt. Der Nutzer kann dann den Zugriff auf einen oder mehrere von Ihrer Anwendung angeforderte Bereiche oder eine Anfrage ablehnen.

Deine Anwendung muss zu diesem Zeitpunkt nichts tun, da sie auf die Antwort von Googles OAuth 2.0-Server wartet, die angibt, ob ein Zugriff gewährt wurde. Diese Antwort wird im folgenden Schritt erklärt.

Fehler

Anfragen an den OAuth 2.0-Autorisierungsendpunkt von Google können anstelle der erwarteten Authentifizierungs- und Autorisierungsabläufe Fehlermeldungen anzeigen. Häufige Fehlercodes und vorgeschlagene Lösungen sind unten aufgeführt.

admin_policy_enforced

Das Google-Konto kann einen oder mehrere angeforderte Bereiche aufgrund der Richtlinien des Google Workspace-Administrators nicht autorisieren. Im Google Workspace-Admin-Hilfeartikel Zugriff externer und interner Apps auf Google Workspace-Daten verwalten finden Sie weitere Informationen dazu, wie ein Administrator den Zugriff auf alle oder sensible und eingeschränkte Bereiche einschränken kann, bis der OAuth-Client-ID Zugriff gewährt wurde.

disallowed_useragent

Der Autorisierungsendpunkt wird in einem eingebetteten User-Agent angezeigt, der gemäß den OAuth 2.0-Richtlinien von Google nicht zulässig ist.

Android

Android-Entwickler sehen möglicherweise diese Fehlermeldung, wenn sie Autorisierungsanfragen in android.webkit.WebView öffnen. Entwickler sollten stattdessen Android-Bibliotheken wie Google Log-in für Android oder OpenID Foundation AppAuth für Android verwenden.

Dieser Fehler kann auftreten, wenn eine Android-App einen allgemeinen Weblink in einem eingebetteten User-Agent öffnet und ein Nutzer von Ihrer Website zum OAuth 2.0-Autorisierungsendpunkt von Google geht. Entwickler sollten generelle Links im Standard-Link-Handler des Betriebssystems zulassen, das sowohl Android-App-Links-Handler als auch die Standard-Browser-App umfasst. Auch die Bibliothek Benutzerdefinierte Android-Tabs wird unterstützt.

iOS

Diesen Fehler können iOS- und macOS-Entwickler beim Öffnen von Autorisierungsanfragen in WKWebView feststellen. Entwickler sollten stattdessen iOS-Bibliotheken wie Google Log-in für iOS oder OpenID Foundation AppApp for iOS verwenden.

Dieser Fehler kann auftreten, wenn eine iOS- oder macOS-App einen allgemeinen Weblink in einem eingebetteten User-Agent öffnet und ein Nutzer von Ihrer Website zum OAuth 2.0-Autorisierungsendpunkt von Google geht. Entwickler sollten allgemeine Links im Standard-Link-Handler des Betriebssystems zulassen, das sowohl Universal Links-Handler als auch die Standard-Browser-App enthält. Die Bibliothek SFSafariViewController wird ebenfalls unterstützt.

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 beschränkt. Weitere Informationen zu dieser Konfigurationsoption finden Sie im Hilfeartikel OAuth-Zustimmungsbildschirm einrichten.

redirect_uri_mismatch

Der in der Autorisierungsanfrage übergebene redirect_uri stimmt nicht mit einem autorisierten Weiterleitungs-URI für die OAuth-Client-ID überein. Überprüfen Sie autorisierte Weiterleitungs-URIs in Google API Console Credentials page.

Schritt 4: Antwort des OAuth 2.0-Servers verarbeiten

Der OAuth 2.0-Server antwortet auf die Zugriffsanfrage Ihrer Anwendung mithilfe 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 wie unten dargestellt im Abfragestring angezeigt:

Eine Fehlermeldung:

https://oauth2.example.com/auth?error=access_denied

Eine Autorisierungscode-Antwort:

https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7

Beispiel für eine OAuth 2.0-Serverantwort

Sie können den Ablauf testen, indem Sie auf die folgende Beispiel-URL klicken, die Lesezugriff auf Metadaten für Dateien in Google Drive anfordert:

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=https%3A//oauth2.example.com/code&
 client_id=client_id

Nach Abschluss des OAuth 2.0-Vorgangs sollten Sie zu http://localhost/oauth2callback weitergeleitet werden. Das führt wahrscheinlich zu einem 404 NOT FOUND-Fehler, es sei denn, Ihr lokaler Computer stellt eine Datei unter dieser Adresse bereit. Im nächsten Schritt erhältst du weitere Details zu den Informationen, die im URI zurückgegeben werden, wenn der Nutzer zu deiner Anwendung weitergeleitet wird.

Schritt 5: Autorisierungscode für die Aktualisierung und das Zugriffstoken austauschen

Nachdem der Autorisierungscode auf dem Webserver eingegangen ist, kann er ihn gegen ein Zugriffstoken austauschen.

PHP

Verwenden Sie die Methode authenticate, um einen Autorisierungscode für ein Zugriffstoken auszutauschen:

$client->authenticate($_GET['code']);

Das Zugriffstoken können Sie mit der Methode getAccessToken abrufen:

$access_token = $client->getAccessToken();

Python

Prüfen Sie auf der Callback-Seite die Bibliothek google-auth, um die Antwort des Autorisierungsservers zu prüfen. Verwenden Sie dann die flow.fetch_token-Methode, 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/drive.metadata.readonly'],
    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

Verwenden Sie die Methode fetch_access_token!, um einen Autorisierungscode für ein Zugriffstoken auszutauschen:

auth_client.code = auth_code
auth_client.fetch_access_token!

Node.js

Verwenden Sie die Methode getToken, um einen Autorisierungscode für ein Zugriffstoken auszutauschen:

const url = require('url');

// Receive the callback from Google's OAuth 2.0 server.
if (req.url.startsWith('/oauth2callback')) {
  // Handle the OAuth 2.0 server response
  let q = url.parse(req.url, true).query;

  // Get access and refresh tokens (if access_type is offline)
  let { tokens } = await oauth2Client.getToken(q.code);
  oauth2Client.setCredentials(tokens);
}

HTTP/REST

Wenn Sie einen Autorisierungscode für ein Zugriffstoken austauschen möchten, rufen Sie den Endpunkt https://oauth2.googleapis.com/token auf und legen Sie die folgenden Parameter fest:

Felder
client_id Die Client-ID, die über API Console Credentials pageabgerufen wird.
client_secret Der Clientschlüssel, der aus API ConsoleCredentials pageabgerufen wurde.
code Der Autorisierungscode, der von der ursprünglichen Anfrage zurückgegeben wurde.
grant_type In der OAuth 2.0-Spezifikation muss der Wert dieses Felds auf authorization_code festgelegt werden.
redirect_uri Einer der Weiterleitungs-URIs, die für die angegebene client_id in der API ConsoleCredentials page für dein Projekt 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, indem er ein JSON-Objekt zurückgibt, das ein kurzlebiges Zugriffstoken und ein Aktualisierungstoken enthält. Hinweis: Das Aktualisierungstoken wird nur zurückgegeben, wenn in der Anwendung der Parameter access_type in der ersten Anfrage an den Autorisierungsserver von Google auf offline gesetzt wurde.

Die Antwort umfasst die folgenden Felder:

Felder
access_token Das Token, das Ihre Anwendung zur Autorisierung einer Google API-Anfrage sendet.
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 Sie den Parameter access_type in der ersten Anfrage an den Autorisierungsserver von Google auf offline setzen.
scope Der Zugriffsbereich, der von access_token gewährt wird, als Liste mit durch Leerzeichen voneinander getrennten Groß-/Kleinschreibung-Strings.
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/drive.metadata.readonly",
  "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
}

Google APIs aufrufen

PHP

Verwenden Sie das Zugriffstoken, um Google APIs aufzurufen. Führen Sie dazu die folgenden Schritte aus:

  1. Wenn Sie ein Zugriffstoken auf ein neues Google_Client-Objekt anwenden müssen – z. B. wenn Sie das Zugriffstoken in einer Nutzersitzung gespeichert haben – verwenden Sie die Methode setAccessToken:
    $client->setAccessToken($access_token);
  2. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Sie erstellen ein Dienstobjekt, indem Sie dem Konstruktor ein autorisiertes Google_Client-Objekt für die API bereitstellen, die Sie aufrufen möchten. So rufen Sie beispielsweise die Drive API auf:
    $drive = new Google_Service_Drive($client);
  3. Anfragen an den API-Dienst über die Schnittstelle, die vom Dienstobjekt bereitgestellt wird So rufen Sie beispielsweise die Dateien im authentifizierten Google Drive-Nutzer auf:
    $files = $drive->files->listFiles(array())->getItems();

Python

Nachdem Sie ein Zugriffstoken abgerufen haben, kann Ihre Anwendung dieses Token verwenden, um API-Anfragen im Namen eines bestimmten Nutzerkontos oder Dienstkontos zu autorisieren. Verwenden Sie die nutzerspezifischen Autorisierungsanmeldedaten, um ein Dienstobjekt für die API zu erstellen, die Sie aufrufen möchten, und verwenden Sie dann dieses Objekt, um autorisierte API-Anfragen zu stellen.

  1. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Zum Erstellen eines Dienstobjekts rufen Sie die Methode build in der googleapiclient.discovery-Bibliothek auf, die den Namen und die Version der API und die Nutzeranmeldedaten enthält: So rufen Sie beispielsweise Version 2 der Drive API auf:
    from googleapiclient.discovery import build
    
    drive = build('drive', 'v2', credentials=credentials)
  2. Anfragen an den API-Dienst über die Schnittstelle, die vom Dienstobjekt bereitgestellt wird So rufen Sie beispielsweise die Dateien im authentifizierten Google Drive-Nutzer auf:
    files = drive.files().list().execute()

Ruby

Führen Sie die folgenden Schritte aus, um die Google APIs mithilfe des Objekts auth_client aufzurufen:

  1. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. So rufen Sie beispielsweise Version 2 der Drive API auf:
    drive = Google::Apis::DriveV2::DriveService.new
  2. Legen Sie die Anmeldedaten für den Dienst fest:
    drive.authorization = auth_client
  3. Anfragen an den API-Dienst über die Schnittstelle, die vom Dienstobjekt zur Verfügung gestellt wird. So rufen Sie beispielsweise die Dateien im authentifizierten Nutzer von Google Drive auf:
    files = drive.list_files

Alternativ kann die Autorisierung pro Methode bereitgestellt werden. Dazu wird der Parameter options an eine Methode übergeben:

files = drive.list_files(options: { authorization: auth_client })

Node.js

Nachdem Sie ein Zugriffstoken abgerufen und auf das Objekt OAuth2 festgelegt haben, rufen Sie Google APIs mit dem Objekt auf. Ihre Anwendung kann dieses Token verwenden, um API-Anfragen für ein bestimmtes Nutzerkonto oder Dienstkonto 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 erhalten hat, können Sie mit dem Token Aufrufe an eine Google API im Namen eines bestimmten Nutzerkontos stellen, sofern die von der API erforderlichen Zugriffsberechtigungen gewährt wurden. Füge dazu das Zugriffstoken in eine Anfrage an die API ein. Füge dazu entweder den access_token-Abfrageparameter oder den Authorization-HTTP-Header-Wert Bearer ein. Der HTTP-Header wird nach Möglichkeit bevorzugt, da Abfragestrings in der Regel in Serverlogs sichtbar sind. In den meisten Fällen können Sie eine Clientbibliothek verwenden, um Aufrufe an Google APIs einzurichten, z. B. beim Aufruf der Drive Files API.

Du kannst alle Google APIs ausprobieren und dir ihre Bereiche im OAuth 2.0 Playground ansehen.

Beispiele für HTTP GET

Ein Aufruf des Endpunkts drive.files (Drive Files API) über den HTTP-Header Authorization: Bearer sieht so aus. Sie müssen Ihr eigenes Zugriffstoken angeben:

GET /drive/v2/files HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

Im Folgenden finden Sie einen Aufruf an die gleiche API für den authentifizierten Nutzer mit dem Abfragestringparameter access_token:

GET https://www.googleapis.com/drive/v2/files?access_token=access_token

Beispiele für curl

Du kannst diese Befehle mit der curl-Befehlszeile testen. Beispiel für die HTTP-Header-Option (bevorzugt):

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files

Alternativ haben Sie die Möglichkeit, die Parameteroption für Abfragestrings auszuwählen:

curl https://www.googleapis.com/drive/v2/files?access_token=access_token

Vollständiges Beispiel

Im folgenden Beispiel wird eine JSON-formatierte Liste von Dateien in Google Drive ausgegeben, nachdem der Nutzer sich authentifiziert und der Anwendung zugestimmt hat, auf die Drive-Metadaten des Nutzers zuzugreifen.

PHP

So führen Sie das Beispiel aus:

  1. Fügen Sie in der API Consoleder Liste der Weiterleitungs-URLs die URL des lokalen Computers hinzu, z. B. http://localhost:8080.
  2. Erstellen Sie ein neues Verzeichnis und ändern Sie es. Beispiel:
    mkdir ~/php-oauth2-example
    cd ~/php-oauth2-example
  3. Installieren Sie die Google API-Clientbibliothek für PHP mit Composer:
    composer require google/apiclient:^2.0
  4. Erstelle die Dateien index.php und oauth2callback.php mit dem Inhalt unten.
  5. Führen Sie das Beispiel mit einem Webserver aus, der für die Bereitstellung von PHP konfiguriert ist. Wenn du PHP 5.4 oder höher verwendest, kannst du den integrierten Test-Webserver von PHP:
    php -S localhost:8080 ~/php-oauth2-example
    verwenden

index.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google_Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $drive = new Google_Service_Drive($client);
  $files = $drive->files->listFiles(array())->getItems();
  echo json_encode($files);
} 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_Drive::DRIVE_METADATA_READONLY);

if (! isset($_GET['code'])) {
  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  $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. Sie führt eine Webanwendung unter http://localhost:8080 aus, mit der Sie den OAuth 2.0-Vorgang testen können. Wenn du diese URL aufrufst, solltest du vier Links sehen:

  • API-Anfrage testen: Dieser Link verweist auf eine Seite, auf der eine API-Beispielanfrage ausgeführt wird. Bei Bedarf wird der Autorisierungsvorgang gestartet. Wenn die Anfrage erfolgreich ist, wird auf der Seite die API-Antwort angezeigt.
  • Authentifizierungsvorgang direkt testen: Dieser Link verweist auf eine Seite, auf der der Nutzer über den Autorisierungsvorgang weitergeleitet wird. Die Anwendung fordert die Berechtigung an, autorisierte API-Anfragen im Namen des Nutzers zu senden.
  • Aktuelle Anmeldedaten widerrufen: Dieser Link verweist auf eine Seite, auf der die Berechtigungen des Nutzers der App aufgehoben werden.
  • Anmeldedaten für Flask löschen: Mit diesem Link werden die in der Flask-Sitzung gespeicherten Anmeldedaten gelöscht. So sehen Sie, was passiert, wenn ein Nutzer, der Ihrer App bereits die Berechtigung erteilt hat, in einer neuen Sitzung eine API-Anfrage ausgeführt hat. Außerdem können Sie sehen, welche API-Antwort Ihre App erhalten würde, wenn ein Nutzer Ihre App widerrufen und Ihre App immer noch versuchen würde, 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/drive.metadata.readonly']
API_SERVICE_NAME = 'drive'
API_VERSION = 'v2'

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'])

  drive = googleapiclient.discovery.build(
      API_SERVICE_NAME, API_VERSION, credentials=credentials)

  files = drive.files().list().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(**files)


@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 Sinatra-Framework verwendet.

require 'google/apis/drive_v2'
require 'google/api_client/client_secrets'
require 'json'
require 'sinatra'

enable :sessions
set :session_secret, 'setme'

get '/' do
  unless session.has_key?(:credentials)
    redirect to('/oauth2callback')
  end
  client_opts = JSON.parse(session[:credentials])
  auth_client = Signet::OAuth2::Client.new(client_opts)
  drive = Google::Apis::DriveV2::DriveService.new
  files = drive.list_files(options: { authorization: auth_client })
  "<pre>#{JSON.pretty_generate(files.to_h)}</pre>"
end

get '/oauth2callback' do
  client_secrets = Google::APIClient::ClientSecrets.load
  auth_client = client_secrets.to_authorization
  auth_client.update!(
    :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
    :redirect_uri => url('/oauth2callback'))
  if request['code'] == nil
    auth_uri = auth_client.authorization_uri.to_s
    redirect to(auth_uri)
  else
    auth_client.code = request['code']
    auth_client.fetch_access_token!
    auth_client.client_secret = nil
    session[:credentials] = auth_client.to_json
    redirect to('/')
  end
end

Node.js

So führen Sie das Beispiel aus:

  1. Fügen Sie in der Liste API Consoledie Weiterleitungs-URLs der lokalen Maschine hinzu, z. B. http://localhost.
  2. Achten Sie darauf, dass auf der Wartung LTS, der aktive LTS-Dienst oder der aktuelle Release von Node.js installiert ist.
  3. Erstellen Sie ein neues Verzeichnis und ändern Sie es. Beispiel:
    mkdir ~/nodejs-oauth2-example
    cd ~/nodejs-oauth2-example
  4. Install the Google API Client Library for Node.js using npm:
    npm install googleapis
  5. Erstellen Sie die Dateien main.js mit dem Inhalt unten.
  6. Führen Sie das Beispiel aus:
    node .\main.js

Haupt.js

const http = require('http');
const https = require('https');
const url = require('url');
const { google } = require('googleapis');

/**
 * 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'
];

// 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
});

/* 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 server = http.createServer(async function (req, res) {
    // Example on redirecting user to Google's OAuth 2.0 server.
    if (req.url == '/') {
      res.writeHead(301, { "Location": authorizationUrl });
    }

    // Receive the callback from Google's OAuth 2.0 server.
    if (req.url.startsWith('/oauth2callback')) {
      // 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 { // 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
    if (req.url == '/revoke') {
      // 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();
    }
    res.end();
  }).listen(80);
}
main().catch(console.error);

HTTP/REST

In diesem Python-Beispiel wird das Flask-Framework und die Requests-Bibliothek verwendet, um den OAuth 2.0-Webfluss zu demonstrieren. Wir empfehlen, für diesen Ablauf die Google API-Clientbibliothek für Python zu verwenden. 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/drive.metadata.readonly'
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/drive/v2/files'
    r = requests.get(req_uri, headers=headers)
    return r.text


@app.route('/oauth2callback')
def oauth2callback():
  if 'code' not in flask.request.args:
    auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code'
                '&client_id={}&redirect_uri={}&scope={}').format(CLIENT_ID, REDIRECT_URI, SCOPE)
    return flask.redirect(auth_uri)
  else:
    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 Weiterleitungen an, um Entwickler zum Schutz ihrer Anwendungen zu unterstützen. Ihre Weiterleitungs-URIs müssen diese Regeln einhalten. Die Definition von Domain, Host, Pfad, Abfrage, Schema und Nutzerinformationen finden Sie im RFC 3986-Abschnitt 3 unten.

Validierungsregeln
Schema

Für Weiterleitungs-URIs muss das HTTPS-Schema verwendet werden, nicht das Nur-HTTP-Schema. Localhost-URIs (einschließlich URIs der Localhost-IP-Adressen) sind von dieser Regel ausgenommen.

Moderator:in

Hosts dürfen keine unformatierten IP-Adressen haben. Localhost-IP-Adressen sind von dieser Regel ausgenommen.

Domain
  • Host-TLDs (Top-Level-Domains) müssen zur öffentlichen Suffixliste gehören.
  • Hostdomains dürfen nicht “googleusercontent.com” sein.
  • Weiterleitungs-URIs dürfen keine URL-Kürzungen-Domains (z.B. goo.gl) enthalten, es sei denn, die App ist Inhaber der Domain. Wenn eine App, die einer kürzeren Domain gehört, eine Weiterleitung zu dieser Domain zulässt, muss der Weiterleitungs-URI entweder “/google-callback/” im Pfad enthalten oder mit “/google-callback” enden.
  • Nutzerinformationen

    Weiterleitungs-URIs dürfen die Nutzerinfo-Unterkomponente nicht enthalten.

    Pfad

    Weiterleitungs-URIs dürfen keinen Pfaddurchlauf (auch Verzeichnis-Backtracking genannt) enthalten, der durch “/..” oder “\..” oder die URL-Codierung dargestellt wird.

    Suchanfrage

    Weiterleitungs-URIs dürfen keine offenen Weiterleitungen enthalten.

    Fragment

    Weiterleitungs-URIs dürfen die Fragmentkomponente nicht enthalten.

    Zeichen Weiterleitungs-URIs dürfen keine der folgenden Zeichen enthalten:
    • Platzhalterzeichen ('*')
    • Nicht druckbare ASCII-Zeichen
    • Ungültige Prozentcodierungen (Prozentzeichen, die nicht der URL-Codierung eines Prozentsatzes folgen, gefolgt von zwei Hexadezimalzeichen)
    • Nullzeichen (ein codiertes NULL-Zeichen, z.B. %00, %C0%80)

    Inkrementelle Autorisierung

    Im OAuth 2.0-Protokoll fordert Ihre Anwendung die Autorisierung für den Zugriff auf Ressourcen an, die über Bereiche identifiziert werden. Es hat sich bewährt, die Autorisierung von Ressourcen zum jeweiligen Zeitpunkt anzufordern. Damit diese Praxis genutzt werden kann, unterstützt der Autorisierungsserver von Google die inkrementelle Autorisierung. Mit diesem Feature können Sie Bereiche nach Bedarf anfordern. Wenn der Nutzer die Berechtigung für den neuen Bereich gewährt, wird ein Autorisierungscode zurückgegeben, der gegen ein Token ausgetauscht wird, das alle vom Nutzer gewährten Bereiche enthält.

    Beispiel: Eine Anwendung, mit der Musik-Tracks aufgenommen und Mixe erstellt werden können, benötigt bei der Anmeldung möglicherweise nur sehr wenige Ressourcen, vielleicht nichts mehr als den Namen der Person, die sich anmeldet. Sie brauchen jedoch Zugriff auf das Google Drive-Konto, um einen fertigen Mix zu speichern. Die meisten Nutzer dürften es als normal ansehen, wenn sie zum Zeitpunkt der App nur Zugriff auf ihr Google Drive-Konto wünschten.

    In diesem Fall fordert die Anwendung zum Zeitpunkt der Anmeldung die Bereiche openid und profile an, um eine grundlegende Anmeldung auszuführen. Später wird dann der Bereich https://www.googleapis.com/auth/drive.file zum Zeitpunkt der ersten Anfrage angefordert, um eine Kombination zu speichern.

    Wenn Sie die inkrementelle Autorisierung implementieren möchten, müssen Sie den normalen Vorgang für die Anforderung eines Zugriffstokens ausführen. Achten Sie dabei aber darauf, dass die Autorisierungsanfrage zuvor gewährte Bereiche enthält. Bei dieser Methode müssen Sie nicht mehr mehrere Zugriffstokens für Ihre Anwendung verwalten.

    Die folgenden Regeln gelten für ein Zugriffstoken, das durch eine inkrementelle Autorisierung abgerufen wird:

    • Mit dem Token können Sie auf Ressourcen zugreifen, die einem der Bereiche entsprechen, die in die neue kombinierte Autorisierung aufgenommen wurden.
    • 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 alle scope-Werte in der Antwort 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 einen Desktop-Client Zugriff auf einen Bereich gewährt und dieser Anwendung dann über einen mobilen Client einen anderen Bereich gewährt, umfasst die kombinierte Autorisierung beide Bereiche.
    • Wenn Sie ein Token widerrufen, das eine kombinierte Autorisierung darstellt, wird der Zugriff auf alle diese Autorisierungsbereiche im Namen des verknüpften Nutzers gleichzeitig widerrufen.

    Für die sprachspezifischen Codebeispiele in Schritt 1: Autorisierungsparameter festlegen und die Beispiel-HTTP-/REST-Weiterleitungs-URL in Schritt 2: Weiterleitung an den OAuth 2.0-Server von Google wird die zusätzliche Autorisierung verwendet. Die folgenden Codebeispiele zeigen auch den Code, den du zur Verwendung der inkrementellen Autorisierung hinzufügen musst.

    PHP

    $client->setIncludeGrantedScopes(true);

    Python

    Legen Sie in Python das Argument include_granted_scopes für das Keyword auf true fest, damit eine Autorisierungsanfrage zuvor gewährte Bereiche enthält. Es ist möglich, dass include_granted_scopes nicht das einzige Keyword-Argument ist, das du festlegst, wie im Beispiel unten 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

    GET https://accounts.google.com/o/oauth2/v2/auth?
      client_id=your_client_id&
      response_type=code&
      state=state_parameter_passthrough_value&
      scope=https%3A//www.googleapis.com/auth/drive.file&
      redirect_uri=https%3A//oauth2.example.com/code&
      prompt=consent&
      include_granted_scopes=true

    Zugriffstoken aktualisieren (Offlinezugriff)

    Zugriffstokens laufen in regelmäßigen Abständen ab und werden zu ungültigen Anmeldedaten für eine entsprechende API-Anfrage. Wenn Sie den Offlinezugriff auf die mit dem Token verknüpften Bereiche angefordert haben, können Sie ein Zugriffstoken aktualisieren, ohne den Nutzer um Erlaubnis zu bitten. Das gilt auch, wenn der Nutzer nicht anwesend ist.

    • Wenn Sie eine Google API-Clientbibliothek verwenden, wird das Zugriffstoken über das Clientobjekt entsprechend aktualisiert, sofern Sie dieses Objekt für den Offlinezugriff konfigurieren.
    • Wenn du keine Clientbibliothek verwendest, musst du den HTTP-Abfrageparameter access_type auf offline setzen, wenn du den Nutzer an den OAuth 2.0-Server von Google weiterleitest. In diesem Fall gibt der Autorisierungsserver von Google ein Aktualisierungstoken zurück, wenn Sie einen Autorisierungscode gegen ein Zugriffstoken austauschen. Wenn das Zugriffstoken dann abläuft (oder zu einem beliebigen anderen Zeitpunkt), können Sie ein Aktualisierungstoken verwenden, um ein neues Zugriffstoken abzurufen.

    Die Anwendung des Offlinezugriffs ist für alle Anwendungen erforderlich, die auf eine Google API zugreifen müssen, wenn der Nutzer nicht vorhanden ist. Beispielsweise muss eine Anwendung, die Sicherungsdienste ausführt oder zu bestimmten Zeiten Aktionen ausführt, ihr Zugriffstoken aktualisieren können, wenn der Nutzer nicht vorhanden ist. Der Standardstil für den Zugriff ist online.

    Serverseitige Webanwendungen, installierte Anwendungen und Geräte erhalten während des Autorisierungsprozesses Aktualisierungstokens. Aktualisierungstokens werden in der Regel nicht in clientseitigen Webanwendungen (JavaScript) verwendet.

    PHP

    Wenn die Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf offline fest:

    $client->setAccessType("offline");

    Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie weiterhin den API-Client verwenden, um im Namen des Nutzers auf Google APIs zuzugreifen. Das Clientobjekt aktualisiert das Zugriffstoken nach Bedarf.

    Python

    Legen Sie in Python das Argument access_type auf offline fest, damit Sie das Zugriffstoken aktualisieren können, ohne den Nutzer noch einmal um Erlaubnis zu bitten. Es ist sehr möglich, dass access_type nicht das einzige Keyword-Argument ist, das Sie festlegen, wie im Beispiel unten 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 weiterhin den API-Client verwenden, um im Namen des Nutzers auf Google APIs zuzugreifen. 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 weiterhin den API-Client verwenden, um im Namen des Nutzers auf Google APIs zuzugreifen. 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 weiterhin den API-Client verwenden, um im Namen des Nutzers auf Google APIs zuzugreifen. Das Clientobjekt aktualisiert das Zugriffstoken nach Bedarf.

    Zugriffstokens laufen ab. Diese Bibliothek verwendet automatisch ein Aktualisierungstoken, um ein neues Zugriffstoken abzurufen. Die Verwendung des Token-Ereignisses ist eine einfache Möglichkeit, um immer die neuesten Tokens zu speichern:

    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 Token-Ereignis tritt nur in der ersten Autorisierung auf. Sie müssen access_type beim Aufrufen der Methode generateAuthUrl auf offline setzen, um das Aktualisierungstoken zu erhalten. Wenn Sie Ihrer Anwendung bereits die erforderlichen Berechtigungen 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 du die refresh_token später einrichten möchtest, kannst du die setCredentials-Methode verwenden:

    oauth2Client.setCredentials({
      refresh_token: `STORED_REFRESH_TOKEN`
    });
    

    Sobald der Client ein Aktualisierungstoken hat, werden Zugriffstokens beim nächsten Aufruf der API automatisch abgerufen und aktualisiert.

    HTTP/REST

    Zum Aktualisieren eines Zugriffstokens sendet Ihre Anwendung eine HTTPS-POST-Anfrage an den Autorisierungsserver von Google (https://oauth2.googleapis.com/token), der die folgenden Parameter enthält:

    Felder
    client_id Die Client-ID, die von API Consoleabgerufen wurde.
    client_secret Der Clientschlüssel aus dem API Console.
    grant_type Wie in der OAuth 2.0-Spezifikation definiert, muss der Wert dieses Feldes auf refresh_token festgelegt werden.
    refresh_token Das Aktualisierungstoken, das vom Austausch des Autorisierungscodes zurückgegeben wurde

    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 Zugriff für die Anwendung 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 die Anzahl der ausgestellten Aktualisierungstokens begrenzt ist, ein Limit pro Client/Nutzer-Kombination und ein weiteres pro Nutzer über alle Clients hinweg. Sie sollten Aktualisierungstokens im Langzeitspeicher speichern und weiterhin verwenden, solange sie gültig sind. Wenn Ihre Anwendung zu viele Aktualisierungstokens anfordert, gelten entsprechende Einschränkungen. In diesem Fall funktionieren ältere Aktualisierungstokens nicht mehr.

    Token widerrufen

    In einigen Fällen möchte ein Nutzer den Zugriff einer Anwendung widerrufen. Ein Nutzer kann den Zugriff in den Kontoeinstellungen widerrufen. Weitere Informationen findest du im Supportdokument Websites und Apps-Zugriff von Websites von Drittanbietern entfernen.

    Es ist auch möglich, dass eine Anwendung den Zugriff für sie programmatisch widerrufen kann. Der programmatische Widerruf ist wichtig, wenn ein Nutzer sich abmeldet, eine Anwendung entfernt oder die für eine Anwendung erforderlichen API-Ressourcen sich erheblich geändert haben. Mit anderen Worten: Der Prozess kann auch eine API-Anfrage umfassen, mit der dafür gesorgt wird, dass die zuvor gewährten Berechtigungen nicht entfernt werden.

    PHP

    Wenn Sie ein Token programmatisch widerrufen möchten, rufen Sie revokeToken() auf:

    $client->revokeToken();

    Python

    Wenn du ein Token programmatisch widerrufen möchtest, sende eine Anfrage an https://oauth2.googleapis.com/revoke, die das Token als Parameter enthält und den Header Content-Type festlegt:

    requests.post('https://oauth2.googleapis.com/revoke',
        params={'token': credentials.token},
        headers = {'content-type': 'application/x-www-form-urlencoded'})

    Ruby

    Möchtest du ein Token programmatisch widerrufen, indem du eine HTTP-Anfrage an den Endpunkt oauth2.revoke sendest:

    uri = URI('https://oauth2.googleapis.com/revoke')
    response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)
    

    Es kann sich dabei um ein Zugriffstoken oder ein Aktualisierungstoken handeln. Wenn es ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken hat, wird auch das Aktualisierungstoken widerrufen.

    Wenn die Sperrung erfolgreich verarbeitet wurde, lautet der Statuscode der Antwort 200. Bei Fehlerbedingungen wird der Statuscode 400 zusammen mit einem Fehlercode zurückgegeben.

    Node.js

    Wenn du ein Token programmatisch widerrufen möchtest, kannst du eine HTTPS-POST-Anfrage an den /revoke-Endpunkt senden:

    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 es ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken hat, wird auch das Aktualisierungstoken widerrufen.

    Wenn die Sperrung 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, sendet Ihre Anwendung eine Anfrage an https://oauth2.googleapis.com/revoke. Dabei wird das Token als Parameter hinzugefügt:

    curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
            https://oauth2.googleapis.com/revoke?token={token}

    Es kann sich dabei um ein Zugriffstoken oder ein Aktualisierungstoken handeln. Wenn das Token ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken hat, wird auch das Aktualisierungstoken widerrufen.

    Wenn der Widerruf erfolgreich verarbeitet wurde, ist der HTTP-Statuscode der Antwort 200. Bei Fehlerbedingungen wird der HTTP-Statuscode 400 zusammen mit einem Fehlercode zurückgegeben.