Gegevens verplaatsen naar het vFXT-cluster : parallelle gegevens opnemen

Artikel
09/24/2021
13 minuten om te lezen

Nadat u een nieuw vFXT-cluster hebt gemaakt, kunt u als eerste gegevens verplaatsen naar een nieuw opslagvolume in Azure. Als uw gebruikelijke methode voor het verplaatsen van gegevens die een eenvoudige kopieeropdracht vanaf één client uitgeven, ziet u waarschijnlijk trage kopieerprestaties. Kopiëren met één thread is geen goede optie voor het kopiëren van gegevens naar Avere vFXT back-endopslag van het cluster.

Omdat het Avere vFXT for Azure cluster een schaalbare cache met meerdere clients is, is de snelste en meest efficiënte manier om gegevens naar het cluster te kopiëren met meerdere clients. Deze techniek parallelliseert de opname van de bestanden en objecten.

Diagram met meerdere clientgegevensver movementing met meerdere threads: Linksboven ziet u een pictogram voor on-premises hardwareopslag met meerdere pijlen die ervan afkomstig zijn. De pijlen wijzen naar vier clientmachines. Vanaf elke clientmachine wijzen drie pijlen naar de Avere vFXT. Vanuit de Avere vFXT wijzen meerdere pijlen naar Blob Storage.

De opdrachten of die vaak worden gebruikt voor het overdragen van gegevens van het ene opslagsysteem naar het andere, zijn processen met één thread die slechts één bestand cp copy tegelijk kopiëren. Dit betekent dat de bestandsserver slechts één bestand per keer opsommen, wat een verspilling is van de resources van het cluster.

In dit artikel worden strategieën uitgelegd voor het maken van een systeem voor het kopiëren van bestanden met meerdere clientthreads om gegevens te verplaatsen naar Avere vFXT cluster. Er worden concepten voor bestandsoverdracht en beslissingspunten uitgelegd die kunnen worden gebruikt voor het efficiënt kopiëren van gegevens met behulp van meerdere clients en eenvoudige kopieeropdrachten.

Er worden ook enkele hulpprogramma's uitgelegd die u kunnen helpen. Het hulpprogramma kan worden gebruikt om het proces van het delen van een gegevensset in buckets en het gebruik van opdrachten gedeeltelijk msrsync te rsync automatiseren. Het parallelcp script is een ander hulpprogramma dat de bronmap leest en automatisch kopieeropdrachten uit geeft. Het hulpprogramma kan ook in twee fasen worden gebruikt om een snellere kopie te bieden die nog rsync steeds gegevensconsistentie biedt.

Klik op de koppeling om naar een sectie te gaan:

Voorbeeld van handmatig kopiëren: een uitgebreide uitleg met behulp van kopieeropdrachten
Voorbeeld van rsync in twee fasen
Voorbeeld van gedeeltelijk geautomatiseerd (msrsync)
Voorbeeld van parallel kopiëren

VM-sjabloon data ingestor

Een Resource Manager-sjabloon is beschikbaar op GitHub om automatisch een VM te maken met de hulpprogramma's voor parallelle gegevensingestie die in dit artikel worden vermeld.

diagram met meerdere pijlen die elk afkomstig zijn van blobopslag, hardwareopslag en Azure-bestandsbronnen. De pijlen wijzen naar een 'data ingestor vm' en van hier naar de Avere vFXT

De data ingestor-VM maakt deel uit van een zelfstudie waarin de zojuist gemaakte VM het Avere vFXT-cluster vasthingen en het bootstrapscript van het cluster downloadt. Lees Bootstrap a data ingestor VM voor meer informatie.

Strategische planning

Bij het ontwerpen van een strategie om gegevens parallel te kopiëren, moet u de afwegingen in bestandsgrootte, bestandsgrootte en mapdiepte begrijpen.

Wanneer bestanden klein zijn, zijn de metrische gegevens van belang voor bestanden per seconde.
Wanneer bestanden groot zijn (10MiBi of hoger), is de metrische waarde bytes per seconde.

Elk kopieerproces heeft een doorvoersnelheid en een snelheid waarmee bestanden worden overgedragen. Dit kan worden gemeten door de duur van de kopieeropdracht te timingen en de bestandsgrootte en het aantal bestanden te factoreren. Uitleg over het meten van de tarieven valt buiten het bereik van dit document, maar het is belangrijk om te weten of u te maken hebt met kleine of grote bestanden.

Voorbeeld van handmatig kopiëren

U kunt handmatig een kopie met meerdere threads op een client maken door meer dan één kopieeropdracht tegelijk op de achtergrond uit te voeren op basis van vooraf gedefinieerde sets bestanden of paden.

De Linux/UNIX cp bevat het argument om eigendom en -p mtime-metagegevens te behouden. Het toevoegen van dit argument aan de onderstaande opdrachten is optioneel. (Het toevoegen van het argument verhoogt het aantal bestandssysteem aanroepen verzonden van de client naar het doelbestandssysteem voor metagegevens wijzigen.)

In dit eenvoudige voorbeeld worden twee bestanden parallel gekopieerd:

cp /mnt/source/file1 /mnt/destination1/ & cp /mnt/source/file2 /mnt/destination1/ &

Na het uitvoeren van deze opdracht wordt jobs met de opdracht laten zien dat er twee threads worden uitgevoerd.

Voorspelbare bestandsnaamstructuur

Als uw bestandsnamen voorspelbaar zijn, kunt u expressies gebruiken om parallelle kopieerthreads te maken.

Als uw map bijvoorbeeld 1000 bestanden bevat die sequentisch zijn genummerd van tot , kunt u de volgende expressies gebruiken om tien parallelle threads te maken die elk 0001 1000 100 bestanden kopiëren:

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/

Onbekende bestandsnaamstructuur

Als uw bestandsnaamgevingsstructuur niet voorspelbaar is, kunt u bestanden groeperen op mapnamen.

In dit voorbeeld worden volledige directories verzameld om opdrachten te verzenden cp die worden uitgevoerd als achtergrondtaken:

/root
|-/dir1
| |-/dir1a
| |-/dir1b
| |-/dir1c
   |-/dir1c1
|-/dir1d

Nadat de bestanden zijn verzameld, kunt u parallelle kopieeropdrachten uitvoeren om de subdirecties en alle inhoud ervan recursief te kopiëren:

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/ &

Wanneer u een bevestigingspunt toevoegt

Nadat u voldoende parallelle threads hebt die op een enkel doelbestandssysteem worden geplaatst, is er een punt waar het toevoegen van meer threads niet meer doorvoer geeft. (Doorvoer wordt gemeten in bestanden/seconde of bytes per seconde, afhankelijk van uw type gegevens.) Of nog erger: overthreading kan soms leiden tot een verslechtering van de doorvoer.

Als dit gebeurt, kunt u aan de clientzijde verbindingspunten toevoegen aan andere IP-adressen van het vFXT-cluster, met behulp van hetzelfde pad voor het externe bestandssysteem:

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)

Door bevestigingspunten aan de clientzijde toe te voegen, kunt u extra kopieeropdrachten naar de extra bevestigingspunten vervorken, waardoor /mnt/destination[1-3] verdere parallelle ontwikkeling wordt bereikt.

Als uw bestanden bijvoorbeeld erg groot zijn, kunt u de kopieeropdrachten definiëren om afzonderlijke doelpaden te gebruiken, en meer opdrachten parallel verzenden vanaf de client die de kopie uitvoeren.

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/ & \

In het bovenstaande voorbeeld worden alle drie de doel-mount points het doelwit van de processen voor het kopiëren van clientbestand.

Wanneer clients toevoegen

Ten laatste levert het toevoegen van meer kopieerthreads of extra bevestigingspunten geen extra bestanden per seconde of bytes per seconde op wanneer u de mogelijkheden van de client hebt bereikt. In dat geval kunt u een andere client implementeren met dezelfde set bevestigingspunten die zijn eigen sets met processen voor het kopiëren van bestanden uitvoeren.

Voorbeeld:

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/ &

Bestandsmanifests maken

Nadat u de bovenstaande benaderingen hebt begrepen (meerdere copy-threads per bestemming, meerdere bestemmingen per client, meerdere clients per bronbestandssysteem dat toegankelijk is voor het netwerk), kunt u deze aanbeveling overwegen: Bestandsmanifests bouwen en deze vervolgens gebruiken met kopieeropdrachten voor meerdere clients.

In dit scenario wordt de UNIX find gebruikt om manifesten van bestanden of mappen te maken:

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

Dit resultaat omleiden naar een bestand: find . -mindepth 4 -maxdepth 4 -type d > /tmp/foo

Vervolgens kunt u het manifest door middel van BASH-opdrachten uitvoeren om bestanden te tellen en de grootte van de subdirectorieën te bepalen:

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

Ten laatste moet u de daadwerkelijke opdrachten voor het kopiëren van bestanden naar de clients maken.

Als u vier clients hebt, gebruikt u deze opdracht:

for i in 1 2 3 4 ; do sed -n ${i}~4p /tmp/foo > /tmp/client${i}; done

Als u vijf clients hebt, gebruikt u iets als dit:

for i in 1 2 3 4 5; do sed -n ${i}~5p /tmp/foo > /tmp/client${i}; done

En voor zes... Extrapoleren naar behoefte.

for i in 1 2 3 4 5 6; do sed -n ${i}~6p /tmp/foo > /tmp/client${i}; done

U krijgt N resulterende bestanden, één voor elk van uw N-clients met de padnamen naar de mappen op niveau vier die zijn verkregen als onderdeel van de uitvoer van de find opdracht.

Gebruik elk bestand om de kopieeropdracht te maken:

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

Het bovenstaande geeft u N bestanden, elk met een kopieeropdracht per regel, die kunnen worden uitgevoerd als een BASH-script op de client.

Het doel is om meerdere threads van deze scripts gelijktijdig per client parallel uit te voeren op meerdere clients.

Een rsync-proces in twee fasen gebruiken

Het standaardprogramma werkt niet goed voor het vullen van cloudopslag via het Avere vFXT for Azure-systeem, omdat er een groot aantal bewerkingen voor het maken en hernoemen van bestanden wordt gegenereerd om gegevensintegriteit rsync te garanderen. U kunt de optie met echter veilig gebruiken om de meer zorgvuldige kopieerprocedure over te slaan als u deze procedure volgt met een tweede run die de --inplace rsync bestandsintegriteit controleert.

Met een rsync standaardkopiebewerking maakt u een tijdelijk bestand en vult u dit met gegevens. Als de gegevensoverdracht is voltooid, wordt de naam van het tijdelijke bestand gewijzigd in de oorspronkelijke bestandsnaam. Deze methode garandeert consistentie, zelfs als de bestanden tijdens het kopiëren worden gebruikt. Met deze methode worden echter meer schrijfbewerkingen gegenereerd, waardoor de verplaatsing van bestanden via de cache wordt vertraagd.

De optie --inplace schrijft het nieuwe bestand rechtstreeks naar de uiteindelijke locatie. Bestanden zijn niet gegarandeerd consistent tijdens de overdracht, maar dat is niet belangrijk als u een opslagsysteem voor later gebruik in gebruik wilt.

De tweede rsync bewerking fungeert als een consistentiecontrole bij de eerste bewerking. Omdat de bestanden al zijn gekopieerd, is de tweede fase een snelle scan om ervoor te zorgen dat de bestanden op de bestemming overeenkomen met de bestanden op de bron. Als bestanden niet overeenkomen, worden ze opnieuw gecodeerd.

U kunt beide fasen samen in één opdracht uitvoeren:

rsync -azh --inplace <source> <destination> && rsync -azh <source> <destination>

Deze methode is een eenvoudige en kosteneffectieve methode voor gegevenssets tot het aantal bestanden dat door de interne directorybeheerder kan worden verwerkt. (Dit zijn doorgaans 200 miljoen bestanden voor een cluster met drie knooppunt, 500 miljoen bestanden voor een cluster met zes knooppunt, en meer.)

Het hulpprogramma msrsync gebruiken

Het msrsync hulpprogramma kan ook worden gebruikt om gegevens te verplaatsen naar een back-end kern-filer voor het Avere-cluster. Dit hulpprogramma is ontworpen om het bandbreedtegebruik te optimaliseren door meerdere parallelle processen uit te rsync werken. Deze is beschikbaar via GitHub op https://github.com/jbd/msrsync .

msrsync de bronmap opbreekt in afzonderlijke 'buckets' en voert vervolgens afzonderlijke rsync processen uit op elke bucket.

Voorlopige tests met behulp van een VM met vier kernen hebben de beste efficiëntie aangetoond bij het gebruik van 64 processen. Gebruik de msrsync optie om het aantal processen in te stellen op -p 64.

U kunt het argument ook --inplace gebruiken met msrsync opdrachten. Als u deze optie gebruikt, kunt u overwegen een tweede opdracht uit te voeren (zoals met rsync, zoals hierboven beschreven) om de gegevensintegriteit te garanderen.

msrsync kan alleen schrijven naar en van lokale volumes. De bron en het doel moeten toegankelijk zijn als lokale mounts in het virtuele netwerk van het cluster.

Als u wilt msrsync gebruiken om een Azure-cloudvolume te vullen met een Avere-cluster, volgt u deze instructies:

Installeren msrsync en de vereisten (rsync en Python 2.6 of hoger)
Bepaal het totale aantal bestanden en mappen dat moet worden gekopieerd.

Gebruik bijvoorbeeld het hulpprogramma Avere met prime.py argumenten prime.py --directory /path/to/some/directory (beschikbaar door URL te https://github.com/Azure/Avere/blob/master/src/clientapps/dataingestor/prime.py downloaden).

Als u geen gebruikt, kunt u het aantal items als volgt berekenen met het prime.py find GNU-hulpprogramma:
```
find <path> -type f |wc -l         # (counts files)
find <path> -type d |wc -l         # (counts directories)
find <path> |wc -l                 # (counts both)
```
Deel het aantal items door 64 om het aantal items per proces te bepalen. Gebruik dit nummer met de -f optie om de grootte van de buckets in te stellen wanneer u de opdracht uit te voeren.
Voer de opdracht msrsync uit om bestanden te kopiëren:
```
msrsync -P --stats -p 64 -f <ITEMS_DIV_64> --rsync "-ahv" <SOURCE_PATH> <DESTINATION_PATH>
```
Als u gebruikt, voegt u een tweede uitvoering toe zonder de optie om te controleren of de --inplace gegevens correct zijn gekopieerd:
```
msrsync -P --stats -p 64 -f <ITEMS_DIV_64> --rsync "-ahv --inplace" <SOURCE_PATH> <DESTINATION_PATH> && msrsync -P --stats -p 64 -f <ITEMS_DIV_64> --rsync "-ahv" <SOURCE_PATH> <DESTINATION_PATH>
```
Met deze opdracht worden bijvoorbeeld 11.000 bestanden in 64 processen van /test/source-repository naar /mnt/vfxt/repository verplaatst:

msrsync -P --stats -p 64 -f 170 --rsync "-ahv --inplace" /test/source-repository/ /mnt/vfxt/repository && msrsync -P --stats -p 64 -f 170 --rsync "-ahv --inplace" /test/source-repository/ /mnt/vfxt/repository

Het script voor parallel kopiëren gebruiken

Het parallelcp script kan ook nuttig zijn voor het verplaatsen van gegevens naar de back-endopslag van uw vFXT-cluster.

Het onderstaande script voegt het uitvoerbare bestand parallelcp toe. (Dit script is ontworpen voor Ubuntu. Als u een andere distributie gebruikt, moet u parallel afzonderlijk installeren.)

sudo touch /usr/bin/parallelcp && sudo chmod 755 /usr/bin/parallelcp && sudo sh -c "/bin/cat >/usr/bin/parallelcp" <<EOM
#!/bin/bash

display_usage() {
    echo -e "\nUsage: \$0 SOURCE_DIR DEST_DIR\n"
}

if [  \$# -le 1 ] ; then
    display_usage
    exit 1
fi

if [[ ( \$# == "--help") ||  \$# == "-h" ]] ; then
    display_usage
    exit 0
fi

SOURCE_DIR="\$1"
DEST_DIR="\$2"

if [ ! -d "\$SOURCE_DIR" ] ; then
    echo "Source directory \$SOURCE_DIR does not exist, or is not a directory"
    display_usage
    exit 2
fi

if [ ! -d "\$DEST_DIR" ] && ! mkdir -p \$DEST_DIR ; then
    echo "Destination directory \$DEST_DIR does not exist, or is not a directory"
    display_usage
    exit 2
fi

if [ ! -w "\$DEST_DIR" ] ; then
    echo "Destination directory \$DEST_DIR is not writeable, or is not a directory"
    display_usage
    exit 3
fi

if ! which parallel > /dev/null ; then
    sudo apt-get update && sudo apt install -y parallel
fi

DIRJOBS=225
JOBS=225
find \$SOURCE_DIR -mindepth 1 -type d -print0 | sed -z "s/\$SOURCE_DIR\///" | parallel --will-cite -j\$DIRJOBS -0 "mkdir -p \$DEST_DIR/{}"
find \$SOURCE_DIR -mindepth 1 ! -type d -print0 | sed -z "s/\$SOURCE_DIR\///" | parallel --will-cite -j\$JOBS -0 "cp -P \$SOURCE_DIR/{} \$DEST_DIR/{}"
EOM

Voorbeeld van parallel kopiëren

In dit voorbeeld wordt het script voor parallel kopiëren gebruikt om te glibc compileren met behulp van bronbestanden uit het Avere-cluster.

De bronbestanden worden opgeslagen op het Avere-cluster mount point en de objectbestanden worden opgeslagen op de lokale harde schijf.

In dit script wordt het bovenstaande script voor parallel kopiëren gebruikt. De optie -j wordt gebruikt met en om parallelcp make parallellisatie te verkrijgen.

sudo apt-get update
sudo apt install -y gcc bison gcc binutils make parallel
cd
wget https://mirrors.kernel.org/gnu/libc/glibc-2.27.tar.bz2
tar jxf glibc-2.27.tar.bz2
ln -s /nfs/node1 avere
time parallelcp glibc-2.27 avere/glibc-2.27
cd
mkdir obj
mkdir usr
cd obj
/home/azureuser/avere/glibc-2.27/configure --prefix=/home/azureuser/usr
time make -j