Dela via

Stöd för Spring Cloud Azure för Spring Security

  • Artikel

Den här artikeln gäller för:✅ version 4.19.0 ✅ version 5.19.0

Den här artikeln beskriver hur Spring Cloud Azure och Spring Security kan användas tillsammans.

Spring Security med Microsoft Entra-ID

När du skapar ett webbprogram är identitets- och åtkomsthantering alltid grundläggande delar.

Azure erbjuder en bra plattform för att demokratisera din programutvecklingsresa, eftersom den inte bara erbjuder en molnbaserad identitetstjänst, utan även djup integrering med resten av Azure-ekosystemet.

Spring Security har gjort det enkelt att skydda dina Spring-baserade program med kraftfulla abstraktioner och utökningsbara gränssnitt. Men så kraftfullt som Spring-ramverket kan vara är det inte skräddarsytt för en specifik identitetsprovider.

spring-cloud-azure-starter-active-directory är det mest optimala sättet att ansluta webbappen till en Microsoft Entra-ID (Microsoft Entra-ID för kort) klientorganisation och skydda resursservern med Microsoft Entra-ID. Det använder Oauth 2.0-protokollet för att skydda webbprogram och resursservrar.

Åtkomst till ett webbprogram

I det här scenariot används Auktoriseringskoden OAuth 2.0 beviljar flöde för att logga in en användare med ett Microsoft-konto.

Systemdiagram

Systemdiagram för ett fristående webbprogram.

Skapa nödvändiga resurser i Azure

  1. Läs Snabbstart: Registrera ett program med Microsofts identitetsplattform.

  2. Skapa en appregistrering. Hämta AZURE_TENANT_ID, AZURE_CLIENT_IDoch AZURE_CLIENT_SECRET.

  3. Ange redirect URI till APPLICATION_BASE_URI/login/oauth2/code/ – till exempel http://localhost:8080/login/oauth2/code/. Tailing-/ krävs.

Lägga till nödvändiga beroenden

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>

Lägga till nödvändiga egenskaper

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Starta nu programmet och få åtkomst till programmet via webbläsaren. Du omdirigeras till Microsofts inloggningssida.

Avancerade användningar

Lägga till extra säkerhetskonfigurationer
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2LoginSecurityConfig {

   /**
    * Add configuration logic as needed.
    */
   @Bean
   SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
       http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
               .and()
           .authorizeHttpRequests()
               .anyRequest().authenticated();
           // Do some custom configuration.
       return http.build();
   }
}
Auktorisera åtkomst efter approller

Skapa nödvändiga resurser i Azure:

Not

Om du vill använda approllbaserad åtkomstkontroll kan du inte placera gruppnamn i role anspråk. Mer information finns i avsnittet Konfigurera grupper valfria anspråk i Ange valfria anspråk till din app.

Skydda den specifika metoden.

class Demo {
   @GetMapping("Admin")
   @ResponseBody
   @PreAuthorize("hasAuthority('APPROLE_Admin')")
   public String admin() {
       return "Admin message";
   }
}
Auktorisera åtkomst efter gruppnamn eller grupp-ID

Lägg till relaterade konfigurationsegenskaper.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       user-group:
         allowed-group-names: group1_name_1, group2_name_2
         # 1. If allowed-group-ids == all, then all group ID will take effect.
         # 2. If "all" is used, we should not configure other group ids.
         # 3. "all" is only supported for allowed-group-ids, not supported for allowed-group-names.
         allowed-group-ids: group_id_1, group_id_2

Skydda den specifika metoden.

@Controller
public class RoleController {
   @GetMapping("group1")
   @ResponseBody
   @PreAuthorize("hasRole('ROLE_group1')")
   public String group1() {
       return "group1 message";
   }

   @GetMapping("group2")
   @ResponseBody
   @PreAuthorize("hasRole('ROLE_group2')")
   public String group2() {
       return "group2 message";
   }

   @GetMapping("group1Id")
   @ResponseBody
   @PreAuthorize("hasRole('ROLE_<group1-id>')")
   public String group1Id() {
       return "group1Id message";
   }

   @GetMapping("group2Id")
   @ResponseBody
   @PreAuthorize("hasRole('ROLE_<group2-id>')")
   public String group2Id() {
       return "group2Id message";
   }
}
Använda National Azure i stället för Global Azure

Förutom globalt Azure-moln distribueras Microsoft Entra-ID i följande nationella moln:

  • Azure Government

  • Azure China 21Vianet

  • Azure Tyskland

Här är ett exempel med Azure China 21Vianet.

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        base-uri: https://login.partner.microsoftonline.cn
        graph-base-uri: https://microsoftgraph.chinacloudapi.cn

Mer information finns i Nationella molndistributioner.

Konfigurera omdirigerings-URI-mall

Utvecklare kan anpassa omdirigerings-uri.

Systemdiagram för omdirigerings-URI:er.

Lägg till redirect-uri-template egenskaper i filen application.yml.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       redirect-uri-template: ${REDIRECT-URI-TEMPLATE}

