Bagikan melalui

Memindahkan data ke kluster vFXT - Penyerapan data paralel

  • Artikel

Setelah Anda membuat kluster vFXT baru, tugas pertama Anda mungkin adalah memindahkan data ke volume penyimpanan baru di Azure. Namun, jika metode pemindahan data Anda yang biasa mengeluarkan perintah penyalinan sederhana dari satu klien, Anda mungkin akan melihat performa penyalinan yang lambat. Penyalinan utas tunggal bukanlah pilihan yang baik untuk menyalin data ke penyimpanan back-end kluster Avere vFXT.

Karena kluster Avere vFXT for Azure adalah cache multi-klien yang dapat diskalakan, cara tercepat dan paling efisien untuk menyalin data ke sana adalah dengan beberapa klien. Teknik ini memparalelkan penyerapan file dan objek.

Diagram showing multi-client, multi-threaded data movement: At the top left, an icon for on-premises hardware storage has multiple arrows coming from it. The arrows point to four client machines. From each client machine three arrows point toward the Avere vFXT. From the Avere vFXT, multiple arrows point to Blob storage.

Perintah cp atau copy yang biasanya digunakan untuk mentransfer data dari satu sistem penyimpanan ke yang lain adalah proses utas tunggal yang hanya menyalin satu file pada satu waktu. Artinya, server file hanya menyerap satu file pada satu waktu - yang membuang-buang sumber daya kluster.

Artikel ini menjelaskan strategi pembuatan sistem penyalinan file multi-klien, multi-utas untuk memindahkan data ke kluster Avere vFXT. Hal ini menjelaskan konsep transfer file dan poin keputusan yang dapat digunakan untuk penyalinan data yang efisien menggunakan beberapa klien dan perintah salinan sederhana.

Hal ini juga menjelaskan beberapa utilitas yang dapat membantu. Utilitas msrsync dapat digunakan untuk mengotomatiskan sebagian proses membagi himpunan data ke dalam wadah dan menggunakan perintah rsync. Skrip parallelcp adalah utilitas lain yang membaca direktori sumber dan mengeluarkan perintah salin secara otomatis. Selain itu, alat rsync dapat digunakan dalam dua fase untuk menyediakan salinan yang lebih cepat yang masih memberikan konsistensi data.

Klik tautan untuk melompat ke suatu bagian:

Templat VM penyerap data

Templat Resource Manager tersedia di GitHub untuk membuat VM secara otomatis dengan alat penyerapan data paralel yang disebutkan dalam artikel ini.

diagram showing multiple arrows each from blob storage, hardware storage, and Azure file sources. The arrows point to a

VM penyerap data adalah bagian dari tutorial yang mengatur agar VM yang baru dibuat memasang kluster Avere vFXT dan mengunduh skrip bootstrapnya dari kluster. Baca Bootstrap VM penyerap data untuk mengetahui detailnya.

Perencanaan strategis

Saat merancang strategi untuk menyalin data secara paralel, Anda harus memahami pertukaran dalam ukuran file, jumlah file, dan kedalaman direktori.

  • Jika ukuran file kecil, metrik yang dimaksud adalah file per detik.
  • Jika ukuran file besar (10MiBi atau lebih besar), metrik yang dimaksud adalah byte per detik.

Setiap proses salin memiliki laju throughput dan laju yang ditransfer file, yang dapat diukur dengan mengatur waktu panjang perintah salin dan memperhitungkan ukuran file dan jumlah file. Menjelaskan cara mengukur tarif berada di luar cakupan dokumen ini, tetapi sangat penting untuk memahami apakah Anda akan berurusan dengan file kecil atau besar.

Contoh salinan manual

Anda dapat membuat salinan multi-rangkaian secara manual pada klien dengan menjalankan lebih dari satu perintah salinan sekaligus di latar belakang terhadap kumpulan file atau jalur yang telah ditentukan sebelumnya.

Perintah Linux/UNIX cpmenyertakan argumen -p untuk mempertahankan kepemilikan dan metadata mtime. Menambahkan argumen ini ke perintah di bawah ini bersifat opsional. (Penambahan argumen meningkatkan jumlah panggilan sistem file yang dikirim dari klien ke sistem file tujuan untuk modifikasi metadata.)

Contoh sederhana ini menyalin dua file secara paralel:

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

Setelah mengeluarkan perintah ini, perintah jobs akan menunjukkan bahwa dua utas sedang berjalan.

Struktur nama file yang dapat diprediksi

Jika nama file Anda dapat diprediksi, Anda dapat menggunakan ekspresi untuk membuat utas salinan paralel.

