Spring Cloud Azure-támogatás a Spring Securityhez

A következőre érvényes:: ✅ Version 4.20.0, ✅ Version 5.25.0, ✅ Version 6.5.0, ✅ Version 7.4.0

Ez a cikk azt ismerteti, hogyan használható együtt a Spring Cloud Azure és a Spring Security.

Spring Security Microsoft Entra ID használatával

Webalkalmazás létrehozásakor az identitás- és hozzáférés-kezelés mindig alapvető fontosságú lesz.

Az Azure nagyszerű platformot kínál az alkalmazásfejlesztési folyamat demokratizálásához, mivel nem csak felhőalapú identitásszolgáltatást, hanem az Azure többi ökoszisztémájával való mély integrációt is kínál.

A Spring Security megkönnyíti a Spring-alapú alkalmazások hatékony absztrakciókkal és bővíthető felületekkel való védelmét. A Spring-keretrendszer azonban nem egy adott identitásszolgáltatóra van szabva.

A spring-cloud-azure-starter-active-directory biztosítja a webalkalmazás microsoft entra-azonosítójához (röviden Microsoft Entra-azonosítóhoz) való csatlakoztatásának és az erőforrás-kiszolgáló Microsoft Entra-azonosítóval való védelmének legoptimálisabb módját. Az Oauth 2.0 protokollt használja a webalkalmazások és az erőforrás-kiszolgálók védelmére.

Webalkalmazás elérése

Ez a forgatókönyv Az OAuth 2.0 engedélyezési kód folyamatot biztosít egy Microsoft-fiókkal rendelkező felhasználó bejelentkezéséhez.

Rendszerdiagram

különálló webalkalmazás rendszerdiagramja.

Szükséges erőforrások létrehozása az Azure-ban

Olvassa el rövid útmutatót: Alkalmazás regisztrálása a Microsoft identitásplatformon.
Alkalmazásregisztráció létrehozása. AZURE_TENANT_ID, AZURE_CLIENT_IDés AZURE_CLIENT_SECRETlekérése.
Állítsa a(z) redirect URI értékét erre: APPLICATION_BASE_URI/login/oauth2/code/ – például http://localhost:8080/login/oauth2/code/. A záró / kötelező.

Szükséges függőségek hozzáadása

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

Kötelező tulajdonságok hozzáadása

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

Jegyzet

A tenant-id engedélyezett értékek a következők: common, organizations, consumersvagy bérlőazonosító. Ezekről az értékekről további információt az AADSTS50020 hiba – Az identitásszolgáltatótól származó felhasználói fiók nem létezik a bérlőben című cikk Rossz végpont (személyes és szervezeti fiókok) szakaszában talál. Az egybérlős alkalmazás átalakításával kapcsolatos információkért lásd: Egybérlős alkalmazás átalakítása több-bérlős alkalmazássá a Microsoft Entra ID-ban.

Most indítsa el az alkalmazást, és nyissa meg az alkalmazást a böngészőben. A rendszer átirányítja a Microsoft bejelentkezési oldalára.

Speciális használati módok

További biztonsági konfigurációk hozzáadása

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

   /**
    * Add configuration logic as needed.
    */
   @Bean
   SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
       http.with(AadWebApplicationHttpSecurityConfigurer.aadWebApplication(), Customizer.withDefaults())
           .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated());
           // Do some custom configuration.
       return http.build();
   }
}

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

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

Hozzáférés engedélyezése alkalmazásszerepkörök szerint

Szükséges erőforrások létrehozása az Azure-ban:

Olvassa el a következőt: Alkalmazásszerepkörök hozzáadása az alkalmazáshoz és megkapásuk a tokenben.
Hozzon létre egy alkalmazásszerepkört a következő paraméterekkel:
- Megjelenítendő név: Rendszergazda
- Engedélyezett tagtípusok: Felhasználók/csoportok
- Érték: Rendszergazda
- Szeretné engedélyezni ezt az alkalmazásszerepet: igen

Jegyzet

Ha alkalmazásszerepkör-alapú hozzáférés-vezérlést szeretne használni, nem helyezhet csoportneveket a role jogcímbe. További információért lásd a Opcionális jogcímek megadása az alkalmazás számára című cikk Csoportok választható jogcímeinek konfigurálása című szakaszát.

Az adott metódus védelme.

class Demo {
   @GetMapping("Admin")
   @ResponseBody
   @PreAuthorize("hasAuthority('APPROLE_Admin')")
   public String admin() {
       return "Admin message";
   }
}

