OAuth 2.0

इस दस्तावेज़ में बताया गया है कि OAuth 2.0 का इस्तेमाल कब किया जाता है, इसका इस्तेमाल कब किया जाता है, क्लाइंट आईडी कैसे हासिल किए जाते हैं, और .NET के लिए Google API क्लाइंट लाइब्रेरी के साथ इसे कैसे इस्तेमाल किया जाता है.

OAuth 2.0 प्रोटोकॉल

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

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

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

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

क्रेडेंशियल

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

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

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

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

यह पक्का करने के लिए कि ऐक्सेस और रीफ़्रेश टोकन बनाए रखें, IDataStore को खुद लागू करें या लाइब्रेरी में उपलब्ध कराए गए इनमें से किसी एक तरीके का इस्तेमाल करें:

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

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

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

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

  • इस तरीके से मिलने वाला UserCredential, शुरू करने वाले टूल का इस्तेमाल करके BooksService पर HttpClientInitializer के तौर पर सेट किया जाता है. जैसा कि ऊपर बताया गया है, 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, एक सुझाई गई लाइब्रेरी है. इसका इस्तेमाल ASP.NET Core 3 ऐप्लिकेशन में, Google पर आधारित OAuth 2.0 के ज़्यादातर मामलों में किया जा सकता है. यह खास तौर पर, Google के लिए बना OpenIdConnect ऑथराइज़ेशन हैंडलर लागू करता है. यह इंक्रीमेंटल (बढ़ने वाली) पुष्टि की सुविधा देता है. साथ ही, यह इंजेक्टेबल IGoogleAuthProvider के बारे में बताता है, ताकि Google के क्रेडेंशियल उपलब्ध कराए जा सकें. इन क्रेडेंशियल का इस्तेमाल Google API के साथ किया जा सकता है.

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

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

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

  • Google.Apis.Auth.AspNetCore3 पैकेज इंस्टॉल करें.
  • हम Google Drive 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 क्लास या इससे मिलते-जुलते विकल्प में कॉन्फ़िगर किया गया है. ऐसा हो सकता है कि इसका इस्तेमाल किया जा रहा हो. नीचे दिए गए स्निपेट, Google.Apis.Auth.AspNetCore3.इंटिग्रेशन टेस्ट प्रोजेक्ट में Startup.cs से लिए गए हैं.

  • निर्देश का इस्तेमाल करके, अपनी Startup.cs फ़ाइल में ये चीज़ें जोड़ें. 
    using Google.Apis.Auth.AspNetCore3;
  • Startup.ConfigureServices तरीके में यह कोड जोड़ें, क्लाइंट आईडी और क्लाइंट सीक्रेट प्लेसहोल्डर को client_secrets.json फ़ाइल में मौजूद वैल्यू के हिसाब से बदलें. इन वैल्यू को सीधे JSON फ़ाइल से लोड किया जा सकता है या इन्हें किसी और सुरक्षित तरीके से स्टोर किया जा सकता है. JSON फ़ाइल से सीधे इन वैल्यू को लोड करने के तरीके के बारे में जानने के लिए, Google.Apis.Auth.AspNetCore3.इंटिग्रेशन टेस्ट प्रोजेक्ट में, ClientInfo.Load तरीके पर एक नज़र डालें. 
    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 को ऐक्सेस करने के लिए, उपयोगकर्ता क्रेडेंशियल की ज़रूरत होती है. नीचे दिए गए स्निपेट में, पुष्टि किए गए उपयोगकर्ता के Google Drive खाते में फ़ाइलों की सूची बनाने का तरीका बताया गया है. दो चीज़ों पर ज़्यादा ध्यान दें:

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

कोड:

  • सबसे पहले अपने कंट्रोलर में डायरेक्टिव का इस्तेमाल करके, इन निर्देशों को जोड़ें. 
    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.इंटिग्रेशन टेस्ट के प्रोजेक्ट में मौजूद, 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 के तौर पर सेट है.