Como: Utilizar o Serviço de Gestão ACS para configurar regras e grupos de regras

Artigo
11/09/2015

Atualizado: 19 de junho de 2015

Aplica-se a: Azure

Aplica-se A

Microsoft Azure Ative Directory Controlo de Acesso (também conhecido como serviço de Controlo de Acesso ou ACS)

Descrição Geral

Pode configurar as regras e grupos de regras acs usando o Portal de Gestão ACS (para mais informações, consulte Grupos e Regras de Regras) ou o Serviço de Gestão ACS. Trabalhar com o AcS Management Service pode ser mais eficiente se estiver a construir uma interface de utilizador personalizada para gerir o ACS ou se quiser automatizar o embarque de um novo inquilino para soluções multi-arrendantes como Serviço (SaaS).

Passos para configurar regras e grupos de regras utilizando o Serviço de Gestão ACS

Importante

Antes de executar os seguintes passos, certifique-se de que o seu sistema cumpre todos os requisitos de estrutura e plataforma .NET que são resumidos em Pré-requisitos ACS.

Para configurar regras e grupos de regras utilizando o Serviço de Gestão ACS, complete os seguintes passos:

Passo 1 – Recolher informações de configuração de ACS
Passo 2 - Criar uma aplicação de consola de amostra
Passo 3 - Adicionar referências aos serviços e assembleias exigidos
Passo 4 - Implementar o Serviço de Gestão Cliente
Passo 5 - Adicionar um Grupo de Regras
Passo 6 - Adicionar uma regra

Passo 1 – Recolher informações de configuração de ACS

Pode utilizar o Portal de Gestão ACS para recolher as informações de configuração necessárias. Para mais informações sobre como lançar o Portal de Gestão ACS, consulte o Portal de Gestão acs.

Para recolher informações de configuração acs

Lançar o Portal de Gestão ACS. Para mais informações sobre como lançar o Portal de Gestão ACS, consulte o Portal de Gestão acs.
Obtenha o valor da conta de serviço de gestão ACS. Pode utilizar a conta ManagementClient padrão. Para visualizar este valor, no Portal de Gestão acs, clique no serviço de Gestão sob a secção Administração na árvore do lado esquerdo da página.
Obtenha o valor da senha da conta do Serviço de Gestão ACS. Para ver este valor, faça o seguinte:
1. No Portal de Gestão acs, clique em Gestão sob a secção Administração na árvore do lado esquerdo da página.
2. Na página do Serviço de Gestão , clique em ManagementClient em Contas de Serviço de Gestão.
3. Na página 'Conta de Serviço de Gestão de Edição ', em Credenciais, clique em Palavra-passe.
4. Na página de Credencial de Gestão de Edição , copie o valor no campo Palavra-Passe .
Obtenha o nome do seu espaço de nome Azure a partir do portal do Azure ou a partir do URL do seu Portal de Gestão ACS. Por exemplo, em http://contoso.accesscontrol.windows.net, o nome é contoso.
Pegue o nome de anfitrião ACS. Normalmente, é accesscontrol.windows.net.

Passo 2 - Criar uma aplicação de consola de amostra

Neste passo, cria-se uma aplicação de consola de amostras que pode executar o código para adicionar os seus grupos e regras de regras ACS.

Para criar uma aplicação de consola de amostra

Abra Visual Studio 2012 e crie um novo projeto de aplicação de consola sob o modelo instalado Windows.

Adicione o seguinte código à classe Programa e, em seguida, atribua serviçoIdentityPasswordForManagement, serviceNamespace e acsHostName variáveis às informações de configuração apropriadas que recolheu no passo 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;

Passo 3 - Adicionar referências aos serviços e assembleias exigidos

Neste passo identifica-se e adiciona as dependências necessárias aos serviços e assembleias.

Para adicionar as dependências necessárias aos serviços e assembleias

Clique com o botão direito Referências, clique em Adicionar Referência e adicione uma referência a System.Web.Extensions.

Nota

Pode ter de clicar com o direito no nome da aplicação da consola da amostra no Explorador de Soluções, selecionar Propriedades e alterar o quadro alvo da sua aplicação de amostra de .NET Framework 4 Perfil de Cliente (atribuído por padrão quando cria uma nova aplicação de consola) para .NET Framework 4.
Clique em referências de serviço à direita, clique em Adicionar Referência de Serviço e adicione uma referência de serviço ao Serviço de Gestão. O URL do Serviço de Gestão é exclusivo do seu espaço de nome e parece semelhante ao seguinte:

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

Adicione as seguintes declarações, onde MyConsoleApplication é o nome da sua aplicação para consola e MyServiceReference é o nome da sua referência de serviço:

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;

Passo 4 - Implementar o Serviço de Gestão Cliente

Neste passo implementa-se o cliente do Serviço de Gestão.

Implementar o cliente do Serviço de Gestão

Adicione o seguinte método à classe Programa :

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

Adicione o seguinte código à classe Programa para criar o método GetTokenWithWritePermission e os seus métodos de ajuda. GetTokenWithWritePermission e seus ajudantes adicionam o token SWT OAuth ao cabeçalho de autorização do pedido 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;

        }

Passo 5 - Adicionar um Grupo de Regras

Neste passo, adicione um grupo de regras utilizando o cliente do Serviço de Gestão que criou no degrau acima.

Para adicionar um grupo de regras

Inicializar o cliente do Serviço de Gestão adicionando o seguinte código ao método Principal na classe Programa :
```
ManagementService svc = CreateManagementServiceClient();
```
Adicione o seu novo grupo de regras (pode chamá-lo de "mygroup", como mostrado no código abaixo) e guarde as alterações adicionando o seguinte código ao método Principal na classe Programa :
```
RuleGroup rg = new RuleGroup();
            rg.Name = "mygroup";
            svc.AddToRuleGroups(rg);
            svc.SaveChanges(SaveChangesOptions.Batch);
```

Passo 6 - Adicionar uma regra

Neste passo, adicione uma regra ao grupo de regras que criou no passo anterior utilizando o Serviço de Gestão ACS.

Para adicionar uma regra

Estabeleça uma variável para "LOCAL AUTHORITY", que é um nome emitente incorporado que representa o seu Controlo de Acesso espaço de nome, adicionando o seguinte código ao método Principal na classe Programa:
```
// "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();
```

Faça um dos seguintes:

Para adicionar uma regra básica, adicione o seguinte código ao método Principal na classe Programa :

            //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 adicionar uma regra que passa uma determinada reclamação de entrada e valor para a aplicação sem alterações, adicione o seguinte código ao método Principal na classe Programa :

//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 adicionar uma regra que passa qualquer reclamação com um tipo especificado, adicione o seguinte código ao método Principal na classe Programa :

//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 adicionar uma regra que passa qualquer reclamação de entrada com um valor especificado, adicione o seguinte código ao método Principal na classe Programa :

//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 adicionar uma regra que transforma um tipo de reclamação de entrada especificado num tipo de reivindicação de saída diferente, mas não altera o valor de reclamação, adicione o seguinte código ao método Principal na classe Programa :

//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 também

Conceitos

ACS Como Fazer

Partilhar via