Usare Python per gestire directory e file in Azure Data Lake Storage

Questo articolo illustra come usare Python per creare e gestire directory e file negli account di archiviazione con uno spazio dei nomi gerarchico.

Per informazioni su come ottenere, impostare e aggiornare gli elenchi di controllo di accesso (ACL) di directory e file, vedere Usare Python per gestire gli elenchi di controllo di accesso in Azure Data Lake Storage.

Pacchetto (PyPi) | Esempi | Riferimento API | Mapping da Gen1 a Gen2 | Invia commenti

Prerequisiti

Impostare il progetto

Questa sezione illustra come preparare un progetto da usare con la libreria client di Azure Data Lake Storage per Python.

Nella directory del progetto installare i pacchetti per le librerie client di Azure Data Lake Storage e Azure Identity usando il comando pip install. Il pacchetto azure-identity è necessario per le connessioni senza password ai servizi di Azure.

pip install azure-storage-file-datalake azure-identity

Aprire quindi il file di codice e aggiungere le istruzioni di importazione necessari. In questo esempio si aggiunge il codice seguente al file .py:

import os
from azure.storage.filedatalake import (
    DataLakeServiceClient,
    DataLakeDirectoryClient,
    FileSystemClient
)
from azure.identity import DefaultAzureCredential

Nota

L'accesso multi-protocollo in Data Lake Storage consente alle applicazioni di usare sia le API BLOB che le API Data Lake Storage Gen2 per lavorare con i dati negli account di archiviazione con spazio dei nomi gerarchico (HNS) abilitato. Quando si usano funzionalità specifiche di Data Lake Storage Gen2, ad esempio operazioni di directory e ACL, usare le API data Lake Storage Gen2, come illustrato in questo articolo.

Quando si scelgono le API da usare in uno scenario specifico, prendere in considerazione il carico di lavoro e le esigenze dell'applicazione, insieme ai problemi noti e all'impatto di HNS su carichi di lavoro e applicazioni.

Autorizzare l'accesso e connettersi alle risorse dati

Per usare gli esempi di codice in questo articolo, è necessario creare un'istanza di DataLakeServiceClient autorizzata che rappresenta l'account di archiviazione. È possibile autorizzare un DataLakeServiceClient oggetto usando Microsoft Entra ID, una chiave di accesso all'account o una firma di accesso condiviso.

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

Creare un'istanza della classe DataLakeServiceClient, passando un oggetto DefaultAzureCredential.

def get_service_client_token_credential(self, account_name) -> DataLakeServiceClient:
    account_url = f"https://{account_name}.dfs.core.windows.net"
    token_credential = DefaultAzureCredential()

    service_client = DataLakeServiceClient(account_url, credential=token_credential)

    return service_client

Per altre informazioni sull'uso DefaultAzureCredential di per autorizzare l'accesso ai dati, vedere Panoramica: Autenticare le app Python in Azure con Azure SDK.

Creazione di un contenitore

Un contenitore funge da file system per i file. È possibile creare un contenitore usando il metodo seguente:

L'esempio di codice seguente crea un contenitore e restituisce un oggetto FileSystemClient per un uso successivo:

def create_file_system(self, service_client: DataLakeServiceClient, file_system_name: str) -> FileSystemClient:
    file_system_client = service_client.create_file_system(file_system=file_system_name)

    return file_system_client

Crea una directory

È possibile creare un riferimento alla directory nel contenitore usando il metodo seguente:

Nell'esempio di codice seguente viene aggiunta una directory a un contenitore e viene restituito un oggetto DataLakeDirectoryClient per un uso successivo:

def create_directory(self, file_system_client: FileSystemClient, directory_name: str) -> DataLakeDirectoryClient:
    directory_client = file_system_client.create_directory(directory_name)

    return directory_client

Rinominare o spostare una directory

È possibile rinominare o spostare una directory usando il metodo seguente:

Passa il percorso con il nome della nuova directory nell'argomento new_name. Il valore deve avere il formato seguente: {filesystem}/{directory}/{sottodirectory}.

L'esempio di codice seguente illustra come rinominare una sottodirectory:

def rename_directory(self, directory_client: DataLakeDirectoryClient, new_dir_name: str):
    directory_client.rename_directory(
        new_name=f"{directory_client.file_system_name}/{new_dir_name}")

Carica un file in una cartella

È possibile caricare contenuto in un file nuovo o esistente usando il metodo seguente:

L'esempio di codice seguente illustra come caricare un file in una directory usando il metodo upload_data :

def upload_file_to_directory(self, directory_client: DataLakeDirectoryClient, local_path: str, file_name: str):
    file_client = directory_client.get_file_client(file_name)

    with open(file=os.path.join(local_path, file_name), mode="rb") as data:
        file_client.upload_data(data, overwrite=True)

È possibile utilizzare questo metodo per creare e caricare contenuto in un nuovo file oppure impostare l'argomento overwrite su True per sovrascrivere un file esistente.

Accodare dati a un file

Per aggiungere dati a un file, utilizzare il metodo seguente:

Nell'esempio di codice seguente viene illustrato come aggiungere dati alla fine di un file attenendosi alla procedura seguente:

  • Creare un oggetto DataLakeFileClient per rappresentare la risorsa file esistente.
  • Caricare i dati nel file usando il metodo append_data .
  • Completare il caricamento chiamando il metodo flush_data per scrivere i dati caricati in precedenza nel file.
def append_data_to_file(self, directory_client: DataLakeDirectoryClient, file_name: str):
    file_client = directory_client.get_file_client(file_name)
    file_size = file_client.get_file_properties().size
    
    data = b"Data to append to end of file"
    file_client.append_data(data, offset=file_size, length=len(data))

    file_client.flush_data(file_size + len(data))

Con questo metodo, i dati possono essere aggiunti solo a un file e l'operazione è limitata a 4000 MiB per richiesta.

Scaricare da una directory

L'esempio di codice seguente illustra come scaricare un file da una directory in un file locale attenendosi alla procedura seguente:

def download_file_from_directory(self, directory_client: DataLakeDirectoryClient, local_path: str, file_name: str):
    file_client = directory_client.get_file_client(file_name)

    with open(file=os.path.join(local_path, file_name), mode="wb") as local_file:
        download = file_client.download_file()
        local_file.write(download.readall())
        local_file.close()

Elencare il contenuto della directory

È possibile elencare il contenuto della directory usando il metodo seguente ed enumerando il risultato:

L'enumerazione dei percorsi presenti nel risultato potrebbe inviare più richieste al servizio durante il recupero dei valori.

Nell'esempio di codice seguente viene stampato il percorso di ogni sottodirectory e file che si trova in una directory:

def list_directory_contents(self, file_system_client: FileSystemClient, directory_name: str):
    paths = file_system_client.get_paths(path=directory_name)

    for path in paths:
        print(path.name + '\n')

Eliminare una directory

È possibile eliminare una directory usando il metodo seguente:

Nell'esempio di codice seguente viene illustrato come eliminare una directory:

def delete_directory(self, directory_client: DataLakeDirectoryClient):
    directory_client.delete_directory()

Vedi anche

  • Last updated on