Usar Java para gerenciar ACLs no Armazenamento do Azure Data Lake

Este artigo mostra como usar o Java para obter, definir e atualizar as listas de controle de acesso de diretórios e arquivos.

A herança de ACL já está disponível para novos itens subordinados que são criados num diretório principal. Mas você também pode adicionar, atualizar e remover ACLs recursivamente nos itens filho existentes de um diretório pai sem ter que fazer essas alterações individualmente para cada item filho.

Pacote (Maven) | Exemplos | API referência | Gen1 para Gen2 mapeamento | Dar feedback

Pré-requisitos

• Subscrição do Azure - crie uma gratuitamente.
• Conta de armazenamento do Azure que tem namespace hierárquico (HNS) habilitado. Siga estas instruções para criar um.
• Java Development Kit (JDK) versão 8 ou superior.
• O Apache Maven é usado para gerenciamento de projetos neste exemplo.
• Versão da CLI 2.6.0 do Azure ou superior.
• Uma das seguintes permissões de segurança:
  • Uma entidade de segurança de ID do Microsoft Entra provisionada à qual foi atribuída a função de Proprietário de Dados do Blob de Armazenamento, com escopo para o contêiner de destino, conta de armazenamento, grupo de recursos pai ou assinatura.
  • Usuário proprietário do contêiner ou diretório de destino ao qual você planeja aplicar as configurações da ACL. Para definir ACLs recursivamente, isso inclui todos os itens filho no contêiner ou diretório de destino.
  • Chave da conta de armazenamento.

Configure o seu projeto

Use o Maven para criar um novo aplicativo de console ou abrir um projeto existente. Siga estas etapas para instalar pacotes e adicionar as diretivas necessárias import .

Instalar pacotes

Abra o arquivo no editor de pom.xml texto. Instale os pacotes incluindo o arquivo BOM ou incluindo uma dependência direta.

Incluir o arquivo BOM

Adicione azure-sdk-bom para depender da versão mais recente da biblioteca. No trecho a seguir, substitua o espaço reservado {bom_version_to_target} pelo número da versão. Usar azure-sdk-bom evita que você precise especificar a versão de cada dependência individual. Para saber mais sobre a lista técnica, consulte o Leiame da lista técnica do SDK do Azure.

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

Adicione os seguintes elementos de dependência ao grupo de dependências. A dependência azure-identity é necessária para conexões sem senha com os serviços do 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>

Incluir uma dependência direta

Para assumir a dependência de uma versão específica da biblioteca, adicione a dependência direta ao seu projeto:

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

Incluir diretivas de importação

Acrescentar as diretivas necessárias import . Neste exemplo, adicionamos as seguintes diretivas no arquivo 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;

Conecte-se à conta

Para executar os exemplos de código neste artigo, você precisa criar uma instância DataLakeServiceClient que represente a conta de armazenamento. Você pode autorizar o objeto cliente com credenciais do Microsoft Entra ID ou com uma chave de conta.

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

static public DataLakeServiceClient GetDataLakeServiceClient
(String accountName, String accountKey){
    StorageSharedKeyCredential sharedKeyCredential =
        new StorageSharedKeyCredential(accountName, accountKey);

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

    return dataLakeServiceClient;
}

Definir ACLs

Ao definir uma ACL, você substitui a ACL inteira, incluindo todas as suas entradas. Se desejar alterar o nível de permissão de uma entidade de segurança ou adicionar uma nova entidade de segurança à ACL sem afetar outras entradas existentes, atualize a ACL. Para atualizar uma ACL em vez de substituí-la, consulte a seção Atualizar ACLs deste artigo.

Se você optar por definir a ACL, deverá adicionar uma entrada para o usuário proprietário, uma entrada para o grupo proprietário e uma entrada para todos os outros usuários. Para saber mais sobre o usuário proprietário, o grupo proprietário e todos os outros usuários, consulte Usuários e identidades.

Esta seção mostra como:

• Definir a ACL de um diretório
• Definir a ACL de um arquivo
• Definir ACLs recursivamente

Definir a ACL de um diretório

Este exemplo obtém e define a ACL de um diretório chamado my-directory. Este exemplo dá ao usuário proprietário permissões de leitura, gravação e execução, concede ao grupo proprietário apenas permissões de leitura e execução e concede a todos os outros acesso de leitura.

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

  }

