האם אשכול Redis זקוק לזקיף?

עם מהדורת Gitlab Enterprise, אתה יכול להשתמש בחבילת Omnibus כדי להגדיר מכונות מרובות עם הדמון Sentinel.

Redis sentinel ו- fix-slevave-config בעיה: Redis Node מתגדיר כעבד של שני אדונים כשלא אמור להיות.

אני משתמש ב- Redis Sentinel בגלל כישלון בצי Redis גדול המורכב מ 12 זקיפים ומעל 500 שרדטים, כל אחד עם אדון אחד ועבד אחד. עם זאת, נתקלתי בנושא מוזר בו מוציאים שוב ושוב צמתים של Redis Redis. זה הביא לכמה עבדים שעברו בין המאסטר הנכון למאסטר שגוי נוסף. לא שמתי לב לבעיה זו בקנה מידה קטן יותר. אני מחפש עצות כיצד לתקן או לנקוט באגים בבעיה זו.

צפיתי בשני סוגיות ספציפיות:

א) ההודעות +תיקון-סליבה-קונפיג שהזכרתי קודם לכן.

ב) הסנטינל.קובץ CONF מראה שלעבדים מסוימים יש שני אדונים, למרות שהם צריכים להיות רק אחד כזה.

בתחילה, לצי צומת עבדים מסוים xxx.Xxx.Xxx.177 עם המאסטר xxx.Xxx.Xxx.244 (גיבוש שרד 188). עם זאת, ללא הפסקות צומת, אדון העבד הזה מועבר ל- XXX.Xxx.Xxx.96 (שהוא המאסטר לשארד 188) ואז חזרה לאדון הנכון, ומחזור זה חוזר. אימתתי זאת על ידי גישה לצמתים של העבדים והמאסטר ושימוש בפקודת המידע Redis-CLI. כל צמתי Redis מתחילים בתצורה הנכונה, ולכל צמתים של Sentinel יש את התצורה הנכונה בסנטינל שלהם.קבצי CONF. כשאני שואלת כל זקיף, לכולם יש את אותה רשימת אדונים בדיוק לאחר כל שינוי עבד למאסטר.

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

Sentinel #8: 20096: x 22 באוקטובר 01:41:49.793 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ שרד -188 xxx.Xxx.Xxx.96 6379
סנטינל מספר 1: 9832: x 22 באוקטובר 01:42:50.795 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ Shard-172 xxx.Xxx.Xxx.244 6379
סנטינל מס ‘6: 20528: x 22 באוקטובר 01:43:52.458 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ שרד -188 xxx.Xxx.Xxx.96 6379
Sentinel #10: 20650: x 22 באוקטובר 01:43:52.464 * +תקן-עבד-קונפיג עבד xxx.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ שרד -188 xxx.Xxx.Xxx.96 6379
סנטינל מס ‘2: 20838: x 22 באוקטובר 01:44:53.489 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ Shard-172 xxx.Xxx.Xxx.244 6379

כשאני מריץ את פיקוד המאסטרס של סנטינל, שמתי לב למשהו מוזר. במקרה 1, ל- Shard-188 יש שני עבדים במקום אחד. אותה דפוס נצפה כאשר xxx.Xxx.Xxx.177 נופל תחת שרד -172 או שרד -182:

מקרה 1) המאסטר הוא xxx.Xxx.Xxx.244 ו- xxx.Xxx.Xxx.177 הוא אחד העבדים שלו:

183) 1) “שם”
2) “Shard-172”
3) “IP”
4) “xxx.Xxx.Xxx.244 “
5) “נמל”
6) “6379”
7) “runid”
8) “CA02DA1F0002A25A880E6765AED306B1857AE2F7”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “14”
17) “פליפ-רפלי אחרון”
18) “14”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “5636”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17154406”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “1”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”
72) 1) “שם”
2) “Shard-188”
3) “IP”
4) “xxx.Xxx.Xxx.96 “
5) “נמל”
6) “6379”
7) “runid”
8) “95CD3A457EF71FC91F1A1C5A6D5D4496B266167”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “927”
17) “פליפ-רפלי אחרון”
18) “927”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “5333”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17154312”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “2”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”

מקרה 2) המאסטר הוא xxx.Xxx.Xxx.96 ו- xxx.Xxx.Xxx.177 הוא אחד העבדים שלו:

79) 1) “שם”
2) “Shard-172”
3) “IP”
4) “xxx.Xxx.Xxx.244 “
5) “נמל”
6) “6379”
7) “runid”
8) “CA02DA1F0002A25A880E6765AED306B1857AE2F7”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “1012”
17) “פליפ-רפלי אחרון”
18) “1012”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “1261”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17059720”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “1”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”
273) 1) “שם”
2) “Shard-188”
3) “IP”
4) “xxx.Xxx.Xxx.96 “
5) “נמל”
6) “6379”
7) “runid”
8) “95CD3A457EF71FC91F1A1C5A6D5D4496B266167”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “886”
17) “פליפ-רפלי אחרון”
18) “886”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “5333”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17154312”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “2”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”

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

האם אשכול Redis זקוק לזקיף

עם מהדורת Gitlab Enterprise, אתה יכול להשתמש בחבילת Omnibus כדי להגדיר מכונות מרובות עם הדמון Sentinel.

Redis sentinel ו- fix-slevave-config בעיה: Redis Node מתגדיר כעבד של שני אדונים כשלא אמור להיות.

Возожно, alle orкрדיר.

אני מנסה להשתמש ב- Sentinel עבור Failover בצי Redis גדול (12 Sentinels, 500+ Shard של אדון אחד ועבד אחד כל אחד). אני נתקל בנושא מוזר מאוד בו הזקיפים שלי מנצלים שוב ושוב את הפקודה +תיקון-עבדה-קונפיג לצמתים מסוימים של Redis, והתוצאה הייתה עבדים מסוימים שעוברים בין המאסטר הנכון לאדון שגוי נוסף. לא שמתי לב שזה קורה בקנה מידה קטן יותר, על מה שזה שווה. כל עצה לגבי מה לתקן או לנקוט באגים?

שמתי לב לשני סוגיות ספציפיות:

א) +הודעות תקן-סליבה-קונפיג, כאמור לעיל.

ב) הסנטינל.CONP מראה לעבדים מסוימים שיש שני אדונים (הם צריכים להיות רק כאלה)

