👃🏼 🤹🏽 📘 नेट कोर 3.0 में आइडेंटिटी सर्वर 4 का उपयोग करना 🕞 🤴🏻 🖕🏽

परिचय

मेरे समर्थित प्रोजेक्ट्स में से एक ने हाल ही में .NET फ्रेमवर्क 4.5 से। नेट कोर से माइग्रेट होने की संभावना का विश्लेषण करने और संचित तकनीकी ऋण की एक बड़ी राशि को फिर से तैयार करने और रेकिंग की आवश्यकता के मामले में सामना करने का काम किया। चुनाव लक्ष्य प्लेटफ़ॉर्म .NET कोर 3.0 पर गिर गया, क्योंकि, Microsoft के डेवलपर्स के अनुसार, संस्करण 3.0 की रिलीज़ के साथ, विरासत कोड को स्थानांतरित करने के लिए आवश्यक कदम कई बार कम हो जाएंगे। विशेष रूप से हम EntityFramework 6.3 for .Net Core यानी के लिए निकास योजनाओं द्वारा इसकी ओर आकर्षित हुए थे । शुद्ध कोर पर एक माइग्रेटेड प्रोजेक्ट में EF 6.2 पर आधारित अधिकांश कोड "जैसा है" छोड़ा जा सकता है।

डेटा स्तर के साथ, ऐसा लगता है, यह स्पष्ट हो गया, हालांकि, कोड पोर्टिंग का एक और बड़ा हिस्सा सुरक्षा का स्तर था, जो दुर्भाग्य से, एक त्वरित ऑडिट के बाद, आपको लगभग पूरी तरह से इसे बाहर फेंकना होगा और इसे खरोंच से फिर से लिखना होगा। सौभाग्य से, परियोजना पहले से ही एएसपी नेट आइडेंटिटी के हिस्से का उपयोग करती थी, स्टोरिंग उपयोगकर्ताओं और अन्य "साइकिल" के रूप में।

यह तार्किक प्रश्न उठाता है: यदि सुरक्षा भाग में बहुत अधिक परिवर्तन करना है, तो उद्योग मानकों के रूप में अनुशंसित दृष्टिकोणों को तुरंत लागू क्यों नहीं किया जाना चाहिए, अर्थात्: आइडेंटिटीसेवर 4 ढांचे का उपयोग करके ओपन आईडी कनेक्ट और ओउथ का उपयोग करने के लिए एप्लिकेशन लाएं।

समस्याओं और समाधान

तो, हमें दिया गया है: एंगुलर में एक जावास्क्रिप्ट एप्लिकेशन है (आईएस 4 शब्दों में क्लाइंट), यह वेबएपीआई (संसाधन) के एक निश्चित सबसेट का उपयोग करता है, उपयोगकर्ता लॉगिन के साथ पुरानी एएसपी नेट पहचान का एक डेटाबेस भी है जिसे अपडेट के बाद फिर से शुरू किया जाना चाहिए (ताकि अन्य सभी को शुरू करने के लिए नहीं। समय), प्लस कुछ मामलों में आइडेंटिटीसेवर 4 की ओर से विंडोज प्रमाणीकरण के माध्यम से सिस्टम में लॉग इन करने का अवसर देना आवश्यक है। यानी ऐसे समय होते हैं जब उपयोगकर्ता ActiveDirectory डोमेन में एक स्थानीय क्षेत्र नेटवर्क के माध्यम से काम करते हैं।

उपयोगकर्ता डेटा को माइग्रेट करने के लिए मुख्य समाधान मैन्युअल रूप से (या स्वचालित टूल का उपयोग करके) पुराने और नए आइडेंटिटी स्कीमा के बीच एक माइग्रेशन स्क्रिप्ट लिखना है। हम, बदले में, स्वचालित डेटा स्कीमा तुलना एप्लिकेशन का उपयोग करते हैं और एक एसक्यूएल स्क्रिप्ट उत्पन्न करते हैं, पहचान संस्करण के आधार पर, लक्ष्य माइग्रेशन स्क्रिप्ट में अलग-अलग अपडेट निर्देश होंगे। यहाँ मुख्य बात यह है कि EFMigrationsHistory टेबल का समन्वय करना न भूलें यदि EF का उपयोग पहले किया गया था और भविष्य में इसकी योजना बनाई गई है, उदाहरण के लिए, IdentityUser इकाई को अतिरिक्त क्षेत्रों में विस्तारित करने के लिए।

लेकिन अब IdentityServer4 को सही ढंग से कैसे कॉन्फ़िगर करें और इसे कॉन्फ़िगर करें विंडोज खातों के साथ नीचे वर्णित किया जाएगा।

कार्यान्वयन योजना

NDA कारणों से, मैंने यह वर्णन नहीं किया कि हम अपनी परियोजना में IS4 को कैसे कार्यान्वित करने में कामयाब रहे, हालाँकि, इस लेख में, मैं आपको एक सरल ASP.NET कोर साइट पर दिखाऊँगा जो कि स्क्रैच से बनाई गई है जिसे आपको पूरी तरह से कॉन्फ़िगर और कार्यात्मक अनुप्रयोग प्राप्त करने के लिए क्या कदम उठाने की आवश्यकता है। प्राधिकरण और प्रमाणीकरण उद्देश्यों के लिए IdentityServer4 का उपयोग करता है।
वांछित व्यवहार का एहसास करने के लिए, हमें निम्नलिखित कदम उठाने होंगे:

एक रिक्त ASP.Net कोर प्रोजेक्ट बनाएँ और IdentityServer4 का उपयोग करने के लिए कॉन्फ़िगर करें।
एक क्लाइंट को कोणीय अनुप्रयोग के रूप में जोड़ें।
ओपन-आईडी-कनेक्ट गूगल के माध्यम से लॉग इन करें
Windows प्रमाणीकरण विकल्प जोड़ें

