Přesun dat do clusteru vFXT – Paralelní ingestování dat

  • Článek
  • 11 min ke čtení

Po vytvoření nového clusteru vFXT může být vaším prvním úkolem přesun dat na nový svazek úložiště v Azure. Pokud však obvyklá metoda přesunu dat vydává jednoduchý příkaz pro kopírování z jednoho klienta, pravděpodobně se zobrazí nízký výkon kopírování. Kopírování s jedním vláknem není dobrou volbou pro kopírování dat do Avere vFXT back-endového úložiště clusteru.

Vzhledem k Avere vFXT for Azure cluster je škálovatelná mezipaměť s více klienty, nejrychlejší a nejúčinnější způsob kopírování dat do ní je s více klienty. Tato technika paralelizuje příjem souborů a objektů.

Diagram znázorňující přesun dat s více klienty s více vlákny: Ikona místního hardwarového úložiště má vlevo nahoře několik šipek, které z něj přicházejí. Šipky odkazovat na čtyři klientské počítače. Z každého klientského počítače míří tři šipky směrem k Avere vFXT. Několik šipek Avere vFXT na Úložiště objektů blob.

Příkazy nebo, které se běžně používají k přenosu dat z jednoho úložného systému do druhého, jsou procesy s jedním vláknem, které kopírují pouze jeden cp copy soubor najednou. To znamená, že souborový server ingestuje najednou jenom jeden soubor – to je plýtvání prostředky clusteru.

Tento článek vysvětluje strategie pro vytvoření systému pro kopírování souborů s více klienty a více vlákny pro přesun dat do Avere vFXT clusteru. Vysvětluje koncepty přenosu souborů a rozhodovací body, které lze použít k efektivnímu kopírování dat pomocí více klientů a jednoduchých příkazů pro kopírování.

Vysvětluje také některé nástroje, které vám můžou pomoct. Pomocí nástroje je možné částečně automatizovat proces dělení datové sady do msrsync kbelíků a pomocí rsync příkazů. Skript parallelcp je další nástroj, který čte zdrojový adresář a automaticky vydává příkazy pro kopírování. Nástroj lze také použít ve dvou fázích k zajištění rychlejší kopie, která stále zajišťuje rsync konzistenci dat.

Kliknutím na odkaz přejdete na oddíl:

Šablona virtuálního počítače s gestorem dat

Na Resource Manager k dispozici šablona GitHub pro automatické vytvoření virtuálního počítače s nástroji pro paralelní příjem dat zmíněnými v tomto článku.

Diagram znázorňující několik šipek z úložiště objektů blob, hardwarového úložiště a zdrojů souborů Azure Šipky odkazjí na "virtuální počítač s datovými ingestory" a z tohoto virtuálního počítače ukazuje více šipek na Avere vFXT

Virtuální počítač s datovými ingestory je součástí kurzu, kde nově vytvořený virtuální počítač připojí cluster Avere vFXT a stáhne svůj zaváděcí skript z clusteru. Podrobnosti najdete v tématu Spuštění virtuálního počítače s ingestorem dat.

Strategické plánování

Při navrhování strategie paralelního kopírování dat byste měli rozumět kompromisům z oblasti velikosti souboru, počtu souborů a hloubky adresáře.

  • Pokud jsou soubory malé, metrika, která vás zajímá, jsou soubory za sekundu.
  • Pokud jsou soubory velké (10MiBi nebo vyšší), metrika zájmu je bajty za sekundu.

Každý proces kopírování má rychlost propustnosti a přenosy souborů, které je možné změřit načasováním délky příkazu pro kopírování a zoceněním velikosti souboru a počtu souborů. Vysvětlení, jak měřit sazby, je nad rámec tohoto dokumentu, ale je důležité pochopit, jestli budete řešit malé nebo velké soubory.

Příklad ručního kopírování

Kopii s více vlákny můžete na klientovi vytvořit ručně spuštěním více než jednoho příkazu kopírování na pozadí s předdefinovanými sadami souborů nebo cest.

Příkaz Linux/systém UNIX obsahuje argument pro zachování vlastnictví a cp -p metadat mtime. Přidání tohoto argumentu do následujících příkazů je volitelné. (Přidáním argumentu se zvýší počet volání systému souborů odeslaných z klienta do cílového systému souborů kvůli úpravám metadat.)

Tento jednoduchý příklad paralelně kopíruje dva soubory:

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

