Vorgehensweise: Verwenden des ACS-Verwaltungsdiensts zum Konfigurieren eines OpenID-Identitätsanbieters

Artikel
11/09/2015

Aktualisiert: 19. Juni 2015

Gilt für: Azure

Gilt für

Microsoft® Azure™ Access Control Service (ACS)
OpenID 2.0

Zusammenfassung

In diesem Thema werden die grundlegenden Schritte zum Hinzufügen von Identitätsanbieter beschrieben, die das OpenID-Protokoll unterstützen. OpenID-Identitätsanbieter können acS mithilfe des Verwaltungsdiensts hinzugefügt werden. OpenID-Identitätsanbieter können nicht mithilfe des ACS-Verwaltungsportals hinzugefügt werden. In diesem Thema verweisen wir auf die OpenID 2.0-Spezifikation, da dies die Spezifikationsversion ist, die ACS unterstützt.

Inhalte

Ziele
Übersicht
Zusammenfassung von Schritten
Schritt 1 – Erfassen von Konfigurationsinformationen
Schritt 2 – Hinzufügen von Verweisen zu den erforderlichen Diensten und Assemblys
Schritt 3 – Implementieren des Verwaltungsdienstclients
Schritt 4 – Hinzufügen eines Identitätsanbieters

Ziele

Identifizieren der erforderlichen Voraussetzungen und Konfigurationsinformationen.
Auflisten der zum Hinzufügen von OpenID als Identitätsanbieter erforderlichen Schritte.

Übersicht

Der Verwaltungsdienst ist ein Webdienst, der eine der wichtigsten Komponenten von ACS ist. Der Verwaltungsdienst stellt Funktionen zur Verfügung, die über die Verwaltungsportal-Benutzerschnittstelle zur Verfügung gestellt werden. Alle Aktionen, die im Verwaltungsportal ausgeführt werden können, können auch mithilfe des Verwaltungsdiensts ausgeführt werden. Das Hinzufügen von OpenID-Identitätsanbietern ACS ermöglicht es Ihnen, den Identitätsverwaltungsmechanismus der Internetskala zu entwickeln und zu verwalten. Sie müssen Code erstellen, der bestimmte Schritte berücksichtigt, um einen OpenID-Identitätsanbieter hinzufügen zu können. In diesem Thema werden diese grundlegenden Schritte beschrieben.

Zusammenfassung von Schritten

Schritt 1 – Erfassen von Konfigurationsinformationen
Schritt 2 – Hinzufügen von Verweisen zu den erforderlichen Diensten und Assemblys
Schritt 3 – Implementieren des Verwaltungsdienstclients
Schritt 4 – Hinzufügen eines Identitätsanbieters

Schritt 1 – Erfassen von Konfigurationsinformationen

In diesem Schritt werden die erforderlichen Konfigurationsinformationen identifiziert und deren Erfassung erläutert. Sie müssen die folgenden Informationen erfassen:

Benutzername der Verwaltungsdienstidentität – ManagementClient.
Kennwort der Verwaltungsdienstidentität – Gehen Sie folgendermaßen vor, um das Kennwort der Dienstidentität für den Verwaltungsdienst abzurufen:
1. Melden Sie sich beim Access Control Service-Verwaltungsportal an.
2. Klicken Sie im Abschnitt Verwaltung auf den Link Verwaltungsdienst.
3. Klicken Sie auf der Seite Verwaltungsdienst auf den Link ManagementClient (ManagementClient ist der tatsächliche Benutzername für den Dienst).
4. Klicken Sie im Abschnitt Anmeldeinformationen auf den Link Symmetrischer Schlüssel oder Kennwort. Der Wert ist in beiden Links identisch. Dies ist das Kennwort.
Der Namespace Ihres Diensts.
ACS-Hostname – Normalerweise accesscontrol.windows.net.

Nachdem Sie die erforderlichen Informationen erfasst haben, führen Sie die folgenden Schritte aus, um eine Beispielkonsolenanwendung zu erstellen, die den Code zum Hinzufügen des OpenID-Identitätsanbieters ausführt:

Öffnen Sie Visual Studio® 2010, und erstellen Sie dann ein neues Konsolenanwendungsprojekt.
Weisen Sie den Modulbereichsvariablen in der Klasse Program die zuvor erfassten Informationen mithilfe von Code zu, der dem folgenden ähnelt.

        static string serviceIdentityUsernameForManagement = "ManagementClient";
        static string serviceIdentityPasswordForManagement = "...update to your password...";

        static string serviceNamespace = "...update to your namespace...";
        static string acsHostName = "accesscontrol.windows.net";
        static string acsManagementServicesRelativeUrl = "v2/mgmt/service/";

        static string identityProviderName = "My Open ID Identity Provider";

        static string cachedSwtToken;

Schritt 2 – Hinzufügen von Verweisen zu den erforderlichen Diensten und Assemblys

In diesem Schritt werden die erforderlichen Abhängigkeiten identifiziert und den Diensten und Assemblys hinzugefügt.

So fügen Sie die erforderlichen Abhängigkeiten den Diensten und Assemblys hinzu

Fügen Sie einen Verweis auf System.Web.Extensions hinzu.
Fügen Sie dem Verwaltungsdienst einen Dienstverweis hinzu. Die Verwaltungsdienst-URL ist für Ihren Namespace eindeutig und ähnelt der folgenden URL:

https:// YOURNAMESPACE.accesscontrol.windows.net/v2/mgmt/service

