Condividi tramite

Usare Java per gestire gli elenchi di controllo di accesso in Azure Data Lake Storage

  • Articolo

Questo articolo illustra come usare Java per ottenere, impostare e aggiornare gli elenchi di controllo di accesso di directory e file.

L'ereditarietà di ACL è già disponibile per i nuovi elementi figlio creati in una directory padre Ma è anche possibile aggiungere, aggiornare e rimuovere gli ACL in modo ricorsivo sugli elementi figlio esistenti di una directory padre senza dover apportare queste modifiche singolarmente per ogni elemento figlio.

Pacchetto (Maven) | Esempi | Riferimento API | Mapping da Gen1 a Gen2 | Fornisci feedback

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.
  • Un account di archiviazione di Azure in cui è abilitato lo spazio dei nomi gerarchico (HNS). Per crearne uno, seguire queste istruzioni.
  • Java Development Kit (JDK) versione 8 o successiva.
  • Per la gestione dei progetti in questo esempio viene usato Apache Maven.
  • Interfaccia della riga di comando di Azure versione 2.6.0 o successiva.
  • Una delle autorizzazioni di sicurezza seguenti:
    • Entità di sicurezza Microsoft Entra ID di cui è stato effettuato il provisioning a cui è stato assegnato il ruolo Proprietario dati BLOB di archiviazione, con ambito al contenitore di destinazione, all'account di archiviazione, al gruppo di risorse padre o alla sottoscrizione.
    • Utente proprietario del contenitore o della directory di destinazione a cui si prevede di applicare le impostazioni ACL. Per impostare gli ACL in modo ricorsivo, include tutti gli elementi figlio nel contenitore o nella directory di destinazione.
    • Chiave dell'account di archiviazione.

Impostare il progetto

Nota

Questo articolo usa lo strumento Maven per compilare ed eseguire il codice di esempio. Anche altri strumenti di compilazione, come Gradle, sono compatibili con Azure SDK per Java.

Usare Maven per creare una nuova app console o aprire un progetto esistente. Seguire questa procedura per installare i pacchetti e aggiungere le direttive import necessarie.

Installare i pacchetti

Aprire il file pom.xml nell'editor di testo. Installare i pacchetti includendo il file BOM o includendo una dipendenza diretta.

Includere il file BOM

Aggiungere azure-sdk-bom per inserire una dipendenza dall'ultima versione della libreria. Nel frammento di codice seguente sostituire il segnaposto {bom_version_to_target} con il numero di versione. L'uso di azure-sdk-bom permette di non specificare la versione di ogni singola dipendenza. Per altre informazioni sul file BOM, vedere il file LEGGIMI di BOM di Azure SDK.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Aggiungere gli elementi di dipendenza seguenti al gruppo di dipendenze. La dipendenza azure-identity è necessaria per le connessioni senza password ai servizi di Azure.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-file-datalake</artifactId>
</dependency>
<dependency>
      <groupId>com.azure</groupId>
      <artifactId>azure-storage-common</artifactId>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
</dependency>

Includere una dipendenza diretta

Per inserire una dipendenza da una determinata versione della libreria, aggiungere la dipendenza diretta al progetto:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-file-datalake</artifactId>
    <version>{package_version_to_target}</version>
</dependency>
<dependency>
      <groupId>com.azure</groupId>
      <artifactId>azure-storage-common</artifactId>
      <version>{package_version_to_target}</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>{package_version_to_target}</version>
</dependency>

Includere direttive import

Aggiungere le direttive necessarie import. In questo esempio vengono aggiunte le direttive seguenti nel file App.java:

import com.azure.storage.common.StorageSharedKeyCredential;
import com.azure.storage.file.datalake.DataLakeDirectoryClient;
import com.azure.storage.file.datalake.DataLakeFileClient;
import com.azure.storage.file.datalake.DataLakeFileSystemClient;
import com.azure.storage.file.datalake.DataLakeServiceClient;
import com.azure.storage.file.datalake.DataLakeServiceClientBuilder;
import com.azure.storage.file.datalake.models.ListPathsOptions;
import com.azure.storage.file.datalake.models.PathItem;
import com.azure.storage.file.datalake.models.AccessControlChangeCounters;
import com.azure.storage.file.datalake.models.AccessControlChangeResult;
import com.azure.storage.file.datalake.models.AccessControlType;
import com.azure.storage.file.datalake.models.PathAccessControl;
import com.azure.storage.file.datalake.models.PathAccessControlEntry;
import com.azure.storage.file.datalake.models.PathPermissions;
import com.azure.storage.file.datalake.models.PathRemoveAccessControlEntry;
import com.azure.storage.file.datalake.models.RolePermissions;
import com.azure.storage.file.datalake.options.PathSetAccessControlRecursiveOptions;

Effettuare la connessione all'account

Per eseguire gli esempi di codice in questo articolo, è necessario creare un'istanza di DataLakeServiceClient che rappresenta l'account di archiviazione. È possibile autorizzare l'oggetto client con le credenziali di Microsoft Entra ID o con una chiave dell'account.

È possibile usare la libreria client di identità di Azure per Java per autenticare l'applicazione con Microsoft Entra ID.

Prima di tutto, è necessario assegnare uno dei ruoli di controllo degli accessi in base al ruolo di Azure (Azure RBAC) seguenti all'entità di sicurezza:

Ruolo Funzionalità di impostazione ACL
Proprietario dei dati del BLOB di archiviazione Tutte le directory e i file nell'account.
Collaboratore ai dati del BLOB di archiviazione Solo directory e file di proprietà dell'entità di sicurezza.

Creare quindi un'istanza di DataLakeServiceClient e passare una nuova istanza della classe DefaultAzureCredential.

static public DataLakeServiceClient GetDataLakeServiceClient(String accountName){
    DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

    DataLakeServiceClient dataLakeServiceClient = new DataLakeServiceClientBuilder()
        .endpoint("https://" + accountName + ".dfs.core.windows.net")
        .credential(defaultCredential)
        .buildClient();

    return dataLakeServiceClient;
}

Per altre informazioni sull'uso di DefaultAzureCredential per autorizzare l'accesso ai dati, vedere Libreria client di Identità di Azure per Java.

Impostare gli ACL

Quando si imposta un ACL, sostituire l'intero ACL, incluse tutte le sue voci. Se si vuole modificare il livello di autorizzazione di un'entità di sicurezza o aggiungere una nuova entità di sicurezza all'ACL senza influire sulle altre voci esistenti, è consigliabile aggiornare invece l'ACL. Per aggiornare un elenco di controllo di accesso anziché sostituirlo, vedere la sezione Aggiornare gli ACL di questo articolo.

Se si sceglie di impostare l'ACL, è necessario aggiungere una voce per l'utente proprietario, una voce per il gruppo proprietario e una voce per tutti gli altri utenti. Per altre informazioni sull'utente proprietario, sul gruppo proprietario e su tutti gli altri utenti, vedere Utenti e identità.

Questa sezione illustra come:

  • Impostare l'ACL di una directory
  • Impostare l'ACL di un file
  • Impostare ricorsivamente gli elenchi di controllo di accesso

Impostare l'ACL di una directory

Questo esempio ottiene e successivamente imposta l'ACL di una directory denominata my-directory. In questo esempio vengono concesse all'utente le autorizzazioni di lettura, scrittura ed esecuzione proprietarie, concede al gruppo proprietario solo autorizzazioni di lettura ed esecuzione e concede a tutti gli altri utenti accesso in lettura.

  public void ManageDirectoryACLs(DataLakeFileSystemClient fileSystemClient){

      DataLakeDirectoryClient directoryClient =
        fileSystemClient.getDirectoryClient("");

      PathAccessControl directoryAccessControl =
          directoryClient.getAccessControl();

      List<PathAccessControlEntry> pathPermissions = directoryAccessControl.getAccessControlList();
     
      System.out.println(PathAccessControlEntry.serializeList(pathPermissions));
           
      RolePermissions groupPermission = new RolePermissions();
      groupPermission.setExecutePermission(true).setReadPermission(true);

      RolePermissions ownerPermission = new RolePermissions();
      ownerPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(true);

      RolePermissions otherPermission = new RolePermissions();
      otherPermission.setReadPermission(true);

      PathPermissions permissions = new PathPermissions();

      permissions.setGroup(groupPermission);
      permissions.setOwner(ownerPermission);
      permissions.setOther(otherPermission);

      directoryClient.setPermissions(permissions, null, null);

      pathPermissions = directoryClient.getAccessControl().getAccessControlList();
   
      System.out.println(PathAccessControlEntry.serializeList(pathPermissions));

  }

È anche possibile ottenere e impostare l'ACL della directory radice di un contenitore. Per ottenere la directory radice, passare una stringa vuota ("") al metodo DataLakeFileSystemClient.getDirectoryClient.

Impostare l'ACL di un file

Questo esempio ottiene e successivamente imposta l'ACL di un file denominato upload-file.txt. In questo esempio vengono concesse all'utente le autorizzazioni di lettura, scrittura ed esecuzione proprietarie, concede al gruppo proprietario solo autorizzazioni di lettura ed esecuzione e concede a tutti gli altri utenti accesso in lettura.

 public void ManageFileACLs(DataLakeFileSystemClient fileSystemClient){

     DataLakeDirectoryClient directoryClient =
       fileSystemClient.getDirectoryClient("my-directory");

     DataLakeFileClient fileClient = 
       directoryClient.getFileClient("uploaded-file.txt");

     PathAccessControl fileAccessControl =
         fileClient.getAccessControl();

   List<PathAccessControlEntry> pathPermissions = fileAccessControl.getAccessControlList();
  
   System.out.println(PathAccessControlEntry.serializeList(pathPermissions));
        
   RolePermissions groupPermission = new RolePermissions();
   groupPermission.setExecutePermission(true).setReadPermission(true);

   RolePermissions ownerPermission = new RolePermissions();
   ownerPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(true);

   RolePermissions otherPermission = new RolePermissions();
   otherPermission.setReadPermission(true);

   PathPermissions permissions = new PathPermissions();

   permissions.setGroup(groupPermission);
   permissions.setOwner(ownerPermission);
   permissions.setOther(otherPermission);

   fileClient.setPermissions(permissions, null, null);

   pathPermissions = fileClient.getAccessControl().getAccessControlList();

   System.out.println(PathAccessControlEntry.serializeList(pathPermissions));

 }

Impostare ricorsivamente gli elenchi di controllo di accesso

Impostare ACL in modo ricorsivo chiamando il metodo DataLakeDirectoryClient.setAccessControlRecursive. Passare questo metodo a un elenco di oggetti PathAccessControlEntry. Ogni PathAccessControlEntry definisce una voce ACL.

Se si desidera impostare una voce ACL predefinita, è possibile chiamare il metodo setDefaultScope del PathAccessControlEntry e inserire un valore true.

In questo esempio viene impostato l'ACL di una directory denominata my-parent-directory. Questo metodo accetta un parametro booleano denominato isDefaultScope che specifica se impostare l'ACL predefinito. Questo parametro viene usato in ogni chiamata al metodo setDefaultScope di PathAccessControlEntry. Le voci dell'ACL concedono all'utente le autorizzazioni di lettura, scrittura ed esecuzione proprietarie, concedono al gruppo proprietario solo autorizzazioni di lettura ed esecuzione e non concedono a tutti gli altri utenti alcun accesso. L'ultima voce ACL in questo esempio fornisce a un utente specifico le autorizzazioni di lettura ed esecuzione con l'ID oggetto "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".

public void SetACLRecursively(DataLakeFileSystemClient fileSystemClient, Boolean isDefaultScope){
    
    DataLakeDirectoryClient directoryClient =
        fileSystemClient.getDirectoryClient("my-parent-directory");

    List<PathAccessControlEntry> pathAccessControlEntries = 
        new ArrayList<PathAccessControlEntry>();

    // Create owner entry.
    PathAccessControlEntry ownerEntry = new PathAccessControlEntry();

    RolePermissions ownerPermission = new RolePermissions();
    ownerPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(true);

    ownerEntry.setDefaultScope(isDefaultScope);
    ownerEntry.setAccessControlType(AccessControlType.USER);
    ownerEntry.setPermissions(ownerPermission);

    pathAccessControlEntries.add(ownerEntry);

    // Create group entry.
    PathAccessControlEntry groupEntry = new PathAccessControlEntry();

    RolePermissions groupPermission = new RolePermissions();
    groupPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(false);

    groupEntry.setDefaultScope(isDefaultScope);
    groupEntry.setAccessControlType(AccessControlType.GROUP);
    groupEntry.setPermissions(groupPermission);

    pathAccessControlEntries.add(groupEntry);

    // Create other entry.
    PathAccessControlEntry otherEntry = new PathAccessControlEntry();

    RolePermissions otherPermission = new RolePermissions();
    otherPermission.setExecutePermission(false).setReadPermission(false).setWritePermission(false);

    otherEntry.setDefaultScope(isDefaultScope);
    otherEntry.setAccessControlType(AccessControlType.OTHER);
    otherEntry.setPermissions(otherPermission);

    pathAccessControlEntries.add(otherEntry);

    // Create named user entry.
    PathAccessControlEntry userEntry = new PathAccessControlEntry();

    RolePermissions userPermission = new RolePermissions();
    userPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(false);

    userEntry.setDefaultScope(isDefaultScope);
    userEntry.setAccessControlType(AccessControlType.USER);
    userEntry.setEntityId("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
    userEntry.setPermissions(userPermission);    
    
    pathAccessControlEntries.add(userEntry);
    
    directoryClient.setAccessControlRecursive(pathAccessControlEntries);        

}

Aggiornare gli elenchi di controllo di accesso

Quando si aggiorna un ACL, si modifica l'ACL anziché sostituirlo. Ad esempio, è possibile aggiungere una nuova entità di sicurezza all'ACL senza influire sulle altre entità di sicurezza elencate nell'ACL. Per sostituire l'ACL invece di aggiornarlo, vedere la sezione Impostare gli ACL di questo articolo.

Questa sezione illustra come:

  • Aggiornare un ACL
  • Aggiornare gli ACL in modo ricorsivo

Aggiornare un ACL

Prima di tutto, ottenere l'ACL di una directory chiamando il metodo PathAccessControl.getAccessControlList. Copiare l'elenco di voci ACL in un nuovo oggetto Elenco di tipo PathAccessControlListEntry. Individuare quindi la voce da aggiornare e sostituirla nell'elenco. Impostare l'ACL chiamando il metodo DataLakeDirectoryClient.setAccessControlList.

In questo esempio viene aggiornato l'elenco di controllo di accesso di una directory denominata my-parent-directory sostituendo la voce per tutti gli altri utenti.

   public void UpdateACL(DataLakeFileSystemClient fileSystemClient, Boolean isDefaultScope){

       DataLakeDirectoryClient directoryClient =
       fileSystemClient.getDirectoryClient("my-parent-directory");

       List<PathAccessControlEntry> pathAccessControlEntries = 
           directoryClient.getAccessControl().getAccessControlList();

       int index = -1;

       for (PathAccessControlEntry pathAccessControlEntry : pathAccessControlEntries){
           
           if (pathAccessControlEntry.getAccessControlType() == AccessControlType.OTHER){
               index = pathAccessControlEntries.indexOf(pathAccessControlEntry);
               break;
           }
       }

       if (index > -1){

       PathAccessControlEntry userEntry = new PathAccessControlEntry();

       RolePermissions userPermission = new RolePermissions();
       userPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(true);

       userEntry.setDefaultScope(isDefaultScope);
       userEntry.setAccessControlType(AccessControlType.OTHER);
       userEntry.setPermissions(userPermission);  
       
       pathAccessControlEntries.set(index, userEntry);
       }

       directoryClient.setAccessControlList(pathAccessControlEntries, 
           directoryClient.getAccessControl().getGroup(), 
           directoryClient.getAccessControl().getOwner());
   
   }

È anche possibile ottenere e impostare l'ACL della directory radice di un contenitore. Per ottenere la directory radice, passare una stringa vuota ("") al metodo DataLakeFileSystemClient.getDirectoryClient.

Aggiornare gli ACL in modo ricorsivo

Per aggiornare un ACL in modo ricorsivo, creare un nuovo oggetto ACL con la voce ACL da aggiornare, quindi usare tale oggetto nell'operazione di aggiornamento ACL. Non ottenere l'ACL esistente, specificare solo le voci ACL da aggiornare.

Aggiornare gli ACL in modo ricorsivo chiamando il metodo DataLakeDirectoryClient.updateAccessControlRecursive. Passare questo metodo a un elenco di oggetti PathAccessControlEntry. Ogni PathAccessControlEntry definisce una voce ACL.

Se si desidera aggiornare una voce ACL predefinita, è possibile chiamare il metodo setDefaultScope del PathAccessControlEntry e inserire un valore true.

In questo esempio viene aggiornata una voce ACL con autorizzazione di scrittura. Questo metodo accetta un parametro booleano denominato isDefaultScope che specifica se aggiornare l'ACL predefinito. Tale parametro viene usato nella chiamata al metodo setDefaultScope di PathAccessControlEntry.

public void UpdateACLRecursively(DataLakeFileSystemClient fileSystemClient, Boolean isDefaultScope){

    DataLakeDirectoryClient directoryClient =
    fileSystemClient.getDirectoryClient("my-parent-directory");

    List<PathAccessControlEntry> pathAccessControlEntries = 
        new ArrayList<PathAccessControlEntry>();

    // Create named user entry.
    PathAccessControlEntry userEntry = new PathAccessControlEntry();

    RolePermissions userPermission = new RolePermissions();
    userPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(true);

    userEntry.setDefaultScope(isDefaultScope);
    userEntry.setAccessControlType(AccessControlType.USER);
    userEntry.setEntityId("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
    userEntry.setPermissions(userPermission);    
    
    pathAccessControlEntries.add(userEntry);
    
    directoryClient.updateAccessControlRecursive(pathAccessControlEntries);        

}

Rimuovere le voci ACL

È possibile rimuovere una o più voci ACL. Questa sezione illustra come:

  • Rimuovere una voce ACL
  • Rimuovere le voci ACL in modo ricorsivo

Rimuovere una voce ACL

Prima di tutto, ottenere l'ACL di una directory chiamando il metodo PathAccessControl.getAccessControlList. Copiare l'elenco di voci ACL in un nuovo oggetto Elenco di tipo PathAccessControlListEntry. Individuare quindi la voce da rimuovere e chiamare il metodo Rimuovi dell'oggetto Elenco. Impostare l'ACL aggiornato chiamando il metodo DataLakeDirectoryClient.setAccessControlList.

 public void RemoveACLEntry(DataLakeFileSystemClient fileSystemClient, Boolean isDefaultScope){

     DataLakeDirectoryClient directoryClient =
     fileSystemClient.getDirectoryClient("my-parent-directory");

     List<PathAccessControlEntry> pathAccessControlEntries = 
         directoryClient.getAccessControl().getAccessControlList();

     PathAccessControlEntry entryToRemove = null;

     for (PathAccessControlEntry pathAccessControlEntry : pathAccessControlEntries){
         
         if (pathAccessControlEntry.getEntityId() != null){

             if (pathAccessControlEntry.getEntityId().equals("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")){
                 entryToRemove = pathAccessControlEntry;
                 break;
             }
         }

     }

     if (entryToRemove != null){
         
         pathAccessControlEntries.remove(entryToRemove);

         directoryClient.setAccessControlList(pathAccessControlEntries, 
         directoryClient.getAccessControl().getGroup(), 
         directoryClient.getAccessControl().getOwner());   
     }

 
 }

Rimuovere le voci ACL in modo ricorsivo

Per rimuovere le voci ACL in modo ricorsivo, creare un nuovo oggetto ACL per la voce ACL da rimuovere, quindi usare tale oggetto nell'operazione di rimozione dell'elenco di controllo di accesso. Non ottenere l'ACL esistente, specificare solo le voci ACL da rimuovere.

Rimuovere le voci ACL chiamando il metodo DataLakeDirectoryClient.removeAccessControlRecursive. Passare questo metodo a un elenco di oggetti PathAccessControlEntry. Ogni PathAccessControlEntry definisce una voce ACL.

Se si desidera rimuovere una voce ACL predefinita, è possibile chiamare il metodo setDefaultScope del PathAccessControlEntry e inserire un valore true.

In questo esempio viene rimossa una voce ACL dall'ACL della directory denominata my-parent-directory. Questo metodo accetta un parametro booleano denominato isDefaultScope che specifica se rimuovere la voce dall'ACL predefinito. Tale parametro viene usato nella chiamata al metodo setDefaultScope di PathAccessControlEntry.

  public void RemoveACLEntryRecursively(DataLakeFileSystemClient fileSystemClient, Boolean isDefaultScope){

      DataLakeDirectoryClient directoryClient =
      fileSystemClient.getDirectoryClient("my-parent-directory");

      List<PathRemoveAccessControlEntry> pathRemoveAccessControlEntries = 
          new ArrayList<PathRemoveAccessControlEntry>();

      // Create named user entry.
      PathRemoveAccessControlEntry userEntry = new PathRemoveAccessControlEntry();

      RolePermissions userPermission = new RolePermissions();
      userPermission.setExecutePermission(true).setReadPermission(true).setWritePermission(true);

      userEntry.setDefaultScope(isDefaultScope);
      userEntry.setAccessControlType(AccessControlType.USER);
      userEntry.setEntityId("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"); 
      
      pathRemoveAccessControlEntries.add(userEntry);
      
      directoryClient.removeAccessControlRecursive(pathRemoveAccessControlEntries);      
  
  }

Ripristino da errori

Potrebbero verificarsi errori di runtime o di autorizzazione. Per gli errori di runtime, riavviare il processo dall'inizio. Gli errori di autorizzazione possono verificarsi se l'entità di sicurezza non dispone di autorizzazioni sufficienti per modificare l'ACL di una directory o di un file presente nella gerarchia di directory da modificare. Risolvere il problema di autorizzazione, quindi scegliere di riprendere il processo dal punto di errore usando un token di continuazione o riavviare il processo dall'inizio. Non è necessario usare il token di continuazione se si preferisce riavviare dall'inizio. È possibile riapplicare le voci ACL senza alcun impatto negativo.

In questo esempio viene restituito un token di continuazione in caso di errore. L'applicazione può chiamare di nuovo questo metodo di esempio dopo aver risolto l'errore e passare il token di continuazione. Se questo metodo di esempio viene chiamato per la prima volta, l'applicazione può passare un valore di null per il parametro del token di continuazione.

public String ResumeSetACLRecursively(DataLakeFileSystemClient fileSystemClient,
    DataLakeDirectoryClient directoryClient,
    List<PathAccessControlEntry> accessControlList, 
    String continuationToken){

    try{
        PathSetAccessControlRecursiveOptions options = new PathSetAccessControlRecursiveOptions(accessControlList);
        
        options.setContinuationToken(continuationToken);
    
       Response<AccessControlChangeResult> accessControlChangeResult =  
          directoryClient.setAccessControlRecursiveWithResponse(options, null, null);

       if (accessControlChangeResult.getValue().getCounters().getFailedChangesCount() > 0)
       {
          continuationToken =
              accessControlChangeResult.getValue().getContinuationToken();
       }
    
       return continuationToken;

    }
    catch(Exception ex){
    
        System.out.println(ex.toString());
        return continuationToken;
    }


}

Se si desidera che il processo venga completato senza interruzioni dagli errori di autorizzazione, è possibile specificare tale fatto.

Per garantire che il processo venga completato senza interruzioni, chiamare il metodo setContinueOnFailure di un oggetto PathSetAccessControlRecursiveOptions e inserire un valore true.

Questo esempio imposta le voci ACL in modo ricorsivo. Se questo codice rileva un errore di autorizzazione, registra l'errore e continua l'esecuzione. In questo esempio viene stampato il numero di errori nella console.

public void ContinueOnFailure(DataLakeFileSystemClient fileSystemClient,
    DataLakeDirectoryClient directoryClient,
    List<PathAccessControlEntry> accessControlList){
    
    PathSetAccessControlRecursiveOptions options = 
       new PathSetAccessControlRecursiveOptions(accessControlList);
        
    options.setContinueOnFailure(true);
    
    Response<AccessControlChangeResult> accessControlChangeResult =  
        directoryClient.setAccessControlRecursiveWithResponse(options, null, null);

    AccessControlChangeCounters counters = accessControlChangeResult.getValue().getCounters();

    System.out.println("Number of directories changes: " + 
        counters.getChangedDirectoriesCount());

    System.out.println("Number of files changed: " + 
        counters.getChangedDirectoriesCount());

    System.out.println("Number of failures: " + 
        counters.getChangedDirectoriesCount());
}

Procedure consigliate

Questa sezione fornisce alcune linee guida sulle procedure consigliate per l'impostazione degli ACL in modo ricorsivo.

Gestione degli errori di runtime

Un errore di runtime può verificarsi per molti motivi (ad esempio, un'interruzione o un problema di connettività client). Se si verifica un errore di runtime, riavviare il processo ACL ricorsivo. Gli ACL possono essere riapplicati agli elementi senza causare un impatto negativo.

Gestione degli errori di autorizzazione (403)

Se si verifica un'eccezione di controllo di accesso durante l'esecuzione di un processo ACL ricorsivo, l'entità di sicurezza di Active Directory potrebbe non disporre di autorizzazioni sufficienti per applicare un ACL a uno o più elementi figlio nella gerarchia di directory. Quando si verifica un errore di autorizzazione, il processo viene arrestato e viene fornito un token di continuazione. Risolvere il problema di autorizzazione, quindi usare il token di continuazione per elaborare il set di dati rimanente. Le directory e i file che sono già stati elaborati correttamente non dovranno essere elaborati di nuovo. È anche possibile scegliere di riavviare il processo ACL ricorsivo. Gli ACL possono essere riapplicati agli elementi senza causare un impatto negativo.

Credenziali

È consigliabile effettuare il provisioning di un'entità di sicurezza di Microsoft Entra assegnata al ruolo Proprietario dati BLOB di archiviazione nell'ambito dell'account di archiviazione o del contenitore di destinazione.

Prestazioni

Per ridurre la latenza, è consigliabile eseguire il processo ACL ricorsivo in una macchina virtuale di Azure che si trova nella stessa area dell'account di archiviazione.

Limiti ACL

Il numero massimo di ACL che è possibile applicare a una directory o a un file è 32 ACL di accesso e 32 ACL predefiniti. Per altre informazioni, vedere Access control in Azure Data Lake Storage Gen2 (Controllo di accesso in Azure Data Lake Storage Gen2).

Vedi anche