OAuth 2.0 für Webserveranwendungen verwenden

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.

OAuth 2.0 ermöglicht es Nutzern, bestimmte Daten für eine Anwendung freizugeben, während ihre 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 nutzerspezifische 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.

Hinweis: Aufgrund der Auswirkungen auf die Sicherheit, wenn die Implementierung abgerufen wird korrekt ist, empfehlen wir dringend, für die Interaktion mit den OAuth-2.0-Bibliotheken OAuth 2.0-Endpunkte. Es empfiehlt sich, gut debuggenden Code anderer Nutzer zu verwenden. können Sie sich und Ihre Nutzer besser schützen. Weitere Informationen finden Sie unter Clientbibliotheken

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:

• Go
• Java
• .NET
• Node.js
• PHP
• Python
• Ruby

Wichtig: Der Google API-Client Bibliothek für JavaScript und Über Google anmelden sind nur für die Verarbeitung von OAuth 2.0 im Browser des Nutzers vorgesehen. Wenn Sie JavaScript auf dem zur Verwaltung von OAuth 2.0-Interaktionen mit Google verwendet, Node.js-Bibliothek auf Ihrer Backend-Plattform

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:

1. Open the API Library in der Google API Console.
2. If prompted, select a project, or create a new one.
3. 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.

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. 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 wird http://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.

Wichtig:Speichern Sie die Datei client_secret.json nicht in einem öffentlich zugänglich sind. Wenn Sie den Quellcode an Ihren in einer Anwendung, z. B. auf GitHub, die Datei client_secret.json speichern außerhalb der Quellstruktur, um zu vermeiden, dass Ihre Clientanmeldedaten versehentlich weitergegeben werden.

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.

Wenn Ihre öffentliche Anwendung Bereiche verwendet, die den Zugriff auf bestimmte Nutzerdaten muss ein Überprüfungsverfahren durchlaufen werden. Wenn Sie das Symbol Nicht überprüft App angezeigt wird, müssen Sie ein um sie zu entfernen. Weitere Informationen zu nicht überprüfte Apps und erhalte Antworten auf <ph type="x-smartling-placeholder"></ph> Antworten auf häufig gestellte Fragen zur App-Bestätigung finden Sie in der Hilfe.

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 pip-Paketverwaltungstool.
• 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 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 über Folgendes verfügen: Einwilligung erteilen, bevor eine Google API-Anfrage ausgeführt werden kann, die eine Nutzerautorisierung erfordert.

Die folgende Liste fasst diese Schritte kurz zusammen:

1. Ihre Anwendung ermittelt die erforderlichen Berechtigungen.
2. Der Nutzer wird von Ihrer Anwendung zusammen mit der Liste der angeforderten Dokumente an Google weitergeleitet. Berechtigungen.
3. Der Nutzer entscheidet, ob er Ihrer Anwendung die Berechtigungen erteilen möchte.
4. Ihre Anwendung findet heraus, was der Nutzer entschieden hat.
5. Wenn der Nutzer die angeforderten Berechtigungen gewährt hat, ruft Ihre Anwendung Tokens ab, die für API-Anfragen im Namen des Nutzers durchführen

Schritt 1: Autorisierungsparameter festlegen

Der erste Schritt besteht darin, die Autorisierungsanfrage zu erstellen. 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

Mit dem folgenden Code-Snippet wird ein Google\Client()-Objekt erstellt, 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('[e-mail]');

// 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='[e-mail]',
    # 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 nach Berechtigungen zum Abrufen eines Zugriffstokens von einem Nutzer fragen, 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 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 client_id erhalten Sie eine redirect_uri_mismatch Fehler. Beachten Sie, dass das Schema http oder https, die Groß-/Kleinschreibung und der nachgestellte Schrägstrich ('/') müssen übereinstimmen.
