Delen via

Python gebruiken om mappen en bestanden te beheren in Azure Data Lake Storage

  • Artikel

In dit artikel leest u hoe u Python gebruikt om mappen en bestanden te maken en beheren in opslagaccounts met een hiërarchische naamruimte.

Zie Python gebruiken voor het beheren van ACL's in Azure Data Lake Storage voor meer informatie over het ophalen, instellen en bijwerken van de toegangsbeheerlijsten (ACL's).

Package (PyPi) | Samples | API reference | Gen1 to Gen2 mapping | Give Feedback

Vereisten

Uw project instellen

In deze sectie wordt uitgelegd hoe u een project voorbereidt voor gebruik met de Azure Data Lake Storage-clientbibliotheek voor Python.

Installeer vanuit uw projectmap pakketten voor de Azure Data Lake Storage- en Azure Identity-clientbibliotheken met behulp van de pip install opdracht. Het azure-identity-pakket is nodig voor verbindingen zonder wachtwoord met Azure-services.

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

Open vervolgens het codebestand en voeg de benodigde importinstructies toe. In dit voorbeeld voegen we het volgende toe aan het bestand .py :

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

Notitie

Met toegang tot meerdere protocollen in Data Lake Storage kunnen toepassingen zowel Blob-API's als Data Lake Storage Gen2-API's gebruiken om te werken met gegevens in opslagaccounts waarvoor HNS (hiërarchische naamruimte) is ingeschakeld. Wanneer u werkt met mogelijkheden die uniek zijn voor Data Lake Storage Gen2, zoals adreslijstbewerkingen en ACL's, gebruikt u de Data Lake Storage Gen2-API's, zoals wordt weergegeven in dit artikel.

Wanneer u kiest welke API's in een bepaald scenario moeten worden gebruikt, moet u rekening houden met de workload en de behoeften van uw toepassing, samen met de bekende problemen en impact van HNS op workloads en toepassingen.

Toegang autoriseren en verbinding maken met gegevensbronnen

Als u wilt werken met de codevoorbeelden in dit artikel, moet u een geautoriseerd DataLakeServiceClient-exemplaar maken dat het opslagaccount vertegenwoordigt. U kunt een DataLakeServiceClient object autoriseren met behulp van Microsoft Entra ID, een toegangssleutel voor een account of een Shared Access Signature (SAS).

U kunt de Azure Identity-clientbibliotheek voor Python gebruiken om uw toepassing te verifiëren met Microsoft Entra-id.

Maak een exemplaar van de klasse DataLakeServiceClient en geef een DefaultAzureCredential-object door .

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

Zie Overzicht: Python-apps verifiëren bij Azure met behulp van de Azure SDK voor meer informatie over het autoriseren DefaultAzureCredential van toegang tot gegevens.

Een container maken

Een container fungeert als een bestandssysteem voor uw bestanden. U kunt een container maken met behulp van de volgende methode:

In het volgende codevoorbeeld wordt een container gemaakt en wordt een FileSystemClient object geretourneerd voor later gebruik:

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

Een map maken

U kunt een mapreferentie in de container maken met behulp van de volgende methode:

In het volgende codevoorbeeld wordt een map aan een container toegevoegd en wordt een DataLakeDirectoryClient object geretourneerd voor later gebruik:

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

    return directory_client

De naam van een map wijzigen of verplaatsen

U kunt de naam van een map wijzigen of verplaatsen met behulp van de volgende methode:

Geef het pad door met de nieuwe mapnaam in het new_name argument. De waarde moet de volgende indeling hebben: {filesystem}/{directory}/{submap}.

In het volgende codevoorbeeld ziet u hoe u de naam van een submap wijzigt:

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}")

Een bestand uploaden naar een map

U kunt inhoud uploaden naar een nieuw of bestaand bestand met behulp van de volgende methode:

In het volgende codevoorbeeld ziet u hoe u een bestand uploadt naar een map met behulp van de methode 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)

U kunt deze methode gebruiken om inhoud te maken en te uploaden naar een nieuw bestand, of u kunt het overwrite argument instellen om True een bestaand bestand te overschrijven.

Gegevens toevoegen aan een bestand

U kunt gegevens uploaden die aan een bestand moeten worden toegevoegd met behulp van de volgende methode:

  • DataLakeFileClient.append_data methode.

In het volgende codevoorbeeld ziet u hoe u gegevens toevoegt aan het einde van een bestand met behulp van deze stappen:

  • Maak een DataLakeFileClient object dat de bestandsresource vertegenwoordigt waarmee u werkt.
  • Gegevens uploaden naar het bestand met behulp van de methode append_data .
  • Voltooi het uploaden door de methode flush_data aan te roepen om de eerder geüploade gegevens naar het bestand te schrijven.
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))

Met deze methode kunnen gegevens alleen worden toegevoegd aan een bestand en de bewerking is beperkt tot 4000 MiB per aanvraag.

Downloaden uit een map

In het volgende codevoorbeeld ziet u hoe u een bestand downloadt van een map naar een lokaal bestand met behulp van deze stappen:

  • Maak een DataLakeFileClient object dat het bestand vertegenwoordigt dat u wilt downloaden.
  • Open een lokaal bestand om te schrijven.
  • Roep de DataLakeFileClient.download_file methode aan om het bestand te lezen en schrijf de gegevens vervolgens naar het lokale bestand.
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()

Mapinhoud weergeven

U kunt de inhoud van de map weergeven met behulp van de volgende methode en het resultaat opsommen:

Als u de paden in het resultaat opsommen, kunnen er meerdere aanvragen naar de service worden verzonden tijdens het ophalen van de waarden.

In het volgende codevoorbeeld wordt het pad afgedrukt van elke submap en elk bestand dat zich in een map bevindt:

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

Een directory verwijderen

U kunt een map verwijderen met behulp van de volgende methode:

In het volgende codevoorbeeld ziet u hoe u een map verwijdert:

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

Zie ook