Supporto di Spring Cloud Azure per Spring Security

Articolo
12/14/2024

Questo articolo si applica a:✅ versione 4.19.0 ✅ versione 5.19.0

Questo articolo descrive in che modo Spring Cloud Azure e Spring Security possono essere usati insieme.

Spring Security con Microsoft Entra ID

Quando si crea un'applicazione Web, la gestione delle identità e degli accessi sarà sempre un elemento fondamentale.

Azure offre un'ottima piattaforma per democratizzare il percorso di sviluppo delle applicazioni, poiché offre non solo un servizio di gestione delle identità di base cloud, ma anche una profonda integrazione con il resto dell'ecosistema di Azure.

Spring Security ha reso più semplice proteggere le applicazioni basate su Spring con potenti astrazioni ed interfacce estendibili. Tuttavia, il framework Spring può essere potente, non è personalizzato per un provider di identità specifico.

Il spring-cloud-azure-starter-active-directory offre il modo più ottimale per connettere l'applicazione Web a un tenant Microsoft Entra ID (Microsoft Entra ID for short) e proteggere il server di risorse con Microsoft Entra ID. Usa il protocollo Oauth 2.0 per proteggere applicazioni Web e server di risorse.

Accesso a un'applicazione Web

Questo scenario usa Il flusso di concessione del codice di autorizzazione OAuth 2.0 per accedere a un utente con un account Microsoft.

Diagramma di sistema

Diagramma di sistema per un'applicazione Web autonoma.

Creare le risorse necessarie in Azure

Leggere Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform.
Creare una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.
Impostare redirect URI su APPLICATION_BASE_URI/login/oauth2/code/, ad esempio http://localhost:8080/login/oauth2/code/. È necessario il / di tailing.

Aggiungere le dipendenze necessarie

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

Aggiungere le proprietà obbligatorie

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

Nota

I valori consentiti per tenant-id sono: common, organizations, consumerso l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.

A questo punto, avviare l'applicazione e accedere all'applicazione tramite il browser. Si verrà reindirizzati alla pagina di accesso Microsoft.

Utilizzi avanzati

Aggiungere configurazioni di sicurezza aggiuntive

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

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

Autorizzare l'accesso in base ai ruoli dell'app

Creare le risorse necessarie in Azure:

Leggere Aggiungere ruoli dell'app all'applicazione e riceverli nel token.
Creare un ruolo app con i parametri seguenti:
- Nome visualizzato: Amministratore
- Tipi di membri consentiti: Utenti/Gruppi
- Valore: Admin
- Abilitare questo ruolo dell'app: sì

Nota

Se si vuole usare il controllo degli accessi in base al ruolo dell'app, non è possibile inserire i nomi dei gruppi nell'attestazione role. Per altre informazioni, vedere la sezione configurazione dei gruppi di attestazioni facoltative di Fornire attestazioni facoltative all'app.

Proteggere il metodo specifico.

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

Autorizzare l'accesso in base al nome del gruppo o all'ID gruppo

Aggiungere proprietà di configurazione correlate.

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

Proteggere il metodo specifico.

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

Usare Azure nazionale invece di Azure globale

Ora, ad eccezione del cloud di Azure globale, Microsoft Entra ID viene distribuito nei cloud nazionali seguenti:

Azure per enti pubblici
Azure China 21Vianet
Azure Germania

Ecco un esempio che usa Azure China 21Vianet.

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

Per altre informazioni, vedere Distribuzioni cloud nazionali.

Configurare il modello URI di reindirizzamento

Gli sviluppatori possono personalizzare l'URI di reindirizzamento.

diagramma di sistema per gli URI di reindirizzamento.

Aggiungere redirect-uri-template proprietà nel file application.yml.

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

Aggiornare redirect-uri nel portale di Azure.

Dopo aver impostato redirect-uri-template, è necessario aggiornare il generatore di sicurezza:

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

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

Connessione all'ID Microsoft Entra tramite proxy

Per connettere Microsoft Entra ID tramite proxy, specificare un RestTemplateCustomizer bean come quello illustrato nell'esempio seguente:

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

Campioni

Progetto di esempio: aad-web-application.

Applicazione Web che accede ai server delle risorse

Diagramma di sistema

diagramma di sistema per un'applicazione Web che accede ai server delle risorse.

Creare risorse necessarie in Azure

Leggere Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform.
Creare una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.
Impostare redirect URI su APPLICATION_BASE_URI/login/oauth2/code/, ad esempio http://localhost:8080/login/oauth2/code/. È necessario il / di tailing.

Aggiungere le dipendenze necessarie

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

Aggiungere le proprietà obbligatorie

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

Nota

In questo caso, graph è il nome di OAuth2AuthorizedClient, scopes indica gli ambiti necessari per il consenso durante l'accesso.

Usare OAuth2AuthorizedClient nell'applicazione

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

A questo punto, avviare l'applicazione e accedere all'applicazione nel browser. Si verrà quindi reindirizzati alla pagina di accesso Microsoft.

Utilizzi avanzati

Flusso di credenziali client

Il flusso predefinito è flusso del codice di autorizzazione, se si vuole usare flusso di credenziali client, è possibile configurare come segue:

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

Nota

Accedere a più server di risorse

In un'applicazione Web è possibile accedere a più server di risorse configurando come segue:

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

Nota

È quindi possibile usare OAuth2AuthorizedClient nell'applicazione come segue

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

Campioni

Progetto di esempio: aad-web-application.

Accesso a un server di risorse

Questo scenario non supporta l'accesso, ma solo proteggere il server convalidando il token di accesso. Se il token di accesso è valido, il server gestisce la richiesta.

Diagramma di sistema

diagramma di sistema per l'utilizzo del server di risorse autonomo.

Creare le risorse necessarie in Azure

Leggere Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform.
Creare una registrazione dell'app. Ottenere AZURE_CLIENT_ID.
Leggere Avvio rapido: Configurare un'applicazione per esporre un'API Web.
Esporre un'API Web con un ambito denominato Scope-1.

Aggiungere le dipendenze necessarie

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

Aggiungere le proprietà obbligatorie

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

Avviare l'applicazione e accedere all'API Web dell'applicazione.

Si otterrà 401 senza un token di accesso.
Accedere all'applicazione con un token di accesso. Le attestazioni seguenti nel token di accesso verranno convalidate:
- iss: il token di accesso deve essere rilasciato da Microsoft Entra ID.
- nbf: l'ora corrente non può essere prima di nbf.
- exp: l'ora corrente non può essere eseguita dopo exp.
- aud: se spring.cloud.azure.active-directory.credential.client-id o spring.cloud.azure.active-directory.credential.app-id-uri configurati, il gruppo di destinatari deve essere uguale al client-id configurato o app-id-uri. Se le due proprietà non sono configurate, questa attestazione non verrà convalidata.

Per altre informazioni sul token di accesso, vedere documentazione ms sui token di accesso di Microsoft Identity Platform.

Utilizzi avanzati

Aggiungere configurazioni di sicurezza aggiuntive

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

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

Convalidare l'autorizzazione in base agli ambiti

Creare le risorse necessarie in Azure.
- Leggere Avvio rapido: Configurare un'applicazione per esporre un'API Web.
- Esporre un'API Web con un ambito denominato Scope1.

Proteggere il metodo specifico.

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

In questo modo, quando si accede /scope1 endpoint, verranno convalidate le attestazioni seguenti nel token di accesso:

scp: il valore deve contenere Scope1.

Convalidare l'autorizzazione in base ai ruoli dell'app

Creare le risorse necessarie in Azure.
- Leggere Aggiungere ruoli dell'app all'applicazione e riceverli nel token.
- Creare un ruolo app con i parametri seguenti:
  - Nome visualizzato: AppRole1
  - Tipi di membri consentiti: Utenti/Gruppi
  - Valore: AppRole1
  - Abilitare questo ruolo dell'app: sì

Proteggere il metodo specifico.

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

In questo modo, quando si accede /app-role1 endpoint, verranno convalidate le attestazioni seguenti nel token di accesso:

roles: il valore deve contenere AppRole1.

Usare l'autenticazione client JWT

Per usare un token JSON Web (JWT) per l'autenticazione client, seguire questa procedura:

Vedere la sezione Registrare il certificato con Microsoft Identity Platform di credenziali del certificato di autenticazione delle applicazioni di Microsoft Identity Platform.
Caricare un certificato pem nell'applicazione registrata nel portale di Azure.
Configurare il percorso del certificato e la password di un . PFX o . P12 certificato.
Aggiungere la proprietà spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt configurazione al client da autenticare tramite l'autenticazione client JWT.

Il file di configurazione di esempio seguente è relativo a uno scenario di applicazione Web. Le informazioni sul certificato sono configurate nelle proprietà globali.

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

Nota

È anche possibile configurare le informazioni sul certificato nelle proprietà del servizio active-directory, come illustrato in questo esempio:

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

Nota

Connessione all'ID Microsoft Entra tramite proxy

Per connettere Microsoft Entra ID tramite proxy, specificare un RestTemplateCustomizer bean. Per altre informazioni, vedere la sezione Connecting to Microsoft Entra ID via proxy.

Campioni

Progetto di esempio: aad-resource-server.

Server di risorse che visita altri server di risorse

Diagramma di sistema

diagramma di sistema per un server di risorse che visita altri server di risorse.

Creare le risorse necessarie in Azure

Leggere Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform.
Creare una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.

Aggiungere le dipendenze necessarie

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

Aggiungere le proprietà obbligatorie

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

Nota

Usare OAuth2AuthorizedClient nell'applicazione

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

Campioni

Progetto di esempio: aad-resource-server-obo.

Applicazione Web e server risorse in un'unica applicazione

Creare le risorse necessarie in Azure

Leggere Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform.
Creare una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.

Aggiungere le dipendenze necessarie

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

Aggiungere le proprietà obbligatorie

Impostare la proprietà spring.cloud.azure.active-directory.application-type su web_application_and_resource_servere specificare il tipo di autorizzazione per ogni client di autorizzazione.

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

Nota

Definire SecurityFilterChain

Configurare più istanze di SecurityFilterChain. AadWebApplicationAndResourceServerConfig contiene due configurazioni della catena di filtri di sicurezza per il server delle risorse e l'applicazione Web.

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

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

Configurazione

Proprietà configurabili di spring-cloud-azure-starter-active-directory:

Nome	Descrizione
spring.cloud.azure.active-directory.app-id-uri	URI ID app che può essere usato nell'attestazione "aud" di un id_token.
spring.cloud.azure.active-directory.application-type	Tipo di applicazione Microsoft Entra.
spring.cloud.azure.active-directory.authenticate-additional-parameters	Aggiungere altri parametri all'URL di autorizzazione.
spring.cloud.azure.active-directory.authorization-clients	Client di autorizzazione OAuth2.
spring.cloud.azure.active-directory.credential.client-id	ID client da usare quando si esegue l'autenticazione dell'entità servizio con Azure.
spring.cloud.azure.active-directory.credential.client-secret	Segreto client da usare quando si esegue l'autenticazione dell'entità servizio con Azure.
spring.cloud.azure.active-directory.jwk-set-cache-durata	La durata del set JWK memorizzato nella cache prima della scadenza, il valore predefinito è 5 minuti.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time	L'ora di aggiornamento del JWK memorizzato nella cache impostata prima della scadenza, il valore predefinito è 5 minuti.
spring.cloud.azure.active-directory.jwt-connect-timeout	Timeout della connessione per la chiamata a URL remoto JWKSet.
spring.cloud.azure.active-directory.jwt-read-timeout	Valore Timeout di lettura per la chiamata a URL remoto JWKSet.
spring.cloud.azure.active-directory.jwt-size-limit	Limite di dimensioni in byte della chiamata URL remota JWKSet.
spring.cloud.azure.active-directory.post-logout-redirect-uri	URI di reindirizzamento dopo la disconnessione.
spring.cloud.azure.active-directory.profile.cloud-type	Nome del cloud di Azure a cui connettersi. I tipi supportati sono: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
spring.cloud.azure.active-directory.profile.environment	Proprietà per gli endpoint di Microsoft Entra.
spring.cloud.azure.active-directory.profile.tenant-id	ID tenant di Azure. I valori consentiti per `tenant-id` sono: `common`, `organizations`, `consumers`o l'ID tenant.
spring.cloud.azure.active-directory.redirect-uri-template	Endpoint di reindirizzamento: usato dal server di autorizzazione per restituire risposte contenenti credenziali di autorizzazione al client tramite l'agente utente del proprietario della risorsa. Il valore predefinito è `{baseUrl}/login/oauth2/code/`.
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map	Configurare l'attestazione che verrà usata per compilare GrantedAuthority e il prefisso del valore stringa di GrantedAuthority. Il valore predefinito è"scp" -> "SCOPE_", "roles" -> "APPROLE_".
spring.cloud.azure.active-directory.resource-server.principal-claim-name	Configurare l'attestazione nel token di accesso da restituire in AuthenticatedPrincipal#getName. Il valore predefinito è "sub".
spring.cloud.azure.active-directory.session-stateless	Se true attiva il filtro di autenticazione senza stato AadAppRoleStatelessAuthenticationFilter. Il valore predefinito è false che attiva AadAuthenticationFilter.
spring.cloud.azure.active-directory.user-group.allowed-group-ids	Gli ID gruppo possono essere usati per costruire GrantedAuthority.
spring.cloud.azure.active-directory.user-group.allowed-group-names	I nomi dei gruppi possono essere usati per costruire GrantedAuthority.
spring.cloud.azure.active-directory.user-group.use-transitive-members	Se "true", usare "v1.0/me/transitiveMemberOf" per ottenere i membri. In caso contrario, usare "v1.0/me/memberOf". Il valore predefinito è `false`.
spring.cloud.azure.active-directory.user-name-attribute	Decidere quale attestazione deve essere il nome dell'entità.

Ecco alcuni esempi su come usare queste proprietà:

Tipo di applicazione

Il tipo di applicazione può essere dedotto dalle dipendenze: spring-security-oauth2-client o spring-security-oauth2-resource-server. Se il valore dedotto non è il valore desiderato, è possibile specificare il tipo di applicazione. Ecco la tabella dei valori validi e dei valori dedotti:

Tipo di applicazione di spring-cloud-azure-starter-active-directory:

Dipendenza: `spring-security-oauth2-client`	Dipendenza: `spring-security-oauth2-resource-server`	Valori validi del tipo di applicazione	Valore dedotto
Sì	No	`web_application`	`web_application`
No	Sì	`resource_server`	`resource_server`
Sì	Sì	`web_application`, `resource_server`, `resource_server_with_obo`, `web_application_and_resource_server`	`resource_server_with_obo`

Spring Security con Azure Active Directory B2C

Azure Active Directory (Azure AD) B2C è un servizio di gestione delle identità che consente di personalizzare e controllare il modo in cui i clienti eseguono l'iscrizione, l'accesso e la gestione dei profili quando usano le applicazioni. Azure AD B2C abilita queste azioni proteggendo contemporaneamente le identità dei clienti.

Configurazione delle dipendenze

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

Configurazione

Proprietà configurabili di spring-cloud-azure-starter-active-directory-b2c:

