Como: Usar o Serviço de Gerenciamento ACS para configurar regras e grupos de regras
TOC
Recolher sumário
Expandir sumário
Esta documentação foi arquivada e não está sendo atualizada.

Como: Usar o Serviço de Gerenciamento ACS para configurar regras e grupos de regras

Publicado: abril de 2011

Atualizado: junho de 2015

Aplica-se a: Azure

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

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

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

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

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

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

    1. No Portal de Gerenciamento ACS, clique em Serviço de gerenciamento na seção Administração, na árvore à esquerda 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 de seu namespace Azure no portal do Azure ou na URL de seu Portal de Gerenciamento ACS. Por exemplo, em http://contoso.accesscontrol.windows.net, o nome é contoso.

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

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

  1. Abra o Visual Studio 2012 e crie um novo projeto de aplicativo de console no modelo instalado do 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;
    
    

Nesta etapa, você identifica e adiciona 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.

    noteObservaçã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://SEUNAMESPACE.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;
    
    

Nesta etapa, você implementa 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;
    
            }
    
    
    

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

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

Nessa etapa, você adiciona um grupo de regras usando o cliente do Serviço de Gerenciamento ACS.

  1. Estabeleça uma variável para "LOCAL AUTHORITY", que é o nome de um emissor interno que representa o namespace de seu Namespace do Access Control, adicionando o seguinte código ao método Principal na classe Programa:

    
    // "LOCAL AUTHORITY" is a built-in IDP name that represents the Namespace do Access Control. 
    Issuer localAuthority = svc.Issuers.Where(m => m.Name == "LOCAL AUTHORITY").FirstOrDefault();
    
    
  2. Execute um destes 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

Manuais do ACS

Mostrar:
© 2016 Microsoft