Tous les produits
Search
Centre de documentation

Object Storage Service:Reduce OSS requests and improve mount target performance

Dernière mise à jour :Aug 19, 2026

L'optimisation des requêtes de métadonnées envoyées par ossfs 2,0 vers OSS réduit les coûts des appels d'API, améliore la concurrence et accélère les opérations de lecture/écriture sur les points de montage.

Principes de base

ossfs 2,0 repose sur le framework FUSE (Filesystem in Userspace). Il traduit les opérations de métadonnées du système de fichiers en requêtes OSS, vous permettant ainsi d'accéder aux ressources de stockage OSS via des interfaces standard de système de fichiers.

Commande

Règles de conversion d'interface

lookup

Lors de l'exécution des opérations lookup ou stat, si le cache de métadonnées est invalide, ossfs 2,0 envoie d'abord une requête GetObjectMeta à OSS pour obtenir les attributs de l'objet homonyme.

Si la requête GetObjectMeta renvoie une réponse 404 (indiquant que l'objet n'existe pas), ossfs 2,0 envoie ensuite une requête ListObject(max-keys=1) pour vérifier l'existence d'un objet de dossier virtuel homonyme.

stat

readdir

Lors de l'exécution des opérations readdir ou readdirplus, ossfs 2,0 envoie des requêtes ListObject répétées à OSS.

Notez qu'ossfs 2,0 active la fonctionnalité readdirplus par défaut. Lorsque cette fonctionnalité est activée, les résultats des requêtes ListObject mettent à jour le cache de métadonnées pour tous les sous-éléments du dossier correspondant, ce qui réduit efficacement le nombre de requêtes de métadonnées ultérieures pour les fichiers enfants.

readdirplus

Analyse des scénarios

L'accès à un fichier via un système de fichiers diffère considérablement de l'accès direct à l'objet correspondant dans OSS.

Méthodes d'accès aux fichiers

ossfs résout les chemins de fichiers de haut en bas, à partir du répertoire racine. Par exemple, pour obtenir les attributs de /dir/object, la commande stat /dir/object s'exécute comme suit :

  1. Effectuez d'abord une opération sur /dir en envoyant une requête GetObjectMeta dir. Si elle renvoie 404 Not Found, l'objet n'existe pas ; une requête ListObject (max-keys=1)dir/ est alors envoyée. Si elle renvoie 200 OK, un dossier virtuel correspondant existe.

  2. Effectuez une opération sur /dir/object en envoyant une requête GetObjectMeta dir/object. Si elle renvoie 200 OK, les attributs de l'objet sont obtenus avec succès.

Une seule commande stat /dir/object génère deux requêtes GetObjectMeta et une requête ListObject. Comme chaque composant du chemin nécessite ses propres recherches de métadonnées, le nombre de requêtes OSS augmente avec la profondeur du fichier, ce qui dégrade les performances.

Impact de la mise en cache des métadonnées de fichiers

Important

ossfs 2,0 active la mise en cache des métadonnées de fichiers par défaut, avec une durée de validité par défaut de 60 secondes. La capacité du cache de métadonnées est implémentée via l'API bas niveau de FUSE et c'est le noyau du système d'exploitation qui décide quand évincer les données. Les machines disposant de plus de mémoire peuvent généralement mettre en cache davantage d'informations de métadonnées.

L'exemple suivant montre comment la mise en cache des métadonnées affecte les performances lors de la lecture des attributs de 100 fichiers enfants dans le répertoire /dir/.

  • Sans mise en cache des métadonnées

    • Accès aux fichiers avec une liste de fichiers connue :

      Lors de l'exécution en boucle de la commande stat /dir/object-<i>, chaque opération stat est convertie en une requête GetObjectMeta, générant au total 100 requêtes GetObjectMeta envoyées à OSS pour obtenir les attributs des fichiers. Cette multitude de requêtes de métadonnées affecte les performances.

    • Accès aux fichiers avec une liste de fichiers inconnue :

      Lors de l'exécution de la commande ls, cette opération est convertie en une requête ListObject envoyée à OSS pour obtenir la liste des fichiers. Ensuite, la commande stat /dir/object-<i> est exécutée en boucle pour obtenir les attributs des fichiers sur la base de la liste récupérée. Cela génère au final une requête ListObject et 100 requêtes GetObjectMeta envoyées à OSS, ce qui affecte les performances en raison du nombre élevé de requêtes de métadonnées.

  • Avec mise en cache des métadonnées

    • Accès aux fichiers avec une liste de fichiers connue :

      Lors de l'exécution en boucle de la commande stat /dir/object-<i> , chaque opération stat est convertie en une requête GetObjectMeta, générant au total 100 requêtes GetObjectMeta. Ces 100 requêtes atteignent directement le cache local de métadonnées pour obtenir les attributs des fichiers dans la période de validité du cache, réduisant ainsi efficacement le nombre de requêtes envoyées à OSS.

    • Accès aux fichiers avec une liste de fichiers inconnue :

      Lors de l'exécution de la commande ls, cette opération est convertie en une requête ListObject envoyée à OSS tout en mettant à jour le cache local de métadonnées. Une fois la mise à jour du cache terminée, l'exécution en boucle de la commande stat /dir/object-<i> n'envoie aucune requête supplémentaire à OSS, car les métadonnées se trouvent déjà dans le cache local.