Hozzáférés engedélyezése csoportnév vagy csoportazonosító alapján

Adjon hozzá kapcsolódó konfigurációs tulajdonságokat.

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

Az adott metódus védelme.

@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";
   }
}

A Nemzeti Azure használata a globális Azure helyett

A globális Azure-felhő kivételével a Microsoft Entra ID a következő nemzeti felhőkben van üzembe helyezve:

Azure Government
Azure China 21Vianet
Azure Németország

Íme egy minta az Azure China 21Vianet használatával.

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

További információ: nemzeti felhőtelepítések.

Átirányítási URI-sablon konfigurálása

A fejlesztők testre szabhatják az átirányítási uri-t.

átirányítási URI-k rendszerdiagramja.

Adjon hozzá redirect-uri-template tulajdonságokat a application.yml fájlhoz.

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

Frissítse a(z) redirect-uri elemet az Azure Portalon.

A redirect-uri-templatebeállítása után frissíteni kell a biztonsági szerkesztőt:

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

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

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

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

Csatlakozás a Microsoft Entra-azonosítóhoz proxyn keresztül

Ha proxyn keresztül szeretné csatlakoztatni a Microsoft Entra-azonosítót, adjon meg egy RestTemplateCustomizer babot, mint az alábbi példában látható:

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

Minták

Mintaprojekt: aad-web-application.

Erőforrás-kiszolgálókhoz hozzáférő webalkalmazás

Rendszerdiagram

rendszerdiagram erőforrás-kiszolgálókat elérő webalkalmazásokhoz.

Szükséges erőforrások létrehozása az Azure-ban

Olvassa el rövid útmutatót: Alkalmazás regisztrálása a Microsoft identitásplatformon.
Alkalmazásregisztráció létrehozása. AZURE_TENANT_ID, AZURE_CLIENT_IDés AZURE_CLIENT_SECRETlekérése.
Állítsa redirect URI értékét erre: APPLICATION_BASE_URI/login/oauth2/code/, például http://localhost:8080/login/oauth2/code/. A záró / kötelező.

Szükséges függőségek hozzáadása

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

Kötelező tulajdonságok hozzáadása

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

Jegyzet

Itt graph a OAuth2AuthorizedClientneve, scopes a bejelentkezéshez szükséges hatóköröket jelenti.

Az OAuth2AuthorizedClient használata az alkalmazásban

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

Most indítsa el az alkalmazást, és nyissa meg az alkalmazást a böngészőben. Ezután a rendszer átirányítja a Microsoft bejelentkezési oldalára.

Speciális használati módok

Ügyfél hitelesítő adatainak folyamata

Az alapértelmezett folyamat engedélyezési kódfolyamat, ha ügyfél hitelesítőadat-folyamatát szeretné használni, az alábbi módon konfigurálhatja:

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

Jegyzet

Több erőforráskiszolgáló elérése

Egy webalkalmazásban a következőképpen konfigurálva érhet el több erőforráskiszolgálót:

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

Jegyzet

Ezután használhatja a OAuth2AuthorizedClient az ilyen alkalmazásokban

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

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

Minták

Mintaprojekt: aad-web-application.

Erőforrás-kiszolgáló elérése

Ez a forgatókönyv nem támogatja a bejelentkezést, csak a hozzáférési jogkivonat érvényesítésével védi a kiszolgálót. Ha a hozzáférési jogkivonat érvényes, a kiszolgáló kiszolgálja a kérést.

Rendszerdiagram

különálló erőforráskiszolgáló-használat rendszerdiagramja.

Szükséges erőforrások létrehozása az Azure-ban

Olvassa el rövid útmutatót: Alkalmazás regisztrálása a Microsoft identitásplatformon.
Alkalmazásregisztráció létrehozása. AZURE_CLIENT_IDlekérése.
Olvassa el a Gyorsútmutató: Alkalmazás konfigurálása webes API közzétételéhez.
Egy Scope-1nevű hatókörrel rendelkező webes API-t tehet közzé.

Szükséges függőségek hozzáadása

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

Kötelező tulajdonságok hozzáadása

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

Most indítsa el az alkalmazást, és nyissa meg az alkalmazás webes API-ját.

A 401-et hozzáférési jogkivonat nélkül fogja megkapni.
Hozzáférés az alkalmazáshoz hozzáférési jogkivonattal. A hozzáférési tokenben a következő jogcímadatok lesznek ellenőrizve:
- iss: A hozzáférési jogkivonatot a Microsoft Entra ID-nak kell kiállítania.
- nbf: Az aktuális idő nem lehet nbf előtt.
- exp: Az aktuális idő nem lehet exp után.
- aud: Ha spring.cloud.azure.active-directory.credential.client-id vagy spring.cloud.azure.active-directory.credential.app-id-uri konfigurálva van, a célközönségnek meg kell egyezike a konfigurált client-id vagy app-id-uri. Ha a két tulajdonság nincs konfigurálva, a jogcím nem lesz érvényesítve.

A hozzáférési tokennel kapcsolatos további információkért tekintse meg a Microsoft identitásplatform hozzáférési tokenjeiről szóló MS Docs dokumentációt.

Speciális használati módok

További biztonsági konfigurációk hozzáadása

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

    /**
     * Add configuration logic as needed.
     */
    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.with(AadResourceServerHttpSecurityConfigurer.aadResourceServer(), Customizer.withDefaults())
            .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated());
        // @formatter:on
        return http.build();
    }
}

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

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

Engedély érvényesítése hatókörök szerint

Hozzon létre szükséges erőforrásokat az Azure-ban.
- Olvassa el a Rövid útmutató: Alkalmazás konfigurálása webes API közzétételéhez című cikket.
- Egy Scope1nevű hatókörrel rendelkező webes API-t tehet közzé.

Az adott metódus védelme.

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

Ezzel /scope1 végpont elérésekor a következő jogcímek lesznek érvényesítve a hozzáférési jogkivonatban:

scp: Az értéknek Scope1kell tartalmaznia.

Engedély érvényesítése alkalmazásszerepkörök szerint

Hozzon létre szükséges erőforrásokat az Azure-ban.
- Olvassa el a következőt: Alkalmazásszerepkörök hozzáadása az alkalmazáshoz és megkapásuk a tokenben.
- Hozzon létre egy alkalmazásszerepkört a következő paraméterekkel:
  - Megjelenítendő név: AppRole1
  - Engedélyezett tagtípusok: Felhasználók/csoportok
  - Érték: AppRole1
  - Szeretné engedélyezni ezt az alkalmazásszerepet: igen

Az adott metódus védelme.

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

Ezzel /app-role1 végpont elérésekor a következő jogcímek lesznek érvényesítve a hozzáférési jogkivonatban:

roles: Az értéknek AppRole1kell tartalmaznia.

JWT-ügyfélhitelesítés használata

JSON-webjogkivonat (JWT) ügyfél-hitelesítéshez való használatához kövesse az alábbi lépéseket:

Tekintse meg Tanúsítvány regisztrálása a Microsoft identitásplatformon Microsoft identitásplatform-alkalmazás hitelesítési hitelesítő adatainakcímű szakaszát.
Töltsön fel egy .pem tanúsítványt az Azure Portalon regisztrált alkalmazásba.
Állítsa be egy .PFX vagy .P12 tanúsítvány elérési útját és jelszavát.
Adja hozzá a JWT-ügyfélhitelesítéssel hitelesítendő spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt tulajdonságkonfigurációt az ügyfélhez.

Az alábbi példakonfigurációs fájl egy webalkalmazás-forgatókönyvhöz készült. A tanúsítványadatok a globális tulajdonságokban vannak konfigurálva.

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

Jegyzet

A tanúsítványadatokat a active-directory szolgáltatás tulajdonságaiban is konfigurálhatja, ahogyan az ebben a példában látható:

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

Jegyzet

Csatlakozás a Microsoft Entra-azonosítóhoz proxyn keresztül

A Microsoft Entra ID-hez proxykiszolgálón keresztül történő csatlakozáshoz adjon meg egy RestTemplateCustomizer bean-t. További információkért lásd a Kapcsolódás a Microsoft Entra ID-hoz proxyn keresztül című szakaszt.

Minták

Mintaprojekt: aad-resource-server.

Más erőforráskiszolgálókat elérő erőforráskiszolgáló

Rendszerdiagram

Más erőforrás-kiszolgálókat felkereső erőforrás-kiszolgáló rendszerdiagramja.

Szükséges erőforrások létrehozása az Azure-ban

Olvassa el rövid útmutatót: Alkalmazás regisztrálása a Microsoft identitásplatformon.
Alkalmazásregisztráció létrehozása. AZURE_TENANT_ID, AZURE_CLIENT_IDés AZURE_CLIENT_SECRETlekérése.

Szükséges függőségek hozzáadása

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

Kötelező tulajdonságok hozzáadása

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

Jegyzet

Az OAuth2AuthorizedClient használata az alkalmazásban

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

Minták

Mintaprojekt: aad-resource-server-obo.

Webalkalmazás és erőforrás-kiszolgáló egy alkalmazásban

Szükséges erőforrások létrehozása az Azure-ban

Olvassa el rövid útmutatót: Alkalmazás regisztrálása a Microsoft identitásplatformon.
Alkalmazásregisztráció létrehozása. AZURE_TENANT_ID, AZURE_CLIENT_IDés AZURE_CLIENT_SECRETlekérése.

Szükséges függőségek hozzáadása

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

Kötelező tulajdonságok hozzáadása

Állítsa a spring.cloud.azure.active-directory.application-type tulajdonságot web_application_and_resource_serverértékre, és adja meg az egyes engedélyezési ügyfelek engedélyezési típusát.

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

Jegyzet

SecurityFilterChain definiálása

Konfiguráljon több SecurityFilterChain példányt. AadWebApplicationAndResourceServerConfig két biztonsági szűrőlánc-konfigurációt tartalmaz az erőforrás-kiszolgálóhoz és a webalkalmazáshoz.

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

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

    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.with(AadWebApplicationHttpSecurityConfigurer.aadWebApplication(), Customizer.withDefaults())
            .authorizeHttpRequests(auth -> auth.requestMatchers("/login").permitAll().anyRequest().authenticated());
        // @formatter:on
        return http.build();
    }
}

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

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

Konfiguráció

A spring-cloud-azure-starter-active-directory konfigurálható tulajdonságai:

Név	Leírás
`spring.cloud.azure.active-directory.app-id-uri`	Az az alkalmazásazonosító URI, amely felhasználható lehet egy id_token „aud” claimjében.
`spring.cloud.azure.active-directory.application-type`	A Microsoft Entra alkalmazás típusa.
`spring.cloud.azure.active-directory.authenticate-additional-parameters`	Adjon hozzá további paramétereket az engedélyezési URL-címhez.
`spring.cloud.azure.active-directory.authorization-clients`	Az OAuth2 engedélyezési ügyfelei.
`spring.cloud.azure.active-directory.credential.client-id`	Az Azure-ral végzett egyszerű szolgáltatáshitelesítéshez használandó ügyfél-azonosító.
`spring.cloud.azure.active-directory.credential.client-secret`	Az Azure-ral végzett egyszerű szolgáltatáshitelesítéshez használandó ügyfélkód.
`spring.cloud.azure.active-directory.jwk-set-cache-lifespan`	A gyorsítótárazott JWK-készlet élettartamának lejárata előtt az alapértelmezett érték 5 perc.
`spring.cloud.azure.active-directory.jwk-set-cache-refresh-time`	A gyorsítótárazott JWK-készlet frissítési ideje a lejárat előtt, alapértelmezés szerint 5 perc.
`spring.cloud.azure.active-directory.jwt-connect-timeout`	Kapcsolódási időtúllépés a JWKSet távoli URL-jének meghívásakor.
`spring.cloud.azure.active-directory.jwt-read-timeout`	A JWKSet távoli URL-hívásának olvasási időkorlátja.
`spring.cloud.azure.active-directory.jwt-size-limit`	Méretkorlát a távoli JWKSet URL-hívás bájtjaiban.
`spring.cloud.azure.active-directory.post-logout-redirect-uri`	A kijelentkezés utáni átirányítási URI.
`spring.cloud.azure.active-directory.profile.cloud-type`	A csatlakozni kívánt Azure-felhő neve. A támogatott típusok a következők: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
`spring.cloud.azure.active-directory.profile.environment`	Tulajdonságok a Microsoft Entra-végpontokhoz.
`spring.cloud.azure.active-directory.profile.tenant-id`	Azure-bérlőazonosító. A `tenant-id` engedélyezett értékek a következők: `common`, `organizations`, `consumers`vagy bérlőazonosító.
`spring.cloud.azure.active-directory.redirect-uri-template`	Átirányítási végpont: Az engedélyezési kiszolgáló az engedélyezési hitelesítő adatokat tartalmazó válaszok visszaadására szolgál az ügyfélnek az erőforrás-tulajdonos felhasználói ügynökön keresztül. Az alapértelmezett érték a `{baseUrl}/login/oauth2/code/`.
`spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map`	Adja meg, melyik claim lesz használva a GrantedAuthority létrehozásához, valamint a GrantedAuthority karakterlánc-értékének előtagját. Az alapértelmezett érték: "scp" -> "SCOPE_", "roles" -> "APPROLE_".
`spring.cloud.azure.active-directory.resource-server.principal-claim-name`	Konfigurálja, hogy a hozzáférési jogkivonat melyik claimje legyen visszaadva az AuthenticatedPrincipal#getName metódusban. Az alapértelmezett érték a(z) „sub”.
`spring.cloud.azure.active-directory.session-stateless`	Ha az értéke igaz, aktiválja az AadAppRoleStatelessAuthenticationFilter nevű állapot nélküli hitelesítési szűrőt. Az alapértelmezett érték hamis, amely aktiválja az AadAuthenticationFiltert.
`spring.cloud.azure.active-directory.user-group.allowed-group-ids`	A csoportazonosítók az GrantedAuthority létrehozásához használhatók.
`spring.cloud.azure.active-directory.user-group.allowed-group-names`	A csoportnevek a GrantedAuthority létrehozásához használhatók.
`spring.cloud.azure.active-directory.user-group.use-transitive-members`	Ha "igaz", használja a "v1.0/me/transitiveMemberOf" parancsot a tagok lekéréséhez. Ellenkező esetben használja a "v1.0/me/memberOf" parancsot. Az alapértelmezett érték a `false`.
`spring.cloud.azure.active-directory.user-name-attribute`	Döntse el, hogy melyik jogcím legyen a tag neve.

