Spring Cloud supporto tecnico di Azure for Spring Security

Questo articolo si applica a: ✔️ Versione 4.14.0 ✔️ versione 5.8.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.

Fornisce spring-cloud-azure-starter-active-directory 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

Creare le risorse necessarie in Azure

1. Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

2. Crea una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.

3. Impostare redirect URI su APPLICATION_BASE_URI/login/oauth2/code/ , ad esempio http://localhost:8080/login/oauth2/code/. La coda / è obbligatoria.

Aggiungere le dipendenze obbligatorie

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

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

Autorizzare l'accesso in base ai ruoli dell'app

Creare le risorse necessarie in Azure:

• Leggere Aggiungere i ruoli dell'app all'applicazione e riceverli nel token.

• Creare un ruolo app con i parametri seguenti:

  • Nome visualizzato: Amministrazione
  • Tipi di membri consentiti: Utenti/Gruppi
  • Valore: Amministrazione
  • 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 di attestazioni facoltative dei gruppi in 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 Government

• Azure Cina 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.

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

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

Eseguire l'aggiornamento redirect-uri nel portale di Azure.

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

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

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

Connessione a Microsoft Entra ID tramite proxy

Per connettere Microsoft Entra ID tramite proxy, specificare un RestTemplateCustomizer bean simile a 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);
        };
    }
}

Esempi

Progetto di esempio: aad-web-application.

Applicazione Web che accede ai server delle risorse

Diagramma di sistema

Creare risorse necessarie in Azure

1. Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

2. Crea una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.

3. Impostare redirect URI su APPLICATION_BASE_URI/login/oauth2/code/, ad esempio http://localhost:8080/login/oauth2/code/. La coda / è obbligatoria.

Aggiungere le dipendenze obbligatorie

<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

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.

In questo caso, graph è il nome di OAuth2AuthorizedClient, scopes indica gli ambiti necessari per fornire 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 è il flusso del codice di autorizzazione, se si vuole usare il flusso delle 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

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.

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

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.

È quindi possibile usare OAuth2AuthorizedClient in un'applicazione come questa

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

Esempi

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

Creare le risorse necessarie in Azure

1. Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

2. Crea una registrazione dell'app. Ottenere AZURE_CLIENT_ID.

3. Leggere Avvio rapido: Configurare un'applicazione per esporre un'API Web.

4. Esporre un'API Web con un ambito denominato Scope-1.

Aggiungere le dipendenze obbligatorie

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

1. Si otterrà 401 senza un token di accesso.

2. 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 precedente a nbf.

   • exp: l'ora corrente non può dopo exp.

   • aud: se spring.cloud.azure.active-directory.credential.client-id o spring.cloud.azure.active-directory.credential.app-id-uri configurato, il gruppo di destinatari deve essere uguale all'oggetto configurato client-id o app-id-uri. Se le due proprietà non sono configurate, questa attestazione non verrà convalidata.

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

Utilizzi avanzati

Aggiungere configurazioni di sicurezza aggiuntive

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

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

Convalidare l'autorizzazione in base agli ambiti

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

2. 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 all'endpoint /scope1 , verranno convalidate le attestazioni seguenti nel token di accesso:

• scp: il valore deve contenere Scope1.

Convalidare l'autorizzazione in base ai ruoli dell'app

1. Creare le risorse necessarie in Azure.

   • Leggere Aggiungere i 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ì

2. 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 all'endpoint /app-role1 , 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:

1. Vedere la sezione Registrare il certificato con Microsoft Identity Platform delle credenziali del certificato di autenticazione delle applicazioni di Microsoft Identity Platform.
2. Caricare un certificato con estensione pem nell'applicazione registrata nel portale di Azure.
3. Configurare il percorso del certificato e la password di un oggetto . PFX o . Certificato P12 .
4. Aggiungere la configurazione della proprietà spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt 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

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.

È anche possibile configurare le informazioni sul certificato nelle proprietà del active-directory servizio, 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

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.

Connessione a Microsoft Entra ID tramite proxy

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

Esempi

Progetto di esempio: aad-resource-server.

Server di risorse che visita altri server di risorse

Diagramma di sistema

Creare le risorse necessarie in Azure

1. Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

2. Crea una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.

Aggiungere le dipendenze obbligatorie

<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

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.

Usare OAuth2AuthorizedClient nell'applicazione

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

Esempi

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

