Utvecklarguide för Spring Boot Starter för Microsoft Entra

Artikel
01/23/2025

Den här artikeln gäller för:✅ version 4.19.0 ✅ version 5.19.0

Den här artikeln beskriver funktionerna och huvudscenarierna i Spring Boot Starter för Microsoft Entra ID. Artikeln innehåller även vägledning om vanliga problem, lösningar och diagnostiksteg.

När du skapar ett webbprogram är identitets- och åtkomsthantering grundläggande delar. Azure erbjuder en molnbaserad identitetstjänst som har djup integrering med resten av Azure-ekosystemet.

Även om Spring Security gör det enkelt att skydda dina Spring-baserade program är det inte skräddarsytt för en specifik identitetsprovider. Med Spring Boot Starter för Microsoft Entra ID kan du ansluta din webbapp till en Microsoft Entra-klientorganisation och skydda resursservern med Microsoft Entra-ID. Det använder Oauth 2.0-protokollet för att skydda webbprogram och resursservrar.

Följande länkar ger åtkomst till startpaketet, dokumentationen och exemplen:

Förutsättningar

Om du vill följa anvisningarna i den här guiden måste du ha följande förutsättningar:

En Azure-prenumeration; Om du inte redan har en Azure-prenumeration kan du aktivera dina MSDN-prenumerantförmåner eller registrera dig för ett kostnadsfritt Azure-konto.
Ett Java Development Kit (JDK) som stöds, version 8 eller senare. Mer information finns i Java-support på Azure och Azure Stack.
Apache Maven, version 3.0 eller senare.
Ett program registrerat med Microsoft Entra-ID. Mer information finns i Snabbstart: Registrera ett program med Microsofts identitetsplattform.

Viktig

Spring Boot version 2.5 eller senare krävs för att slutföra stegen i den här artikeln.

Grundläggande scenarier

Den här guiden beskriver hur du använder Microsoft Entra Starter i följande scenarier:

Få åtkomst till ett webbprogram
Åtkomst till resursservrar från ett webbprogram
Skydda en resursserver/API
Komma åt andra resursservrar från en resursserver
webbprogram och resursserver i ett program

Ett webbprogram är ett webbaserat program som gör det möjligt för en användare att logga in. En resursserver accepterar eller nekar åtkomst när en åtkomsttoken har verifierats.

Få åtkomst till ett webbprogram

Det här scenariot använder OAuth 2.0-auktoriseringskodens beviljningsflöde för att möjliggöra för en användare att logga in med ett Microsoft-konto.

Använd följande steg för att använda Microsoft Entra Starter i det här scenariot:

Ange omdirigerings-URI:n till <application-base-uri>/login/oauth2/code/. Till exempel: http://localhost:8080/login/oauth2/code/. Se till att inkludera den avslutande koden /. Mer information om omdirigerings-URI finns i Lägg till en omdirigerings-URI i Snabbstart: Registrera ett program med Microsofts identitetsplattform.

Skärmbild av Azure-portalen som visar autentiseringssidan för webbappar med omdirigerings-URI markerat.

Lägg till följande beroenden i din pom.xml-fil.

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

Not

Mer information om hur du hanterar Spring Cloud Azure-biblioteksversioner med hjälp av en strukturlista (BOM) finns i avsnittet Komma igång i utvecklarguiden för Spring Cloud Azure.

Lägg till följande egenskaper i filen application.yml. Du kan hämta värdena för dessa egenskaper från appregistreringen som du skapade i Azure-portalen, enligt beskrivningen i förutsättningarna.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <your-client-ID>
         client-secret: <your-client-secret>

Observera

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Använt fel slutpunkt (personliga och organisationskonton) i Fel AADSTS50020 - Användarkonto från identitetsleverantören finns inte i klientorganisationen. Information om hur du konverterar din enklientapp till flerklient finns i Konvertera enklientapp till flerklient på Microsoft Entra ID.

Använd standardsäkerhetskonfigurationen eller ange en egen konfiguration.

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

Alternativ 1: Använd standardkonfigurationen.

Med det här alternativet behöver du inte göra något. Klassen DefaultAadWebSecurityConfiguration konfigureras automatiskt.

Alternativ 2: Ange en självdefinierad konfiguration.

Om du vill ange en konfiguration använder du metoden AadWebApplicationHttpSecurityConfigurer#aadWebApplication för HttpSecurity, som du ser i följande exempel:

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

