Como usar o Serviço de Gerenciamento do ACS para configurar regras e grupos de regras

Atualizado em: 19 de junho de 2015

Aplica-se ao Azure

Aplica-se A

  • Access Control do Active Directory do Microsoft Azure (também conhecido como Access Control Service ou ACS)

Visão geral

Você pode configurar regras e grupos de regras do ACS usando o Portal de Gerenciamento do ACS (para obter mais informações, consulte Grupos de Regras e Regras) ou o Serviço de Gerenciamento do ACS. Trabalhar com o Serviço de Gerenciamento do ACS pode ser mais eficiente se você estiver criando uma interface do usuário personalizada para gerenciar o ACS ou se quiser automatizar a integração de um novo locatário para soluções saaS (software como serviço) multilocatário.

Etapas para configurar regras e grupos de regras usando o Serviço de Gerenciamento ACS

Importante

Antes de executar as etapas a seguir, verifique se o sistema atende a todos os requisitos de estrutura e plataforma do .NET que são resumidos nos pré-requisitos do ACS.

Para configurar regras e grupos de regras usando o Serviço de Gerenciamento do ACS, conclua as seguintes etapas:

  • Etapa 1 – Coletar informações de configuração do ACS

  • Etapa 2 – Criar um exemplo de aplicativo de console

  • Etapa 3 – Adicionar referências aos serviços e assemblies necessários

  • Etapa 4 – Implementar o cliente do Serviço de Gerenciamento

  • Etapa 5 – Adicionar um grupo de regras

  • Etapa 6 – Adicionar uma regra

Etapa 1 – Coletar informações de configuração do ACS

Você pode usar o Portal de Gerenciamento do ACS para coletar as informações de configuração necessárias. Para obter mais informações sobre como iniciar o Portal de Gerenciamento do ACS, consulte o Portal de Gerenciamento do ACS.

Para coletar informações de configuração do ACS

  1. Inicie o Portal de Gerenciamento do ACS. Para obter mais informações sobre como iniciar o Portal de Gerenciamento do ACS, consulte o Portal de Gerenciamento do ACS.

  2. Obtenha o valor da conta de serviço de gerenciamento do ACS. Você pode usar a conta padrão ManagementClient. Para exibir esse valor, no Portal de Gerenciamento do ACS, clique no serviço Gerenciamento na seção Administração na árvore no lado esquerdo da página.

  3. Obtenha o valor da senha da conta do Serviço de Gerenciamento do ACS. Para exibir esse valor, faça o seguinte:

    1. No Portal de Gerenciamento do ACS, clique no serviço Gerenciamento na seção Administração na árvore no lado esquerdo da página.

    2. Na página Serviço de gerenciamento, clique em ManagementClient em Contas do Serviço de Gerenciamento.

    3. Na página Editar Contas do Serviço de Gerenciamento, em Credenciais, clique em Senha.

    4. Na página Editar Credencial de Gerenciamento, copie o valor no campo Senha.

  4. Obtenha o nome do namespace do Azure do portal do Azure ou da URL do Portal de Gerenciamento do ACS. Por exemplo, em http://contoso.accesscontrol.windows.net, o nome é contoso.

  5. Obtenha o nome do host do ACS. Normalmente é accesscontrol.windows.net.

Etapa 2 – Criar um exemplo de aplicativo de console

Nesta etapa, você criará um aplicativo de console de exemplo que pode executar o código para adicionar seus grupos de regras e regras do ACS.

Para criar um exemplo de aplicativo de console

  1. Abra Visual Studio 2012 e crie um novo projeto de aplicativo de console no modelo instalado Windows.

  2. Adicione o código a seguir à classe Programa e atribua as variáveis serviceIdentityPasswordForManagement, serviceNamespace e acsHostName às informações de configuração apropriadas que você coletou na etapa 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;
    

Etapa 3 – Adicionar referências aos serviços e assemblies necessários

Nesta etapa, você identifica e adiciona as dependências necessárias aos serviços e assemblies.

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

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

    Observação

    Você talvez tenha que clicar com o botão direito do mouse no nome do exemplo de aplicativo de console no Gerenciador de Soluções, selecionar Propriedades e alterar a estrutura de destino de seu exemplo de aplicativo no .NET Framework 4 Client Profile (atribuído por padrão quando você cria um novo aplicativo de console) ao .NET Framework 4.

  2. Clique com o botão direito do mouse em Referências de Serviço, clique em Adicionar Referência de Serviço e adicione uma referência de serviço ao Serviço de Gerenciamento. A URL do Serviço de Gerenciamento é exclusiva para seu namespace e tem uma aparência semelhante a esta:

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

  3. Adicione as seguintes declarações, onde MyConsoleApplication é o nome de seu aplicativo de console e MyServiceReference é o nome de 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;
    

Etapa 4 – Implementar o cliente do Serviço de Gerenciamento

Nesta etapa, você implementa o cliente do Serviço de Gerenciamento.

Para implementar o cliente do Serviço de Gerenciamento

  1. 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;
            }
    
  2. Adicione o código a seguir à classe Programa para criar o método GetTokenWithWritePermission e os métodos auxiliares. GetTokenWithWritePermission e seus auxiliares adicionam o token SWT OAuth ao cabeçalho de autorização da solicitação 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;
    
            }
    

Etapa 5 – Adicionar um grupo de regras

Nesta etapa, você adiciona um grupo de regras usando o cliente do Serviço de Gerenciamento que criou na etapa anterior.

Para adicionar um grupo de regras

  1. Inicialize o cliente do Serviço de Gerenciamento adicionando o seguinte código ao método Principal na classe Programa:

    ManagementService svc = CreateManagementServiceClient();
    
  2. Adicione o novo grupo de regras (você pode chamá-lo de “mygroup”, como no código abaixo) e salve as alterações adicionando o código ao método Principal na classe Programa:

    RuleGroup rg = new RuleGroup();
                rg.Name = "mygroup";
                svc.AddToRuleGroups(rg);
                svc.SaveChanges(SaveChangesOptions.Batch);
    

Etapa 6 – Adicionar uma regra

Nesta etapa, você adicionará uma regra ao grupo de regras criado na etapa anterior usando o Serviço de Gerenciamento do ACS.

Para adicionar uma regra

  1. Estabeleça uma variável para "AUTORIDADE LOCAL", que é um nome do emissor interno que representa seu namespace de namespace Controle de Acesso, adicionando o seguinte código ao método Main 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();
    
  2. Realize um dos seguintes procedimentos:

    1. 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);
      
    2. Para adicionar uma regra que passe determinado valor e declaração de entrada ao aplicativo sem alterações, adicione esse 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);
      
    3. Para adicionar uma regra que passe uma declaração de 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);
      
    4. Para adicionar uma regra que passe uma declaraçã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);
      
    5. Para adicionar uma regra que transforme determinado tipo de declaração de entrada em um tipo de declaração de saída diferente, mas sem alterar o valor da declaraçã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

Instruções do ACS