Spring Cloud Azure-Support für Spring Security

Dieser Artikel bezieht sich auf: ✔️ Version 4.14.0 ✔️ Version 5.8.0

In diesem Artikel wird beschrieben, wie Spring Cloud Azure und Spring Security zusammen verwendet werden können.

Spring Security mit Microsoft Entra ID

Wenn Sie eine Webanwendung erstellen, sind Identitäts- und Zugriffsverwaltung immer grundlegende Elemente.

Azure bietet eine großartige Plattform, um Ihre Anwendungsentwicklung zu demokratisieren, da sie nicht nur einen Cloud-Basis-Identitätsdienst bietet, sondern auch eine tiefe Integration mit dem Rest des Azure-Ökosystems.

Spring Security hat es leicht gemacht, Ihre Spring-basierten Anwendungen mit leistungsstarken Abstraktionen und erweiterbaren Schnittstellen zu sichern. So leistungsfähig wie das Spring-Framework sein kann, ist es jedoch nicht auf einen bestimmten Identitätsanbieter zugeschnitten.

Dies spring-cloud-azure-starter-active-directory bietet die optimale Möglichkeit, Ihre Webanwendung mit einem Microsoft Entra ID (Microsoft Entra ID for short) Mandanten zu verbinden und Ihren Ressourcenserver mit Microsoft Entra ID zu schützen. Hierbei wird das OAuth 2.0-Protokoll verwendet, um Webanwendungen und Ressourcenserver zu schützen.

Zugreifen auf eine Webanwendung

In diesem Szenario wird der OAuth 2.0-Autorisierungscode-Genehmigungsfluss verwendet, um sich bei einem Benutzer mit einem Microsoft-Konto anzumelden.

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Schnellstart: Registrieren einer Anwendung bei der Microsoft Identity Platform.

2. Erstellen Sie eine -App-Registrierung. Abrufen AZURE_TENANT_ID, AZURE_CLIENT_ID, und AZURE_CLIENT_SECRET.

3. Festlegen redirect URI auf APPLICATION_BASE_URI/login/oauth2/code/ - z. B http://localhost:8080/login/oauth2/code/. . Der Schwanz / ist erforderlich.

Hinzufügen von erforderlichen Abhängigkeiten

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

Hinzufügen der erforderlichen Eigenschaften

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Starten Sie nun Ihre Anwendung, und greifen Sie über den Browser auf Ihre Anwendung zu. Sie werden auf die Microsoft-Anmeldeseite umgeleitet.

Erweiterte Verwendungen

Hinzufügen zusätzlicher Sicherheitskonfigurationen

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

Autorisieren des Zugriffs nach App-Rollen

Erstellen sie erforderliche Ressourcen in Azure:

• Lesen Sie "Hinzufügen von App-Rollen zu Ihrer Anwendung" und empfangen Sie sie im Token.

• Erstellen Sie eine App-Rolle mit den folgenden Parametern:

  • Anzeigename: Administrator
  • Zulässige Mitgliedertypen: Benutzer/Gruppen
  • Wert: Administrator
  • Möchten Sie diese App-Rolle aktivieren: Ja

Hinweis

Wenn Sie die app-rollenbasierte Zugriffssteuerung verwenden möchten, können Sie gruppennamen nicht in den role Anspruch einfügen. Weitere Informationen finden Sie im Abschnitt "Konfigurieren von Gruppen optionaler Ansprüche " unter "Bereitstellen optionaler Ansprüche für Ihre App".

Schützen Sie die spezifische Methode.

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

Autorisieren des Zugriffs nach Gruppenname oder Gruppen-ID

Fügen Sie verwandte Konfigurationseigenschaften hinzu.

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

Schützen Sie die spezifische Methode.

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

Verwenden von National Azure anstelle von globalen Azure

Mit Ausnahme der globalen Azure-Cloud wird die Microsoft Entra-ID in den folgenden nationalen Clouds bereitgestellt:

• Azure Government

• Azure China 21Vianet

• Azure Deutschland

Hier ist ein Beispiel mit Azure China 21Vianet.

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

Weitere Informationen finden Sie unter "Nationale Cloudbereitstellungen".

Konfigurieren der Umleitungs-URI-Vorlage

Entwickler können den Umleitungs-URI anpassen.

Fügen Sie redirect-uri-template Eigenschaften in der Datei application.yml hinzu.

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