Alternativ 1: Använd standardkonfigurationen.

Med det här alternativet behöver du inte göra något. Klassen DefaultAadWebSecurityConfigurerAdapter konfigureras automatiskt.

Alternativ 2: Ange en självdefinierad konfiguration.

Om du vill ange en konfiguration utökar du klassen AadWebSecurityConfigurerAdapter och anropar super.configure(http) i funktionen configure(HttpSecurity http), som du ser i följande exempel:

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

Få åtkomst till resursservrar från ett webbprogram

Använd följande steg för att använda Microsoft Entra Starter i det här scenariot:

Ange omdirigerings-URI enligt beskrivningen tidigare.

Lägg till följande beroenden i din pom.xml-fil.

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

Not

Mer information om hur du hanterar Spring Cloud Azure-biblioteksversioner med hjälp av en strukturlista (BOM) finns i avsnittet Komma igång i utvecklarguiden för Spring Cloud Azure.

Lägg till följande egenskaper i din application.yml-fil enligt beskrivningen tidigare:

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <your-client-ID>
         client-secret: <your-client-secret>
       authorization-clients:
         graph:
           scopes: https://graph.microsoft.com/Analytics.Read, email

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Error AADSTS50020 – Användarkonto från identitetsprovidern finns inte i klientorganisationen. Information om hur du konverterar din enklientapp till en flerklientlösning finns i Konvertera enklientapp till flerklient på Microsoft Entra ID.

Här är graph namnet på din OAuth2AuthorizedClientoch scopes är de behörigheter som krävs för samtycke vid inloggning.

Lägg till kod i ditt program som liknar följande exempel:

@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 the resource server.
   return toJsonString(graphClient);
}

Här är graph det klient-ID som konfigurerades i föregående steg. OAuth2AuthorizedClient innehåller åtkomsttoken som används för att komma åt resursservern.

Ett fullständigt exempel som visar det här scenariot finns i spring-cloud-azure-starter-active-directory-sample: aad-web-application.

Skydda en resursserver/API

Det här scenariot stöder inte inloggning, men skyddar servern genom att verifiera åtkomsttoken. Om åtkomsttoken är giltig hanterar servern begäran.

Använd följande steg för att använda Microsoft Entra Starter i det här scenariot:

Lägg till följande beroenden i din pom.xml-fil.

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

Not

Mer information om hur du hanterar Spring Cloud Azure-biblioteksversioner med hjälp av en strukturlista (BOM) finns i avsnittet Komma igång i utvecklarguiden för Spring Cloud Azure.

Lägg till följande egenskaper i din application.yml-fil enligt beskrivningen tidigare:

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       credential:
         client-id: <your-client-ID>
       app-id-uri: <your-app-ID-URI>

Du kan använda både <your-client-ID>- och <your-app-ID-URI>-värdena för att verifiera åtkomsttoken. Du kan hämta <your-app-ID-URI>-värdet från Azure-portalen enligt följande bilder:

Skärmbild av Azure-portalen som visar webbappen Exponera en API-sida med program-ID-URI markerat.

Använd standardsäkerhetskonfigurationen eller ange en egen konfiguration.

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

Alternativ 1: Använd standardkonfigurationen.

Med det här alternativet behöver du inte göra något. Klassen DefaultAadResourceServerConfiguration konfigureras automatiskt.

Alternativ 2: Ange en självdefinierad konfiguration.

Om du vill ange en konfiguration använder du metoden AadResourceServerHttpSecurityConfigurer#aadResourceServer för HttpSecurity, som du ser i följande exempel:

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

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

Alternativ 1: Använd standardkonfigurationen.

Med det här alternativet behöver du inte göra något. Klassen DefaultAadResourceServerWebSecurityConfigurerAdapter konfigureras automatiskt.

Alternativ 2: Ange en självdefinierad konfiguration.

Om du vill ange en konfiguration utökar du klassen AadResourceServerWebSecurityConfigurerAdapter och anropar super.configure(http) i funktionen configure(HttpSecurity http), som du ser i följande exempel:

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

Ett fullständigt exempel som visar det här scenariot finns i spring-cloud-azure-starter-active-directory-sample: aad-resource-server.

Få åtkomst till andra resursservrar från en resursserver

Det här scenariot stöder en resursserver som besöker andra resursservrar.

Använd följande steg för att använda Microsoft Entra Starter i det här scenariot:

Lägg till följande beroenden i din pom.xml-fil.

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

Obs

Mer information om hur du hanterar Spring Cloud Azure-biblioteksversioner med hjälp av en strukturlista (BOM) finns i avsnittet Komma igång i utvecklarguiden för Spring Cloud Azure.

Lägg till följande egenskaper i din application.yml-fil:

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <web-API-A-client-ID>
         client-secret: <web-API-A-client-secret>
       app-id-uri: <web-API-A-app-ID-URI>
       authorization-clients:
         graph:
           scopes:
              - https://graph.microsoft.com/User.Read

Anteckning

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Använde fel slutpunkt (personliga och organisationskonton) i Fel AADSTS50020 – Användarkonto från identitetsleverantören finns inte i hyresgästen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Använd attributet @RegisteredOAuth2AuthorizedClient i koden för att komma åt den relaterade resursservern, som du ser i följande exempel:

@PreAuthorize("hasAuthority('SCOPE_Obo.Graph.Read')")
@GetMapping("call-graph")
public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
   return callMicrosoftGraphMeEndpoint(graph);
}

Ett komplett exempel som demonstrerar detta scenario finns i spring-cloud-azure-starter-active-directory-sample: aad-resource-server-obo.

Webbprogram och resursserver i ett program

Det här scenariot stöder Åtkomst till ett webbprogram och Skydda en resursserver/API- i ett program.

Följ dessa steg om du vill använda aad-starter i det här scenariot:

Lägg till följande beroenden i din pom.xml-fil.

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

Notera

Mer information om hur du hanterar Spring Cloud Azure-biblioteksversioner med hjälp av en strukturlista (BOM) finns i avsnittet Komma igång i utvecklarguiden för Spring Cloud Azure.

Uppdatera din application.yml-fil. Ange egenskapen spring.cloud.azure.active-directory.application-type till web_application_and_resource_serveroch ange auktoriseringstypen för varje auktoriseringsklient, enligt följande exempel.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <Web-API-C-client-id>
         client-secret: <Web-API-C-client-secret>
       app-id-uri: <Web-API-C-app-id-url>
       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

Not

De värden som tillåts för tenant-id är: common, organizations, consumerseller klientorganisations-ID. Mer information om dessa värden finns i avsnittet Used the wrong endpoint (personal and organization accounts) i Fel AADSTS50020 – Användarkonto från identitetsleverantören finns inte i hyresgästen. Information om hur du konverterar din app för en klientorganisation finns i Konvertera enklientapp till flera klientorganisationer på Microsoft Entra-ID.

Skriv Java-kod för att konfigurera flera HttpSecurity instanser.

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

I följande exempelkod innehåller AadWebApplicationAndResourceServerConfig två bönor för säkerhetsfilterkedja, en för en resursserver och en för ett webbprogram. Den apiFilterChain-komponenten har hög prioritet för att konfigurera resursserverns säkerhetskonfigurerare. Den htmlFilterChain bönan har låg prioritet för att konfigurera säkerhetsverktyget för webbprogram.

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

I följande exempelkod innehåller AadWebApplicationAndResourceServerConfig två säkerhetskonfigurationer, en för en resursserver och en för ett webbprogram. Klassen ApiWebSecurityConfigurationAdapter har hög prioritet för att konfigurera säkerhetsadaptern för resursservern. Klassen HtmlWebSecurityConfigurerAdapter har låg prioritet för att konfigurera webbapplikationens säkerhetsadapter.

@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 the resource server. Other paths work as  the 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
       }
   }
}

Programtyp

Egenskapen spring.cloud.azure.active-directory.application-type är valfri eftersom dess värde kan härledas av beroenden. Du måste endast ange egenskapen manuellt när du använder värdet web_application_and_resource_server.

Har beroende: spring-security-oauth2-client	Är beroende av: spring-security-oauth2-resource-server	Giltiga värden för programtyp	Standardvärde
Ja	Nej	`web_application`	`web_application`
Nej	Ja	`resource_server`	`resource_server`
Ja	Ja	`web_application`,`resource_server`, `resource_server_with_obo`, `web_application_and_resource_server`	`resource_server_with_obo`

Konfigurerbara egenskaper

Spring Boot Starter för Microsoft Entra ID innehåller följande egenskaper:

Egenskaper	Beskrivning
spring.cloud.azure.active-directory.app-id-uri	Används av resursservern för att verifiera målgruppen i åtkomsttoken. Den åtkomsttoken är endast giltig när målgruppen är lika med de `<your-client-ID>`- eller `<your-app-ID-URI>`-värden som beskrevs tidigare.
spring.cloud.azure.active-directory.authorization-clients	En karta som konfigurerar resurs-API:erna som programmet ska besöka. Varje objekt motsvarar ett resurs-API som programmet kommer att besöka. I Din Spring-kod motsvarar varje objekt ett `OAuth2AuthorizedClient` objekt.
spring.cloud.azure.active-directory.authorization-clients.`<your-client-name>`.scopes	API-behörigheterna för en resursserver som programmet ska hämta.
spring.cloud.azure.active-directory.authorization-clients.`<your-client-name>`.authorization-grant-type	Typ av auktoriseringsklient. Typer som stöds är `authorization_code` (standardtyp för webbapp), `on_behalf_of` (standardtyp för resursserver) `client_credentials`.
spring.cloud.azure.active-directory.application-type	Se Programtyp.
spring.cloud.azure.active-directory.profile.environment.active-directory-endpoint	Bas-URI:n för auktoriseringsservern. Standardvärdet är `https://login.microsoftonline.com/`.
spring.cloud.azure.active-directory.credential.client-id	Det registrerade program-ID:t i Microsoft Entra-ID.
spring.cloud.azure.active-directory.credential.client-secret	Klientens hemlighet för den registrerade applikationen.
spring.cloud.azure.active-directory.user-group.use-transitive-members	Använd `v1.0/me/transitiveMemberOf` för att hämta grupper om det är inställt på `true`. Annars använder du `/v1.0/me/memberOf`.
spring.cloud.azure.active-directory.post-logout-redirect-uri	Omdirigerings-URI:n för att publicera utloggningen.
spring.cloud.azure.active-directory.profile.tenant-id	Azure-klientorganisations-ID. De värden som tillåts för `tenant-id` är: `common`, `organizations`, `consumers`eller klientorganisations-ID.
spring.cloud.azure.active-directory.user-group.allowed-group-names	De förväntade användargrupper som en myndighet kommer att beviljas om de hittas i svaret från `MemberOf` Graph API-anropet.
spring.cloud.azure.active-directory.user-name-attribute	Anger vilket anspråk som ska vara huvudmannens namn.

I följande exempel visas hur du använder dessa egenskaper:

Egenskapsexempel 1: Om du vill använda Azure China 21Vianet i stället för Azure Global använder du följande steg.

Lägg till följande egenskaper i din application.yml-fil:

spring:
   cloud:
     azure:
       active-directory:
         enabled: true
         profile:
           environment:
             active-directory-endpoint: https://login.partner.microsoftonline.cn

Med den här metoden kan du använda ett Azure-suvereänt eller nationellt moln i stället för det publika Azure-molnet.

Egenskapsexempel 2: Använd följande steg om du vill använda ett gruppnamn för att skydda någon metod i ett webbprogram:

Lägg till följande egenskap i din application.yml-fil:

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       user-group:
         allowed-groups: group1, group2

Använd standardsäkerhetskonfigurationen eller ange en egen konfiguration.

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

Alternativ 1: Använd standardkonfigurationen. Med det här alternativet behöver du inte göra något. Klassen DefaultAadWebSecurityConfiguration konfigureras automatiskt.

Alternativ 2: Ange en självdefinierad konfiguration. Om du vill ange en konfiguration använder du metoden AadWebApplicationHttpSecurityConfigurer#aadWebApplication för HttpSecurity, som du ser i följande exempel:

@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()
           .authorizeHttpRequests()
               .anyRequest().authenticated();
       // @formatter:on
       // Do some custom configuration.
       return http.build();
   }
}

Alternativ 1: Använd standardkonfigurationen. Med det här alternativet behöver du inte göra något. Klassen DefaultAadWebSecurityConfigurerAdapter konfigureras automatiskt.

Alternativ 2: Ange en självdefinierad konfiguration. Om du vill ange en konfiguration utökar du klassen AadWebSecurityConfigurerAdapter och anropar super.configure(http) i funktionen configure(HttpSecurity http), som du ser i följande exempel:

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

Använd @PreAuthorize-kommentaren för att skydda metoden, som du ser i följande exempel:

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