La mise en cache des métadonnées réduit efficacement les requêtes répétitives vers OSS. Lors du parcours de tous les fichiers d'un dossier, l'exécution préalable de ls précharge le cache et élimine les requêtes OSS subséquentes pour chaque fichier.

Méthodes d'optimisation

Utilisez les méthodes suivantes pour réduire les requêtes de métadonnées vers OSS et améliorer les performances :

Prolonger la durée de mise en cache des métadonnées

Si vos données sont immuables après le téléchargement ou changent rarement par rapport à la durée du cache, augmentez l'option de montage attr_timeout pour prolonger la période de validité du cache de métadonnées et réduire les requêtes répétitives.

  • Scénario métier : Dans un scénario d'annotation de données, le système lit un lot de données brutes précédemment collectées, les traite, puis génère un nouveau lot de données. Dans ce cas, les données brutes ne sont pas modifiées une fois téléchargées vers OSS.

  • Configuration de montage : Dans le fichier de configuration ossfs 2,0, configurez la période de validité du cache de métadonnées sur 7200 secondes.

    # Bucket Endpoint (region node)
    --oss_endpoint=https://oss-cn-hangzhou-internal.aliyuncs.com
    
    # Bucket name
    --oss_bucket=bucketName
    
    # Metadata cache validity period
    --attr_timeout=7200
    
    # Access keys AccessKey ID and AccessKey Secret (optional for ossfs 2.0.1 and later versions)
    --oss_access_key_id=LTAI******************
    --oss_access_key_secret=8CE4**********************

Opérer après obtention de la liste des fichiers

Avant d'accéder à des fichiers individuels dans un répertoire, exécutez la commande ls ou envoyez une requête ListObject pour précharger toutes les métadonnées des fichiers dans le cache local. Combinée à une période de validité du cache plus longue, cette approche élimine les requêtes répétitives vers OSS pour chaque fichier.

Vous pouvez remplacer la commande ls par tout programme lisant le contenu d'un répertoire. Les exemples suivants répertorient les fichiers du répertoire /mnt/data/.

Python

os.listdir('/mnt/data/')

Go

entries, err := os.ReadDir("/mnt/data/")

C

dir = opendir("/mnt/data/");
if (dir != NULL) {
  struct dirent *entry;
  while((entry = readdir(dir)) != NULL) {}
  closedir(dir);
}

Utiliser un cache négatif pour accélérer la création de fichiers

Pour créer un nouveau fichier, un système de fichiers exécute deux appels système séquentiellement : lookup et create.

  1. L'opération lookup détermine si le fichier correspondant existe. Dans ossfs 2.0, cette opération est analysée en une requête GetObjectMeta et une requête ListObjects.

  2. Si une erreur 404 Not Found est renvoyée, ossfs crée le fichier à l'aide de l'opération create. Lorsque ossfs 2.0 exécute create, il envoie également une requête GetObjectMeta et une requête ListObjects pour vérifier si le fichier existe dans OSS.

Par conséquent, le processus de création d'un nouveau fichier implique quatre opérations de requête de métadonnées OSS.

ossfs 2,0 prend en charge la mise en cache des requêtes 404 renvoyées par OSS afin de réduire les requêtes dupliquées ultérieures. Pour activer cette fonctionnalité, spécifiez les options suivantes lors du montage du système de fichiers :

  • --oss_negative_cache_timeout=30 (La valeur par défaut est 0 seconde. Nous vous recommandons de définir cette valeur inférieure à celle de attr_timeout.)

  • --oss_negative_cache_size=10000 (Valeur par défaut : 10000)

Lorsque le cache négatif OSS est activé, la requête 404 issue de l'opération lookup pour un nouveau fichier est mise en cache. Par conséquent, la requête ultérieure lors de l'opération create atteint le cache négatif et aucune requête n'est envoyée à OSS. Cela réduit le nombre de requêtes OSS pour le processus de création de fichier de quatre à deux.

Important

Après avoir activé le cache négatif OSS, si une entrée de cache 404 pour un fichier nommé object-A est mise en cache, le fichier n'est visible au point de montage qu'après l'expiration de l'entrée de cache, même si vous créez immédiatement object-A dans OSS. La période de validité du cache est spécifiée par oss_negative_cache_timeout. Nous vous déconseillons d'activer cette fonctionnalité dans les scénarios nécessitant une forte cohérence des données.

Comparaison des performances

Méthode de test : Montez un bucket OSS avec ossfs 2,0 sur une instance ECS située dans la même région, en utilisant un endpoint interne avec la mise en cache des métadonnées activée, puis lisez les métadonnées de 10 000 fichiers dans le répertoire monté.

Résultats des tests

Opération

Temps consommé

Sans préchargement du cache de métadonnées (lecture directe des métadonnées des fichiers dans le dossier sans exécuter au préalable la commande ls)

111 secondes

Avec préchargement du cache de métadonnées (exécution préalable de la commande ls, puis lecture des métadonnées des fichiers dans le dossier)

18 secondes

Conclusion du test : Le préchargement du cache de métadonnées avant l'accès massif aux fichiers, combiné à une période de validité du cache appropriée, réduit considérablement les requêtes de métadonnées OSS et améliore les performances globales.