Misalnya, jika direktori Anda berisi 1000 file yang diberi nomor secara berurutan dari 0001 hingga 1000, Anda dapat menggunakan ekspresi berikut untuk membuat sepuluh utas paralel yang masing-masing menyalin 100 file:

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/

Struktur nama file tidak diketahui

Jika struktur penamaan file Anda tidak dapat diprediksi, Anda dapat mengelompokkan file berdasarkan nama direktori.

Contoh ini mengumpulkan seluruh direktori untuk dikirim cp perintah jalankan sebagai proses di latar belakang:

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

Setelah file dikumpulkan, Anda dapat menjalankan perintah salin paralel untuk menyalin subdirektori dan semua kontennya secara rekursif:

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

Kapan harus menambahkan titik pemasangan

Setelah Anda memiliki cukup utas paralel yang bertentangan dengan satu titik pemasangan sistem file tujuan, akan ada titik tempat menambahkan lebih banyak utas tidak memberikan lebih banyak throughput. (Keluaran akan diukur dalam file/detik atau byte/detik, tergantung pada jenis data Anda). Atau lebih buruk lagi, over-threading terkadang dapat menyebabkan penurunan throughput.

Ketika ini terjadi, Anda dapat menambahkan titik pemasangan sisi klien ke alamat IP kluster vFXT lainnya, dengan menggunakan jalur pemasangan sistem file jarak jauh yang sama:

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)

Dengan menambahkan titik pemasangan sisi klien, Anda dapat memotong perintah penyalinan tambahan ke titik pemasangan /mnt/destination[1-3] tambahan, sehingga mencapai paralelisme lebih lanjut.

Misalnya, jika filenya sangat besar, Anda dapat menentukan perintah salin untuk menggunakan jalur tujuan yang berbeda, sehingga mengirimkan lebih banyak perintah secara paralel dari klien yang melakukan penyalinan.

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

Dalam contoh di atas, ketiga titik pemasangan tujuan ditargetkan oleh proses penyalinan file klien.

Kapan harus menambahkan klien

Terakhir, ketika Anda telah mencapai kemampuan klien, menambahkan lebih banyak utas salin atau titik pemasangan tambahan tidak akan menghasilkan peningkatan file/dtk atau byte/dtk tambahan. Dalam situasi itu, Anda dapat menyebarkan klien lain dengan kumpulan titik pemasangan yang sama yang akan menjalankan kumpulan proses penyalinan filenya sendiri.

Contoh:

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

Buat manifes file

Setelah memahami pendekatan di atas (beberapa utas salinan per tujuan, beberapa tujuan per klien, beberapa klien per sistem file sumber yang dapat diakses jaringan), pertimbangkan rekomendasi ini: Bangun manifes file, lalu gunakan itu dengan perintah salin di beberapa klien.

Skenario ini menggunakan findperintah UNIX untuk membuat manifes file atau direktori:

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

Arahkan ulang hasil ini ke file: find . -mindepth 4 -maxdepth 4 -type d > /tmp/foo

Kemudian Anda dapat membuat pengulangan melalui manifes, menggunakan perintah BASH untuk menghitung file dan menentukan ukuran subdirektori:

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

Terakhir, Anda harus membuat perintah salin file yang sebenarnya ke klien.

Jika Anda memiliki empat klien, gunakan perintah ini:

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

Jika Anda memiliki lima klien, gunakan sesuatu seperti ini:

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

Dan untuk enam.... Ekstrapolasi sesuai kebutuhan.

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

Anda akan mendapatkan N file yang dihasilkan, satu untuk setiap N klien yang memiliki nama jalur ke direktori tingkat empat yang diperoleh sebagai bagian dari output dari perintah find.

Gunakan setiap file untuk membangun perintah salin:

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

Di atas akan memberi Anda N file, masing-masing dengan perintah salin per baris, yang dapat dijalankan sebagai skrip BASH pada klien.

Tujuannya adalah untuk menjalankan beberapa utas skrip ini secara bersamaan per klien secara paralel pada beberapa klien.

Gunakan proses rsync dua fase

Utilitas rsync standar tidak berfungsi dengan baik untuk mengisi penyimpanan cloud melalui sistem Avere vFXT for Azure karena menghasilkan sejumlah besar operasi pembuatan dan penggantian nama file untuk menjamin integritas data. Namun, Anda dapat dengan aman menggunakan opsi --inplace dengan rsync untuk melompati prosedur penyalinan yang lebih hati-hati jika Anda mengikutinya dengan eksekusi kedua yang memeriksa integritas file.