הצי במצב המתחיל יש צומת עבדים מסוים xxx.Xxx.Xxx.177 עם אדון xxx.Xxx.Xxx.244 (יחד, הם כוללים את שרד 188 בצי). ללא הפסקות צומת, אדון העבד מועבר ל- XXX.Xxx.Xxx.96 (אדון לשארד 188) ואז חזרה ואז קדימה. זה מאומת על ידי SSing אל תוך הצמתים העבדים והמאסטר ובדיקת מידע Redis-CLI. כל צמתי Redis התחילו בתצורה הנכונה. לכל צמתים של Sentinel הייתה התצורה הנכונה בסנטינל שלהם.Conf. לכל זקיף יש את אותה רשימת אדונים בדיוק כשאני שואלת אותם לאחר כל אחד מהשינויים האלה-> שינויים מאסטר.

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

Sentinel #8: 20096: x 22 באוקטובר 01:41:49.793 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ שרד -188 xxx.Xxx.Xxx.96 6379
סנטינל מספר 1: 9832: x 22 באוקטובר 01:42:50.795 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ Shard-172 xxx.Xxx.Xxx.244 6379
סנטינל מס ‘6: 20528: x 22 באוקטובר 01:43:52.458 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ שרד -188 xxx.Xxx.Xxx.96 6379
Sentinel #10: 20650: x 22 באוקטובר 01:43:52.464 * +תקן-עבד-קונפיג עבד xxx.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ שרד -188 xxx.Xxx.Xxx.96 6379
סנטינל מס ‘2: 20838: x 22 באוקטובר 01:44:53.489 * +FIX-SLAVE-CONFIG עבד XXX.Xxx.Xxx.177: 6379 xxx.Xxx.Xxx.177 6379 @ Shard-172 xxx.Xxx.Xxx.244 6379

להלן הפלט של פקודת המאסטר של Sentinel. הדבר המוזר הוא שלשארד -188 יש שני עבדים, כאשר למעשה זה צריך להיות רק 1. הפלט נראה זהה כאשר xxx.Xxx.Xxx.177 נמצא תחת שרד -172 ושארד -182.

מקרה 1) xxx.Xxx.Xxx.244 הוא אדון XXX.Xxx.Xxx.177

183) 1) “שם”
2) “Shard-172”
3) “IP”
4) “xxx.Xxx.Xxx.244 ”
5) “נמל”
6) “6379”
7) “runid”
8) “CA02DA1F0002A25A880E6765AED306B1857AE2F7”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “14”
17) “פליפ-רפלי אחרון”
18) “14”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “5636”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17154406”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “1”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”
72) 1) “שם”
2) “Shard-188”
3) “IP”
4) “xxx.Xxx.Xxx.96 ”
5) “נמל”
6) “6379”
7) “runid”
8) “95CD3A457EF71FC91F1A1C5A6D5D4496B266167”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “927”
17) “פליפ-רפלי אחרון”
18) “927”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “5333”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17154312”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “2”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”

מקרה 2) xxx.Xxx.Xxx.96 הוא אדון XXX.Xxx.Xxx.177

79) 1) “שם”
2) “Shard-172”
3) “IP”
4) “xxx.Xxx.Xxx.244 ”
5) “נמל”
6) “6379”
7) “runid”
8) “CA02DA1F0002A25A880E6765AED306B1857AE2F7”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “1012”
17) “פליפ-רפלי אחרון”
18) “1012”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “1261”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17059720”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “1”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”
273) 1) “שם”
2) “Shard-188”
3) “IP”
4) “xxx.Xxx.Xxx.96 ”
5) “נמל”
6) “6379”
7) “runid”
8) “95CD3A457EF71FC91F1A1C5A6D5D4496B266167”
9) “דגלים”
10) “אדון”
11) “פקודות ממתינות”
12) “0”
13) “ציפוי אחרון”
14) “0”
15) “אחרון-אוק-פינג-רפלי”
16) “886”
17) “פליפ-רפלי אחרון”
18) “886”
19) “למטה-מילי-שניות”
20) “30000”
21) “Effrefresh”
22) “5762”
23) “דיווח על תפקידים”
24) “אדון”
25) “זמן דיווח על תפקידים”
26) “17059758”
27) “config-epoch”
28) “0”
29) “num-sleaves”
30) “2”
31) “מספר אחר-סטינלים”
32) “12”
33) “קוורום”
34) “7”
35) “Failover-Timeout”
36) “60000”
37) “סנכרון מקביל”
38) “1”

הזקיף המתחיל שלי.conf עבור כל זקיף הוא

MaxClients 20000
הודעה על Loglevel
logfile “/home/redis/logs/sentinel.עֵץ”
צג Sentinel Shard-172 Redis-B-172 7
Sentinel Down-After-Milliseconds Shard-172 30000
Sentinel Failover-Timeout Shard-172 60000
Sentinel מקביל סנכרון shard-172 1
.
צג Sentinel Shard-188 Redis-B-188 7
Sentinel Down-After-Milliseconds Shard-188 30000
Sentinel Failover-Timeout Shard-188 60000
Sentinel מקביל סנכרון shard-188 1

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

צג Sentinel Shard-172 xxx.Xxx.Xxx.244 6379 7
Sentinel Failover-Timeout Shard-172 60000
Sentinel config-epoch shard-172 0
Sentinel Leader-Epoch Shard-172 0
Sentinel ידוע Shard-172 xxx.Xxx.Xxx.177 6379 Sentinel ידוע-סנטינל שרד -172 .
.
צג Sentinel Shard-188 xxx.Xxx.Xxx.96 6379 7
Sentinel Failover-Timeout Shard-188 60000
Sentinel config-epoch shard-188 0
Sentinel Leader-Epoch Shard-188 0
Sentinel ידוע Shard-188 xxx.Xxx.Xxx.194 6379 Sentinel ידוע Shard-188 XXX.Xxx.Xxx.177 6379
Sentinel ידוע-סנטינל שרד -188 .

Redis Replication ו- Failover עם אומניבוס Gitlab (עצמי פרימיום)

הערה: זהו התיעוד לחבילות Gitlab Omnibus. לשימוש ב redis לא מסומן משלך, עקוב אחר התיעוד הרלוונטי.