Po spuštění tohoto příkazu příkaz zobrazí, že jsou spuštěná jobs dvě vlákna.

Předvídatelná struktura názvů souborů

Pokud jsou názvy souborů předvídatelné, můžete pomocí výrazů vytvořit vlákna paralelního kopírování.

Pokud například váš adresář obsahuje 1 000 souborů sekvenčně očíslovaných od do , můžete pomocí následujících výrazů vytvořit deset paralelních vláken, z nichž každý zkopíruje 0001 1000 100 souborů:

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/

Struktura neznámého názvu souboru

Pokud vaše struktura pojmenování souborů není předvídatelná, můžete soubory seskupit podle názvů adresářů.

Tento příklad shromažďuje celé adresáře, které se mají odeslat do cp příkazů spuštěných jako úlohy na pozadí:

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

Po shromážděných souborech můžete spustit paralelní příkazy kopírování, které rekurzivně zkopírují podadresáře a veškerý jejich obsah:

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

Kdy přidat přípojné body

Jakmile budete mít dostatek paralelních vláken pro jeden cílový přípojný bod systému souborů, bude na místě, kde přidání dalších vláken neposkytuje větší propustnost. (Propustnost se bude měřit v souborech za sekundu nebo bajtech za sekundu v závislosti na typu dat.) Nebo ještě horší je, že přílišné zřetěžení může někdy způsobit snížení propustnosti.

Když k tomu dojde, můžete přidat přípojné body na straně klienta k jiným IP adresám clusteru vFXT pomocí stejné cesty připojení vzdáleného systému souborů:

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)

Přidání přípojných bodů na straně klienta umožňuje vytvořit fork dalších příkazů kopírování do dalších přípojných bodů /mnt/destination[1-3] a dosáhnout tak dalšího paralelismu.

Pokud jsou například soubory velmi velké, můžete definovat příkazy kopírování, které budou používat odlišné cílové cesty a současně odesílat další příkazy z klienta, který kopii provádí.

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

V příkladu výše jsou všechny tři cílové přípojné body cílem procesů kopírování souborů klienta.

Kdy přidat klienty

A konečně, když dosáhnete schopností klienta, přidání dalších vláken kopírování nebo dalších přípojných bodů nezvětší žádné další soubory/s ani bajty/s. V takové situaci můžete nasadit jiného klienta se stejnou sadou přípojových bodů, ve které budou spuštěny vlastní sady procesů kopírování souborů.

Příklad:

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

Vytváření manifestů souborů

Po pochopení výše uvedených přístupů (více vláken kopírování na cíl, více cílů na klienta, více klientů na zdrojový systém souborů s přístupem k síti) zvažte toto doporučení: Sestavíte manifesty souborů a pak je použijete s příkazy pro kopírování mezi více klienty.

Tento scénář používá systém UNIX find k vytvoření manifestů souborů nebo adresářů:

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

Přesměrovat tento výsledek do souboru: find . -mindepth 4 -maxdepth 4 -type d > /tmp/foo

Potom můžete iterovat manifestem pomocí příkazů BASH k počítání souborů a určení velikostí podadresářů:

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

Nakonec musíte klientům vytvořit příkazy pro vlastní kopírování souborů.

Pokud máte čtyři klienty, použijte tento příkaz:

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

Pokud máte pět klientů, použijte něco podobného:

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

A za šest... Extrapolovat podle potřeby.

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

Získáte N výsledných souborů, jeden pro každého klienta N, který má názvy cest k adresářům úrovně 4 získaným jako součást výstupu find příkazu .

Pomocí každého souboru sestavte příkaz copy:

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

Výše uvedené informace vám poskytne N souborů, každý s příkazem copy na řádek, které lze spustit jako skript BASH na klientovi.

Cílem je spustit několik vláken těchto skriptů paralelně pro každého klienta na více klientech.

Použití dvoufázového procesu rsync

Standardní nástroj nefunguje dobře pro naplnění cloudového úložiště prostřednictvím systému Avere vFXT for Azure, protože generuje velký počet operací vytvoření a přejmenování souborů, aby se zaručil rsync integrita dat. Pokud ale postup kopírování použijete při druhém spuštění, které kontroluje integritu souboru, můžete bezpečně použít možnost s parametrem --inplace rsync .

Standardní operace rsync kopírování vytvoří dočasný soubor a vyplní ho daty. Pokud se přenos dat úspěšně dokončí, dočasný soubor se přejmenuje na původní název souboru. Tato metoda zaručuje konzistenci i v případě, že se k souborům přistupuje během kopírování. Tato metoda ale generuje více operací zápisu, což zpomaluje přesun souborů prostřednictvím mezipaměti.

Možnost --inplace zapíše nový soubor přímo do konečného umístění. Není zaručeno, že soubory budou během přenosu konzistentní, ale to není důležité, pokud budete systém úložiště připravovat pro pozdější použití.

Druhá operace rsync slouží jako kontrola konzistence u první operace. Vzhledem k tomu, že soubory již byly zkopírovány, je druhou fází rychlá kontrola, která zajistí, aby soubory v cíli odpovídaly souborům ve zdroji. Pokud se nějaké soubory neshodují, jsou zobráněny.

Obě fáze můžete vydat společně v jednom příkazu:

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

Tato metoda je jednoduchá a nákladově efektivní metoda pro datové sady až do počtu souborů, které může interní správce adresáře zpracovat. (Obvykle se jedná o 200 milionů souborů pro cluster se 3 uzly, 500 milionů souborů pro cluster se šesti uzly atd.)

Použití nástroje msrsync

Nástroj msrsync lze také použít k přesunu dat do back-endového základního fileru pro cluster Avere. Tento nástroj je navržený tak, aby optimalizoval využití šířky pásma spuštěním několika paralelních rsync procesů. Je k dispozici na GitHub na https://github.com/jbd/msrsync adrese .

msrsync rozdělí zdrojový adresář do samostatných "kbelíků" a pak v každém kbelíku spustí rsync jednotlivé procesy.

Předběžné testování pomocí virtuálního počítače se čtyřmi jádry ukázalo nejlepší efektivitu při použití 64 procesů. Pomocí msrsync možnosti -p nastavte počet procesů na 64.

Argument můžete použít také --inplace s příkazy msrsync . Pokud použijete tuto možnost, zvažte spuštění druhého příkazu (stejně jako u rsyncpopsaného výše), abyste zajistili integritu dat.

msrsync může zapisovat jenom na místní svazky a z místních svazků. Zdroj a cíl musí být přístupné jako místní připojení ve virtuální síti clusteru.

Pokud chcete použít msrsync k naplnění cloudového svazku Azure pomocí clusteru avere, postupujte podle těchto pokynů:

  1. Nainstalovat msrsync a jeho požadavky (rsync a Python 2,6 nebo novější)

  2. Určete celkový počet souborů a adresářů, které mají být zkopírovány.

    Použijte například nástroj avere prime.py s argumenty prime.py --directory /path/to/some/directory (k dispozici stažením adresy URL https://github.com/Azure/Avere/blob/master/src/clientapps/dataingestor/prime.py ).

    Pokud nepoužíváte prime.py , můžete vypočítat počet položek pomocí nástroje GNU následujícím find způsobem:

    find <path> -type f |wc -l         # (counts files)
find <path> -type d |wc -l         # (counts directories)
find <path> |wc -l                 # (counts both)

  3. Rozdělte počet položek podle 64 k určení počtu položek na proces. Toto číslo použijte s -f možností nastavení velikosti intervalů při spuštění příkazu.

  4. Vydejte msrsync příkaz ke kopírování souborů:

    msrsync -P --stats -p 64 -f <ITEMS_DIV_64> --rsync "-ahv" <SOURCE_PATH> <DESTINATION_PATH>

    Pokud používáte --inplace , přidejte druhé spuštění bez možnosti, abyste zkontrolovali, jestli jsou data správně zkopírovaná:

    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>

    Například tento příkaz je navržen pro přesun 11 000 souborů v 64 Process z/test/source-repository na/mnt/vfxt/Repository:

    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

Použití skriptu paralelního kopírování

Tento parallelcp skript může být vhodný také pro přesun dat do back-endu clusteru vFXT.

Do následujícího skriptu se přidá spustitelný soubor parallelcp . (Tento skript je určený pro Ubuntu; Pokud používáte jinou distribuci, musíte nainstalovat parallel samostatně.)

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

Příklad paralelního kopírování

V tomto příkladu se používá skript paralelního kopírování ke kompilaci glibc pomocí zdrojových souborů z clusteru avere.

Zdrojové soubory jsou uloženy v přípojném bodu clusteru avere a soubory objektů jsou uloženy na místním pevném disku.

Tento skript používá skript paralelního kopírování. Možnost se -j používá s parallelcp a make k získání paralelismu.

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