OAuth 2.0

इस दस्तावेज़ में OAuth 2.0, उसका इस्तेमाल कब किया जा सकता है, Client-ID कैसे हासिल करें, साथ ही, .NET के लिए Google API क्लाइंट लाइब्रेरी के साथ इसका इस्तेमाल कैसे करें.

OAuth 2.0 प्रोटोकॉल

OAuth 2.0, अनुमति देने वाला ऐसा प्रोटोकॉल है जिसका इस्तेमाल Google API करता है. प्रोटोकॉल के बारे में जानने के लिए, यहां दिए गए लिंक पढ़ें:

क्लाइंट आईडी और सीक्रेट पाना

आपको Google API कंसोल पर क्लाइंट आईडी और सीक्रेट मिल सकते हैं. क्लाइंट आईडी कई तरह के होते हैं. इसलिए, यह पक्का करें कि आपके आवेदन का टाइप सही हो:

नीचे दिए गए हर कोड स्निपेट में (सेवा खाते वाले एक को छोड़कर), आपको क्लाइंट सीक्रेट को सेव करेगा और उसे अपने प्रोजेक्ट में client_secrets.json के तौर पर सेव करेगा.

क्रेडेंशियल

उपयोगकर्ता के क्रेडेंशियल

UserCredential यह एक थ्रेड से सुरक्षित हेल्पर क्लास है. यह सुरक्षित संसाधनों को ऐक्सेस करने के लिए ऐक्सेस टोकन का इस्तेमाल करता है. ऐक्सेस टोकन की समयसीमा, आम तौर पर एक घंटे बाद खत्म हो जाती है. इसके बाद, अगर आपने इसका इस्तेमाल करने की कोशिश की, तो आपको गड़बड़ी का मैसेज मिलेगा.

UserCredential और AuthorizationCodeFlow अपने आप "रीफ़्रेश होने" का ध्यान रखें टोकन का मतलब है, जिसका मतलब है कि कोई नया ऐक्सेस टोकन जोड़ें. ऐसा लंबे समय तक चलने वाले रीफ़्रेश टोकन का इस्तेमाल करके किया जाता है. यह टोकन आपको ऐक्सेस टोकन पाने के लिए, अगर आप access_type=offline पैरामीटर को कॉन्फ़िगर करने की ज़रूरत नहीं होती.

ज़्यादातर ऐप्लिकेशन में, हमारी सलाह है कि क्रेडेंशियल का ऐक्सेस टोकन और रीफ़्रेश टोकन को स्थायी स्टोरेज में रखा जाता है. ऐसा न होने पर, आपको असली उपयोगकर्ता को ब्राउज़र में हर घंटे प्राधिकरण पेज होने लगता है, क्योंकि ऐक्सेस टोकन मिलने के एक घंटे बाद उसकी समयसीमा खत्म हो जाती है.

यह पक्का करने के लिए कि ऐक्सेस और रीफ़्रेश टोकन बने रहें, तो अपने हिसाब से यह तय किया जा सकता है कि IDataStore या लाइब्रेरी से मिले इनमें से किसी एक तरीके का इस्तेमाल किया जा सकता है:

  • FileDataStore .NET के लिए यह पक्का करता है कि क्रेडेंशियल किसी फ़ाइल में लगातार बना रहेगा.

ServiceAccountCredential

ServiceAccountCredential UserCredential से मिलती-जुलती है, लेकिन इसका मकसद अलग है. Google OAuth 2.0, सर्वर-टू-सर्वर इंटरैक्शन के साथ काम करता है. जैसे, वेब ऐप्लिकेशन और Google Cloud Storage के बीच होने वाले इंटरैक्शन. किसी एपीआई का ऐक्सेस पाने के लिए, अनुरोध करने वाले ऐप्लिकेशन को अपनी पहचान साबित करनी होगी. साथ ही, असली उपयोगकर्ता को इसमें शामिल होने की ज़रूरत नहीं है. ServiceAccountCredential में एक निजी पासकोड सेव होता है, जिसका इस्तेमाल नया ऐक्सेस टोकन पाने के अनुरोध पर हस्ताक्षर करने के लिए किया जाता है.

UserCredential और ServiceAccountCredential, दोनों लागू होती हैं IConfigurableHttpClientInitializer तो आप इनमें से हर एक को इस रूप में रजिस्टर कर सकते हैं:

  • एक असफल रिस्पॉन्स हैंडलर, इसलिए, एचटीटीपी 401 स्टेटस कोड मिलने पर यह टोकन को रीफ़्रेश कर देगा.
  • Authorization को इंटरसेप्ट करने के लिए, इंटरसेप्टर हेडर दिखाई देता है.