Applicazione Web e server risorse in un'unica applicazione

Creare le risorse necessarie in Azure

1. Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

2. Crea una registrazione dell'app. Ottenere AZURE_TENANT_ID, AZURE_CLIENT_IDe AZURE_CLIENT_SECRET.

Aggiungere le dipendenze obbligatorie

<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

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.

Definire SecurityFilterChain

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

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

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

Impostazione

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	Connessione out di timeout per la chiamata all'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, consumerso 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:

Ha una dipendenza: spring-security-oauth2-client	Ha una 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 si iscrivono, accedono e gestiscono i rispettivi profili quando usano le applicazioni, Azure AD B2C consente queste azioni proteggendo al tempo stesso 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>

Impostazione

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	Connessione out di timeout per la chiamata all'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.b2c.user-flows	Flussi utente.
spring.cloud.azure.active-directory.b2c.user-name-attribute-name	Nome attributo nome utente.

Per le configurazioni complete, controllare le proprietà di configurazione di Spring Cloud 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 aver convalidato access_token ottenuto da Microsoft Entra ID. In questa guida verranno illustrati 4 scenari:

1. Accesso a un'applicazione Web.

2. Applicazione Web che accede ai server delle risorse.

3. Accesso a un server di risorse.

4. 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 Azure AD B2C dal menu del portale, selezionare Applicazioni e quindi selezionare Aggiungi.

Specificare il nome dell'applicazione , ad esempio webapp, aggiungere http://localhost:8080/login/oauth2/code/ per l'URL di risposta, registrare l'ID applicazione come WEB_APP_AZURE_CLIENT_IDe 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 nuovo flusso utente.

Scegliere Iscrizione o accesso, Modifica profilo e Reimpostazione password rispettivamente per creare flussi utente. Specificare il nome del flusso utente e gli attributi utente e le attestazioni, quindi selezionare Crea.

Selezionare Autorizzazioni>API Aggiungi 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 Graph .

Aggiungere le dipendenze seguenti al file pom.xml .

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>

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>

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 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:off
   }
}

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

Copiare home.html dall'esempio aad-b2c-web-application e sostituire e PROFILE_EDIT_USER_FLOWPASSWORD_RESET_USER_FLOW con i nomi dei flussi utente usati in precedenza.

Compilare e testare l'app. Eseguire 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. Si dovrebbe essere reindirizzati in Azure AD B2C per avviare il processo di autenticazione.

Dopo aver eseguito l'accesso, verrà visualizzato l'esempio home page 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 è Il flusso di concessione delle credenziali client OAuth 2.0.

Selezionare Azure AD B2C dal menu del portale, selezionare Applicazioni e quindi selezionare Aggiungi.

Specificare il nome dell'applicazione ( ad esempio webApiA), registrare l'ID applicazione come WEB_API_A_AZURE_CLIENT_ID, 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 l'URI ID applicazione come WEB_API_A_APP_ID_URL, quindi selezionare Salva.

Selezionare Manifesto nel riquadro di spostamento e quindi incollare il segmento JSON seguente nella 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_VALUE, 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 Aggiungi un'autorizzazione>Api personali, selezionare Nome applicazione WebApiA , selezionare Autorizzazioni applicazione, selezionare WebApiA.SampleScope autorizzazione e quindi selezionare Aggiungi autorizzazione per completare il processo.

Concedere il consenso amministratore per le autorizzazioni 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

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.

Scrivere il Webapp codice Java.

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 è uguale a quello dello scenario Accesso a un'applicazione Web. Aggiungere un altro bean webClient 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 WebApiA codice Java, vedere la sezione Accesso a un server di risorse.

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

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

Aggiungere WebApiA l'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

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.

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

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

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

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

Questo scenario è un aggiornamento dell'accesso a un server di risorse e 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 WebApiB.SampleScopedell'applicazione .

{
   "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 WebApiB le autorizzazioni.

In base all'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 WebApiA codice del controller, è 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 WebApiB codice del controller, è 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 uno scenario del server di risorse, viene aggiunto un altro bean webClient 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 WebApiA e WebApiB eseguire rispettivamente sulla porta 8081 e 8082 . Avviare le WebApiA applicazioni e WebApiB , ottenere il token di accesso per webApiA la risorsa e accedere http://localhost:8081/webApiA/webApiB/sample come intestazione di autorizzazione bearer.

Esempi

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