Você também pode obter e definir a ACL do diretório raiz de um contêiner. Para obter o diretório raiz, passe uma cadeia de caracteres vazia ("") para o método DataLakeFileSystemClient.getDirectoryClient .

Definir a ACL de um arquivo

Este exemplo obtém e define a ACL de um arquivo chamado upload-file.txt. Este exemplo dá ao usuário proprietário permissões de leitura, gravação e execução, concede ao grupo proprietário apenas permissões de leitura e execução e concede a todos os outros acesso de leitura.

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

 }

Definir ACLs recursivamente

Defina ACLs recursivamente chamando o método DataLakeDirectoryClient.setAccessControlRecursive . Passe esse método para List de objetos PathAccessControlEntry. Cada PathAccessControlEntry define uma entrada ACL.

Se você quiser definir uma entrada ACL padrão , então você pode chamar o método setDefaultScope do PathAccessControlEntry e passar um valor de true.

Este exemplo define a ACL de um diretório chamado my-parent-directory. Esse método aceita um parâmetro booleano chamado isDefaultScope que especifica se a ACL padrão deve ser definida. Esse parâmetro é usado em cada chamada para o método setDefaultScope do PathAccessControlEntry. As entradas da ACL dão ao usuário proprietário permissões de leitura, gravação e execução, dá ao grupo proprietário apenas permissões de leitura e execução e não dá acesso a todos os outros. A última entrada ACL neste exemplo fornece a um usuário específico com o ID de objeto "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" permissões de leitura e execução.

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

}

Atualizar ACLs

Ao atualizar uma ACL, você modifica a ACL em vez de substituí-la. Por exemplo, você pode adicionar uma nova entidade de segurança à ACL sem afetar outras entidades de segurança listadas na ACL. Para substituir a ACL em vez de atualizá-la, consulte a seção Definir ACLs deste artigo.

Esta seção mostra como:

• Atualizar uma ACL
• Atualizar ACLs recursivamente

Atualizar uma ACL

Primeiro, obtenha a ACL de um diretório chamando o método PathAccessControl.getAccessControlList . Copie a lista de entradas ACL para um novo objeto List do tipo PathAccessControlListEntry. Em seguida, localize a entrada que você deseja atualizar e substitua-a na lista. Defina a ACL chamando o método DataLakeDirectoryClient.setAccessControlList .

Este exemplo atualiza a ACL de um diretório nomeado my-parent-directory substituindo a entrada para todos os outros usuários.

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

Você também pode obter e definir a ACL do diretório raiz de um contêiner. Para obter o diretório raiz, passe uma cadeia de caracteres vazia ("") para o método DataLakeFileSystemClient.getDirectoryClient .

Atualizar ACLs recursivamente

Para atualizar uma ACL recursivamente, crie um novo objeto ACL com a entrada ACL que você deseja atualizar e use esse objeto na operação de atualização da ACL. Não obtenha a ACL existente, apenas forneça entradas de ACL para serem atualizadas.

Atualize as ACLs recursivamente chamando o método DataLakeDirectoryClient.updateAccessControlRecursive . Passe esse método para List de objetos PathAccessControlEntry. Cada PathAccessControlEntry define uma entrada ACL.

Se você quiser atualizar uma entrada de ACL padrão , então você pode chamar o método setDefaultScope do PathAccessControlEntry e passar um valor de true.

Este exemplo atualiza uma entrada ACL com permissão de gravação. Esse método aceita um parâmetro booleano chamado isDefaultScope que especifica se a ACL padrão deve ser atualizada. Esse parâmetro é usado na chamada para o método setDefaultScope do 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);        

}

Remover entradas da ACL

Você pode remover uma ou mais entradas da ACL. Esta seção mostra como:

• Remover uma entrada de ACL
• Remover entradas da ACL recursivamente

Remover uma entrada de ACL

Primeiro, obtenha a ACL de um diretório chamando o método PathAccessControl.getAccessControlList . Copie a lista de entradas ACL para um novo objeto List do tipo PathAccessControlListEntry. Em seguida, localize a entrada que você deseja remover e chame o método Remove do objeto List . Defina a ACL atualizada chamando o método 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());   
     }

 
 }

Remover entradas da ACL recursivamente

