Podpora Spring Cloud Azure pro Spring Security

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

Spring Security se službou 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í. Nicméně, jakkoli může být framework Spring výkonný, není přizpůsoben konkrétnímu poskytovateli identity.

spring-cloud-azure-starter-active-directory představuje nejvhodnější způsob, jak propojit vaši webovou aplikaci s tenantem Microsoft Entra ID (zkráceně Microsoft Entra ID) a chránit váš server prostředků pomocí Microsoft Entra ID. Používá protokol OAuth 2.0 k ochraně webových aplikací a zdrojových serverů.

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

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/. Koncové / 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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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í

Spring Cloud Azure 6.x/7.x

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

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

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

Autorizace přístupu podle rolí aplikací

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

• Přečtěte si Přidání rolí aplikace do vaší aplikace a jejich obdržení v tokenu.

• Vytvořte roli aplikace s následujícími parametry:

  • Zobrazovaný název: Správce
  • Povolené typy členů: Uživatelé/skupiny
  • Hodnota: Správce
  • Chcete povolit tuto roli aplikace: Ano

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 (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ů.

Nakonfigurujte šablonu identifikátoru URI přesměrování

Vývojáři mohou přizpůsobit URI přesměrování.

Přidejte redirect-uri-template vlastnosti do souboru application.yml.

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 aktualizovat tvůrce zabezpečení:

Spring Cloud Azure 6.x/7.x

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

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.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();
    }
}

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

Systémový diagram

Vytvořte požadované prostředky 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/. Koncové / 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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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);
    }
}

Nyní spusťte aplikaci a otevřete ji 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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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řistupujte k více serverům prostředků

V rámci jedné webové aplikace můžete přistupovat k více serverům prostředků pomocí následující konfigurace:

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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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 graph1(
    @RegisteredOAuth2AuthorizedClient("resource-server-1") OAuth2AuthorizedClient client) {
        return callResourceServer1(client);
    }

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

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

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. Přečtěte si Rychlý start: Konfigurace aplikace pro zveřejnění webového rozhraní API.

4. Zpřístupněte webové API s rozsahem 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 vydán službou Microsoft Entra ID.

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

   • exp: Aktuální čas nemůže být později než 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 nakonfigurovány, tento atribut identity nebude ověřen.

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í

Spring Cloud Azure 6.x/7.x

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

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.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());
    }
}

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

1. Vytvořte požadované prostředky v Azure.

   • Přečtěte si Rychlý start: Konfigurace aplikace pro zpřístupnění webového rozhraní API.

   • Zpřístupněte webové rozhraní API s rozsahem s názvem Scope1.

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.

   • Přečtěte si Přidání rolí aplikace do aplikace a jejich získání 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

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žít ověřování klienta pomocí JWT

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

1. Viz část Registrace certifikátu na platformě Microsoft Identity Platform v článku Přihlašovací údaje certifikátu pro ověřování aplikací na platformě Microsoft Identity Platform.
2. Nahrajte do aplikace zaregistrované na webu Azure Portal certifikát .pem.
3. Nakonfigurujte cestu k certifikátu a heslo certifikátu ve formátu .PFX nebo .P12.
4. Přidejte ke klientovi konfiguraci vlastnosti spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt, aby bylo možné klienta ověřovat pomocí 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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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ů navštěvující jiné servery prostředků

Systémový diagram

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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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ězce bezpečnostních filtrů pro server zdrojů a webovou aplikaci.

Spring Cloud Azure 6.x/7.x

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

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

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.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
        }
    }
}

Konfigurace

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