Aktualisieren redirect-uri sie im Azure-Portal.

Nach dem Festlegen redirect-uri-templatemüssen wir den Sicherheits-Generator aktualisieren:

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

Verbinden ing an Microsoft Entra ID via Proxy

Um die Microsoft Entra-ID über einen Proxy zu verbinden, geben Sie eine RestTemplateCustomizer Bohnen wie die im folgenden Beispiel gezeigte an:

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

Beispiele

Beispielprojekt: aad-web-application.

Webanwendung, die auf Ressourcenserver zugreift

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Schnellstart: Registrieren einer Anwendung bei der Microsoft Identity Platform.

2. Erstellen Sie eine -App-Registrierung. Abrufen AZURE_TENANT_ID, AZURE_CLIENT_ID, und AZURE_CLIENT_SECRET.

3. Festlegen redirect URI auf APPLICATION_BASE_URI/login/oauth2/code/, z. B http://localhost:8080/login/oauth2/code/. . Der Schwanz / ist erforderlich.

Hinzufügen von erforderlichen Abhängigkeiten

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

Hinzufügen der erforderlichen Eigenschaften

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

graph Hier ist der Name von OAuth2AuthorizedClient, scopes bedeutet die Bereiche, die zum Zustimmen bei der Anmeldung erforderlich sind.

Verwenden von OAuth2AuthorizedClient in Ihrer Anwendung

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

Starten Sie nun Ihre Anwendung, und greifen Sie im Browser auf Ihre Anwendung zu. Anschließend werden Sie zur Microsoft-Anmeldeseite umgeleitet.

Erweiterte Verwendungen

Clientanmeldeinformationsfluss

Der Standardfluss ist der Autorisierungscodefluss, wenn Sie den Clientanmeldeinformationsfluss verwenden möchten, können Sie wie folgt konfigurieren:

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Zugreifen auf mehrere Ressourcenserver

In einer Webanwendung können Sie auf mehrere Ressourcenserver zugreifen, indem Sie wie folgt konfigurieren:

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Dann können Sie wie folgt in der Anwendung verwenden OAuth2AuthorizedClient .

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

Beispiele

Beispielprojekt: aad-web-application.

Zugreifen auf einen Ressourcenserver

In diesem Szenario wird die Anmeldung nicht unterstützt. Schützen Sie einfach den Server, indem Sie das Zugriffstoken überprüfen. Wenn das Zugriffstoken gültig ist, wird die Anforderung vom Server bereitgestellt.

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Schnellstart: Registrieren einer Anwendung bei der Microsoft Identity Platform.

2. Erstellen Sie eine -App-Registrierung. Abrufen AZURE_CLIENT_ID.

3. Schnellstart : Konfigurieren einer Anwendung zum Verfügbarmachen einer Web-API.

4. Machen Sie eine Web-API mit einem Bereich namens verfügbar Scope-1.

Hinzufügen von erforderlichen Abhängigkeiten

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

Hinzufügen der erforderlichen Eigenschaften

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

Starten Sie nun Ihre Anwendung, und greifen Sie auf die Web-API Ihrer Anwendung zu.

1. Sie erhalten 401 ohne Zugriffstoken.

2. Greifen Sie mit einem Zugriffstoken auf Ihre Anwendung zu. Die folgenden Ansprüche im Zugriffstoken werden überprüft:

   • iss: Das Zugriffstoken muss von der Microsoft Entra-ID ausgestellt werden.

   • nbf: Die aktuelle Uhrzeit kann nicht vorher nbfsein.

   • exp: Die aktuelle Uhrzeit kann nicht nach exp.

   • aud: Wenn spring.cloud.azure.active-directory.credential.client-id oder spring.cloud.azure.active-directory.credential.app-id-uri konfiguriert, muss die Zielgruppe der konfigurierten client-id oder app-id-uri. Wenn die beiden Eigenschaften nicht konfiguriert sind, wird dieser Anspruch nicht überprüft.

Weitere Informationen zum Zugriffstoken finden Sie in MS-Dokumentationen zu Zugriffstoken der Microsoft Identity Platform.

Erweiterte Verwendungen

Hinzufügen zusätzlicher Sicherheitskonfigurationen

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

Überprüfen der Berechtigung nach Bereichen

1. Erstellen Sie erforderliche Ressourcen in Azure.

   • Schnellstart : Konfigurieren einer Anwendung zum Verfügbarmachen einer Web-API.

   • Machen Sie eine Web-API mit einem Bereich namens verfügbar Scope1.