Íme néhány példa a tulajdonságok használatára:

Alkalmazás típusa

Az alkalmazás típusa a függőségekből következtethető ki: spring-security-oauth2-client vagy spring-security-oauth2-resource-server. Ha a kikövetkeztetett érték nem a kívánt érték, megadhatja az alkalmazás típusát. Az alábbi táblázat érvényes értékeket és kikövetkedő értékeket tartalmaz:

A spring-cloud-azure-starter-active-directoryalkalmazástípusa:

Függőség: `spring-security-oauth2-client`	Függőség: `spring-security-oauth2-resource-server`	Alkalmazástípus érvényes értékei	Kikövetkeztetett érték
Igen	Nem	`web_application`	`web_application`
Nem	Igen	`resource_server`	`resource_server`
Igen	Igen	`web_application`, `resource_server`, `resource_server_with_oboweb_application_and_resource_server`	`resource_server_with_obo`

Spring Security az Azure Active Directory B2C-vel

Az Azure Active Directory (Azure AD) B2C egy identitáskezelési szolgáltatás, amellyel testre szabhatja és szabályozhatja az ügyfelek regisztrációját, bejelentkezését és a profiljaik kezelését az alkalmazások használatakor. Az Azure AD B2C lehetővé teszi ezeket a műveleteket, miközben egyszerre védi az ügyfelek identitásait.

Függőségek beállítása

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

Konfiguráció

A spring-cloud-azure-starter-active-directory-b2c konfigurálható tulajdonságai:

Név	Leírás
`spring.cloud.azure.active-directory.b2c.app-id-uri`	Egy token „aud” claimjében használható alkalmazásazonosító URI.
`spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters`	További paraméterek a hitelesítéshez.
`spring.cloud.azure.active-directory.b2c.authorization-clients`	Adja meg az ügyfélkonfigurációt.
`spring.cloud.azure.active-directory.b2c.base-uri`	Az Azure AD B2C-végpont alap-URI-ja.
`spring.cloud.azure.active-directory.b2c.credential`	Az Azure AD B2C hitelesítő adatai.
`spring.cloud.azure.active-directory.b2c.jwt-connect-timeout`	Kapcsolódási időtúllépés a JWKSet távoli URL-jének meghívásakor.
`spring.cloud.azure.active-directory.b2c.jwt-read-timeout`	A JWKSet távoli URL-hívásának olvasási időkorlátja.
`spring.cloud.azure.active-directory.b2c.jwt-size-limit`	Méretkorlát a távoli JWKSet URL-hívás bájtjaiban.
`spring.cloud.azure.active-directory.b2c.login-flow`	Adja meg az elsődleges bejelentkezési folyamatkulcsot. Az alapértelmezett érték a `sign-up-or-sign-in`.
`spring.cloud.azure.active-directory.b2c.logout-success-url`	Url-cím átirányítása kijelentkezés után. Az alapértelmezett érték a `http://localhost:8080/login`.
`spring.cloud.azure.active-directory.b2c.profile`	Az Azure AD B2C-profil adatai.
`spring.cloud.azure.active-directory.b2c.reply-url`	Válasz URL-cím az engedélyezési kód lekérése után. Az alapértelmezett érték a `{baseUrl}/login/oauth2/code/`.
`spring.cloud.azure.active-directory.b2c.user-flows`	Felhasználói folyamatok.
`spring.cloud.azure.active-directory.b2c.user-name-attribute-name`	A felhasználónév attribútum neve.

