Spring Cloud Azure-Unterstützung für Spring Security

Dieser Artikel gilt für:✅ Version 4.19.0 ✅ Version 5.19.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.

Die 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. Es verwendet das Oauth 2.0-Protokoll zum Schutz von Webanwendungen und Ressourcenservern.

Zugreifen auf eine Webanwendung

In diesem Szenario wird Der OAuth 2.0-Autorisierungscode gewährt Fluss, um sich mit einem Microsoft-Konto bei einem Benutzer anzumelden.

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Lesen sie Schnellstart: Registrieren einer Anwendung mit der Microsoft Identity Platform.

2. Erstellen Sie eine App-Registrierung. Rufen Sie AZURE_TENANT_ID, AZURE_CLIENT_IDund AZURE_CLIENT_SECRETab.

3. Legen Sie redirect URI auf APPLICATION_BASE_URI/login/oauth2/code/ fest , z. B. http://localhost:8080/login/oauth2/code/. Die tailing / ist erforderlich.

Hinzufügen erforderlicher 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 erforderlicher Eigenschaften

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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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 5.x

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

   /**
    * Add configuration logic as needed.
    */
   @Bean
   SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
       http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
               .and()
           .authorizeHttpRequests()
               .anyRequest().authenticated();
           // Do some custom configuration.
       return http.build();
   }
}

Spring Cloud Azure 4.x

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

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

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

Anmerkung

Wenn Sie die app-rollenbasierte Zugriffssteuerung verwenden möchten, können Sie gruppennamen nicht in den Anspruch role einfügen. Weitere Informationen finden Sie im Abschnitt Konfigurieren von optionalen Ansprüchen Abschnitt 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 nationalen Cloudbereitstellungen.

Konfigurieren der Umleitungs-URI-Vorlage

Entwickler können den Umleitungs-URI anpassen.

Fügen Sie ihrer redirect-uri-template Datei Eigenschaften hinzu.

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

Aktualisieren Sie redirect-uri im Azure-Portal.

Nachdem wir redirect-uri-templatefestgelegt haben, müssen wir den Sicherheits-Generator aktualisieren:

Spring Cloud Azure 5.x

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

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

Spring Cloud Azure 4.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2LoginSecurityConfig extends AadWebSecurityConfigurerAdapter {
    /**
     * Add configuration logic as needed.
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.oauth2Login()
                .loginProcessingUrl("${REDIRECT-URI-TEMPLATE}")
                .and()
            .authorizeRequests()
                .anyRequest().authenticated();
    }
}

Herstellen einer Verbindung mit der Microsoft Entra-ID über den Proxy

Um die Microsoft Entra-ID über einen Proxy zu verbinden, stellen Sie eine RestTemplateCustomizer Anker wie im folgenden Beispiel gezeigt bereit:

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

Proben

Beispielprojekt: aad-webanwendung.

Webanwendung, die auf Ressourcenserver zugreift

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Lesen sie Schnellstart: Registrieren einer Anwendung mit der Microsoft Identity Platform.

2. Erstellen Sie eine App-Registrierung. Rufen Sie AZURE_TENANT_ID, AZURE_CLIENT_IDund AZURE_CLIENT_SECRETab.

3. Legen Sie redirect URI auf APPLICATION_BASE_URI/login/oauth2/code/fest, z. B. http://localhost:8080/login/oauth2/code/. Die tailing / ist erforderlich.

Hinzufügen erforderlicher 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 erforderlicher 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Hier ist graph der Name von OAuth2AuthorizedClient, scopes bedeutet, dass 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 Autorisierungscodefluss, wenn Sie Clientanmeldeinformationsflussverwenden 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Anschließend können Sie OAuth2AuthorizedClient in der Anwendung wie folgt verwenden.

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

Proben

Beispielprojekt: aad-webanwendung.

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, dient der Server der Anforderung.

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Lesen sie Schnellstart: Registrieren einer Anwendung mit der Microsoft Identity Platform.

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

3. Lesen Schnellstart: Konfigurieren einer Anwendung, um eine Web-API-verfügbar zu machen.

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

Hinzufügen erforderlicher 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 erforderlicher 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 vor nbfsein.

   • exp: Die aktuelle Uhrzeit kann nach expnicht mehr ausgeführt werden.

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

Weitere Informationen zum Zugriffstoken finden Sie unter MS-Dokumentation zu Zugriffstoken der Microsoft Identity Platform.

Erweiterte Verwendungen

Hinzufügen zusätzlicher Sicherheitskonfigurationen

Spring Cloud Azure 5.x

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

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

Spring Cloud Azure 4.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2ResourceServerSecurityConfig extends AadResourceServerWebSecurityConfigurerAdapter {
    /**
     * Add configuration logic as needed.
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.authorizeRequests((requests) -> requests.anyRequest().authenticated());
    }
}

Überprüfen der Berechtigung nach Bereichen

1. Erstellen Sie erforderliche Ressourcen in Azure.

   • Lesen Schnellstart: Konfigurieren einer Anwendung, um eine Web-API-verfügbar zu machen.

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

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 Zugriff auf /scope1 Endpunkt die folgenden Ansprüche im Zugriffstoken überprüft:

• scp: Der Wert muss Scope1enthalten.

Ü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 Zugriff auf /app-role1 Endpunkt die folgenden Ansprüche im Zugriffstoken überprüft:

• roles: Der Wert muss AppRole1enthalten.

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 Abschnitt Anmeldeinformationen für die Anwendungsauthentifizierungvon Microsoft Identity Platform.
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 die Eigenschaft spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt Konfiguration zum Client 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. Informationen zum Konvertieren Ihrer Einzelmandanten-App finden Sie unter Konvertieren einer Einzelmandanten-App in multitenant auf Microsoft Entra ID.

Herstellen einer Verbindung mit der Microsoft Entra-ID über den Proxy

Um die Microsoft Entra-ID über den Proxy zu verbinden, stellen Sie eine RestTemplateCustomizer Bean bereit. Weitere Informationen finden Sie im Abschnitt Herstellen einer Verbindung mit microsoft Entra ID über proxy Abschnitt.

Proben

Beispielprojekt: aad-resource-server.

Ressourcenserver, der andere Ressourcenserver besucht

Systemdiagramm

Erstellen erforderlicher Ressourcen in Azure

1. Lesen sie Schnellstart: Registrieren einer Anwendung mit der Microsoft Identity Platform.

2. Erstellen Sie eine App-Registrierung. Rufen Sie AZURE_TENANT_ID, AZURE_CLIENT_IDund AZURE_CLIENT_SECRETab.

Hinzufügen erforderlicher 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 erforderlicher 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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);
    }
}

Proben

Beispielprojekt: aad-resource-server-obo.

Webanwendung und Ressourcenserver in einer Anwendung

Erstellen erforderlicher Ressourcen in Azure

1. Lesen sie Schnellstart: Registrieren einer Anwendung mit der Microsoft Identity Platform.

2. Erstellen Sie eine App-Registrierung. Rufen Sie AZURE_TENANT_ID, AZURE_CLIENT_IDund AZURE_CLIENT_SECRETab.

Hinzufügen erforderlicher 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 erforderlicher Eigenschaften

Legen Sie die Eigenschaft spring.cloud.azure.active-directory.application-type auf web_application_and_resource_serverfest, 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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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 Webanwendungen.

Spring Cloud Azure 5.x

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

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

    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
                .and()
            .authorizeHttpRequests()
                .requestMatchers("/login").permitAll()
                .anyRequest().authenticated();
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 4.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadWebApplicationAndResourceServerConfig {

    @Order(1)
    @Configuration
    public static class ApiWebSecurityConfigurationAdapter extends AadResourceServerWebSecurityConfigurerAdapter {
        protected void configure(HttpSecurity http) throws Exception {
            super.configure(http);
            // All the paths that match `/api/**`(configurable) work as `Resource Server`, other paths work as `Web application`.
            http.antMatcher("/api/**")
                .authorizeRequests().anyRequest().authenticated();
        }
    }

    @Configuration
    public static class HtmlWebSecurityConfigurerAdapter extends AadWebSecurityConfigurerAdapter {

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            super.configure(http);
            // @formatter:off
            http.authorizeRequests()
                    .antMatchers("/login").permitAll()
                    .anyRequest().authenticated();
            // @formatter:on
        }
    }
}

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-directoryAutorisierungsclients	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	Verbindungstimeout 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 für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID.
spring.cloud.azure.active-directory.redirect-uri-vorlage	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 spring-cloud-azure-starter-active-directory:

Hat Abhängigkeit: spring-security-oauth2-client	Hat Abhängigkeit: spring-security-oauth2-resource-server	Gültige Werte des Anwendungstyps	Abgeleiteter Wert
Ja	Nein	web_application	web_application
Nein	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 anpassen und steuern können, wie Kunden sich registrieren, anmelden und verwalten, wenn Sie Ihre Anwendungen verwenden. Azure AD B2C aktiviert 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	Verbindungstimeout 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 Spring Cloud Azure-Konfigurationseigenschaften.

Grundlegende Nutzung

Eine Webanwendung ist jede 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 der 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 gewährt, Ablauf, um sich bei einem Benutzer mit Ihrem Azure AD B2C-Benutzer anzumelden.

Wählen Sie Azure AD B2C- im Portalmenü aus, wählen Sie Anwendungenaus, und wählen Sie dann Hinzufügenaus.

Geben Sie ihre Anwendung Name (z. B. webapp), fügen Sie http://localhost:8080/login/oauth2/code/ für die Antwort-URLhinzu, notieren Sie die Anwendungs-ID als WEB_APP_AZURE_CLIENT_ID, und wählen Sie dann Speichernaus.

Wählen Sie Schlüssel aus Ihrer Anwendung aus, wählen Sie Schlüssel generieren aus, um WEB_APP_AZURE_CLIENT_SECRETzu generieren, und wählen Sie dann Speichernaus.

Wählen Sie Benutzerflüsse links aus, und wählen Sie dann Neuen Benutzerablaufaus.

Wählen Sie Registrieren oder in, Profilbearbeitungund Kennwortzurücksetzung, um Benutzerflüsse zu erstellen. Geben Sie ihren Benutzerablauf Name und Benutzerattribute und Ansprüchean, und wählen Sie dann Erstellenaus.

Wählen Sie API-Berechtigungen>Hinzufügen einer Berechtigung>Microsoft-APIs, wählen Sie Microsoft Graphaus, wählen Sie delegierte Berechtigungenaus, wählen Sie die offline_access und openid- Berechtigungen aus, und wählen Sie dann Berechtigung hinzufügen aus, um den Vorgang abzuschließen.

Erteilen Der Administratorzustimmung für Graph--Berechtigungen.

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Fügen Sie Ihrer application.yml Datei 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 5.x

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

    private final AadB2cOidcLoginConfigurer configurer;

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

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.authorizeHttpRequests()
                .anyRequest().authenticated()
                .and()
            .apply(configurer);
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 4.x

@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

   private final AadB2cOidcLoginConfigurer configurer;

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

   @Override
   protected void configure(HttpSecurity http) throws Exception {
       // @formatter:off
       http.authorizeRequests()
               .anyRequest().authenticated()
               .and()
           .apply(configurer);
       // @formatter:off
   }
}

Kopieren Sie die home.html aus aad-b2c-webanwendungsbeispiel, und ersetzen Sie die PROFILE_EDIT_USER_FLOW und PASSWORD_RESET_USER_FLOW durch Die zuvor verwendeten Benutzernamen.

Erstellen und testen Sie Ihre App. Lassen Sie Webapp portieren 8080.

Nachdem Ihre Anwendung von 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. Sie sollten Azure AD B2C umgeleitet 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 Zugreifen auf eine Webanwendung Szenario, um einer Anwendung den Zugriff auf andere Ressourcen zu ermöglichen. Dieses Szenario ist Die OAuth 2.0-Clientanmeldeinformationen gewähren Fluss.

Wählen Sie Azure AD B2C- im Portalmenü aus, wählen Sie Anwendungenaus, und wählen Sie dann Hinzufügenaus.

Geben Sie ihre Anwendung Name (z. B. webApiA), notieren Sie die Anwendungs-ID als WEB_API_A_AZURE_CLIENT_ID, und wählen Sie dann Speichernaus.

Wählen Sie Schlüssel aus Ihrer Anwendung aus, wählen Sie Schlüssel generieren aus, um WEB_API_A_AZURE_CLIENT_SECRETzu generieren, und wählen Sie dann Speichernaus.

Wählen Sie API- im Navigationsbereich verfügbar machen, und wählen Sie dann Festlegenaus. Notieren Sie den Anwendungs-ID-URI als WEB_API_A_APP_ID_URL, und wählen Sie dann Speichernaus.

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

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

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

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

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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 Zugreifen auf eine Webanwendung Szenario. Fügen Sie eine weitere 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 Abschnitt.

Erstellen und testen Sie Ihre App. Lassen Sie Webapp und WebApiA portieren 8080 bzw. 8081. Starten Sie die anwendungen Webapp und WebApiA. Kehren Sie nach der erfolgreichen Anmeldung zur Startseite zurück. Sie können dann auf http://localhost:8080/webapp/webApiA zugreifen, um die WebApiA Ressourcenantwort abzurufen.

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 Berechtigung hinzu, und erteilen Sie Der Administratorzustimmung für Ihre Webanwendung.

Fügen Sie der pom.xml Datei 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}

Anmerkung

Die für tenant-id zulässigen Werte sind: common, organizations, consumersoder die Mandanten-ID. Weitere Informationen zu diesen Werten finden Sie im Abschnitt Abschnitt Abschnitt Fehler-AADSTS50020 – Benutzerkonto des Identitätsanbieters ist nicht im Mandantenvorhanden. 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 5.x

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

Spring Cloud Azure 4.x

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfiguration extends WebSecurityConfigurerAdapter {

   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http.authorizeRequests((requests) -> requests.anyRequest().authenticated())
           .oauth2ResourceServer()
           .jwt()
               .jwtAuthenticationConverter(new AadJwtBearerTokenAuthenticationConverter());
   }
}

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

Verwendung 4: Ressourcenserver, der auf andere Ressourcenserver zugreift

Dieses Szenario ist ein Upgrade von Zugreifen auf einen Ressourcenserverund 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 Sie der Administratorzustimmung für WebApiB Berechtigungen.

Fügen Sie auf der Grundlage Zugreifen auf einen Ressourcenserverdie 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 Zugreifen auf einen Ressourcenserver Szenariokonfiguration 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 Ihren 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 Ihren 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 Zugreifen auf einen Ressourcenserver Szenario, eine weitere 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 Sie WebApiA und WebApiB8081 und 8082 ausführen. Starten Sie die WebApiA und WebApiB Anwendungen, rufen Sie das Zugriffstoken für webApiA Ressource ab, und greifen Sie als Bearer-Autorisierungsheader auf http://localhost:8081/webApiA/webApiB/sample zu.

Proben

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