Condividi tramite

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

  • Articolo

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.

Riferimento all'API package (PyPi) | Samples | Gen1 to Gen2 mapping | Give Feedback |

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 l'ID Microsoft Entra, 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 e passare 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:

Nell'esempio di codice seguente viene creato un contenitore e viene restituito un FileSystemClient oggetto 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

Creare 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 per un DataLakeDirectoryClient 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:

Passare il percorso con il nuovo nome di 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}")

Caricare un file in una directory

È 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

È possibile caricare i dati da aggiungere a un file usando il metodo seguente:

  • DataLakeFileClient.append_data metodo.

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

  • Creare un DataLakeFileClient oggetto per rappresentare la risorsa file con cui si sta lavorando.
  • 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

Nell'esempio di codice seguente viene illustrato come scaricare un file da una directory in un file locale attenendosi alla procedura seguente:

  • Creare un DataLakeFileClient oggetto per rappresentare il file da scaricare.
  • Aprire un file locale per la scrittura.
  • Chiamare il metodo DataLakeFileClient.download_file per leggere dal file e quindi scrivere i dati nel file locale.
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 nel risultato può effettuare 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