A teljes konfigurációkért tekintse meg Spring Cloud Azure konfigurációs tulajdonságait.

Alapszintű használat

A webalkalmazások bármely olyan webalapú alkalmazás, amely lehetővé teszi a felhasználó számára a Microsoft Entra-azonosítóval való bejelentkezést, míg egy erőforrás-kiszolgáló a Microsoft Entra-azonosítóból beszerzett access_token ellenőrzése után fogadja vagy megtagadja a hozzáférést. Ebben az útmutatóban 4 forgatókönyvet mutatunk be:

Webalkalmazás elérése.
Erőforrás-kiszolgálókhoz hozzáférő webalkalmazás.
Erőforrás-kiszolgáló elérése.
Más erőforráskiszolgálókhoz hozzáférő erőforrás-kiszolgáló.

1. használat: Webalkalmazás elérése

Ez a forgatókönyv a OAuth 2.0-s engedélyezésikód-jogkivonat folyamatot használja egy felhasználó bejelentkeztetéséhez az Azure AD B2C-felhasználójával.

Válassza Azure AD B2C a portál menüjében, válassza Alkalmazások, majd a Hozzáadáslehetőséget.

Adja meg az alkalmazás nevét (például webapp), adja hozzá a(z) http://localhost:8080/login/oauth2/code/ értéket a Válasz URL-cím mezőhöz, jegyezze fel a Application ID értékét WEB_APP_AZURE_CLIENT_IDként, majd válassza a Mentés lehetőséget.

Az alkalmazásban válassza a Kulcsok lehetőséget, a Kulcs létrehozása lehetőséget a WEB_APP_AZURE_CLIENT_SECRET létrehozásához, majd válassza a Mentés lehetőséget.

Válassza Felhasználói folyamatok lehetőséget a bal oldalon, majd válassza Új felhasználói folyamatlehetőséget.

Válassza a Regisztráció vagy, Profilszerkesztési, valamint a felhasználói folyamatok létrehozásához Jelszóátállítás lehetőséget. Adja meg a felhasználói folyamatot Név és Felhasználói attribútumok és jogcímek, majd válassza a Létrehozáslehetőséget.

Válassza API-engedélyeket>Engedély hozzáadása>Microsoft API-k, válassza Microsoft Graph, válassza Delegált engedélyek, válassza ki a offline_access és openid engedélyeket, majd válassza Engedély hozzáadása a folyamat befejezéséhez.

Adjon rendszergazdai hozzájárulást Graph- engedélyhez.

Adja hozzá a következő függőségeket a pom.xml fájlhoz.

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

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

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

Tulajdonságok hozzáadása a application.yml fájlhoz a korábban létrehozott értékekkel, ahogyan az alábbi példában látható:

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}

Írja meg a Java-kódot.

A vezérlő kódjához tekintse meg a következő példát:

@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";
   }
}

A biztonsági konfigurációs kód esetében tekintse meg a következő példát:

@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(auth -> auth.anyRequest().authenticated())
            .with(configurer, Customizer.withDefaults());
        // @formatter:on
        return http.build();
    }
}

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

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

Másolja a aad-b2c-web-application sample mintából a home.html fájlt, és cserélje le a PROFILE_EDIT_USER_FLOW és a PASSWORD_RESET_USER_FLOW elemet a korábban használt felhasználói folyamatok nevére.

Készítse el és tesztelje az alkalmazást. Futtassa Webapp porton 8080.

Miután a Maven elkészítette és elindította az alkalmazást, nyissa meg a http://localhost:8080/ egy webböngészőben. A bejelentkezési lapra kell átirányítani.

Válassza ki a bejelentkezési felhasználói folyamatot tartalmazó hivatkozást. A hitelesítési folyamat elindításához átirányítani kell az Azure AD B2C-t.

Miután sikeresen bejelentkezett, a(z) home page mintának meg kell jelennie a böngészőben.