Egenskapsexempel 3: Använd följande steg om du vill aktivera flöde för klientautentiseringsuppgifter på en resursserver som besöker resursservrar:

Lägg till följande egenskap i din application.yml-fil:

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       authorization-clients:
         webapiC:   # When authorization-grant-type is null, on behalf of flow is used by default
           authorization-grant-type: client_credentials
           scopes:
             - <Web-API-C-app-id-url>/.default

Lägg till kod i ditt program som liknar följande exempel:

@PreAuthorize("hasAuthority('SCOPE_Obo.WebApiA.ExampleScope')")
@GetMapping("webapiA/webapiC")
public String callClientCredential() {
   String body = webClient
       .get()
       .uri(CUSTOM_LOCAL_READ_ENDPOINT)
       .attributes(clientRegistrationId("webapiC"))
       .retrieve()
       .bodyToMono(String.class)
       .block();
   LOGGER.info("Response from Client Credential: {}", body);
   return "client Credential response " + (null != body ? "success." : "failed.");
}

Avancerade funktioner

Stöd för åtkomstkontroll via ID-token i ett webbprogram

Startprogrammet har stöd för att skapa GrantedAuthority från en ID-tokens roles krav för att möjliggöra användning av ID-token för auktorisering i en webbapplikation. Du kan använda funktionen appRoles i Microsoft Entra-ID för att skapa ett roles anspråk och implementera åtkomstkontroll.

Notera

Det roles-anspråk som genereras från appRoles är försett med prefixet APPROLE_.

När du använder appRoles som ett roles anspråk bör du undvika att konfigurera ett gruppattribut som roles samtidigt. Annars åsidosätter gruppattributet påståendet så att det innehåller gruppinformation i stället för appRoles. Du bör undvika följande konfiguration i manifestet:

"optionalClaims": {
    "idtoken": [{
        "name": "groups",
        "additionalProperties": ["emit_as_roles"]
    }]
}

Använd följande steg för att stödja åtkomstkontroll via ID-token i ett webbprogram:

Lägg till apprroller i ditt program och tilldela dem till användare eller grupper. För mer information, se Hur du: Lägger till approller i din applikation och tar emot dem i tokenen.

Lägg till följande appRoles konfiguration i programmets manifest:

 "appRoles": [
   {
     "allowedMemberTypes": [
       "User"
     ],
     "displayName": "Admin",
     "id": "2fa848d0-8054-4e11-8c73-7af5f1171001",
     "isEnabled": true,
     "description": "Full admin access",
     "value": "Admin"
    }
 ]

Lägg till kod i ditt program som liknar följande exempel:

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

Felsökning

Aktivera klientloggning

Azure SDK:er för Java erbjuder en konsekvent loggningshistoria som hjälper dig att felsöka och lösa programfel. Loggarna som skapas samlar in flödet för ett program innan de når terminalen, vilket hjälper till att hitta rotproblemet. Se loggning wiki för vägledning om att aktivera loggning.

Aktivera Spring-loggning

Spring gör det möjligt för alla loggningssystem som stöds att ange loggningsnivåer i Spring-miljön, till exempel i application.properties, med hjälp av logging.level.<logger-name>=<level> där <level> är en av TRACE, DEBUG, INFO, WARN, ERROR, FATALeller OFF. Du kan konfigurera rotloggaren med hjälp av logging.level.root.

I följande exempel visas potentiella loggningsinställningar i filen application.properties:

logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.org.hibernate=ERROR

Mer information om konfiguration av loggning i Spring finns i Loggning i Spring-dokumentationen.

Nästa steg

Om du vill veta mer om Spring och Azure fortsätter du till dokumentationscentret för Spring on Azure.

Vår på Azure

Dela via

Utvecklarguide för Spring Boot Starter för Microsoft Entra

Förutsättningar

Grundläggande scenarier

Få åtkomst till ett webbprogram

Få åtkomst till resursservrar från ett webbprogram

Skydda en resursserver/API

Få åtkomst till andra resursservrar från en resursserver

Webbprogram och resursserver i ett program

Programtyp

Konfigurerbara egenskaper

Avancerade funktioner

Stöd för åtkomstkontroll via ID-token i ett webbprogram

Felsökning

Aktivera klientloggning

Aktivera Spring-loggning

Nästa steg

Feedback

Ytterligare resurser