Share via

Konfigurera Azure Active Directory B2C med Akamai Enterprise Application Access för enkel inloggning och säker hybridåtkomst

  • Artikel

I den här exempelguiden lär du dig att integrera Azure Active Directory B2C-autentisering (Azure AD B2C) med Akamai Enterprise Application Access. Akamai Enterprise Application Access är en ZTNA-lösning (Nolltillit Network Access) som möjliggör säker fjärråtkomst till moderna och äldre program som finns i privata datacenter. Akamai Enterprise Application Access federerar med IdP (IdP) Azure AD B2C för att autentisera användare och använder sedan sina auktoriseringsprinciper för att utföra kontinuerlig utvärdering av identitets-, enhets-, program- och begärandekontexten innan åtkomst till privata program tillåts.

Den här funktionen är endast tillgänglig för anpassade principer. För installationssteg väljer du Anpassad princip i föregående väljare.

Förutsättningar

För att komma igång behöver du:

  • Ett Akamai Enterprise Access-kontrakt. Om du inte har en får du en kostnadsfri utvärderingsversion.

  • En Azure-prenumeration Om du inte har en prenumeration kan du få ett kostnadsfritt konto.

  • En Azure AD B2C-klientorganisation som är länkad till din Azure-prenumeration.

  • En virtuell installation som distribueras bakom brandväggen i ditt datacenter eller i hybridmolnmiljöer för att distribuera anslutningsappen för Akamai Enterprise-programåtkomst

  • Ett program som använder rubriker för autentisering. I det här exemplet använder vi ett program som visar sidhuvuden docker header-demo-app.

  • ELLER ett OpenID Anslut-program (OIDC). I det här exemplet använder vi en ASP.NET MVC-webbapp som loggar in användare med hjälp av mellanprogrammet Öppna webbgränssnitt för .NET (OWIN) och Microsofts identitetsplattform.

Beskrivning av scenario

I det här scenariot aktiverar du Azure AD B2C-autentisering för slutanvändare när de försöker komma åt privata program som skyddas av Akamai Enterprise Application Access.

De komponenter som ingår i den här integreringen är:

  • Azure AD B2C: DEN SAML-identitetsprovider som ansvarar för att autentisera slutanvändare.

  • Akamai Enterprise Application Access: ZTNA-molntjänsten som ansvarar för att skydda åtkomsten till privata program med kontinuerlig ZTNA-principframtvingande.

  • Akamai Enterprise Application Access Anslut or: En virtuell installation som distribueras i det privata datacentret. Det möjliggör säker anslutning till privata appar utan att öppna några inkommande brandväggsportar för datacenter.

  • Program: En tjänst eller ett program som distribueras i ditt privata datacenter och som slutanvändarna behöver åtkomst till.

Användaren autentiserar till Azure AD B2C (som SAML IdP) som svarar på Akamai Enterprise Application Access (tjänstleverantören) med en SAML-försäkran. Akamai Enterprise Application Access mappar information från SAML-försäkran och konstruerar OpenID-anspråk eller matar in HTTP-huvuden som innehåller information om användaren. Akamai Enterprise Application Access skickar sedan detta till programmet som är tillgängligt via anslutningsappen för Akamai Enterprise Application Access. I vårt exempel visar programmet innehållet i dessa rubriker. I användningsfallet för OIDC-programmet visas användarens anspråk.

Följande diagram visar hur Akamai Enterprise Application Access (EAA) integreras med Azure AD B2C.

Screenshot shows the integration architecture.

  1. En slutanvändare försöker komma åt ett program som finns i det privata datacentret med hjälp av programmets externa URL som är registrerad i Akamai Enterprise Application Access.

  2. Akamai Enterprise Application Access omdirigerar den oautentiserade slutanvändaren till Azure AD B2C för autentisering.

  3. Efter lyckad autentisering omdirigerar Azure AD B2C användaren tillbaka till Akamai Enterprise Application Access med en SAML-försäkran.

  4. Akamai Enterprise Application Access använder identitetsinformationen från SAML-försäkran för att identifiera användaren och avgöra om användaren får åtkomst till det begärda programmet.

  5. Akamai Enterprise Application Access konstruerar OIDC-anspråk eller matar in HTTP-huvuden som skickas till programmet.

  6. Programmet använder den här informationen för att identifiera den autentiserade användaren och skapar en programsession för slutanvändaren.

