Procedure: ACS Management Service gebruiken om regels en regelgroepen te configureren

2015-11-09

Bijgewerkt: 19 juni 2015

Van toepassing op: Azure

Van toepassing op

Microsoft Azure Active Directory Access Control (ook wel Access Control Service of ACS genoemd)

Overzicht

U kunt ACS-regels en regelgroepen configureren met behulp van de ACS Management Portal (zie Regelgroepen en regels voor meer informatie) of de ACS Management Service. Werken met de ACS Management Service kan efficiënter zijn als u een aangepaste gebruikersinterface bouwt voor het beheer van ACS of als u de onboarding van een nieuwe tenant voor multi-tenant Software as a Service (SaaS)-oplossingen wilt automatiseren.

Stappen voor het configureren van regels en regelgroepen met behulp van de ACS Management Service

Belangrijk

Voordat u de volgende stappen uitvoert, moet u ervoor zorgen dat uw systeem voldoet aan alle .NET-framework- en platformvereisten die zijn samengevat in ACS-vereisten.

Voer de volgende stappen uit om regels en regelgroepen te configureren met behulp van de ACS Management Service:

Stap 1 - Verzamel ACS-configuratie-informatie
Stap 2 – Maak een voorbeeld van een console-applicatie
Stap 3 – Voeg verwijzingen toe naar de vereiste diensten en samenstellingen
Stap 4 – Implementeer de Management Service Client
Stap 5 – Een regelgroep toevoegen
Stap 6 – Voeg een regel toe

Stap 1 - Verzamel ACS-configuratie-informatie

U kunt de ACS Management Portal gebruiken om de benodigde configuratie-informatie te verzamelen. Voor meer informatie over het starten van het ACS Management Portal, zie ACS Management Portal.

ACS-configuratie-informatie verzamelen

Start het ACS Management Portal. Voor meer informatie over het starten van het ACS Management Portal, zie ACS Management Portal.
Haal de waarde op van het ACS-beheerserviceaccount. U kunt het standaard ManagementClient account gebruiken. Als u deze waarde wilt weergeven, klikt u in de ACS Management Portal op Beheerservice onder de sectie Beheer in de boom aan de linkerkant van de pagina.
Haal de waarde van het wachtwoord van het ACS Management Service-account op. Ga als volgt te werk om deze waarde weer te geven:
1. Klik in de ACS Management Portal op Beheerservice onder de sectie Beheer in de boom aan de linkerkant van de pagina.
2. Klik op de pagina Beheerservice op ManagementClient onder Serviceaccounts beheren.
3. Klik op de pagina Beheerserviceaccount bewerken onder Referenties op Wachtwoord.
4. Kopieer op de pagina Beheerreferenties bewerken de waarde in het veld Wachtwoord .
Haal de naam van uw Azure-naamruimte op uit de Azure Portal of uit de URL van uw ACS Management Portal. In http://contoso.accesscontrol.windows.netis de naam bijvoorbeeld contoso.
Haal de ACS-hostnaam op. Meestal is het accesscontrol.windows.net.

Stap 2 – Maak een voorbeeld van een console-applicatie

In deze stap maakt u een voorbeeldconsoletoepassing die de code kan uitvoeren voor het toevoegen van uw ACS-regelgroepen en -regels.

Een voorbeeldconsole-toepassing maken

Open Visual Studio 2012 en maak een nieuw consoletoepassingsproject onder de sjabloon Geïnstalleerd door Windows .

Voeg de volgende code toe aan de klasse Program en wijs vervolgens de variabelen serviceIdentityPasswordForManagement, serviceNamespace en acsHostName toe aan de juiste configuratiegegevens die u in de vorige stap hebt verzameld.

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;

Stap 3 – Voeg verwijzingen toe naar de vereiste diensten en samenstellingen

In deze stap identificeert u de vereiste afhankelijkheden en voegt u deze toe aan de services en assembly's.

De vereiste afhankelijkheden toevoegen aan de services en assembly's

Klik met de rechtermuisknop op Verwijzingen, klik op Verwijzing toevoegen en voeg een verwijzing toe naar System.Web.Extensions.

Opmerking

Mogelijk moet u met de rechtermuisknop op de naam van uw voorbeeldconsoletoepassing klikken in de Solution Explorer, Eigenschappen selecteren en het doelframework van uw voorbeeldtoepassing wijzigen van .NET Framework 4-clientprofiel (standaard toegewezen wanneer u een nieuwe consoletoepassing maakt) in .NET Framework 4.
Klik met de rechtermuisknop op Serviceverwijzingen, klik op Serviceverwijzing toevoegen en voeg een serviceverwijzing toe aan de beheerservice. De URL van de beheerservice is uniek voor uw naamruimte en ziet er ongeveer als volgt uit:

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

Voeg de volgende declaraties toe, waarbij MyConsoleApplication de naam van uw console-applicatie is en MyServiceReference de naam van uw servicereferentie:

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;

Stap 4 – Implementeer de Management Service Client

In deze stap implementeer je de Management Service client.

De Management Service-client implementeren

Voeg de volgende methode toe aan de klasse Program:

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

Voeg de volgende code toe aan de klasse Program om de methode GetTokenWithWritePermission en de bijbehorende hulpmethoden te maken. GetTokenWithWritePermission en zijn helpers voegen het SWT OAuth-token toe aan de autorisatieheader van het HTTP-verzoek.

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;

        }

Stap 5 – Een regelgroep toevoegen

In deze stap voegt u een regelgroep toe met behulp van de Management Service-client die u in de bovenstaande stap hebt gemaakt.

Een regelgroep toevoegen

Initialiseer de Management Service-client door de volgende code toe te voegen aan de hoofdmethode in de programmaklasse :
```
ManagementService svc = CreateManagementServiceClient();
```
Voeg uw nieuwe regelgroep toe (u kunt deze "mijngroep" noemen, zoals weergegeven in de onderstaande code) en sla de wijzigingen op door de volgende code toe te voegen aan de hoofdmethodein de programmaklasse:
```
RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);
```

Stap 6 – Voeg een regel toe

In deze stap voegt u een regel toe aan de regelgroep die u in de vorige stap hebt gemaakt met behulp van de ACS Management Service.

Een regel toevoegen

Stel een variabele in voor 'LOCAL AUTHORITY', een ingebouwde naam van de uitgever die uw naamruimte voor toegangsbeheer vertegenwoordigt, door de volgende code toe te voegen aan de hoofdmethode in de klasse Programma :
```
// "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();
```

Ga op een van de volgende manieren te werk:

Als u een basisregel wilt toevoegen, voegt u de volgende code toe aan de methode Main in de klasse Programma :

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

Als u een regel wilt toevoegen die een bepaalde invoerclaim en -waarde zonder wijzigingen aan de toepassing doorgeeft, voegt u de volgende code toe aan de methode Main in de klasse Programma :

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

Als u een regel wilt toevoegen die een claim met een opgegeven type doorgeeft, voegt u de volgende code toe aan de methode Main in de klasse Programma :

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

Als u een regel wilt toevoegen die een invoerclaim met een opgegeven waarde doorgeeft, voegt u de volgende code toe aan de hoofdmethode in de klasse Programma :

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

Als u een regel wilt toevoegen die een opgegeven invoerclaimtype omzet in een ander uitvoerclaimtype, maar de claimwaarde niet wijzigt, voegt u de volgende code toe aan de Main-methode in de Programmaklasse :

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

Zie ook

Concepten

ACS Hoe werkt het?

Delen via