Sdílet prostřednictvím


Podpora Spring Cloud Azure pro Spring Security

Tento článek se vztahuje na:✅ verze 4.19.0 ✅ verze 5.19.0

Tento článek popisuje, jak je možné společně používat Spring Cloud Azure a Spring Security.

Spring Security s Microsoft Entra ID

Při vytváření webové aplikace bude správa identit a přístupu vždy základem.

Azure nabízí skvělou platformu pro demokratizaci vaší cesty vývoje aplikací, protože nabízí nejen službu cloudové základní identity, ale také hlubokou integraci se zbytkem ekosystému Azure.

Spring Security usnadňuje zabezpečení aplikací založených na Springu pomocí výkonných abstrakcí a rozšiřitelných rozhraní. Stejně výkonné jako architektura Spring ale není přizpůsobená konkrétnímu zprostředkovateli identity.

spring-cloud-azure-starter-active-directory poskytuje optimální způsob, jak připojit webovou aplikaci k tenantovi Microsoft Entra ID (Microsoft Entra ID for short) a chránit váš server prostředků pomocí Microsoft Entra ID. K ochraně webových aplikací a serverů prostředků používá protokol Oauth 2.0.

Přístup k webové aplikaci

Tento scénář používá Autorizační kód OAuth 2.0 uděluje toku k přihlášení uživatele pomocí účtu Microsoft.

Systémový diagram

systémový diagram pro samostatnou webovou aplikaci.

Vytvoření požadovaných prostředků v Azure

  1. Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .

  2. Vytvořte registraci aplikace. Získejte AZURE_TENANT_ID, AZURE_CLIENT_IDa AZURE_CLIENT_SECRET.

  3. Nastavte redirect URI na APPLICATION_BASE_URI/login/oauth2/code/ – například http://localhost:8080/login/oauth2/code/. Chvost / je povinný.

Přidání požadovaných závislostí

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

Přidání požadovaných vlastností

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Teď spusťte aplikaci a přejděte k aplikaci prostřednictvím prohlížeče. Budete přesměrováni na přihlašovací stránku Microsoftu.

Pokročilé využití

Přidání dalších konfigurací zabezpečení
@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();
   }
}
Autorizace přístupu podle rolí aplikací

Vytvoření požadovaných prostředků v Azure:

Poznámka

Pokud chcete použít řízení přístupu na základě role aplikace, nemůžete do deklarace identity role vložit názvy skupin. Další informace najdete v části Konfigurace volitelných deklarací identity skupin části Zadání volitelných deklarací identity doaplikace.

Chraňte konkrétní metodu.

class Demo {
   @GetMapping("Admin")
   @ResponseBody
   @PreAuthorize("hasAuthority('APPROLE_Admin')")
   public String admin() {
       return "Admin message";
   }
}
Autorizace přístupu podle názvu skupiny nebo ID skupiny

Přidejte související vlastnosti konfigurace.

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

Chraňte konkrétní metodu.

@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";
   }
}
Použití Národního Azure místo globálního Azure

Teď kromě globálního cloudu Azure se ID Microsoft Entra nasadí v následujících národních cloudech:

  • Azure Government

  • Azure China 21Vianet

  • Azure Germany

Tady je ukázka s využitím Azure China 21Vianet.

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

Další informace najdete v tématu nasazení národních cloudů.

Konfigurace šablony identifikátoru URI přesměrování

Vývojáři můžou identifikátor URI přesměrování přizpůsobit.

systémový diagram pro identifikátory URI přesměrování.

Do souboru redirect-uri-template přidejte vlastnosti.

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

Aktualizujte redirect-uri na webu Azure Portal.

konfigurace šablony identifikátoru URI přesměrování

Po nastavení redirect-uri-templatemusíme aktualizovat tvůrce zabezpečení:

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

Připojení k MICROSOFT Entra ID přes proxy server

Pokud chcete připojit ID Microsoft Entra prostřednictvím proxy serveru, zadejte RestTemplateCustomizer bean jako ten, který je znázorněn v následujícím příkladu:

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

Vzorky

Ukázkový projekt: aad-web-application .

Webová aplikace přistupující k serverům prostředků

Systémový diagram