Registrera med Akamai Enterprise Application Access

Om du vill komma igång med Akamai Enterprise Application Access kan du läsa kom igång-guiden komma igång med Akamai Enterprise Application Access.

Steg 1 – Lägga till Azure AD B2C som en SAML-IdP i Akamai Enterprise Application Access

Akamai Enterprise Application Access stöder SAML-federation med moln-IDP:er som Azure AD B2C. Lägg till Azure AD B2C som en SAML-IdP från tredje part i Akamai Enterprise Application Access.

  1. Logga in på Enterprise Center https://control.akamai.com/

  2. I navigeringsmenyn i Enterprise Center väljer du Identitetsprovidrar för programåtkomstidentitetsanvändare>&>.

  3. Välj Lägg till identitetsprovider (+).

  4. Ange ett namn, en beskrivning och välj providertypen som SAML från tredje part.

  5. Välj Fortsätt. Konfigurationssidan för identitetsprovidern visas.

  6. I Inställningar> Allmänt anger du en URL för identitetsservern. Du kan välja Använd Akamai-domän eller Använd din domän. Om du använder din egen domän använder du ett självsignerat certifikat eller använder det uppladdade anpassade certifikatet.

  7. I Autentisering anger du samma URL som definierats i föregående steg i Allmänt och Välj Spara.

    Screenshot shows the akamai settings.

Steg 2 – Registrera ett SAML-program i Azure AD B2C

  1. Hämta startpaketen för anpassad princip från GitHub och uppdatera sedan XML-filerna i LocalAccounts-startpaketet med ditt Azure AD B2C-klientnamn:

    • Ladda ned ZIP-filen eller klona lagringsplatsen:

      git clone https://github.com/Azure-Samples/active-directory-b2c-custom-policy-starterpack

    • I alla filer i katalogen LocalAccounts ersätter du strängen yourtenant med namnet på din Azure AD B2C-klientorganisation. Om till exempel namnet på din B2C-klient är fabrikamblir alla instanser av yourtenant.onmicrosoft.com .fabrikam.onmicrosoft.com

  2. Skapa ett signeringscertifikat för Azure AD B2C för att signera SAML-svaret som skickas till Akamai Enterprise Application Access:

    a. Skaffa ett certifikat. Om du inte redan har ett certifikat kan du använda ett självsignerat certifikat.

    b. Ladda upp certifikatet i din Azure AD B2C-klientorganisation. Anteckna namnet eftersom det behövs i de TechnicalProfile som nämns i nästa steg.

  3. Aktivera principen för att ansluta till ett SAML-program.

    a. Öppna LocalAccounts\TrustFrameworkExtensions.xml i startpaketet för anpassad princip. Hitta elementet ClaimsProviders . Om den inte finns lägger du till den under rotelementet TrustFrameworkPolicy och lägger till följande XML-kodfragment för att implementera SAML-svarsgeneratorn:

     <ClaimsProvider>
   <DisplayName>Akamai</DisplayName>
   <TechnicalProfiles>
     <!-- SAML Token Issuer technical profile -->
     <TechnicalProfile Id="AkamaiSaml2AssertionIssuer">
       <DisplayName>Token Issuer</DisplayName>
       <Protocol Name="SAML2" />
       <OutputTokenFormat>SAML2</OutputTokenFormat>
       <Metadata>
         <Item Key="IssuerUri">https://<REPLACE>.login.go.akamai-access.com/saml/sp/response</Item>
       </Metadata>
       <CryptographicKeys>
         <Key Id="SamlAssertionSigning" StorageReferenceId="B2C_1A_AkamaiSAMLSigningCert" />
         <Key Id="SamlMessageSigning" StorageReferenceId="B2C_1A_AkamaiSAMLSigningCert" />
       </CryptographicKeys>
       <InputClaims />
       <OutputClaims />
       <UseTechnicalProfileForSessionManagement ReferenceId="SM-Saml-issuerAkamai" />
     </TechnicalProfile>
     <!-- Session management technical profile for SAML-based tokens -->
     <TechnicalProfile Id="SM-Saml-issuerAkamai">
       <DisplayName>Session Management Provider</DisplayName>
       <Protocol Name="Proprietary" Handler="Web.TPEngine.SSO.SamlSSOSessionProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
       <Metadata>
         <Item Key="IncludeSessionIndex">false</Item>
         <Item Key="RegisterServiceProviders">false</Item>
       </Metadata>
     </TechnicalProfile>
   </TechnicalProfiles>
 </ClaimsProvider>

    b. issuerUri Ersätt med Akamai-URL:en som definierats i Akamai Enterprise Application Access Setting > General i steg 1

    • Exempel <Item Key="IssuerUri">https://fabrikam.login.go.akamai-access.com/saml/sp/response</Item>

    • Ersätt B2C_1A_AkamaiSAMLSigningCert med namnet på den uppladdade principnyckeln.

Steg 3 – Skapa en registrerings- eller inloggningsprincip som konfigurerats för SAML

  1. Skapa en kopia av SignUpOrSignin.xml filen i startpaketets arbetskatalog och spara den med ett nytt namn. Den här artikeln använder SignUpOrSigninSAML.xml som exempel. Den här filen är din principfil för den förlitande parten. Den är konfigurerad för att utfärda ett JWT-svar som standard.

  2. SignUpOrSigninSAML.xml Öppna filen i önskad redigerare.

  3. Uppdatera tenant-name med namnet på din Azure AD B2C-klientorganisation, ändra PolicyId principens värden och PublicPolicyUri till B2C_1A_signup_signin_saml och http://<tenant-name>.onmicrosoft.com/B2C_1A_signup_signin_saml.

    <TrustFrameworkPolicy
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://schemas.microsoft.com/online/cpim/schemas/2013/06"
PolicySchemaVersion="0.3.0.0"
TenantId="tenant-name.onmicrosoft.com"
PolicyId="B2C_1A_signup_signin_saml"
PublicPolicyUri="http://<tenant-name>.onmicrosoft.com/B2C_1A_signup_signin_saml">

  4. I slutet av användarresan innehåller Azure AD B2C ett SendClaims steg. Det här steget refererar till den tekniska profilen token utfärdare. Om du vill utfärda ett SAML-svar i stället för JWT-standardsvaret SendClaims ändrar du steget för att referera till den nya tekniska profilen för SAML Token Issuer, Saml2AssertionIssuer.

    Lägg till följande XML-kodfragment precis före elementet <RelyingParty> . Den här XML-koden skriver över orkestrering steg 4 i SignUpOrSignIn användarresan förutsatt att du använder startpaketen för LocalAccount anpassad princip.

    Om du har startat från en annan mapp i startpaketet eller om du har anpassat användarresan genom att lägga till eller ta bort orkestreringsstegen kontrollerar du att numret i elementet order motsvarar det nummer som angavs i användarresan för token utfärdarsteget. I de andra startpaketmapparna är till exempel motsvarande stegnummer 7 för SocialAndLocalAccounts, 6 för SocialAccountsoch 9 för SocialAndLocalAccountsWithMfa.

    <UserJourneys>
<UserJourney Id="SignUpOrSignIn">
  <OrchestrationSteps>
    <OrchestrationStep Order="4" Type="SendClaims" CpimIssuerTechnicalProfileReferenceId="AkamaiSaml2AssertionIssuer"/>
  </OrchestrationSteps>
