Cómo: Usar el servicio de administración de ACS para configurar reglas y grupos de reglas

Artículo
11/09/2015

Actualizado: 19 de junio de 2015

Se aplica a: Azure

Se aplica a

Active Directory Access Control de Microsoft Azure (también conocido como Access Control Service o ACS)

Información general

Puede configurar reglas y grupos de reglas de ACS mediante el Portal de administración de ACS (para obtener más información, consulte Reglas y grupos de reglas) o el servicio de administración de ACS. Trabajar con el servicio de administración de ACS puede ser más eficaz si va a crear una interfaz de usuario personalizada para administrar ACS o si desea automatizar la incorporación de un nuevo inquilino para soluciones de software como servicio (SaaS) multiinquilino.

Pasos para la configuración de reglas y grupos de reglas mediante el Servicio de administración de ACS

Importante

Antes de realizar los pasos siguientes, asegúrese de que el sistema cumple todos los requisitos de .NET Framework y plataforma que se resumen en Requisitos previos de ACS.

Para configurar reglas y grupos de reglas mediante el servicio de administración de ACS, complete los pasos siguientes:

Paso 1: Recopilación de información de configuración de ACS
Paso 2: Creación de una aplicación de consola de ejemplo
Paso 3: Agregar referencias a los servicios y ensamblados necesarios
Paso 4: Implementar el cliente del servicio de administración
Paso 5: Adición de un grupo de reglas
Paso 6: Adición de una regla

Paso 1: Recopilación de información de configuración de ACS

Puede usar el Portal de administración de ACS para recopilar la información de configuración necesaria. Para obtener más información sobre cómo iniciar el Portal de administración de ACS, consulte Portal de administración de ACS.

Para recopilar la información de configuración de ACS

Inicie el Portal de administración de ACS. Para obtener más información sobre cómo iniciar el Portal de administración de ACS, consulte Portal de administración de ACS.
Obtenga el valor de la cuenta de servicio de administración de ACS. Puede usar la cuenta ManagementClient predeterminada. Para ver este valor, en el Portal de administración de ACS, haga clic en Servicio de administración en la sección Administración del árbol del lado izquierdo de la página.
Obtenga el valor de la contraseña de la cuenta del servicio de administración de ACS. Para ver este valor, haga lo siguiente:
1. En el Portal de administración de ACS, haga clic en Servicio de administración en la sección Administración del árbol del lado izquierdo de la página.
2. En la página Servicio de administración, haga clic en ManagementClient en Cuentas de servicio de administración.
3. En la página Editar cuenta del servicio de administración, en Credenciales, haga clic en Contraseña.
4. En la página Editar credencial de administración, copie el valor del campo Contraseña.
Obtenga el nombre del espacio de nombres de Azure desde el Azure Portal o desde la dirección URL del Portal de administración de ACS. Por ejemplo, en http://contoso.accesscontrol.windows.net, el nombre es contoso.
Obtenga el nombre de host de ACS. En general, suele ser accesscontrol.windows.net.

Paso 2: Creación de una aplicación de consola de ejemplo

En este paso, creará una aplicación de consola de ejemplo que puede ejecutar el código para agregar reglas y grupos de reglas de ACS.

Para crear una aplicación de consola de ejemplo

Abra Visual Studio 2012 y cree un nuevo proyecto de aplicación de consola en la plantilla Windows instalada.

Agregue el código siguiente a la clase Program y luego asigne las variables serviceIdentityPasswordForManagement, serviceNamespace y acsHostName a la información de configuración correspondiente que recopiló en el paso anterior.

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;

Paso 3: Agregar referencias a los servicios y ensamblados necesarios

En este paso, deberá identificar y agregar las dependencias necesarias de los servicios y ensamblados.

Para agregar las dependencias necesarias a los servicios y ensamblados

Haga clic con el botón secundario en Referencias, haga clic en Agregar referencia y agregue una referencia a System.Web.Extensions.

Nota

Es posible que tenga que hacer clic con el botón secundario en el nombre de la aplicación de consola de ejemplo en el Explorador de soluciones, seleccionar Propiedades y cambiar el marco de destino de su aplicación de ejemplo del Perfil de cliente de .NET Framework 4 (asignado de forma predeterminada al crear una nueva aplicación de consola) a .NET Framework 4.
Haga clic con el botón secundario en Referencias al servicio, haga clic en Agregar referencia de servicio y agregue una referencia de servicio al Servicio de administración. La dirección URL del servicio de administración es única a su espacio de nombres y es similar a la siguiente:

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

Agregue las declaraciones siguientes, donde MyConsoleApplication corresponde al nombre de la aplicación de consola y MyServiceReference es el nombre de su referencia de servicio:

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;

Paso 4: Implementar el cliente del servicio de administración

En este paso se implementa el cliente del servicio de administración.

Para implementar el cliente de servicio de administración

Agregue el método siguiente a la clase 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;
        }

Agregue el código siguiente a la clase Program para crear el método GetTokenWithWritePermission junto con los métodos de su asistente. El método GetTokenWithWritePermission y sus asistentes agregan el token SWT OAuth al encabezado Authorization de la solicitud HTTP.

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;

        }

Paso 5: Adición de un grupo de reglas

En este paso, agregará un grupo de reglas mediante el cliente de servicio de administración creado en el paso anterior.

Para agregar un grupo de reglas

Inicie el cliente del servicio de administración. Para ello, agregue el código siguiente al método Main de la clase Program:
```
ManagementService svc = CreateManagementServiceClient();
```
Agregue el nuevo grupo de reglas (puede llamarlo “mygroup”, tal como se muestra en el código siguiente) y guarde los campos. Para ello, agregue el código siguiente al método Main de la clase Program:
```
RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);
```

Paso 6: Adición de una regla

En este paso, agregará una regla al grupo de reglas que creó en el paso anterior mediante el servicio de administración de ACS.

Para agregar una regla

Establezca una variable para "LOCAL AUTHORITY", que es un nombre de emisor integrado que representa el espacio de nombres del espacio de nombres Access Control, agregando el código siguiente al método Main en la clase 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();
```

Realice una de las siguientes acciones:

Para agregar una regla básica, agregue el código siguiente al método Main de la clase 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);

Para agregar una regla que transmita un valor y una notificación de entrada determinada a la aplicación sin realizar cambios, agregue el código siguiente al método Main de la clase 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);

Para agregar una regla que transmita cualquier notificación con un tipo especificado, agregue el código siguiente al método Main de la clase 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);

Para agregar una regla que transmita cualquier notificación de entrada con un valor especificado, agregue el código siguiente al método Main de la clase 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);

Para agregar una regla que transforme un tipo de notificación de entrada específico en un tipo de notificación de salida distinto, pero que no cambie el valor de notificación, agregue el código siguiente al método Main de la clase 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);

Consulte también

Conceptos

Procedimientos de ACS

Compartir a través de