הערה: ב- Redis Lingo, הראשי נקרא Master. במסמך זה משתמשים ראשוני במקום מאסטר, למעט ההגדרות בהן נדרש אדון.

השימוש ב- Redis בסביבה מדרגית אפשרי באמצעות א יְסוֹדִי איקס הֶעתֵק מְדוּיָק טופולוגיה עם שירות Redis Sentinel לצפייה ולהתחיל אוטומטית בהליך Failover.

Redis דורש אימות אם משתמשים בהם ב- Sentinel. עיין בתיעוד אבטחת Redis למידע נוסף. אנו ממליצים להשתמש בשילוב של סיסמת redis וכללי חומת אש הדוקים כדי להבטיח את שירות Redis שלך. אתה מעודד מאוד לקרוא את התיעוד של Redis Sentinel לפני שתגדיר את התצורה של Redis עם Gitlab כדי להבין היטב את הטופולוגיה והארכיטקטורה.

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

אתה צריך לפחות 3 מכונות עצמאיות: פיזיות, או VMs הנמצאות במכונות פיזיות מובחנות. חיוני שכל מופעי ה- Redis הראשוניים וההעתק יפעלו במכונות שונות. אם אינך מצליח לספק את המכונות בדרך ספציפית, כל בעיה בסביבה המשותפת יכולה להוריד את כל ההתקנה שלך.

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

אתה צריך גם לקחת בחשבון את טופולוגיית הרשת הבסיסית, ולוודא שיש לך קישוריות מיותרת בין מקרים של Redis / Sentinel ו- Gitlab, אחרת הרשתות הופכות לנקודת כישלון יחידה.

הפעלת Redis בסביבה בקנה מידה דורשת כמה דברים:

• מקרים מרובים Redis
• הפעל redis ב- a יְסוֹדִי איקס הֶעתֵק מְדוּיָק טופולוגיה
• מקרים מרובים של זקיפות
• תמיכה ונראות ליישומים לכל מקרי הזקיף וה- Redis

Redis Sentinel יכול להתמודד עם המשימות החשובות ביותר בסביבת HA וזה כדי לעזור לשמור על שרתים ברשת עם מינימום ללא השבתה. Redis Sentinel:

• צגים יְסוֹדִי וכן העתקים מקרים כדי לראות אם הם זמינים
• מקדם א הֶעתֵק מְדוּיָק ל יְסוֹדִי כאשר יְסוֹדִי נכשל
• הדמות א יְסוֹדִי ל הֶעתֵק מְדוּיָק כאשר הכושלים יְסוֹדִי חוזר באופן מקוון (למניעת חלוקת נתונים)
• ניתן לשאול על ידי היישום כדי להתחבר תמיד לזרם יְסוֹדִי שרת

כש יְסוֹדִי לא מצליח להגיב, באחריות הבקשה (במקרה שלנו Gitlab) לטפל בפסק זמן ולתחבר מחדש (שאילתת א זָקִיף לחדש יְסוֹדִי).

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

הגדרה מומלצת

לקבלת הגדרה מינימלית, עליך להתקין את חבילת gitlab של Omnibus ב- 3 עצמאי מכונות, שניהם עם Redis וכן זָקִיף:

• Redis ראשוני + Sentinel
• Redis Replica + Sentinel
• Redis Replica + Sentinel

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

לקבלת התקנה מומלצת שיכולה לעמוד בפני תקלות רבות יותר, עליך להתקין את חבילת GitLab של Omnibus ב- 5 עצמאי מכונות, שניהם עם Redis וכן זָקִיף:

• Redis ראשוני + Sentinel
• Redis Replica + Sentinel
• Redis Replica + Sentinel
• Redis Replica + Sentinel
• Redis Replica + Sentinel

סקירה כללית של הגדרת Redis

אתה חייב להיות לפחות 3 שרתי redis: 1 ראשוני, 2 העתקים, והם צריכים להיות כל אחד במכונות עצמאיות (ראה הסבר לעיל).

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

כדוגמה, אם יש לך 6 צמתים Redis, מקסימום 3 יכול להיות בו זמנית למטה.

ישנן דרישות שונות לצמתים של Sentinel. אם אתה מארח אותם באותן מכונות redis, ייתכן שתצטרך לקחת בחשבון את ההגבלות האלה בעת חישוב כמות הצמתים שיש למתן. עיין בסקירה כללית של Sentinel Sevey Doction למידע נוסף.

יש להגדיר את כל צמתי Redis באותה צורה ועם מפרט שרת דומים, כמו במצב כישלון, כל הֶעתֵק מְדוּיָק ניתן לקדם כ- New יְסוֹדִי על ידי שרתי הזקיף.

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

סקירה כללית של הגדרת Sentinel

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

בכל פעם מִניָן נפגש, רוֹב מכל צמתים הידועים של Sentinel צריכים להיות זמינים וניתן להגיע אליו, כך שיוכלו לבחור את הזקיף מַנהִיג שלוקח את כל ההחלטות להחזרת זמינות השירות על ידי:

• קידום חדש יְסוֹדִי
• הגדרת מחדש של האחר העתקים ולגרום להם להצביע על החדש יְסוֹדִי
• להכריז על החדש יְסוֹדִי לכל עמית זקיף אחר
• להגדיר מחדש את הישן יְסוֹדִי ולהריום ל הֶעתֵק מְדוּיָק כשזה חוזר לרשת

אתה חייב להיות לפחות 3 שרתי Redis Sentinel, והם צריכים להיות כל אחד במכונה עצמאית (שלפי ההערכה נכשלים באופן עצמאי), באופן אידיאלי באזורים גיאוגרפיים שונים.

אתה יכול להגדיר אותם באותן מכונות בהן הגדרת את שרתי ה- Redis האחרים, אך הבינו שאם צומת שלם יורד, אתה מאבד גם את הזקיף וגם מופע Redis Redis.

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

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

הנה כמה דוגמאות:

• עם 5 או 6 זקיפים, מקסימום 2 יכול לרדת להתחלה של כישלון.
• עם 7 זקיפים, מקסימום 3 צמתים יכולים לרדת.

ה מַנהִיג בחירות יכולות לפעמים להיכשל בסיבוב ההצבעה כאשר קוֹנסֶנזוּס אינו מושג (ראה המספר המוזר של דרישת הצמתים לעיל). במקרה כזה, ניסיון חדש מתבצע לאחר משך הזמן שהוגדר בסנטינל [‘failover_timeout’] (באלפיות השנייה).

הערה: אנו יכולים לראות היכן מוגדר Sentinel [‘failover_timeout’].

למשתנה failover_timeout יש הרבה מקרי שימוש שונים. על פי התיעוד הרשמי:

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

קביעת תצורה של Redis

זהו החלק בו אנו מתקינים ומגדיר את המקרים החדשים של Redis.

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

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

דרישות

הדרישות להגדרת Redis הן הבאות:

1. אספקת מספר המקרים המינימלי הנדרש כמפורט בסעיף ההתקנה המומלץ.
2. אָנוּ אל ממליץ להתקין את Redis או Redis Sentinel באותן מכונות יישום GitLab שלך פועל מכיוון שזה מחליש את תצורת ה- HA שלך. עם זאת אתה יכול להצטרף להתקנת Redis ו- Sentinel באותה מכונה.
3. כל צמתי Redis חייבים להיות מסוגלים לדבר זה עם זה ולקבל חיבורים נכנסים על פני יציאות Redis (6379) ויציאות Sentinel (26379) (אלא אם כן תשנה את ברירת המחדל).
4. השרת שמארח את יישום GitLab חייב להיות מסוגל לגשת לצמתים Redis Redis.
5. הגן על הצמתים מפני גישה מרשתות חיצוניות (אינטרנט), באמצעות חומת אש.

מעבר מהתקנה קיימת של מכונה יחידה

אם כבר יש לך התקנת Gitlab יחיד במכונה, עליך לשכפל תחילה ממכונה זו, לפני שתפעל את מופע ה- Redis בתוכו.

ההתקנה היחידה שלך במכונה היא הראשונית יְסוֹדִי, ויש להגדיר את 3 האחרים כ- הֶעתֵק מְדוּיָק מצביע על המכונה הזו.

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

בצע את השינויים הנדרשים בתצורה והפעיל מחדש את הצמתים החדשים שוב.

כדי להשבית את Redis בהתקנה היחידה, עריכה/וכו ‘/גיטלב/גיטלב.RB:

redis['לְאַפשֵׁר'] = שֶׁקֶר

אם אינך מצליח לשכפל תחילה, אתה עלול לאבד נתונים (עבודות רקע לא מעובדות).

שלב 1. קביעת תצורה של מופע Redis הראשי

1. Ssh לתוך יְסוֹדִי שרת Redis.
2. הורד/התקן את חבילת Gitlab של Omnibus שלבים 1 ו -2 מדף ההורדות של GitLab.
   • וודא שאתה בוחר את חבילת Omnibus הנכונה, עם אותה גרסה וסוג (קהילה, מהדורות ארגוניות) של ההתקנה הנוכחית שלך.
   • אל תסיים שלבים אחרים בדף ההורדה.
3. עריכה/וכו ‘/גיטלב/גיטלב.RB והוסף את התוכן:

# ציין את תפקיד השרת כ'- Redis_Master_Role ' תפקידים ['redis_master_role'] # כתובת IP מצביעה על IP מקומי שאר המכונות יכולות להגיע אליו. # אתה יכול גם להגדיר את ה- BIND ל- '0.0.0.0 'שמאזינים בכל הממשקים. # אם אתה באמת צריך להיקשר ל- IP חיצוני נגיש, עשה # בטוח שתוסיף כללי חומת אש נוספים למניעת גישה לא מורשית. redis['לִקְשׁוֹר'] = '10.0.0.1 ' # הגדר יציאה כך ש- Redis תוכל להאזין לבקשות TCP המאפשרות אחרות # מכונות להתחבר אליו. redis['נמל'] = 6379 # הגדר אימות סיסמא עבור Redis (השתמש באותה סיסמה בכל הצמתים). redis['סיסמה'] = 'Redis-Password-Goes-Here'

Gitlab_rails['auto_migrate'] = שֶׁקֶר

הערה: אתה יכול לציין תפקידים מרובים כמו Sentinel ו- Redis כ: תפקידים [‘redis_sentinel_role’, ‘redis_master_role’] . קרא עוד על תפקידים.

שלב 2. קביעת תצורה של מופעי העתק Redis

1. Ssh לתוך הֶעתֵק מְדוּיָק שרת Redis.
2. הורד/התקן את חבילת Gitlab של Omnibus שלבים 1 ו -2 מדף ההורדות של GitLab.
   • וודא שאתה בוחר את חבילת Omnibus הנכונה, עם אותה גרסה וסוג (קהילה, מהדורות ארגוניות) של ההתקנה הנוכחית שלך.
   • אל תסיים שלבים אחרים בדף ההורדה.
3. עריכה/וכו ‘/גיטלב/גיטלב.RB והוסף את התוכן:

# ציין את תפקיד השרת כ'- Redis_Replica_Role ' תפקידים ['Redis_Replica_Role'] # כתובת IP מצביעה על IP מקומי שאר המכונות יכולות להגיע אליו. # אתה יכול גם להגדיר את ה- BIND ל- '0.0.0.0 'שמאזינים בכל הממשקים. # אם אתה באמת צריך להיקשר ל- IP חיצוני נגיש, עשה # בטוח שתוסיף כללי חומת אש נוספים למניעת גישה לא מורשית. redis['לִקְשׁוֹר'] = '10.0.0.2 ' # הגדר יציאה כך ש- Redis תוכל להאזין לבקשות TCP המאפשרות אחרות # מכונות להתחבר אליו. redis['נמל'] = 6379 # אותה סיסמה לאימות Redis שהגדרת עבור הצומת הראשי. redis['סיסמה'] = 'Redis-Password-Goes-Here' # ה- IP של צומת redis הראשי. redis['master_ip'] = '10.0.0.1 ' # יציאה של שרת Redis ראשי, ביטול סימון לשינוי ללא ברירת מחדל. ברירת מחדל # עד `6379 '. #REDIS ['MASTER_PORT'] = 6379

סודו מגע /etc/gitlab/skip-auto-reconfigure

הערה: אתה יכול לציין תפקידים מרובים כמו Sentinel ו- Redis כ: תפקידים [‘redis_sentinel_role’, ‘redis_master_role’] . קרא עוד על תפקידים.

לא צריך לשנות את הערכים הללו שוב ב-/etc/gitlab/gitlab.RB לאחר כישלון, מכיוון שהצמתים מנוהלים על ידי הזקיפים, ואפילו לאחר תצורה מחדש של GitLab-CTL, הם מקבלים את התצורה שלהם על ידי אותם זקיפים.

שלב 3. קביעת תצורה של מופעי ה- Redis Sentinel

הערה: אם אתה משתמש במופע חיצוני של redis sentinel, הקפד לשלול את פרמטר ה- DieficePass מתצורת Sentinel. פרמטר זה גורם ללקוחות לדווח על אימות NOAUTH נדרש. . Redis Sentinel 3.2.x אינו תומך באימות סיסמא.

כעת, כאשר שרתי Redis מוגדרים כולם, בואו נקבע את התצורה של שרתי Sentinel.

אם אינך בטוח אם שרתי ה- Redis שלך עובדים ומשכפלים נכון, אנא קרא את שכפול פתרון הבעיות ותקן אותו לפני שתמשיך בהגדרת Sentinel.

אתה חייב להיות לפחות 3 שרתי Redis Sentinel, והם צריכים להיות כל אחד במכונה עצמאית. באפשרותך להגדיר אותם באותן מכונות בהן הגדרת את שרתי ה- Redis האחרים.

עם מהדורת Gitlab Enterprise, אתה יכול להשתמש בחבילת Omnibus כדי להגדיר מכונות מרובות עם הדמון Sentinel.

1. SSH לשרת שמארח את Redis Sentinel.
2. אתה יכול להשמיט שלב זה אם הזקיפים מתארחים באותו צומת כמו מקרים אחרים של Redis.הורד/התקן את חבילת המהדורה הארגונית של Omnibus Gitlab שלבים 1 ו -2 מדף ההורדות של GitLab.
   • וודא שאתה בוחר את חבילת Omnibus הנכונה, עם אותה גרסה יישום GitLab פועל.
   • אל תסיים שלבים אחרים בדף ההורדה.
3. עריכה/וכו ‘/גיטלב/גיטלב.RB והוסף את התוכן (אם אתה מתקין את הזקיפים באותו צומת כמו שאר המקרים Redis, ערכים מסוימים עשויים להיות כפולים להלן):

תפקידים ['redis_sentinel_role'] # חייב להיות זהה בכל צומת Sentinel redis['master_name'] = 'gitlab-redis' # אותה סיסמה לאימות Redis שהגדרת עבור הצומת הראשי. redis['master_password'] = 'Redis-Password-Goes-Here' # ה- IP של צומת redis הראשי. redis['master_ip'] = '10.0.0.1 ' # הגדר יציאה כך ש- Redis תוכל להאזין לבקשות TCP המאפשרות אחרות # מכונות להתחבר אליו. redis['נמל'] = 6379 # יציאה של שרת Redis ראשי, ביטול סימון לשינוי ללא ברירת מחדל. ברירת מחדל # עד `6379 '. #REDIS ['MASTER_PORT'] = 6379 ## הגדר את Sentinel זָקִיף['לִקְשׁוֹר'] = '10.0.0.1 ' # יציאה ש- Sentinel מקשיבה על, ביטול קיום כדי להשתנות ללא ברירת מחדל. ברירת מחדל # עד `26379`. # sentinel ['יציאה'] = 26379 ## Quorum חייב לשקף את כמות הזקיף ההצבעה שנדרש כדי להתחיל בכישלון. ## ערך אסור להיות גדול יותר מכמות הזקיפים. ## ## ניתן להשתמש במניין המניין כדי לכוונן את הזקיף בשתי דרכים: ## 1. אם המניין מוגדר לערך קטן יותר מרוב הזקיפים ## אנו פורסים, אנו בעצם הופכים את הסנטינל ליותר הגיוני לכישלונות ראשוניים, ## הפעלת כישלון ברגע שאפילו סתם מיעוט של זקיפים כבר לא ## מסוגל לדבר עם הראשי. ## 1. אם מניין מוגדר לערך גדול יותר מרוב הזקיפים, אנו ## מה שהופך את Sentinel מסוגל להיכשל רק כשיש מספר גדול מאוד (גדול יותר ## מרוב) של זקיפים מחוברים היטב המסכימים על כך שהראשוני יורד.ג זָקִיף['מִניָן'] = 2 ## שקול שרת לא מגיב למטה לאחר כמות x של טרשת נפוצה. # sentinel ['down_after_milliseconds'] = 10000 ## מציין את פסק הזמן של Failover באלפיות השנייה. הוא משמש במובנים רבים: ## ## - הזמן הדרוש להפעלת כישלון מחדש לאחר כישלון קודם היה ## שכבר ניסה נגד אותו ראשוני על ידי זקיף נתון, הוא שניים ## פעמים בפסק הזמן של Failover. ## ## - הזמן הדרוש להעתק המשכפל לראשות לא נכונה ## לתצורת זרם זקיף, כדי להיאלץ לשכפל ## עם הראשי הנכון, הוא בדיוק פסק הזמן של Failover (ספירה מאז ## ברגע שזקיף זיהה את התצורה השגויה). ## ## - הזמן הדרוש לביטול כישלון שכבר נמצא בעיצומו אך ## לא ייצר שום שינוי תצורה (העתק אף אחד עדיין לא ## הודה על ידי העתק המקודם). ## ## - הזמן המרבי שכישלון מתבצע מחכה שכל ההעתק יהיה ## הוגדר מחדש כעפילים של הראשי החדש. עם זאת, גם אחרי הזמן הזה ## בכל מקרה מוגדרים העתקים מחדש על ידי הזקיפים, אך לא עם ## התקדמות הסנכרון המקביל המדויק כמפורט. # sentinel ['failover_timeout'] = 60000

סודו מגע /etc/gitlab/skip-auto-reconfigure

שלב 4. קביעת תצורה של יישום GitLab

החלק הסופי הוא ליידע את שרת היישומים הראשי של GitLab של שרתי Redis Sentinels ותעודות אימות.

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

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

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

1. SSH לשרת בו מותקנת יישום GITLAB.
2. עריכה/וכו ‘/גיטלב/גיטלב.RB והוסף/שנה את השורות הבאות:

## חייב להיות זהה בכל צומת Sentinel redis['master_name'] = 'gitlab-redis' ## אותה סיסמה לאימות Redis שהגדרת עבור הצומת הראשי. redis['master_password'] = 'Redis-Password-Goes-Here' ## רשימת זקיפים עם 'מארח' ו'פורט ' Gitlab_rails['redis_sentinels'] = [ 'מנחה' => '10.0.0.1 ', 'נמל' => 26379>, 'מנחה' => '10.0.0.2 ', 'נמל' => 26379>, 'מנחה' => '10.0.0.3 ', 'נמל' => 26379> ]

שלב 5. אפשר ניטור

אם אתה מאפשר ניטור, יש להפעיל אותו את כל שרתי Redis.

1. הקפד לאסוף consul_server_nodes, שהם כתובות ה- IP או רשומות ה- DNS של צמתי שרת הקונסול, לשלב הבא. שימו לב שהם מוצגים כ- y.Y.Y.Y consul1.גיטלב.דוגמא.com z.Z.Z.Z
2. צור/ערוך/etc/gitlab/gitlab.RB והוסף את התצורה הבאה:

# אפשר גילוי שירות עבור פרומתאוס קוֹנסוּל['לְאַפשֵׁר'] = נָכוֹן קוֹנסוּל['ניטור_שירות_דיסקו'] = נָכוֹן # החלף את מצייני המקום # Y.Y.Y.Y consul1.גיטלב.דוגמא.com z.Z.Z.Z # עם הכתובות של צמתי שרת הקונסול קוֹנסוּל['תְצוּרָה'] =  Retry_join: %w (y.Y.Y.Y consul1.גיטלב.דוגמא.com z.Z.Z.Z), > # הגדר את כתובות הרשת שהיצואנים מאזינים עליהן node_exporter['האזן_דברס'] = '0.0.0.0: 9100 ' redis_exporter['האזן_דברס'] = '0.0.0.0: 9121 '

דוגמה לתצורה מינימלית עם 1 ראשוני, 2 העתקים ו -3 זקיפים

בדוגמה זו אנו רואים שלכל השרתים יש ממשק רשת פנימי עם IPS ב- 10.0.0.x טווח, ושהם יכולים להתחבר זה לזה באמצעות IPs אלה.

בשימוש בעולם האמיתי, הייתם מקים כללי חומת אש כדי למנוע גישה לא מורשית ממכונות אחרות ולחסום תנועה מבחוץ (אינטרנט).

אנו משתמשים באותם 3 צמתים עם Redis + זָקִיף טופולוגיה שנדונה בסקירה כללית של הגדרת Redis ו- Sentinel Setup Doction.

להלן רשימה ותיאור של כל אחד מהם מְכוֹנָה והוקצה IP:

• 10.0.0.1: Redis ראשוני + Sentinel 1
• 10.0.0.2: Redis Replica 1 + Sentinel 2
• 10.0.0.3: Redis Replica 2 + Sentinel 3
• 10.0.0.4: יישום Gitlab

לאחר התצורה הראשונית, אם נכשל יוזם על ידי צמתים של Sentinel, צמתים Redis מוגדרים מחדש ו- יְסוֹדִי משתנה לצמיתות (כולל ב- Redis.conf) מצומת אחד למשנהו, עד שיוזם שוב כישלון חדש.

אותו דבר קורה עם סנטינל.conf שמוחלט לאחר הביצוע הראשוני, לאחר שכל צומת זקיף חדש מתחיל לצפות ב יְסוֹדִי, או כישלון מקדם שונה יְסוֹדִי צוֹמֶת.

תצורת דוגמה עבור Redis ראשוני ו- Sentinel 1

תפקידים ['redis_sentinel_role', 'redis_master_role'] redis['לִקְשׁוֹר'] = '10.0.0.1 ' redis['נמל'] = 6379 redis['סיסמה'] = 'Redis-Password-Goes-Here' redis['master_name'] = 'gitlab-redis' # חייב להיות זהה בכל צומת Sentinel redis['master_password'] = 'Redis-Password-Goes-Here' # אותו ערך המוגדר ב- Redis ['סיסמה'] במקרה הראשי redis['master_ip'] = '10.0.0.1 ' # IP של מופע ה- Redis הראשוני הראשוני #REDIS ['MASTER_PORT'] = 6379 # יציאת המופע הראשי הראשוני של Redis, ביטול סימון לשינוי ללא ברירת מחדל זָקִיף['לִקְשׁוֹר'] = '10.0.0.1 ' # sentinel ['יציאה'] = 26379 # ביטול סימון לשינוי יציאת ברירת מחדל זָקִיף['מִניָן'] = 2 # sentinel ['down_after_milliseconds'] = 10000 # sentinel ['failover_timeout'] = 60000

הגדר מחדש את Omnibus Gitlab כדי שהשינויים ייכנסו לתוקף.

תצורת דוגמה עבור Redis Replica 1 ו- Sentinel 2

תפקידים ['redis_sentinel_role', 'Redis_Replica_Role'] redis['לִקְשׁוֹר'] = '10.0.0.2 ' redis['נמל'] = 6379 redis['סיסמה'] = 'Redis-Password-Goes-Here' redis['master_password'] = 'Redis-Password-Goes-Here' redis['master_ip'] = '10.0.0.1 ' # IP של שרת redis ראשי ראשוני #REDIS ['MASTER_PORT'] = 6379 # יציאת שרת redis ראשי ראשוני, ביטול סימון לשינוי ללא ברירת מחדל redis['master_name'] = 'gitlab-redis' # חייב להיות זהה בכל צומת Sentinel זָקִיף['לִקְשׁוֹר'] = '10.0.0.2 ' # sentinel ['יציאה'] = 26379 # ביטול סימון לשינוי יציאת ברירת מחדל זָקִיף['מִניָן'] = 2 # sentinel ['down_after_milliseconds'] = 10000 # sentinel ['failover_timeout'] = 60000

הגדר מחדש את Omnibus Gitlab כדי שהשינויים ייכנסו לתוקף.

תצורת דוגמה עבור Redis Replica 2 ו- Sentinel 3