Nome	Descrizione
spring.cloud.azure.active-directory.b2c.app-id-uri	URI ID app che potrebbe essere usato nell'attestazione "aud" di un token.
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters	Parametri aggiuntivi per l'autenticazione.
spring.cloud.azure.active-directory.b2c.authorization-clients	Specificare la configurazione client.
spring.cloud.azure.active-directory.b2c.base-uri	URI di base dell'endpoint di Azure AD B2C.
spring.cloud.azure.active-directory.b2c.credential	Informazioni sulle credenziali di Azure AD B2C.
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout	Timeout della connessione per la chiamata a URL remoto JWKSet.
spring.cloud.azure.active-directory.b2c.jwt-read-timeout	Valore Timeout di lettura per la chiamata a URL remoto JWKSet.
spring.cloud.azure.active-directory.b2c.jwt-size-limit	Limite di dimensioni in byte della chiamata URL remota JWKSet.
spring.cloud.azure.active-directory.b2c.login-flow	Specificare la chiave del flusso di accesso primario. Il valore predefinito è `sign-up-or-sign-in`.
spring.cloud.azure.active-directory.b2c.logout-success-url	URL di reindirizzamento dopo la disconnessione. Il valore predefinito è `http://localhost:8080/login`.
spring.cloud.azure.active-directory.b2c.profile	Informazioni sul profilo di Azure AD B2C.
spring.cloud.azure.active-directory.b2c.reply-url	URL di risposta dopo aver ottenuto il codice di autorizzazione. Il valore predefinito è `{baseUrl}/login/oauth2/code/`.
spring.cloud.azure.active-directory.b2cflussi utente	Flussi utente.
spring.cloud.azure.active-directory.b2c.user-name-attribute-name	Nome attributo nome utente.

Per le configurazioni complete, controllare proprietà di configurazione di Spring Cloud di Azure.

Utilizzo di base

Un'applicazione Web è qualsiasi applicazione basata sul Web che consente all'utente di accedere con l'ID Microsoft Entra, mentre un server di risorse accetterà o negherà l'accesso dopo la convalida access_token ottenuta dall'ID Microsoft Entra. In questa guida verranno illustrati 4 scenari:

Accesso a un'applicazione Web.
Applicazione Web che accede ai server delle risorse.
Accesso a un server di risorse.
Server di risorse che accede ad altri server di risorse.

Utilizzo 1: accesso a un'applicazione Web

Questo scenario usa Il flusso di concessione del codice di autorizzazione OAuth 2.0 per accedere a un utente con l'utente di Azure AD B2C.

Selezionare di Azure AD B2C dal menu del portale, selezionare Applicazionie quindi selezionare Aggiungi.

Specificare nome dell'applicazione (ad esempio ), aggiungere per l'URL di risposta , registrare il ID applicazione come e quindi selezionare Salva.

Selezionare Chiavi dall'applicazione, selezionare Genera chiave per generare WEB_APP_AZURE_CLIENT_SECRETe quindi selezionare Salva.

Selezionare Flussi utente a sinistra e quindi selezionare Nuovo flusso utente.

Scegliere Iscriversi o in, Profilo di modificae reimposta zione della password rispettivamente per creare flussi utente. Specificare il flusso utente Nome e Attributi utente e attestazioni, quindi selezionare Crea.

Selezionare autorizzazioni API >Aggiungere un'autorizzazione>API Microsoft, selezionare Microsoft Graph, selezionare Autorizzazioni delegate, selezionare le autorizzazioni offline_access e openid e quindi selezionare Aggiungi autorizzazione per completare il processo.

Concedere il consenso amministratore per le autorizzazioni di graph .

Aggiungere le dipendenze seguenti al file pom.xml.

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

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

Aggiungere proprietà al file application.yml usando i valori creati in precedenza, come illustrato nell'esempio seguente:

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}

Scrivere il codice Java.

Per il codice del controller, è possibile fare riferimento all'esempio seguente:

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

Per il codice di configurazione della sicurezza, è possibile fare riferimento all'esempio seguente:

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

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

Copiare il home.html da esempio aad-b2c-web-applicatione sostituire il PROFILE_EDIT_USER_FLOW e PASSWORD_RESET_USER_FLOW con i nomi dei flussi utente usati in precedenza.

Compilare e testare l'app. Consentire l'esecuzione di Webapp sulla porta 8080.

Dopo che l'applicazione è stata compilata e avviata da Maven, aprire http://localhost:8080/ in un Web browser. Si dovrebbe essere reindirizzati alla pagina di accesso.

Selezionare il collegamento con il flusso utente di accesso. È necessario essere reindirizzati ad Azure AD B2C per avviare il processo di autenticazione.

Dopo aver eseguito l'accesso, verrà visualizzato il home page di esempio dal browser.

Utilizzo 2: applicazione Web che accede ai server risorse

Questo scenario si basa sullo scenario Accesso a un'applicazione Web per consentire a un'applicazione di accedere ad altre risorse. Questo scenario è flusso di concessione delle credenziali client OAuth 2.0.

Selezionare di Azure AD B2C dal menu del portale, selezionare Applicazionie quindi selezionare Aggiungi.

Specificare nome dell'applicazione (ad esempio ), registrare l'ID applicazione come e quindi selezionare Salva.

Selezionare Chiavi dall'applicazione, selezionare Genera chiave per generare WEB_API_A_AZURE_CLIENT_SECRETe quindi selezionare Salva.

Selezionare Esporre un API nel riquadro di spostamento e quindi selezionare Imposta. Registrare il URI ID applicazione come e quindi selezionare Salva.

Selezionare manifesto nel riquadro di spostamento e quindi incollare il segmento JSON seguente in appRoles matrice. Registrare l'URI id applicazione come WEB_API_A_APP_ID_URL, registrare il valore del ruolo dell'app come WEB_API_A_ROLE_VALUEe quindi selezionare Salva.

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

Selezionare autorizzazioni API >Aggiungere un'autorizzazione>API personali, selezionare Nome applicazione WebApiA, selezionare Autorizzazioni applicazione, selezionare Autorizzazione WebApiA.SampleScope e quindi selezionare Aggiungi autorizzazione per completare il processo.

Concedere il consenso amministratore per le autorizzazioni di WebApiA.

Aggiungere la dipendenza seguente in base allo scenario Accesso a un'applicazione Web.

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

Aggiungere la configurazione seguente in base allo scenario Accesso a un'applicazione Web.

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

Nota

Scrivere il codice Java Webapp.

Per il codice del controller, è possibile fare riferimento all'esempio seguente:

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

Il codice di configurazione della sicurezza è identico a quello dello scenario Accesso a un'applicazione Web. Aggiungere un altro webClient bean come segue:

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

Per scrivere il codice Java WebApiA, vedere la sezione Accesso a un server di risorse.

Compilare e testare l'app. Consentire l'esecuzione di Webapp e WebApiA sulla porta 8080 e 8081 rispettivamente. Avviare le applicazioni Webapp e WebApiA. Tornare alla home page dopo l'accesso. È quindi possibile accedere a http://localhost:8080/webapp/webApiA per ottenere la risposta alla risorsa WebApiA.

Utilizzo 3: Accesso a un server di risorse

Questo scenario non supporta l'accesso. È sufficiente proteggere il server convalidando il token di accesso e, se valido, viene usata la richiesta.

Per compilare l'autorizzazione WebApiA, vedere Utilizzo 2: Applicazione Web che accede ai server delle risorse.

Aggiungere WebApiA autorizzazione e concedere il consenso amministratore per l'applicazione Web.

Aggiungere le dipendenze seguenti al file pom.xml.

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

Aggiungere la configurazione seguente.

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}

Nota

Scrivere il codice Java.

Per il codice del controller, è possibile fare riferimento all'esempio seguente:

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

Per il codice di configurazione della sicurezza, è possibile fare riferimento all'esempio seguente:

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

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

Compilare e testare l'app. Consentire WebApiA l'esecuzione sulla porta 8081. Ottenere il token di accesso per la risorsa webApiA e quindi accedere http://localhost:8081/webApiA/sample come intestazione di autorizzazione di connessione.

Utilizzo 4: Server risorse che accede ad altri server di risorse

