Spring Cloud podpora Azure for Spring Security

Článek
12/06/2023

Tento článek se vztahuje na: ✔️ Verze 4.14.0 ✔️ verze 5.8.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.

Poskytuje spring-cloud-azure-starter-active-directory nejoptimálnější způsob, jak připojit webovou aplikaci k tenantovi Microsoft Entra ID (Microsoft Entra ID pro krátké) 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á tok udělení autorizačního kódu OAuth 2.0 k přihlášení uživatele pomocí účtu Microsoft.

Systémový diagram

System diagram for a standalone web application.

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

Přečtěte si rychlý start: Registrace aplikace na platformě Microsoft Identity Platform.
Vytvořte registraci aplikace. Získat AZURE_TENANT_ID, AZURE_CLIENT_IDa AZURE_CLIENT_SECRET.
Nastavit 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:

Povolené hodnoty 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ích účtů a účtů organizace) v části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity v tenantovi neexistuje. Informace o převodu aplikace s jedním tenantem najdete v tématu Převod aplikace s jedním tenantem na víceklienta na ID Microsoft Entra.

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í

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

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

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

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

Autorizace přístupu podle rolí aplikací

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

Přečtěte si článek Přidání rolí aplikace do aplikace a jejich přijetí v tokenu.
Vytvořte roli aplikace s následujícími parametry:
- Zobrazovaný název: Správa
- Povolené typy členů: Uživatelé/skupiny
- Hodnota: Správa
- Chcete povolit tuto roli aplikace: Ano

Poznámka:

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

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 (Čína) 21Vianet
Azure (Německo)

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.

System diagram for redirect URIs.

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

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

Aktualizujte redirect-uri na webu Azure Portal.

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

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

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

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

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

Připojení na MICROSOFT Entra ID prostřednictvím proxy serveru

Pokud chcete propojit 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);
        };
    }
}

Ukázky

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

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

Systémový diagram

System diagram for a web application accessing resource servers.

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

Přečtěte si rychlý start: Registrace aplikace na platformě Microsoft Identity Platform.
Vytvořte registraci aplikace. Získat AZURE_TENANT_ID, AZURE_CLIENT_IDa AZURE_CLIENT_SECRET.
Nastavit 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:

graph Tady 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:

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:

Pak můžete použít OAuth2AuthorizedClient v aplikaci, jako je tato:

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

Ukázky

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

System diagram for standalone resource server usage.

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

Přečtěte si rychlý start: Registrace aplikace na platformě Microsoft Identity Platform.
Vytvořte registraci aplikace. Získat AZURE_CLIENT_ID.
Rychlý start pro čtení: Konfigurace aplikace pro zveřejnění webového rozhraní API
Zveřejnění webového rozhraní API s názvem Scope-1oboru .

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.

401 získáte bez přístupového tokenu.
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: Je-li spring.cloud.azure.active-directory.credential.client-id nebo spring.cloud.azure.active-directory.credential.app-id-uri nakonfigurováno, musí cílová skupina odpovídat nakonfigurované 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 dokumentaci MS o přístupových tokenech platformy Microsoft Identity Platform.

Pokročilé využití

Přidání dalších konfigurací zabezpečení

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

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

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

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

Ověření oprávnění podle oborů

Vytvořte požadované prostředky v Azure.
- Rychlý start pro čtení: Konfigurace aplikace pro zveřejnění webového rozhraní API
- Zveřejnění webového rozhraní API s názvem Scope1oboru .

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ého 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í

Vytvořte požadované prostředky v Azure.
- Přečtěte si článek Přidání rolí aplikace do aplikace a jejich přijetí v tokenu.
- Vytvořte roli aplikace s následujícími parametry:
  - Zobrazovaný název: AppRole1
  - Povolené typy členů: Uživatelé/skupiny
  - Hodnota: AppRole1
  - Chcete povolit tuto roli aplikace: Ano

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ého 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ě:

Přečtěte si část Registrace certifikátu v části Microsoft Identity Platform přihlašovacích údajů k ověřovacímu certifikátu aplikace Microsoft Identity Platform.
Nahrajte certifikát .pem do aplikace zaregistrované na webu Azure Portal.
Nakonfigurujte cestu k certifikátu a heslo . PFX nebo . Certifikát P12 .
Přidejte do klienta konfiguraci vlastnosti spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt , 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:

Můžete také nakonfigurovat informace o certifikátu ve active-directory vlastnostech služby, 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:

Připojení na MICROSOFT Entra ID prostřednictvím proxy serveru

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

Ukázky

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

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

Systémový diagram

System diagram for a resource server visiting other resource servers.

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

Přečtěte si rychlý start: Registrace aplikace na platformě Microsoft Identity Platform.
Vytvořte registraci aplikace. Získat 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:

Použití OAuth2AuthorizedClient ve vaší aplikaci

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

Ukázky

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

Přečtěte si rychlý start: Registrace aplikace na platformě Microsoft Identity Platform.
Vytvořte registraci aplikace. Získat 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_serverhodnotu a 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:

Definování atributu SecurityFilterChain

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

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

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

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

    @Configuration
    public static class HtmlWebSecurityConfigurerAdapter extends AadWebSecurityConfigurerAdapter {

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

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

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

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

Konfigurace

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

Název	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	Připojení vypršení časového limitu 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. Povolené hodnoty `tenant-id` jsou: `common`, `organizations`, `consumers`nebo 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
Yes	No	`web_application`	`web_application`
No	Ano	`resource_server`	`resource_server`
Ano	Yes	`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ůsobení a řízení způsobu, jakým se zákazníci registrují, přihlašují a jakým při používání vašich aplikací spravují své profily. Azure AD B2C umožňuje tyto akce, zatímco zároveň 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:

Název	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	Připojení vypršení časového limitu 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-flows	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 Azure Spring Cloud.

Základní použití

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

Přístup k webové aplikaci
Webová aplikace, která přistupuje k serverům prostředků
Přístup k serveru prostředků
Server prostředků, který přistupuje k jiným serverům prostředků.

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

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

Tento scénář používá tok udělení autorizačního kódu OAuth 2.0 k přihlášení uživatele s uživatelem Azure AD B2C.

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

Zadejte název aplikace (například webapp), přidejte http://localhost:8080/login/oauth2/code/ pro adresu URL odpovědi, poznamenejte si ID aplikace jako vaše WEB_APP_AZURE_CLIENT_IDa pak vyberte Uložit.

V aplikaci vyberte Klíče, vyberte Vygenerovat klíč, který chcete vygenerovatWEB_APP_AZURE_CLIENT_SECRET, a pak vyberte Uložit.

Na levé straně vyberte Toky uživatelů a pak vyberte Nový tok uživatele.

Zvolte Možnost Registrace nebo Přihlášení, Úpravy profilu a Resetování hesla a vytvořte toky uživatelů. Zadejte název toku uživatele a atributy uživatele a deklarace identity a pak vyberte Vytvořit.

Vyberte oprávnění rozhraní API Pro přidání oprávnění>>rozhraní Microsoft API, vyberte Microsoft Graph, vyberte Delegovaná oprávnění, vyberte offline_access a openid oprávnění a pak vyberte Přidat oprávnění k dokončení procesu.

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

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

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

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

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

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:

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

@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

   private final AadB2cOidcLoginConfigurer configurer;

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

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

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

    private final AadB2cOidcLoginConfigurer configurer;

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

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

Zkopírujte home.html z ukázky webové aplikace aad-b2c-web-application a nahraďte PROFILE_EDIT_USER_FLOW název toku uživatele, PASSWORD_RESET_USER_FLOW 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ázku home page z prohlížeče.

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

Tento scénář je založený na scénáři přístupu k webové aplikaci , aby aplikace mohla přistupovat k jiným prostředkům. Tento scénář je tok udělení přihlašovacích údajů klienta OAuth 2.0.

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

Zadejte název aplikace (například webApiA), poznamenejte si ID aplikace jako vaše WEB_API_A_AZURE_CLIENT_IDa pak vyberte Uložit.

V aplikaci vyberte Klíče, vyberte Vygenerovat klíč, který chcete vygenerovatWEB_API_A_AZURE_CLIENT_SECRET, a pak vyberte Uložit.

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

V navigačním podokně vyberte Manifest a vložte do pole následující segment appRoles JSON. Poznamenejte si identifikátor URI ID aplikace jako váš , poznamenejte WEB_API_A_APP_ID_URLsi hodnotu role aplikace jako vaši 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í k dokončení procesu.

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

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

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

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

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:

Napište kód Webapp Java.

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řístupu k webové aplikaci . Následujícím způsobem přidejte další bean webClient :

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

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

Sestavte a otestujte aplikaci. Nechte a WebApiA spusťte Webapp na portu 8080 a 8081. Spusťte aplikace Webapp a WebApiA aplikace. 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/webApiAWebApiA odpovědi na prostředek.

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 Využití 2: Webová aplikace přistupující k serverům prostředků.

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:

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:

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

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

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

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

Sestavte a otestujte aplikaci. Nechte WebApiA běžet na portu 8081. Získejte přístupový token pro webApiA prostředek a pak získejte přístup 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řístupu 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.

Odkazem na předchozí kroky vytvoříme WebApiB aplikaci a zveřejníme oprávnění WebApiB.SampleScopeaplikace .

{
   "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 WebApiB oprávnění

Na základě přístupu k serveru 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 scénáře přístupu k serveru prostředků 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.

WebApiA Kód kontroleru 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.");
   }
}

WebApiB Kód kontroleru 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ý jako při přístupu ke scénáři serveru prostředků, přidá se další bean webClient 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 a WebApiB spusťte WebApiA na portu 8081 a 8082. Spusťte aplikace WebApiA , WebApiB získejte přístupový token pro webApiA prostředek a získejte přístup http://localhost:8081/webApiA/webApiB/sample jako autorizační hlavičku Bearer.

Ukázky

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

Spring Cloud podpora Azure for Spring Security

Spring Security s Microsoft Entra ID

Přístup k webové aplikaci

Systémový diagram

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

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

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

Pokročilé využití

Přidání dalších konfigurací zabezpečení

Autorizace přístupu podle rolí aplikací

Autorizace přístupu podle názvu skupiny nebo ID skupiny

Použití Národního Azure místo globálního Azure

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

Připojení na MICROSOFT Entra ID prostřednictvím proxy serveru

Ukázky

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

Systémový diagram

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

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

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

Použití OAuth2AuthorizedClient ve vaší aplikaci

Pokročilé využití

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

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

Ukázky

Přístup k serveru prostředků

Systémový diagram

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

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

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

Pokročilé využití

Přidání dalších konfigurací zabezpečení

Ověření oprávnění podle oborů

Ověření oprávnění podle rolí aplikací

Použití ověřování klienta JWT

Připojení na MICROSOFT Entra ID prostřednictvím proxy serveru

Ukázky

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

Systémový diagram

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

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

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

Použití OAuth2AuthorizedClient ve vaší aplikaci

Ukázky

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

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

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

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

Definování atributu SecurityFilterChain

Konfigurace

Typ aplikace

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

Nastavení závislostí

Konfigurace

Základní použití

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

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

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

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

Ukázky

Váš názor

Váš názor

Další materiály