2. használat: Erőforrás-kiszolgálókhoz hozzáférő webalkalmazás

Ez a forgatókönyv a Webalkalmazás elérése forgatókönyvre épül, hogy egy alkalmazás más erőforrásokhoz is hozzáférjen. Ez a forgatókönyv a OAuth 2.0 ügyfél-hitelesítőadatok támogatás folyamata.

Válassza Azure AD B2C a portál menüjében, válassza Alkalmazások, majd a Hozzáadáslehetőséget.

Adja meg az alkalmazás Név elemét (például webApiA), jegyezze fel a alkalmazásazonosítót a(z) WEB_API_A_AZURE_CLIENT_ID értékeként, majd válassza a Mentés lehetőséget.

Az alkalmazásban válassza a Kulcsok lehetőséget, a Kulcs létrehozása lehetőséget a WEB_API_A_AZURE_CLIENT_SECRET létrehozásához, majd válassza a Mentés lehetőséget.

A navigációs panelen válassza a API közzététele lehetőséget, majd válassza a Beállítás lehetőséget. Jegyezze fel a Application ID URI-t WEB_API_A_APP_ID_URLként, majd válassza a Mentés lehetőséget.

Válassza Jegyzék a navigációs panelen, majd illessze be a következő JSON-szegmenst appRoles tömbbe. Jegyezze fel a Application ID URI értékét WEB_API_A_APP_ID_URL értékként, jegyezze fel az alkalmazásszerepkör értékét WEB_API_A_ROLE_VALUE értékként, majd válassza a Mentés lehetőséget.

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

Válassza API-engedélyek>Engedély hozzáadása>Saját API-k, válassza WebApiA alkalmazás nevét, válassza Alkalmazásengedélyeklehetőséget, válassza WebApiA.SampleScope engedélyt, majd válassza a Engedély hozzáadása lehetőséget a folyamat befejezéséhez.

Adjon rendszergazdai hozzájárulást WebApiA engedélyéhez.

Adja hozzá a következő függőséget a Webalkalmazás elérése forgatókönyv alapján.

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

Adja hozzá a következő konfigurációt a Webalkalmazás elérése forgatókönyv alapján.

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

Jegyzet

Írja meg a Webapp Java-kódját.

A vezérlő kódjához tekintse meg a következő példát:

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

A biztonsági konfigurációs kód ugyanaz, mint a Webalkalmazás elérése forgatókönyvben. Adjon hozzá egy másik bean webClient az alábbiak szerint:

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

A WebApiA Java-kód írásához tekintse meg az Erőforrás-kiszolgáló elérése című szakaszt.

Készítse el és tesztelje az alkalmazást. Futtassa Webapp és WebApiA a porton 8080 és 8081. Indítsa el a Webapp és WebApiA alkalmazásokat. A sikeres bejelentkezés után térjen vissza a kezdőlapra. Ezután elérheti a http://localhost:8080/webapp/webApiA-t a WebApiA erőforrás válaszának lekéréséhez.

3. használat: Erőforrás-kiszolgáló elérése

Ez a forgatókönyv nem támogatja a bejelentkezést. Csak védje a kiszolgálót a hozzáférési jogkivonat érvényesítésével, és ha érvényes, akkor az kiszolgálja a kérést.

A WebApiA engedély létrehozásához lásd: 2. használat: Webalkalmazások hozzáférése erőforráskiszolgálókhoz.

Adjon hozzá WebApiA engedélyt, és adjon rendszergazdai hozzájárulást a webalkalmazáshoz.

Adja hozzá a következő függőségeket a pom.xml fájlhoz.

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

Adja hozzá a következő konfigurációt.

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}

Jegyzet

Írja meg a Java-kódot.

A vezérlő kódjához tekintse meg a következő példát:

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.";
   }
}

A biztonsági konfigurációs kód esetében tekintse meg a következő példát:

@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(auth -> auth.anyRequest().authenticated())
            .oauth2ResourceServer(o -> o.jwt(j -> j.jwtAuthenticationConverter(authenticationConverter)));
        // @formatter:on
        return http.build();
    }
}

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

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

Készítse el és tesztelje az alkalmazást. Futtassa WebApiA porton 8081. Szerezze be a webApiA erőforrás hozzáférési tokenjét, majd férjen hozzá a http://localhost:8081/webApiA/sample erőforráshoz a Bearer hitelesítési fejlécben.

4. használat: Más erőforráskiszolgálókhoz hozzáférő erőforráskiszolgáló