Operasi penyalinan rsync standar membuat file sementara dan mengisinya dengan data. Jika transfer data berhasil diselesaikan, file sementara diubah namanya menjadi nama file asli. Metode ini menjamin konsistensi bahkan jika file diakses selama penyalinan. Tetapi metode ini menghasilkan lebih banyak operasi tulis, yang memperlambat pergerakan file melalui cache.

Opsi --inplace menulis file baru secara langsung di lokasi akhirnya. Konsistensi file tidak dijamin selama transfer, tetapi itu tidak penting jika Anda menyiapkan sistem penyimpanan yang akan digunakan nanti.

Operasi rsync kedua berfungsi sebagai pemeriksaan konsistensi pada operasi pertama. Karena file telah disalin, fase kedua adalah pemindaian cepat untuk memastikan bahwa file di tujuan cocok dengan file di sumbernya. Jika ada file yang tidak cocok, file tersebut akan disalin ulang.

Anda dapat mengeluarkan kedua fase bersama-sama dalam satu perintah:

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

Metode ini adalah metode yang sederhana dan hemat waktu untuk himpunan data hingga jumlah file yang dapat ditangani oleh manajer direktori internal. (Ini biasanya 200 juta file untuk kluster 3-simpul, 500 juta file untuk cluster enam-simpul, dan seterusnya.)

Gunakan utilitas msrsync

Alat msrsync juga dapat digunakan untuk memindahkan data ke filer inti back-end untuk kluster Avere. Alat ini dirancang untuk mengoptimalkan penggunaan bandwidth dengan menjalankan beberapa proses rsync paralel. Ini tersedia dari GitHub di https://github.com/jbd/msrsync.

msrsync memecah direktori sumber menjadi “bucket” terpisah, lalu menjalankan proses rsync individual pada setiap bucket.

Pengujian awal dengan menggunakan VM empat inti menunjukkan efisiensi terbaik saat menggunakan 64 proses. Gunakan msrsync pilihan -p untuk mengatur jumlah proses ke 64.

Anda juga dapat menggunakan argumen --inplace dengan perintah msrsync. Jika Anda menggunakan opsi ini, pertimbangkan untuk menjalankan perintah kedua (seperti rsync, yang dijelaskan di atas) untuk memastikan integritas data.

msrsync hanya dapat menulis ke dan dari volume lokal. Sumber dan tujuan harus dapat diakses sebagai mount lokal di jaringan virtual kluster.

Agar dapat menggunakan msrsync untuk mengisi volume awan Azure dengan kluster Avere, ikuti petunjuk berikut:

  1. Instal msrsync dan prasyaratnya (rsync dan Python 2.6 atau lebih baru)

  2. Tentukan jumlah total file dan direktori yang akan disalin.

    Misalnya, gunakan utilitas Avere prime.py dengan argumenprime.py --directory /path/to/some/directory (tersedia dengan mengunduh urlhttps://github.com/Azure/Avere/blob/master/src/clientapps/dataingestor/prime.py).

    Jika tidak menggunakan prime.py, Anda dapat menghitung jumlah item dengan alat GNU find sebagai berikut:

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

  3. Bagilah jumlah item dengan 64 untuk menentukan jumlah item per proses. Gunakan nomor ini dengan opsi -f untuk mengatur ukuran bucket saat Anda menjalankan perintah.

  4. Keluarkan perintah msrsync untuk menyalin file:

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

    Jika menggunakan --inplace, tambahkan eksekusi kedua tanpa opsi untuk memeriksa apakah data disalin dengan benar:

    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>

    Misalnya, perintah ini dirancang untuk memindahkan 11.000 file dalam 64 proses dari /test/source-repository ke /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

Gunakan skrip salinan paralel

Skrip parallelcp juga dapat berguna untuk memindahkan data ke penyimpanan back-end di kluster vFXT Anda.

Skrip di bawah ini akan menambahkan parallelcp yang dapat dieksekusi. (Skrip ini dirancang untuk Ubuntu; jika menggunakan distribusi lain, Anda harus menginstal parallel secara terpisah.)

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

Contoh salinan paralel

Contoh ini menggunakan skrip salinan paralel untuk mengompilasi glibc dengan menggunakan file sumber dari kluster Avere.

File sumber disimpan di titik pemasangan kluster Avere, dan file objek disimpan di hard drive lokal.

Skrip ini menggunakan skrip salinan paralel di atas. Opsi -j digunakan dengan parallelcp dan make untuk mendapatkan paralelisasi.

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