</UserJourney>
</UserJourneys>

    Det förlitande partelementet avgör vilket protokoll programmet använder. Standardvärdet är OpenId. Elementet Protocol måste ändras till SAML. Utdataanspråken skapar anspråksmappningen till SAML-försäkran.

    Ersätt hela <TechnicalProfile> elementet i elementet <RelyingParty> med följande tekniska profil-XML.

     <TechnicalProfile Id="PolicyProfile">
   <DisplayName>PolicyProfile</DisplayName>
   <Protocol Name="SAML2"/>
   <OutputClaims>
     <OutputClaim ClaimTypeReferenceId="displayName" />
     <OutputClaim ClaimTypeReferenceId="givenName" />
     <OutputClaim ClaimTypeReferenceId="surname" />
     <OutputClaim ClaimTypeReferenceId="email" DefaultValue="" />
     <OutputClaim ClaimTypeReferenceId="identityProvider" DefaultValue="" />
     <OutputClaim ClaimTypeReferenceId="objectId" PartnerClaimType="objectId"/>
   </OutputClaims>
   <SubjectNamingInfo ClaimType="objectId" ExcludeAsClaim="true"/>
 </TechnicalProfile>

    Den sista principfilen för den förlitande parten bör se ut som följande XML-kod:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<TrustFrameworkPolicy
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns="http://schemas.microsoft.com/online/cpim/schemas/2013/06"
 PolicySchemaVersion="0.3.0.0"
 TenantId="fabrikam.onmicrosoft.com"
 PolicyId="B2C_1A_signup_signin_saml"
 PublicPolicyUri="http://fabrikam.onmicrosoft.com/B2C_1A_signup_signin_saml">
 <BasePolicy>
   <TenantId>fabrikam.onmicrosoft.com</TenantId>
   <PolicyId>B2C_1A_TrustFrameworkExtensions</PolicyId>
 </BasePolicy>

 <UserJourneys>
   <UserJourney Id="SignUpOrSignIn">
     <OrchestrationSteps>
       <OrchestrationStep Order="7" Type="SendClaims" CpimIssuerTechnicalProfileReferenceId="AkamaiSaml2AssertionIssuer"/>
     </OrchestrationSteps>
   </UserJourney>
 </UserJourneys>
 <RelyingParty>
   <DefaultUserJourney ReferenceId="SignUpOrSignIn" />
   <TechnicalProfile Id="PolicyProfile">
     <DisplayName>PolicyProfile</DisplayName>
     <Protocol Name="SAML2"/>
     <OutputClaims>
       <OutputClaim ClaimTypeReferenceId="displayName" />
       <OutputClaim ClaimTypeReferenceId="givenName" />
       <OutputClaim ClaimTypeReferenceId="surname" />
       <OutputClaim ClaimTypeReferenceId="email" DefaultValue="" />
       <OutputClaim ClaimTypeReferenceId="identityProvider" DefaultValue="" />
       <OutputClaim ClaimTypeReferenceId="objectId" PartnerClaimType="objectId"/>
     </OutputClaims>
     <SubjectNamingInfo ClaimType="objectId" ExcludeAsClaim="true"/>
   </TechnicalProfile>
 </RelyingParty>
 </TrustFrameworkPolicy>

Kommentar

Du kan följa samma process för att implementera andra typer av flöden, till exempel inloggning, lösenordsåterställning eller profilredigeringsflöden.

Steg 4 – Ladda upp din princip

Spara ändringarna och ladda upp TrustFrameworkBase.xml, de nya TrustFrameworkExtensions.xml och SignUpOrSigninSAML.xml principfilerna till Azure-portalen.

  1. Logga in på Azure-portalen.

  2. Om du har åtkomst till flera klienter väljer du ikonen Inställningar på den översta menyn för att växla till din Azure AD B2C-klient från menyn Kataloger + prenumerationer.

  3. I Azure-portalen söker du efter och väljer Azure AD B2C.

  4. Under Principer väljer du Identity Experience Framework. Välj Överför anpassad princip och ladda sedan upp de två principfilerna som du ändrade i följande ordning:

    • Basfilen, till exempel TrustFrameworkBase.xml
    • Tilläggsprincipen, till exempel TrustFrameworkExtensions.xml
    • Sedan den förlitande partens princip, till exempel SignUpOrSigninSAML.xml.

Steg 5 – Ladda ned Azure AD B2C IdP SAML-metadata

När principfilerna har laddats upp använder Azure AD B2C konfigurationsinformationen för att generera identitetsproviderns SAML-metadatadokument som programmet ska använda. SAML-metadatadokumentet innehåller platser för tjänster, till exempel inloggningsmetoder, utloggningsmetoder och certifikat.

  • Azure AD B2C-principmetadata är tillgängliga på följande URL: https://<tenant-name>.b2clogin.com/<tenant-name>.onmicrosoft.com/<policy-name>/samlp/metadata

  • Ersätt <tenant-name> med namnet på din Azure AD B2C-klientorganisation. Ersätt <policy-name> med namnet (ID) för principen. Här är ett exempel: https://fabrikam.b2clogin.com/fabrikam.onmicrosoft.com/B2C_1A_signup_signin_saml/samlp/metadata