תפקידים ['redis_sentinel_role', 'Redis_Replica_Role'] redis['לִקְשׁוֹר'] = '10.0.0.3 ' redis['נמל'] = 6379 redis['סיסמה'] = 'Redis-Password-Goes-Here' redis['master_password'] = 'Redis-Password-Goes-Here' redis['master_ip'] = '10.0.0.1 ' # IP של שרת redis ראשי ראשוני #REDIS ['MASTER_PORT'] = 6379 # יציאת שרת redis ראשי ראשוני, ביטול סימון לשינוי ללא ברירת מחדל redis['master_name'] = 'gitlab-redis' # חייב להיות זהה בכל צומת Sentinel זָקִיף['לִקְשׁוֹר'] = '10.0.0.3 ' # sentinel ['יציאה'] = 26379 # ביטול סימון לשינוי יציאת ברירת מחדל זָקִיף['מִניָן'] = 2 # sentinel ['down_after_milliseconds'] = 10000 # sentinel ['failover_timeout'] = 60000

הגדר מחדש את Omnibus Gitlab כדי שהשינויים ייכנסו לתוקף.

תצורת דוגמה ליישום GitLab

redis['master_name'] = 'gitlab-redis' redis['master_password'] = 'Redis-Password-Goes-Here' Gitlab_rails['redis_sentinels'] = [ 'מנחה' => '10.0.0.1 ', 'נמל' => 26379>, 'מנחה' => '10.0.0.2 ', 'נמל' => 26379>, 'מנחה' => '10.0.0.3 ', 'נמל' => 26379> ]

הגדר מחדש את Omnibus Gitlab כדי שהשינויים ייכנסו לתוקף.

תצורה מתקדמת

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

הפעלת אשכולות Redis מרובים

אומניבוס גיטלב תומך בהפעלת מקרים נפרדים של Redis ו- Sentinel עבור שיעורי התמדה שונים.

מעמד	מַטָרָה
מטמון	אחסן נתונים במטמון.
תורים	חנות משרות רקע של Sidekiq.
shared_state	אחסן נתונים הקשורים להפעלה ונתונים מתמשכים אחרים.
ActionCable	Backen.
Trace_Chunks	אחסן נתוני נתוני CI Trace.

לעשות את העבודה הזו עם Sentinel:

1. קבע את התצורה של מופעי Redis/Sentinels השונים על סמך הצרכים שלך.
2. עבור כל מופע של יישום Rails, ערוך את/etc/gitlab/gitlab.קובץ RB:

Gitlab_rails['redis_cache_instance'] = Redis_cache_url Gitlab_rails['redis_queues_instance'] = Redis_queues_url Gitlab_rails['redis_shared_state_instance'] = Redis_shared_state_url Gitlab_rails['redis_actioncable_instance'] = Redis_actioncable_url Gitlab_rails['redis_trace_chunks_instance'] = Redis_trace_chunks_url # הגדר את התצורה של הזקיפים Gitlab_rails['redis_cache_sentinels'] = [  מנחה: Redis_cache_sentinel_host, נמל: 26379 >,  מנחה: Redis_cache_sentinel_host2, נמל: 26379 > ] Gitlab_rails['redis_queues_sentinels'] = [  מנחה: Redis_queues_sentinel_host, נמל: 26379 >,  מנחה: Redis_queues_sentinel_host2, נמל: 26379 > ] Gitlab_rails['redis_shared_state_sentinels'] = [  מנחה: Shared_state_sentinel_host, נמל: 26379 >,  מנחה: Shared_state_sentinel_host2, נמל: 26379 > ] Gitlab_rails['redis_actioncable_sentinels'] = [  מנחה: ActionCable_sentinel_host, נמל: 26379 >,  מנחה: ActionCable_sentinel_host2, נמל: 26379 > ] Gitlab_rails['redis_trace_chunks_sentinels'] = [  מנחה: Trace_chunks_sentinel_host, נמל: 26379 >,  מנחה: Trace_chunks_sentinel_host2, נמל: 26379 > ]

