Scripting Qumulo avec S3 via Minio

Chez Qumulo, il est extrêmement important de permettre aux clients d’accéder facilement à leurs données et de les gérer, car nous nous efforçons de remplir notre mission qui consiste à devenir la société dans laquelle le monde se fie pour stocker ses données pour toujours. Depuis longtemps, les utilisateurs sont en mesure d'interagir avec leurs données via les API SMB, NFS et RESTful. Pour la plupart des clients, ces protocoles répondent à leurs besoins. Cependant, un nombre croissant de nos clients cherchent à communiquer avec leur Qumulo via une API compatible S3 afin de tirer parti de l'économie et des performances du stockage de fichiers avec des outils modernes écrits pour object.

Le stockage d'objets est une option de plus en plus populaire pour les clients cherchant à stocker leurs données dans le cloud. Même pour les clients qui ne cherchent pas à exploiter le stockage d'objets, de nombreux outils qu'ils commencent à utiliser supposent un backend d'objet et communiquent via l'API S3 d'Amazon (qui est devenue le standard de facto dans les API de stockage d'objets).

Pour les clients souhaitant interagir avec Qumulo via le SDK ou l’API S3, nous vous recommandons d’utiliser Minio. Minio est un serveur de stockage d’objets hautes performances qui agit comme une interface S3 compatible avec différents systèmes de stockage en nuage et locaux. Cela signifie que vous pouvez faire asseoir un serveur Minio devant votre stockage Qumulo et gérer les requêtes S3.

Dans ce tutoriel, je suppose que vous avez déjà une configuration de cluster Qumulo. Si ce n'est pas le cas, veuillez suivre ce tutoriel d'abord.

Modèle de déploiement

Pour des performances optimales, le modèle de passerelle distribuée de Minio est recommandé. À l'aide d'un DNS équilibreur de charge ou alternatif, plusieurs instances de Minio peuvent être activées et connectées au même NAS. L'équilibreur de charge peut répartir les demandes d'application sur un pool de serveurs Minio qui communiquent via NFS avec Qumulo. Du point de vue de vos applications, ils communiquent avec S3 alors que Qumulo ne voit que plusieurs clients NFS qui y sont connectés, vous n'avez donc pas à vous soucier du verrouillage.

Environnement recommandé

Qumulo Nodes: Tous les produits Qumulo sont compatibles avec Minio

Qumulo Client / Minio Server: 4 x uC-small (mc-14,15,18,19)

Mounts: chaque client a chaque noeud Qumulo monté avec des arguments NFS par défaut

Serveur Minio: instances 4 s'exécutant via Docker sur chaque ordinateur client

Client Minio (mc): Exécution de x86 en natif sur chaque serveur Minio

Tutorial

Télécharger Minio

Commençons par télécharger Minio. Minio est disponible pour tous les principaux systèmes d'exploitation et peut même être exécuté en tant que conteneur Docker ou Kubernetes.

Docker

$> docker pull minio / minio


Linux

$> wget https://dl.minio.io/server/minio/release/linux-amd64/minio $> chmod + x minio


MacOS

$> brassez installez minio / stable / minio


Windows

Téléchargez et installez via https://dl.minio.io/server/minio/release/windows-amd64/minio.exe

Exécution de Minio en mode passerelle

Dans chaque conteneur Docker sur vos clients, créez une instance Minio à l'aide de la commande suivante:

Docker

$> exécution du menu fixe -d -p 9000: 9000 -e "MINIO_ACCESS_KEY = minio" -e "MINIO_SECRET_KEY = minio123" --nom minio -v / mnt / minio-test: / mot-clé minio / minio / passerelle nas / nas

Linux

./minio gateway nas ./Path-To-Mounted-Qumulo


MacOS

passerelle minio nas ./Path-To-Mounted-Qumulo

Windows

passerelle minio.exe nas X: \ Path-To-Mounted-Qumulo

Testez que ça fonctionne

Pour vérifier que votre serveur Minio fonctionne, nous allons télécharger Boto, le SDK S3 Python et écrire un script simple.

$> pip3 installez boto3

Je vais créer un script de test en Python appelé «minio-test.py». À l'intérieur, j'ai écrit le code ci-dessous. Il utilise Boto3 pour lire le fichier 'minio-read-test.txt' stocké dans le dossier 'minio-demo' et imprime le contenu du fichier sur la console.

import boto3 à partir de botocore.client import Config # Configurez la connexion S3 s3 = boto3.resource ('s3', aws_access_key_id = 'VOTRE-ACCES-CLÉ-ICI', aws_secret_access_key = 'VOTRE-SECRE-KY -SERVER-URL-HERE ', config = Config (signature_version =' s3v4 ')) # Lire le fichier objet = s3.Object (' minio-demo ',' minio-read-test.txt ') body = object.get ( ) ['Body'] empreinte (body.read ())

Vous trouverez ci-dessous un exemple de code complet indiquant comment effectuer des opérations S3 supplémentaires.

Conclusion

Minio est un projet open source stable et extrêmement populaire vantant plus de millions de téléchargements 105. Le projet est populaire auprès d'une communauté extrêmement active, ce qui nous enthousiasme pour les clients qui le déploient dans leurs environnements. Nous sommes également enthousiasmés par le fait que nous prenons au sérieux les commentaires de nos clients et que le déploiement de Minio en tant qu’interface pour Qumulo répond à la demande principale d’une couche de compatibilité S3.

Exemple de code complet

# Importation du kit SDK AWS Python importation boto3 de botocore.client import Config bucket_name = 'minio-test-bucket' # Nom du dossier Qumulo monté nom_objet = 'minio-read-test.txt' # Nom du fichier que vous souhaitez lire votre dossier Qumulo # Configurez la connexion S3 s3 = boto3.resource ('s3', aws_access_key_id = 'Votre-clé-d’accès-ICI', aws_secret_access_key = 'Votre-clé-SECRET-KEY-HERE', endpoint_ur ICI ', config = Config (signature_version =' s3v4 ')) # Liste tous les compartiments pour le compartiment dans s3.buckets.all (): print (bucket.name) input (' Appuyez sur Entrée pour continuer ... \ n ') # Lire le fichier object = s3.Object (nom du compartiment, nom de l'objet) body = object.get () ['Body'] imprimer (body.read ()) print ('Fichier Lire') entrée ('Appuyez sur Entrée pour continuer ... \ n ') # Fichier de flux - Utile pour les fichiers plus volumineux object = s3.Object (nom_seau, nom_objet) body = object.get () [' Body '] avec io.FileIO (' / tmp / sample.txt ',' w ' ) en tant que tmp_file: while fichier.write (body.read (amt = 512)): pass print ('File Strea med @ /tmp/sample.txt ') input (' Appuyez sur Entrée pour continuer ... \ n ') # Fichier d'écriture s3.Object (nom de compartiment,' aws-write-test.txt '). put (Corps = ouvert ( './aws-write-test.txt', 'rb')) print ('Fichier écrit') entrée ('Appuyez sur Entrée pour continuer ... \ n') # Supprimez le fichier s3.Object (nom de compartiment, 'aws_write_test. txt '). delete () print (' Fichier supprimé ') entrée (' Appuyez sur Entrée pour continuer ... \ n ') # Flux Ecrire Fichier # Créer Bucket s3.create_bucket (Bucket =' new-bucket ') print (' Bucket Created ') input (' Appuyez sur Entrée pour continuer ... \ n ') # Supprimer Bucket bucket_to_delete = s3.Bucket (' new-bucket ') pour la clé dans bucket_to_delete.objects.all (): key.delete () bucket_to_delete .delete () print ('Bucket Deleted') entrée ('Appuyez sur Entrée pour continuer ... \ n')

performance

En fonction du nombre d'instances de passerelle Minio activées, les performances peuvent varier. En règle générale, plus la charge de travail sera parallélisable et plus il y aura de passerelles devant Qumulo, meilleures seront les performances. Pour aider les clients à déterminer si Minio pourrait les aider ou non, nous avons publié nos résultats de test de performance et notre méthodologie de test.

Environnement de test

  • Qumulo Nodes: 4 x Q0626 (du19,21,23,30)
  • Qumulo Client / Minio Server: 4 x uC-small (mc-14,15,18,19)
  • Mounts: chaque client a chaque noeud Qumulo monté avec des arguments NFS par défaut
  • Serveur Minio: instances 4 s'exécutant via Docker sur chaque ordinateur client avec la commande ci-dessous
$> exécution du menu fixe -d -p 9000: 9000 -e "MINIO_ACCESS_KEY = minio" -e "MINIO_SECRET_KEY = minio123" --nom minio -v / mnt / minio-test: / mot-clé minio / minio / passerelle nas / nas

Client Minio (mc): Exécution de x86 en natif sur chaque serveur Minio

Écriture à un seul flux: 84MB / s

Des zéros en streaming ont été transmis à Qumulo via la commande mc pipe du client Minio:

$> dd if = / dev / zero bs = 1M nombre = 10000 | ./mc pipe minio1 / test / 10Gzeros Les enregistrements 10000 + 0 dans 10000 + 0 enregistrent les octets 10485760000 (10 GB) copiés, 124.871 s, 84.0 MB / s

En utilisant Qumulo Analytics, nous voyons un mélange d’IOPS en lecture et en écriture pendant ce temps, avec les lectures provenant du répertoire .minio.sys / multipart:

Cela est dû à la façon dont le protocole S3 traite les gros fichiers dans lesquels le fichier est téléchargé en morceaux, puis réassemblé dans le fichier final à partir de ces parties. En mode passerelle NAS, Minio implémente ce comportement en attribuant à chaque bloc son propre fichier temporaire, en le lisant puis en l'ajoutant afin de l'ajouter au fichier final. Il existe essentiellement un facteur d'amplification en écriture de 2x et une lecture supplémentaire de toutes les données écrites.

Lecture en flux unique: 643MBps

Le fichier que j'ai écrit via la commande "mc cat" de Minio a été retransmis en streaming, en veillant à supprimer d'abord le cache du système de fichiers Linux et le cache Qumulo:

$> / opt / qumulo / qq_internal cache_clear $> echo 1> / proc / sys / vm / drop_caches $> ./mc cat minio1 / test / 10Gzeros | dd of = / dev / null bs = 1M Enregistrements 524 + 274771 dans 524 + 274771 enregistre des octets 10485760000 (10 GB) copiés, 16.3165 s, 643 MB / s


Mutli-Stream Write: ~ 600MBps-1GBps

Ce test a été exécuté avec des flux d'écriture 32 10GB s'exécutant en parallèle de la manière décrite ci-dessus (2 par instance Minio):

Lecture multi-flux: 1.1-1.7GBps

Ce test a été exécuté avec des flux de lecture 32 10GB s'exécutant en parallèle de la manière décrite ci-dessus (2 par instance Minio):

S3 Benchmarks

En utilisant La version modifiée de Minio of La référence S3 de Wasabi Tech, nous avons pu produire les résultats suivants à partir de notre environnement de test. Le benchmark devait être modifié car l'original prenait en charge le contrôle de version des objets, ce que Minio en mode passerelle ne prend pas en charge.

Client unique

$> ./s3-benchmark -a minio -s minio123 -u http: // localhost: 9001 -t Programme de référence Wasabi 100 v2.0 Paramètres: url = http: // hôte local: 9001, bucket = wasabi-benchmark-bucket, durée = 60, threads = 100, boucles = 1, taille = 1M Boucle 1: temps de PUT 60.2 secondes, objets = 7562, vitesse = 125.5MB / s, opérations 125.5 / s. Boucle 1: Temps GET 60.2 secondes, objets = 23535, vitesse = 390.8MB / s, opérations 390.8 / s. Boucle 1: temps DELETE, secondes 17.7, suppressions 427.9 / s. Indice de référence terminé.


Multi-client

Dans cette variante du test, nous avons exécuté une instance de s3-benchmark par instance Minio pour un total général d'instances simultanées 16. Chaque cycle d'analyse comparative s3 s'est vu attribuer son propre compartiment. Dans l'ensemble, les vitesses d'écriture semblaient atteindre environ ~ 700MBps, tandis que les vitesses de lecture atteignaient leur maximum à 1.5GBps, puis se réduisaient:

En augmentant la taille du fichier à 16MiB, j'ai pu atteindre le débit d'écriture agrégé 1.5-1.8 GBps et le débit de lecture agrégé 2.5 GBps au maximum. Il est possible d'augmenter le débit en écriture en spécifiant plus de threads, mais Minio démarré renvoie des erreurs 503, ce qui est probablement dû à l'exécution de quatre conteneurs Minio par ordinateur client.

Le script Bash suivant a été exécuté sur chacun des ordinateurs clients:

pour i dans $ (seq 1 4); s3-benchmark / s3-benchmark -a minio -s minio123 -u http: // localhost: 900 $ i -b $ HOSTNAME- $ i -t 20 -z 16M & done;

Compatibilité S3

Les API S3 suivantes ne sont pas prises en charge par Minio.

API de seau

  • BucketACL (Utilisation politiques de seau au lieu)
  • BucketCORS (CORS activé par défaut sur tous les compartiments pour tous les verbes HTTP)
  • BucketLifecycle (Non requis pour le backend codé avec effacement Minio)
  • BucketReplication (Utilisation mc miroir au lieu)
  • BucketVersions, BucketVersioning (Utiliser s3git)
  • BucketWebsite (Utiliser Caddie or nginx)
  • BucketAnalytics, BucketMetrics, BucketLogging (Utilisation notification de seau Apis)
  • BucketRequestPayment
  • BucketTagging

API d'objet

Restrictions sur les noms d'objet sur Minio

Noms d'objets contenant des caractères `^ * | & # 34; ne sont pas pris en charge sur Windows et les autres systèmes de fichiers qui ne prennent pas en charge les noms de fichiers contenant ces caractères.