systémový diagram pro webovou aplikaci, která přistupuje k serverům prostředků.

Vytvoření požadovaných prostředků v Azure

  1. Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .

  2. Vytvořte registraci aplikace. Získejte AZURE_TENANT_ID, AZURE_CLIENT_IDa AZURE_CLIENT_SECRET.

  3. Nastavte redirect URI na APPLICATION_BASE_URI/login/oauth2/code/, například http://localhost:8080/login/oauth2/code/. Chvost / je povinný.

Přidání požadovaných závislostí

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

Přidání požadovaných vlastností

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Tady graph je název OAuth2AuthorizedClient, scopes znamená rozsahy potřebné k vyjádření souhlasu při přihlášení.

Použití OAuth2AuthorizedClient ve vaší aplikaci

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

Teď spusťte aplikaci a přejděte k aplikaci v prohlížeči. Pak budete přesměrováni na přihlašovací stránku Microsoftu.

Pokročilé využití

Tok přihlašovacích údajů klienta

Výchozí tok je tok autorizačního kódu, pokud chcete použít tok přihlašovacích údajů klienta , můžete ho nakonfigurovat takto:

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Přístup k více serverům prostředků

V jedné webové aplikaci můžete získat přístup k více serverům prostředků tak, že nakonfigurujete následující:

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Pak můžete v aplikaci použít OAuth2AuthorizedClient takto:

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

Vzorky

Ukázkový projekt: aad-web-application .

Přístup k serveru prostředků

Tento scénář nepodporuje přihlášení, stačí chránit server ověřením přístupového tokenu. Pokud je přístupový token platný, server žádost obsluhuje.

Systémový diagram

Systémový diagram pro použití samostatného serveru prostředků

Vytvoření požadovaných prostředků v Azure

  1. Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .

  2. Vytvořte registraci aplikace. Získejte AZURE_CLIENT_ID.

  3. Rychlý start ke čtení : Konfigurace aplikace pro zveřejnění webového rozhraní API.

  4. Zveřejnění webového rozhraní API s oborem s názvem Scope-1.

Přidání požadovaných závislostí

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

Přidání požadovaných vlastností

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

Teď spusťte aplikaci a získejte přístup k webovému rozhraní API vaší aplikace.

  1. 401 získáte bez přístupového tokenu.

  2. Přístup k aplikaci pomocí přístupového tokenu Ověří se následující deklarace identity v přístupovém tokenu:

    • iss: Přístupový token musí být vystavený id Microsoft Entra.

    • nbf: Aktuální čas nemůže být před nbf.

    • exp: Aktuální čas nemůže po exp.

    • aud: Pokud je nakonfigurovaná spring.cloud.azure.active-directory.credential.client-id nebo spring.cloud.azure.active-directory.credential.app-id-uri, musí se cílová skupina rovnat nakonfigurovaným client-id nebo app-id-uri. Pokud tyto dvě vlastnosti nejsou nakonfigurované, tato deklarace identity se neověří.

Další informace o přístupovém tokenu najdete v tématu dokumentace MS o přístupových tokenech platformy Microsoft Identity Platform.

Pokročilé využití

Přidání dalších konfigurací zabezpečení
@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();
    }
}
Ověření oprávnění podle oborů
  1. Vytvořte požadované prostředky v Azure.

  2. Chraňte konkrétní metodu.

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

Tímto způsobem se při přístupu /scope1 koncovému bodu ověří následující deklarace identity v přístupovém tokenu:

  • scp: Hodnota musí obsahovat Scope1.
Ověření oprávnění podle rolí aplikací
  1. Vytvořte požadované prostředky v Azure.

  2. Chraňte konkrétní metodu.

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

Tímto způsobem se při přístupu /app-role1 koncovému bodu ověří následující deklarace identity v přístupovém tokenu:

  • roles: Hodnota musí obsahovat AppRole1.
Použití ověřování klienta JWT

Pokud chcete pro ověřování klientů použít webový token JSON (JWT), postupujte následovně:

  1. Viz část Registrace certifikátu v platformě Microsoft Identity Platform přihlašovacích údajů ověřovacího certifikátu aplikace Microsoft Identity Platform.
  2. Nahrajte do aplikace zaregistrované na webu Azure Portal certifikát .pem.
  3. Nakonfigurujte cestu k certifikátu a heslo . PFX nebo . Certifikát P12
  4. Přidejte do klienta konfiguraci spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt vlastnosti, která se má ověřit prostřednictvím ověřování klienta JWT.