संक्षिप्तता कारणों के लिए, सभी तीन घटक (IdentityServer, WebAPI, कोणीय ग्राहक) एक ही परियोजना में होंगे। क्लाइंट और आइडेंटिटी सेवर (ग्रांट टाइप) के बीच चयनित प्रकार का इंटरैक्शन इम्प्लिक्ट फ्लो है, जब एक्सेस_टोकन को ब्राउज़र में एप्लिकेशन साइड में पास किया जाता है, और तब वेबएपीआई के साथ इंटरैक्ट करते समय इसका उपयोग किया जाता है। ASP.NET कोर रिपॉजिटरी में हुए बदलावों को देखते हुए क्लोज़र को रिलीज़ करने के लिए, इम्प्लिक्ट फ्लो को प्राधिकरण कोड + PKCE द्वारा बदल दिया जाएगा।)

एप्लिकेशन को बनाने और संशोधित करने की प्रक्रिया में, .NET कोर कमांड लाइन इंटरफ़ेस का व्यापक रूप से उपयोग किया जाएगा, इसे सिस्टम में प्रीव्यू कोर 3.0 के नवीनतम संस्करण (आर्टिकल लिखने के समय 3.0.100-प्रीव्यू 7-012821) के साथ स्थापित किया जाना चाहिए।

एक वेब परियोजना का निर्माण और विन्यास

IdentityServer संस्करण 4 की रिलीज इस ढांचे से यूआई के पूर्ण कटिंग द्वारा चिह्नित की गई थी। अब डेवलपर्स को प्राधिकरण सर्वर के मुख्य इंटरफ़ेस को निर्धारित करने का पूर्ण अधिकार है। इसके कई तरीके हैं। लोकप्रिय लोगों में से एक QuickStart UI पैकेज से UI का उपयोग करना है, जिसे जीथब पर आधिकारिक रिपॉजिटरी में पाया जा सकता है।

दूसरा, कोई कम सुविधाजनक नहीं है, एएसपी नेट कोर आइडेंटिटी यूआई के साथ एकीकरण है, इस मामले में, डेवलपर को प्रोजेक्ट में संबंधित मिडलवेयर को सही ढंग से कॉन्फ़िगर करने की आवश्यकता है। इस विधि का वर्णन बाद में किया जाएगा।

आइए एक सरल वेब प्रोजेक्ट बनाकर शुरू करें। ऐसा करने के लिए, कमांड लाइन पर निम्नलिखित निर्देश को निष्पादित करें:

dotnet new webapp -n IdentityServer4WebApp

निष्पादन के बाद, आउटपुट एक वेब एप्लिकेशन फ्रेमवर्क होगा, जिसे धीरे-धीरे उस राज्य में लाया जाएगा जिसकी हमें आवश्यकता है। यहां आपको एक आरक्षण करने की आवश्यकता है जो पहचान के लिए .Net कोर 3.0 हैवीवेट एमवीसी के विपरीत, अधिक हल्के रेज़रपेज का उपयोग करता है।
अब आपको हमारे प्रोजेक्ट में IdentityServer समर्थन जोड़ने की आवश्यकता है। ऐसा करने के लिए, आवश्यक पैकेज स्थापित करें:

 dotnet add package Microsoft.AspNetCore.ApiAuthorization.IdentityServer -v 3.0.0-preview7.19365.7 dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore -v 3.0.0-preview7.19365.7 dotnet add package Microsoft.EntityFrameworkCore.Tools -v 3.0.0-preview7.19362.6 dotnet add package Microsoft.EntityFrameworkCore.Sqlite -v 3.0.0-preview7.19362.6

प्राधिकरण सर्वर पैकेजों के लिंक के अलावा, यहां हमने पहचान पारिस्थितिकी तंत्र में उपयोगकर्ता जानकारी संग्रहीत करने के लिए एंटिटी फ्रेमवर्क समर्थन जोड़ा है। सरलता के लिए, हम SQLite डेटाबेस का उपयोग करेंगे।

डेटाबेस को इनिशियलाइज़ करने के लिए, अपना यूजर मॉडल और डेटाबेस संदर्भ बनाएँ, इसके लिए हम दो ApplicationUser क्लासेस की घोषणा करते हैं, जिन्हें मॉडल फ़ोल्डर में IdentityUser से विरासत में मिला है और ApplicationDbContext , इनसे विरासत में मिला है: डेटा फ़ोल्डर में ApiAuthorizationDonContext।

अगला, आपको EntityFramework संदर्भ के उपयोग को कॉन्फ़िगर करने और डेटाबेस बनाने की आवश्यकता है। ऐसा करने के लिए, हम संदर्भ को स्टार्टअप क्लास के कॉन्फिगरस्वाइस विधि में लिखते हैं:

 public void ConfigureServices(IServiceCollection services) { services.AddDbContext<ApplicationDbContext>(options =>options.UseSqlite(Configuration.GetConnectionString("DefaultConnection"))); services.AddRazorPages(); }

और appstings.json के लिए कनेक्शन स्ट्रिंग जोड़ें

 "ConnectionStrings": { "DefaultConnection": "Data Source=data.db" },

अब आप प्रारंभिक माइग्रेशन बना सकते हैं और डेटाबेस स्कीमा को इनिशियलाइज़ कर सकते हैं। यह ध्यान देने योग्य है कि एफई कोर के लिए स्थापित टूल की आवश्यकता है (प्रश्न में पूर्वावलोकन के लिए, संस्करण 3.0.0-पूर्वावलोकन 7.19362.6 की आवश्यकता है)।

 dotnet ef migrations add Init dotnet ef database update

यदि पिछले सभी चरण त्रुटियों के बिना पूरे हो गए थे, तो SQLite डेटा फ़ाइल data.db आपके प्रोजेक्ट में दिखाई देनी चाहिए।

इस स्तर पर, हम पूरी तरह से Asp.Net कोर पहचान का उपयोग करने की पूर्ण क्षमता को कॉन्फ़िगर और परीक्षण कर सकते हैं। ऐसा करने के लिए, स्टार्टअप विधियों में परिवर्तन करें । कॉन्फ़िगर करें और Start.ConfigureServices ।

 //Startup.ConfigureServices: services.AddDefaultIdentity<ApplicationUser>() .AddEntityFrameworkStores<ApplicationDbContext>(); //Startup. Configure: app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapRazorPages(); });

इन पंक्तियों के साथ, हम अनुरोध प्रसंस्करण पाइपलाइन में प्रमाणीकरण और प्राधिकरण की संभावना को एम्बेड करते हैं। और पहचान के लिए डिफ़ॉल्ट उपयोगकर्ता इंटरफ़ेस भी जोड़ें।
यह केवल यूआई को ठीक करने के लिए बनी हुई है, \ _ogogPartial.cshtml नाम और निम्न सामग्री के साथ एक नया रेजर देखें

 @using IdentityServer4WebApp.Models @using Microsoft.AspNetCore.Identity @inject SignInManager<ApplicationUser> SignInManager @inject UserManager<ApplicationUser> UserManager <ul class="navbar-nav"> @if (SignInManager.IsSignedIn(User)) { <li class="nav-item"> <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" title="Manage">Hello @User.Identity.Name!</a> </li> <li class="nav-item"> <form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" asp-route-returnUrl="/"> <button type="submit" class="nav-link btn btn-link text-dark">Logout</button> </form> </li> } else { <li class="nav-item"> <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a> </li> <li class="nav-item"> <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a> </li> } </ul>

उपर्युक्त प्रस्तुति कोड को नेविगेशन पैनल (अंतर्निहित लॉगिन और पासवर्ड, पंजीकरण, आदि) में अंतर्निहित उपयोगकर्ता नियंत्रण के साथ पहचान इंटरफ़ेस क्षेत्र से लिंक जोड़ना चाहिए।

नए मेनू आइटमों के प्रतिपादन को प्राप्त करने के लिए, हम इस आंशिक दृश्य के प्रतिपादन को जोड़कर _Layout.cshtml फ़ाइल को संशोधित करते हैं।

  <ul class="navbar-nav flex-grow-1"> <li class="nav-item"> <a class="nav-link text-dark" asp-area="" asp-page="/Index">Home</a> </li> <li class="nav-item"> <a class="nav-link text-dark" asp-area="" asp-page="/Privacy">Privacy</a> </li> </ul> </div> <partial name="_LoginPartial" /> <!––––> </div>

और अब चलो हमारे आवेदन को चलाने की कोशिश करते हैं और उन लिंक पर क्लिक करते हैं जो सिर में दिखाई देते हैं
मेनू, उपयोगकर्ता को स्वागत और अनुरोध के साथ एक पृष्ठ देखना चाहिए
लॉगिन और पासवर्ड दर्ज करें। इस स्थिति में, आप पंजीकरण कर सकते हैं और लॉग इन कर सकते हैं - सभी
काम करना चाहिए।

IdentityServer4 डेवलपर्स ने ASP.NET आइडेंटिटी और सर्वर फ्रेमवर्क के एकीकरण को बेहतर बनाने का एक उत्कृष्ट काम किया है। OAuth2 टोकन का उपयोग करने की क्षमता जोड़ने के लिए, आपको कोड में कुछ नए निर्देशों के साथ हमारी परियोजना को पूरक करने की आवश्यकता है।

Startup.ConfigureServices विधि की पारंगत रेखा में , ASP.NET कोर पहचान पर IS4 सम्मेलनों का विन्यास जोड़ें:

 services.AddIdentityServer() .AddApiAuthorization<ApplicationUser, ApplicationDbContext>();

AddApiAuthorization पद्धति एक विशिष्ट समर्थित कॉन्फ़िगरेशन का उपयोग करने के लिए मुख्य रूप से appsettings.json फ़ाइल के माध्यम से रूपरेखा का निर्देश देती है। फिलहाल, अंतर्निहित IS4 प्रबंधन क्षमताएं इतनी लचीली नहीं हैं और इसे आपके अनुप्रयोगों के निर्माण के लिए एक प्रारंभिक बिंदु माना जाना चाहिए। किसी भी स्थिति में, आप इस पद्धति के अतिभारित संस्करण का उपयोग कर सकते हैं और कॉलबैक के माध्यम से मापदंडों को अधिक विस्तार से कॉन्फ़िगर कर सकते हैं।

अगला, हम सहायक विधि को कहते हैं, जो फ्रेमवर्क द्वारा जारी किए गए जेडब्ल्यूटी टोकन की जांच के लिए एप्लिकेशन को कॉन्फ़िगर करता है।

 services.AddAuthentication() .AddIdentityServerJwt();

अंत में, Start..Configure विधि में , के लिए मिडलवेयर जोड़ें
ओपन आईडी कनेक्ट एंडपॉइंट प्रदान करना

 app.UseAuthentication(); app.UseAuthorization(); app.UseIdentityServer();//<-

जैसा कि ऊपर उल्लेख किया गया है, सहायक विधियों का उपयोग विन्यास को पढ़ता है
एप्लिकेशन सेटिंग में appsettings.json फ़ाइल है, जिसमें हमें एक नया जोड़ना होगा
पहचानकर्ता अनुभाग।

 "IdentityServer": { "Clients": { "TestIdentityAngular": { "Profile": "IdentityServerSPA" } } }

इस खंड में, एक ग्राहक को TestIdentityAngular नाम से परिभाषित किया गया है, जिसे हम भविष्य के ब्राउज़र क्लाइंट और एक विशिष्ट कॉन्फ़िगरेशन प्रोफ़ाइल में असाइन करेंगे।

एप्लिकेशन प्रोफाइल एक नया पहचानकर्ता कॉन्फ़िगरेशन उपकरण है जो कुछ मापदंडों को परिष्कृत करने की क्षमता के साथ कई पूर्वनिर्धारित कॉन्फ़िगरेशन प्रदान करता है। हम IdentityServerSPA प्रोफ़ाइल का उपयोग करेंगे, ऐसे मामलों के लिए डिज़ाइन किया जाएगा जब ब्राउज़र क्लाइंट और फ़्रेमवर्क एक ही प्रोजेक्ट में स्थित हैं और निम्न पैरामीटर हैं:

रीडायरेक्ट_यूरी संसाधन सेट / प्रमाणीकरण / लॉगिन-कॉलबैक के लिए ।
संसाधन post_logout_redirect_uri, पर / प्रमाणीकरण / लॉगआउट-कॉलबैक पर सेट करें ।
क्षेत्रों के सेट में प्रत्येक एप्लिकेशन एपीआई संसाधन के लिए ओपनिड, प्रोफाइल शामिल हैं।
अनुमत OIDC प्रतिक्रिया प्रकारों का सेट - id_token token
ग्राहक के लिए ग्रांट टाइप - निहित

