Útmutató: Szabályok és szabálycsoportok konfigurálása az ACS felügyeleti szolgáltatással

Cikk
11/09/2015

Frissítve: 2015. június 19.

Érintett kiadások: Azure

Érvényesség

Microsoft Azure Active Directory Access Control (más néven Access Control Service vagy ACS)

Áttekintés

Az ACS-szabályokat és -szabálycsoportokat az ACS felügyeleti portálon (további információ: Szabálycsoportok és szabályok) vagy az ACS felügyeleti szolgáltatással konfigurálhatja. Az ACS felügyeleti szolgáltatás használata hatékonyabb lehet, ha egyéni felhasználói felületet hoz létre az ACS kezeléséhez, vagy ha automatizálni szeretné egy új bérlő előkészítését a több-bérlős szolgáltatott szoftver (SaaS) megoldásokhoz.

Szabályok és szabálycsoportok konfigurálásának lépései az ACS felügyeleti szolgáltatással

Fontos

A következő lépések végrehajtása előtt győződjön meg arról, hogy a rendszer megfelel az ACS-előfeltételekben összefoglalt .NET-keretrendszer- és platformkövetelményeknek.

Ha szabályokat és szabálycsoportokat szeretne konfigurálni az ACS felügyeleti szolgáltatással, hajtsa végre a következő lépéseket:

1. lépés – Az ACS konfigurációs adatainak összegyűjtése
2. lépés – Minta konzolalkalmazás létrehozása
3. lépés – Hivatkozások hozzáadása a szükséges szolgáltatásokhoz és szerelvényekhez
4. lépés – A felügyeleti szolgáltatásügyfél implementálása
5. lépés – Szabálycsoport hozzáadása
6. lépés – Szabály hozzáadása

1. lépés – Az ACS konfigurációs adatainak összegyűjtése

Az ACS felügyeleti portálján összegyűjtheti a szükséges konfigurációs adatokat. Az ACS felügyeleti portál elindításával kapcsolatos további információkért lásd az ACS felügyeleti portálját.

Az ACS konfigurációs adatainak összegyűjtése

Indítsa el az ACS felügyeleti portált. Az ACS felügyeleti portál elindításával kapcsolatos további információkért lásd az ACS felügyeleti portálját.
Kérje le az ACS felügyeleti szolgáltatásfiók értékét. Használhatja az alapértelmezett ManagementClient-fiókot . Ennek az értéknek a megtekintéséhez az ACS felügyeleti portálon kattintson az oldal bal oldalán található fa Felügyelet szakaszának Felügyeletiszolgáltatás elemére.
Kérje le az ACS management szolgáltatásfiók jelszavának értékét. Az érték megtekintéséhez tegye a következőket:
1. Az ACS felügyeleti portálon kattintson a Felügyeleti szolgáltatás elemre az oldal bal oldalán található fa Adminisztráció szakaszában.
2. A Felügyeleti szolgáltatás lapon kattintson a Felügyeleti szolgáltatásfiókok területen a ManagementClient elemre.
3. A Felügyeleti szolgáltatásfiók szerkesztése lap Hitelesítő adatok területén kattintson a Jelszó elemre.
4. Az Edit Management Credential (Kezelés hitelesítő adatainak szerkesztése ) lapon másolja ki az értéket a Jelszó mezőbe.
Kérje le az Azure-névtér nevét az Azure Portal vagy az ACS felügyeleti portál URL-címéről. Ebben a példában http://contoso.accesscontrol.windows.neta név contoso.
Kérje le az ACS-állomásnevet. Általában accesscontrol.windows.net.

2. lépés – Minta konzolalkalmazás létrehozása

Ebben a lépésben létrehoz egy minta konzolalkalmazást, amely futtathatja az ACS-szabálycsoportok és -szabályok hozzáadására szolgáló kódot.

Minta konzolalkalmazás létrehozása

Nyissa meg Visual Studio 2012-t, és hozzon létre egy új konzolalkalmazás-projektet a Windows telepített sablon alatt.

Adja hozzá a következő kódot a Program osztályhoz, majd rendelje hozzá a serviceIdentityPasswordForManagement, serviceNamespace és acsHostName változókat az előző lépésben összegyűjtött konfigurációs információkhoz.

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;

3. lépés – Hivatkozások hozzáadása a szükséges szolgáltatásokhoz és szerelvényekhez

