Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona

Procedura: Usare il servizio di gestione ACS per la configurazione di regole e gruppi di regole

Pubblicato: aprile 2011

Aggiornamento: giugno 2015

Si applica a: Azure

  • Microsoft Azure Active Directory Access Control (anche noto come Servizio di controllo di accesso o ACS)

È possibile configurare regole e gruppi di regole ACS usando il portale di gestione ACS (per altre informazioni, vedere Gruppi di regole e regole) o il servizio di gestione ACS. Quando si crea un'interfaccia utente personalizzata per la gestione di ACS oppure si desidera automatizzare il processo di on-boarding di un nuovo tenant per soluzioni SaaS (Software as a Service) multi-tenant, l'uso del servizio di gestione ACS presenta vantaggi in termini di efficienza.

Per raccogliere le informazioni di configurazione necessarie, è possibile usare il portale di gestione ACS. Per altre informazioni sull'avvio del portale di gestione ACS, vedere Portale di gestione ACS.

  1. Avviare il portale di gestione ACS. Per altre informazioni sull'avvio del portale di gestione ACS, vedere Portale di gestione ACS.

  2. Ottenere il valore dell'account del servizio di gestione ACS. È possibile usare l'account predefinito ManagementClient. Per visualizzare questo valore, nel portale di gestione ACS fare clic su Management service nella sezione Administration nell'albero nella parte sinistra della pagina.

  3. Ottenere il valore della password dell'account del servizio di gestione ACS. Per visualizzare questo valore, attenersi alla seguente procedura:

    1. Nel portale di gestione ACS fare clic su Management service nella sezione Administration nell'albero nella parte sinistra della pagina.

    2. Nella pagina Management Service fare clic su ManagementClient in Management Service Accounts.

    3. Nella pagina Edit Management Service Account in Credentials fare clic su Password.

    4. Nella pagina Edit Management Credential copiare il valore nel campo Password.

  4. Ottenere il nome dello spazio dei nomi di Azure dal relativo portale oppure dall'URL del portale di gestione ACS. Ad esempio, in http://contoso.accesscontrol.windows.net, il valore del nome è contoso.

  5. Ottenere il nome host di ACS. In genere, questo valore è accesscontrol.windows.net.

In questo passaggio viene creata un'applicazione console di esempio in grado di eseguire il codice per l'aggiunta di gruppi di regole e regole ACS.

  1. Aprire Visual Studio 2012 e creare un nuovo progetto di applicazione console sotto il modello installato di Windows.

  2. Aggiungere il seguente codice alla classe Program e quindi assegnare le variabili serviceIdentityPasswordForManagement, serviceNamespace e acsHostName alle informazioni di configurazione appropriate raccolte nel passaggio precedente.

    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;
    
    

In questo passaggio vengono identificate e aggiunte le dipendenze richieste ai servizi e agli assembly.

  1. Fare clic con il pulsante destro del mouse su Riferimenti, scegliere Aggiungi riferimento e aggiungere un riferimento a System.Web.Extensions.

    noteNota
    Può essere necessario fare clic con il pulsante destro del mouse sul nome dell'applicazione console di esempio in Esplora soluzioni, scegliere Proprietà e modificare il framework di destinazione dell'applicazione di esempio da .NET Framework 4 Client Profile (assegnato per impostazione predefinita quando si crea una nuova applicazione console) in .NET Framework 4.

  2. Fare clic con il pulsante destro del mouse su Riferimento al servizio, scegliere Aggiungi riferimento al servizio e aggiungere un riferimento al servizio di gestione. L'URL del servizio di gestione, univoco per lo spazio dei nomi, ha un aspetto simile al seguente:

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

  3. Aggiungere le seguenti dichiarazioni, dove MyConsoleApplication è il nome dell'applicazione console e MyServiceReference è il nome del riferimento al servizio:

    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;
    
    

In questo passaggio viene implementato il client del servizio di gestione.

  1. Aggiungere il seguente metodo alla 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. Aggiungere il seguente codice alla classe Program per creare il metodo GetTokenWithWritePermission e i relativi metodi di supporto. GetTokenWithWritePermission e i relativi metodi di supporto aggiungono il token SWT OAuth all'intestazione Authorization della richiesta 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;
    
            }
    
    
    

In questo passaggio viene aggiunto un gruppo di regole mediante il client del servizio di gestione creato nel passaggio precedente.

  1. Inizializzare il client del servizio di gestione aggiungendo il seguente codice al metodo Main della classe Program:

    ManagementService svc = CreateManagementServiceClient();
    
    
  2. Aggiungere il nuovo gruppo di regole, che è possibile denominare "mygroup", come nel seguente codice, e salvare le modifiche aggiungendo il codice riportato di seguito al metodo Main della classe Program:

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

In questo passaggio viene aggiunta una regola al gruppo di regole creato nel passaggio precedente usando il servizio di gestione ACS.

  1. Definire una variabile per "LOCAL AUTHORITY", nome dell'autorità emittente predefinita che rappresenta lo Spazi dei nomi controllo di accesso, aggiungendo il seguente codice al metodo Main della classe Program:

    
    // "LOCAL AUTHORITY" is a built-in IDP name that represents the Spazi dei nomi controllo di accesso. 
    Issuer localAuthority = svc.Issuers.Where(m => m.Name == "LOCAL AUTHORITY").FirstOrDefault();
    
    
  2. Effettuare una delle seguenti operazioni:

    1. Per aggiungere una regola di base, aggiungere il seguente codice al metodo Main della 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. Per aggiungere una regola che consente di passare un'attestazione e un valore di input specifici, aggiungere il seguente codice al metodo Main della 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. Per aggiungere una regola che consente di passare un'attestazione con un tipo specifico, aggiungere il seguente codice al metodo Main della 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. Per aggiungere una regola che consente di passare un'attestazione di input con un valore specifico, aggiungere il seguente codice al metodo Main della 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. Per aggiungere una regola che consente di trasformare un determinato tipo di attestazione di input in un tipo diverso di attestazione di output, mantenendo il valore dell'attestazione, aggiungere il seguente codice al metodo Main della 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);
      
      

Vedere anche

Concetti

Procedure di ACS

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft