guestfs-performance - מקוון בענן

תָכְנִית:

שֵׁם

guestfs-performance - הנדסת libguestfs לביצועים מעולים

תיאור

עמוד זה מתעד כיצד להפיק את הביצועים הטובים ביותר מ-libguestfs, במיוחד כאשר
אתה מצפה להשתמש ב-libguestfs כדי לתפעל אלפי מכונות וירטואליות או תמונות דיסק.

שלושה תחומים עיקריים מכוסים. Libguestfs מפעיל מכשיר (הפצה קטנה של לינוקס)
בתוך qemu/KVM. שני התחומים הראשונים הם: צמצום הזמן שלוקח להתחיל את זה
המכשיר, ומספר הפעמים שיש להפעיל את המכשיר. התחום השלישי הוא
קיצור הזמן שלוקח לבדיקת מכשירי VM.

בסיס מידות

לפני ביצוע שינויים באופן השימוש ב-libguestfs, בצע מדידות בסיס.

קו בסיס: החל מה היא מכשיר
במכונה לא טעונה, זמן כמה זמן לוקח להפעיל את המכשיר:

time guestfish -ריצת /dev/null

הפעל את הפקודה הזו מספר פעמים ברציפות והסר את הריצות הראשונות, כך שאתה
מדידת מקרה "מטמון חם" טיפוסי.

הסבר

פקודה זו מפעילה את התקן libguestfs בדיסק null, ולאחר מכן נסגרת מיד
זה למטה. בפעם הראשונה שתפעיל את הפקודה, היא תיצור מכשיר ותשמור אותה במטמון
(בדרך כלל מתחת /var/tmp/.guestfs-*). ריצות עוקבות צריכות לעשות שימוש חוזר במכשיר השמור.

צפוי תוצאות

אתה צריך לצפות לקבל זמנים מתחת ל-6 שניות. אם הזמנים שאתה רואה ב-an
מכונה שלא נטענת נמצאות מעל זה, ואז עיין בסעיף "פתרון בעיות בביצועים גרועים"
לְהַלָן.

קו בסיס: מבצע בדיקה of a אורח
לבדיקה זו תזדקק למכונה לא טעונה ולפחות תמונת אורח או דיסק אמיתית אחת.
אם אתה מתכנן להשתמש ב-libguestfs רק נגד X אורחים (למשל X = Windows), אז השתמש
אורח X כאן יהיה המתאים ביותר. אם אתה מתכנן להפעיל את libguestfs נגד
שילוב של אורחים, ולאחר מכן השתמש בשילוב של אורחים לבדיקה כאן.

זמן כמה זמן לוקח לבצע בדיקה ולהרכיב את הדיסקים של האורח. להשתמש ב
הפקודה הראשונה אם תשתמש בתמונות דיסק, והפקודה השנייה אם תהיה
באמצעות libvirt.

time guestfish --ro -a disk.img -i exit

זמן guestfish --ro -d GuestName -i exit

הפעל את הפקודה מספר פעמים ברציפות ובטל את הריצות הראשונות, כך שאתה
מדידת מקרה "מטמון חם" טיפוסי.

הסבר

פקודה זו מפעילה את התקן libguestfs על תמונת הדיסק או האורח libvirt בשם,
מבצע בו בדיקת libguestfs (ראה "INSPECTION" ב guestfs(3)), עולה על של האורח
דיסקים, ואז משליך את כל התוצאות הללו ומכבה.

בפעם הראשונה שתפעיל את הפקודה, היא תיצור מכשיר ותשמור אותו במטמון (בדרך כלל
תחת /var/tmp/.guestfs-*). ריצות עוקבות צריכות לעשות שימוש חוזר במכשיר השמור.

צפוי תוצאות

אתה צריך לצפות לזמנים שהם ≤ 5 שניות יותר ממה שנמדד בקו הבסיס הראשון
בדיקה למעלה. (לדוגמה, אם מבחן הבסיס הראשון נמשך תוך 5 שניות, אז הבדיקה הזו
אמור לפעול תוך ≤ 10 שניות).

מבינים LA מַכשִׁיר ו כאשר IT IS בנוי/מאוחסן

בפעם הראשונה שאתה משתמש ב-libguestfs, הוא יבנה ותשמור מכשיר במטמון. זה בדרך כלל
in /var/tmp/.guestfs-*, אלא אם כן הגדרת $TMPDIR או $LIBGUESTFS_CACHEDIR במקרה כזה
זה יהיה תחת הספרייה הזמנית הזו.

למידע נוסף על אופן בניית המכשיר, ראה "מכשירי SUPERMIN" ב
supermin(1).

בכל פעם ש-libguestfs פועל, הוא יבדוק שאין קבצי מארח המשמשים את המכשיר
השתנה. אם יש, המכשיר נבנה מחדש. זה קורה בדרך כלל כאשר חבילה
מותקן או מעודכן במארח (למשל באמצעות תוכניות כמו "yum" או "apt-get"). ה
הסיבה לשחזור המכשיר היא אבטחה: התוכנית החדשה שהייתה
המותקן עשוי להכיל תיקון אבטחה, ולכן אנו רוצים לכלול את התוכנית הקבועה ב-
מכשיר אוטומטי.

אלו השלכות הביצועים:

· תהליך הבנייה (או הבנייה מחדש) של המכשיר המאוחסן הוא איטי, ואתה יכול
הימנע מכך על ידי שימוש במכשיר קבוע (ראה להלן).

· אם לא משתמשים במכשיר קבוע, שימו לב שעדכון תוכנה במארח יגרום
בנייה חד פעמית של המכשיר.

· / var / tmp (או $TMPDIR, $LIBGUESTFS_CACHEDIR) צריך להיות בדיסק מהיר, ויש לו הרבה
של מקום למכשיר.

משתמש A תוקן מַכשִׁיר

כדי לשלוט באופן מלא בעת בניית המכשיר, אתה יכול לבנות מכשיר קבוע. זֶה
יש לאחסן את המכשיר בדיסק מקומי מהיר.

כדי לבנות את המכשיר, הפעל את הפקודה:

libguestfs-make-fixed-appliance

מחליף" " עם שם הספרייה שבה המכשיר יאוחסן
(בדרך כלל היית שם ספריית משנה, למשל: /usr/local/lib/guestfs/appliance or
/dev/shm/appliance).

לאחר מכן הגדר את $LIBGUESTFS_PATH (ווודא שמשתנה סביבה זה מוגדר ב-libguestfs שלך
תוכנית), או שנה את התוכנית שלך כך שהיא תקרא "guestfs_set_path". לדוגמה:

ייצא LIBGUESTFS_PATH=/usr/local/lib/guestfs/appliance

עכשיו אתה יכול להפעיל תוכניות libguestfs, כלי virt, guestfish וכו' כרגיל. התוכניות
ישתמשו במכשיר הקבוע שלך, ולעולם לא יבנה, יבנה מחדש או שמור את עצמם
מכשיר.

(למידע מפורט בנושא זה, ראה: libguestfs-make-fixed-appliance(1)).

ביצוע of מה היא קבוע מכשיר
בבדיקות שלנו לא מצאנו ששימוש במכשיר קבוע נתן כל מדיד
יתרון ביצועים, גם כאשר המכשיר היה ממוקם בזיכרון (כלומר דולק / dev / shm).
עם זאת יש שתי נקודות שיש לקחת בחשבון:

1. שימוש במכשיר קבוע מונע מ-libguestfs לבנות מחדש את המכשיר, כלומר
של-libguestfs יהיו זמני הפעלה צפויים יותר.

2. המכשיר נטען לפי דרישה. בדיקה פשוטה כגון:

time guestfish -ריצת /dev/null