Jméno	Popis
spring.cloud.azure.active-directory.app-id-uri	URI ID aplikace, které lze použít v atributu „aud“ tokenu 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-lifespan	Životnost sady JWK v mezipaměti před vypršením platnosti; výchozí hodnota je 5 minut.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time	Interval obnovení sady JWK uložené v mezipaměti před vypršením její platnosti; výchozí hodnota je 5 minut.
spring.cloud.azure.active-directory.jwt-connect-timeout	Vypršel časový limit připojení při volání vzdálené adresy URL JWKSet.
spring.cloud.azure.active-directory.jwt-read-timeout	Časový limit pro čtení při volání na vzdálenou adresu URL JWKSet
spring.cloud.azure.active-directory.jwt-size-limit	Limit velikosti v bajtech pro volání na vzdálenou adresu URL JWKSet.
spring.cloud.azure.active-directory.post-logout-redirect-uri	URI pro 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 služby 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ý claim se použije k vytvoření 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ý claim v přístupovém tokenu se má vracet v metodě AuthenticatedPrincipal#getName. Výchozí hodnota je sub.
spring.cloud.azure.active-directory.session-stateless	Pokud je hodnota true, aktivuje filtr bezstavového ověřování 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 na: spring-security-oauth2-client	Závisí na: 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_oboweb_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šel časový limit připojení při volání vzdálené adresy URL JWKSet.
spring.cloud.azure.active-directory.b2c.jwt-read-timeout	Časový limit pro čtení při volání na vzdálenou adresu URL JWKSet
spring.cloud.azure.active-directory.b2c.jwt-size-limit	Limit velikosti v bajtech pro volání na vzdálenou adresu 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 pro 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 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 přistupující k serverům prostředků

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

4. Server prostředků přistupující k jiným serverům prostředků.

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

Tento scénář používá tok udělení autorizačního kódu OAuth 2.0 pro přihlášení uživatele pomocí uživatelského účtu 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 pro Adresu URL pro odpověď, zaznamenejte si ID aplikace jako a potom 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 Registraci nebo přihlášení, úpravu profilu a obnovení hesla a vytvoříte tak jednotlivé toky uživatelů. Zadejte název toku uživatele a atributy uživatele a deklarace identity a potom vyberte Vytvořit.

Vyberte oprávnění rozhraní APIPřidat oprávněníRozhraní API Microsoftu, vyberte Microsoft Graph, vyberte Delegovaná oprávnění, vyberte oprávnění offline_access a openid a potom výběrem Přidat oprávnění proces dokončete.

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

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

Spring Cloud Azure 6.x.7.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-springsecurity6</artifactId>
   </dependency>
</dependencies>

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

Spring Cloud Azure 4.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>

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 6.x/7.x

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

    private final AadB2cOidcLoginConfigurer configurer;

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

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.authorizeHttpRequests(auth -> auth.anyRequest().authenticated())
            .with(configurer, Customizer.withDefaults());
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.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:on
   }
}

Zkopírujte soubor home.html z ukázky a nahraďte a názvy toků uživatele, které jste dříve použili.

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 v prohlížeči vidět ukázku home page.

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ář představuje tok udělení přihlašovacích údajů klienta OAuth 2.0.

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 Manifest a potom 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

Přidejte následující závislost na základě scénáře Přístup 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řístup 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

Hodnoty povolené pro tenant-id jsou: common, organizations, consumersnebo ID tenanta. Další informace o těchto hodnotách najdete v části Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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();
   }
}

Chcete-li psát kód v Javě WebApiA, viz oddíl Přístup k serveru prostředků.

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 přistoupit k http://localhost:8080/webapp/webApiA a získat odpověď prostředku WebApiA.

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

Tento scénář nepodporuje přihlášení. Stačí server chránit ověřením přístupového tokenu; pokud je platný, server požadavek vyřídí.

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 Byl použit nesprávný koncový bod (osobní účty a účty organizací) v článku Chyba AADSTS50020 – Uživatelský účet od poskytovatele identity v tenantovi 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:

Spring Cloud Azure 6.x/7.x

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.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());
   }
}

Sestavte a otestujte aplikaci. Nechte WebApiA běžet na portu 8081. Získejte přístupový token pro prostředek webApiA a poté přistupujte k http://localhost:8081/webApiA/sample s autorizační hlavičkou Bearer.

Příklad použití 4: Server prostředků přistupující k jiným serverům prostředků

Tento scénář je rozšířením scénáře Přístup k serveru prostředků a podporuje přístup k dalším prostředkům aplikace pomocí toku klientských přihlašovacích údajů 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

Na základě informací v Přístupu k serveru prostředků přidejte do svého 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řístup 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.

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ý jako ve scénáři Přístup k serveru prostředků, přičemž se navíc přidává další bean webClient takto:

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 aplikace WebApiA a WebApiB, získejte přístupový token pro prostředek webApiA a přistupte k http://localhost:8081/webApiA/webApiB/sample pomocí autorizační hlavičky Bearer.

Vzorky

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