• כתובות כתובות redis צריכות להיות בפורמט: redis: //: סיסמה@sentinel_primary_name, איפה:
  • הסיסמה היא סיסמת הפשטוף עבור מופע Redis.
  • Sentinel_primary_name הוא השם הראשי של Sentinel שנקבע עם redis [‘master_name’], למשל Gitlab-Redis-Cache .

  sudo תצורה מחדש של Gitlab-CTL

  הערה: עבור כל מחלקת התמדה, GitLab ברירת מחדל לשימוש בתצורה שצוינה ב- GitLab_rails [‘redis_sentinels’] אלא אם כן הוחלף על ידי ההגדרות שתוארו בעבר.

  שליטה בשירותי הפעלה

  בדוגמה הקודמת, השתמשנו.

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

  ## תפקיד Redis Sentinel redis_sentinel_role['לְאַפשֵׁר'] = נָכוֹן # כאשר תפקיד Sentinel מופעל, גם השירותים הבאים מופעלים זָקִיף['לְאַפשֵׁר'] = נָכוֹן # השירותים הבאים מושבתים redis['לְאַפשֵׁר'] = שֶׁקֶר Bootstrap['לְאַפשֵׁר'] = שֶׁקֶר Nginx['לְאַפשֵׁר'] = שֶׁקֶר Postgresql['לְאַפשֵׁר'] = שֶׁקֶר Gitlab_rails['לְאַפשֵׁר'] = שֶׁקֶר חדר דואר['לְאַפשֵׁר'] = שֶׁקֶר ------- ## תפקיד ראשוני/העתק redis_master_role['לְאַפשֵׁר'] = נָכוֹן # הפעל רק אחד מהם redis_replica_role['לְאַפשֵׁר'] = נָכוֹן # הפעל רק אחד מהם # כאשר תפקיד ראשוני או העתק מופעל, השירותים הבאים הם # מופעל/מושבת. אם משולבים תפקידי Redis ו- Sentinel, שניהם # השירותים מופעלים. # השירותים הבאים מושבתים זָקִיף['לְאַפשֵׁר'] = שֶׁקֶר Bootstrap['לְאַפשֵׁר'] = שֶׁקֶר Nginx['לְאַפשֵׁר'] = שֶׁקֶר Postgresql['לְאַפשֵׁר'] = שֶׁקֶר Gitlab_rails['לְאַפשֵׁר'] = שֶׁקֶר חדר דואר['לְאַפשֵׁר'] = שֶׁקֶר # לתפקיד Redis Replica, שנה גם הגדרה זו מברירת מחדל 'אמיתית' ל'שקר ': redis['לִשְׁלוֹט'] = שֶׁקֶר

  אתה יכול למצוא את התכונות הרלוונטיות המוגדרות ב- GitLab_rails.RB .

  פתרון תקלות

  לקריאה נוספת

  1. ארכיטקטורות עזר
  2. קבע את התצורה של מסד הנתונים
  3. הגדר NFS
  4. קבע את התצורה של מאזני העומס

  Redis Sentinel

  תשומת הלב. מנגנון ה- Redis Sentinel שהוצא מופרז יפרוש בגרסה 7 של Creatio 7.18.3. אנו ממליצים לעבור לאשכול Redis לאחר עדכון Creatio לגרסה 7.18.0.

  מנגנון Redis Sentinel משמש כדי לספק סובלנות לתקלות למאגרי Redis המשמשים את Creatio. זה מספק את התכונות הבאות:

  • ניטור. סנטינל מוודא שמופעי המאסטר/העבדים יעבדו נכון ב- Redis.
  • התראות. Sentinel התראות מנהלי מערכת אם שגיאות הקשורות למופע מתרחשות ב- Redis.
  • כישלון אוטומטי. אם מופע הראשי של Redis אינו פועל כראוי, Sentinel מקדם את אחד המקרים העבדים למאסטר, ומגדיר מחדש את השאר לעבוד עם מופע המאסטר החדש. Creatio מקבל הודעה גם על כתובת החיבור החדשה של Redis.

  תשומת הלב. Creatio אינו תומך באשכולות Redis בגרסה 7.17.4 ומוקדם יותר.

  Redis Sentinel היא מערכת מבוזרת שנועדה להריץ מספר מקרים המשתפים פעולה יחד. לגישה זו היתרונות הבאים:

  • התקלה נרשמת רק אם מספר מקרים של Sentinel (המהווים קוורום) מסכימים כי מופע הראשי אינו זמין ב- Redis. זה נעשה כדי להפחית את מספר ההתראות השוואיות.
  • מנגנון Sentinel עדיין יהיה זמין גם אם מקרים מרובים של זקיף לא מגיבים או לא עובדים לגמרי. זה נעשה כדי להגביר את סובלנות התקלות.

  פרטי הזקיף הבולטים

  • לפחות שלושה מקרים של Sentinel נדרשים לפריסה חזקה. יש להכניס מקרים אלה למחשבים או במכונות וירטואליות שלפי ההערכה נכשלים בצורה עצמאית, אני. ה., התקלות שנרשמו על ידי מקרים זקיפים אלה צריכים להיגרם על ידי מקורות שונים. לדוגמה, המחשבים ממוקמים באזורי רשת שונים.
  • עקב שכפול אסינכרוני, המערכת המופצת (Sentinel + Redis) אינה מבטיחה כי כל הנתונים יישמרו אם תתרחש כישלון.
  • יש לפקח באופן קבוע על סובלנות התקלות של התצורה ולאשר עוד יותר באמצעות בדיקות המדמות כישלונות.
  • מיפוי נמל של Docker יוצר בעיות מסוימות עם תהליכי Sentinel (ראו Sentinel, Docker, NAT ובעיות אפשריות חסימות של תיעוד Sentinel).

  דרישות סובלנות מינימליות לתקלות עבור Redis Sentinel

  • M1, M2 הם מופעי Master Redis.
  • R1, R2, R3 הם מקרים של עבדים מחדש.
  • S1, S2, S3 הם מקרים של Sentinel.
  • C1 הוא יישום Creatio.
  • [M2] מקודם מופע (ה. ז., מעבד לשלוט).

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

  תאנה. 1 תצורת שלושת הצמתים: Quorum = 2

  

  במהלך פעולה קבועה, יישום לקוח Creatio כותב את הנתונים שלו למופע אב (M1). לאחר מכן משוכפלים נתונים אלה באופן אסינכרוני למופעי העבדים (R2 ו- R3).

  אם מופע הראשי של Redis (M1) הופך להיות אינו זמין, מקרי הזקיף (S1 ו- S2) רואים בכך כישלון ולהתחיל בתהליך Failover. אחד ממופעי העבדים Redis (R2 או R3) מקודם לאדון, ומאפשר ליישום להשתמש בו במקום במופע הראשי הקודם.

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

  הערה. תצורות סובלניות אחרות אפשריות לתקלות מתוארות בתיעוד Sentinel .

  בעיות הפרדת רשת

  אם חיבור הרשת אבוד, קיים סיכון ש- Creatio תמשיך לעבוד עם מופע ה- Redis Master הישן (M1), בעוד שמופע הראשי החדש שקידם (M2]) כבר הוקצה (איור. 2).

  תאנה. 2 הפרדת רשת

  

  זה נמנע בקלות על ידי הפעלת האפשרות להפסיק את כתיבת הנתונים למקרה שמופע הראשי יגלה שמספר מקרי העבדים ירד. לשם כך, קבעו את הערכים הבאים ב- Redis.קובץ תצורת CONF של מופע הראשי של Redis:

  Min-Sleaves- לכתיבה 1 דקה-סלאבים-מקס-ליג 10

  כתוצאה מכך, אם מופע ה- Redis Master (M1) לא יוכל להעביר נתונים למופע עבדים אחד לפחות, הוא יפסיק לקבל נתונים תוך 10 שניות לאחר הניסיון הראשון. לאחר התאוששות המערכת על ידי מקרים של סנטינל המהווים מניין (S2 ו- S3), יוגדר היישום של Creatio (C1) כדי לעבוד עם האב -הפנסת החדש (M2).

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

  דרישות מערכת

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

  מומלץ לפרוס את Redis ו- Sentinel במערכת ההפעלה לינוקס.

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

  האם אשכול Redis זקוק לזקיף?

  Б эой сранице

  Ы зé. С помדיר. Почем эо мого?

  Эа сраница о бображае тех сах, кога воматеשיים си сисלוח рmе рגות р רבות ш רבות р р рוהים р рוהים которые нé. Сраница пересанет ообрוחים. До эого момента д.

  Исочником запросов может сmжж вредоносfte по, подаееые моди базלוח нилm mчnзnзnчnчnчnчnчnчnчnчnчnчnчnчnчnчnчзדי ы з запросов. Еи ы иололalty ощий дדיר. O. Подробнרבה.

  Проверка по сов может тelte пояяе, еи ы водите сדיר еами, или же водите запроы ченн часо.