אינו טוען הרבה מאוד מהמכשיר. תוכנית libguestfs אמיתית באמצעות מסובכת
קריאות API ידרשו לטעון הרבה יותר מהמכשיר. היכולת לאחסן את
מכשיר במיקום מוגדר הופך את הביצועים לצפויים יותר.

צמצום LA מספר OF TIMES LA מַכשִׁיר IS הושק

ללא ספק הדרך היעילה ביותר, אם כי לא תמיד הדרך הפשוטה ביותר להשיג ביצועים טובים היא
כדי להבטיח שהמכשיר יופעל את מספר הפעמים המינימלי. זה יהיה כנראה
כרוך בשינוי אפליקציית libguestfs שלך.

נסה לקרוא "guestfs_launch" לכל היותר פעם אחת לכל מחשב וירטואלי יעד או תמונת דיסק.

במקום להשתמש במופע נפרד של דג אורח(1) לבצע סדרה של שינויים ב-
אותו אורח, השתמש במופע יחיד של דג אורח ו/או השתמש בדג אורח --להקשיב אוֹפְּצִיָה.

שקול לכתוב את התוכנית שלך בתור דמון שמחזיק אורח פתוח בזמן יצירת סדרה
של שינויים. או מרשל את כל הפעולות שאתה רוצה לבצע לפני פתיחת האורח.

אתה יכול גם לנסות להוסיף דיסקים ממספר אורחים למכשיר יחיד. לפני שמנסים
זאת, שימו לב לנקודות הבאות:

1. הוספת אורחים מרובים למכשיר אחד היא בעיית אבטחה מכיוון שהיא עשויה לאפשר אחד
אורח להפריע לדיסקים של אורח אחר. עשה את זה רק אם אתה סומך על כל
אורחים, או אם אתה יכול לקבץ אורחים לפי אמון.

2. קיימת הגבלה קשה למספר הדיסקים שניתן להוסיף למכשיר בודד. שִׂיחָה
"guestfs_max_disks" ב guestfs(3) כדי לקבל את הגבול הזה. למידע נוסף ראה
"מגבלות" ב guestfs(3).

3. השימוש ב-libguestfs בדרך זו הוא מסובך. לדיסקים יכולים להיות אינטראקציות בלתי צפויות: עבור
לדוגמה, אם שני אורחים משתמשים באותו UUID עבור מערכת קבצים (מכיוון שהם שובטו),
או שיש להם קבוצות נפח עם אותו שם (אך ראה "guestfs_lvm_set_filter").

virt-df(1) מוסיף דיסקים מרובים כברירת מחדל, כך שקוד המקור של תוכנית זו יהיה א
מקום טוב להתחיל בו.

הִתקַצְרוּת LA זמן לקחו עבור בדיקה OF VMs

העצה העיקרית ברורה: אל תבצע בדיקה (שהיא יקרה) אלא אם כן אתה צריך
התוצאות.

אם ביצעת בעבר בדיקה על האורח, אז זה יכול להיות בטוח לשמור במטמון ו
לעשות שימוש חוזר בתוצאות מהפעם הקודמת.

חלק מהדיסקים אינם צריכים להיבדק כלל: למשל, אם אתה יוצר דיסק
תמונה, או אם תמונת הדיסק אינה VM, או אם לתמונת הדיסק יש פריסה ידועה.

גם כאשר נדרשת בדיקה בסיסית ("guestfs_inspect_os"), בדיקת עזר
ניתן להימנע מפעולות:

· הרכבת דיסקים נחוצה רק כדי לקבל מידע נוסף על מערכת הקבצים.

· רישום יישומים ("guestfs_inspect_list_applications") היא פעולה יקרה
ב-Linux, אבל כמעט בחינם ב-Windows.

· יצירת אייקון אורח ("guestfs_inspect_get_icon") זולה בלינוקס אך יקרה
ב- Windows.

מַקְבִּיל מכשירים

מכשירי Libguestfs קשורים בעיקר ל-I/O וניתן להפעיל מספר מכשירים
מַקְבִּיל. בתנאי שיש מספיק זיכרון פנוי, אמור להיות הבדל קטן ב
השקת מכשיר אחד לעומת מכשירי N במקביל.

במחשב נייד בעל 2 ליבות (4 חוטים) עם זיכרון RAM של 16 ג'יגה-בייט, תוך שימוש במבחן (לא ריאלי במיוחד)
סקריפט Perl להלן, העלילה הבאה מציגה מדרגיות מצוינת כאשר פועלת בין 1
ו-20 מכשירים במקביל:

12 ++---+----+----+-----+-----+-----+-----+----+----+-- -++
+ + + + + + + + + + *
| |
| * |
11 ++ ++
| |
| |
| * * |
10 ++ ++
| * |
| |
s | |
9 ++ ++
ה | |
| * |
ג | |
8 ++ * ++
o | * |
| |
n 7 ++ ++
| * |
ד | * |
| |
s 6 ++ ++
| * * |
| * |
| |
5 ++ ++
| |
| * |
| * * |
4 ++ ++
| |
| |
+ * * * + + + + + + + + +
3 ++-*-+----+----+-----+-----+-----+-----+----+----+-- -++
מקורי XNXX 0 2 4 6 8 10 12 14 16 18 20 XNUMX XNUMX XNUMX XNUMX
מספר מכשירים מקבילים

אפשר להפעיל הרבה יותר מ-20 מכשירים במקביל, אבל אם אתה משתמש ב
libvirt backend אז אתה צריך להיות מודע לכך שמחוץ לקופסה libvirt מגביל את מספר
חיבורי לקוח עד 20.

התסריט הפשוט של Perl למטה שימש לאיסוף הנתונים עבור העלילה למעלה, אבל יש
הרבה יותר מידע בנושא זה, כולל סקריפטים וגרפים מבחן מתקדמים יותר,
זמין בפוסטים הבאים בבלוג:

http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-1/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-2/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-3/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-4/

#!/usr/bin/env פרל

השתמש מחמירים;
להשתמש בחוטים;
להשתמש באזהרות;
השתמש ב- Sys::Guestfs;
השתמש ב-Time::HiRes qw(time);

תת מבחן {
my $g = Sys::Guestfs->new;
$g->add_drive_ro ("/dev/null");
$g->השקה ();

# אתה יכול להוסיף קצת עבודה ל-libguestfs לעשות כאן.

$g->סגור ();
}

# הכנס הכל למטמון.
מבחן (); מבחן (); מבחן ();

עבור $nr_threads שלי (1..20) {
שלי $start_t = זמן ();
חוטי ה@ שלי;
foreach (1..$nr_threads) {
push @threads, threads->create (\&test)
}
foreach (@threads) {
$_->הצטרף ();
if (my $err = $_->error ()) {
ה-"השקה נכשלה עם שרשורי $nr_threads: $err"
}
}
my $end_t = זמן ();
printf ("%d %.2f\n", $nr_threads, $end_t - $start_t);
}

משתמש מצב משתמש LINUX

מאז libguestfs 1.24, ניתן היה להשתמש ב-User-Mode Linux (uml) backend
במקום KVM (ראה "USER-MODE LINUX BACKEND" ב guestfs(3)). הסעיף הזה עושה כמה
הערות כלליות לגבי הקצה האחורי הזה, אבל זה כן מאוד רצוי למדוד את שלך
עומס עבודה תחת UML ולא בוטח בהערות או באינטואיציה.

· UML בדרך כלל מבצע אותו דבר או מעט יותר איטי מ-KVM, על baremetal.

· עם זאת UML מבצעת לעתים קרובות את אותו הדבר תחת וירטואליזציה כפי שהיא עושה ב-baremetal,
ואילו KVM יכול לפעול הרבה יותר לאט תחת וירטואליזציה (מאז האצת וירט בחומרה
לא זמין).

· העלאה והורדה איטית פי 10 ב-UML מאשר ב-KVM. Libguestfs שולח
הנתונים האלה דרך היציאה הטורית המדומה UML, שהיא הרבה פחות יעילה מזו של KVM
וירטו-סדרתי.

· ל-UML חסרים תכונות מסוימות (למשל תמיכה ב-qcow2), כך שייתכן שהוא לא ישים כלל.

למספר נתונים אמיתיים, ראה:
http://rwmj.wordpress.com/2013/08/14/performance-of-user-mode-linux-as-a-libguestfs-backend/#content

פתרון תקלות עני ביצועים

להבטיח חומרה וירטואליזציה is זמין
השתמש / proc / cpuinfo והדף הזה:

http://virt-tools.org/learning/check-hardware-virt/

כדי להבטיח שווירטואליזציית חומרה זמינה. שים לב שייתכן שתצטרך להפעיל אותו
ב-BIOS שלך.

Virt של חומרה אינו זמין בדרך כלל בתוך מכשירי VM, ו-libguestfs יפעלו לאט בפנים
עוד מכונה וירטואלית מה שלא תעשה. וירטואליזציה מקוננת לא עובדת טוב אצלנו
ניסיון, והוא בהחלט לא תחליף להפעלת libguestfs על baremetal.

להבטיח KVM is זמין
ודא ש-KVM מופעל וזמין למשתמש שיפעיל את libguestfs. זה אמור
להיות בטוח להגדיר הרשאות 0666 /dev/kvm ורוב ההפצות עושות זאת כעת.

מעבדים ל לְהִמָנַע
הימנע ממעבדים שאין להם וירטואליזציה של חומרה, ומעבדים מסוימים שכן
פשוט מאוד איטי (AMD Geode הוא דוגמה מצוינת).

Xen dom0
ב-Xen, dom0 הוא מכונה וירטואלית, ולכן וירטואליזציה של החומרה אינה זמינה.

מְפוֹרָט תזמונים משתמש TS

השתמש ts(1) פקודה (מ-moreutils) כדי להציג תזמונים מפורטים:

$ guestfish -a /dev/null run -v |& ts -i '%s'
0.000022 libguestfs: הפעלה: program=guestfish
0.000134 libguestfs: השקה: version=1.29.31fedora=23,release=2.fc23,libvirt
0.000044 libguestfs: השקה: backend רשום: unix
0.000035 libguestfs: השקה: backend רשום: uml
0.000035 libguestfs: השקה: backend רשום: libvirt
0.000032 libguestfs: השקה: backend רשום: ישיר
0.000030 libguestfs: הפעלה: backend=libvirt
0.000031 libguestfs: השקה: tmpdir=/tmp/libguestfsw18rBQ
0.000029 libguestfs: השקה: umask=0002
0.000031 libguestfs: השקה: euid=1000
0.000030 libguestfs: libvirt version = 1002012 (1.2.12)
[וכו]

חותמות הזמן הן שניות (באופן מצטבר מאז השורה הקודמת).

מְפוֹרָט תזמונים משתמש SYSTEMTAP

אתה יכול להשתמש ב-SystemTap (שלב(1)) כדי לקבל תזמונים מפורטים מתוכניות libguestfs.

שמור את הסקריפט הבא בשם time.stap:

אחרון עולמי;

function display_time () {
now = gettimeofday_us ();
delta = 0;
אם (אחרון > 0)
delta = עכשיו - אחרון;
אחרון = עכשיו;

printf ("%d (+%d):", עכשיו, דלתא);
}

בדיקה מתחילה {
אחרון = 0;
printf ("מוכן\n");
}

/* הצג את כל הקריאות לסמנים סטטיים. */
תהליך בדיקה("/ Usr / lib*/libguestfs.so.0")
.provider("guestfs").mark("*") ? {
display_time();
printf ("\t%s %s\n", $$name, $$parms);
}

/* הצג את כל הקריאות לפונקציות guestfs_*. */
תהליך בדיקה("/ Usr / lib*/libguestfs.so.0")
.function("guestfs_[az]*") ? {
display_time();
printf ("\t%s %s\n", probefunc(), $$parms);
}

הפעל אותו כשורש בחלון אחד:

# stap time.stap
מוכן

הוא מדפיס "מוכן" כאשר SystemTap טען את התוכנית. הפעל את תוכנית libguestfs שלך,
דג אורח או כלי וירט בחלון אחר. לדוגמה:

$ guestfish -a /dev/null run

בחלון הסטאפ תראה כמות גדולה של פלט, עם הזמן שלוקח לכל אחד
השלב מוצג (מיקרו-שניות בסוגריים). לדוגמה:

xxxx (+0): guestfs_create
xxxx (+29): guestfs_set_pgroup g=0x17a9de0 pgroup=0x1
xxxx (+9): guestfs_add_drive_opts_argv g=0x17a9de0 [...]
xxxx (+8): guestfs_int_safe_strdup g=0x17a9de0 str=0x7f8a153bed5d
xxxx (+19): guestfs_int_safe_malloc g=0x17a9de0 nbytes=0x38
xxxx (+5): guestfs_int_safe_strdup g=0x17a9de0 str=0x17a9f60
xxxx (+10): guestfs_launch g=0x17a9de0
xxxx (+4): launch_start
[וכו]

תצטרך להתייעץ, ואפילו לשנות, את המקור ל-libguestfs כדי להבין אותו במלואו
הפלט.

מְפוֹרָט פיתרון משתמש Gdb

אתה יכול לצרף למכשיר BIOS/קרנל באמצעות gdb. אם אתה יודע מה אתה עושה,
זו יכולה להיות דרך שימושית לאבחון רגרסיות אתחול.

ראשית, עליך לשנות את ה-qemu כך שהוא ירוץ עם האפשרויות "-S" ו-"-s". אפשרויות אלו
לגרום ל-qemu להשהות בעת האתחול ולאפשר לך לצרף מאתר באגים. לקרוא qemu(1) להמשך
מֵידָע. Libguestfs מפעיל את ה-qemu מספר פעמים (כדי לסרוק את פלט העזרה וכן הלאה)
ואתה רוצה שרק הקריאה הסופית של qemu תשתמש באפשרויות האלה, אז השתמש במעטפת qemu
תסריט כזה:

#!/ bin / bash -

# הגדר את זה כך שיצביע על ה-qemu הבינארי האמיתי.
qemu=/usr/bin/qemu-kvm

if [ "$1" != "-גלובל" ]; לאחר מכן
# סריקת פלט עזרה וכו'.
exec $qemu "$@"
אחר
# באמת רץ qemu.
exec $qemu -S -s "$@"
fi

כעת הפעל את guestfish או כלי אחר של libguestfs עם מעטפת ה-qemu (ראה "QEMU WRAPPERS" ב-
guestfs(3) כדי להבין מה זה עושה):

LIBGUESTFS_HV=/path/to/qemu-wrapper guestfish -a /dev/null -v run

זה אמור להשהות מיד לאחר השקת qemu. בחלון אחר, צרף ל-qemu באמצעות gdb:

$ gdb
(gdb) הגדר ארכיטקטורה i8086
ההנחה היא שארכיטקטורת היעד היא i8086
(gdb) שלט יעד :1234
איתור באגים מרחוק באמצעות :1234
0x0000fff0 ב ?? ()
(gdb) המשך

בשלב זה אתה יכול להשתמש בטכניקות gdb סטנדרטיות, למשל. לחיצה על "^C" כדי להפריע לאתחול
ו-"bt" מקבלים מעקב מחסנית, הגדרת נקודות שבירה וכו'. שימו לב שכאשר אתם מעבר ל-
BIOS ואל ליבת לינוקס, תרצה לשנות את הארכיטקטורה בחזרה ל-32 או 64
bit.

השתמש ב-guestfs-performance באינטרנט באמצעות שירותי onworks.net