Udostępnij za pomocą

Programowanie dla usługi Azure Files przy użyciu języka Python

Dowiedz się, jak tworzyć aplikacje języka Python korzystające z usługi Azure Files do przechowywania danych. Azure Files to zarządzana usługa udziału plików w chmurze. Zapewnia w pełni zarządzane udziały plików, które są dostępne za pośrednictwem standardowych protokołów SMB (Server Message Block) i Network File System (NFS). Usługa Azure Files udostępnia również interfejs API REST do programowego dostępu do udziałów plikowych.

W tym artykule przedstawiono różne podejścia do programowania za pomocą usługi Azure Files w języku Python oraz sposób wybierania podejścia, które najlepiej odpowiada potrzebom aplikacji. Dowiesz się również, jak utworzyć podstawową aplikację konsolową, która współdziała z zasobami usługi Azure Files.

Odnosi się do

Model zarządzania Model rozliczania Poziom mediów Redundancja SMB NFS
Microsoft.Storage Wersja 2 została przygotowana HDD (standardowa) Lokalna sieć (LRS) Tak Nie.
Microsoft.Storage Wersja 2 została przygotowana HDD (standardowa) Strefa (ZRS) Tak Nie.
Microsoft.Storage Wersja 2 została przygotowana HDD (standardowa) Geo (GRS) Tak Nie.
Microsoft.Storage Wersja 2 została przygotowana HDD (standardowa) Strefa geograficzna (GZRS) Tak Nie.
Microsoft.Storage Zaprovisionowana wersja 1 SSD klasy premium Lokalna sieć (LRS) Tak Nie.
Microsoft.Storage Zaprovisionowana wersja 1 SSD klasy premium Strefa (ZRS) Tak Nie.
Microsoft.Storage Płać według zużycia HDD (standardowa) Lokalna sieć (LRS) Tak Nie.
Microsoft.Storage Płać według zużycia HDD (standardowa) Strefa (ZRS) Tak Nie.
Microsoft.Storage Płać według zużycia HDD (standardowa) Geo (GRS) Tak Nie.
Microsoft.Storage Płać według zużycia HDD (standardowa) Strefa geograficzna (GZRS) Tak Nie.

Informacje o tworzeniu aplikacji w języku Python za pomocą usługi Azure Files

Usługa Azure Files oferuje kilka sposobów uzyskiwania dostępu do danych i zarządzania zasobami w usłudze Azure Files przez deweloperów języka Python. W poniższej tabeli wymieniono metody, podsumowano sposób ich działania i przedstawiono wskazówki dotyczące tego, kiedy należy używać poszczególnych metod:

Metoda Jak to działa Kiedy należy używać
Standardowe biblioteki we/wy plików Używa wywołań interfejsu API na poziomie systemu operacyjnego poprzez zamontowane zasoby plikowe platformy Azure, korzystając z protokołu SMB lub NFS. Podczas instalowania udziału plików przy użyciu protokołu SMB/NFS można użyć bibliotek we/wy plików dla języka programowania lub struktury, takich jak os i io dla języka Python. Masz aplikacje biznesowe z istniejącym kodem wykorzystującym standardowe operacje we/wy plików i nie chcesz przepisywać kodu, aby aplikacja działała z udostępnianiem plików Azure.
FileREST API Bezpośrednie wywołanie punktów końcowych HTTPS w celu interakcji z danymi przechowywanymi w usłudze Azure Files. Zapewnia programową kontrolę nad zasobami do udostępniania plików. Zestaw Azure SDK udostępnia bibliotekę klienta udziałów plików (azure-storage-file-share), która bazuje na interfejsie API FileREST, umożliwiając interakcję z operacjami interfejsu API FileREST za pomocą znanych paradygmatów języka programowania Python. Tworzysz usługi w chmurze i aplikacje w chmurze dla klientów i chcesz używać zaawansowanych funkcji niedostępnych za pośrednictwem bibliotek we/wy plików języka Python.
Interfejs REST API dostawcy zasobów przechowywania Używa usługi Azure Resource Manager (ARM) do zarządzania kontami magazynowymi i udostępnieniami plików. Wywołuje punkty końcowe interfejsu API REST dla różnych operacji zarządzania zasobami. Aplikacja lub usługa musi wykonywać zadania zarządzania zasobami, takie jak tworzenie, usuwanie lub aktualizowanie kont przechowywania lub udostępniania plików.

Aby uzyskać ogólne informacje na temat tych podejść, zobacz Omówienie tworzenia aplikacji w usłudze Azure Files.

Ten artykuł koncentruje się na pracy z zasobami usługi Azure Files przy użyciu następujących metod:

Wymagania wstępne

Konfigurowanie projektu

Ta sekcja przeprowadzi Cię przez proces przygotowywania projektu do pracy z usługą Azure Files.

Z katalogu projektu zainstaluj pakiety na podstawie potrzeb aplikacji przy użyciu pip install polecenia . W poniższym przykładzie pokazano, jak zainstalować bibliotekę klienta udziałów plików platformy Azure, bibliotekę klienta zarządzania magazynem i bibliotekę tożsamości platformy Azure. Pakiet azure-identity jest wymagany w przypadku połączeń bez hasła z usługami platformy Azure.

pip install azure-identity
pip install azure-storage-file-share
pip install azure-mgmt-resource
pip install azure-mgmt-storage

Otwórz plik kodu i dodaj niezbędne instrukcje importu.

Jeśli planujesz używać języka Python os i io bibliotek, dodaj następujące elementy do pliku .py :

import os
import io

Jeśli planujesz używać biblioteki klienta Azure Storage File Shares, dodaj następujące do pliku .py

from azure.identity import DefaultAzureCredential
from azure.storage.fileshare import ShareClient, ShareDirectoryClient, ShareFileClient

Jeśli planujesz używać bibliotek zarządzania usługi Azure Storage, dodaj następujące elementy do pliku .py :

from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.storage import StorageManagementClient

Praca z Azure Files przy użyciu bibliotek do obsługi plików w Pythonie

Standardowe biblioteki we/wy plików to najbardziej typowy sposób uzyskiwania dostępu do zasobów usługi Azure Files i pracy z nimi. Podczas montowania udziału plikowego za pomocą SMB lub NFS system operacyjny przekierowuje żądania API dotyczące lokalnego systemu plików. Takie podejście umożliwia korzystanie ze standardowych bibliotek we/wy plików, takich jak os lub io, do interakcji z plikami i katalogami w udziale.

Rozważ użycie bibliotek do operacji na plikach w Pythonie, jeśli Twoja aplikacja tego wymaga:

  • Zgodność aplikacji: Idealne rozwiązanie dla aplikacji biznesowych z istniejącym kodem, który już używa bibliotek we/wy plików języka Python. Nie musisz ponownie pisać kodu, aby aplikacja działała z współdzieleniem plików Azure.
  • Łatwość użycia: Biblioteki we/wy plików języka Python są dobrze znane przez deweloperów i są łatwe w użyciu. Kluczową wartością usługi Azure Files jest to, że uwidacznia natywne interfejsy API systemu plików za pośrednictwem protokołu SMB i systemu plików NFS.

W tej sekcji dowiesz się, jak używać bibliotek we/wy plików języka Python do pracy z zasobami usługi Azure Files.

Więcej informacji i przykładów zawierają następujące zasoby:

  • Biblioteki języka Python do operacji we/wy plików: os i io

Zamontować udział plików

Aby użyć bibliotek we/wy plików języka Python, należy najpierw zamontować współdzielony zasób plikowy. Zapoznaj się z następującymi zasobami, aby uzyskać wskazówki dotyczące montowania udziału plików przy użyciu protokołu SMB lub NFS.

W tym artykule użyjemy następującej ścieżki, aby odwołać się do zamontowanego udziału plików SMB w systemie Windows:

file_share_path = "Z:\\file-share"

Przykład: nawiązywanie połączenia z udziałem plików i wyliczanie katalogów przy użyciu bibliotek we/wy plików języka Python

W poniższym przykładzie kodu pokazano, jak nawiązać połączenie do zasobu udostępnionego i wyświetlić listę katalogów w nim:

import os

def enumerate_directories(path):
    try:
        # Get all directories in the specified path
        dirs = [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]
        
        # Print each directory name
        for dir_name in dirs:
            print(f"{dir_name}")
            
        print(f"{len(dirs)} directories found.")
    except (PermissionError, FileNotFoundError, OSError) as ex:
        print(f"Error: {ex}")

#Example usage
file_share_path = "Z:\\file-share"
enumerate_directories(file_share_path)

Przykład: zapisywanie danych w pliku w zasobie współdzielonym przy użyciu bibliotek operacji na plikach w Pythonie.

W poniższym przykładzie kodu pokazano, jak napisać i dołączyć tekst do pliku:

import os

def write_to_file(file_share_path, file_name):
    # First line of text with platform-appropriate line ending
    text_to_write = "First line" + os.linesep
    
    # Combine the file share path and filename
    file_path = os.path.join(file_share_path, file_name)
    
    # Write initial text to file (overwrites if file exists)
    with open(file_path, 'w') as file:
        file.write(text_to_write)
    
    # Text to append
    text_to_append = ["Second line", "Third line"]
    
    # Append lines to the file
    with open(file_path, 'a') as file:
        file.write(os.linesep.join(text_to_append) + os.linesep)

# Example usage
file_share_path = "Z:\\file-share"
write_to_file(file_share_path, "test.txt")

Przykład: wyliczanie list ACL plików przy użyciu bibliotek do operacji wejścia/wyjścia na plikach w Pythonie

Poniższy przykład kodu przedstawia sposób wyliczania podstawowych list kontroli dostępu (ACL) dla pliku:

import os
import stat

def enumerate_file_acls(file_path):
    try:
        # Get file stats
        file_stat = os.stat(file_path)
        
        # Get permissions in octal format
        permissions_octal = oct(stat.S_IMODE(file_stat.st_mode))
        
        print(f"File: {file_path}")
        print(f"Permissions (octal): {permissions_octal}")
        
        # Interpret permissions in a human-readable format
        permissions = ""
        permissions += "r" if file_stat.st_mode & stat.S_IRUSR else "-"
        permissions += "w" if file_stat.st_mode & stat.S_IWUSR else "-"
        permissions += "x" if file_stat.st_mode & stat.S_IXUSR else "-"
        permissions += "r" if file_stat.st_mode & stat.S_IRGRP else "-"
        permissions += "w" if file_stat.st_mode & stat.S_IWGRP else "-" 
        permissions += "x" if file_stat.st_mode & stat.S_IXGRP else "-"
        permissions += "r" if file_stat.st_mode & stat.S_IROTH else "-"
        permissions += "w" if file_stat.st_mode & stat.S_IWOTH else "-"
        permissions += "x" if file_stat.st_mode & stat.S_IXOTH else "-"
        
        print(f"Permissions (symbolic): {permissions}")
        
        print(f"Owner ID: {file_stat.st_uid}")
        print(f"Group ID: {file_stat.st_gid}")
        print("Note: For detailed Windows ACLs, you may need a specialized library.")
        
    except FileNotFoundError:
        print(f"Error: File '{file_path}' not found.")
    except PermissionError:
        print(f"Error: Permission denied for '{file_path}'.")
    except Exception as e:
        print(f"Error: {e}")

# Example usage
file_share_path = "Z:\\file-share"
file_name = "test.txt"
file_path = os.path.join(file_share_path, file_name)

enumerate_file_acls(file_path)

Praca z danymi usługi Azure Files przy użyciu biblioteki klienta udziałów plików dla języka Python

Interfejs API FileREST zapewnia dostęp programowy do usługi Azure Files. Umożliwia wywoływanie punktów końcowych HTTPS w celu wykonywania operacji na zasobach plikowych, katalogach i plikach. Interfejs API FileREST został zaprojektowany z myślą o wysokiej skalowalności i zaawansowanych funkcjach, które mogą nie być dostępne za pośrednictwem protokołów natywnych. Zestaw Azure SDK udostępnia biblioteki klienckie, takie jak biblioteka klienta udziałów plików dla języka Python, które są oparte na interfejsie API FileREST.

Rozważ użycie interfejsu API FileREST i biblioteki klienta dysku sieciowego, jeśli aplikacja wymaga:

  • Funkcje zaawansowane: Operacje dostępu i funkcje, które nie są dostępne za pośrednictwem protokołów natywnych.
  • Niestandardowe integracje z chmurą: Twórz niestandardowe usługi dodane do wartości, takie jak tworzenie kopii zapasowych, ochrony antywirusowej lub zarządzanie danymi, które współdziałają bezpośrednio z usługą Azure Files.
  • Optymalizacja wydajności: Skorzystaj z zalet wydajności w scenariuszach o dużej skali przy użyciu operacji płaszczyzny danych.

Interfejs API FileREST modeluje usługę Azure Files jako hierarchię zasobów i jest zalecany w przypadku operacji wykonywanych na poziomie katalogu lub pliku . Powinieneś preferować interfejs API REST dostawcy zasobów usługi Storage dla operacji wykonywanych na poziomie usługi plików lub udziału plików.

W tej sekcji dowiesz się, jak używać biblioteki klienta Azure Files do pracy z zasobami usługi Azure Files.

Więcej informacji i przykładów zawierają następujące zasoby:

Autoryzowanie dostępu i tworzenie klienta

Aby połączyć aplikację z usługą ShareClient Azure Files, utwórz obiekt. Ten obiekt jest punktem wyjścia do pracy z zasobami usługi Azure Files. W poniższych przykładach kodu pokazano, jak utworzyć ShareClient obiekt przy użyciu różnych mechanizmów autoryzacji.

Aby autoryzować za pomocą Microsoft Entra ID, musisz użyć podmiotu zabezpieczeń. Typ wymaganego podmiotu zabezpieczeń zależy od tego, gdzie działa aplikacja. Użyj tej tabeli jako przewodnika.

Gdzie działa aplikacja Podmiot bezpieczeństwa Wskazówki
Maszyna lokalna (programowanie i testowanie) Podmiot usługi Aby dowiedzieć się, jak zarejestrować aplikację, skonfigurować grupę firmy Microsoft Entra, przypisać role i skonfigurować zmienne środowiskowe, zobacz Autoryzowanie dostępu przy użyciu jednostek usługi dewelopera
Maszyna lokalna (programowanie i testowanie) Tożsamość użytkownika Aby dowiedzieć się, jak skonfigurować grupę firmy Microsoft Entra, przypisać role i zalogować się na platformie Azure, zobacz Autoryzowanie dostępu przy użyciu poświadczeń dewelopera
Hostowane na platformie Azure Tożsamość zarządzana Aby dowiedzieć się, jak włączyć tożsamość zarządzaną i przypisać role, zobacz Autoryzowanie dostępu z aplikacji hostowanych na platformie Azure przy użyciu tożsamości zarządzanej
Hostowane poza platformą Azure (na przykład aplikacje lokalne) Podmiot usługi Aby dowiedzieć się, jak zarejestrować aplikację, przypisać role i skonfigurować zmienne środowiskowe, zobacz Autoryzowanie dostępu z aplikacji lokalnych przy użyciu jednostki usługi aplikacji

Aby pracować z przykładami kodu w tym artykule, przypisz wbudowaną rolę RBAC Uprzywilejowany współautor danych plików magazynu do podmiotu zabezpieczeń. Ta rola zapewnia pełny dostęp do odczytu, zapisu, modyfikowania list kontrolnych dostępu oraz usuwania danych we wszystkich udziałach dla skonfigurowanych kont magazynowych, niezależnie od uprawnień NTFS ustawionych na poziomie pliku lub katalogu. Aby uzyskać więcej informacji, zobacz Access Azure file shares using Microsoft Entra ID with Azure Files OAuth over REST (Uzyskiwanie dostępu do udziałów plików platformy Azure przy użyciu identyfikatora Entra firmy Microsoft za pomocą protokołu OAuth usługi Azure Files za pośrednictwem interfejsu REST).