अन्य संभावित प्रोफाइल एसपीए (आईएस 4 के बिना आवेदन), आइडेंटिटीसेवरज्वेट (आईएस 4 के साथ साझा एपीआई), एपीआई (अलग एपीआई) हैं।

इसके अलावा, कॉन्फ़िगरेशन संसाधनों को पंजीकृत करता है:

ApiResources: एक एपीआई संसाधन जिसका नाम << appname >> एपीआई सभी ग्राहकों के लिए गुणों के साथ (*) है।
IdentityServerResources: IdentityResources.OpenId () और IdentityResources.Profile ()

जैसा कि आप जानते हैं, IdentityServer टोकन साइन करने के लिए प्रमाण पत्र का उपयोग करता है, उनके पैरामीटर कॉन्फ़िगरेशन फ़ाइल में भी सेट किए जा सकते हैं, इसलिए परीक्षण के समय हम उपयोग कर सकते हैं
x509 परीक्षण प्रमाण पत्र, इसके लिए आपको इसे appsettings.Development.json फ़ाइल के "कुंजी" अनुभाग में निर्दिष्ट करना होगा।

 "IdentityServer": { "Key": { "Type": "Development" } }

अब हम कह सकते हैं कि बैकएंड जो आपको IdentityServer का उपयोग करने की अनुमति देता है तैयार है और आप ब्राउज़र एप्लिकेशन को लागू करना शुरू कर सकते हैं।

कोणीय ग्राहक कार्यान्वयन

हमारे ब्राउज़र-आधारित एसपीए को कोणीय मंच पर लिखा जाएगा। आवेदन में दो पृष्ठ होंगे, एक अनधिकृत उपयोगकर्ताओं के लिए और दूसरा प्रमाणित उपयोगकर्ताओं के लिए। उदाहरण 8.1.2 संस्करण का उपयोग करते हैं

सबसे पहले, भविष्य की रूपरेखा बनाएं:

 ng new ClientApp

रूटिंग का उपयोग करने के प्रस्ताव के लिए आपको "हां" का जवाब देने की आवश्यकता है। और बूटस्ट्रैप लाइब्रेरी के माध्यम से पेज को थोड़ा स्टाइल करें:

 cd ClientApp ng add bootstrap

अगला, आपको हमारे मुख्य एप्लिकेशन में एसपीए होस्टिंग समर्थन को जोड़ने की आवश्यकता है। सबसे पहले आपको csproj प्रोजेक्ट को ठीक करने की आवश्यकता है - हमारे ब्राउज़र एप्लिकेशन के बारे में जानकारी जोड़ें।

 <PropertyGroup> <TargetFramework>netcoreapp3.0</TargetFramework> <TypeScriptCompileBlocked>true</TypeScriptCompileBlocked> <TypeScriptToolsVersion>Latest</TypeScriptToolsVersion> <IsPackable>false</IsPackable> <SpaRoot>ClientApp\</SpaRoot> <DefaultItemExcludes>$(DefaultItemExcludes);$(SpaRoot)node_modules\**</DefaultItemExcludes> <BuildServerSideRenderer>false</BuildServerSideRenderer> </PropertyGroup> … <ItemGroup> <Content Remove="$(SpaRoot)**" /> <None Remove="$(SpaRoot)**" /> <None Include="$(SpaRoot)**" Exclude="$(SpaRoot)node_modules\**" /> </ItemGroup> <Target Name="DebugEnsureNodeEnv" BeforeTargets="Build" Condition=" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') "> <Exec Command="node --version" ContinueOnError="true"> <Output TaskParameter="ExitCode" PropertyName="ErrorCode" /> </Exec> <Error Condition="'$(ErrorCode)' != '0'" Text="Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE." /> <Message Importance="high" Text="Restoring dependencies using 'npm'. This may take several minutes..." /> <Exec WorkingDirectory="$(SpaRoot)" Command="npm install" /> </Target>

उसके बाद, ब्राउज़र अनुप्रयोगों का समर्थन करने के लिए विशेष नगेट पैकेज स्थापित करें।

 dotnet add package Microsoft.AspNetCore.SpaServices.Extensions -v 3.0.0-preview7.19365.7

और हम इसके सहायक तरीकों का उपयोग करते हैं:

 //Startup. ConfigureServices: services.AddSpaStaticFiles(configuration => { configuration.RootPath = "ClientApp/dist"; }); //Startup. Configure: app.UseSpa(spa => { spa.Options.SourcePath = "ClientApp"; if (env.IsDevelopment()) { spa.UseAngularCliServer(npmScript: "start"); } });

नए तरीकों को कॉल करने के अलावा, आपको रेज़र इंडेक्स.चटामेल और _ViewStart.chtml पृष्ठों को हटाना होगा ताकि एसपीए सेवाएं अब सामग्री प्रदान करें।

यदि सब कुछ निर्देशों के अनुसार किया गया था, जब आवेदन शुरू होता है, तो डिफ़ॉल्ट पृष्ठ स्क्रीन पर दिखाई देगा।

अब आपको रूटिंग को कॉन्फ़िगर करने की आवश्यकता है, इसके लिए हम प्रोजेक्ट 2 में जोड़ते हैं
घटक:

 ng generate component Home -t=true -s=true --skipTests=true ng generate component Data -t=true -s=true --skipTests=true

हम उन्हें रूटिंग टेबल में लिखते हैं:

 const routes: Routes = [ { path: '', component: HomeComponent, pathMatch: 'full' }, { path: 'data', component: DataComponent } ];

और हम मेनू आइटम को सही ढंग से प्रदर्शित करने के लिए app.component.html फ़ाइल को संशोधित करते हैं।

 <header> <nav class='navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3'> <div class="container"> <a class="navbar-brand" [routerLink]='["/"]'>Client App</a> <div class="navbar-collapse collapse d-sm-inline-flex flex-sm-row-reverse" [ngClass]='{"show": isExpanded}'> <ul class="navbar-nav flex-grow"> <li class="nav-item" [routerLinkActive]='["link-active"]' [routerLinkActiveOptions]='{ exact: true }'> <a class="nav-link text-dark" [routerLink]='["/"]'>Home</a> </li> <li class="nav-item" [routerLinkActive]='["link-active"]'> <a class="nav-link text-dark" [routerLink]='["/data"]'>Web api data</a> </li> </ul> </div> </div> </nav> </header> <div style="text-align:center"> <h1> Welcome to {{ title }}! </h1> </div> <div class="router-outlet"> <router-outlet></router-outlet> </div>

इस कदम पर, आप IdentityServer द्वारा जारी टोकन के माध्यम से इंटरैक्शन को लागू करने के लिए आवेदन ढांचे की बुनियादी तैयारी को पूरा कर सकते हैं।

हमारे एसपीए की रूपरेखा तैयार करने के वर्तमान चरण को पूरा किया जा सकता है और अब हमें ओपेनआईडी कनेक्ट और ओउथ प्रोटोकॉल का उपयोग करके सर्वर भाग के साथ बातचीत के लिए जिम्मेदार मॉड्यूल को लागू करना शुरू करना चाहिए। सौभाग्य से, माइक्रोसॉफ्ट के डेवलपर्स ने पहले से ही इस तरह के कोड को लागू किया है, और अब आप बस इस मॉड्यूल को उनसे उधार ले सकते हैं। चूँकि मेरा लेख ASP.NET Core 3.0 के प्री-रिलीज़ 7 पर आधारित है, इसलिए हम github पर रिलीज़ टैग “v3.0.0-preview7.19365.7” का उपयोग करके सभी कोड लेंगे।

कोड आयात करने से पहले, आपको oidc-client लाइब्रेरी स्थापित करना होगा, जो
ब्राउज़र अनुप्रयोगों के लिए कई इंटरफेस प्रदान करता है, साथ ही साथ
उपयोगकर्ता सत्र और पहुंच टोकन के प्रबंधन का समर्थन करता है। के लिए
इसके साथ काम करना शुरू करने के लिए, आपको उचित पैकेज स्थापित करने की आवश्यकता है।

 npm install oidc-client@1.8.0

अब हमारे एसपीए में एक मॉड्यूल को लागू करना आवश्यक है जो आवश्यक प्रोटोकॉल के अनुसार पूर्ण इंटरैक्शन को एन्क्रिप्ट करता है। ऐसा करने के लिए, आपको उपरोक्त ASP.NET कोर रिपॉजिटरी लेबल से संपूर्ण ApiAuthorizationModule मॉड्यूल लेने की जरूरत है और इसकी सभी फाइलों को एप्लिकेशन में जोड़ें।

इसके अलावा, आपको इसे AppModule एप्लिकेशन के मुख्य मॉड्यूल में आयात करना होगा:

 @NgModule({ declarations: [ AppComponent, HomeComponent, DataComponent ], imports: [ BrowserModule, HttpClientModule, ApiAuthorizationModule,//<- AppRoutingModule ], providers: [], bootstrap: [AppComponent] }) export class AppModule { }

आयातित मॉड्यूल में नए मेनू आइटम प्रदर्शित करने के लिए, एक ऐप-लॉगिन-मेनू घटक है,
यह पूरी तरह से आपकी आवश्यकताओं के अनुरूप और जोड़ा जा सकता है
app.component.html दृश्य के नेविगेशन अनुभाग में इसके लिए एक लिंक।

एसपीए क्लाइंट के ओपनआईडी कनेक्ट को कॉन्फ़िगर करने के लिए एपीआई प्राधिकरण मॉड्यूल को एप्लिकेशन कार्यान्वयन में एक विशेष समापन बिंदु का उपयोग करना चाहिए, इसके कार्यान्वयन के लिए
इन चरणों का पालन करना चाहिए:

क्लाइंट आईडी को हम जो विन्यास फाइल appsettings.json में IdentityServer में सेट करते हैं, उसके अनुसार ठीक करें: ग्राहक अनुभाग, हमारे मामले में यह TestIdentityAngular है, यह api-authorization.constants.ts निरंतर सेट की पहली पंक्ति में लिखा गया है।
एक OidcConfigurationController नियंत्रक जोड़ें जो सीधे ब्राउज़र एप्लिकेशन में कॉन्फ़िगरेशन लौटाएगा

निर्मित नियंत्रक का कोड नीचे प्रस्तुत किया गया है:

  [ApiController] public class OidcConfigurationController: ControllerBase { private readonly IClientRequestParametersProvider _clientRequestParametersProvider; public OidcConfigurationController(IClientRequestParametersProvider clientRequestParametersProvider) { _clientRequestParametersProvider = clientRequestParametersProvider; } [HttpGet("_configuration/{clientId}")] public IActionResult GetClientRequestParameters([FromRoute]string clientId) { var parameters = _clientRequestParametersProvider.GetClientParameters(HttpContext, clientId); return Ok(parameters); } }

बैकएंड एप्लिकेशन के लिए आपको बिंदु एपीआई समर्थन को कॉन्फ़िगर करने की भी आवश्यकता है।

 //Startup.ConfigureServices: services.AddControllers();//<-  services.AddRazorPages(); //Startup. Configure: app.UseEndpoints(endpoints => { endpoints.MapRazorPages(); endpoints.MapControllers(); });

अब आवेदन लॉन्च करने का समय है। शीर्ष मेनू में मुख्य पृष्ठ पर दो आइटम दिखाई देने चाहिए - लॉगिन और रजिस्टर । इसके अलावा, स्टार्टअप पर, आयातित प्राधिकरण मॉड्यूल क्लाइंट की ओर से क्लाइंट कॉन्फ़िगरेशन से अनुरोध करेगा, जिसे बाद में प्रोटोकॉल में ध्यान में रखा जाएगा। एक उदाहरण कॉन्फ़िगरेशन आउटपुट नीचे दिखाया गया है:

 { "authority": "https://localhost:44367", "client_id": "TestIdentityAngular", "redirect_uri": "https://localhost:44367/authentication/login-callback", "post_logout_redirect_uri": "https://localhost:44367/authentication/logout-callback", "response_type": "id_token token", "scope": "IdentityServer4WebAppAPI openid profile" }

जैसा कि आप देख सकते हैं, इंटरैक्शन के दौरान क्लाइंट आईडी टोकन और एक्सेस टोकन प्राप्त करने की उम्मीद करता है, और यह हमारे एपीआई तक पहुंच क्षेत्र के लिए भी कॉन्फ़िगर किया गया है।

अब, यदि हम लॉगिन मेनू आइटम का चयन करते हैं, तो हमें हमारे IdentityServer4 के पृष्ठ पर पुनर्निर्देशित किया जाना चाहिए और यहां हम लॉगिन और पासवर्ड दर्ज कर सकते हैं, और यदि वे सही हैं, तो हमें तुरंत ब्राउज़र एप्लिकेशन पर वापस स्थानांतरित कर दिया जाएगा, जो बदले में id_token और access_token प्राप्त करेगा। जैसा कि आप नीचे देख सकते हैं, ऐप-लॉगिन-मेनू घटक ने स्वयं निर्धारित किया था कि प्राधिकरण ने सफलतापूर्वक पूरा किया और "ग्रीटिंग" प्रदर्शित किया, साथ ही लॉगआउट के लिए एक बटन भी।

जब आप ब्राउज़र में "डेवलपर टूल" खोलते हैं, तो आप ओआईडीसी / ओथथ प्रोटोकॉल का उपयोग करके बैकस्टेज सभी इंटरैक्शन में देख सकते हैं। यह प्राधिकरण सर्वर जानकारी प्राप्त कर रहा है
एंडपॉइंट के माध्यम से .well- जाना जाता है / ओपेन-कॉन्फ़िगरेशन और पूलिंग सेशन एक्टिविटी कनेक्ट / चेकसेशन एक्सेस पॉइंट के जरिए। इसके अलावा, प्राधिकरण मॉड्यूल "टोकन के मूक अद्यतन" तंत्र के लिए कॉन्फ़िगर किया गया है, जब पहुंच टोकन समाप्त हो जाता है, तो सिस्टम स्वतंत्र रूप से एक छिपे हुए iframe में प्राधिकरण चरणों को पारित करता है। आप AuthorI.service.ts फ़ाइल में "झूठे" में शामिल करें IndITTokenInSilentRenew पैरामीटर का मान सेट करके टोकन-अपडेट को अक्षम कर सकते हैं।

अब आप एसपीए एप्लिकेशन के घटकों से अनधिकृत उपयोगकर्ताओं तक पहुंच को प्रतिबंधित कर सकते हैं, साथ ही पीठ पर कुछ एपीआई नियंत्रक भी। कुछ एपीआई प्रदर्शित करने के लिए, हम मॉडल फ़ोल्डर में एक ExchangeRateItem वर्ग , साथ ही नियंत्रक फ़ोल्डर में कुछ यादृच्छिक डेटा लौटाते हैं, जो एक नियंत्रक बनाएंगे।

 //Controller: [ApiController] public class ExchangeRateController { private static readonly string[] Currencies = new[] { "EUR", "USD", "BGN", "AUD", "CNY", "TWD", "NZD", "TND", "UAH", "UYU", "MAD" }; [HttpGet("api/rates")] public IEnumerable<ExchangeRateItem> Get() { var rng = new Random(); return Enumerable.Range(1, 5).Select(index => new ExchangeRateItem { FromCurrency = "RUR", ToCurrency = Currencies[rng.Next(Currencies.Length)], Value = Math.Round(1.0+ 1.0/rng.Next(1, 100),2) }) .ToArray(); } } //Models: public class ExchangeRateItem { public string FromCurrency { get; set; } public string ToCurrency { get; set; } public double Value { get; set; } }

अगला, फ्रंट-एंड साइड पर, एक नया घटक बनाएं जो प्राप्त होगा
और बस बनाए गए नियंत्रक से विनिमय दरों पर डेटा प्रदर्शित करें।

 ng generate component ExchangeRate -t=true -s=true --skipTests=true

घटक की सामग्री इस तरह दिखनी चाहिए:

कोड

 import { Component, OnInit, Input } from '@angular/core'; import { HttpClient } from '@angular/common/http'; import { Observable, of, Subject } from 'rxjs'; import { catchError } from 'rxjs/operators'; @Component({ selector: 'app-exchange-rate', template: ` <div class="alert alert-danger" *ngIf="errorMessage | async as msg"> {{msg}} </div> <table class='table table-striped'> <thead> <tr> <th>From currency</th> <th>To currency</th> <th>Rate</th> </tr> </thead> <tbody> <tr *ngFor="let rate of rates | async"> <td>{{ rate.fromCurrency }} </td> <td>{{ rate.toCurrency }}</td> <td>{{ rate.value }}</td> </tr> </tbody> </table> `, styles: [] }) export class ExchangeRateComponent implements OnInit { public rates: Observable<ExchangeRateItem[]>; public errorMessage: Subject<string>; @Input() public apiUrl: string; constructor(private http: HttpClient) { this.errorMessage = new Subject<string>(); } ngOnInit() { this.rates = this.http.get<ExchangeRateItem[]>("/api/"+this.apiUrl).pipe(catchError(this.handleError(this.errorMessage)) ); } private handleError(subject: Subject<string>): (te:any) => Observable<ExchangeRateItem[]> { return (error) => { let message = ''; if (error.error instanceof ErrorEvent) { message = `Error: ${error.error.message}`; } else { message = `Error Code: ${error.status}\nMessage: ${error.message}`; } subject.next(message); let emptyResult: ExchangeRateItem[] = []; return of(emptyResult); } } } interface ExchangeRateItem { fromCurrency: string; toCurrency: string; value: number; }

अब यह ऐप-डेटा पृष्ठ पर इसका उपयोग शुरू करने के लिए बना हुआ है, बस टेम्पलेट में <app-exchange-rate-apiUrl = "दरें"> </ app-exchange-rate> लिखकर और आप फिर से परियोजना शुरू कर सकते हैं। जब हम लक्ष्य पथ पर नेविगेट करते हैं, तो हम देखेंगे कि घटक ने डेटा प्राप्त किया और इसे एक तालिका में प्रदर्शित किया।

अगला, हम नियंत्रक के एपीआई तक पहुंच के प्राधिकरण के लिए एक अनुरोध जोड़ने का प्रयास करेंगे। ऐसा करने के लिए, ExchangeRateController वर्ग पर [प्राधिकरण] विशेषता जोड़ें और फिर से एसपीए चलाएं, हालांकि, जब हम अपने एपीआई को कॉल करने वाले घटक पर वापस जाते हैं, तो हम एक त्रुटि देखेंगे, जो इंगित करता है। प्राधिकरण हेडर।

आउटगोइंग अनुरोधों को एक प्राधिकरण टोकन को सही ढंग से जोड़ने के लिए, आप कर सकते हैं
कोणीय इंटरसेप्टर इंटरसेप्टर तंत्र को संलग्न करें। सौभाग्य से, आयातित मॉड्यूल में पहले से ही आवश्यक प्रकार शामिल हैं, हमें केवल आवेदन के आधार मॉड्यूल में इसे पंजीकृत करने की आवश्यकता है।

 providers: [ { provide: HTTP_INTERCEPTORS, useClass: AuthorizeInterceptor, multi: true } ],

इन चरणों के बाद, सब कुछ सही ढंग से काम करना चाहिए। यदि आप डेवलपर टूल को फिर से देखते हैं, तो ब्राउज़र को नया बियरर access_token प्राधिकरण हेडर दिखाई देगा। बैकएंड पर, इस टोकन को IdentityServer द्वारा मान्य किया जाएगा और यह सुरक्षित एपीआई बिंदु को कॉल करने की अनुमति भी देगा।

प्राधिकरण सर्वर के साथ एकीकरण के उदाहरण के अंत में, आप एसपीए में विनिमय दर डेटा के साथ मार्ग पर सक्रियण गार्ड रख सकते हैं, यह उपयोगकर्ताओं को पृष्ठ पर स्विच करने से रोक देगा यदि वे वर्तमान में अधिकृत नहीं हैं। यह रक्षक पहले से आयातित मॉड्यूल में भी प्रस्तुत किया गया है, आपको इसे लक्ष्य मार्ग पर लटकाए जाने की आवश्यकता है।

 { path: 'data', component: DataComponent, canActivate: [AuthorizeGuard] }

अब, उस स्थिति में जब उपयोगकर्ता ने एप्लिकेशन में लॉग इन नहीं किया है और हमारे संरक्षित घटक के लिए एक लिंक का चयन किया है, तो उसे तुरंत उपयोगकर्ता नाम और पासवर्ड दर्ज करने के अनुरोध के साथ प्राधिकरण पृष्ठ पर पुनः निर्देशित किया जाएगा। परिणामी कोड जीथब पर उपलब्ध है।

Google प्रदाता के माध्यम से बाहरी लॉगिन कनेक्ट करना

ASP.NET Core 1.1 / 2.0 + के लिए Google खातों के माध्यम से लॉगिन को जोड़ने के लिए एक अलग Microsoft.AspNetCore.Authentication.Google नुगेट पैकेज है, हालाँकि, निगम की नीति में परिवर्तन के कारण, Microsoft के पास ASP.NET Core ++ के लिए योजना है इसे अप्रचलित के रूप में पहचानें। और अब यह सहायक विधि OpenIdConnectExtensions और AddOpenIdConnect के माध्यम से कनेक्ट करने के लिए अनुशंसित है, जिसका उपयोग हम इस लेख में करेंगे।

OpenIdConnect एक्सटेंशन स्थापित करें:

 dotnet add package Microsoft.AspNetCore.Authentication.OpenIdConnect -v 3.0.0-preview7.19365.7

आरंभ करने के लिए, हमें Google - Id Client और Client Secret से दो प्रमुख मान प्राप्त करने होंगे, इसके लिए इन चरणों का पालन करना प्रस्तावित है:

लिंक का पालन करें और "संपर्क एक परियोजना" बटन का चयन करें।
दिखाई देने वाले संवाद में, वेब सर्वर निर्दिष्ट करें।
«Authorized redirect URI» Google (.. https://localhost:44301/ , https://localhost:44301/signin-google )
ClientID Client Secret.
, , URL .

Secret Manager . , .

 dotnet user-secrets init dotnet user-secrets set "Authentication:Google:ClientId" "  ClientID" dotnet user-secrets set "Authentication:Google:ClientSecret" "  ClientSecret"

Google.

 services.AddAuthentication() .AddOpenIdConnect("Google", "Google", o => { IConfigurationSection googleAuthNSection = Configuration.GetSection("Authentication:Google"); o.ClientId = googleAuthNSection["ClientId"]; o.ClientSecret = googleAuthNSection["ClientSecret"]; o.Authority = "https://accounts.google.com"; o.ResponseType = OpenIdConnectResponseType.Code; o.CallbackPath = "/signin-google"; }) .AddIdentityServerJwt();

,
Google. , , SPA .

, , OAuth , . Nuget .

Windows

, SPA Microsoft, ActiveDirectory. , Html ASP.NET, WebForms .., Windows WindowsIdentity, , . Identity Server, Windows, claims id_token access_token . , IS4 , ,
github . , ASP.NET Core Identity 3.0.

Identity, Razor Login ExternalLogin ( CLI aspnet-codegenerator ):

 dotnet add package Microsoft.EntityFrameworkCore.SqlServer dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design dotnet aspnet-codegenerator identity -dc IdentityServer4WebApp.Data.ApplicationDbContext --files "Account.Login;Account.ExternalLogin"

, Area Identity , .

, . , Identity I AuthenticationSchemeProvider. GetAllSchemesAsync() DisplayName != null, Windows DisplayName = null. LoginModel OnGetAsync :

 ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList(); // << >> ExternalLogins =(await _schemeProvider.GetAllSchemesAsync()).Where(x => x.DisplayName != null ||(x.Name.Equals(IISDefaults.AuthenticationScheme,StringComparison.OrdinalIgnoreCase))).ToList();

private readonly AuthenticationSchemeProvider _schemeProvider . View Login.cshtml :

 <button type="submit" class="btn btn-primary" name="provider" value="@provider.Name" title="Log in using your @provider.DisplayName account">@provider.DisplayName</button> << >> <button type="submit" class="btn btn-primary" name="provider" value="@provider.Name" title="Log in using your @(provider.DisplayName ??provider.Name) account">@(provider.DisplayName ??provider.Name)</button>

, windows launchSettings.json
( IIS, web.config ).

 "iisSettings": { "windowsAuthentication": true, "anonymousAuthentication": true, "iisExpress": { "applicationUrl": "http://localhost:15479", "sslPort": 44301 } },

«Windows» .

SPA IdentityServer . «» [AllowAnonymous] LoginModel [Authorize(AuthenticationSchemes = "Windows")] , , WindowsIdentity.

ExternalLogin , Identity Windows . ProcessWindowsLoginAsync .

 private async Task<IActionResult> ProcessWindowsLoginAsync(string returnUrl) { var result = await HttpContext.AuthenticateAsync(IISDefaults.AuthenticationScheme); if (result?.Principal is WindowsPrincipal wp) { var redirectUrl = Url.Page("./ExternalLogin", pageHandler: "Callback", values: new { returnUrl }); var props = _signInManager.ConfigureExternalAuthenticationProperties(IISDefaults.AuthenticationScheme, redirectUrl); props.Items["scheme"] = IISDefaults.AuthenticationScheme; var id = new ClaimsIdentity(IISDefaults.AuthenticationScheme); id.AddClaim(new Claim(JwtClaimTypes.Subject, wp.Identity.Name)); id.AddClaim(new Claim(JwtClaimTypes.Name, wp.Identity.Name)); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, wp.Identity.Name)); var wi = wp.Identity as WindowsIdentity; var groups = wi.Groups.Translate(typeof(NTAccount)); var hasUsersGroup = groups.Any(i => i.Value.Contains(@"BUILTIN\Users", StringComparison.OrdinalIgnoreCase)); id.AddClaim(new Claim("hasUsersGroup", hasUsersGroup.ToString())); await HttpContext.SignInAsync(IdentityConstants.ExternalScheme, new ClaimsPrincipal(id), props); return Redirect(props.RedirectUri); } return Challenge(IISDefaults.AuthenticationScheme); }

, .

ExternalLoginModel.OnPost :

 if (IISDefaults.AuthenticationScheme == provider) { return await ProcessWindowsLoginAsync(returnUrl); }

Claim Windows Claim «hasUsersGroup», ID access, . ASP.NET Identity UserClaims. ExternalLoginModel .

 private async Task UpdateClaims(ExternalLoginInfo info, ApplicationUser user, params string[] claimTypes) { if (claimTypes == null) { return; } var claimTypesHash = new HashSet<string>(claimTypes); var claims = (await _userManager.GetClaimsAsync(user)).Where(c => claimTypesHash.Contains(c.Type)).ToList(); await _userManager.RemoveClaimsAsync(user, claims); foreach (var claimType in claimTypes) { if (info.Principal.HasClaim(c => c.Type == claimType)) { claims = info.Principal.FindAll(claimType).ToList(); await _userManager.AddClaimsAsync(user, claims); } } }

OnPostConfirmationAsync (
).

 result = await _userManager.AddLoginAsync(user, info); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent: false); _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider); await UpdateClaims(info, user, "hasUsersGroup");// return LocalRedirect(returnUrl); }

