Diese Seite wurde von der Cloud Translation API übersetzt.

OAuth 2.0

In diesem Dokument wird OAuth 2.0, wann Sie es verwenden sollten, wie Sie Client-IDs erhalten, und wie sie mit der Google API-Clientbibliothek für .NET verwendet werden.

OAuth 2.0-Protokoll

OAuth 2.0 ist das Autorisierungsprotokoll, das von Google APIs verwendet wird. Sie sollten sich mit dem Protokoll unter den folgenden Links vertraut machen:

Client-IDs und Secrets abrufen

Sie können Client-IDs und Secrets in der Google API Console abrufen. Es gibt verschiedene Arten von Client-IDs, Achten Sie daher darauf, den richtigen Typ für Ihre Anwendung auszuwählen:

In jedem der nachfolgenden Code-Snippets (außer im Dienstkonto eines) müssen Sie den Clientschlüssel und speichern ihn als client_secrets.json in Ihrem Projekt.

</ph> Hinweis: Sie müssen die Build-Aktion in „Inhalt“ ändern und der „Copy to Output“- Verzeichnis in „Bei neueren Versionen kopieren“ in der IDE für client_secrets.json. Weitere Informationen zu Clientschlüsseln finden Sie in der Seite Clientschlüssel

Anmeldedaten

Nutzeranmeldedaten

UserCredential ist eine threadsichere Hilfsklasse für den Zugriff auf geschützte Ressourcen mit einem Zugriffstoken. Ein Zugriffstoken läuft in der Regel nach einer Stunde ab. Danach erhalten Sie eine Fehlermeldung, wenn Sie versuchen, es zu verwenden.

UserCredential und AuthorizationCodeFlow für die automatische Aktualisierung das Token, was einfach bedeutet, ein neues Zugriffstoken. Dies geschieht mit einem langlebigen Aktualisierungstoken, das Sie zusammen mit dem Zugriffstokens, wenn Sie den access_type=offline -Parameter während des Vorgangs mit dem Autorisierungscode.

In den meisten Anwendungen empfiehlt es sich, Zugriffstoken für Anmeldedaten und Aktualisierungstoken im nichtflüchtigen Speicher. Andernfalls müssen Sie dem Endnutzer eine im Browser stündlich aktualisiert, da der Zugriff Das Token läuft eine Stunde nach Erhalt ab.

Um sicherzustellen, dass die Zugriffs- und Aktualisierungs-Tokens erhalten bleiben, können Sie Ihre eigene Implementierung IDataStore, Alternativ können Sie eine der folgenden von der Bibliothek bereitgestellten Implementierungen verwenden:

FileDataStore für .NET stellt sicher, dass die Anmeldedaten dauerhaft in einer Datei gespeichert sind.

ServiceAccountCredential

ServiceAccountCredential ähnelt UserCredential, dient aber einem anderen Zweck. Google OAuth 2.0 unterstützt Server-zu-Server-Interaktionen, zum Beispiel zwischen einer Webanwendung und Google Cloud Storage. Die anfragende Anwendung muss ihre eigene Identität nachweisen, um Zugriff auf eine API zu erhalten, und ein Endnutzer muss nicht beteiligt sein. ServiceAccountCredential speichert einen privaten Schlüssel, mit dem eine Anfrage zum Abrufen eines neuen Zugriffstokens signiert wird.

Sowohl UserCredential als auch ServiceAccountCredential implementieren IConfigurableHttpClientInitializer Sie können also Folgendes registrieren:

Ein nicht erfolgreicher Antwort-Handler, Daher wird das Token aktualisiert, wenn es den HTTP-Statuscode 401 empfängt.
Einen Interceptor, um die Authorization abzufangen -Header bei jeder Anfrage.

Installierte Apps

Beispielcode mit der Books API:

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

using Google.Apis.Auth.OAuth2;
using Google.Apis.Books.v1;
using Google.Apis.Books.v1.Data;
using Google.Apis.Services;
using Google.Apis.Util.Store;

namespace Books.ListMyLibrary
{
    /// <summary>
    /// Sample which demonstrates how to use the Books API.
    /// https://developers.google.com/books/docs/v1/getting_started
    /// <summary>
    internal class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            Console.WriteLine("Books API Sample: List MyLibrary");
            Console.WriteLine("================================");
            try
            {
                new Program().Run().Wait();
            }
            catch (AggregateException ex)
            {
                foreach (var e in ex.InnerExceptions)
                {
                    Console.WriteLine("ERROR: " + e.Message);
                }
            }
            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }

        private async Task Run()
        {
            UserCredential credential;
            using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read))
            {
                credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(stream).Secrets,
                    new[] { BooksService.Scope.Books },
                    "user", CancellationToken.None, new FileDataStore("Books.ListMyLibrary"));
            }

            // Create the service.
            var service = new BooksService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Books API Sample",
                });

            var bookshelves = await service.Mylibrary.Bookshelves.List().ExecuteAsync();
            ...
        }
    }
}

In diesem Beispielcode wird eine neue UserCredential-Instanz durch Aufrufen der Methode GoogleWebAuthorizationBroker.AuthorizeAsync-Methode. Diese statische Methode ruft Folgendes ab:
- Der Clientschlüssel (oder ein Stream zum Clientschlüssel)
- Die erforderlichen Bereiche.
- Die Nutzerkennung.
- Das Abbruchtoken zum Abbrechen eines Vorgangs.
- Ein optionaler Datenspeicher. Wenn der Datenspeicher nicht angegeben ist, ist die Standardeinstellung ein FileDataStore. mit dem Standardordner Google.Apis.Auth. Der Ordner wird in Environment.SpecialFolder.ApplicationData erstellt.
Die von dieser Methode zurückgegebene UserCredential ist als HttpClientInitializer festgelegt. auf dem BooksService (mithilfe des Initialisierers). Wie oben erläutert, implementiert UserCredential ein HTTP-Clientinitialisierer.

Im obigen Beispielcode werden die Clientschlüsselinformationen aus einer Datei geladen. Sie können aber auch Folgendes tun:

credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
    new ClientSecrets
    {
        ClientId = "PUT_CLIENT_ID_HERE",
        ClientSecret = "PUT_CLIENT_SECRETS_HERE"
    },
    new[] { BooksService.Scope.Books },
    "user",
    CancellationToken.None,
    new FileDataStore("Books.ListMyLibrary"));

Sehen Sie sich unsere Leseprobe an.

Webanwendungen (ASP.NET Core 3)

Unterstützung für Google APIs <ph type="x-smartling-placeholder"></ph> OAuth 2.0 für Webserveranwendungen.

Die <ph type="x-smartling-placeholder"></ph> Google.Apis.Auth.AspNetCore3 ist die empfohlene Bibliothek für die meisten Google-basierten OAuth 2.0-Szenarien in ASP.NET Core 3-Anwendungen. Es implementiert eine Google-spezifische OpenIdConnect-Authentifizierungs-Handler. Sie unterstützt inkrementelle Authentifizierung und definiert eine injizierbare IGoogleAuthProvider zur Bereitstellung von Google-Anmeldedaten, die mit Google APIs verwendet werden können.

In diesem Abschnitt wird beschrieben, wie Google.Apis.Auth.AspNetCore3 konfiguriert und verwendet wird. Der angezeigte Code hier basiert auf <ph type="x-smartling-placeholder"></ph> Google.Apis.Auth.AspNetCore3.IntegrationTests, ein voll funktionsfähiges Standard-ASP.NET Core 3-Anwendung.

Wenn Sie diese Dokumentation als Anleitung verwenden möchten, benötigen Sie Ihr eigenes ASP.NET Core 3-Anwendung zu testen und diese Schritte als Voraussetzung auszuführen.

Vorbereitung

Installieren Sie die <ph type="x-smartling-placeholder"></ph> Google.Apis.Auth.AspNetCore3-Paket enthalten ist.
Wir verwenden die Google Drive API. Sie können also müssen außerdem die Google.Apis.Drive.v3 Paket.
Erstellen Sie ein Google Cloud-Projekt, falls Sie noch keines haben. Folgen <ph type="x-smartling-placeholder"></ph> dieser Anleitung. Dies ist das Projekt, mit dem Ihre App identifiziert wird.
Aktivieren Sie die Google Drive API. Um APIs zu aktivieren, folgen Sie <ph type="x-smartling-placeholder"></ph> dieser Anleitung.
Erstellen Sie Autorisierungsanmeldedaten, mit denen Ihre App für Google identifiziert wird. Folgen <ph type="x-smartling-placeholder"></ph> dieser Anleitung, um Anmeldedaten für die Autorisierung zu erstellen und die client_secrets.json-Datei. Zwei Highlights: <ph type="x-smartling-placeholder">
- Die Anmeldedaten muss Webanwendung sein.
- Zum Ausführen dieser Anwendung müssen Sie nur den Weiterleitungs-URI hinzufügen: https://localhost:5001/signin-oidc

Anwendung für die Verwendung von Google.Apis.Auth.AspNetCore3 konfigurieren

Google.Apis.Auth.AspNetCore3 ist in der Startup-Klasse oder ähnlich konfiguriert die Sie nutzen könnten. Die folgenden Snippets werden aus <ph type="x-smartling-placeholder"></ph> Startup.cs im Projekt „Google.Apis.Auth.AspNetCore3.IntegrationTests“.

Fügen Sie die folgende Nutzungs-Anweisung in die Datei Startup.cs ein.
```
using Google.Apis.Auth.AspNetCore3;
```

Fügen Sie in der Methode Startup.ConfigureServices den folgenden Code hinzu und ändern Sie die die Platzhalter für Client-ID und Clientschlüssel mit den Werten in der client_secrets.json-Datei. Sie können diese Werte direkt aus der JSON-Datei laden. oder auf andere sichere Weise speichern. Werfen Sie einen Blick auf die <ph type="x-smartling-placeholder"></ph> ClientInfo.Load-Methode in der Methode „Google.Apis.Auth.AspNetCore3.IntegrationTests“ Projekt. Dort finden Sie ein Beispiel dafür, wie diese Werte direkt aus der JSON-Datei geladen werden.

public void ConfigureServices(IServiceCollection services)
{
    ...

    // This configures Google.Apis.Auth.AspNetCore3 for use in this app.
    services
        .AddAuthentication(o =>
        {
            // This forces challenge results to be handled by Google OpenID Handler, so there's no
            // need to add an AccountController that emits challenges for Login.
            o.DefaultChallengeScheme = GoogleOpenIdConnectDefaults.AuthenticationScheme;
            // This forces forbid results to be handled by Google OpenID Handler, which checks if
            // extra scopes are required and does automatic incremental auth.
            o.DefaultForbidScheme = GoogleOpenIdConnectDefaults.AuthenticationScheme;
            // Default scheme that will handle everything else.
            // Once a user is authenticated, the OAuth2 token info is stored in cookies.
            o.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        })
        .AddCookie()
        .AddGoogleOpenIdConnect(options =>
        {
            options.ClientId = {YOUR_CLIENT_ID};
            options.ClientSecret = {YOUR_CLIENT_SECRET};
        });
}

Fügen Sie in der Methode Startup.Configure die ASP.NET Core 3-Authentifizierung hinzu und Autorisierungs-Middleware-Komponenten zur Pipeline sowie HTTPS-Weiterleitungen:
```
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    ...
    app.UseHttpsRedirection();
    ...

    app.UseAuthentication();
    app.UseAuthorization();

    ...
}
      
```
<ph type="x-smartling-placeholder">
</ph> Hinweis: Warum Sie die HTTPS-Weiterleitung verwenden sollten, erfahren Sie in den SameSite-Cookie-Änderungen ASP.NET Core 3.1 eingeführt. Damit die OpenID-Authentifizierung funktioniert, mit dem Identitätsserver ausgetauschte Cookies auf SameSite=None eingestellt werden, setzt auch voraus, dass diese Cookies gesichert werden. Wenn Ihre Anwendung HTTP-Anfragen unterstützt, Der einfachste Weg, um sicherzustellen, dass Identitätscookies gesichert werden, ist die Unterstützung von HTTPS. und anschließend die HTTPS-Weiterleitung konfigurieren.

Mit den Anmeldedaten des Nutzers in seinem Namen auf Google APIs zugreifen

Sie können jetzt Ihren Controllern Aktionsmethoden hinzufügen, für die die Nutzeranmeldedaten erforderlich sind in ihrem Namen auf Google APIs zugreifen. Das folgende Snippet zeigt, wie die Dateien im Google Drive-Konto des authentifizierten Nutzers. Beachten Sie vor allem zwei Dinge:

Der Nutzer muss nicht nur authentifiziert sein, sondern auch die Berechtigung https://www.googleapis.com/auth/drive.readonly zu Ihrer Anwendung, die die Sie mit dem Attribut GoogleScopedAuthorize festlegen.
Wir verwenden den Standard-Mechanismus zum Einschleusen von Abhängigkeiten von ASP.NET Core 3, um eine IGoogleAuthProvider, mit dem wir die Anmeldedaten des Nutzers abrufen.

Der Code:

Fügen Sie zunächst die folgenden mithilfe von -Anweisungen zu Ihrem Controller hinzu.

using Google.Apis.Auth.AspNetCore3;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

Fügen Sie die Controller-Aktion wie folgt hinzu (und begleiten Sie sie mit einer einfachen Ansicht) das ein IList<string>-Modell erhält):

/// <summary>
/// Lists the authenticated user's Google Drive files.
/// Specifying the <see cref="GoogleScopedAuthorizeAttribute"> will guarantee that the code
/// executes only if the user is authenticated and has granted the scope specified in the attribute
/// to this application.
/// </summary>
/// <param name="auth">The Google authorization provider.
/// This can also be injected on the controller constructor.</param>
[GoogleScopedAuthorize(DriveService.ScopeConstants.DriveReadonly)]
public async Task<IActionResult> DriveFileList([FromServices] IGoogleAuthProvider auth)
{
    GoogleCredential cred = await auth.GetCredentialAsync();
    var service = new DriveService(new BaseClientService.Initializer
    {
        HttpClientInitializer = cred
    });
    var files = await service.Files.List().ExecuteAsync();
    var fileNames = files.Files.Select(x => x.Name).ToList();
    return View(fileNames);
}

Und das sind die Grundlagen. Sie können sich <ph type="x-smartling-placeholder"></ph> HomeController.cs aus dem Projekt „Google.Apis.Auth.AspNetCore3.IntegrationTests“ wie Sie diese Ziele erreichen können:

Nur Nutzerauthentifizierung ohne bestimmte Bereiche
Abmeldefunktion
Inkrementelle Autorisierung über Code. Wie Sie sehen, zeigt das Snippet oben über Attribute.
Aktuell gewährte Bereiche untersuchen
Zugriffs- und Aktualisierungstoken untersuchen
Erzwingen Sie die Aktualisierung des Zugriffstokens. Beachten Sie, dass Sie dies nicht selbst tun müssen, Google.Apis.Auth.AspNetCore3 erkennt, ob das Zugriffstoken abgelaufen ist oder bald abläuft. und wird automatisch aktualisiert.

Dienstkonto

Google APIs unterstützen auch Dienstkonten: Im Gegensatz zu einem Szenario, in dem eine Client-Anwendung Zugriff auf die Daten eines Endnutzers anfordert, Dienstkonten ermöglichen Zugriff auf die eigenen Daten der Clientanwendung.

Ihre Clientanwendung signiert die Anforderung eines Zugriffstokens mithilfe eines heruntergeladenen privaten Schlüssels. über die Google API Console. Nachdem Sie eine neue Client-ID erstellt haben, sollten Sie ein „Dienstkonto“ auswählen Anschließend können Sie den privaten Schlüssel herunterladen. Werfen Sie einen Blick in unsere <ph type="x-smartling-placeholder"></ph> Dienstkontobeispiel mit der Google Plus API.

using System;
using System.Security.Cryptography.X509Certificates;

using Google.Apis.Auth.OAuth2;
using Google.Apis.Plus.v1;
using Google.Apis.Plus.v1.Data;
using Google.Apis.Services;

namespace Google.Apis.Samples.PlusServiceAccount
{
    /// <summary>
    /// This sample demonstrates the simplest use case for a Service Account service.
    /// The certificate needs to be downloaded from the Google API Console
    /// <see cref="https://console.cloud.google.com/">
    ///   "Create another client ID..." -> "Service Account" -> Download the certificate,
    ///   rename it as "key.p12" and add it to the project. Don't forget to change the Build action
    ///   to "Content" and the Copy to Output Directory to "Copy if newer".
    /// </summary>
    public class Program
    {
        // A known public activity.
        private static String ACTIVITY_ID = "z12gtjhq3qn2xxl2o224exwiqruvtda0i";

        public static void Main(string[] args)
        {
            Console.WriteLine("Plus API - Service Account");
            Console.WriteLine("==========================");

            String serviceAccountEmail = "SERVICE_ACCOUNT_EMAIL_HERE";

            var certificate = new X509Certificate2(@"key.p12", "notasecret", X509KeyStorageFlags.Exportable);

            ServiceAccountCredential credential = new ServiceAccountCredential(
               new ServiceAccountCredential.Initializer(serviceAccountEmail)
               {
                   Scopes = new[] { PlusService.Scope.PlusMe }
               }.FromCertificate(certificate));

            // Create the service.
            var service = new PlusService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = "Plus API Sample",
            });

            Activity activity = service.Activities.Get(ACTIVITY_ID).Execute();
            Console.WriteLine("  Activity: " + activity.Object.Content);
            Console.WriteLine("  Video: " + activity.Object.Attachments[0].Url);

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
    }
}

Mit dem obigen Beispielcode wird ein ServiceAccountCredential Die erforderlichen Bereiche sind festgelegt und FromCertificate wird aufgerufen, mit dem der private Schlüssel aus dem angegebenen X509Certificate2 geladen wird. Wie bei allen anderen Beispielcodes sind die Anmeldedaten auf HttpClientInitializer festgelegt.