Vorgehensweise: Verwenden des ACS-Verwaltungsdiensts zum Konfigurieren von Regeln und Regelgruppen

  • Artikel

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-Regeln und Regelgruppen mithilfe des ACS-Verwaltungsportals (weitere Informationen finden Sie unter Regelgruppen und Regeln) oder dem ACS-Verwaltungsdienst konfigurieren. Das Arbeiten mit dem ACS-Verwaltungsdienst kann effizienter sein, wenn Sie eine benutzerdefinierte Benutzeroberfläche zum Verwalten von ACS erstellen oder wenn Sie das Onboarding eines neuen Mandanten für multimandanten Software as a Service -Lösungen (SaaS) automatisieren möchten.

Schritte zum Konfigurieren von Regeln und Regelgruppen mithilfe des ACS-Verwaltungsdiensts

Wichtig

Stellen Sie vor der Ausführung der folgenden Schritte 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 Regeln und Regelgruppen 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 Regelgruppe

  • Schritt 6 – Hinzufügen einer Regel

Schritt 1 – Erfassen der ACS-Konfigurationsinformationen

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

So erfassen Sie ACS-Konfigurationsinformationen

  1. Starten Sie das ACS-Verwaltungsportal. Weitere Informationen zum Starten des ACS-Verwaltungsportals finden Sie im ACS-Verwaltungsportal.

  2. 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 unter dem Abschnitt "Verwaltung " in der Struktur auf der linken Seite der Seite.

  3. Rufen Sie den Wert des ACS Management Service-Kontokennworts ab. Gehen Sie wie folgt vor, um diesen Wert anzuzeigen:

    1. Klicken Sie im ACS-Verwaltungsportal auf den Verwaltungsdienst unter dem 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.

  4. Rufen Sie den Namen Ihres Azure-Namespaces aus dem Azure-Portal oder aus der URL Ihres ACS-Verwaltungsportals ab. Beispielsweise http://contoso.accesscontrol.windows.netist der Name "contoso".

  5. Rufen Sie den ACS-Hostname 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

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

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

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

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

  3. Fügen Sie die folgenden Deklarationen hinzu. Dabei ist MyConsoleApplication der Name Ihrer Konsolenanwendung und MyServiceReference der Name Ihres Dienstverweises:

    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 MyConsoleApplication.MyServiceReference;

Schritt 4 – Implementieren des Verwaltungsdienstclients

In diesem Schritt implementieren Sie den Verwaltungsdienstclient.

So implementieren Sie den Verwaltungsdienstclient

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

  2. Fügen Sie der Klasse Program den folgenden Code hinzu, um die Methode GetTokenWithWritePermission und deren Hilfsmethoden zu erstellen. 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 Regelgruppe

In diesem Schritt fügen Sie eine Regelgruppe mithilfe des Verwaltungsdienstclients hinzu, den Sie in einem der vorherigen Schritte erstellt haben.

So fügen Sie eine Regelgruppe hinzu

  1. Initialisieren Sie den Verwaltungsdienstclient, indem Sie der Methode Main in der Klasse Program den folgenden Code hinzufügen:

    ManagementService svc = CreateManagementServiceClient();

  2. Fügen Sie Ihre neue Regelgruppe hinzu (Sie können diese "mygroup" 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:

    RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);

Schritt 6 – Hinzufügen einer Regel

In diesem Schritt fügen Sie eine Regel zur Regelgruppe hinzu, die Sie im vorherigen Schritt mithilfe des ACS-Verwaltungsdiensts erstellt haben.

So fügen Sie eine Regel hinzu

  1. Erstellen Sie eine Variable für "LOKALE BEHÖRDE", die einen integrierten Ausstellernamen darstellt, der Ihren Access Control Namespace-Namespace darstellt, indem Sie der Main-Methode in der Programmklasse den folgenden Code hinzufügen:

    // "LOCAL AUTHORITY" is a built-in IDP name that represents the Access Control namespace. 
Issuer localAuthority = svc.Issuers.Where(m => m.Name == "LOCAL AUTHORITY").FirstOrDefault();

  2. Führen Sie eines der folgenden Verfahren aus:

    1. Fügen Sie der Methode Main der Klasse Program den folgenden Code hinzu, um eine grundlegende Regel hinzuzufügen:

                  //EXAMPLE #1 - BASIC RULE
            Rule basicRule = new Rule()
            {
                InputClaimType = "https://acs/your-input-type",
                InputClaimValue = "inputValue",
                OutputClaimType = "https://acs/your-output-type",
                OutputClaimValue = "outputValue",
            };

            basicRule.Description = string.Format(CultureInfo.InvariantCulture,
                "Transforms claim from {0} with type: {1}, value: {2}, into a new claim with type: {3}, value:{4}",
                "ACS",
                basicRule.InputClaimType,
                basicRule.InputClaimValue,
                basicRule.OutputClaimType,
                basicRule.OutputClaimValue);

            svc.AddToRules(basicRule);
            svc.SetLink(basicRule, "RuleGroup", rg);
            svc.SetLink(basicRule, "Issuer", localAuthority);                                              
              svc.SaveChanges(SaveChangesOptions.Batch);

    2. Fügen Sie der Methode Main der Klasse Program den folgenden Code hinzu, um eine Regel hinzuzufügen, die einen bestimmten Eingabeanspruch und -wert ohne Änderungen an die Anwendung weiterleitet:

      //EXAMPLE #2 - PASS TYPE AND VALUE RULE
            Rule passSpecificClaimRule = new Rule()
            {
                InputClaimType = "https://acs/your-input-type2",
                InputClaimValue = "inputValue2",
            };

            passSpecificClaimRule.Description = string.Format(CultureInfo.InvariantCulture,
                "Passthough claim from {0} with type: {1}, value: {2}",
                "ACS",
                passSpecificClaimRule.InputClaimType,
                passSpecificClaimRule.InputClaimValue);

            svc.AddToRules(passSpecificClaimRule);
            svc.SetLink(passSpecificClaimRule, "RuleGroup", rg);
            svc.SetLink(passSpecificClaimRule, "Issuer", localAuthority); 
svc.SaveChanges(SaveChangesOptions.Batch);

    3. Fügen Sie der Methode Main der Klasse Program den folgenden Code hinzu, um eine Regel hinzuzufügen, die einen beliebigen Anspruch mit einem angegebenen Typ weiterleitet:

      //EXAMPLE #3 PASS SPECIFIC TYPE RULE
            Rule passAnyClaimSpecificTypeRule = new Rule()
            {
                InputClaimType = "https://acs/your-input-type3",
            };

            passAnyClaimSpecificTypeRule.Description = string.Format(CultureInfo.InvariantCulture,
                "Pass claim from {0} with type: {1}, and any value",
                "ACS",
                passSpecificClaimRule.InputClaimType);

            svc.AddToRules(passAnyClaimSpecificTypeRule);
            svc.SetLink(passAnyClaimSpecificTypeRule, "RuleGroup", rg);
            svc.SetLink(passAnyClaimSpecificTypeRule, "Issuer", localAuthority); 
svc.SaveChanges(SaveChangesOptions.Batch);

    4. Fügen Sie der Methode Main der Klasse Program den folgenden Code hinzu, um eine Regel hinzuzufügen, die einen beliebigen Anspruch mit einem angegebenen Wert weiterleitet:

      //EXAMPLE #4 PASS ANY CLAIM W/SPECIFIC VALUE RULE
            Rule passAnyClaimSpecificValueRule = new Rule()
            {
                InputClaimValue = "inputValue3",
            };

            passAnyClaimSpecificValueRule.Description = string.Format(CultureInfo.InvariantCulture,
                "Pass claim from {0} with any type, and specific value {1}",
                "ACS",
                passSpecificClaimRule.InputClaimValue);

            svc.AddToRules(passAnyClaimSpecificValueRule);
            svc.SetLink(passAnyClaimSpecificValueRule, "RuleGroup", rg);
            svc.SetLink(passAnyClaimSpecificValueRule, "Issuer", localAuthority); 
svc.SaveChanges(SaveChangesOptions.Batch);

    5. Fügen Sie der Methode Main der Klasse Program den folgenden Code hinzu, um eine Regel hinzuzufügen, die einen angegebenen Eingabeanspruchstyp in einen anderen Ausgabeanspruchstyp transformiert, den Anspruchswert jedoch nicht ändert:

      //EXAMPLE #5 COMPLEX RULE
            Rule complexTransformationRule = new Rule()
            {
                InputClaimType = "https://acs/your-input-type4",
                OutputClaimType = "https://acs/your-output-type2",
            };

            complexTransformationRule.Description = string.Format(CultureInfo.InvariantCulture,
                "Transforms claim from {0} with type: {1}, and any value, into a new claim with type: {2}, keeping(passingthough) old value",
                "ACS",
                complexTransformationRule.InputClaimType,
                complexTransformationRule.OutputClaimType);

            svc.AddToRules(complexTransformationRule);
            svc.SetLink(complexTransformationRule, "RuleGroup", rg);
            svc.SetLink(complexTransformationRule, "Issuer", localAuthority);

            svc.SaveChanges(SaveChangesOptions.Batch);

Weitere Informationen

Konzepte

ACS – Vorgehensweisen