इंस्‍टॉल किए गए ऐप्स

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();
            ...
        }
    }
}

  • इस नमूना कोड में एक नया UserCredential इंस्टेंस इस GoogleWebAuthorizationBroker.AuthorizeAsync तरीका. इस स्टैटिक तरीके से ये चीज़ें मिलती हैं:

    • क्लाइंट सीक्रेट (या क्लाइंट सीक्रेट के लिए स्ट्रीम).
    • ज़रूरी स्कोप.
    • उपयोगकर्ता आइडेंटिफ़ायर.
    • किसी कार्रवाई को रद्द करने के लिए रद्द करने का टोकन.
    • एक वैकल्पिक डेटा स्टोर. अगर डेटा स्टोर के बारे में नहीं बताया गया है, तो FileDataStore डिफ़ॉल्ट होता है डिफ़ॉल्ट Google.Apis.Auth फ़ोल्डर के साथ. यह फ़ोल्डर Environment.SpecialFolder.ApplicationData में बनाया गया है.

  • इस तरीके से मिलने वाले UserCredential को HttpClientInitializer के तौर पर सेट किया गया है BooksService पर (प्रोसेसर का इस्तेमाल करके). जैसा कि ऊपर बताया गया है, UserCredential एचटीटीपी क्लाइंट इनिशलाइज़र.

  • ध्यान दें कि ऊपर दिए गए सैंपल कोड में, क्लाइंट की सीक्रेट जानकारी किसी फ़ाइल से लोड की गई है, हालांकि, ये काम भी किए जा सकते हैं: 

    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"));

किताबों के नमूने पर एक नज़र डालें.

वेब ऐप्लिकेशन (ASP.NET Core 3)

Google API से जुड़ी सहायता वेब सर्वर ऐप्लिकेशन के लिए OAuth 2.0.

Google.Apis.Auth.AspNetCore3 की लाइब्रेरी का सुझाव दिया जाता है, ताकि Google के ज़्यादातर संगठनों में इसका इस्तेमाल किया जा सके ASP.NET Core 3 ऐप्लिकेशन में OAuth 2.0 के उदाहरण. यह Google की एक खास सुविधा लागू करता है OpenIdConnect पुष्टि करने वाला हैंडलर. यह इंक्रीमेंटल ऑथेंटिकेशन की सुविधा देता है और इंजेक्ट किए जाने वाले Google के एपीआई के साथ इस्तेमाल किए जा सकने वाले Google के क्रेडेंशियल देने के लिए IGoogleAuthProvider.

इस सेक्शन में Google.Apis.Auth.AspNetCore3 को कॉन्फ़िगर और इस्तेमाल करने का तरीका बताया गया है. कोड दिखाया गया यह इस पर आधारित है Google.Apis.Auth.AspNetCore3.IntegrationTests, जो पूरी तरह से काम करने वाला स्टैंडर्ड ASP.NET है कोर 3 ऐप्लिकेशन.

अगर आप ट्यूटोरियल के रूप में इस दस्तावेज़ का पालन करना चाहते हैं, तो आपको अपने ASP.NET की ज़रूरत होगी कोर 3 ऐप्लिकेशन और ज़रूरी शर्तों के तौर पर इन चरणों को पूरा करना.

ज़रूरी शर्तें

  • इंस्टॉल करें Google.Apis.Auth.AspNetCore3 पैकेज.
  • हम Google डिस्क API का उपयोग कर रहे हैं, इसलिए इसे इंस्टॉल करने की ज़रूरत है Google.Apis.Drive.v3 पैकेज.
  • अगर आपके पास पहले से Google Cloud प्रोजेक्ट नहीं है, तो एक प्रोजेक्ट बनाएं. फ़ॉलो करें इन निर्देशों का पालन करें. यह वह प्रोजेक्ट होगा जिससे आपके ऐप्लिकेशन की पहचान की जाती है.
  • पक्का करें कि आपने Google Drive API को चालू किया हो. एपीआई चालू करने के लिए, यह तरीका अपनाएं ये निर्देश पढ़ें.
  • ऐसे अनुमति देने वाले क्रेडेंशियल बनाएं जिनसे Google आपके ऐप्लिकेशन की पहचान कर सके. फ़ॉलो करें इन निर्देशों का पालन करके पुष्टि करने के क्रेडेंशियल बनाए जा सकते हैं और client_secrets.json फ़ाइल. दो खास बातें:
    • ध्यान दें कि क्रेडेंशियल प्रकार वेब ऐप्लिकेशन होना चाहिए.
    • इस ऐप्लिकेशन को चलाने के लिए, आपको केवल यह रीडायरेक्ट यूआरआई जोड़ने की ज़रूरत है https://localhost:5001/signin-oidc.

Google.Apis.Auth.AspNetCore3 का इस्तेमाल करने के लिए, अपना ऐप्लिकेशन कॉन्फ़िगर करें