Autoryzowanie dostępu za pomocą DefaultAzureCredential

Łatwym i bezpiecznym sposobem autoryzowania dostępu i nawiązywania połączenia z usługą Azure Files jest uzyskanie tokenu OAuth przez utworzenie wystąpienia DefaultAzureCredential . Następnie możesz użyć tego poświadczenia, aby utworzyć ShareClient obiekt.

Poniższy przykład tworzy obiekt ShareClient autoryzowany przy użyciu DefaultAzureCredential, a następnie tworzy obiekt ShareDirectoryClient do pracy z katalogiem w zasobie udostępnionym:

from azure.identity import DefaultAzureCredential
from azure.storage.fileshare import ShareClient

account_name = "<account-name>"
share_name = "<share-name>"

# Create the share client using DefaultAzureCredential
share_client = ShareClient(
    account_url=f"https://{account_name}.file.core.windows.net",
    share_name=share_name,
    credential=DefaultAzureCredential(),
    # When using a token credential, you MUST specify a token_intent
    token_intent='backup'
)

# Get a reference to a directory in the share
directory_client = share_client.get_directory_client("sample-directory")

Jeśli wiesz dokładnie, którego typu poświadczeń używasz do uwierzytelniania użytkowników, możesz uzyskać token OAuth przy użyciu innych klas w bibliotece klienta tożsamości platformy Azure dla języka Python. Te klasy pochodzą z klasy TokenCredential .

Aby dowiedzieć się więcej na temat każdego z tych mechanizmów autoryzacji, zobacz Wybieranie sposobu autoryzowania dostępu do danych plików.

Przykład: kopiowanie plików przy użyciu biblioteki klienta dla udostępniania plików

Pliki w udziale plików lub między udziałami plików można skopiować przy użyciu następującej metody:

Plik można skopiować przy użyciu następującej metody z obiektu BlobClient do docelowego obiektu blob.

W poniższym przykładzie kodu pokazano, jak skopiować plik do pliku w innym udziale plików:

from azure.identity import DefaultAzureCredential
from azure.storage.fileshare import ShareFileClient

# Define storage account parameters
account_name = "<account-name>"
src_share_name = "src-file-share"
dest_share_name = "dest-file-share"
src_file_path = "src/path/to/file"
dest_file_path = "dest/path/to/file"

# Create token credential
token_credential = DefaultAzureCredential()

# Create source file client
src_file_client = ShareFileClient(
    account_url=f"https://{account_name}.file.core.windows.net",
    share_name=src_share_name,
    file_path=src_file_path,
    credential=token_credential,
    token_intent='backup'
)

# Create destination file client
dest_file_client = ShareFileClient(
    account_url=f"https://{account_name}.file.core.windows.net",
    share_name=dest_share_name,
    file_path=dest_file_path,
    credential=token_credential,
    token_intent='backup'
)

# Copy the file from the source share to the destination share
copy_operation = dest_file_client.start_copy_from_url(src_file_client.url)

Przykład: dzierżawa pliku przy użyciu biblioteki klienta udostępniania plików

Dzierżawa tworzy blokadę pliku zarządzanego przez platformę Azure za pośrednictwem identyfikatora dzierżawy. Dzierżawa zapewnia mechanizm koordynowania dostępu do plików między wieloma klientami w systemie rozproszonym. Dzierżawa pliku zapewnia wyłączny dostęp do zapisu i usuwania. Aby dowiedzieć się więcej o stanach dzierżawy i akcjach, zobacz Plik dzierżawy.

Poniższy przykład kodu pokazuje, jak utworzyć klienta najmu, uzyskać nieskończony czas trwania najmu na plik i zwolnić najem.

from azure.identity import DefaultAzureCredential
from azure.storage.fileshare import ShareFileClient, ShareLeaseClient

# Define storage account parameters
account_name = "<account-name>"
share_name = "sample-file-share"
file_path = "path/to/file"

# Create a DefaultAzureCredential for authentication
token_credential = DefaultAzureCredential()

