Anvisningar: Använda ACS-hanteringstjänsten för att konfigurera regler och regelgrupper

Artikel
11/09/2015

Uppdaterad: 19 juni 2015

Gäller för: Azure

Gäller för

Microsoft Azure Active Directory Access Control (även kallat Access Control Service eller ACS)

Översikt

Du kan konfigurera ACS-regler och regelgrupper med hjälp av acs-hanteringsportalen (mer information finns i Regelgrupper och regler) eller ACS-hanteringstjänsten. Att arbeta med ACS Management Service kan vara mer effektivt om du skapar ett anpassat användargränssnitt för att hantera ACS eller om du vill automatisera registrering av en ny klientorganisation för SaaS-lösningar (Programvara som en tjänst för flera innehavare).

Steg för att konfigurera regler och regelgrupper med hjälp av ACS-hanteringstjänsten

Viktigt

Innan du utför följande steg kontrollerar du att systemet uppfyller alla .NET-ramverks- och plattformskrav som sammanfattas i ACS-krav.

Utför följande steg för att konfigurera regler och regelgrupper med hjälp av ACS-hanteringstjänsten:

Steg 1 – Samla in ACS-konfigurationsinformation
Steg 2 – Skapa ett exempelkonsolprogram
Steg 3 – Lägg till referenser till nödvändiga tjänster och sammansättningar
Steg 4 – Implementera hanteringstjänstklienten
Steg 5 – Lägg till en regelgrupp
Steg 6 – Lägg till en regel

Steg 1 – Samla in ACS-konfigurationsinformation

Du kan använda ACS-hanteringsportalen för att samla in nödvändig konfigurationsinformation. Mer information om hur du startar ACS-hanteringsportalen finns i ACS-hanteringsportalen.

Samla in ACS-konfigurationsinformation

Starta ACS-hanteringsportalen. Mer information om hur du startar ACS-hanteringsportalen finns i ACS-hanteringsportalen.
Hämta värdet för ACS-hanteringstjänstkontot. Du kan använda standardkontot ManagementClient . Om du vill visa det här värdet går du till ACS-hanteringsportalen och klickar på Hanteringstjänst under avsnittet Administration i trädet till vänster på sidan.
Hämta värdet för lösenordet för ACS Management Service-kontot. Om du vill visa det här värdet gör du följande:
1. I ACS-hanteringsportalen klickar du på Hanteringstjänst under avsnittet Administration i trädet till vänster på sidan.
2. På sidan Hanteringstjänst klickar du på HanteringKlient under Hanteringstjänstkonton.
3. Klicka på Lösenord under Autentiseringsuppgifter på sidan Redigera hanteringstjänstkonto.
4. På sidan Redigera hanteringsautentiseringsuppgifter kopierar du värdet i fältet Lösenord .
Hämta namnet på ditt Azure-namnområde från Azure Portal eller från URL:en för ACS-hanteringsportalen. I http://contoso.accesscontrol.windows.netär till exempel namnet contoso.
Hämta ACS-värdnamnet. Vanligtvis är det accesscontrol.windows.net.

Steg 2 – Skapa ett exempelkonsolprogram

I det här steget skapar du ett exempelkonsolprogram som kan köra koden för att lägga till dina ACS-regelgrupper och regler.

Skapa ett exempelkonsolprogram

Öppna Visual Studio 2012 och skapa ett nytt konsolprogramprojekt under den Windows installerade mallen.

Lägg till följande kod i klassen Program och tilldela sedan variablerna serviceIdentityPasswordForManagement, serviceNamespace och acsHostName till lämplig konfigurationsinformation som du samlade in i föregående steg.

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;

Steg 3 – Lägg till referenser till nödvändiga tjänster och sammansättningar

I det här steget identifierar och lägger du till nödvändiga beroenden i tjänsterna och sammansättningarna.

Lägga till nödvändiga beroenden i tjänsterna och sammansättningarna

Högerklicka på Referenser, klicka på Lägg till referens och lägg till en referens till System.Web.Extensions.

Anteckning

Du kan behöva högerklicka på exempelkonsolens programnamn i Solution Explorer, välja Egenskaper och ändra målramverket för exempelprogrammet från .NET Framework 4 Klientprofil (tilldelad som standard när du skapar ett nytt konsolprogram) till .NET Framework 4.
Högerklicka på Tjänstreferenser, klicka på Lägg till tjänstreferens och lägg till en tjänstreferens till hanteringstjänsten. Url:en för hanteringstjänsten är unik för ditt namnområde och ser ut ungefär så här:

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

Lägg till följande deklarationer, där MyConsoleApplication är namnet på konsolprogrammet och MyServiceReference är namnet på tjänstreferensen:

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;

Steg 4 – Implementera hanteringstjänstklienten

I det här steget implementerar du Management Service-klienten.

Implementera hanteringstjänstklienten

Lägg till följande metod i klassen 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;
        }

Lägg till följande kod i klassen Program för att skapa metoden GetTokenWithWritePermission och dess hjälpmetoder. GetTokenWithWritePermission och dess hjälpanvändare lägger till SWT OAuth-token i auktoriseringshuvudet för HTTP-begäran.

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;

        }

Steg 5 – Lägg till en regelgrupp

I det här steget lägger du till en regelgrupp med hjälp av hanteringstjänstklienten som du skapade i steget ovan.

Lägga till en regelgrupp

Initiera hanteringstjänstklienten genom att lägga till följande kod i Main-metoden i klassen Program :
```
ManagementService svc = CreateManagementServiceClient();
```
Lägg till den nya regelgruppen (du kan kalla den "mygroup", som du ser i koden nedan) och spara ändringarna genom att lägga till följande kod i Main-metoden i klassen Program :
```
RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);
```

Steg 6 – Lägg till en regel

I det här steget lägger du till en regel i regelgruppen som du skapade i föregående steg med hjälp av ACS-hanteringstjänsten.

Lägga till en regel

Upprätta en variabel för "LOCAL AUTHORITY", som är ett inbyggt utfärdarnamn som representerar namnområdet för Access Control namnområde genom att lägga till följande kod i main-metoden i klassen 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();
```

Gör något av följande:

Lägg till en grundläggande regel genom att lägga till följande kod i Main-metoden i klassen 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);

Om du vill lägga till en regel som skickar ett visst indataanspråk och ett visst värde till programmet utan ändringar lägger du till följande kod i main-metoden i klassen 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);

Om du vill lägga till en regel som skickar anspråk med en angiven typ lägger du till följande kod i Main-metoden i klassen 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);

Om du vill lägga till en regel som skickar indataanspråk med ett angivet värde lägger du till följande kod i main-metoden i klassen 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);

Om du vill lägga till en regel som omvandlar en angiven typ av indataanspråk till en annan utdataanspråkstyp, men inte ändrar anspråksvärdet, lägger du till följande kod i Main-metoden i klassen 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);

Se även

Begrepp

ACS Så här gör du

Dela via