Ez a forgatókönyv a hozzáférés egy erőforráskiszolgálóhoz továbbfejlesztett változata, és az OAuth2 kliensazonosítós hitelesítési folyamatra épülve támogatja a más alkalmazások erőforrásaihoz való hozzáférést.

Az előző lépésekre hivatkozva létrehozunk egy WebApiB alkalmazást, és közzé teszünk egy alkalmazásengedélyt 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"
}

Adjon rendszergazdai hozzájárulást WebApiB engedélyekhez.

A Erőforráskiszolgáló elérése alapján adja hozzá a következő függőséget a pom.xml fájlhoz.

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

Adja hozzá a következő konfigurációt az erőforrás-kiszolgáló elérése forgatókönyv-konfiguráció alapján.

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

Írja meg a Java-kódot.

A WebApiA vezérlőkódjához tekintse meg a következő példát:

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

A WebApiB vezérlőkódjához tekintse meg a következő példát:

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.";
   }
}

A biztonsági konfigurációs kód megegyezik a Erőforrás-kiszolgáló elérése esetében használt kóddal, és az alábbiak szerint egy másik bean webClient kerül hozzáadásra.

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

Készítse el és tesztelje az alkalmazást. Futtassa WebApiA és WebApiB a porton 8081 és 8082. Indítsa el a WebApiA és WebApiB alkalmazásokat, szerezze be a hozzáférési tokent a webApiA erőforráshoz, és érje el a http://localhost:8081/webApiA/webApiB/sample-t a Bearer engedélyezési fejléc használatával.

Minták

További információkért tekintse meg a spring-cloud-azure-starter-active-directory-b2c mintákat.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-09-21

Spring Cloud Azure-támogatás a Spring Securityhez

Spring Security Microsoft Entra ID használatával

Webalkalmazás elérése

Rendszerdiagram

Szükséges erőforrások létrehozása az Azure-ban

Szükséges függőségek hozzáadása

Kötelező tulajdonságok hozzáadása

Speciális használati módok

További biztonsági konfigurációk hozzáadása

Hozzáférés engedélyezése alkalmazásszerepkörök szerint

Hozzáférés engedélyezése csoportnév vagy csoportazonosító alapján

A Nemzeti Azure használata a globális Azure helyett

Átirányítási URI-sablon konfigurálása

Csatlakozás a Microsoft Entra-azonosítóhoz proxyn keresztül

Minták

Erőforrás-kiszolgálókhoz hozzáférő webalkalmazás

Rendszerdiagram

Szükséges erőforrások létrehozása az Azure-ban

Szükséges függőségek hozzáadása

Kötelező tulajdonságok hozzáadása

Az OAuth2AuthorizedClient használata az alkalmazásban

Speciális használati módok

Ügyfél hitelesítő adatainak folyamata

Több erőforráskiszolgáló elérése

Minták

Erőforrás-kiszolgáló elérése

Rendszerdiagram

Szükséges erőforrások létrehozása az Azure-ban

Szükséges függőségek hozzáadása

Kötelező tulajdonságok hozzáadása

Speciális használati módok

További biztonsági konfigurációk hozzáadása

Engedély érvényesítése hatókörök szerint

Engedély érvényesítése alkalmazásszerepkörök szerint

JWT-ügyfélhitelesítés használata

Csatlakozás a Microsoft Entra-azonosítóhoz proxyn keresztül

Minták

Más erőforráskiszolgálókat elérő erőforráskiszolgáló

Rendszerdiagram

Szükséges erőforrások létrehozása az Azure-ban

Szükséges függőségek hozzáadása

Kötelező tulajdonságok hozzáadása

Az OAuth2AuthorizedClient használata az alkalmazásban

Minták

Webalkalmazás és erőforrás-kiszolgáló egy alkalmazásban

Szükséges erőforrások létrehozása az Azure-ban

Szükséges függőségek hozzáadása

Kötelező tulajdonságok hozzáadása

SecurityFilterChain definiálása

Konfiguráció

Alkalmazás típusa

Spring Security az Azure Active Directory B2C-vel

Függőségek beállítása

Konfiguráció

Alapszintű használat

1. használat: Webalkalmazás elérése

2. használat: Erőforrás-kiszolgálókhoz hozzáférő webalkalmazás

3. használat: Erőforrás-kiszolgáló elérése

4. használat: Más erőforráskiszolgálókhoz hozzáférő erőforráskiszolgáló

Minták

Visszajelzés

További források