# Create a ShareFileClient
file_client = ShareFileClient(
    account_url=f"https://{account_name}.file.core.windows.net",
    share_name=share_name,
    file_path=file_path,
    credential=token_credential,
    token_intent='backup'
)

# Get a lease client for the file
lease_client = ShareLeaseClient(file_client)

# Acquire an infinite duration lease on the file
lease_info = lease_client.acquire()

# Do something with the file while it's leased
# ...

# Release the lease
lease_client.release()

W przypadku korzystania zarówno z protokołu SMB, jak i interfejsu API FileREST należy pamiętać, że interfejs API FileREST używa dzierżaw do zarządzania blokadami plików, podczas gdy protokół SMB używa blokad systemu plików zarządzanych przez system operacyjny. Aby dowiedzieć się więcej na temat zarządzania interakcjami blokowania plików między protokółem SMB i interfejsem API FileREST, zobacz Zarządzanie blokadami plików.

Przykład: Tworzenie i wyświetlanie listy migawek współdzielonych zasobów przy użyciu biblioteki klienta współdzielonych zasobów plikowych.

Migawki udziałów plików to kopie tylko do odczytu danej wersji udziału plików w określonym momencie. Możesz utworzyć migawkę udziału plików, a następnie użyć tej migawki, aby uzyskać dostęp do danych w udziale w chwili jej utworzenia. Można również wyświetlić listę wszystkich migawek w udziale plików oraz usunąć migawki udziału plików.

W poniższym przykładzie kodu pokazano, jak utworzyć migawkę współdzielenia, wyświetlić listę migawek we współdzieleniu plików i przejść przez katalog główny w migawce współdzielenia.

from azure.storage.fileshare import ShareServiceClient, ShareDirectoryClient

def list_root_directory_snapshot(root_dir: ShareDirectoryClient):
    for item in root_dir.list_directories_and_files():
        if item["is_directory"]:
            print(f"Directory in snapshot: {item['name']}")
        else:
            print(f"File in snapshot: {item['name']}")

# Connection string with account key (required for share snapshots)
connection_string = "<connection-string>"

# Create service and share clients
share_service_client = ShareServiceClient.from_connection_string(connection_string)
share_name = "sample-file-share"
share_client = share_service_client.get_share_client(share_name)

# Create a snapshot
snapshot_info = share_client.create_snapshot()
print(f"Snapshot created: {snapshot_info['snapshot']}")

# List snapshots in a share
for share_item in share_service_client.list_shares(include_snapshots=True):
    if share_item["snapshot"]:
        print(f"Share: {share_item['name']} (Snapshot: {share_item['snapshot']})")

# List directories and files in a share snapshot
snapshot_timestamp = snapshot_info["snapshot"]
share_snapshot = share_service_client.get_share_client(share_name, snapshot=snapshot_timestamp)
root_dir = share_snapshot.get_directory_client("")

list_root_directory_snapshot(root_dir)

Uwaga / Notatka

Tokeny OAuth, takie jak te uzyskane podczas korzystania z DefaultAzureCredential, nie są dozwolone do operacji na płaszczyźnie danych na poziomie zasobu współdzielenia plików. Aby pracować z migawkami udziałów, obiekt klienta musi być autoryzowany za pomocą klucza konta. Obiekt ShareClient utworzony w tym przykładzie kodu używa parametrów połączenia, które zawierają klucz konta.

Przechowywanie kluczy konta lub parametrów połączenia stanowi zagrożenie bezpieczeństwa. Należy ich używać tylko wtedy, gdy uwierzytelnianie microsoft Entra nie jest dostępne. Aby dowiedzieć się więcej na temat bezpiecznego przechowywania kluczy kont w usłudze Azure Key Vault, zobacz About Azure Key Vault managed storage account keys (Informacje o kluczach konta zarządzanego magazynu usługi Azure Key Vault).

Zarządzanie zasobami usługi Azure Files przy użyciu bibliotek zarządzania usługi Azure Storage