Questo scenario è un aggiornamento di Accesso a un server di risorsee supporta l'accesso ad altre risorse dell'applicazione, in base al flusso di credenziali client OAuth2.

Facendo riferimento ai passaggi precedenti, si crea un'applicazione WebApiB ed espongono un'autorizzazione dell'applicazione 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"
}

Concedere il consenso amministratore per le autorizzazioni di WebApiB.

In base a Accesso a un server di risorse, aggiungere la dipendenza seguente al file pom.xml.

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

Aggiungere la configurazione seguente in base alla configurazione dello scenario Accesso a un server di risorse.

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

Scrivere il codice Java.

Per il codice del controller WebApiA, è possibile fare riferimento all'esempio seguente:

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

Per il codice del controller WebApiB, è possibile fare riferimento all'esempio seguente:

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

Il codice di configurazione della sicurezza è lo stesso con Accesso a un server di risorse scenario, viene aggiunto un altro webClient bean come indicato di seguito

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

Compilare e testare l'app. Consentire l'esecuzione di WebApiA e WebApiB rispettivamente sulla porta 8081 e 8082. Avviare le applicazioni WebApiA e WebApiB, ottenere il token di accesso per webApiA risorsa e accedere http://localhost:8081/webApiA/webApiB/sample come intestazione di autorizzazione di connessione.

Campioni

Per altre informazioni, vedere gli esempi spring-cloud-azure-starter-active-directory-b2c.

Condividi tramite

Supporto di Spring Cloud Azure per Spring Security

Spring Security con Microsoft Entra ID

Accesso a un'applicazione Web

Diagramma di sistema

Creare le risorse necessarie in Azure

Aggiungere le dipendenze necessarie

Aggiungere le proprietà obbligatorie

Utilizzi avanzati

Aggiungere configurazioni di sicurezza aggiuntive

Autorizzare l'accesso in base ai ruoli dell'app

Autorizzare l'accesso in base al nome del gruppo o all'ID gruppo

Usare Azure nazionale invece di Azure globale

Configurare il modello URI di reindirizzamento

Connessione all'ID Microsoft Entra tramite proxy

Campioni

Applicazione Web che accede ai server delle risorse

Diagramma di sistema

Creare risorse necessarie in Azure

Aggiungere le dipendenze necessarie

Aggiungere le proprietà obbligatorie

Usare OAuth2AuthorizedClient nell'applicazione

Utilizzi avanzati

Flusso di credenziali client

Accedere a più server di risorse

Campioni

Accesso a un server di risorse

Diagramma di sistema

Creare le risorse necessarie in Azure

Aggiungere le dipendenze necessarie

Aggiungere le proprietà obbligatorie

Utilizzi avanzati

Aggiungere configurazioni di sicurezza aggiuntive

Convalidare l'autorizzazione in base agli ambiti

Convalidare l'autorizzazione in base ai ruoli dell'app

Usare l'autenticazione client JWT

Connessione all'ID Microsoft Entra tramite proxy

Campioni

Server di risorse che visita altri server di risorse

Diagramma di sistema

Creare le risorse necessarie in Azure

Aggiungere le dipendenze necessarie

Aggiungere le proprietà obbligatorie

Usare OAuth2AuthorizedClient nell'applicazione

Campioni

Applicazione Web e server risorse in un'unica applicazione

Creare le risorse necessarie in Azure

Aggiungere le dipendenze necessarie

Aggiungere le proprietà obbligatorie

Definire SecurityFilterChain

Configurazione

Tipo di applicazione

Spring Security con Azure Active Directory B2C

Configurazione delle dipendenze

Configurazione

Utilizzo di base

Utilizzo 1: accesso a un'applicazione Web

Utilizzo 2: applicazione Web che accede ai server risorse

Utilizzo 3: Accesso a un server di risorse

Utilizzo 4: Server risorse che accede ad altri server di risorse

Campioni

Commenti e suggerimenti

Risorse aggiuntive