response_type	Erforderlich Bestimmt, ob der Google OAuth 2.0-Endpunkt einen Autorisierungscode zurückgibt. Legen Sie den Parameterwert für Webserveranwendungen auf code fest.
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. Mit 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: 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 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 online (Standardwert) Wert und offline. Legen Sie den Wert auf offline fest, wenn Ihre Anwendung die Zugriffstokens aktualisieren muss Der Nutzer ist nicht im Browser. Dies ist die Methode zum Aktualisieren des Zugriffs Tokens, die weiter unten in diesem Dokument beschrieben werden. Dieser Wert weist die Google-Autorisierung an, ein Aktualisierungstoken und ein Zugriffstoken zurückzugeben, wenn die Anwendung tauscht einen Autorisierungscode gegen Tokens aus.
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 name=value-Paar im URL-Suchkomponente (?) von redirect_uri, nachdem der Nutzer den Nutzungsbedingungen Ihrer Anwendung zustimmt oder sie ablehnt Zugriffsanforderung. 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 redirect_uri erraten werden kann, verwenden Sie einen state können Sie sicher sein, dass eine eingehende Verbindung das Ergebnis eines Authentifizierungsanfrage an. Wenn Sie einen zufälligen String generieren oder den Hash eines Cookies oder einen anderen Wert, der den Status des Clients erfasst, können Sie die Antwort auf Außerdem muss sichergestellt werden, dass Anfrage und Antwort aus demselben Browser stammen. und bietet Schutz vor Angriffen wie websiteübergreifende Anfrage Fälschung. Weitere Informationen finden Sie in der OpenID Connect Dokumentation mit einem Beispiel zum Erstellen und Bestätigen eines state-Tokens. Wichtig: Der OAuth-Client muss die CSRF verhindern, wie im OAuth2-Spezifikation . Eine Möglichkeit, dies zu erreichen, besteht darin, den Parameter state zu verwenden, Status zwischen Ihrer Autorisierungsanfrage und der Antwort des Autorisierungsservers.
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 true setzen und das Attribut Autorisierungsanfrage gewährt wurde, deckt das neue Zugriffstoken auch alle Bereiche ab, die der Nutzer der Anwendung zuvor Zugriff gewährt hat. Weitere Informationen finden Sie in der inkrementelle Autorisierung.
enable_granular_consent	Optional Die Standardeinstellung ist true. Wenn false festgelegt ist, gilt Folgendes: mehr detaillierte Google-Kontoberechtigungen wird für OAuth-Client-IDs deaktiviert, die vor 2019 erstellt wurden. Keine Auswirkungen auf neuere OAuth-Client-IDs, da für sie immer detailliertere Berechtigungen aktiviert sind. 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 zu 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 sub-Kennung fest. mit der Google-ID des Nutzers übereinstimmen.
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: none Keine Authentifizierungs- oder Zustimmungsbildschirme anzeigen. Darf nicht angegeben werden mit andere Werte. consent Den Nutzer um seine Einwilligung bitten. select_account Nutzer auffordern, ein Konto auszuwählen

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

1. Generieren Sie eine URL, um den Zugriff vom OAuth 2.0-Server von Google anzufordern:

   $auth_url = $client->createAuthUrl();

2. Leite den Nutzer zu $auth_url weiter:

   header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

In diesem Beispiel wird gezeigt, wie der Nutzer über das Flask-Web zur Autorisierungs-URL weitergeleitet wird Anwendungsframework:

return flask.redirect(authorization_url)

Ruby

1. 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)

2. Leite den Nutzer zu auth_uri weiter.

Node.js

1. Verwenden Sie die generierte URL authorizationUrl aus Schritt 1 generateAuthUrl, um den Zugriff vom OAuth 2.0-Server von Google anzufordern.
2. Leite den Nutzer zu authorizationUrl weiter.

   res.redirect(authorizationUrl);

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability. The URL requests access to a scope that permits access to retrieve the user's YouTube data. It uses incremental authorization (include_granted_scopes=true) to ensure that the new access token covers any scopes to which the user previously granted the application access. Several other parameters are also set in the example.

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 für die er die Berechtigung anfordert, mit den Anmeldedaten des Nutzers 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 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 zum Autorisierungsendpunkt von Google OAuth 2.0 von für Ihre Website. Entwickler sollten das Öffnen allgemeiner Links im Standard-Link-Handler der Betriebssystem, das sowohl Android-App-Links oder die Standard-Browser-App verwenden. 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 Google zum 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 die Standard-Browser-App verwenden. 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 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 anzuzeigen, 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 mehrere Gründe geben:

• Die Anfrage war nicht richtig formatiert
• In der Anfrage fehlen erforderliche Parameter
• In der Anfrage wird eine Autorisierungsmethode verwendet, die von Google nicht unterstützt wird. OAuth bestätigen Für die Integration wird eine empfohlene Integrationsmethode verwendet.

Schritt 4: Die Antwort des OAuth 2.0-Servers verarbeiten

Wichtig: Bevor Sie die OAuth 2.0-Antwort auf dem Server verarbeiten, sollten Sie sich vergewissern, dass die Die von Google erhaltene state stimmt mit der state überein, die im Autorisierungsanfrage. So können wir sichergehen, dass keine böswilligen Nutzer die Anfrage stellt, und verringert das Risiko, CSRF-Angriffe:

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

Wichtig: Wenn Ihr Antwortendpunkt eine HTML-Seite können alle Ressourcen auf dieser Seite den Autorisierungscode in der URL sehen. Skripts können die URL direkt lesen. Die URL im HTTP-Header Referer könnte sein an beliebige oder alle Ressourcen auf der Seite gesendet.