Uppdatera redirect-uri i Azure-portalen.

Konfigurera omdirigerings-URI-mall.

När vi har angett redirect-uri-templatemåste vi uppdatera säkerhetsverktyget:

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2LoginSecurityConfig {

    /**
     * Add configuration logic as needed.
     */
    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
                .and()
            .oauth2Login()
                .loginProcessingUrl("${REDIRECT-URI-TEMPLATE}")
                .and()
            .authorizeHttpRequests()
                .anyRequest().authenticated();
        // @formatter:on
        return http.build();
    }
}

Ansluta till Microsoft Entra-ID via proxy

Om du vill ansluta Microsoft Entra-ID via proxy anger du en RestTemplateCustomizer böna som den som visas i följande exempel:

@Configuration
class DemoConfiguration {
    @Bean
    public RestTemplateCustomizer proxyRestTemplateCustomizer() {
        return (RestTemplate restTemplate) -> {
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(PROXY_SERVER_HOST, PROXY_SERVER_PORT));
            SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
            requestFactory.setProxy(proxy);
            restTemplate.setRequestFactory(requestFactory);
        };
    }
}

Prover

Exempelprojekt: aad-web-application.

Webbprogram som har åtkomst till resursservrar

Systemdiagram

Systemdiagram för ett webbprogram som har åtkomst till resursservrar.

Skapa nödvändiga resurser i Azure

  1. Läs Snabbstart: Registrera ett program med Microsofts identitetsplattform.

  2. Skapa en appregistrering. Hämta AZURE_TENANT_ID, AZURE_CLIENT_IDoch AZURE_CLIENT_SECRET.

  3. Ange redirect URI till APPLICATION_BASE_URI/login/oauth2/code/, till exempel http://localhost:8080/login/oauth2/code/. Tailing-/ krävs.

Lägga till nödvändiga beroenden

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>

Lägga till nödvändiga egenskaper

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          graph:
            scopes: https://graph.microsoft.com/Analytics.Read, email

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Här graph namnet på OAuth2AuthorizedClient, scopes innebär de omfång som krävs för att samtycka när du loggar in.

Använda OAuth2AuthorizedClient i ditt program

public class Demo {
    @GetMapping("/graph")
    @ResponseBody
    public String graph(
    @RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graphClient) {
        // toJsonString() is just a demo.
        // oAuth2AuthorizedClient contains access_token. We can use this access_token to access resource server.
        return toJsonString(graphClient);
    }
}

Starta nu programmet och få åtkomst till ditt program i webbläsaren. Sedan omdirigeras du till Microsofts inloggningssida.

Avancerade användningar

Flöde för klientautentiseringsuppgifter

Standardflödet är auktoriseringskodflöde, om du vill använda flöde för klientautentiseringsuppgifterkan du konfigurera så här:

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          graph:
            authorization-grant-type: client_credentials # Change type to client_credentials
            scopes: https://graph.microsoft.com/Analytics.Read, email

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Få åtkomst till flera resursservrar

I ett webbprogram kan du komma åt flera resursservrar genom att konfigurera så här:

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          resource-server-1:
            scopes: # Scopes for resource-server-1
          resource-server-2:
            scopes: # Scopes for resource-server-2

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Sedan kan du använda OAuth2AuthorizedClient i ett program som det här

public class Demo {
    @GetMapping("/resource-server-1")
    @ResponseBody
    public String graph(
    @RegisteredOAuth2AuthorizedClient("resource-server-1") OAuth2AuthorizedClient client) {
        return callResourceServer1(client);
    }

    @GetMapping("/resource-server-2")
    @ResponseBody
    public String graph(
    @RegisteredOAuth2AuthorizedClient("resource-server-2") OAuth2AuthorizedClient client) {
        return callResourceServer2(client);
    }
}

Prover

Exempelprojekt: aad-web-application.

Åtkomst till en resursserver

Det här scenariot stöder inte inloggning, utan skyddar bara servern genom att verifiera åtkomsttoken. Om åtkomsttoken är giltig hanterar servern begäran.

Systemdiagram

Systemdiagram för fristående resursserveranvändning.

Skapa nödvändiga resurser i Azure

  1. Läs Snabbstart: Registrera ett program med Microsofts identitetsplattform.

  2. Skapa en appregistrering. Hämta AZURE_CLIENT_ID.

  3. Läs snabbstart: Konfigurera ett program för att exponera ett webb-API.

  4. Exponera ett webb-API med ett omfång med namnet Scope-1.

Lägga till nödvändiga beroenden

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
</dependencies>

Lägga till nödvändiga egenskaper

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        credential:
          client-id: ${AZURE_CLIENT_ID}

Starta nu programmet och få åtkomst till programmets webb-API.

  1. Du får 401 utan en åtkomsttoken.

  2. Få åtkomst till ditt program med en åtkomsttoken. Följande anspråk i åtkomsttoken verifieras:

    • iss: Åtkomsttoken måste utfärdas av Microsoft Entra-ID.

    • nbf: Den aktuella tiden kan inte vara före nbf.

    • exp: Den aktuella tiden kan inte efter exp.

    • aud: Om spring.cloud.azure.active-directory.credential.client-id eller spring.cloud.azure.active-directory.credential.app-id-uri konfigurerats måste målgruppen vara lika med den konfigurerade client-id eller app-id-uri. Om de två egenskaperna inte har konfigurerats verifieras inte det här anspråket.

Mer information om åtkomsttoken finns i MS-dokument om åtkomsttoken för Microsoft identity platform.

Avancerade användningar

Lägga till extra säkerhetskonfigurationer
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2ResourceServerSecurityConfig {

    /**
     * Add configuration logic as needed.
     */
    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.apply(AadResourceServerHttpSecurityConfigurer.aadResourceServer())
            .and()
            .authorizeHttpRequests()
            .anyRequest().authenticated();
        // @formatter:on
        return http.build();
    }
}
Verifiera behörighet efter omfång

  1. Skapa nödvändiga resurser i Azure.

  2. Skydda den specifika metoden.

    class Demo {
    @GetMapping("scope1")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_Scope1')")
    public String scope1() {
        return "Congratulations, you can access `scope1` endpoint.";
    }
}

När åtkomst /scope1 slutpunkt verifieras följande anspråk i åtkomsttoken:

  • scp: Värdet måste innehålla Scope1.
Verifiera behörighet efter approller

  1. Skapa nödvändiga resurser i Azure.

  2. Skydda den specifika metoden.

    class Demo {
    @GetMapping("app-role1")
    @ResponseBody
    @PreAuthorize("hasAuthority('APPROLE_AppRole1')")
    public String appRole1() {
        return "Congratulations, you can access `app-role1` endpoint.";
    }
}

När åtkomst /app-role1 slutpunkt verifieras följande anspråk i åtkomsttoken:

  • roles: Värdet måste innehålla AppRole1.
Använda JWT-klientautentisering

Använd följande steg för att använda en JSON-webbtoken (JWT) för klientautentisering:

  1. Se avsnittet Registrera ditt certifikat med Microsoft identity platform i autentiseringscertifikat för Microsofts identitetsplattform.
  2. Ladda upp ett .pem- certifikat till programmet som är registrerat i Azure-portalen.
  3. Konfigurera certifikatsökvägen och lösenordet för en . PFX- eller . P12 certifikat.
  4. Lägg till egenskapen spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt konfiguration till klienten som ska autentiseras via JWT-klientautentisering.

Följande exempelkonfigurationsfil är för ett webbprogramscenario. Certifikatinformationen konfigureras i de globala egenskaperna.

spring:
  cloud:
    azure:
      credential:
        client-id: ${AZURE_CLIENT_ID}
        client-certificate-path: ${AZURE_CERTIFICATE_PATH}
        client-certificate-password: ${AZURE_CERTIFICATE_PASSWORD}
      profile:
        tenant-id: <tenant>
      active-directory:
        enabled: true
        user-group:
          allowed-group-names: group1,group2
          allowed-group-ids: <group1-id>,<group2-id>
        post-logout-redirect-uri: http://localhost:8080
        authorization-clients:
          azure:
            client-authentication-method: private_key_jwt
          arm:
            client-authentication-method: private_key_jwt
            scopes: https://management.core.windows.net/user_impersonation
          graph:
            client-authentication-method: private_key_jwt
            scopes:
              - https://graph.microsoft.com/User.Read
              - https://graph.microsoft.com/Directory.Read.All
          webapiA:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_A_APP_ID_URL}/Obo.WebApiA.ExampleScope
          webapiB:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_B_APP_ID_URL}/.default
            authorization-grant-type: client_credentials

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Du kan också konfigurera certifikatinformationen i active-directory-tjänstegenskaperna, som du ser i det här exemplet:

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-certificate-path: ${AZURE_CERTIFICATE_PATH}
          client-certificate-password: ${AZURE_CERTIFICATE_PASSWORD}
        profile:
          tenant-id: <tenant>
        user-group:
          allowed-group-names: group1,group2
          allowed-group-ids: <group1-id>,<group2-id>
        post-logout-redirect-uri: http://localhost:8080
        authorization-clients:
          azure:
            client-authentication-method: private_key_jwt
          arm:
            client-authentication-method: private_key_jwt
            scopes: https://management.core.windows.net/user_impersonation
          graph:
            client-authentication-method: private_key_jwt
            scopes:
              - https://graph.microsoft.com/User.Read
              - https://graph.microsoft.com/Directory.Read.All
          webapiA:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_A_APP_ID_URL}/Obo.WebApiA.ExampleScope
          webapiB:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_B_APP_ID_URL}/.default
            authorization-grant-type: client_credentials

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Ansluta till Microsoft Entra-ID via proxy

Om du vill ansluta Microsoft Entra-ID via proxy anger du en RestTemplateCustomizer böna. Mer information finns i avsnittet Ansluta till Microsoft Entra-ID via proxy.

Prover

Exempelprojekt: aad-resource-server.

Resursserver som besöker andra resursservrar

Systemdiagram

Systemdiagram för en resursserver som besöker andra resursservrar.

Skapa nödvändiga resurser i Azure

  1. Läs Snabbstart: Registrera ett program med Microsofts identitetsplattform.

  2. Skapa en appregistrering. Hämta AZURE_TENANT_ID, AZURE_CLIENT_IDoch AZURE_CLIENT_SECRET.

Lägga till nödvändiga beroenden

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>

Lägga till nödvändiga egenskaper

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          graph:
            scopes:
              - https://graph.microsoft.com/User.Read

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Använda OAuth2AuthorizedClient i ditt program

public class SampleController {
    @GetMapping("call-graph")
    public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
        return callMicrosoftGraphMeEndpoint(graph);
    }
}

Prover

Exempelprojekt: aad-resource-server-obo.

Webbprogram och resursserver i ett program

Skapa nödvändiga resurser i Azure

  1. Läs Snabbstart: Registrera ett program med Microsofts identitetsplattform.

  2. Skapa en appregistrering. Hämta AZURE_TENANT_ID, AZURE_CLIENT_IDoch AZURE_CLIENT_SECRET.

Lägga till nödvändiga beroenden

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>

Lägga till nödvändiga egenskaper

Ange egenskapen spring.cloud.azure.active-directory.application-type till web_application_and_resource_serveroch ange auktoriseringstypen för varje auktoriseringsklient.

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        app-id-uri: ${WEB_API_ID_URI}
        application-type: web_application_and_resource_server  # This is required.
        authorization-clients:
          graph:
            authorizationGrantType: authorization_code # This is required.
            scopes:
              - https://graph.microsoft.com/User.Read
              - https://graph.microsoft.com/Directory.Read.All

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Definiera SecurityFilterChain

Konfigurera flera SecurityFilterChain instanser. AadWebApplicationAndResourceServerConfig innehåller två säkerhetsfilterkedjekonfigurationer för resursserver och webbprogram.

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadWebApplicationAndResourceServerConfig {

    @Bean
    @Order(1)
    public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
        http.apply(AadResourceServerHttpSecurityConfigurer.aadResourceServer())
                .and()
            // All the paths that match `/api/**`(configurable) work as the resource server. Other paths work as the web application.
            .securityMatcher("/api/**")
            .authorizeHttpRequests()
                .anyRequest().authenticated();
        return http.build();
    }

    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
                .and()
            .authorizeHttpRequests()
                .requestMatchers("/login").permitAll()
                .anyRequest().authenticated();
        // @formatter:on
        return http.build();
    }
}

Konfiguration

Konfigurerbara egenskaper för spring-cloud-azure-starter-active-directory:

