Vorgehensweise: Verwenden des ACS-Verwaltungsdiensts zum Konfigurieren von Anwendungen für vertrauende Parteien

Artikel
11/09/2015

Aktualisiert: 19. Juni 2015

Gilt für: Azure

Gilt für

Zugriffssteuerung für Microsoft Azure Active Directory (auch Zugriffssteuerungsdienst oder ACS)

Übersicht

Sie können ACS-Anwendungen mit dem ACS-Verwaltungsportal konfigurieren (weitere Informationen finden Sie unter "Anwendungen für vertrauende Parteien") oder den ACS-Verwaltungsdienst. Das Arbeiten mit dem ACS-Verwaltungsdienst kann effizienter sein, wenn Sie eine benutzerdefinierte Benutzeroberfläche für die Verwaltung von ACS erstellen oder das Onboarding eines neuen Mandanten für Mehrmandantensoftware as a Service-Lösungen (SaaS) automatisieren möchten.

Schritte zum Konfigurieren von Anwendungen der vertrauenden Seite mithilfe des ACS-Verwaltungsdiensts

Wichtig

Bevor Sie die folgenden Schritte ausführen, stellen Sie sicher, dass Ihr System alle .NET Framework- und Plattformanforderungen erfüllt, die in ACS-Voraussetzungen zusammengefasst sind.

Führen Sie die folgenden Schritte aus, um Anwendungen von vertrauenden Parteien mithilfe des ACS-Verwaltungsdiensts zu konfigurieren:

Schritt 1 – Erfassen der ACS-Konfigurationsinformationen
Schritt 2 – Erstellen einer Konsolenbeispielanwendung
Schritt 3 – Hinzufügen von Verweisen auf die erforderlichen Dienste und Assemblys
Schritt 4 – Implementieren des Verwaltungsdienstclients
Schritt 5 – Hinzufügen einer Anwendung für vertrauende Parteien

Schritt 1 – Erfassen der ACS-Konfigurationsinformationen

Sie können das ACS-Verwaltungsportal verwenden, um die erforderlichen Konfigurationsinformationen zu erfassen. Weitere Informationen zum Starten des ACS-Verwaltungsportals finden Sie im ACS-Verwaltungsportal.

So erfassen Sie ACS-Konfigurationsinformationen

Starten Sie das ACS-Verwaltungsportal. Weitere Informationen zum Starten des ACS-Verwaltungsportals finden Sie im ACS-Verwaltungsportal.
Rufen Sie den Wert des ACS-Verwaltungsdienstkontos ab. Sie können das Standardkonto ManagementClient verwenden. Um diesen Wert anzuzeigen, klicken Sie im ACS-Verwaltungsportal auf den Verwaltungsdienst im Abschnitt "Verwaltung " in der Struktur auf der linken Seite der Seite.
Rufen Sie den Wert des ACS-Verwaltungsdienstkontokennworts ab. Gehen Sie wie folgt vor, um diesen Wert anzuzeigen:
1. Klicken Sie im ACS-Verwaltungsportal auf den Verwaltungsdienst im Abschnitt "Verwaltung " in der Struktur auf der linken Seite der Seite.
2. Klicken Sie auf der Seite Verwaltungsdienst unter Verwaltungsdienstkonten auf ManagementClient.
3. Klicken Sie auf der Seite Verwaltungsdienstkonto bearbeiten unter Anmeldeinformationen auf Kennwort.
4. Kopieren Sie auf der Seite Verwaltungsanmeldeinformationen bearbeiten den Wert im Feld Kennwort.
Rufen Sie den Namen Ihres Azure-Namespace ab. Sie können diesen Wert aus dem Azure-Portal oder aus der URL Ihres ACS-Verwaltungsportals abrufen. Beispielsweise ist der Namespacename " http://contoso.accesscontrol.windows.netcontoso".
Rufen Sie den ACS-Hostnamen ab. Normalerweise lautet dieser accesscontrol.windows.net.

Schritt 2 – Erstellen einer Konsolenbeispielanwendung

In diesem Schritt erstellen Sie eine Beispielkonsolenanwendung, die den Code zum Hinzufügen Ihrer ACS-Regelgruppen und -regeln ausführen kann.

So erstellen Sie eine Konsolenbeispielanwendung

Öffnen Sie Visual Studio 2012, und erstellen Sie ein neues Konsolenanwendungsprojekt unter der Windows installierten Vorlage.

Fügen Sie der Klasse Program den folgenden Code hinzu, und weisen Sie dann die Variablen serviceIdentityPasswordForManagement, serviceNamespace und acsHostName den entsprechenden Konfigurationsinformationen zu, die Sie im vorherigen Schritt erfasst haben.

public const string serviceIdentityUsernameForManagement = "ManagementClient";
public const string serviceIdentityPasswordForManagement = "My Password/Key for ManagementClient";
public const string serviceNamespace = "MyNameSpaceNoDots";
public const string acsHostName = "accesscontrol.windows.net";
public const string acsManagementServicesRelativeUrl = "v2/mgmt/service/";
static string cachedSwtToken;

Schritt 3 – Hinzufügen von Verweisen auf die erforderlichen Dienste und Assemblys

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

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

Klicken Sie mit der rechten Maustaste auf Verweise, klicken Sie auf Verweis hinzufügen, und fügen Sie dann einen Verweis auf System.Web.Extensions hinzu.

Hinweis

Ggf. müssen Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Namen Ihrer Konsolenbeispielanwendung klicken, Eigenschaften auswählen, und dann das Zielframework Ihrer Beispielanwendung von .NET Framework 4-Clientprofil (dieser Wert wird standardmäßig zugewiesen, wenn Sie eine neue Konsolenanwendung erstellen) in .NET Framework 4 ändern.
Klicken Sie mit der rechten Maustaste auf Dienstverweise, klicken Sie auf Dienstverweis hinzufügen, und fügen Sie dem Verwaltungsdienst dann 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. Dabei ist MyConsoleApplication der Name Ihrer Konsolenanwendung:

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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.Security.Cryptography;
using System.Security.Cryptography.X509Certificates; 
using MyConsoleApplication.MyServiceReference;

Schritt 4 – Implementieren des Verwaltungsdienstclients

In diesem Schritt implementieren Sie den Verwaltungsdienstclient.

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

Fügen Sie die Methode GetTokenWithWritePermission und deren Hilfsmethoden der Klasse Program hinzu. GetTokenWithWritePermission und deren Hilfsmethoden fügen das SWT OAuth-Token des Autorisierungsheaders der HTTP-Anforderung hinzu.

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 5 – Hinzufügen einer Anwendung für vertrauende Parteien

In diesem Schritt erstellen Sie eine Beispielanwendung für vertrauende Parteien mit einem SAML 2.0-Tokenformat (Standardoption), keine Tokenverschlüsselungsrichtlinie (Standardoption), die einem Identitätsanbieter für Windows Live ID (Microsoft-Konto) zugeordnet ist (Standardoption), 600 Sekunden tokenlebensdauer (Standardoption) und entweder ein benutzerdefiniertes X.509-Tokensignaturzertifikat für Ihre vertrauende Parteianwendung oder ein Tokensignaturzertifikat für die Access Control Namespace.

So fügen Sie eine Anwendung mit einem Access Control Namespacetokensignaturzertifikat hinzu

Initialisieren Sie den Verwaltungsdienstclient, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:
```
ManagementService svc = CreateManagementServiceClient();
```

Fügen Sie Ihre neue Anwendung der vertrauenden Seite hinzu (Sie können diese "MyRelyingPartyApplication" nennen, wie im Code unten gezeigt), und speichern Sie dann die Änderungen, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:

Hinweis

Ersetzen Sie "Full path to your .PFX file" im Code unten durch den gültigen vollständigen Pfad zu Ihrem X.509-Zertifikat. Wenn beispielsweise ein Zertifikat namens ACS2ClientCertificate.cer unter C:gespeichert wird, lautet der richtige Wert "C:\ ACS2ClientCertificate.cer".

Ersetzen Sie "MyCertificatePassword" im Code unten durch das richtige Kennwort für Ihr X.509-Zertifikat.

            //Create Relying Party Application

            RelyingParty relyingParty = new RelyingParty()
            {
                Name = "MyRelyingPartyApplication",
                AsymmetricTokenEncryptionRequired = false,
                TokenType = "SAML_2_0",
                TokenLifetime = 3600
            };

            svc.AddToRelyingParties(relyingParty);


            //Create the Realm Address

            RelyingPartyAddress realmAddress = new RelyingPartyAddress()
            {
                Address = "http://TestRelyingParty.com/Realm",
                EndpointType = "Realm"
            };

            svc.AddRelatedObject(relyingParty, "RelyingPartyAddresses", realmAddress);

            //Create the Return URL Address

            RelyingPartyAddress replyAddress = new RelyingPartyAddress()
            {
                Address = "http://TestRelyingParty.com/Reply",
                EndpointType = "Reply"
            };

            svc.AddRelatedObject(relyingParty, "RelyingPartyAddresses", replyAddress);

          // Create a Rule Group for This Relying Party Application

            RuleGroup rg = new RuleGroup();
            rg.Name = "SampleRuleGroup For " + relyingParty.Name;
            svc.AddToRuleGroups(rg);

            // Assign This New Rule Group to Your New Relying Party Application

            RelyingPartyRuleGroup relyingPartyRuleGroup = new RelyingPartyRuleGroup();

            svc.AddToRelyingPartyRuleGroups(relyingPartyRuleGroup);
            svc.AddLink(relyingParty, "RelyingPartyRuleGroups", relyingPartyRuleGroup);
            svc.AddLink(rg, "RelyingPartyRuleGroups", relyingPartyRuleGroup);


            //Save Your New Relying Party Application

            svc.SaveChanges(SaveChangesOptions.Batch);

So fügen Sie eine Anwendung der vertrauenden Seite mit einem fest zugeordneten Tokensignaturzertifikat hinzu

Initialisieren Sie den Verwaltungsdienstclient, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:
```
ManagementService svc = CreateManagementServiceClient();
```

Erstellen Sie eine Hilfsfunktion ReadBytesFromPfxFile , um Bytes aus Ihrem X.509-Zertifikat zu lesen, indem Sie der Programmklasse den folgenden Code hinzufügen:

//Helper Function to Read Bytes from Your .pfx file

        public static byte[] ReadBytesFromPfxFile(string pfxFileName, string protectionPassword)
        {
            byte[] signingCertificate;
            using (FileStream stream = File.OpenRead(pfxFileName))
            {
                using (BinaryReader br = new BinaryReader(stream))
                {
                    signingCertificate = br.ReadBytes((int)stream.Length);
                }
            }

            return signingCertificate;
        }