OnGetCallbackAsync , .

 var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor : true); if (result.Succeeded) { var user = await _userManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey); await UpdateClaims(info, user, "hasUsersGroup");//

, WebAPI
«hasUsersGroup». «ShouldHasUsersGroup»

 services.AddAuthorization(options => { options.AddPolicy("ShouldHasUsersGroup", policy => { policy.RequireClaim("hasUsersGroup");}); });

ExchangeRateController
Policy.

  [Authorize(Policy = "ShouldHasUsersGroup")] [HttpGet("api/internalrates")] public IEnumerable<ExchangeRateItem> GetInternalRates() { return Get().Select(i=>{i.Value=Math.Round(i.Value-0.02,2);return i;}); }

view .

 ng generate component InternalData -t=true -s=true --skipTests=true

template .

 //internal-data.component.ts: template: `<app-exchange-rate apiUrl="internalrates"></app-exchange-rate> `, //app-routing.module.ts: { path: ' internaldata', component: InternalDataComponent, canActivate: [AuthorizeGuard] } //app.component.html: <li class="nav-item" [routerLinkActive]='["link-active"]'> <a class="nav-link text-dark" [routerLink]='["/internaldata"]'>Internal api data</a> </li>

, , . , accsee_token
claim hasUsersGroup ,
ApiResources . , , appsettings.json , Startup. ConfigureServices .

 services.AddIdentityServer() .AddApiAuthorization<ApplicationUser, ApplicationDbContext>(options => { var apiResource = options.ApiResources.First(); apiResource.UserClaims = new[] { "hasUsersGroup" }; });