Ebben a lépésben azonosítja és hozzáadja a szükséges függőségeket a szolgáltatásokhoz és szerelvényekhez.

A szükséges függőségek hozzáadása a szolgáltatásokhoz és szerelvényekhez

Kattintson a jobb gombbal a Hivatkozások elemre, kattintson a Hivatkozás hozzáadása parancsra, és adjon hozzá egy hivatkozást a System.Web.Extensions fájlhoz.

Megjegyzés

Előfordulhat, hogy a jobb gombbal a konzolalkalmazás nevére kell kattintania a Megoldáskezelő, ki kell választania a Tulajdonságok lehetőséget, és módosítania kell a mintaalkalmazás célkeretét .NET-keretrendszer 4 ügyfélprofilról (új konzolalkalmazás létrehozásakor alapértelmezés szerint hozzá van rendelve) a 4. .NET-keretrendszer értékre.
Kattintson a jobb gombbal a Szolgáltatáshivatkozások elemre, kattintson a Szolgáltatáshivatkozás hozzáadása parancsra, és adjon hozzá egy szolgáltatáshivatkozást a felügyeleti szolgáltatáshoz. A felügyeleti szolgáltatás URL-címe egyedi a névtérben, és az alábbihoz hasonlóan néz ki:

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

Adja hozzá a következő deklarációkat, ahol a MyConsoleApplication a konzolalkalmazás neve, a MyServiceReference pedig a szolgáltatáshivatkozás neve:

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;

4. lépés – A felügyeleti szolgáltatásügyfél implementálása

Ebben a lépésben implementálja a felügyeleti szolgáltatás ügyfelét.

A felügyeleti szolgáltatásügyfél megvalósítása

Adja hozzá a Program osztályhoz a következő módszert:

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

Adja hozzá a következő kódot a Program osztályhoz a GetTokenWithWritePermission metódus és segédmetódusainak létrehozásához. A GetTokenWithWritePermission és segítői hozzáadják az SWT OAuth-jogkivonatot a HTTP-kérés engedélyezési fejlécéhez.

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;

        }

5. lépés – Szabálycsoport hozzáadása

Ebben a lépésben hozzáad egy szabálycsoportot a fenti lépésben létrehozott felügyeleti szolgáltatásügyféllel.

Szabálycsoport hozzáadása

Inicializálja a felügyeleti szolgáltatás ügyfelét, ha hozzáadja a következő kódot a Main metódushoz a Program osztályban:
```
ManagementService svc = CreateManagementServiceClient();
```
Adja hozzá az új szabálycsoportot (nevezheti "mygroup"-nak, ahogy az az alábbi kódban látható), és mentse a módosításokat úgy, hogy hozzáadja a következő kódot a Program osztály Main metódusához:
```
RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);
```

6. lépés – Szabály hozzáadása

Ebben a lépésben egy szabályt ad hozzá az előző lépésben létrehozott szabálycsoporthoz az ACS felügyeleti szolgáltatással.

Szabály hozzáadása

Hozzon létre egy változót a "LOCAL AUTHORITY" számára, amely egy beépített kiállítónév, amely a Access Control névtér névterét jelöli. Ehhez adja hozzá a következő kódot a Program osztály Main metódusához:
```
// "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();
```

Tegye a következők egyikét:

Alapszintű szabály hozzáadásához adja hozzá a következő kódot a Main metódushoz a Program osztályban:

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

Ha olyan szabályt szeretne hozzáadni, amely módosítás nélkül ad át egy adott bemeneti jogcímet és értéket az alkalmazásnak, adja hozzá a következő kódot a Main metódushoz a Program osztályban:

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

Ha olyan szabályt szeretne hozzáadni, amely egy megadott típusú jogcímet ad át, adja hozzá a következő kódot a Main metódushoz a Program osztályban:

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

Ha olyan szabályt szeretne hozzáadni, amely egy megadott értékkel rendelkező bemeneti jogcímet ad át, adja hozzá a következő kódot a Main metódushoz a Program osztályban:

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

Ha olyan szabályt szeretne hozzáadni, amely egy megadott bemeneti jogcímtípust egy másik kimeneti jogcímtípussá alakít át, de nem módosítja a jogcím értékét, adja hozzá a következő kódot a Main metódushoz a Program osztályban:

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

Lásd még:

Alapelvek

Az ACS útmutatója

Megosztás a következőn keresztül: