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.
Analytics - explorateur de capacité
Analytics - tendances de la capacité
Analytics - analyse intégrée
Analytics - Points chauds IOPS
Analytics - Points chauds
Activité analytique par chemin
Activité d'analyse par client
Réplication continue
Configurez le réseau pour les adresses statiques
Créer un cluster Qumulo sur un Mac
Créer un cluster Qumulo sous Windows
Créer un quota
Créer une exportation NFS
Créer un partage SMB
Création d'instantanés à l'aide du tableau de bord Qumulo
Arrêt sécurisé
Scripting Qumulo avec S3 via Minio
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 d'abord suivre ce tutoriel.
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
Tutoriel
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/Unix
$> wget https://dl.minio.io/server/minio/release/linux-amd64/minio
$> chmod +x minio
MacOS
$> brew install minio/stable/minio
Windows
Téléchargez et installez via https://dl.minio.io/server/minio/release/windows-amd64/minio.exe
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
$> docker run -d -p 9000:9000 -e "MINIO_ACCESS_KEY=minio" -e "MINIO_SECRET_KEY=minio123" --name minio -v /mnt/minio-test:/nas minio/minio gateway nas /nas
Linux/Unix
./minio gateway nas ./Path-To-Mounted-Qumulo
MacOS
minio gateway nas ./Path-To-Mounted-Qumulo
Windows
minio.exe gateway 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 install 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
from botocore.client import Config
# Configure S3 Connection
s3 = boto3.resource('s3',
aws_access_key_id = 'YOUR-ACCESS-KEY-HERE',
aws_secret_access_key = 'YOUR-SECRET-KEY-HERE',
endpoint_url = 'YOUR-SERVER-URL-HERE',
config=Config(signature_version='s3v4'))
# Read File
object = s3.Object('minio-demo', 'minio-read-test.txt')
body = object.get()['Body']
print(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
# Import AWS Python SDK
import boto3
from botocore.client import Config
bucket_name = 'minio-test-bucket' # Name of the mounted Qumulo folder
object_name = 'minio-read-test.txt' # Name of the file you want to read inside your Qumulo folder
# Configure S3 Connection
s3 = boto3.resource('s3',
aws_access_key_id = 'YOUR-ACCESS-KEY-HERE',
aws_secret_access_key = 'YOUR-SECRET-KEY-HERE',
endpoint_url = 'YOUR-SERVER-URL-HERE',
config=Config(signature_version='s3v4'))
# List all buckets
for bucket in s3.buckets.all():
print(bucket.name)
input('Press Enter to continue...\n')
# Read File
object = s3.Object(bucket_name, object_name)
body = object.get()['Body']
print(body.read())
print('File Read')
input('Press Enter to continue...\n')
# Stream File - Useful for Larger Files
object = s3.Object(bucket_name, object_name)
body = object.get()['Body']
with io.FileIO('/tmp/sample.txt', 'w') as tmp_file:
while file.write(body.read(amt=512)):
pass
print('File Streamed @ /tmp/sample.txt')
input('Press Enter to continue...\n')
# Write File
s3.Object(bucket_name, 'aws-write-test.txt').put(Body=open('./aws-write-test.txt', 'rb'))
print('File Written')
input('Press Enter to continue...\n')
# Delete File
s3.Object(bucket_name, 'aws_write_test.txt').delete()
print('File Deleted')
input('Press Enter to continue...\n')
# Stream Write File
# Create Bucket
s3.create_bucket(Bucket='new-bucket')
print('Bucket Created')
input('Press Enter to continue...\n')
# Delete Bucket
bucket_to_delete = s3.Bucket('new-bucket')
for key in bucket_to_delete.objects.all():
key.delete()
bucket_to_delete.delete()
print('Bucket Deleted')
input('Press Enter to continue...\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
$> docker run -d -p 9000:9000 -e "MINIO_ACCESS_KEY=minio" -e "MINIO_SECRET_KEY=minio123" --name minio -v /mnt/minio-test:/nas minio/minio gateway nas /nas
Client Minio (mc): Exécution de x86 en natif sur chaque serveur Minio
Écriture à un seul flux: 84MB / s
Diffusion de zéros sur Qumulo via la commande mc pipe du client Minio:
$> dd if=/dev/zero bs=1M count=10000 | ./mc pipe minio1/test/10Gzeros
10000+0 records in
10000+0 records out
10485760000 bytes (10 GB) copied, 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
524+274771 records in
524+274771 records out
10485760000 bytes (10 GB) copied, 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 de 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
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):
$> ./s3-benchmark -a minio -s minio123 -u http://localhost:9001 -t 100
Wasabi benchmark program v2.0
Parameters: url=http://localhost:9001, bucket=wasabi-benchmark-bucket, duration=60, threads=100, loops=1, size=1M
Loop 1: PUT time 60.2 secs, objects = 7562, speed = 125.5MB/sec, 125.5 operations/sec.
Loop 1: GET time 60.2 secs, objects = 23535, speed = 390.8MB/sec, 390.8 operations/sec.
Loop 1: DELETE time 17.7 secs, 427.9 deletes/sec.
Benchmark completed.
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:
for i in $(seq 1 4); do
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
- ObjectACL (Utilisation politiques de seau au lieu)
- ObjectTorrent
- ObjectVersions
Restrictions sur les noms d'objet sur Minio
Les noms d'objets contenant des caractères «^ * |» ne sont pas pris en charge sous Windows et d'autres systèmes de fichiers qui ne prennent pas en charge les noms de fichiers avec ces caractères.
2. Une boîte de dialogue de confirmation apparaît. Cliquez sur Oui, supprimer.