Überlegen Sie sich gut, ob Sie Autorisierungsanmeldedaten an alle Ressourcen auf Seite hinzu. Dies gilt insbesondere für Skripts von Drittanbietern wie Plug-ins für soziale Netzwerke und Analysen. Um dies zu vermeiden sollte der Server die Anfrage erst verarbeiten und dann eine Weiterleitung an einen anderen URL ohne Antwortparameter.

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. Verwenden Sie dann die Methode flow.fetch_token, um die Autorisierung auszutauschen. 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 das 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

Wichtig: Ihre App sollte beide Tokens in einem sicheren, Langlebigen Speicherort, auf den zwischen verschiedenen Aufrufen Ihrer Anwendung zugegriffen werden kann. Die Mit einem Aktualisierungstoken kann Ihre Anwendung ein neues Zugriffstoken abrufen, wenn das Zugriffstoken verfällt. Wenn Ihre Anwendung das Aktualisierungstoken verliert, muss der Nutzer das OAuth 2.0-Zustimmungsvorgang, damit Ihre Anwendung ein neues Aktualisierungstoken abrufen kann.

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"
}

Hinweis: Ihre Anwendung sollte alle nicht erkannten Felder in den der Antwort.

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:

1. 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 Methode setAccessToken-Methode:

   $client->setAccessToken($access_token);

2. 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);

3. 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.

1. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Sie erstellen ein Dienstobjekt, indem Sie durch Aufrufen der build-Methode der googleapiclient.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)

2. 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.

1. 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

2. Legen Sie die Anmeldedaten für den Dienst fest:

   youtube.authorization = credentials

3. 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 im Namen einer bestimmten 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 der Regel in Serverprotokollen 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 ausprobieren und ihre Bereiche auf der OAuth 2.0 Playground.

Beispiele für HTTP GET

Ein Aufruf an die 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

Hier ist ein 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 dieser die um diese Daten abzurufen.

PHP

So führen Sie das Beispiel aus:

1. Fügen Sie im API Consoledie URL des lokalen Computers zum Liste mit Weiterleitungs-URLs. Fügen Sie beispielsweise http://localhost:8080 hinzu.
2. Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Hier einige Beispiele:

   mkdir ~/php-oauth2-example
   cd ~/php-oauth2-example

3. Google API-Client installieren Bibliothek für PHP mit Composer verwenden:

   composer require google/apiclient:^2.10

4. Erstellen Sie die Dateien index.php und oauth2callback.php mit dem Inhalt. weiter unten.
5. 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.

Hinweis: Um diesen Code lokal auszuführen, müssen Sie die Anweisungen in Voraussetzungen, einschließlich der http://localhost:8080 als gültiger Weiterleitungs-URI für Ihre Anmeldedaten und Downloads die Datei client_secret.json für diese Anmeldedaten in Ihr Arbeitsverzeichnis.

# -*- 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:

1. Fügen Sie in der API Consoledie URL der lokalen Computer hinzu. Fügen Sie beispielsweise http://localhost.
2. Achten Sie darauf, dass Sie die Wartung „Langzeitsupport“, eine aktive Version von „Langzeitsupport“ oder die aktuelle Version von Node.js wurde installiert.
3. Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Hier einige Beispiele:

   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 unten stehenden Inhalt.
6. 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	Host-TLDs (Top-Level-Domains) muss zur öffentlichen Suffixliste gehören. Hostdomains dürfen nicht “googleusercontent.com” sein. Weiterleitungs-URIs dürfen keine URL Shortener-Domains (z.B. 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 “/..” oder “\..” oder eine entsprechende URL dargestellt wird. Codierung.
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: Platzhalterzeichen ('*') Nicht druckbare ASCII-Zeichen Ungültige Prozentcodierung (Prozentcodierung, die nicht der URL-Codierung entspricht) Form eines Prozentzeichens gefolgt von zwei Hexadezimalziffern) Nullzeichen (codiertes NULL-Zeichen, z.B. %00, %C0%80)

Inkrementelle Autorisierung

Im OAuth 2.0-Protokoll fordert Ihre Anwendung 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.

Achtung:Wenn Sie zugelassene Bereiche einschließen, Bereiche, die der Nutzer zuvor Ihrer Autorisierungsanfrage gewährt hat. Eine Warn- oder Fehlerseite kann wird angezeigt, wenn Ihre App derzeit nicht berechtigt ist, alle Bereiche anzufordern, die in auf die Antwort. Weitere Informationen finden Sie unter Nicht überprüfte Apps für finden Sie weitere Informationen.

Die sprachspezifischen Codebeispiele in Schritt 1: Autorisierung festlegen Parameter und die 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 to offline 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, 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 werden 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 Bei Fehlerbedingungen wird der HTTP-Statuscode 400 zusammen mit mit einem Fehlercode.

Hinweis:Nach einer erfolgreichen Widerrufsantwort kann es einige Zeit dauern, bevor der Widerruf vollumfänglich in Kraft tritt.