Usar Java para gerenciar ACLs no Azure Data Lake Storage Gen2
Este artigo mostra como usar 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 filho criados em um diretório pai. Mas você também pode adicionar, atualizar e remover ACLs recursivamente nos itens filho existentes de um diretório pai sem precisar fazer essas alterações individualmente em cada item filho.
Pacote (Maven) | Exemplos | Referência de API | Mapeamento de Gen1 para Gen2 | Dar feedback
Pré-requisitos
Uma assinatura do Azure. Consulte Obter a avaliação gratuita do Azure.
Uma conta de armazenamento precisa ter o HNS (namespace hierárquico) habilitado. Siga estas instruções para criar um.
CLI do Azure versão
2.6.0ou superiorUma das seguintes permissões de segurança:
Uma entidade de segurança do Microsoft Entra ID provisionada à qual foi atribuída a função de Proprietário de Dados do Blob de Armazenamento no escopo do contêiner, conta de armazenamento, grupo de recursos pai ou assinatura de destino.
Usuário proprietário do contêiner ou diretório de destino ao qual você planeja aplicar as configurações de ACL. Para definir ACLs recursivamente, isso inclui todos os itens filho no contêiner ou diretório de destino.
Chave de conta de armazenamento.
Configurar o seu projeto
Para começar, abra esta página e localize a versão mais recente da biblioteca do Java. Abra o arquivo pom.xml no editor de texto. Adicione um elemento de dependência que faz referência a essa versão.
Se você planeja autenticar seu aplicativo cliente usando o Microsoft Entra ID, adicione uma dependência à Biblioteca de Clientes Secretos do Azure. Veja Adicionar o pacote de biblioteca de clientes secretos ao projeto.
Em seguida, adicione essas instruções de importação ao arquivo de código.
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;
Conectar à conta
Para usar os trechos de código neste artigo, será necessário criar uma instância de DataLakeServiceClient que representa a conta de armazenamento.
Conectar usando o Microsoft Entra ID
É possível usar a Biblioteca de clientes de identidade do Azure para Java para autenticar o aplicativo com o Microsoft Entra ID.
Como parte desse processo, primeiro será necessário atribuir uma das seguintes funções do RBAC do Azure (controle de acesso baseado em função do Azure) à sua entidade de segurança:
| Função | Capacidade de configuração de ACL |
|---|---|
| Proprietário de Dados do Blob de Armazenamento | Todos os diretórios e arquivos na conta. |
| Colaborador de dados de blob de armazenamento | Somente diretórios e arquivos de propriedade da entidade de segurança. |
Em seguida, crie uma instância DataLakeServiceClient e passe em uma nova instância da 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;
}
Para saber mais sobre como usar DefaultAzureCredential para autorizar o acesso aos dados, consulte Biblioteca de clientes da Identidade do Azure para Java.
Conectar-se usando uma chave de conta
Você pode autorizar o acesso aos dados usando as chaves de acesso da sua conta (Chave Compartilhada). Esse exemplo cria uma instância DataLakeServiceClient autorizada com a chave de conta.
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;
}
Cuidado
A autorização com Chave Compartilhada não é recomendada, pois pode ser menos segura. Para uma segurança ideal, desabilite a autorização por meio da Chave Compartilhada para sua conta de armazenamento, conforme descrito em Impedir autorização de Chave Compartilhada para uma conta do Armazenamento do Microsoft Azure.
O uso de chaves de acesso e cadeias de conexão deve ser limitado a aplicativos iniciais de prova de conceito ou protótipos de desenvolvimento que não acessem dados confidenciais ou de produção. Caso contrário, as classes de autenticação baseadas em token disponíveis no SDK do Azure devem ser sempre preferenciais ao autenticar recursos do Azure.
A Microsoft recomenda que os clientes usem o Microsoft Entra ID ou uma assinatura de acesso compartilhado (SAS) para autorizar o acesso aos dados no Armazenamento do Microsoft Azure. Para obter mais informações, confira Autorizar operações para acesso a dados.
Definir ACLs
Aodefiniruma ACL, vocêsubstitui toda a ACL, incluindo todas as entradas. Se você quiser 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, deverá atualizar a ACL. Para atualizar uma ACL em vez de substituí-la, confira a seção Atualizar ACLs deste artigo.
Se você optar pordefinira 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, confira Usuários e identidades.
Esta seção mostra como:
- Definir o ACL de um diretório
- Definir o ACL de um arquivo
- Definir ACLs recursivamente
Definir o ACL de um diretório
Este exemplo obtém e define a ACL de um diretório chamado my-directory. Este exemplo fornece ao o usuário proprietário as permissões de leitura, gravação e execução, fornece ao grupo proprietário somente 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));
}
Também é possível 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 o ACL de um arquivo
Este exemplo obtém e define a ACL de um arquivo denominado upload-file.txt. Este exemplo fornece ao o usuário proprietário as permissões de leitura, gravação e execução, fornece ao grupo proprietário somente 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 as ACLs recursivamente chamando o método deDataLakeDirectoryClient.setAccessControlRecursiveAsync. Passe este método a umaListadeobjetos PathAccessControlItem. TodaPathAccessControlItemdefine uma entrada de ACL.
Se você quiser definir uma entradade ACL padrão, poderá chamar o método desetDefaultScopedoPathAccessControlEntrye passar um valorverdadeiro positivo.
Este exemplo define a ACL de um diretório denominado my-parent-directory. Esse método aceita um parâmetro booliano nomeadoisDefaultScopeque especifica se a ACL padrão deve ser definida. Esse parâmetro é usado em cada chamada para ométodo setDefaultScopedoPathAccessControlEntry. As entradas do ACL fornecem as permissões de leitura, gravação e execução do usuário proprietário, fornecem ao grupo proprietário somente permissões de leitura e execução e não concedem acessos a todos os outros. A última entrada de ACL neste exemplo fornece um usuário específico com a 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
AoAtualizaruma ACL, você modifica a ACL em vez de substituir a ACL. 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, confira a seção Definir ACLsdeste 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 de métodoPathAccessControl. Getaccesscontrollist. Copie a lista de entradas de ACL para uma nova lista deobjetosdo tipoPathAccessControlListEntry. Em seguida, localize a entrada que você deseja atualizar e substitua-a na lista. Defina a ACL chamando-o de métodoDataLakeDirectoryClient.setaccesscontrollist.
Este exemplo atualiza a ACL de um diretório chamadomy-parent-directory substituindo a entrada de ACL 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());
}
Também é possível 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 de ACL que você deseja atualizar e, em seguida, use esse objeto na operação atualizar a ACL. Não obtenha a ACL existente, basta fornecer as entradas de ACL a serem atualizadas.
Atualize as ACLs recursivamente chamando o método deDataLakeDirectoryClient.setAccessControlRecursiveAsync. Passe este método a umaListadeobjetos PathAccessControlItem. TodaPathAccessControlItemdefine uma entrada de ACL.
Se você quiser atualizar uma entrada ACL padrão, poderá chamar o métodosetDefaultScope do PathAccessControlEntry e passar um valor de verdadeiro.
Este exemplo atualiza uma entrada ACL com permissão de gravação. Este método aceita um parâmetro booliano chamado deisDefaultScope que especifica se a ACL padrão deve ser atualizada. Esse parâmetro é usado na chamada para ométodo setDefaultScopedoPathAccessControlEntry.
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 de ACL
Você pode remover uma ou mais entradas de ACL. Esta seção mostra como:
- Remover uma entrada de ACL
- Remover entradas de ACL recursivamente
Remover uma entrada de ACL
Primeiro, obtenha a ACL de um diretório chamando-o de métodoPathAccessControl. Getaccesscontrollist. Copie a lista de entradas de ACL para uma nova lista deobjetosdo tipoPathAccessControlListEntry. Em seguida, localize a entrada que você deseja remover e chame o métodoRemoverdo objetode Lista. Defina a ACL atualizada chamando-a de métodoDataLakeDirectoryClient. 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 de ACL recursivamente
Para remover as entradas de ACL recursivamente, crie um novo objeto ACL para a entrada de ACL a ser removida e, em seguida, use este objeto em remover a operação de ACL. Não obtenha a ACL existente, basta fornecer as entradas da ACL a serem removidas.
Remova as entradas de ACL chamando o método deDataLakeDirectoryClient. RemoveAccessControlRecursiveAsync. Passe este método a umaListadeobjetos PathAccessControlItem. TodaPathAccessControlItemdefine uma entrada de ACL.
Se você quiser remover uma entrada ACL padrão, poderá chamar o método desetDefaultScopedoPathAccessControlEntrye passar um valor deverdadeiro.
Este exemplo remove uma entrada ACL da ACL do diretório chamado my-parent-directory. Esse método aceita um parâmetro booliano chamado deisDefaultScope que especifica se a ACL padrão deve ser removida. Esse parâmetro é usado na chamada para ométodo setDefaultScopedoPathAccessControlEntry.
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);
}
Recuperar de falhas
Talvez você encontre erros de runtime ou de permissão. Para erros de runtime, reinicie o processo desde o início. Poderão ocorrer erros de permissão 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ório que está sendo modificada. Resolva o problema de permissão e, em seguida, escolha retomar o processo no ponto de falha usando um token de continuação ou reiniciar o processo do início. Você não precisará usar o token de continuação se preferir reiniciar desde o início. É possível reaplicar entradas de ACL sem nenhum impacto negativo.
Este exemplo retorna um token de continuação no caso de uma falha. O aplicativo pode chamar esse método de exemplo novamente depois que o erro for 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 denullpara o parâmetro de token de 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 você quiser que o processo seja concluído sem interrupções por erros de permissão, poderá especificar isso.
Para garantir que o processo seja concluído sem interrupções, chame o método desetContinueOnFailure um objetoPathSetAccessControlRecursiveOptionse passe um valor deverdadeiro positivo.
Este exemplo define as entradas de 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());
}
Práticas recomendadas
Esta seção fornece algumas diretrizes de práticas recomendadas para definir as ACLs recursivamente.
Manipulanr erros de tempo de execução
Um erro de runtime pode ocorrer por vários motivos (por exemplo: uma interrupção ou um problema de conectividade de cliente). Se você encontrar um erro de runtime, reinicie o processo de ACL recursivo. As ACLs podem ser reaplicadas para itens sem causar um impacto negativo.
Tratamento de erros de permissão (403)
Se você encontrar uma exceção de controle de acesso durante a execução de um processo de ACL recursivo, a entidade de segurança do AD poderá não ter permissão suficiente para aplicar uma ACL a um ou mais dos itens filho na hierarquia de diretórios. Quando ocorre um erro de permissão, o processo é interrompido e um token de continuação é fornecido. Corrija o problema de permissão e, em seguida, use o token de continuação para processar o conjunto de dados restante. Os diretórios e arquivos que já foram processados com êxito não precisam ser processados novamente. Você também pode optar por reiniciar o processo de ACL recursivo. As ACLs podem ser reaplicadas para itens sem causar um impacto negativo.
Credenciais
Recomendamos que você provisione uma entidade de segurança do Microsoft Entra que tenha sido atribuída à função de proprietário de dados do blob de armazenamento no escopo da conta de armazenamento de destino ou do contêiner.
Desempenho
Para reduzir a latência, recomendamos que você execute o processo de ACL recursivo em uma Máquina Virtual (VM) do Azure localizada na mesma região que a sua conta de armazenamento.
Limites de ACL
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, consulte Controle de acesso no Azure Data Lake Storage Gen2.