Ladda ned SAML-metadata och spara dem lokalt på enheten. Detta krävs med följande steg för att slutföra konfigurationen i Akamai Enterprise Application Access.

Steg 6 – Registrera Akamai Enterprise Application Access-program i Azure AD B2C

För att Azure AD B2C ska kunna lita på Akamai Enterprise Application Access skapar du en Azure AD B2C-programregistrering. Registreringen innehåller konfigurationsinformation, till exempel programmets metadataslutpunkt.

  1. Logga in på Azure-portalen.

  2. Om du har åtkomst till flera klienter väljer du ikonen Inställningar på den översta menyn för att växla till din Azure AD B2C-klient från menyn Kataloger + prenumerationer.

  3. Välj Azure AD B2C på den vänstra menyn. Eller välj Alla tjänster och sök sedan efter och välj Azure AD B2C.

  4. Välj Appregistreringar och välj sedan Ny registrering.

  5. Ange ett namn för programmet. Ange till exempel Akamai B2C Enterprise Application Access.

  6. Under Kontotyper som stöds väljer du Endast konton i den här organisationskatalogen (endast B2C – enskild klient).

  7. Under Omdirigerings-URI väljer du Webb och anger sedan den Akamai-URL som definierats i Akamai Enterprise Application Access Setting\General i steg 1. Exempel: https://fabrikam.login.go.akamai-access.com/saml/sp/response

  8. Välj Registrera.

Steg 7 – Konfigurera ditt Akamai Enterprise-programåtkomstprogram i Azure AD B2C

För SAML måste du konfigurera flera egenskaper i programregistreringens manifest.

  1. I Azure-portalen går du till programregistreringen som du skapade i steg 3.

  2. Under Hantera väljer du Manifest för att öppna manifestredigeraren. Ändra sedan egenskaperna som beskrivs i följande avsnitt.

Lägg till identifieraren

När Akamai Enterprise Application Access SAML-programmet skickar en begäran till Azure AD B2C innehåller SAML-autentiseringsbegäran ett Issuer attribut. Värdet för det här attributet är vanligtvis detsamma som programmets metadatavärde entityID . Azure AD B2C använder det här värdet för att söka efter programregistreringen i katalogen och läsa konfigurationen. För att sökningen ska lyckas identifierUri måste du fylla i programregistreringsmanifestet med ett värde som matchar Issuer attributet.

Screenshot shows the b2c saml configuration.

I registreringsmanifestet letar du upp parametern identifierURIs och lägger till det IssuerURI-värde som definierats i steg 2, Azure AD B2C ClaimsProvider.

Exempel:

"identifierUris": [
		"https://fabrikam.login.go.akamai-access.com/saml/sp/response"
	],

Det här värdet är samma värde som konfigureras i SAML AuthN-begäranden för EntityId i programmet och entityID värdet i programmets metadata. Du måste också hitta parametern accessTokenAcceptedVersion och ange värdet till 2.

Viktigt!

Om du inte uppdaterar accessTokenAcceptedVersion till 2 får du ett felmeddelande som kräver en verifierad domän.

Steg 8 – Konfigurera autentiseringsinställningar för Azure AD B2C IdP i Akamai Enterprise Application Access

Uppdatera Akamai Enterprise Application Access Azure AD B2C IdP med autentiseringsinformation som förlitande parts-URL:er.

  1. Logga in på Enterprise Center https://control.akamai.com/

  2. I navigeringsmenyn i Enterprise Center väljer du Identitetsprovidrar för programåtkomstidentitetsanvändare>&>.

  3. Välj namnet på identitetsprovidern som skapades i steg 1.

  4. Ladda upp den Azure AD B2C SAML-metadatafil som du laddade ned i steg 5.

  5. Om du vill ladda upp filen metadata.xml väljer du Välj fil.

    Screenshot shows the metadata file.

  6. Välj Spara och distribuera.

Steg 9 – Distribuera Akamai Enterprise Application Access-Anslut orer i ditt privata datacenter

Om du vill aktivera åtkomst till ett privat program distribuerar du en eller flera Akamai Enterprise Application Access-anslutningsappar i det privata datacenter där programmet finns. Se till att anslutningsapparna kan nå ditt privata program och ha utgående åtkomst till Akamai Cloud.

Steg 10 – Definiera ett åtkomstprogram i Akamai Enterprise-programåtkomst för det privata programmet

  1. Definiera och distribuera ett åtkomstprogram i Akamai Enterprise Application Access.

  2. När du definierar åtkomstprogrammet

Alternativ 1: HTTP-huvuden

I det här exemplet använder vi ett program som visar sidhuvuden docker header-demo-app. När programmet har distribuerats i en privat miljö och en anslutningsapp kan komma åt programmet skapar du ett anpassat HTTP-typprogram enligt Akamai-dokumentationen Konfigurera anpassade HTTP-huvuden för ett åtkomstprogram.

  1. I Autentisering väljer du Azure AD B2C SAML IdP som skapades i föregående steg.

Screenshot shows the akamai authn application.

  1. I avsnittet Avancerat i programmet mappar du HTTP-huvudet till DE SAML-attribut som utfärdats av Azure AD B2C i SAML-svaret vid en lyckad autentisering.

Exempel:

Rubriknamn Attribut
ps-sso-first http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name
ps-sso-last http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname
ps-sso-EmailAddress emailaddress
ps-sso-uid objectId

Screenshot shows the akamai header app mapping.

Testa programmet genom att välja Akamai-URL:en för webbprogrammet av den anpassade HTTP-typ som du skapade.

Screenshot shows the akamai header app results.

Alternativ 2: OpenID Anslut

I det här exemplet använder vi en ASP.NET MVC-webbapp som loggar in användare med hjälp av mellanprogrammet Öppna webbgränssnitt för .NET (OWIN) och Microsofts identitetsplattform.

  1. Konfigurera OIDC till SAML-bryggning i Azure AD B2C SAML IdP som skapades med föregående steg.

    Screenshot shows the akamai oidc app oidc settings.

  2. Skapa ett anpassat HTTP-typprogram efter Konfigurera OpenID-Anslut för ett åtkomstprogram.

  3. I Autentisering väljer du Azure AD B2C SAML IdP som skapades i föregående steg enligt HTTP-huvudprogrammet.

    Screenshot shows the akamai authn app settings.

  4. I Avancerat väljer du OpenID Anslut 1.0 som autentiseringsmekanism och väljer sedan Spara.

    Screenshot shows the akamai oidc app authentication settings.

  5. En ny OpenID-flik visas och kopierar den identifierings-URL som behövs senare i stegen när du konfigurerar OWIN-komponenten för att testa programmet.

    Screenshot shows the akamai oidc app settings.

  6. I avsnittet Anspråk definierar du de anspråk som Akamai utfärdar för OIDC-programmet och mappar sina värden till SAML-attributen som tillhandahålls av Azure AD B2C i SAML-svaret vid en lyckad autentisering. Dessa anspråk måste mappa det du definierade i föregående steg när du konfigurerar OIDC till SAML-bryggning i Azure AD B2C SAML IdP.

    Screenshot shows the akamai oidc app claim settings.

  7. Ersätt startklassen med följande kod i ASP.NET MVC-webbappen.

    Dessa få ändringar konfigurerar beviljandet av auktoriseringskodflödet, auktoriseringskoden löses in för token vid tokenslutpunkten för programmet och den introducerar metadataadressen för att ange identifieringsslutpunkten för att hämta metadata från Akamai.

    public class Startup
{
     // The Client ID is used by the application to uniquely identify itself to Azure AD.
     string clientId = System.Configuration.ConfigurationManager.AppSettings["ClientId"];

     //App Client Secret to redeem the code for an access token
     string ClientSecret = System.Configuration.ConfigurationManager.AppSettings["ClientSecret"];

     // RedirectUri is the URL where the user will be redirected to after they sign in.
     string redirectUri = System.Configuration.ConfigurationManager.AppSettings["RedirectUri"];

     // PostLogoutRedirectUri is the URL where the user will be redirected to after they sign out
     string PostLogoutRedirectUri = System.Configuration.ConfigurationManager.AppSettings["PostLogoutRedirectUri"];

     //Authority is the URL for authority
     string authority = System.Configuration.ConfigurationManager.AppSettings["Authority"];

     //discovery endpoint for obtaining metadata
     string MetadataAddress = System.Configuration.ConfigurationManager.AppSettings["MetadataAddress"];


     /// <summary>
     /// Configure OWIN to use OpenIdConnect
     /// </summary>
     /// <param name="app"></param>
     public void Configuration(IAppBuilder app)
   {
     app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

     app.UseCookieAuthentication(new CookieAuthenticationOptions());
     app.UseOpenIdConnectAuthentication(
         new OpenIdConnectAuthenticationOptions
         {
             // Sets the ClientId, authority, RedirectUri as obtained from web.config
             ClientId = clientId,
             Authority = authority,
             RedirectUri = redirectUri,
             MetadataAddress = MetadataAddress,
             // PostLogoutRedirectUri is the page that users will be redirected to after sign-out. In this case, it is using the home page
             PostLogoutRedirectUri = redirectUri,
             RedeemCode = true,
             Scope = OpenIdConnectScope.OpenIdProfile,
             // ResponseType is set to request the code id_token - which contains basic information about the signed-in user
             ResponseType = OpenIdConnectResponseType.Code,
              // OpenIdConnectAuthenticationNotifications configures OWIN to send notification of failed authentications to OnAuthenticationFailed method
             Notifications = new OpenIdConnectAuthenticationNotifications
             {
                 AuthenticationFailed = OnAuthenticationFailed
             }
         }
     );
 }

 /// <summary>
 /// Handle failed authentication requests by redirecting the user to the home page with an error in the query string
 /// </summary>
 /// <param name="context"></param>
 /// <returns></returns>
 private Task OnAuthenticationFailed(AuthenticationFailedNotification<OpenIdConnectMessage, OpenIdConnectAuthenticationOptions> context)
 {
     context.HandleResponse();
     context.Response.Redirect("/?errormessage=" + context.Exception.Message);
     return Task.FromResult(0);
    }
}

  8. web.config I filen lägger du till metadataadressen och ersätter clientId, clientsecret, authority, redirectUri och PostLogoutRedirectUri med värdena från Akamai-programmet i appSettings.

    Du hittar dessa värden i föregående steg 5 på fliken OpenID för HTTP Akamai-programmet, där du skapade Discovery URL=MetadataAddress. redirectUri är den lokala adressen för Akamai-anslutningsappen som ska matchas mot det lokala OIDC-programmet. Authority är den authorization_endpoint du hittar i .well-known/openid-configurationdokumentet.

    Identifierings-URL: https://fabrikam.login.go.akamai-access.com/.well-known/openid-configuration

     <appSettings>
   <add key="ClientId" value="xxxxxxxxxxxxxxxxxx" />
   <add key="ClientSecret" value="xxxxxxxxxxxxxxxxxx" />
   <add key="Authority" value="https://fabrikam.login.go.akamai-access.com/oidc/oauth" />
   <add key="redirectUri" value="http://oidcapp.identity.mistermik.com/" />
   <add key="PostLogoutRedirectUri" value="https://oidc-test.go.akamai-access.com/" />
   <add key="MetadataAddress" value="https://fabrikam.login.go.akamai-access.com/.well-known/openid-configuration" />
 </appSettings>

    Testa programmet genom att välja Akamai-URL:en för det anpassade webbprogrammet av http-typ som skapats.

    Screenshot shows the akamai oidc app results.

Testa lösningen

  1. Gå till programmets URL med hjälp av den externa URL som anges i Akamai Enterprise Application Access.

  2. Oautentiserad användare omdirigeras till azure AD B2C-inloggningssidan.

  3. Välj IdP i listan på sidan.

  4. Logga in som slutanvändare med autentiseringsuppgifter som är länkade till Azure AD B2C.

  5. Efter lyckad autentisering omdirigeras slutanvändaren tillbaka till programmet och loggas in i programmet som slutanvändare.

Ytterligare resurser