Následující ukázkový konfigurační soubor je určený pro scénář webové aplikace. Informace o certifikátu jsou nakonfigurovány v globálních vlastnostech.

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Můžete také nakonfigurovat informace o certifikátu ve vlastnostech služby active-directory, jak je znázorněno v tomto příkladu:

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Připojení k MICROSOFT Entra ID přes proxy server

Pokud chcete propojit ID Microsoft Entra prostřednictvím proxy serveru, zadejte RestTemplateCustomizer bean. Další informace najdete v části Připojení k Microsoft Entra ID prostřednictvím proxy.

Vzorky

Ukázkový projekt: aad-resource-server .

Server prostředků, který navštíví ostatní servery prostředků

Systémový diagram

systémový diagram pro server prostředků, který navštíví ostatní servery prostředků.

Vytvoření požadovaných prostředků v Azure

  1. Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .

  2. Vytvořte registraci aplikace. Získejte AZURE_TENANT_ID, AZURE_CLIENT_IDa AZURE_CLIENT_SECRET.

Přidání požadovaných závislostí

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

Přidání požadovaných vlastností

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Použití OAuth2AuthorizedClient ve vaší aplikaci

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

Vzorky

Ukázkový projekt: aad-resource-server-obo .

Webová aplikace a server prostředků v jedné aplikaci

Vytvoření požadovaných prostředků v Azure

  1. Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .

  2. Vytvořte registraci aplikace. Získejte AZURE_TENANT_ID, AZURE_CLIENT_IDa AZURE_CLIENT_SECRET.

Přidání požadovaných závislostí

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

Přidání požadovaných vlastností

Nastavte vlastnost spring.cloud.azure.active-directory.application-type na web_application_and_resource_servera zadejte typ autorizace pro každého autorizačního klienta.

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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Definování atributu SecurityFilterChain

Nakonfigurujte více instancí SecurityFilterChain. AadWebApplicationAndResourceServerConfig obsahuje dvě konfigurace řetězu filtrů zabezpečení pro server prostředků a webovou aplikaci.

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

Konfigurace

Konfigurovatelné vlastnosti spring-cloud-azure-starter-active-directory:

