Partager via

Développer pour Azure Files avec Python

Découvrez comment développer des applications Python qui utilisent Azure Files pour stocker des données. Azure Files est un service de partage de fichiers managé dans le cloud. Il fournit des partages de fichiers entièrement managés accessibles via les protocoles SMB (Server Message Block) et NFS (Network File System). Azure Files fournit également une API REST pour l’accès par programmation aux partages de fichiers.

Dans cet article, vous allez découvrir les différentes approches de développement avec Azure Files en Python et comment choisir l’approche qui convient le mieux aux besoins de votre application. Vous allez également apprendre à créer une application console de base qui interagit avec les ressources Azure Files.

S’applique à

Modèle de gestion Modèle de facturation Échelon médiatique Redondance PME Système de fichiers en réseau (NFS)
Microsoft.Storage V2 approvisionné HDD (standard) Local (LRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) Zone (ZRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) Géo (GRS) Oui Non
Microsoft.Storage V2 approvisionné HDD (standard) GeoZone (GZRS) Oui Non
Microsoft.Storage V1 approvisionné SSD (Premium) Local (LRS) Oui Non
Microsoft.Storage V1 approvisionné SSD (Premium) Zone (ZRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Local (LRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Zone (ZRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) Géo (GRS) Oui Non
Microsoft.Storage Paiement à l’utilisation HDD (standard) GeoZone (GZRS) Oui Non

À propos du développement d’applications Python avec Azure Files

Azure Files offre plusieurs façons aux développeurs Python d’accéder aux données et de gérer les ressources dans Azure Files. Le tableau suivant répertorie les approches, résume leur fonctionnement et fournit des conseils sur le moment où utiliser chaque approche :

Approche Fonctionnement Quand utiliser
Bibliothèques d’E/S de fichiers standard Utilise des appels d’API au niveau du système d’exploitation via des partages de fichiers Azure montés à l’aide de SMB ou NFS. Lorsque vous montez un partage de fichiers à l’aide de SMB/NFS, vous pouvez utiliser des bibliothèques d’E/S de fichiers pour un langage de programmation ou une infrastructure, comme os et io pour Python. Vous disposez d’applications métier avec du code existant qui utilise des E/S de fichiers standard, et vous ne souhaitez pas réécrire du code pour que l’application fonctionne avec un partage de fichiers Azure.
FileREST API Appelle directement des points de terminaison HTTPS pour interagir avec les données stockées dans Azure Files. Fournit un contrôle programmatique sur les ressources de partage de fichiers. Le Kit de développement logiciel (SDK) Azure fournit la bibliothèque de client Partages de fichiers (azure-storage-file-share) qui s’appuie sur l’API FileREST, ce qui vous permet d’interagir avec les opérations d’API FileREST via des paradigmes de langage de programmation Python familiers. Vous créez des services et applications cloud à valeur ajoutée pour les clients et vous souhaitez utiliser des fonctionnalités avancées non disponibles via des bibliothèques d’E/S de fichiers Python.
API REST du fournisseur de ressources de stockage Utilise Azure Resource Manager (ARM) pour gérer les comptes de stockage et les partages de fichiers. Appelle des points de terminaison d’API REST pour différentes opérations de gestion de ressources. Votre application ou service doit effectuer des tâches de gestion des ressources, telles que la création, la suppression ou la mise à jour de comptes de stockage ou de partages de fichiers.

Pour obtenir des informations générales sur ces approches, consultez Vue d’ensemble du développement d’applications avec Azure Files.

Cet article se concentre sur l’utilisation des ressources Azure Files à l’aide des approches suivantes :

Conditions préalables

Configuration de votre projet

Cette section vous guide tout au long de la préparation d’un projet pour travailler avec Azure Files.

À partir de votre répertoire de projet, installez des packages en fonction des besoins de votre application à l’aide de la pip install commande. L’exemple suivant montre comment installer la bibliothèque cliente Partages de fichiers Azure, la bibliothèque cliente de gestion du stockage et la bibliothèque d’identités Azure. Le package azure-identity est nécessaire pour les connexions sans mot de passe aux services Azure.

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

Ouvrez votre fichier de code, et ajoutez les instructions import nécessaires.

Si vous envisagez d’utiliser les bibliothèques Python os et io, ajoutez ce qui suit à votre fichier .py :

import os
import io

Si vous envisagez d'utiliser la bibliothèque cliente Partages de fichiers Azure Storage, ajoutez ce qui suit à votre fichier .py :

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

Si vous envisagez d’utiliser les bibliothèques de gestion du stockage Azure, ajoutez ce qui suit à votre fichier .py :

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

Utiliser Azure Files à l’aide de bibliothèques d’E/S de fichiers Python

Les bibliothèques d’E/S de fichiers standard sont le moyen le plus courant d’accéder aux ressources Azure Files et de les utiliser. Lorsque vous montez un partage de fichiers à l’aide de SMB ou NFS, votre système d’exploitation redirige les demandes d’API pour le système de fichiers local. Cette approche vous permet d’utiliser des bibliothèques d’E/S de fichiers standard, telles que os ou io, pour interagir avec des fichiers et des répertoires dans le partage.

Envisagez d’utiliser des bibliothèques d’E/S de fichiers Python lorsque votre application nécessite :

  • Compatibilité des applications : Idéal pour les applications métier avec du code existant qui utilise déjà des bibliothèques d’E/S de fichiers Python. Vous n’avez pas besoin de réécrire du code pour que l’application fonctionne avec un partage de fichiers Azure.
  • Facilité d’utilisation : Les bibliothèques d’E/S de fichiers Python sont bien connues des développeurs et faciles à utiliser. Une proposition de valeur clé d’Azure Files est qu’elle expose des API de système de fichiers natives via SMB et NFS.

Dans cette section, vous allez apprendre à utiliser des bibliothèques d’E/S de fichiers Python pour utiliser des ressources Azure Files.

Pour plus d’informations et d’exemples, consultez les ressources suivantes :

  • Bibliothèques Python pour les E/S de fichier : os et io

Monter un partage de fichiers

Pour utiliser des bibliothèques d’E/S de fichiers Python, vous devez d’abord monter un partage de fichiers. Consultez les ressources suivantes pour obtenir des conseils sur le montage d’un partage de fichiers à l’aide de SMB ou NFS :

Dans cet article, nous utilisons le chemin suivant pour faire référence à un partage de fichiers SMB monté sur Windows :

file_share_path = "Z:\\file-share"

Exemple : Se connecter à un partage de fichiers et énumérer des répertoires à l’aide de bibliothèques d’E/S de fichiers Python

L’exemple de code suivant montre comment se connecter à un partage de fichiers et répertorier les répertoires du partage :

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)

Exemple : Écrire dans un fichier dans un partage de fichiers à l’aide de bibliothèques d’E/S de fichiers Python

L’exemple de code suivant montre comment écrire et ajouter du texte à un fichier :

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

Exemple : Énumérer des listes de contrôle d’accès de fichier à l’aide de bibliothèques d’E/S de fichier Python

L’exemple de code suivant montre comment énumérer les listes de contrôle d’accès de base (ACL) pour un fichier :

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)

Utiliser des données Azure Files à l’aide de la bibliothèque cliente Partages de fichiers pour Python

L’API FileREST fournit un accès programmatique à Azure Files. Il vous permet d’appeler des points de terminaison HTTPS pour effectuer des opérations sur des partages de fichiers, des répertoires et des fichiers. L’API FileREST est conçue pour une scalabilité élevée et des fonctionnalités avancées qui peuvent ne pas être disponibles via des protocoles natifs. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques clientes, telles que la bibliothèque cliente Partages de fichiers pour Python, qui s’appuient sur l’API FileREST.

Envisagez d’utiliser l’API FileREST et la bibliothèque cliente de partage de fichiers si votre application nécessite :

  • Fonctionnalités avancées : Opérations et fonctionnalités d’accès qui ne sont pas disponibles via des protocoles natifs.
  • Intégrations cloud personnalisées : Créez des services à valeur ajoutée personnalisés, tels que la sauvegarde, l’antivirus ou la gestion des données, qui interagissent directement avec Azure Files.
  • Optimisation des performances : Tirez parti des avantages en matière de performances dans les scénarios à grande échelle à l’aide d’opérations de plan de données.

L’API FileREST modélise Azure Files en tant que hiérarchie de ressources et est recommandée pour les opérations effectuées au niveau du répertoire ou du fichier . Vous devez préférer l’API REST du fournisseur de ressources de stockage pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers .

Dans cette section, vous allez apprendre à utiliser la bibliothèque cliente Partages de fichiers pour utiliser les ressources Azure Files.

Pour plus d’informations et d’exemples, consultez les ressources suivantes :

Autoriser l’accès et créer un client

Pour connecter une application à Azure Files, créez un ShareClient objet. Cet objet est votre point de départ pour l’utilisation des ressources Azure Files. Les exemples de code suivants montrent comment créer un ShareClient objet à l’aide de différents mécanismes d’autorisation.

Pour autoriser avec Microsoft Entra ID, vous devez utiliser un principal de sécurité. Le type de principal de sécurité dont vous avez besoin dépend de l’emplacement d’exécution de votre application. Utilisez ce tableau comme guide.

Où l’application s’exécute Principal de sécurité Aide
Ordinateur local (développement et test) Principal de service Pour découvrir comment inscrire l’application, configurer un groupe Microsoft Entra, attribuer des rôles et configurer des variables d’environnement, consultez Autoriser l’accès à l’aide de principaux de service de développeur
Ordinateur local (développement et test) Identité de l’utilisateur Pour découvrir comment configurer un groupe Microsoft Entra, attribuer des rôles et se connecter à Azure, consultez Autoriser l’accès à l’aide des informations d’identification du développeur
Hébergé dans Azure Identité managée Pour savoir comment activer une identité managée et attribuer des rôles, consultez Autoriser l’accès à partir d’applications hébergées sur Azure en utilisant une identité managée.
Hébergé en dehors d’Azure (par exemple, des applications locales) Service principal Pour savoir comment inscrire l’application, attribuer des rôles et configurer des variables d’environnement, consultez Autoriser l’accès à partir d’applications locales en utilisant un principal de service d’application.

Pour utiliser les exemples de code de cet article, attribuez le rôle intégré d’Azure RBAC Storage File Data Privileged Contributor au principal de sécurité. Ce rôle fournit un accès complet en lecture, écriture, modification des ACL et suppression sur toutes les données des partages pour tous les comptes de stockage configurés, quelles que soient les autorisations NTFS définies au niveau du fichier/répertoire. Pour plus d’informations, consultez Accéder aux partages de fichiers Azure à l’aide de Microsoft Entra ID avec Azure Files OAuth via REST.

Autoriser l’accès en utilisant DefaultAzureCredential

Un moyen simple et sécurisé d’autoriser l’accès et de se connecter à Azure Files consiste à obtenir un jeton OAuth en créant une instance DefaultAzureCredential . Vous pouvez ensuite utiliser ces informations d’identification pour créer un objet ShareClient.

L’exemple suivant crée un objet ShareClient autorisé à l'aide de DefaultAzureCredential, puis crée un objet ShareDirectoryClient pour travailler avec un répertoire dans le partage :

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

Si vous connaissez exactement le type d’informations d’identification que vous utilisez pour authentifier les utilisateurs, vous pouvez obtenir un jeton OAuth à l’aide d’autres classes dans la bibliothèque cliente Azure Identity pour Python. Ces classes dérivent de la classe TokenCredential.

Pour en savoir plus sur chacun de ces mécanismes d’autorisation, consultez Choisir comment autoriser l’accès aux données de fichier.

Exemple : Copier des fichiers à l’aide de la bibliothèque cliente Partages de fichiers

Vous pouvez copier des fichiers dans un partage de fichiers ou entre des partages de fichiers à l’aide de la méthode suivante :

Vous pouvez copier un fichier dans un objet blob de destination à l’aide de la méthode suivante à partir d’un BlobClient objet :

L’exemple de code suivant montre comment copier un fichier dans un fichier dans un autre partage de fichiers :

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)

Exemple : louer un fichier à l’aide de la bibliothèque cliente Partages de fichiers

Un bail crée un verrou sur un fichier géré par Azure via un ID de bail. Le bail fournit un mécanisme permettant de coordonner l’accès aux fichiers entre plusieurs clients d’un système distribué. Un bail sur un fichier fournit un accès exclusif en écriture et suppression. Pour en savoir plus sur les états de bail et les actions, consultez Fichier de bail.

L’exemple de code suivant montre comment créer un client de bail, acquérir un bail de durée infinie sur un fichier et libérer le bail :

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

Lorsque vous utilisez SMB et l’API FileREST, gardez à l’esprit que l’API FileREST utilise des baux pour gérer les verrous de fichier, tandis que SMB utilise des verrous de système de fichiers gérés par le système d’exploitation. Pour en savoir plus sur la gestion des interactions de verrouillage de fichiers entre SMB et l’API FileREST, consultez Gérer les verrous de fichier.

Exemple : Créer et répertorier des instantanés de partage à l’aide de la bibliothèque cliente Partages de fichiers

Les instantanés de partage sont des copies en lecture seule d’un partage de fichiers à un moment donné. Vous pouvez créer un instantané d’un partage de fichiers, puis utiliser l’instantané pour accéder aux données du partage au moment de la création de l’instantané. Vous pouvez également répertorier tous les instantanés d’un partage de fichiers et supprimer des instantanés de partage.

L’exemple de code suivant montre comment créer un instantané de partage, répertorier les instantanés d’un partage de fichiers et parcourir le répertoire racine dans un instantané de partage :

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)

Remarque

Les jetons OAuth, tels que ceux obtenus lors de l’utilisation DefaultAzureCredential, ne sont pas autorisés pour les opérations de plan de données au niveau du partage de fichiers. Pour utiliser des instantanés de partage, l'objet client doit être autorisé avec la clé de compte. L’objet ShareClient créé dans cet exemple de code utilise une chaîne de connexion, qui inclut la clé de compte.

Le stockage des clés de compte ou des chaînes de connexion présente un risque de sécurité. Vous ne devez les utiliser que lorsque l’authentification Microsoft Entra n’est pas disponible. Pour en savoir plus sur le stockage sécurisé des clés de compte dans Azure Key Vault, consultez À propos des clés de compte de stockage managé Azure Key Vault.

Gérer les ressources Azure Files à l’aide des bibliothèques de gestion stockage Azure

Les bibliothèques de gestion stockage Azure sont basées sur l’API REST du fournisseur de ressources Stockage Azure. Le fournisseur de ressources Stockage Azure est un service basé sur Azure Resource Manager et prend en charge les méthodes déclaratives (modèles) et impératives (appel d’API directe). L’API REST du fournisseur de ressources Stockage Azure fournit un accès programmatique aux ressources stockage Azure, y compris les partages de fichiers. Le Kit de développement logiciel (SDK) Azure fournit des bibliothèques de gestion qui s’appuient sur l’API REST du fournisseur de ressources stockage Azure.

Les bibliothèques de gestion sont recommandées pour les opérations effectuées au niveau du service de fichiers ou du partage de fichiers . Dans cette section, vous allez apprendre à utiliser les bibliothèques de gestion stockage Azure pour gérer les ressources Azure Files.

Exemple : Créer un partage de fichiers à l’aide de la bibliothèque de gestion stockage Azure

L’exemple de code suivant montre comment créer un objet de niveau ArmClient supérieur, inscrire le fournisseur de ressources de stockage avec un abonnement et créer un partage de fichiers à l’aide de la bibliothèque de gestion stockage Azure :

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

Vous pouvez configurer les propriétés de partage de fichiers à l’aide de la FileShare classe. L’exemple précédent montre comment définir la share_quota propriété. Pour en savoir plus, consultez la référence de classe StorageManagementClient .

Remarque

Pour effectuer l’opération d’inscription, vous avez besoin d’autorisations pour l’action RBAC Azure suivante : Microsoft.Storage/register/action. Cette autorisation est incluse dans les rôles intégrés Contributeur et Propriétaire.

Exemple : répertorier les partages de fichiers et les instantanés à l’aide de la bibliothèque de gestion stockage Azure

L’exemple de code suivant montre comment répertorier les partages de fichiers et les instantanés dans un compte de stockage :

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

Contenu connexe

Pour plus d’informations sur le développement avec Azure Files, consultez les ressources suivantes :