2. Schützen Sie die spezifische Methode.

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

Dadurch werden beim Zugriffsendpunkt /scope1 die folgenden Ansprüche im Zugriffstoken überprüft:

• scp: Der Wert muss enthalten Scope1.

Überprüfen der Berechtigung nach App-Rollen

1. Erstellen Sie erforderliche Ressourcen in Azure.

   • Lesen Sie "Hinzufügen von App-Rollen zu Ihrer Anwendung" und empfangen Sie sie im Token.

   • Erstellen Sie eine App-Rolle mit den folgenden Parametern:

     • Anzeigename: AppRole1
     • Zulässige Mitgliedertypen: Benutzer/Gruppen
     • Wert: AppRole1
     • Möchten Sie diese App-Rolle aktivieren: Ja

2. Schützen Sie die spezifische Methode.

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

Dadurch werden beim Zugriffsendpunkt /app-role1 die folgenden Ansprüche im Zugriffstoken überprüft:

• roles: Der Wert muss enthalten AppRole1.

Verwenden der JWT-Clientauthentifizierung

Führen Sie die folgenden Schritte aus, um ein JSON-Webtoken (JWT) für die Clientauthentifizierung zu verwenden:

1. Weitere Informationen finden Sie im Abschnitt "Registrieren Ihres Zertifikats mit Der Microsoft Identity Platform-Anwendungsauthentifizierung".
2. Laden Sie ein PEM-Zertifikat in die anwendung hoch, die im Azure-Portal registriert ist.
3. Konfigurieren sie den Zertifikatpfad und das Kennwort eines . PFX oder . P12-Zertifikat .
4. Fügen Sie der Clientkonfiguration die Eigenschaftskonfiguration spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt hinzu, die über die JWT-Clientauthentifizierung authentifiziert werden soll.

Die folgende Beispielkonfigurationsdatei ist für ein Webanwendungsszenario vorgesehen. Die Zertifikatinformationen werden in den globalen Eigenschaften konfiguriert.

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Sie können die Zertifikatinformationen auch in den active-directory Diensteigenschaften konfigurieren, wie in diesem Beispiel gezeigt:

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Verbinden ing an Microsoft Entra ID via Proxy

Um die Microsoft Entra-ID über den Proxy zu verbinden, stellen Sie eine RestTemplateCustomizer Bohnen bereit. Weitere Informationen finden Sie im abschnitt "Verbinden ing to Microsoft Entra ID via proxy".

Beispiele

Beispielprojekt: aad-resource-server.

Ressourcenserver, der andere Ressourcenserver besucht

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Schnellstart: Registrieren einer Anwendung bei der Microsoft Identity Platform.

2. Erstellen Sie eine -App-Registrierung. Abrufen AZURE_TENANT_ID, AZURE_CLIENT_ID, und AZURE_CLIENT_SECRET.

Hinzufügen von erforderlichen Abhängigkeiten

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

Hinzufügen der erforderlichen Eigenschaften

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Verwenden von OAuth2AuthorizedClient in Ihrer Anwendung

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

Beispiele

Beispielprojekt: aad-resource-server-obo.

Webanwendung und Ressourcenserver innerhalb einer Anwendung

Erstellen erforderlicher Ressourcen in Azure

1. Schnellstart: Registrieren einer Anwendung bei der Microsoft Identity Platform.

2. Erstellen Sie eine -App-Registrierung. Abrufen AZURE_TENANT_ID, AZURE_CLIENT_ID, und AZURE_CLIENT_SECRET.

Hinzufügen von erforderlichen Abhängigkeiten

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

Hinzufügen der erforderlichen Eigenschaften

Legen Sie die Eigenschaft spring.cloud.azure.active-directory.application-type auf web_application_and_resource_server, und geben Sie den Autorisierungstyp für jeden Autorisierungsclient an.

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Define SecurityFilterChain

Konfigurieren sie mehrere SecurityFilterChain Instanzen. AadWebApplicationAndResourceServerConfig enthält zwei Sicherheitsfilterkettenkonfigurationen für Ressourcenserver und Webanwendung.

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

Konfiguration

Konfigurierbare Eigenschaften von spring-cloud-azure-starter-active-directory:

Name	Beschreibung
spring.cloud.azure.active-directory.app-id-uri	App-ID-URI, der im Anspruch "aud" eines id_token verwendet werden kann.
spring.cloud.azure.active-directory.application-type	Typ der Microsoft Entra-Anwendung.
spring.cloud.azure.active-directory.authenticate-additional-parameters	Fügen Sie der Autorisierungs-URL zusätzliche Parameter hinzu.
spring.cloud.azure.active-directory.authorization-clients	Die OAuth2-Autorisierungsclients.
spring.cloud.azure.active-directory.credential.client-id	Client-ID, die beim Ausführen der Dienstprinzipalauthentifizierung mit Azure verwendet werden soll.
spring.cloud.azure.active-directory.credential.client-secret	Geheimer Clientschlüssel, der beim Ausführen der Dienstprinzipalauthentifizierung mit Azure verwendet werden soll.
spring.cloud.azure.active-directory.jwk-set-cache-lebensdauer	Die Lebensdauer des zwischengespeicherten JWK-Satzes, bevor es abläuft, ist der Standardwert 5 Minuten.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time	Die Aktualisierungszeit des zwischengespeicherten JWK-Satzes, bevor es abläuft, beträgt standardmäßig 5 Minuten.
spring.cloud.azure.active-directory.jwt-connect-timeout	Verbinden ion Timeout für den JWKSet-Remote-URL-Aufruf.
spring.cloud.azure.active-directory.jwt-read-timeout	Lesetimeout für den JWKSet Remote-URL-Aufruf.
spring.cloud.azure.active-directory.jwt-size-limit	Größenbeschränkung in Bytes des JWKSet-Remote-URL-Aufrufs.
spring.cloud.azure.active-directory.post-logout-redirect-uri	Der Umleitungs-URI nach der Abmeldung.
spring.cloud.azure.active-directory.profile.cloud-type	Name der Azure-Cloud, mit der eine Verbindung hergestellt werden soll. Unterstützte Typen sind: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
spring.cloud.azure.active-directory.profile.environment	Eigenschaften für Microsoft Entra-Endpunkte.
spring.cloud.azure.active-directory.profile.tenant-id	Azure-Mandanten-ID. Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID.
spring.cloud.azure.active-directory.redirect-uri-template	Umleitungsendpunkt: Wird vom Autorisierungsserver verwendet, um Antworten zurückzugeben, die Autorisierungsanmeldeinformationen für den Client über den Benutzer-Agent des Ressourcenbesitzers enthalten. Der Standardwert ist {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map	Konfigurieren Sie, welcher Anspruch zum Erstellen von "GrantedAuthority" und dem Präfix des Zeichenfolgenwerts "GrantedAuthority" verwendet wird. Standardwert ist: "scp" -> "SCOPE_", "roles" -> "APPROLE_".
spring.cloud.azure.active-directory.resource-server.principal-claim-name	Konfigurieren Sie, welcher Anspruch im Zugriffstoken in AuthenticatedPrincipal#getName zurückgegeben wird. Der Standardwert ist "sub".
spring.cloud.azure.active-directory.session-stateless	Wenn true den zustandslosen AadAppRoleStatelessAuthenticationFilter aktiviert. Der Standardwert ist "false", der AadAuthenticationFilter aktiviert.
spring.cloud.azure.active-directory.user-group.allowed-group-ids	Die Gruppen-IDs können verwendet werden, um "GrantedAuthority" zu erstellen.
spring.cloud.azure.active-directory.user-group.allowed-group-names	Die Gruppennamen können verwendet werden, um "GrantedAuthority" zu erstellen.
spring.cloud.azure.active-directory.user-group.use-transitive-members	Wenn "true", verwenden Sie "v1.0/me/transitiveMemberOf", um Mitglieder abzurufen. Verwenden Sie andernfalls "v1.0/me/memberOf". Der Standardwert ist false.
spring.cloud.azure.active-directory.user-name-attribute	Entscheiden Sie, welcher Anspruch der Name des Prinzipals sein soll.

Hier sind einige Beispiele für die Verwendung dieser Eigenschaften:

Anwendungstyp

Der Anwendungstyp kann aus den Abhängigkeiten abgeleitet werden: spring-security-oauth2-client oder spring-security-oauth2-resource-server. Wenn der abgeleitete Wert nicht der gewünschte Wert ist, können Sie den Anwendungstyp angeben. Dies ist die Tabelle mit gültigen Werten und abgeleiteten Werten:

Anwendungstyp von spring-cloud-azure-starter-active-directory:

Hat Abhängigkeit: spring-security-oauth2-client	Hat Abhängigkeit: spring-security-oauth2-resource-server	Gültige Werte für den Anwendungstyp	Abgeleiteter Wert
Ja	Nein	web_application	web_application
Nr.	Ja	resource_server	resource_server
Ja	Ja	web_application, resource_server, resource_server_with_obo, web_application_and_resource_server	resource_server_with_obo

Spring Security mit Azure Active Directory B2C

Azure Active Directory (Azure AD) B2C ist ein Identitätsverwaltungsdienst, mit dem Sie die Kundenregistrierung und -anmeldung anpassen und steuern sowie Profile bei der Verwendung Ihrer Anwendungen verwalten können. Azure AD B2C ermöglicht diese Aktionen und schützt gleichzeitig die Identitäten Ihrer Kunden.

Setup von Abhängigkeiten

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

Konfiguration

Konfigurierbare Eigenschaften von spring-cloud-azure-starter-active-directory-b2c:

Name	Beschreibung
spring.cloud.azure.active-directory.b2c.app-id-uri	App-ID-URI, der möglicherweise im "aud"-Anspruch eines Tokens verwendet werden kann.
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters	Zusätzliche Parameter für die Authentifizierung.
spring.cloud.azure.active-directory.b2c.authorization-clients	Geben Sie die Clientkonfiguration an.
spring.cloud.azure.active-directory.b2c.base-uri	Azure AD B2C-Endpunktbasis-URI.
spring.cloud.azure.active-directory.b2c.credential	Azure AD B2C-Anmeldeinformationen.
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout	Verbinden ion Timeout für den JWKSet-Remote-URL-Aufruf.
spring.cloud.azure.active-directory.b2c.jwt-read-timeout	Lesetimeout für den JWKSet Remote-URL-Aufruf.
spring.cloud.azure.active-directory.b2c.jwt-size-limit	Größenbeschränkung in Bytes des JWKSet-Remote-URL-Aufrufs.
spring.cloud.azure.active-directory.b2c.login-flow	Geben Sie den primären Anmeldeflussschlüssel an. Der Standardwert ist sign-up-or-sign-in.
spring.cloud.azure.active-directory.b2c.logout-success-url	Umleitungs-URL nach der Abmeldung. Der Standardwert ist http://localhost:8080/login.
spring.cloud.azure.active-directory.b2c.profile	Azure AD B2C-Profilinformationen.
spring.cloud.azure.active-directory.b2c.reply-url	Antwort-URL nach dem Abrufen des Autorisierungscodes. Der Standardwert ist {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.b2c.user-flows	Benutzerflüsse.
spring.cloud.azure.active-directory.b2c.user-name-attribute-name	Benutzername attributname.

Überprüfen Sie bei vollständigen Konfigurationen die Konfigurationseigenschaften von Spring Cloud Azure.

Grundlegende Verwendung

Eine Webanwendung ist eine beliebige webbasierte Anwendung , die es Benutzern ermöglicht, sich mit Microsoft Entra-ID anzumelden, während ein Ressourcenserver nach der Überprüfung access_token, die von microsoft Entra ID abgerufen wurden, entweder akzeptiert oder verweigert. In diesem Leitfaden werden vier Szenarien behandelt:

1. Zugreifen auf eine Webanwendung.

2. Webanwendung, die auf Ressourcenserver zugreift.

3. Zugreifen auf einen Ressourcenserver.

4. Ressourcenserver, der auf andere Ressourcenserver zugreift.

Verwendung 1: Zugreifen auf eine Webanwendung

In diesem Szenario wird der OAuth 2.0-Autorisierungscode-Genehmigungsfluss verwendet, um sich mit Ihrem Azure AD B2C-Benutzer bei einem Benutzer anzumelden.

Wählen Sie Azure AD B2C im Portalmenü, dann "Anwendungen" und dann "Hinzufügen" aus.

Geben Sie Ihren Anwendungsnamen (zwebapp. B. ) für die Antwort-URL hinzuhttp://localhost:8080/login/oauth2/code/, notieren Sie die Anwendungs-ID als IhreWEB_APP_AZURE_CLIENT_ID, und wählen Sie dann "Speichern" aus.

Wählen Sie "Schlüssel" aus Ihrer Anwendung aus, wählen Sie "Schlüssel generieren" aus, um den Zu generierenden Schlüssel zu generierenWEB_APP_AZURE_CLIENT_SECRET, und wählen Sie dann "Speichern" aus.

Wählen Sie "Benutzerflüsse " auf der linken Seite aus, und wählen Sie dann "Neuer Benutzerablauf" aus.

Wählen Sie "Registrieren" oder "Anmelden", "Profilbearbeitung" und "Kennwortzurücksetzung" aus, um Benutzerflüsse zu erstellen. Geben Sie den Benutzernamen und die Benutzerattribute und Ansprüche an, und wählen Sie dann "Erstellen" aus.

Wählen Sie API-Berechtigungen>Add a permission>Microsoft APIs, select Microsoft Graph, select Delegierte Berechtigungen, select the offline_access and openid permissions, and then select Add permission to complete the process.

Erteilen Der Administratorzustimmung für Graph-Berechtigungen.

Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

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>

Fügen Sie Der Datei application.yml Eigenschaften mithilfe der zuvor erstellten Werte hinzu, wie im folgenden Beispiel gezeigt:

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}

Schreiben Sie Ihren Java-Code.

Für Den Controllercode können Sie sich auf das folgende Beispiel beziehen:

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

Für Ihren Sicherheitskonfigurationscode können Sie sich auf das folgende Beispiel beziehen:

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

Kopieren Sie den "home.html" aus dem Beispiel "aad-b2c-web-application", und ersetzen Sie die PROFILE_EDIT_USER_FLOW zuvor verwendeten Benutzerflussnamen.PASSWORD_RESET_USER_FLOW

Erstellen und testen Sie Ihre App. Lassen Sie den Webapp Anschluss 8080 ausführen.

Nachdem Ihre Anwendung mit Maven erstellt und gestartet wurde, öffnen Sie http://localhost:8080/ in einem Webbrowser. Sie sollten zur Anmeldeseite umgeleitet werden.

Wählen Sie den Link mit dem Anmeldebenutzerablauf aus. Daraufhin sollten Sie zu Azure AD B2C weitergeleitet werden, um den Authentifizierungsprozess zu starten.

Nachdem Sie sich erfolgreich angemeldet haben, sollte das Beispiel home page aus dem Browser angezeigt werden.

Verwendung 2: Webanwendung, die auf Ressourcenserver zugreift

Dieses Szenario basiert auf dem Szenario "Zugreifen auf eine Webanwendung" , damit eine Anwendung auf andere Ressourcen zugreifen kann. Dieses Szenario ist der Ablauf der OAuth 2.0-Clientanmeldeinformationen.This scenario is The OAuth 2.0 client credentials grant flow.

Wählen Sie Azure AD B2C im Portalmenü, dann "Anwendungen" und dann "Hinzufügen" aus.

Geben Sie ihren Anwendungsnamen (zwebApiA. B. ) auf, notieren Sie die Anwendungs-ID als IhreWEB_API_A_AZURE_CLIENT_ID, und wählen Sie dann "Speichern" aus.

Wählen Sie "Schlüssel" aus Ihrer Anwendung aus, wählen Sie "Schlüssel generieren" aus, um den Zu generierenden Schlüssel zu generierenWEB_API_A_AZURE_CLIENT_SECRET, und wählen Sie dann "Speichern" aus.

Wählen Sie im Navigationsbereich eine API verfügbar machen, und wählen Sie dann "Festlegen" aus. Notieren Sie den Anwendungs-ID-URI als Ihr WEB_API_A_APP_ID_URL, und wählen Sie dann "Speichern" aus.

Wählen Sie im Navigationsbereich Manifest aus, und fügen Sie dann das folgende JSON-Segment in appRoles ein Array ein. Notieren Sie den Anwendungs-ID-URI als Ihr WEB_API_A_APP_ID_URL, notieren Sie den Wert der App-Rolle als IhreWEB_API_A_ROLE_VALUE, und wählen Sie dann "Speichern" aus.

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

Wählen Sie API-Berechtigungen>"Meine APIs hinzufügen">, "WebApiA"-Anwendungsname, "Anwendungsberechtigungen", "WebApiA.SampleScope"-Berechtigung und dann "Berechtigung hinzufügen" aus, um den Vorgang abzuschließen.

Erteilen Der Administratorzustimmung für WebApiA-Berechtigungen.

Fügen Sie die folgende Abhängigkeit auf der Grundlage des Szenarios "Zugreifen auf eine Webanwendung " hinzu.

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

Fügen Sie die folgende Konfiguration auf der Grundlage des Szenarios "Zugreifen auf eine Webanwendung " hinzu.

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

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Schreiben Sie Ihren Webapp Java-Code.

Für Den Controllercode können Sie sich auf das folgende Beispiel beziehen:

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

Der Sicherheitskonfigurationscode ist identisch mit dem Szenario "Zugreifen auf eine Webanwendung" . Fügen Sie eine weitere Bohnen webClient wie folgt hinzu:

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

Informationen zum Schreiben ihres WebApiA Java-Codes finden Sie im Abschnitt "Zugreifen auf einen Ressourcenserver ".

Erstellen und testen Sie Ihre App. Lassen und laufen Sie Webapp auf Port 8080 bzw. 8081.WebApiA Starten Sie die Webapp Und WebApiA Anwendungen. Kehren Sie nach der erfolgreichen Anmeldung zur Startseite zurück. Sie können dann auf die WebApiA Ressourcenantwort zugreifenhttp://localhost:8080/webapp/webApiA.

Verwendung 3: Zugreifen auf einen Ressourcenserver

In diesem Szenario wird die Anmeldung nicht unterstützt. Schützen Sie einfach den Server, indem Sie das Zugriffstoken validieren, und falls gültig, dient er der Anforderung.

Informationen zum Erstellen Ihrer WebApiA Berechtigung finden Sie unter Verwendung 2: Webanwendung, die auf Ressourcenserver zugreift.

Fügen Sie WebApiA Berechtigungen hinzu, und erteilen Sie Der Administratorzustimmung für Ihre Webanwendung.

Fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

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

Fügen Sie die folgende Konfiguration hinzu.

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}

Hinweis

Die zulässigen tenant-id Werte sind: common, , organizations, consumers, oder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt "Verwendet" des falschen Endpunkts (persönliche und Organisationskonten) des Fehlers AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandanten vorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Schreiben Sie Ihren Java-Code.

Für Den Controllercode können Sie sich auf das folgende Beispiel beziehen:

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

Für Ihren Sicherheitskonfigurationscode können Sie sich auf das folgende Beispiel beziehen:

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

Erstellen und testen Sie Ihre App. Lassen Sie die WebApiA Ausführung auf Port 8081 durchführen. Rufen Sie das Zugriffstoken für die webApiA Ressource ab, und greifen Sie dann als Bearer-Autorisierungsheader zu http://localhost:8081/webApiA/sample .

Verwendung 4: Ressourcenserver, der auf andere Ressourcenserver zugreift

Dieses Szenario ist ein Upgrade des Zugriffs auf einen Ressourcenserver und unterstützt den Zugriff auf andere Anwendungsressourcen basierend auf dem OAuth2-Clientanmeldeinformationsfluss.

In Bezug auf die vorherigen Schritte erstellen wir eine WebApiB Anwendung und machen eine Anwendungsberechtigung WebApiB.SampleScopeverfügbar.

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

Erteilen Der Administratorzustimmung für WebApiB Berechtigungen.

Fügen Sie auf der Grundlage des Zugriffs auf einen Ressourcenserver die folgende Abhängigkeit zu Ihrer pom.xml-Datei hinzu.

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

Fügen Sie die folgende Konfiguration auf der Grundlage der Konfiguration des Zugriffs auf ein Ressourcenserverszenario hinzu.

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

Schreiben Sie Ihren Java-Code.

Für Den WebApiA Controllercode können Sie sich auf das folgende Beispiel beziehen:

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

Für Den WebApiB Controllercode können Sie sich auf das folgende Beispiel beziehen:

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

Sicherheitskonfigurationscode ist identisch mit dem Zugreifen auf ein Ressourcenserverszenario , ein weiterer Bohnen webClient wird wie folgt hinzugefügt:

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

Erstellen und testen Sie Ihre App. Lassen und laufen Sie WebApiA auf Port 8081 bzw. 8082.WebApiB Starten Sie die WebApiA Und WebApiB Anwendungen, rufen Sie das Zugriffstoken für webApiA die Ressource ab, und greifen Sie http://localhost:8081/webApiA/webApiB/sample als Bearer-Autorisierungsheader zu.

Beispiele

Weitere Informationen finden Sie in den Beispielen spring-cloud-azure-starter-active-directory-b2c.