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

Artikel
12/06/2023

Den här artikeln gäller för: ✔️ Version 4.14.0 ✔️ Version 5.8.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.

Ger spring-cloud-azure-starter-active-directory det mest optimala sättet att ansluta webbprogrammet 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

Det här scenariot använder OAuth 2.0-auktoriseringskoden bevilja flöde för att logga in en användare med ett Microsoft-konto.

Systemdiagram

System diagram for a standalone web application.

Skapa nödvändiga resurser i Azure

Läs snabbstart: Registrera ett program med Microsofts identitetsplattform.
Skapa en appregistrering. Hämta AZURE_TENANT_ID, AZURE_CLIENT_IDoch AZURE_CLIENT_SECRET.
Ange redirect URI till till APPLICATION_BASE_URI/login/oauth2/code/ 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}

Kommentar

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 Använd fel slutpunkt (personliga konton och organisationskonton) i Fel AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera en klientorganisationsapp 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

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2LoginSecurityConfig extends AadWebSecurityConfigurerAdapter {

    /**
     * Add configuration logic as needed.
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.authorizeRequests()
                .anyRequest().authenticated();
        // Do some custom configuration
    }
}

@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:

Läs Lägg till approller i ditt program och ta emot dem i token.
Skapa en approll med följande parametrar:
- Visningsnamn: Administratör
- Tillåtna medlemstyper: Användare/grupper
- Värde: Administratör
- Vill du aktivera den här approllen: ja

Kommentar

Om du vill använda approllbaserad åtkomstkontroll kan du inte placera gruppnamn i anspråket role . 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 Kina 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.

System diagram for redirect URIs.

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 i Azure-portalen redirect-uri .

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

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2LoginSecurityConfig extends AadWebSecurityConfigurerAdapter {
    /**
     * Add configuration logic as needed.
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.oauth2Login()
                .loginProcessingUrl("${REDIRECT-URI-TEMPLATE}")
                .and()
            .authorizeRequests()
                .anyRequest().authenticated();
    }
}

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

Anslut 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);
        };
    }
}

Exempel

Exempelprojekt: aad-web-application.

Webbprogram som har åtkomst till resursservrar

Systemdiagram

System diagram for a web application accessing resource servers.

Skapa nödvändiga resurser i Azure

Läs snabbstart: Registrera ett program med Microsofts identitetsplattform.
Skapa en appregistrering. Hämta AZURE_TENANT_ID, AZURE_CLIENT_IDoch AZURE_CLIENT_SECRET.
Ange redirect URI till , till APPLICATION_BASE_URI/login/oauth2/code/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

Kommentar

graph Här är 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 autentiseringsuppgifter för klienten kan 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

Kommentar

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

Kommentar

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

Exempel

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

System diagram for standalone resource server usage.

Skapa nödvändiga resurser i Azure

Läs snabbstart: Registrera ett program med Microsofts identitetsplattform.
Skapa en appregistrering. Hämta AZURE_CLIENT_ID.
Läs snabbstart: Konfigurera ett program för att exponera ett webb-API.
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.

Du får 401 utan en åtkomsttoken.
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 får 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 konfigurerad 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 Microsofts identitetsplattform åtkomsttoken.

Avancerade användningar

Lägga till extra säkerhetskonfigurationer

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2ResourceServerSecurityConfig extends AadResourceServerWebSecurityConfigurerAdapter {
    /**
     * Add configuration logic as needed.
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.authorizeRequests((requests) -> requests.anyRequest().authenticated());
    }
}

@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

Skapa nödvändiga resurser i Azure.
- Läs snabbstart: Konfigurera ett program för att exponera ett webb-API.
- Exponera ett webb-API med ett omfång med namnet Scope1.

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 du gör detta verifieras följande anspråk i åtkomsttoken när åtkomstslutpunkten /scope1 används:

scp: Värdet måste innehålla Scope1.

Verifiera behörighet efter approller

Skapa nödvändiga resurser i Azure.
- Läs Lägg till approller i ditt program och ta emot dem i token.
- Skapa en approll med följande parametrar:
  - Visningsnamn: AppRole1
  - Tillåtna medlemstyper: Användare/grupper
  - Värde: AppRole1
  - Vill du aktivera den här approllen: ja

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 du gör detta verifieras följande anspråk i åtkomsttoken när åtkomstslutpunkten /app-role1 används:

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:

Se avsnittet Registrera certifikatet med Microsofts identitetsplattform i Microsofts identitetsplattform autentiseringsuppgifter för programautentisering.
Ladda upp ett .pem-certifikat till programmet som är registrerat i Azure-portalen.
Konfigurera certifikatsökvägen och lösenordet för en . PFX eller . P12-certifikat .
Lägg till egenskapskonfigurationen spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt 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

Kommentar

Du kan också konfigurera certifikatinformationen i tjänstegenskaperna active-directory , 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

Kommentar

Anslut 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 Anslut till Microsoft Entra-ID via proxy.

Exempel

Exempelprojekt: aad-resource-server.

Resursserver som besöker andra resursservrar

Systemdiagram

System diagram for a resource server visiting other resource servers.

Skapa nödvändiga resurser i Azure

Läs snabbstart: Registrera ett program med Microsofts identitetsplattform.
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

Kommentar

Använda OAuth2AuthorizedClient i ditt program

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

Exempel

Exempelprojekt: aad-resource-server-obo.

Webbprogram och resursserver i ett program

Skapa nödvändiga resurser i Azure

Läs snabbstart: Registrera ett program med Microsofts identitetsplattform.
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

Kommentar

Definiera SecurityFilterChain

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

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadWebApplicationAndResourceServerConfig {

    @Order(1)
    @Configuration
    public static class ApiWebSecurityConfigurationAdapter extends AadResourceServerWebSecurityConfigurerAdapter {
        protected void configure(HttpSecurity http) throws Exception {
            super.configure(http);
            // All the paths that match `/api/**`(configurable) work as `Resource Server`, other paths work as `Web application`.
            http.antMatcher("/api/**")
                .authorizeRequests().anyRequest().authenticated();
        }
    }

    @Configuration
    public static class HtmlWebSecurityConfigurerAdapter extends AadWebSecurityConfigurerAdapter {

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            super.configure(http);
            // @formatter:off
            http.authorizeRequests()
                    .antMatchers("/login").permitAll()
                    .anyRequest().authenticated();
            // @formatter:on
        }
    }
}

@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:

Name	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	Anslut ion Timeout 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`, `consumers`eller 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:

Apptyp

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 spring-cloud-azure-starter-active-directoryför :

Har beroende: `spring-security-oauth2-client`	Har beroende: `spring-security-oauth2-resource-server`	Giltiga värden för programtyp	Härledt värde
Ja	No	`web_application`	`web_application`
No	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 hjälper dig att anpassa och styra hur kunderna 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:

Name	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	Anslut ion Timeout 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 Konfigurationsegenskaper för Spring Cloud Azure.

Grundläggande användning

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

Åtkomst till ett webbprogram.
Webbprogram som har åtkomst till resursservrar.
Åtkomst till en resursserver.
Resursserver som har åtkomst till andra resursservrar.

System diagram of web application interaction with Microsoft Entra ID and resource servers.

Användning 1: Åtkomst till ett webbprogram

Det här scenariot använder OAuth 2.0-auktoriseringskodens beviljandeflö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 Program och välj sedan Lägg till.

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

Välj Nycklar från ditt program, 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 in, Profilredigering och Lösenordsåterställning för att skapa användarflöden. Ange ditt användarflödesnamn och användarattribut och anspråk och välj sedan Skapa.

Välj API-behörigheter>Lägg till en behörighet>för 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.

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

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

<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-springsecurity5</artifactId>
   </dependency>
</dependencies>

<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 filen application.yml 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:

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

   private final AadB2cOidcLoginConfigurer configurer;

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

   @Override
   protected void configure(HttpSecurity http) throws Exception {
       // @formatter:off
       http.authorizeRequests()
               .anyRequest().authenticated()
               .and()
           .apply(configurer);
       // @formatter:off
   }
}

@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 exemplet aad-b2c-web-application och 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 köra Webapp på port 8080.

När programmet har skapats och startats av Maven öppnar http://localhost:8080/ du 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 exemplet home page från webbläsaren.

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

Det här scenariot baseras på scenariot Åtkomst till ett webbprogram så att ett program kan komma åt andra resurser. Det här scenariot är beviljandeflödet för OAuth 2.0-klientautentiseringsuppgifter .

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

Ange ditt programnamn (till exempel webApiA), registrera program-ID:t som ditt WEB_API_A_AZURE_CLIENT_IDoch välj sedan Spara.

Välj Nycklar från ditt program, välj Generera nyckel för att generera WEB_API_A_AZURE_CLIENT_SECREToch välj sedan Spara.

Välj Exponera ett API i navigeringsfönstret och välj sedan Ange. Registrera program-ID-URI:n 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 matrisen. 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.

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

<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

Kommentar

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

Information om hur du skriver Java-koden WebApiA finns i avsnittet Åtkomst till en resursserver .

Skapa och testa din app. Låt Webapp och WebApiA kör på port 8080 respektive 8081 . Webapp Starta programmen ochWebApiA. Gå tillbaka till startsidan när du har loggat in. Du kan sedan få åtkomst http://localhost:8080/webapp/webApiA till resurssvaret 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 Användning 2: Webbprogram som har åtkomst till resursservrar.

Lägg till WebApiA behörighet och bevilja administratörsmedgivande för din webbapp.

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

<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}

Kommentar

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:

Spring Cloud Azure 4.x
Spring Cloud Azure 5.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfiguration extends WebSecurityConfigurerAdapter {

   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http.authorizeRequests((requests) -> requests.anyRequest().authenticated())
           .oauth2ResourceServer()
           .jwt()
               .jwtAuthenticationConverter(new AadJwtBearerTokenAuthenticationConverter());
   }
}

@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 köra WebApiA på port 8081. Hämta åtkomsttoken för resursen webApiA och få sedan åtkomst 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 resursserver och har stöd för å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.

På grundval av Åtkomst till en resursserver lä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 konfigurationen Åtkomst till ett resursserverscenario .

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 se 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 se 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 ett resursserverscenario , en annan böna webClient läggs 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ör på port 8081respektive 8082 . WebApiA Starta programmen ochWebApiB, hämta åtkomsttoken för webApiA resursen och åtkomst http://localhost:8081/webApiA/webApiB/sample som ägarauktoriseringshuvud.

Exempel

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

Dela via

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

Spring Security med Microsoft Entra-ID

Åtkomst till ett webbprogram

Systemdiagram

Skapa nödvändiga resurser i Azure

Lägga till nödvändiga beroenden

Lägga till nödvändiga egenskaper

Avancerade användningar

Lägga till extra säkerhetskonfigurationer

Auktorisera åtkomst efter approller

Auktorisera åtkomst efter gruppnamn eller grupp-ID

Använda National Azure i stället för Global Azure

Konfigurera omdirigerings-URI-mall

Anslut till Microsoft Entra-ID via proxy

Exempel

Webbprogram som har åtkomst till resursservrar

Systemdiagram

Skapa nödvändiga resurser i Azure

Lägga till nödvändiga beroenden

Lägga till nödvändiga egenskaper

Använda OAuth2AuthorizedClient i ditt program

Avancerade användningar

Flöde för klientautentiseringsuppgifter

Få åtkomst till flera resursservrar

Exempel

Åtkomst till en resursserver

Systemdiagram

Skapa nödvändiga resurser i Azure

Lägga till nödvändiga beroenden

Lägga till nödvändiga egenskaper

Avancerade användningar

Lägga till extra säkerhetskonfigurationer

Verifiera behörighet efter omfång

Verifiera behörighet efter approller

Använda JWT-klientautentisering

Anslut till Microsoft Entra-ID via proxy

Exempel

Resursserver som besöker andra resursservrar

Systemdiagram

Skapa nödvändiga resurser i Azure

Lägga till nödvändiga beroenden

Lägga till nödvändiga egenskaper

Använda OAuth2AuthorizedClient i ditt program

Exempel

Webbprogram och resursserver i ett program

Skapa nödvändiga resurser i Azure

Lägga till nödvändiga beroenden

Lägga till nödvändiga egenskaper

Definiera SecurityFilterChain

Konfiguration

Apptyp

Spring Security med Azure Active Directory B2C

Beroendekonfiguration

Konfiguration

Grundläggande användning

Användning 1: Åtkomst till ett webbprogram

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

Användning 3: Åtkomst till en resursserver

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

Exempel

Feedback

Ytterligare resurser