Namn Beskrivning
spring.cloud.azure.active-directory.app-id-uri App-ID-URI som kan användas i "aud"-anspråket för en id_token.
spring.cloud.azure.active-directory.application-type Typ av Microsoft Entra-program.
spring.cloud.azure.active-directory.authenticate-additional-parameters Lägg till ytterligare parametrar i auktoriserings-URL:en.
spring.cloud.azure.active-directory.authorization-clients OAuth2-auktoriseringsklienter.
spring.cloud.azure.active-directory.credential.client-id Klient-ID som ska användas när du utför autentisering med tjänstens huvudnamn med Azure.
spring.cloud.azure.active-directory.credential.client-secret Klienthemlighet som ska användas vid autentisering av tjänstens huvudnamn med Azure.
spring.cloud.azure.active-directory.jwk-set-cache-lifespan Livslängden för den cachelagrade JWK-uppsättningen innan den upphör att gälla är standardvärdet 5 minuter.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time Uppdateringstiden för den cachelagrade JWK-uppsättningen innan den upphör att gälla är standardvärdet 5 minuter.
spring.cloud.azure.active-directory.jwt-connect-timeout Tidsgräns för anslutning för JWKSet Remote URL-anropet.
spring.cloud.azure.active-directory.jwt-read-timeout Läs timeout för JWKSet Remote URL-anropet.
spring.cloud.azure.active-directory.jwt-size-limit Storleksgräns i byte för JWKSet Remote URL-anropet.
spring.cloud.azure.active-directory.post-logout-redirect-uri Omdirigerings-URI efter utloggning.
spring.cloud.azure.active-directory.profile.cloud-type Namnet på det Azure-moln som ska anslutas till. Typer som stöds är: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
spring.cloud.azure.active-directory.profile.environment Egenskaper för Microsoft Entra-slutpunkter.
spring.cloud.azure.active-directory.profile.tenant-id Azure-klientorganisations-ID. De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID.
spring.cloud.azure.active-directory.redirect-uri-template Omdirigeringsslutpunkt: Används av auktoriseringsservern för att returnera svar som innehåller autentiseringsuppgifter för auktorisering till klienten via resursägarens användaragent. Standardvärdet är {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map Konfigurera vilket anspråk som ska användas för att skapa GrantedAuthority och prefixet för GrantedAuthoritys strängvärde. Standardvärdet är: "scp" –> "SCOPE_", "roles" –> "APPROLE_".
spring.cloud.azure.active-directory.resource-server.principal-claim-name Konfigurera vilket anspråk i åtkomsttoken som ska returneras i AuthenticatedPrincipal#getName. Standardvärdet är "sub".
spring.cloud.azure.active-directory.session-stateless Om true aktiverar det tillståndslösa autentiseringsfiltret AadAppRoleStatelessAuthenticationFilter. Standardvärdet är false som aktiverar AadAuthenticationFilter.
spring.cloud.azure.active-directory.user-group.allowed-group-ids Grupp-ID:erna kan användas för att konstruera GrantedAuthority.
spring.cloud.azure.active-directory.user-group.allowed-group-names Gruppnamnen kan användas för att konstruera GrantedAuthority.
spring.cloud.azure.active-directory.user-group.use-transitive-members Om "sant" använder du "v1.0/me/transitiveMemberOf" för att hämta medlemmar. Annars använder du "v1.0/me/memberOf". Standardvärdet är false.
spring.cloud.azure.active-directory.user-name-attribute Bestäm vilket anspråk som ska vara huvudnamnets namn.

Här följer några exempel på hur du använder dessa egenskaper:

Programtyp

Programtypen kan härledas från beroendena: spring-security-oauth2-client eller spring-security-oauth2-resource-server. Om det härledda värdet inte är det värde du vill använda kan du ange programtypen. Här är tabellen med giltiga värden och härledda värden:

Programtyp för spring-cloud-azure-starter-active-directory:

Har beroende: spring-security-oauth2-client Har beroende: spring-security-oauth2-resource-server Giltiga värden för programtyp Härledt värde
Ja Nej web_application web_application
Nej Ja resource_server resource_server
Ja Ja web_application, resource_server, resource_server_with_obo, web_application_and_resource_server resource_server_with_obo

Spring Security med Azure Active Directory B2C

Azure Active Directory (Azure AD) B2C är en identitetshanteringstjänst som gör att du kan anpassa och styra hur kunder registrerar sig, loggar in och hanterar sina profiler när de använder dina program. Azure AD B2C möjliggör dessa åtgärder samtidigt som kundernas identiteter skyddas.

Beroendekonfiguration

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory-b2c</artifactId>
    </dependency>
</dependencies>

Konfiguration

Konfigurerbara egenskaper för spring-cloud-azure-starter-active-directory-b2c:

Namn Beskrivning
spring.cloud.azure.active-directory.b2c.app-id-uri App-ID-URI som kan användas i "aud"-anspråket för en token.
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters Ytterligare parametrar för autentisering.
spring.cloud.azure.active-directory.b2c.authorization-clients Ange klientkonfiguration.
spring.cloud.azure.active-directory.b2c.base-uri Azure AD B2C-slutpunktsbas-uri.
spring.cloud.azure.active-directory.b2c.credential Autentiseringsinformation för Azure AD B2C.
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout Tidsgräns för anslutning för JWKSet Remote URL-anropet.
spring.cloud.azure.active-directory.b2c.jwt-read-timeout Läs timeout för JWKSet Remote URL-anropet.
spring.cloud.azure.active-directory.b2c.jwt-size-limit Storleksgräns i byte för JWKSet Remote URL-anropet.
spring.cloud.azure.active-directory.b2c.login-flow Ange den primära inloggningsflödesnyckeln. Standardvärdet är sign-up-or-sign-in.
spring.cloud.azure.active-directory.b2c.logout-success-url Omdirigerings-URL efter utloggning. Standardvärdet är http://localhost:8080/login.
spring.cloud.azure.active-directory.b2c.profile Azure AD B2C-profilinformation.
spring.cloud.azure.active-directory.b2c.reply-url Svars-URL efter att ha hämtat auktoriseringskod. Standardvärdet är {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.b2c.user-flows Användarflöden.
spring.cloud.azure.active-directory.b2c.user-name-attribute-name Namn på användarnamnattribut.

Fullständiga konfigurationer finns i Azure-konfigurationsegenskaper för Spring Cloud.

Grundläggande användning

Ett webbprogram är ett webbaserat program som tillåter användare att logga in med Microsoft Entra-ID, medan en resursserver antingen accepterar eller nekar åtkomst efter validering av access_token som hämtats från Microsoft Entra-ID. Vi går igenom fyra scenarier i den här guiden:

  1. Åtkomst till ett webbprogram.

  2. Webbprogram som har åtkomst till resursservrar.

  3. Åtkomst till en resursserver.

  4. Resursserver som har åtkomst till andra resursservrar.

Användning 1: Åtkomst till ett webbprogram

I det här scenariot används OAuth 2.0-auktoriseringskoden bevilja flöde för att logga in en användare med din Azure AD B2C-användare.

Välj Azure AD B2C- på portalmenyn, välj Programoch välj sedan Lägg till.

Ange programmets Namn (till exempel webapp), lägg till http://localhost:8080/login/oauth2/code/ för -svars-URL:en, registrera program-ID som din WEB_APP_AZURE_CLIENT_IDoch välj sedan Spara.

Välj nycklar från programmet, välj Generera nyckel för att generera WEB_APP_AZURE_CLIENT_SECREToch välj sedan Spara.

Välj Användarflöden till vänster och välj sedan Nytt användarflöde.

Välj Registrera dig eller i, Profilredigeringoch Lösenordsåterställning för att skapa användarflöden. Ange ditt användarflöde Namn och Användarattribut och anspråkoch välj sedan Skapa.

Välj API-behörigheter>Lägg till en behörighet>Microsoft API:er, välj Microsoft Graph, välj Delegerade behörigheter, välj offline_access och openid behörigheter och välj sedan Lägg till behörighet för att slutföra processen.

Bevilja administratörsmedgivande för Graph-behörigheter.

skärmbild av Azure-portalen som visar skärmen API-behörigheter för en app med grafbehörigheter markerade.

Lägg till följande beroenden i din pom.xml-fil.

<dependencies>
   <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>azure-spring-boot-starter-active-directory-b2c</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-thymeleaf</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-security</artifactId>
   </dependency>
   <dependency>
       <groupId>org.thymeleaf.extras</groupId>
       <artifactId>thymeleaf-extras-springsecurity6</artifactId>
   </dependency>
</dependencies>

Lägg till egenskaper i application.yml-filen med de värden som du skapade tidigare, som du ser i följande exempel:

spring:
 cloud:
   azure:
     active-directory:
       b2c:
         enabled: true
         authenticate-additional-parameters:
           domain_hint: xxxxxxxxx         # optional
           login_hint: xxxxxxxxx          # optional
           prompt: [login,none,consent]   # optional
         base-uri: ${BASE_URI}
         credential:
           client-id: ${WEBAPP_AZURE_CLIENT_ID}
           client-secret: ${WEBAPP_AZURE_CLIENT_SECRET}
         login-flow: ${LOGIN_USER_FLOW_KEY}               # default to sign-up-or-sign-in, will look up the user-flows map with provided key.
         logout-success-url: ${LOGOUT_SUCCESS_URL}
         user-flows:
           ${YOUR_USER_FLOW_KEY}: ${USER_FLOW_NAME}
         user-name-attribute-name: ${USER_NAME_ATTRIBUTE_NAME}

Skriv din Java-kod.

För din styrenhetskod kan du se följande exempel:

@Controller
public class WebController {

   private void initializeModel(Model model, OAuth2AuthenticationToken token) {
       if (token != null) {
           final OAuth2User user = token.getPrincipal();
           model.addAllAttributes(user.getAttributes());
           model.addAttribute("grant_type", user.getAuthorities());
           model.addAttribute("name", user.getName());
       }
   }

   @GetMapping(value = { "/", "/home" })
   public String index(Model model, OAuth2AuthenticationToken token) {
       initializeModel(model, token);
       return "home";
   }
}

För din säkerhetskonfigurationskod kan du läsa följande exempel:

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
public class WebSecurityConfiguration {

    private final AadB2cOidcLoginConfigurer configurer;

    public WebSecurityConfiguration(AadB2cOidcLoginConfigurer configurer) {
        this.configurer = configurer;
    }

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.authorizeHttpRequests()
                .anyRequest().authenticated()
                .and()
            .apply(configurer);
        // @formatter:on
        return http.build();
    }
}

Kopiera home.html från aad-b2c-web-application exempeloch ersätt PROFILE_EDIT_USER_FLOW och PASSWORD_RESET_USER_FLOW med dina användarnamn som du använde tidigare.

Skapa och testa din app. Låt Webapp köras på port 8080.

När ditt program har skapats och startats av Maven öppnar du http://localhost:8080/ i en webbläsare. Du bör omdirigeras till inloggningssidan.

Välj länken med inloggningsanvändarflödet. Du bör omdirigeras till Azure AD B2C för att starta autentiseringsprocessen.

När du har loggat in bör du se exempel home page från webbläsaren.

Användning 2: Webbprogram som har åtkomst till resursservrar

Det här scenariot baseras på Åtkomst till ett webbprogram scenario för att tillåta att ett program får åtkomst till andra resurser. Det här scenariot är OAuth 2.0-klientens autentiseringsuppgifter beviljar flöde.

Välj Azure AD B2C- på portalmenyn, välj Programoch välj sedan Lägg till.

Ange programmets Namn (till exempel webApiA), registrera program-ID som din WEB_API_A_AZURE_CLIENT_IDoch välj sedan Spara.

Välj nycklar från programmet, välj Generera nyckel för att generera WEB_API_A_AZURE_CLIENT_SECREToch välj sedan Spara.

Välj Exponera en API- i navigeringsfönstret och välj sedan Ange. Registrera program-ID som din WEB_API_A_APP_ID_URLoch välj sedan Spara.

Välj Manifest i navigeringsfönstret och klistra sedan in följande JSON-segment i appRoles matris. Registrera program-ID-URI:n som din WEB_API_A_APP_ID_URL, registrera värdet för approllen som din WEB_API_A_ROLE_VALUEoch välj sedan Spara.

{
 "allowedMemberTypes": [
   "Application"
 ],
 "description": "WebApiA.SampleScope",
 "displayName": "WebApiA.SampleScope",
 "id": "04989db0-3efe-4db6-b716-ae378517d2b7",
 "isEnabled": true,
 "value": "WebApiA.SampleScope"
}

Välj API-behörigheter>Lägg till en behörighet>Mina API:er, välj WebApiA programnamn, välj Programbehörigheter, välj WebApiA.SampleScope behörighet och välj sedan Lägg till behörighet för att slutföra processen.

Bevilja administratörsmedgivande för WebApiA- behörigheter.

skärmbild av Azure-portalen som visar skärmen för program-API-behörigheter.

Lägg till följande beroende på grundval av Åtkomst till ett webbprogram scenario.

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

Lägg till följande konfiguration på grundval av scenariot Åtkomst till ett webbprogram.

spring:
 cloud:
   azure:
     active-directory:
       b2c:
         enabled: true
         base-uri: ${BASE_URI}             # Such as: https://xxxxb2c.b2clogin.com
         profile:
           tenant-id: <tenant>
         authorization-clients:
           ${RESOURCE_SERVER_A_NAME}:
             authorization-grant-type: client_credentials
             scopes: ${WEB_API_A_APP_ID_URL}/.default

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Skriv din Webapp Java-kod.

För din styrenhetskod kan du se följande exempel:

class Demo {
   /**
    * Access to protected data from Webapp to WebApiA through client credential flow. The access token is obtained by webclient, or
    * <p>@RegisteredOAuth2AuthorizedClient("webApiA")</p>. In the end, these two approaches will be executed to
    * DefaultOAuth2AuthorizedClientManager#authorize method, get the access token.
    *
    * @return Respond to protected data from WebApi A.
    */
   @GetMapping("/webapp/webApiA")
   public String callWebApiA() {
       String body = webClient
           .get()
           .uri(LOCAL_WEB_API_A_SAMPLE_ENDPOINT)
           .attributes(clientRegistrationId("webApiA"))
           .retrieve()
           .bodyToMono(String.class)
           .block();
       LOGGER.info("Call callWebApiA(), request '/webApiA/sample' returned: {}", body);
       return "Request '/webApiA/sample'(WebApi A) returned a " + (body != null ? "success." : "failure.");
   }
}

Säkerhetskonfigurationskoden är densamma som i scenariot Åtkomst till ett webbprogram. Lägg till ytterligare en böna webClient på följande sätt:

public class SampleConfiguration {
   @Bean
   public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
       ServletOAuth2AuthorizedClientExchangeFilterFunction function =
           new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
       return WebClient.builder()
                       .apply(function.oauth2Configuration())
                       .build();
   }
}

Om du vill skriva din WebApiA Java-kod kan du läsa avsnittet Åtkomst till en resursserver.

Skapa och testa din app. Låt Webapp och WebApiA köras på port 8080 respektive 8081. Starta programmen Webapp och WebApiA. Gå tillbaka till startsidan när du har loggat in. Du kan sedan komma åt http://localhost:8080/webapp/webApiA för att hämta resurssvaret för WebApiA.

Användning 3: Åtkomst till en resursserver

Det här scenariot stöder inte inloggning. Skydda bara servern genom att verifiera åtkomsttoken och om den är giltig hanterar den begäran.

Information om hur du skapar din WebApiA-behörighet finns i Usage 2: Web Application Accessing Resource Servers.

Lägg till WebApiA behörighet och bevilja administratörsmedgivande för ditt webbprogram.

Lägg till följande beroenden i din pom.xml-fil.

<dependencies>
   <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>azure-spring-boot-starter-active-directory-b2c</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Lägg till följande konfiguration.

spring:
 cloud:
   azure:
     active-directory:
       b2c:
         enabled: true
         base-uri: ${BASE_URI}             # Such as: https://xxxxb2c.b2clogin.com
         profile:
           tenant-id: <tenant>
         app-id-uri: ${APP_ID_URI}         # If you're using v1.0 token, configure app-id-uri for `aud` verification
         credential:
           client-id: ${AZURE_CLIENT_ID}           # If you're using v2.0 token, configure client-id for `aud` verification
         user-flows:
           sign-up-or-sign-in: ${SIGN_UP_OR_SIGN_IN_USER_FLOW_NAME}

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Skriv din Java-kod.