Fügen Sie die folgenden Deklarationen hinzu.

using System.Web; 
using System.Net; 
using System.Data.Services.Client; 
using System.Collections.Specialized; 
using System.Web.Script.Serialization;
using System.Globalization;
using System.Runtime.Serialization.Json;
using ConsoleApplication1.ServiceReference1;

Beachten Sie die letzte Deklaration (ConsoleApplication1.ServiceReference1). Diese kann in Ihrem Fall anders lauten, wenn Sie beim Erstellen Ihrer Konsolenanwendung oder beim Hinzufügen des Verweises für den Verwaltungsdienst Standardeinstellungen geändert haben.

Schritt 3 – Implementieren des Verwaltungsdienstclients

In diesem Schritt wird eine Methode erstellt, die die Implementierung des Verwaltungsdienstclients verkapselt.

So implementieren Sie den Verwaltungsdienstclient

Fügen Sie der Program-Klasse die folgende Methode hinzu.

public static ManagementService CreateManagementServiceClient()
        {
            string managementServiceEndpoint = String.Format(CultureInfo.InvariantCulture, "https://{0}.{1}/{2}",
                serviceNamespace,
                acsHostName,
                acsManagementServicesRelativeUrl);
            ManagementService managementService = new ManagementService(new Uri(managementServiceEndpoint));

            managementService.SendingRequest += GetTokenWithWritePermission;

            return managementService;
        }

Implementieren Sie die Methode GetTokenWithWritePermission und deren Hilfsmethoden. Auf diese Weise wird das SWT OAuth-Token des Autorisierungsheaders der HTTP-Anforderung hinzugefügt.

public static void GetTokenWithWritePermission(object sender, SendingRequestEventArgs args)
        {
            GetTokenWithWritePermission((HttpWebRequest)args.Request);
        }

        public static void GetTokenWithWritePermission(HttpWebRequest args)
        {
            if (cachedSwtToken == null)
            {
                cachedSwtToken = GetTokenFromACS();
            }

            args.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + cachedSwtToken);
        }

        private static string GetTokenFromACS()
        {
            //
            // Request a token from ACS
            //
            WebClient client = new WebClient();
            client.BaseAddress = string.Format(CultureInfo.CurrentCulture, 
                                               "https://{0}.{1}", 
                                               serviceNamespace, 
                                               acsHostName);

            NameValueCollection values = new NameValueCollection();
            values.Add("grant_type", "client_credentials");
            values.Add("client_id", serviceIdentityUsernameForManagement);
            values.Add("client_secret", serviceIdentityPasswordForManagement);
            values.Add("scope", client.BaseAddress + acsManagementServicesRelativeUrl);

            byte[] responseBytes = client.UploadValues("/v2/OAuth2-13", "POST", values);

            string response = Encoding.UTF8.GetString(responseBytes);

            // Parse the JSON response and return the access token 
            JavaScriptSerializer serializer = new JavaScriptSerializer();

            Dictionary<string, object> decodedDictionary = serializer.DeserializeObject(response) as Dictionary<string, object>;

            return decodedDictionary["access_token"] as string;

        }

Schritt 4 – Hinzufügen eines Identitätsanbieters

In diesem Schritt wird ein OpenID-Identitätsanbieter mithilfe des zuvor erstellten Verwaltungsdienstclients hinzugefügt.

So fügen Sie einen OpenID-Identitätsanbieter hinzu

Initialisieren Sie die Methode Main, und initialisieren Sie dann den Verwaltungsdienstclient.
```
ManagementService svc = CreateManagementServiceClient();
```

Fügen Sie Ihren Identitätsanbieter als Aussteller hinzu.

            Issuer issuer = new Issuer
            {
                Name = identityProviderName
            };
            svc.AddToIssuers(issuer);
            svc.SaveChanges(SaveChangesOptions.Batch);

Erstellen Sie einen Identitätsanbieter.

            var openId = new IdentityProvider
            {
                DisplayName = identityProviderName,
                Description = identityProviderName,
                WebSSOProtocolType = "OpenId",
                IssuerId = issuer.Id
            };

            svc.AddObject("IdentityProviders", openId);

Aktualisieren Sie die Anmeldeadresse des Identitätsanbieters. In dieser Übung verwenden Sie www.myopenid.com als Anmeldeadresse. Andere OpenID-Identitätsanbieter sind z. B. Google und Yahoo!. Diese Anbieter verfügen über eigene Anmeldeadressen. Sie sind und https://open.login.yahooapis.com/openid/op/auth, je nachhttps://www.google.com/accounts/o8/ud.
```
            var openIdAddress = new IdentityProviderAddress
            {
                Address = "https://www.myopenid.com/server",
                EndpointType = "SignIn"
            };

            svc.AddRelatedObject(openId, "IdentityProviderAddresses", openIdAddress);
            svc.SaveChanges();
```

Stellen Sie den Identitätsanbieter für die vertrauende Seite mit Ausnahme des Verwaltungsdiensts bereit.

            foreach (RelyingParty rp in svc.RelyingParties)
            {
                // skip the built-in management RP. 
                if (rp.Name != "AccessControlManagement")
                {
                    svc.AddToRelyingPartyIdentityProviders(new RelyingPartyIdentityProvider()
                    {
                        IdentityProviderId = openId.Id,
                        RelyingPartyId = rp.Id
                    });
                }
            }

            svc.SaveChanges(SaveChangesOptions.Batch);

Share via