Biblioteki zarządzania usługi Azure Storage są oparte na interfejsie API REST dostawcy zasobów usługi Azure Storage. Dostawca zasobów usługi Azure Storage jest usługą opartą na usłudze Azure Resource Manager i obsługuje metody deklaratywne (szablony) i imperatywne (bezpośrednie wywołanie interfejsu API). Interfejs API REST dostawcy zasobów usługi Azure Storage zapewnia dostęp programistyczny do zasobów usługi Azure Storage, w tym udziałów plików. Zestaw Azure SDK udostępnia biblioteki zarządzania oparte na interfejsie API REST dostawcy zasobów usługi Azure Storage.

Biblioteki zarządzania są zalecane w przypadku operacji wykonywanych na poziomie usługi plików lub udziału plików . W tej sekcji dowiesz się, jak zarządzać zasobami usługi Azure Files przy użyciu bibliotek zarządzania usługi Azure Storage.

Przykład: tworzenie udziału plików przy użyciu biblioteki zarządzania Azure Storage

W poniższym przykładzie kodu pokazano, jak utworzyć obiekt najwyższego poziomu ArmClient, zarejestrować dostawcę zasobów usługi Storage do subskrypcji oraz utworzyć udział plików przy użyciu biblioteki do zarządzania Azure Storage.

from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import ResourceManagementClient, SubscriptionClient
from azure.mgmt.storage import StorageManagementClient
from azure.mgmt.storage.models import FileShare

# Create the credential for authentication
credential = DefaultAzureCredential()

# Define variables
subscription_id = "<subscription-id>"
resource_group_name = "<resource-group-name>"
storage_account_name = "<storage-account-name>"
share_name = "sample-file-share"

# Create clients
resource_client = ResourceManagementClient(credential, subscription_id)
subscription_client = SubscriptionClient(credential)
storage_client = StorageManagementClient(credential, subscription_id)

# Register Microsoft.Storage resource provider, if not already registered
provider = resource_client.providers.get('Microsoft.Storage')
if provider.registration_state == "NotRegistered":
    resource_client.providers.register('Microsoft.Storage')

# Create a file share
file_share = storage_client.file_shares.create(
    resource_group_name=resource_group_name,
    account_name=storage_account_name,
    share_name=share_name,
    file_share=FileShare(
        share_quota=1  # Share size in GiB
        # Add other file share properties here
    )
)

Właściwości udziału plików można skonfigurować przy użyciu FileShare klasy . Poprzedni przykład pokazuje, jak ustawić właściwość share_quota. Aby dowiedzieć się więcej, zobacz dokumentację klasy StorageManagementClient .

Uwaga / Notatka

Aby wykonać operację rejestrowania, musisz mieć uprawnienia do następującej akcji RBAC platformy Azure: Microsoft.Storage/register/action. To uprawnienie jest uwzględnione w wbudowanych rolach Współautora i Właściciela.

Przykład: Wyświetlanie listy udziałów plikowych i migawek przy użyciu biblioteki zarządzania Azure Storage

Poniższy przykład kodu pokazuje, jak wyświetlić listę udziałów plików i migawek na koncie magazynowym.

from azure.identity import DefaultAzureCredential
from azure.mgmt.storage import StorageManagementClient

# Create the credential for authentication
credential = DefaultAzureCredential()

# Define variables
subscription_id = "<subscription-id>"
resource_group_name = "<resource-group-name>"
storage_account_name = "<storage-account-name>"
expand = "snapshots"  # Include snapshots in the response

# Create storage management client
storage_client = StorageManagementClient(credential, subscription_id)

# List all file shares with their snapshots
file_shares = storage_client.file_shares.list(
    resource_group_name=resource_group_name,
    account_name=storage_account_name,
    expand=expand
)

# Iterate over the file shares and print them along with any snapshots
for share in file_shares:
    print(f"Resource name: {share.name}")
    if share.snapshot_time:
        print(f"Snapshot: {share.snapshot_time}")

Powiązana treść

Aby uzyskać więcej informacji o programowaniu za pomocą usługi Azure Files, zobacz następujące zasoby:

  • Last updated on