För din styrenhetskod kan du se följande exempel:

class Demo {
   /**
    * webApiA resource api for web app
    * @return test content
    */
   @PreAuthorize("hasAuthority('APPROLE_WebApiA.SampleScope')")
   @GetMapping("/webApiA/sample")
   public String webApiASample() {
       LOGGER.info("Call webApiASample()");
       return "Request '/webApiA/sample'(WebApi A) returned successfully.";
   }
}

För din säkerhetskonfigurationskod kan du läsa följande exempel:

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class ResourceServerConfiguration {
    
    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        JwtAuthenticationConverter authenticationConverter = new JwtAuthenticationConverter();
        JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
        jwtGrantedAuthoritiesConverter.setAuthorityPrefix("APPROLE_");
        authenticationConverter.setJwtGrantedAuthoritiesConverter(jwtGrantedAuthoritiesConverter);
        // @formatter:off
        http.authorizeHttpRequests((requests) -> requests.anyRequest().authenticated())
            .oauth2ResourceServer()
            .jwt()
            .jwtAuthenticationConverter(authenticationConverter);
        // @formatter:on
        return http.build();
    }
}

Skapa och testa din app. Låt WebApiA köras på port 8081. Hämta åtkomsttoken för den webApiA resursen och få sedan åtkomst till http://localhost:8081/webApiA/sample som ägarauktoriseringshuvud.

Användning 4: Resursserver som har åtkomst till andra resursservrar

Det här scenariot är en uppgradering av Åtkomst till en resursserveroch stöder åtkomst till andra programresurser baserat på OAuth2-klientens autentiseringsuppgifter.

Med hänvisning till föregående steg skapar vi ett WebApiB-program och exponerar en programbehörighet WebApiB.SampleScope.

{
   "allowedMemberTypes": [
       "Application"
   ],
   "description": "WebApiB.SampleScope",
   "displayName": "WebApiB.SampleScope",
   "id": "04989db0-3efe-4db6-b716-ae378517d2b7",
   "isEnabled": true,
   "lang": null,
   "origin": "Application",
   "value": "WebApiB.SampleScope"
}

Bevilja administratörsmedgivande för WebApiB behörigheter.

skärmbild av Azure-portalen som visar skärmen för webapia-API-behörigheter för programmet.

På grundval av Åtkomst till en resursserverlägger du till följande beroende i din pom.xml-fil.

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

Lägg till följande konfiguration på grundval av Åtkomst till en resursserver scenariokonfiguration.

spring:
 cloud:
   azure:
     active-directory:
       b2c:
         enabled: true
         credential:
           client-secret: ${WEB_API_A_AZURE_CLIENT_SECRET}
         authorization-clients:
           ${RESOURCE_SERVER_B_NAME}:
             authorization-grant-type: client_credentials
             scopes: ${WEB_API_B_APP_ID_URL}/.default

Skriv din Java-kod.

För din WebApiA styrenhetskod kan du läsa följande exempel:

public class SampleController {
   /**
    * Access to protected data from WebApiA to WebApiB through client credential flow. The access token is obtained by webclient, or
    * <p>@RegisteredOAuth2AuthorizedClient("webApiA")</p>. In the end, these two approaches will be executed to
    * DefaultOAuth2AuthorizedClientManager#authorize method, get the access token.
    *
    * @return Respond to protected data from WebApi B.
    */
   @GetMapping("/webApiA/webApiB/sample")
   @PreAuthorize("hasAuthority('APPROLE_WebApiA.SampleScope')")
   public String callWebApiB() {
       String body = webClient
           .get()
           .uri(LOCAL_WEB_API_B_SAMPLE_ENDPOINT)
           .attributes(clientRegistrationId("webApiB"))
           .retrieve()
           .bodyToMono(String.class)
           .block();
       LOGGER.info("Call callWebApiB(), request '/webApiB/sample' returned: {}", body);
       return "Request 'webApiA/webApiB/sample'(WebApi A) returned a " + (body != null ? "success." : "failure.");
   }
}

För din WebApiB styrenhetskod kan du läsa följande exempel:

public class SampleController {
   /**
    * webApiB resource api for other web application
    * @return test content
    */
   @PreAuthorize("hasAuthority('APPROLE_WebApiB.SampleScope')")
   @GetMapping("/webApiB/sample")
   public String webApiBSample() {
       LOGGER.info("Call webApiBSample()");
       return "Request '/webApiB/sample'(WebApi B) returned successfully.";
   }
}

Säkerhetskonfigurationskoden är densamma med Åtkomst till en resursserver scenario läggs en annan böna webClient till på följande sätt

public class SampleConfiguration {
   @Bean
   public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
       ServletOAuth2AuthorizedClientExchangeFilterFunction function =
           new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
       return WebClient.builder()
                       .apply(function.oauth2Configuration())
                       .build();
   }
}

Skapa och testa din app. Låt WebApiA och WebApiB köras på port 8081 respektive 8082. Starta WebApiA och WebApiB program, hämta åtkomsttoken för webApiA resurs och få åtkomst http://localhost:8081/webApiA/webApiB/sample som ägarauktoriseringshuvud.

Prover

Mer information finns i spring-cloud-azure-starter-active-directory-b2c-exempel.