Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Cet article fournit des instructions détaillées pour copier manuellement des données dans un conteneur de stockage d’objets blob à utiliser avec Azure HPC Cache. Il utilise des opérations parallèles multithread pour optimiser la vitesse de copie.
Pour en savoir plus sur le déplacement de données vers le stockage Blob pour votre cache Azure HPC Cache, lisez Déplacer des données vers le stockage Blob Azure.
Exemple de copie simple
Vous pouvez réaliser manuellement une copie multithread sur un client en exécutant simultanément plusieurs commandes de copie en arrière-plan sur des ensembles prédéfinis de fichiers ou de chemins d’accès.
La commande Linux/UNIX cp inclut l’argument -p permettant de conserver la propriété et les métadonnées mtime. L’ajout de cet argument aux commandes ci-dessous est facultatif. (L’ajout de l’argument augmente le nombre d’appels de système de fichiers envoyés du client au système de fichiers de destination pour la modification des métadonnées.)
Cet exemple simple copie deux fichiers en parallèle :
cp /mnt/source/file1 /mnt/destination1/ & cp /mnt/source/file2 /mnt/destination1/ &
Après avoir émis cette commande, la jobs commande indique que deux threads sont en cours d’exécution.
Copier des données avec des noms de fichiers prévisibles
Si vos noms de fichiers sont prévisibles, vous pouvez utiliser des expressions pour créer des threads de copie parallèles.
Par exemple, si votre répertoire contient 1 000 fichiers numérotés séquentiellement de 0001 à 1000, vous pouvez utiliser les expressions suivantes pour créer 10 threads parallèles qui copient chacun 100 fichiers :
cp /mnt/source/file0* /mnt/destination1/ & \
cp /mnt/source/file1* /mnt/destination1/ & \
cp /mnt/source/file2* /mnt/destination1/ & \
cp /mnt/source/file3* /mnt/destination1/ & \
cp /mnt/source/file4* /mnt/destination1/ & \
cp /mnt/source/file5* /mnt/destination1/ & \
cp /mnt/source/file6* /mnt/destination1/ & \
cp /mnt/source/file7* /mnt/destination1/ & \
cp /mnt/source/file8* /mnt/destination1/ & \
cp /mnt/source/file9* /mnt/destination1/
Copier des données avec des noms de fichiers non structurés
Si votre structure d’affectation de noms de fichiers n’est pas prévisible, vous pouvez regrouper des fichiers par noms de répertoires.
Cet exemple recueille des répertoires entiers pour les envoyer aux cp commandes exécutées en tant que tâches en arrière-plan :
/root
|-/dir1
| |-/dir1a
| |-/dir1b
| |-/dir1c
|-/dir1c1
|-/dir1d
Une fois les fichiers collectés, vous pouvez exécuter des commandes de copie parallèle pour copier de manière récursive les sous-répertoires et tout leur contenu :
cp /mnt/source/* /mnt/destination/
mkdir -p /mnt/destination/dir1 && cp /mnt/source/dir1/* mnt/destination/dir1/ &
cp -R /mnt/source/dir1/dir1a /mnt/destination/dir1/ &
cp -R /mnt/source/dir1/dir1b /mnt/destination/dir1/ &
cp -R /mnt/source/dir1/dir1c /mnt/destination/dir1/ & # this command copies dir1c1 via recursion
cp -R /mnt/source/dir1/dir1d /mnt/destination/dir1/ &
Quand ajouter des points de montage
Une fois que vous avez suffisamment de threads parallèles qui vont sur un point de montage du système de fichiers de destination unique, il y aura un point où l’ajout de threads supplémentaires ne donne pas plus de débit. (Le débit est mesuré dans les fichiers/secondes ou octets/seconde, en fonction de votre type de données.) Ou pire, le surthreading peut parfois entraîner une dégradation du débit.
Lorsque cela se produit, vous pouvez ajouter des points de montage côté client à d’autres adresses de montage Azure HPC Cache à l’aide du même chemin de montage de système de fichiers distant :
10.1.0.100:/nfs on /mnt/sourcetype nfs (rw,vers=3,proto=tcp,addr=10.1.0.100)
10.1.1.101:/nfs on /mnt/destination1type nfs (rw,vers=3,proto=tcp,addr=10.1.1.101)
10.1.1.102:/nfs on /mnt/destination2type nfs (rw,vers=3,proto=tcp,addr=10.1.1.102)
10.1.1.103:/nfs on /mnt/destination3type nfs (rw,vers=3,proto=tcp,addr=10.1.1.103)
L’ajout de points de montage côté client vous permet d'effectuer des commandes de copie supplémentaires vers les points de montage ajoutés /mnt/destination[1-3], ce qui permet d’obtenir un parallélisme accru.
Par exemple, si vos fichiers sont très volumineux, vous pouvez définir les commandes de copie pour utiliser des chemins de destination distincts, en envoyant plus de commandes en parallèle à partir du client effectuant la copie.
cp /mnt/source/file0* /mnt/destination1/ & \
cp /mnt/source/file1* /mnt/destination2/ & \
cp /mnt/source/file2* /mnt/destination3/ & \
cp /mnt/source/file3* /mnt/destination1/ & \
cp /mnt/source/file4* /mnt/destination2/ & \
cp /mnt/source/file5* /mnt/destination3/ & \
cp /mnt/source/file6* /mnt/destination1/ & \
cp /mnt/source/file7* /mnt/destination2/ & \
cp /mnt/source/file8* /mnt/destination3/ & \
Dans l’exemple ci-dessus, les trois points de montage de destination sont ciblés par les processus de copie de fichier client.
Quand ajouter des clients
Enfin, lorsque vous avez atteint les fonctionnalités du client, l’ajout de threads de copie ou de points de montage supplémentaires ne génère pas d’augmentations de fichiers supplémentaires/s ou d’octets/s. Dans ce cas, vous pouvez déployer un autre client avec le même ensemble de points de montage qui exécuteront ses propres ensembles de processus de copie de fichiers.
Exemple :
Client1: cp -R /mnt/source/dir1/dir1a /mnt/destination/dir1/ &
Client1: cp -R /mnt/source/dir2/dir2a /mnt/destination/dir2/ &
Client1: cp -R /mnt/source/dir3/dir3a /mnt/destination/dir3/ &
Client2: cp -R /mnt/source/dir1/dir1b /mnt/destination/dir1/ &
Client2: cp -R /mnt/source/dir2/dir2b /mnt/destination/dir2/ &
Client2: cp -R /mnt/source/dir3/dir3b /mnt/destination/dir3/ &
Client3: cp -R /mnt/source/dir1/dir1c /mnt/destination/dir1/ &
Client3: cp -R /mnt/source/dir2/dir2c /mnt/destination/dir2/ &
Client3: cp -R /mnt/source/dir3/dir3c /mnt/destination/dir3/ &
Client4: cp -R /mnt/source/dir1/dir1d /mnt/destination/dir1/ &
Client4: cp -R /mnt/source/dir2/dir2d /mnt/destination/dir2/ &
Client4: cp -R /mnt/source/dir3/dir3d /mnt/destination/dir3/ &
Créer des manifestes de fichier
Après avoir compris les approches ci-dessus (plusieurs threads de copie par destination, plusieurs destinations par client, plusieurs clients par système de fichiers source accessible au réseau), tenez compte de cette recommandation : Générer des manifestes de fichiers, puis les utiliser avec des commandes de copie sur plusieurs clients.
Ce scénario utilise la commande UNIX find pour créer des manifestes de fichiers ou de répertoires :
user@build:/mnt/source > find . -mindepth 4 -maxdepth 4 -type d
./atj5b55c53be6-01/support/gsi/2018-07-22T21:12:06EDT
./atj5b55c53be6-01/support/pcap/2018-07-23T01:34:57UTC
./atj5b55c53be6-01/support/trace/rolling
./atj5b55c53be6-03/support/gsi/2018-07-22T21:12:06EDT
./atj5b55c53be6-03/support/pcap/2018-07-23T01:34:57UTC
./atj5b55c53be6-03/support/trace/rolling
./atj5b55c53be6-02/support/gsi/2018-07-22T21:12:06EDT
./atj5b55c53be6-02/support/pcap/2018-07-23T01:34:57UTC
./atj5b55c53be6-02/support/trace/rolling
Redirigez ce résultat vers un fichier : find . -mindepth 4 -maxdepth 4 -type d > /tmp/foo
Vous pouvez ensuite effectuer une itération dans le manifeste, à l’aide de commandes BASH pour compter les fichiers et déterminer les tailles des sous-répertoires :
ben@xlcycl1:/sps/internal/atj5b5ab44b7f > for i in $(cat /tmp/foo); do echo " `find ${i} |wc -l` `du -sh ${i}`"; done
244 3.5M ./atj5b5ab44b7f-02/support/gsi/2018-07-18T00:07:03EDT
9 172K ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-18T05:01:00UTC
124 5.8M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-19T01:01:01UTC
152 15M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-20T01:01:00UTC
131 13M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-20T21:59:41UTC_partial
789 6.2M ./atj5b5ab44b7f-02/support/gsi/2018-07-20T21:59:41UTC
134 12M ./atj5b5ab44b7f-02/support/gsi/stats_2018-07-20T22:22:55UTC_hpccache_catchup
7 16K ./atj5b5ab44b7f-02/support/pcap/2018-07-18T17:12:19UTC
8 83K ./atj5b5ab44b7f-02/support/pcap/2018-07-18T17:17:17UTC
575 7.7M ./atj5b5ab44b7f-02/support/cores/armada_main.2000.1531980253.gsi
33 4.4G ./atj5b5ab44b7f-02/support/trace/rolling
281 6.6M ./atj5b5ab44b7f-01/support/gsi/2018-07-18T00:07:03EDT
15 182K ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-18T05:01:00UTC
244 17M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-19T01:01:01UTC
299 31M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-20T01:01:00UTC
256 29M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-20T21:59:41UTC_partial
889 7.7M ./atj5b5ab44b7f-01/support/gsi/2018-07-20T21:59:41UTC
262 29M ./atj5b5ab44b7f-01/support/gsi/stats_2018-07-20T22:22:55UTC_hpccache_catchup
11 248K ./atj5b5ab44b7f-01/support/pcap/2018-07-18T17:12:19UTC
11 88K ./atj5b5ab44b7f-01/support/pcap/2018-07-18T17:17:17UTC
645 11M ./atj5b5ab44b7f-01/support/cores/armada_main.2019.1531980253.gsi
33 4.0G ./atj5b5ab44b7f-01/support/trace/rolling
244 2.1M ./atj5b5ab44b7f-03/support/gsi/2018-07-18T00:07:03EDT
9 158K ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-18T05:01:00UTC
124 5.3M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-19T01:01:01UTC
152 15M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-20T01:01:00UTC
131 12M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-20T21:59:41UTC_partial
789 8.4M ./atj5b5ab44b7f-03/support/gsi/2018-07-20T21:59:41UTC
134 14M ./atj5b5ab44b7f-03/support/gsi/stats_2018-07-20T22:25:58UTC_hpccache_catchup
7 159K ./atj5b5ab44b7f-03/support/pcap/2018-07-18T17:12:19UTC
7 157K ./atj5b5ab44b7f-03/support/pcap/2018-07-18T17:17:17UTC
576 12M ./atj5b5ab44b7f-03/support/cores/armada_main.2013.1531980253.gsi
33 2.8G ./atj5b5ab44b7f-03/support/trace/rolling
Enfin, vous devez créer les commandes réelles de copie de fichiers aux clients.
Si vous avez quatre clients, utilisez cette commande :
for i in 1 2 3 4 ; do sed -n ${i}~4p /tmp/foo > /tmp/client${i}; done
Si vous avez cinq clients, utilisez ce qui suit :
for i in 1 2 3 4 5; do sed -n ${i}~5p /tmp/foo > /tmp/client${i}; done
Et pour six.... Extrapolez si nécessaire.
for i in 1 2 3 4 5 6; do sed -n ${i}~6p /tmp/foo > /tmp/client${i}; done
Vous obtiendrez N fichiers résultants, un pour chacun de vos clients N qui a les noms de chemin d’accès aux répertoires de niveau quatre obtenus dans le cadre de la sortie de la find commande.
Utilisez chaque fichier pour générer la commande de copie :
for i in 1 2 3 4 5 6; do for j in $(cat /tmp/client${i}); do echo "cp -p -R /mnt/source/${j} /mnt/destination/${j}" >> /tmp/client${i}_copy_commands ; done; done
Cela vous donnera N fichiers, chacun contenant une commande de copie par ligne, qui peuvent être exécutés en tant que script BASH sur la machine cliente.
L’objectif est d’exécuter plusieurs threads de ces scripts simultanément par client en parallèle sur plusieurs clients.