Cette documentation est archivée et n’est pas conservée.

Procédure : Utiliser le service de gestion ACS pour configurer des règles et des groupes de règles

Publication: avril 2011

Mis à jour: juin 2015

S'applique à: Azure

  • Microsoft Azure Active Directory Access Control (également appelé Access Control Service ou ACS)

Vous pouvez configurer des règles et des groupes de règles ACS à l'aide du portail de gestion ACS (pour plus d'informations, consultez Règles et groupes de règles) ou du service de gestion ACS. L'utilisation du service de gestion ACS peut être plus efficace si vous créez une interface utilisateur personnalisée pour gérer ACS ou si vous voulez automatiser l'intégration d'un nouveau locataire pour des solutions SaaS (Software as a Service) mutualisées.

ImportantImportant
Avant d'effectuer les étapes suivantes, assurez-vous que votre système répond aux exigences de configuration de la plateforme et de .NET Framework indiquées dans Configuration requise pour ACS.

Pour configurer des règles et des groupes de règles à l'aide du service de gestion ACS, procédez comme suit :

Vous pouvez utiliser le portail de gestion ACS pour recueillir les informations de configuration nécessaires. Pour plus d'informations sur le démarrage du portail de gestion ACS, consultez Portail de gestion ACS.

  1. Ouvrez le portail de gestion ACS. Pour plus d'informations sur le démarrage du portail de gestion ACS, consultez Portail de gestion ACS.

  2. Récupérez la valeur du compte de service de gestion ACS. Vous pouvez utiliser le compte par défaut ManagementClient. Pour afficher cette valeur, dans le portail de gestion ACS, cliquez sur Service de gestion sous la section Administration dans l'arborescence du côté gauche de la page.

  3. Récupérez la valeur du mot de passe du compte de service de gestion ACS. Pour afficher cette valeur, procédez comme suit :

    1. Dans le portail de gestion ACS, cliquez sur Service de gestion sous la section Administration dans l'arborescence du côté gauche de la page.

    2. Dans la page Service de gestion, cliquez sur ManagementClient sous Comptes de service de gestion.

    3. Dans la page Modifier le compte du service de gestion, sous Informations d'identification, cliquez sur Mot de passe.

    4. Dans la page Modifier les informations d'identification de gestion, copiez la valeur du champ Mot de passe.

  4. Récupérez le nom de votre espace de noms Azure à partir du portail Azure ou de l'URL de votre portail de gestion ACS. Par exemple, dans http://contoso.accesscontrol.windows.net, le nom est contoso.

  5. Récupérez le nom d'hôte ACS. Généralement, il s'agit de accesscontrol.windows.net.

Lors de cette étape, vous créez un exemple d'application console qui peut exécuter le code pour ajouter vos règles et groupes de règles ACS.

  1. Ouvrez Visual Studio 2012 et créez un projet d'application console sous le modèle Windows installé.

  2. Ajoutez le code suivant à la classe Program et attribuez les variables serviceIdentityPasswordForManagement, serviceNamespace et acsHostName aux informations de configuration appropriées que vous avez recueillies à l'étape précédente.

    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;
    
    

Lors de cette étape, vous allez identifier et ajouter les dépendances nécessaires aux services et aux assemblys.

  1. Cliquez avec le bouton droit sur Références, cliquez sur Ajouter une référence et ajoutez une référence à System.Web.Extensions.

    noteRemarque
    Il se peut que vous deviez cliquer avec le bouton droit sur le nom de votre exemple d'application console dans l'Explorateur de solutions, sélectionner Propriétés et changer le framework cible de votre exemple d'application de .NET Framework 4 Client Profile (attribué par défaut quand vous créez une application console) en .NET Framework 4.

  2. Cliquez avec le bouton droit sur Références du service, cliquez sur Ajouter une référence de service, puis ajoutez une référence de service au service de gestion. L'URL du service de gestion est unique à votre espace de noms et ressemble à la chaîne suivante :

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

  3. Ajoutez les déclarations suivantes, où MyConsoleApplication est le nom de votre application console et MyServiceReference est le nom de votre référence de service :

    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;
    
    

Lors de cette étape, vous allez implémenter le client du service de gestion.

  1. Ajoutez la méthode suivante à la classe 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;
            }
    
    
  2. Ajoutez le code suivant à la classe Program pour créer une méthode GetTokenWithWritePermission et ses méthodes d'assistance. GetTokenWithWritePermission et ses méthodes d'assistance ajoutent le jeton SWT OAuth à l'en-tête Authorization de la requête 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;
    
            }
    
    
    

Lors de cette étape, vous allez ajouter un groupe de règles à l'aide du client du service de gestion que vous avez créé à l'étape précédente.

  1. Initialisez le client du service de gestion en ajoutant le code suivant à la méthode Main de la classe Program :

    ManagementService svc = CreateManagementServiceClient();
    
    
  2. Ajoutez votre nouveau groupe de règles (vous pouvez le nommer « mygroup », comme indiqué dans le code ci-dessous) et enregistrez les modifications en ajoutant le code suivant à la méthode Main dans la classe Program :

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

Lors de cette étape, vous allez ajouter une règle au groupe de règles que vous avez créé à l'étape précédente à l'aide du service de gestion ACS.

  1. Établissez une variable pour « LOCAL AUTHORITY », qui est un nom d'émetteur intégré qui représente votre espace de noms espace de noms Access Control, en ajoutant le code suivant à la méthode Main de la classe Program :

    
    // "LOCAL AUTHORITY" is a built-in IDP name that represents the espace de noms Access Control. 
    Issuer localAuthority = svc.Issuers.Where(m => m.Name == "LOCAL AUTHORITY").FirstOrDefault();
    
    
  2. Procédez de l'une des façons suivantes :

    1. Pour ajouter une règle de base, ajoutez le code suivant à la méthode Main de la classe 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);
      
      
      
    2. Pour ajouter une règle qui passe une valeur et une revendication d'entrée particulières à l'application sans modification, ajoutez le code suivant à la méthode Main de la classe 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);
      
      
    3. Pour ajouter une règle qui passe toute revendication d'un type spécifié, ajoutez le code suivant à la méthode Main de la classe 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);
      
      
    4. Pour ajouter une règle qui passe toute revendication d'entrée avec une valeur spécifiée, ajoutez le code suivant à la méthode Main de la classe 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);
      
      
    5. Pour ajouter une règle qui transforme un type de revendication d'entrée spécifié en un type de revendication de sortie différent sans changer la valeur de revendication, ajoutez le code suivant à la méthode Main de la classe 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);
      
      

Voir aussi

Afficher: