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

Artikel
11/09/2015

Bijgewerkt: 19 juni 2015

Van toepassing op: Azure

Van toepassing op

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

Overzicht

U kunt ACS-regels en -regelgroepen configureren met behulp van de ACS-beheerportal (zie regelgroepen en regels) of de ACS-beheerservice voor meer informatie. Het werken met de ACS Management Service kan efficiënter zijn als u een aangepaste gebruikersinterface bouwt voor het beheren van ACS of als u de onboarding van een nieuwe tenant voor SaaS-oplossingen (Software as a Service) met meerdere tenants wilt automatiseren.

Stappen voor het configureren van regels en regelgroepen met behulp van de ACS-beheerservice

Belangrijk

Voordat u de volgende stappen uitvoert, moet u ervoor zorgen dat uw systeem voldoet aan alle vereisten voor .NET Framework en platform die worden samengevat in ACS-vereisten.

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

Stap 1: ACS-configuratiegegevens verzamelen
Stap 2: een voorbeeldconsoletoepassing maken
Stap 3: Verwijzingen toevoegen aan de vereiste services en assembly's
Stap 4: de Beheerserviceclient implementeren
Stap 5: een regelgroep toevoegen
Stap 6: een regel toevoegen

Stap 1: ACS-configuratiegegevens verzamelen

U kunt de ACS-beheerportal gebruiken om de benodigde configuratiegegevens te verzamelen. Zie de ACS-beheerportal voor meer informatie over het starten van de ACS-beheerportal.

ACS-configuratiegegevens verzamelen

Start de ACS-beheerportal. Zie de ACS-beheerportal voor meer informatie over het starten van de ACS-beheerportal.
Haal de waarde van het ACS-beheerserviceaccount op. U kunt het standaard ManagementClient-account gebruiken. Als u deze waarde wilt weergeven, klikt u in de ACS-beheerportal op Beheerservice onder de sectie Beheer in de structuur aan de linkerkant van de pagina.
Haal de waarde op van het wachtwoord van het ACS Management Service-account. Ga als volgt te werk om deze waarde weer te geven:
1. Klik in de ACS-beheerportal op Beheerservice onder de sectie Beheer in de structuur aan de linkerkant van de pagina.
2. Klik op de pagina Beheerservice op ManagementClient onder Beheerserviceaccounts.
3. Klik op de pagina Beheerserviceaccount bewerken onder Referenties op Wachtwoord.
4. Kopieer op de pagina Referenties voor beheer 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-beheerportal. De http://contoso.accesscontrol.windows.netnaam is bijvoorbeeld contoso.
Haal de ACS-hostnaam op. Meestal is het accesscontrol.windows.net.

Stap 2: een voorbeeldconsoletoepassing maken

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

Een voorbeeldconsoletoepassing maken

Open Visual Studio 2012 en maak een nieuw consoletoepassingsproject onder de Windows geïnstalleerde sjabloon.

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: Verwijzingen toevoegen aan de vereiste services en assembly's

In deze stap identificeert en voegt u de vereiste afhankelijkheden 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 aan System.Web.Extensions.

Notitie

Mogelijk moet u in de Solution Explorer met de rechtermuisknop op de naam van de voorbeeldconsoletoepassing klikken, Eigenschappen selecteren en het doelframework van uw voorbeeldtoepassing wijzigen van .NET Framework 4-clientprofiel (standaard toegewezen wanneer u een nieuwe consoletoepassing maakt) naar .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 managementservice is uniek voor uw naamruimte en ziet er ongeveer als volgt uit:

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

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

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: de Beheerserviceclient implementeren

In deze stap implementeert u 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 helpermethoden te maken. GetTokenWithWritePermission en de bijbehorende helpers voegen het SWT OAuth-token toe aan de autorisatieheader van de HTTP-aanvraag.

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 main-methode in de klasse Program :
```
ManagementService svc = CreateManagementServiceClient();
```
Voeg uw nieuwe regelgroep toe (u kunt deze 'mygroup' noemen, zoals wordt weergegeven in de onderstaande code) en sla wijzigingen op door de volgende code toe te voegen aan de main-methode in de klasse Program :
```
RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);
```

Stap 6: een regel toevoegen

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 verlener die de naamruimte van uw Access Control naamruimte vertegenwoordigt, door de volgende code toe te voegen aan de main-methode in de klasse Program:
```
// "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();
```

Voer een van de volgende handelingen uit:

Als u een basisregel wilt toevoegen, voegt u de volgende code toe aan de main-methode in de klasse Program :

            //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 doorgeeft aan de toepassing zonder wijzigingen, voegt u de volgende code toe aan de main-methode in de klasse Program :

//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 main-methode in de klasse Program :

//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 waarmee een invoerclaim met een opgegeven waarde wordt doorgegeven, voegt u de volgende code toe aan de main-methode in de klasse Program :

//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 transformeert naar een ander uitvoerclaimtype, maar de claimwaarde niet wijzigt, voegt u de volgende code toe aan de main-methode in de klasse Program :

//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-procedures

Share via