, , windows , .

, – Guard claim «hasUsersGroup» « ». Guard :

 ng generate guard AuthorizeWindowsGroupGuard --skipTests=true

 import { Injectable } from '@angular/core'; import { Observable } from 'rxjs'; import { map,tap} from 'rxjs/operators'; import { CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, Router, UrlTree } from '@angular/router'; import { AuthorizeService } from "./authorize.service"; import { ApplicationPaths, QueryParameterNames } from './api-authorization.constants'; @Injectable({ providedIn: 'root' }) export class AuthorizeWindowsGroupGuardGuard implements CanActivate{ constructor(private authorize: AuthorizeService, private router: Router) {} canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree { return this.authorize.getUser().pipe(map((u: any) => !!u && !!u.hasUsersGroup)).pipe(tap((isAuthorized:boolean) => this.handleAuthorization(isAuthorized, state)));; } private handleAuthorization(isAuthenticated: boolean, state: RouterStateSnapshot) { if (!isAuthenticated) { window.location.href = "/Identity/Account/Login?" + QueryParameterNames.ReturnUrl + "=/"; } } }

, , .

 { path: 'internaldata', component: InternalDataComponent, canActivate: [AuthorizeWindowsGroupGuardGuard]

IdentityServer, claims ( sub , profile ), «hasUsersGroup». IdentityResource, - IdentityResources Startup.ConfigureServices .

  var identityResource = new IdentityResource { Name = "customprofile", DisplayName = "Custom profile", UserClaims = new[] { "hasUsersGroup" }, }; identityResource.Properties.Add(ApplicationProfilesPropertyNames.Clients, "*"); options.IdentityResources.Add(identityResource);

- , windows « » SPA – , , Guard .

निष्कर्ष

, ASP.NET Core 3.0 IdentityServer4, . preview , . , github .

नेट कोर 3.0 में आइडेंटिटी सर्वर 4 का उपयोग करना