Jméno Popis
spring.cloud.azure.active-directory.app-id-uri Identifikátor URI ID aplikace, který se může použít v deklaraci identity "aud" id_token.
spring.cloud.azure.active-directory.application-type Typ aplikace Microsoft Entra.
spring.cloud.azure.active-directory.authenticate-additional-parameters Přidejte další parametry do adresy URL autorizace.
spring.cloud.azure.active-directory.authorization-clients Autorizační klienti OAuth2.
spring.cloud.azure.active-directory.credential.client-id ID klienta, které se má použít při ověřování instančního objektu v Azure.
spring.cloud.azure.active-directory.credential.client-secret Tajný klíč klienta, který se má použít při ověřování instančního objektu v Azure.
spring.cloud.azure.active-directory.jwk-set-cache-životnost Životnost sady JWK uložené v mezipaměti před vypršením platnosti je výchozí 5 minut.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time Doba aktualizace sady JWK uložená v mezipaměti před vypršením platnosti je výchozí 5 minut.
spring.cloud.azure.active-directory.jwt-connect-timeout Vypršení časového limitu připojení pro volání vzdálené adresy URL JWKSet
spring.cloud.azure.active-directory.jwt-read-timeout Časový limit čtení pro volání vzdálené adresy URL JWKSet
spring.cloud.azure.active-directory.jwt-size-limit Omezení velikosti v bajtech volání vzdálené adresy URL JWKSet
spring.cloud.azure.active-directory.post-logout-redirect-uri Identifikátor URI přesměrování po odhlášení.
spring.cloud.azure.active-directory.profile.cloud-type Název cloudu Azure, ke kterému se chcete připojit. Podporované typy jsou: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
spring.cloud.azure.active-directory.profile.environment Vlastnosti koncových bodů Microsoft Entra
spring.cloud.azure.active-directory.profile.tenant-id ID tenanta Azure. Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta.
spring.cloud.azure.active-directory.redirect-uri-template Koncový bod přesměrování: Autorizační server používá k vrácení odpovědí obsahujících autorizační přihlašovací údaje klientovi prostřednictvím uživatelského agenta vlastníka prostředku. Výchozí hodnota je {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map Nakonfigurujte, která deklarace identity se použije k sestavení GrantedAuthority, a předponu řetězcové hodnoty GrantedAuthority. Výchozí hodnota je: "scp" –> "SCOPE_", "roles" –> "APPROLE_".
spring.cloud.azure.active-directory.resource-server.principal-claim-name Nakonfigurujte, která deklarace identity v přístupového tokenu se vrátí v souboru AuthenticatedPrincipal#getName. Výchozí hodnota je sub.
spring.cloud.azure.active-directory.session-stateless Pokud true aktivuje bezstavový ověřovací filtr AadAppRoleStatelessAuthenticationFilter. Výchozí hodnota je false, která aktivuje AadAuthenticationFilter.
spring.cloud.azure.active-directory.user-group.allowed-group-ids ID skupiny lze použít k vytvoření GrantedAuthority.
spring.cloud.azure.active-directory.user-group.allowed-group-names Názvy skupin lze použít k vytvoření GrantedAuthority.
spring.cloud.azure.active-directory.user-group.use-transitive-members Pokud je hodnota true, získejte členy pomocí příkazu v1.0/me/transitiveMemberOf. V opačném případě použijte "v1.0/me/memberOf". Výchozí hodnota je false.
spring.cloud.azure.active-directory.user-name-attribute Rozhodněte, která deklarace identity má být názvem objektu zabezpečení.

Tady je několik příkladů použití těchto vlastností:

Typ aplikace

Typ aplikace lze odvodit ze závislostí: spring-security-oauth2-client nebo spring-security-oauth2-resource-server. Pokud odvozená hodnota není požadovanou hodnotou, můžete zadat typ aplikace. Tady je tabulka platných hodnot a odvozených hodnot:

Typ spring-cloud-azure-starter-active-directoryaplikace:

Má závislost: spring-security-oauth2-client Má závislost: spring-security-oauth2-resource-server Platné hodnoty typu aplikace Odvozená hodnota
Ano Ne web_application web_application
Ne Ano resource_server resource_server
Ano Ano web_application, resource_server, resource_server_with_obo, web_application_and_resource_server resource_server_with_obo

Spring Security s Využitím Azure Active Directory B2C

Azure Active Directory (Azure AD) B2C je služba pro správu identit, která umožňuje přizpůsobit a řídit, jak se zákazníci registrují, přihlašují a spravují své profily při používání aplikací. Azure AD B2C umožňuje tyto akce a současně chrání identity vašich zákazníků.

Nastavení závislostí

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

Konfigurace

Konfigurovatelné vlastnosti spring-cloud-azure-starter-active-directory-b2c:

Jméno Popis
spring.cloud.azure.active-directory.b2c.app-id-uri Identifikátor URI ID aplikace, který se může použít v deklaraci identity tokenu "aud".
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters Další parametry pro ověřování.
spring.cloud.azure.active-directory.b2c.authorization-clients Zadejte konfiguraci klienta.
spring.cloud.azure.active-directory.b2c.base-uri Identifikátor URI základního koncového bodu Azure AD B2C
spring.cloud.azure.active-directory.b2c.credential Informace o přihlašovacích údaji Azure AD B2C
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout Vypršení časového limitu připojení pro volání vzdálené adresy URL JWKSet
spring.cloud.azure.active-directory.b2c.jwt-read-timeout Časový limit čtení pro volání vzdálené adresy URL JWKSet
spring.cloud.azure.active-directory.b2c.jwt-size-limit Omezení velikosti v bajtech volání vzdálené adresy URL JWKSet
spring.cloud.azure.active-directory.b2c.login-flow Zadejte primární klíč toku přihlašování. Výchozí hodnota je sign-up-or-sign-in.
spring.cloud.azure.active-directory.b2c.logout-success-url Adresa URL přesměrování po odhlášení Výchozí hodnota je http://localhost:8080/login.
spring.cloud.azure.active-directory.b2c.profile Informace o profilu Azure AD B2C
spring.cloud.azure.active-directory.b2c.reply-url Adresa URL odpovědi po získání autorizačního kódu Výchozí hodnota je {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.b2c.user-flow Toky uživatelů
spring.cloud.azure.active-directory.b2c.user-name-attribute-name Název atributu uživatelského jména.

Pokud chcete úplné konfigurace, zkontrolujte vlastnosti konfigurace Spring Cloud Azure.

Základní využití

webová aplikace je libovolná webová aplikace, která umožňuje přihlášení uživatele pomocí Microsoft Entra ID, zatímco server prostředků přijme nebo odepře přístup po ověření access_token získané z ID Microsoft Entra. V této příručce probereme 4 scénáře:

  1. Přístup k webové aplikaci

  2. Webová aplikace, která přistupuje k serverům prostředků

  3. Přístup k serveru prostředků

  4. Server prostředků, který přistupuje k jiným serverům prostředků.

Použití 1: Přístup k webové aplikaci

Tento scénář používá Autorizační kód OAuth 2.0 uděluje toku pro přihlášení uživatele s uživatelem Azure AD B2C.

V nabídce portálu vyberte Azure AD B2C, vyberteAplikace a pak vyberte Přidat.

Zadejte název aplikace (například ), přidejte proAdresa URL odpovědi , poznamenejte ID aplikace jako a vyberte Uložit.

V aplikaci vyberte Klíče, vyberte Vygenerovat klíč a vygenerujte WEB_APP_AZURE_CLIENT_SECRETa pak vyberte Uložit.

Vyberte Toky uživatelů vlevo a pak vyberte Nový tok uživatele.

Zvolte Registrace nebo v, úpravy profilua resetování hesla vytvářet toky uživatelů. Zadejte tok uživatele Název a Atributy uživatele adeklarací identity a pak vyberte Vytvořit.

Vyberte oprávnění rozhraní APIPřidat oprávněnírozhraní MICROSOFT API, vyberte Microsoft Graph, vyberte Delegovaná oprávnění, vyberte offline_access a Proces dokončete.

Udělení souhlasu správce pro oprávnění Graph

snímku obrazovky webu Azure Portal zobrazující obrazovku oprávnění rozhraní API pro aplikaci se zvýrazněnými oprávněními grafu

Do souboru pom.xml přidejte následující závislosti.

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

Přidejte do souboru application.yml vlastnosti pomocí hodnot, které jste vytvořili dříve, jak je znázorněno v následujícím příkladu:

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}

Napište kód Java.

Kód kontroleru najdete v následujícím příkladu:

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

Kód konfigurace zabezpečení najdete v následujícím příkladu:

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

Zkopírujte home.html z ukázkové a nahraďte a jmény toku uživatele, které jste použili dříve.

Sestavte a otestujte aplikaci. Nechte Webapp běžet na portu 8080.

Po sestavení a spuštění aplikace Maven otevřete http://localhost:8080/ ve webovém prohlížeči. Měli byste být přesměrováni na přihlašovací stránku.

Vyberte odkaz s tokem přihlašovacího uživatele. Měli byste být přesměrováni na Azure AD B2C a zahájit proces ověřování.

Po úspěšném přihlášení byste měli vidět ukázkovou home page z prohlížeče.

Využití 2: Webová aplikace přistupující k serverům prostředků

Tento scénář vychází ze scénáře Přístup k webové aplikaci, aby aplikace mohla přistupovat k jiným prostředkům. Tento scénář je přihlašovací údaje klienta OAuth 2.0 udělovat tok.

V nabídce portálu vyberte Azure AD B2C, vyberteAplikace a pak vyberte Přidat.

Zadejte název aplikace (například ), poznamenejte ID aplikace jako a vyberte Uložit.

V aplikaci vyberte Klíče, vyberte Vygenerovat klíč a vygenerujte WEB_API_A_AZURE_CLIENT_SECRETa pak vyberte Uložit.

V navigačním podokně vyberte Zveřejnit rozhraní API a pak vyberte Nastavit. Poznamenejte identifikátor URI ID aplikace jako WEB_API_A_APP_ID_URLa pak vyberte Uložit.

V navigačním podokně vyberte manifestu a vložte následující segment JSON do pole appRoles. Poznamenejte si identifikátor URI ID aplikace jako WEB_API_A_APP_ID_URL, poznamenejte si hodnotu role aplikace jako WEB_API_A_ROLE_VALUEa pak vyberte Uložit.

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

Vyberte oprávnění rozhraní API>Přidat oprávnění>moje rozhraní API, vyberte Název aplikace WebApiA, vyberte Oprávnění aplikace, vyberte Oprávnění WebApiA.SampleScope a pak vyberte Přidat oprávnění proces dokončit.

Udělení souhlasu správce pro oprávnění WebApiA

snímku obrazovky webu Azure Portal zobrazující obrazovku oprávnění rozhraní API aplikace

Přidejte následující závislost na základě přístupu k webové aplikaci scénář.

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

Přidejte následující konfiguraci na základě Přístup k webové aplikaci scé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

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Napište svůj kód Webapp Javy.

Kód kontroleru najdete v následujícím příkladu:

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

Kód konfigurace zabezpečení je stejný jako ve scénáři Přístup k webové aplikaci. Následujícím způsobem přidejte další webClient bean:

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

Pokud chcete napsat kód WebApiA Javy, přečtěte si část Přístup k serveru prostředků části.

Sestavte a otestujte aplikaci. Nechte Webapp a WebApiA běžet na portech 8080 a 8081. Spusťte aplikace Webapp a WebApiA. Po úspěšném přihlášení se vraťte na domovskou stránku. Pak můžete získat přístup k http://localhost:8080/webapp/webApiA a získat odpověď na WebApiA prostředku.

Použití 3: Přístup k serveru prostředků

Tento scénář nepodporuje přihlášení. Stačí server chránit ověřením přístupového tokenu a pokud je platný, žádost se zobrazí.

Pokud chcete vytvořit oprávnění WebApiA, přečtěte si téma Usage 2: Web Application Accessing Resource Servers.

Přidejte WebApiA oprávnění a udělte správci souhlas pro vaši webovou aplikaci.

Do souboru pom.xml přidejte následující závislosti.

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

Přidejte následující konfiguraci.

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}

Poznámka

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .

Napište kód Java.

Kód kontroleru najdete v následujícím příkladu:

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

Kód konfigurace zabezpečení najdete v následujícím příkladu:

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

Sestavte a otestujte aplikaci. Nechte WebApiA běžet na portu 8081. Získejte přístupový token pro prostředek webApiA a pak získejte přístup k http://localhost:8081/webApiA/sample jako autorizační hlavičku Bearer.

Využití 4: Server prostředků, který přistupuje k jiným serverům prostředků

Tento scénář je upgradem Přístup k serveru prostředkůa podporuje přístup k jiným prostředkům aplikace na základě toku přihlašovacích údajů klienta OAuth2.

V předchozích krocích vytvoříme WebApiB aplikaci a zveřejníme oprávnění aplikace 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"
}

Udělení souhlasu správce pro oprávnění WebApiB

snímku obrazovky webu Azure Portal zobrazující obrazovku oprávnění rozhraní API WebApiA aplikace

Na základě Přístup kserveru prostředků přidejte do souboru pom.xml následující závislost.

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

Na základě konfigurace Přístup k serveru prostředků scénář přidejte následující konfiguraci.

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

Napište kód Java.

Kód kontroleru WebApiA najdete v následujícím příkladu:

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

Kód kontroleru WebApiB najdete v následujícím příkladu:

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

Kód konfigurace zabezpečení je stejný s přístupem k serveru prostředků scénář, další webClient bean je přidán následujícím způsobem:

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

Sestavte a otestujte aplikaci. Nechte WebApiA a WebApiB běžet na portech 8081 a 8082. Spusťte WebApiA a WebApiB aplikace, získejte přístupový token pro prostředek webApiA a jako autorizační hlavičku beareru získejte přístup k http://localhost:8081/webApiA/webApiB/sample.

Vzorky

Další informace najdete v ukázkách spring-cloud-azure-starter-active-directory-b2c.