Google.Apis.Auth.AspNetCore3 को Startup क्लास या इसके मिलते-जुलते वर्शन में कॉन्फ़िगर किया गया है इस्तेमाल किया जा रहा है. निम्न स्निपेट यहां से निकाले गए हैं Startup.cs.

  • अपनी Startup.cs फ़ाइल में, डायरेक्टिव का इस्तेमाल करके ये जोड़ें. 
    using Google.Apis.Auth.AspNetCore3;
  • Startup.ConfigureServices विधि में निम्न कोड जोड़ें, Client-ID और क्लाइंट सीक्रेट प्लेसहोल्डर client_secrets.json फ़ाइल. JSON फ़ाइल से, ये वैल्यू सीधे लोड की जा सकती हैं या उन्हें किसी अन्य सुरक्षित तरीके से सेव किया जा सकता है. इन बातों पर ध्यान दें: Google.Apis.Auth.AspNetCore3.IntegrationTests में ClientInfo.Load तरीका प्रोजेक्ट देखें, ताकि इन वैल्यू को सीधे JSON फ़ाइल से लोड करने का तरीका बताया जा सके. 
    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};
        });
}
  • Startup.Configure तरीके में, ASP.NET Core 3 की पुष्टि करना न भूलें और पाइपलाइन में मिडलवेयर कॉम्पोनेंट की अनुमति के साथ-साथ एचटीटीपीएस रीडायरेक्ट: 
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    ...
    app.UseHttpsRedirection();
    ...

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

    ...
}

उनकी ओर से Google API को ऐक्सेस करने के लिए, उपयोगकर्ता के क्रेडेंशियल का इस्तेमाल करना

अब अपने कंट्रोलर में कार्रवाई के ऐसे तरीके जोड़े जा सकते हैं जिनके लिए उपयोगकर्ता क्रेडेंशियल की ज़रूरत होती है उन्हें अपनी ओर से Google API ऐक्सेस करने की सुविधा मिलती है. निम्न स्निपेट दिखाता है कि पुष्टि हो चुकी है. ज़्यादातर दो चीज़ों पर ध्यान दें:

  • उपयोगकर्ता को न सिर्फ़ प्रमाणित किए जाने की ज़रूरत है, बल्कि उन्हें https://www.googleapis.com/auth/drive.readonly आपके ऐप्लिकेशन का दायरा, जो जिसे GoogleScopedAuthorize एट्रिब्यूट के ज़रिए तय किया जाता है.
  • हम IGoogleAuthProvider, जिसका इस्तेमाल हम उपयोगकर्ता के क्रेडेंशियल पाने के लिए करते हैं.

कोड:

  • सबसे पहले अपने कंट्रोलर में डायरेक्टिव का इस्तेमाल करके, नीचे बताई गई चीज़ें जोड़ें. 
    using Google.Apis.Auth.AspNetCore3;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;
  • कंट्रोलर ऐक्शन को इस तरह जोड़ें (और इसके साथ एक सिंपल व्यू जोड़ें) जिन्हें IList<string> मॉडल मिलता है): 
    /// <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);
}

और ये बुनियादी बातें हैं. आप इन पर एक नज़र डाल सकते हैं Google.Apis.Auth.AspNetCore3.IntegrationTests प्रोजेक्ट से HomeController.cs और जानें कि इस लक्ष्य को कैसे हासिल किया जा सकता है:

  • सिर्फ़ उपयोगकर्ता की पुष्टि करने की सुविधा, जिसके लिए अलग से कोई दायरा तय नहीं किया गया है
  • लॉग आउट करने की सुविधा
  • कोड के ज़रिए इंक्रीमेंटल अनुमति. ध्यान दें कि ऊपर दिया गया स्निपेट बढ़ोतरी दिखाता है अनुमति देने की सुविधा मौजूद होती है.
  • हाल ही में दिए गए दायरों की जांच करें
  • ऐक्सेस की जांच करें और टोकन रीफ़्रेश करें
  • ऐक्सेस टोकन को हर हाल में रीफ़्रेश करें. ध्यान दें कि आपको ऐसा खुद नहीं करना है, क्योंकि Google.Apis.Auth.AspNetCore3 यह पता लगा लेगा कि ऐक्सेस टोकन की समयसीमा खत्म हो गई है या उसकी समयसीमा खत्म होने वाली है और अपने-आप रीफ़्रेश हो जाएगा.

सेवा खाता

Google API, दूसरे डिवाइसों पर सेवा खाते. ऐसी स्थिति में नहीं, जिसमें क्लाइंट ऐप्लिकेशन असली उपयोगकर्ता के डेटा के ऐक्सेस का अनुरोध करता है, सेवा खाते, क्लाइंट ऐप्लिकेशन के डेटा का ऐक्सेस देते हैं.

आपका क्लाइंट ऐप्लिकेशन, डाउनलोड की गई निजी कुंजी का इस्तेमाल करके, ऐक्सेस टोकन के अनुरोध पर हस्ताक्षर करता है Google API कंसोल से ऐक्सेस किया जा सकता है. नया क्लाइंट आईडी बनाने के बाद, आपको “सेवा खाता” चुनना होगा निजी कुंजी डाउनलोड करें और फिर आप निजी कुंजी डाउनलोड कर सकते हैं. हमारे 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();
        }
    }
}

ऊपर दिया गया सैंपल कोड ServiceAccountCredential. ज़रूरी स्कोप सेट कर दिए गए हैं और FromCertificate को कॉल किया गया है, जो दिए गए X509Certificate2 से निजी कुंजी लोड करता है. अन्य सैंपल कोड की तरह, क्रेडेंशियल HttpClientInitializer के तौर पर सेट होता है.