Para remover entradas ACL recursivamente, crie um novo objeto ACL para entrada ACL a ser removida e, em seguida, use esse objeto na operação remover ACL. Não obtenha a ACL existente, apenas forneça as entradas da ACL a serem removidas.

Remova as entradas da ACL chamando o método DataLakeDirectoryClient.removeAccessControlRecursive . Passe esse método para List de objetos PathAccessControlEntry. Cada PathAccessControlEntry define uma entrada ACL.

Se você quiser remover uma entrada ACL padrão , então você pode chamar o método setDefaultScope do PathAccessControlEntry e passar um valor de true.

Este exemplo remove uma entrada ACL da ACL do diretório chamado my-parent-directory. Esse método aceita um parâmetro booleano chamado isDefaultScope que especifica se a entrada deve ser removida da ACL padrão. Esse parâmetro é usado na chamada para o método setDefaultScope do 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);      
  
  }

Recupere-se de falhas

Você pode encontrar erros de tempo de execução ou permissão. Para erros de tempo de execução, reinicie o processo desde o início. Erros de permissão podem ocorrer se a entidade de segurança não tiver permissão suficiente para modificar a ACL de um diretório ou arquivo que está na hierarquia de diretórios que está sendo modificada. Resolva o problema de permissão e, em seguida, opte por retomar o processo a partir do ponto de falha usando um token de continuação ou reiniciar o processo desde o início. Você não precisa usar o token de continuação se preferir reiniciar desde o início. Você pode reaplicar entradas de ACL sem qualquer impacto negativo.

Este exemplo retorna um token de continuação em caso de falha. O aplicativo pode chamar esse método de exemplo novamente após o erro ter sido resolvido e passar o token de continuação. Se esse método de exemplo for chamado pela primeira vez, o aplicativo poderá passar um valor de para o parâmetro de token de null continuação.

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 desejar que o processo seja concluído ininterruptamente por erros de permissão, você pode especificar isso.

Para garantir que o processo seja concluído ininterruptamente, chame o método setContinueOnFailure de um objeto PathSetAccessControlRecursiveOptions e passe um valor true.

Este exemplo define entradas ACL recursivamente. Se esse código encontrar um erro de permissão, ele registrará essa falha e continuará a execução. Este exemplo imprime o número de falhas no 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());
}

Melhores práticas

Esta seção fornece algumas diretrizes de práticas recomendadas para definir ACLs recursivamente.

Manipulando erros de tempo de execução

Um erro de tempo de execução pode ocorrer por vários motivos (por exemplo: uma interrupção ou um problema de conectividade do cliente). Se você encontrar um erro de tempo de execução, reinicie o processo de ACL recursivo. As ACLs podem ser reaplicadas aos itens sem causar um impacto negativo.

Manipulando erros de permissão (403)

Se você encontrar uma exceção de controle de acesso ao executar um processo de ACL recursivo, sua entidade de segurança do AD pode não ter permissão suficiente para aplicar uma ACL a um ou mais itens filho na hierarquia de diretórios. Quando ocorre um erro de permissão, o processo para e um token de continuação é fornecido. Corrija o problema de permissão e use o token de continuação para processar o conjunto de dados restante. Os diretórios e arquivos que já foram processados com sucesso não precisarão ser processados novamente. Você também pode optar por reiniciar o processo de ACL recursiva. As ACLs podem ser reaplicadas aos itens sem causar um impacto negativo.

Credenciais

Recomendamos que você provisione uma entidade de segurança do Microsoft Entra à qual tenha sido atribuída a função de Proprietário de Dados do Blob de Armazenamento no escopo da conta ou contêiner de armazenamento de destino.

Desempenho

Para reduzir a latência, recomendamos que você execute o processo de ACL recursiva em uma máquina virtual (VM) do Azure localizada na mesma região da sua conta de armazenamento.

Limites do LCA

O número máximo de ACLs que você pode aplicar a um diretório ou arquivo é de 32 ACLs de acesso e 32 ACLs padrão. Para obter mais informações, veja Controlo de acesso no Azure Data Lake Storage Gen2.

Consulte também

• Documentação de referência da API
• Pacote (Maven)
• Amostras
• Mapeamento de Gen1 para Gen2
• Problemas conhecidos
• Enviar comentários
• Modelo de controle de acesso no Armazenamento do Azure Data Lake
• Listas de controlo de acesso (ACL) do Azure Data Lake Storage