Rego 102: שילוב שאילתות עם AND/OR והודעות מותאמות אישית
אמ;לק
המדריך מסביר כיצד להשתמש בכללים מורכבים של AND ו-OR ב-Rego. הוא כולל גם יצירת הודעות מותאמות אישית באמצעות OPA ו-Rego, ומספק כלים לניהול מדיניות יעיל יותר.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: Rego 102: Combining queries with AND/OR and custom messages

התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
סדרת פוסטים זו בבלוג מציעה היכרות עדינה עם Rego, שפת המדיניות של יוצרי המנוע Open Policy Agent (OPA). אם אתה מתחיל ורוצה להתחיל בכתיבת מדיניות Rego כקוד, אתה במקום הנכון.
בסדרה זו בת שלושה חלקים, נעבור על הדברים הבאים:
• חלק 1: Rego למתחילים: מבוא ל-Rego
• חלק 2 (חלק זה!): תחביר Rego למתקדמים
כזכור, Rego היא שפת שאילתות הצהרתית מבית היוצרים של מסגרת העבודה Open Policy Agent (OPA). ה-Cloud Native Computing Foundation (CNCF) קיבל את OPA כפרויקט בחסות ה-Incubation שלהם באפריל 2019, ו-OPA סיים את מעמד הדגירה (Incubating) ב-2021.
Rego משמשת לכתיבת "מדיניות כקוד" (Policy as Code), המיישמת שיטות עבודה מתחום התכנות, כמו בקרת גרסאות ועיצוב מודולרי, כדי להעריך משאבי ענן ותשתית כקוד (IaC). OPA הוא המנוע שמעריך מדיניות כקוד הכתובה ב-Rego. כמו כן, Snyk משתמשת בשפת Rego עבור חוקים מותאמים אישית.
סיכום חלק 1
בחלק 1 של סדרת פוסטים זו, הסברנו שחוק (Rule) ב-Rego הוא הקצאה מותנית. החוק מתשאל את הקלט כדי למצוא התאמה לתנאי מסוים, ואם נמצאת התאמה, מוקצה ערך למשתנה.
1 THIS VARIABLE : = HAS THIS VALUE { 2 IF THESE CONDITIONS ARE MET 3 }
הנה הדוגמה שבה השתמשנו, המייצגת מדיניות ארגונית שרק Alice, מנהל רשת, צריך להיות בעל הרשאה ליצור ולמחוק רשתות וירטואליות בחשבון ה-prod:
1 allow : = true { 2 input . user == "alice" 3 }
OPA מעריך מסמך קלט JSON או YAML כנגד כלל כדי להפיק פסק דין מדיניות. מסמך הקלט שלהלן מייצג את המשתמש המחובר כעת:
1 { 2 "user" : "alice" 3 }
אם תשתמש ב-OPA כדי להעריך את הקלט מול חוק זה, הוא ימצא התאמה לשאילתה input.user == "alice". לכן, למשתנה בראש החוק, allow, מוקצה הערך true. להלן הפלט המוכיח זאת:
1 { 2 "allow" : true 3 }
OPA סיפק החלטה ש-Alice, המשתמשת המחוברת כעת, מורשית ליצור ולמחוק רשתות וירטואליות בחשבון ה-prod. הקלט תואם לחוק.
AND ו-OR
עד כה הצגנו חוקים עם שאילתה אחת בלבד. חוק יכול להכיל גם מספר שאילתות. במקרה כזה, השאילתות מייצגות מספר תנאים שכולם חייבים להתקיים כדי שיוקצה ערך למשתנה. ישנו AND מרומז - "תנאי זה חייב להתקיים AND תנאי זה חייב להתקיים."
לדוגמה, בחוק להלן, גם input.user == "alice" וגם input.environment == "prod" חייבים להיות true כדי שהמשתנה allow יקבל את הערך true:
1 allow : = true { 2 input . user == "alice" 3 input . environment == "prod" 4 }
במקרים מסוימים, שימוש ב-OR עשוי להיות מתאים יותר. ניתן לייצג OR על ידי שימוש באותו ראש חוק (Rule Head) במספר חוקים שונים:
1 allow = true { 2 input . user == "alice" 3 } 4 5 allow = true { 6 input . user == "bob" 7 }
הערך של allow יהיה true אם המשתמש הוא "alice" או אם המשתמש הוא "bob".
מבחינה טכנית, קבוצת החוקים מהווה חוק יחיד מכיוון שהראש זהה עבור כולם. מכיוון שאתה מגדיר את החוק הזה במספר שלבים, הוא נקרא חוק מצטבר (Incremental rule).
אם תרצה, תוכל לוותר על הראש השני ולחבר את גופי החוקים יחד. דרך תמציתית יותר לכתיבת האמור לעיל היא:
1 allow = true { 2 input . user == "alice" 3 } { 4 input . user == "bob" 5 }
אולי אתה תוהה מדוע השתמשנו באופרטור האיחוד = ולא באופרטור ההקצאה :=. הסיבה לכך היא שמשתנים ב-Rego הם בלתי ניתנים לשינוי (Immutable). למרות שחוקים עם אותו ראש מטופלים כחוק מצטבר יחיד, אם תנסה להשתמש באופרטור ההקצאה, אתה למעשה "מקצה" לאותו משתנה ערכים מספר פעמים - וזה לא מותר ב-Rego. במקום זאת, אנו משתמשים באופרטור האיחוד בראש החוק מכיוון שהוא מאחד חוקים מרובים בעלי אותו שם.
אם זה מבלבל לזכור מתי להשתמש באיזה אופרטור בראש הכלל, יש דרך פשוטה יותר, הודות לערכי ברירת מחדל ומעט סוכר תחבירי.
ערכי ברירת מחדל בראשי כללים
ערך ברירת המחדל שניתן למשתנה בראש החוק הוא true. לכן, Rego מציע כאן סוכר תחבירי: כאשר חוק מקצה את הערך true למשתנה, ניתן להשמיט את := true מראש החוק.
1 allow : = true { 2 input . user == "alice" 3 input . environment == "prod" 4 }
1 allow { 2 input . user == "alice" 3 input . environment == "prod" 4 }
1 allow = true { 2 input . user == "alice" 3 } { 4 input . user == "bob" 5 }
1 allow { 2 input . user == "alice" 3 } { 4 input . user == "bob" 5 }
מילת המפתח default
כפי שדיברנו בחלק 1, אם אין התאמות בקלט עבור שאילתת החוק, המשתנה בראש החוק אינו מקבל ערך.
כדי להדגים זאת, נחזור לכלל לדוגמה שלנו, שאומר שרק Alice, מנהל רשת, צריך להיות בעל הרשאה ליצור ולמחוק רשתות וירטואליות בחשבון ה-prod:
1 allow : = true { 2 input . user == "alice" 3 }
ונגיד שיש לנו מסמך קלט שבו המשתמש המחובר כרגע הוא Bob:
1 { 2 "user" : "bob" 3 }
מכיוון ש-input.user אינו "אליס", כאשר אנו מעריכים את הכלל מול הקלט, OPA לא מוצא התאמה בקלט. לכן, לאפשר לא מוקצה הערך true , והתוצאה של ההערכה היא קבוצה ריקה:
1 {}
במקרה זה אנו אומרים שהערך של allow הוא undefined. בכל פעם ש-OPA מתשאל קלט כדי להעריך חוק, הוא מחזיר רק ערכים תואמים. אם אין ערך תואם, אין מה להחזיר - ולכן התוצאה היא קבוצה ריקה.
מה אם נרצה ש-OPA יחזיר false אם allow אינו true במפורש? אנו יכולים להשתמש במילת המפתח default כדי להגדיר ערך ברירת מחדל. המשמעות היא שאם הערכת החוק אינה true במפורש, הוא יחזיר ערך ספציפי (במקרה זה, false) במקום להחזיר קבוצה ריקה של תוצאות. לשם כך, אנו כותבים חוק נוסף שמשתמש גם ב-allow:
1 default allow = false
כעת, אם OPA קובע ש-input.user אינו "alice", ה-allow לא יוערך לקבוצה ריקה. במקום זאת, הוא יקבל את ערך ברירת המחדל שהגדרנו, שהוא false:
1 { 2 "allow" : false 3 }
שים לב שכאשר אתה מציין את מילת המפתח default, אתה משתמש באופרטור האיחוד = במקום באופרטור ההקצאה :=, גם בחוק שבו אתה מגדיר את ערך ברירת המחדל וגם בחוק שבו אתה מגדיר את ההקצאה המותנית. שוב, זה בגלל שמשתנים הם בלתי ניתנים לשינוי. אם תנסה להשתמש באופרטור ההקצאה, אתה "מקצה" לאותו משתנה ערכים מספר פעמים, מה ש-Rego אינו מאפשר. אנו משתמשים באופרטור האיחוד במקום זאת:
1 default allow = false 2 3 allow = true { 4 input . user == "alice" 5 }
ניתן כמובן לנצל את הסוכר התחבירי שתיארנו קודם ולהשמיט את = true בחוק עם ההקצאה המותנית. זה מקובל לחלוטין ואולי קל יותר לשימוש כי אינך צריך לזכור באיזה אופרטור להשתמש בהקצאה המותנית:
1 default allow = false 2 3 allow { 4 input . user == "alice" 5 }
הודעות מותאמות אישית
לפעמים תרצה להחזיר סדרה של הודעות במקום תוצאה פשוטה של הצלחה/כישלון, true/false או undefined. אתה יכול לעשות זאת על ידי שימוש בראש החוק deny[msg] והקצאת ההודעה הרצויה למשתנה msg. החוק למטה בודק אם המשתמש אינו Alice, ואם זה המקרה, הוא מקצה את המחרוזת "User is denied access" ל-msg, אשר מתווספת לאחר מכן לקבוצת ה-deny (נדבר יותר על סטים בחלק 3):
1 deny [ msg ] { 2 input . user != "alice" 3 msg : = "User is denied access" 4 }
כדי לבדוק זאת, נניח שמסמך הקלט שלנו מכיל את השם של המשתמש המחובר כעת:
1 { 2 "user" : "bob" 3 }
כאשר אנו מעריכים את הכלל מול הקלט שלמעלה באמצעות OPA של Rego Playground או opa eval -i input.json -d check_user.rego "data.rules.check_user" --format pretty פקודה (להנחיות, עיין בפוסט Part 1 בבלוג שלנו), התוצאה נראית כך:
1 { 2 "deny" : [ 3 "User is denied access" 4 ] 5 }
מה קורה כאן? אנחנו למעשה יוצרים "חוק קבוצה" (Set rule), מושג שנחזור אליו בפוסט הבא בסדרה. לעת עתה, רק הבן שבמקום תוצאה בודדת של true או false/undefined, אנו מחזירים קבוצה של הודעות שהוקצו למשתנה deny. ב-Rego, קבוצה היא רשימה לא מסודרת של איברים ייחודיים, כגון מספרים שלמים {1, 2, 3}, מחרוזות {"alice", "bob", "carlotta"}, או אפילו קבוצות אחרות {{1, 2}, {3, 4}}. אתה יכול ליצור קבוצה מכל סוג נתונים נתמך ב-Rego, או אפילו לערבב סוגים בתוך קבוצה אחת.
במקרה של הכלל לדוגמה שלנו, כל רכיב בקבוצת ה-deny הוא מחרוזת המכילה הודעה. יש רק אלמנט אחד בסט עבור מסמך הקלט הספציפי הזה, אבל יכול להיות יותר, ואנו נראה לך דוגמה בהמשך פוסט זה בבלוג.
מה אם נרצה להחזיר מידע נוסף בהודעה? אנו יכולים להשתמש בפונקציה המובנית sprintf כדי להציג את הערך של השדה input.user שגרם לתוצאה של הכחשה:
1 deny [ msg ] { 2 input . user != "alice" 3 msg : = sprintf ( "User %v is denied access" , [input . user ] ) 4 }
הפונקציה sprintf מקבלת שני ארגומנטים - מחרוזת ומערך של ערכים. במקרה זה, האיבר היחיד במערך הוא מחרוזת המיוצגת על ידי input.user. אנו משתמשים ב-%v כמציין מיקום בארגומנט הראשון, והערך מהמערך תופס את מקומו כאשר החוק מוערך.
כעת, אם נעריך את הכלל באמצעות הקלט הבא...
1 { 2 "user" : "bob" 3 }
1 { 2 "deny" : [ 3 "User bob is denied access" 4 ] 5 }
מילת המפתח not
ניתן לשלול ביטוי על ידי הקדמת מילת המפתח not כך שיקבל משמעות הפוכה. ברוב המקרים, תרצה להשתמש בזה בשאילתה כדי לציין את היעדר המאפיין מהקלט. אז, למשל, השאילתה הזו:
1 input . tags . environment
...פירושו "למסמך הקלט יש מאפיין tags.environment, והערך אינו false ," והשאילתה הזו:
1 not input . tags . environment
…פירושה "למסמך הקלט אין מאפיין tags.environment, או ש-tags.environment מוגדר כ-false." אין חפיפה או דרך אמצע - ביטוי והיפוך שלו סותרים זה את זה.
הנה דוגמה לחוק שמקצה true ל-deny אם לקלט אין תג מחלקה (department tag):
1 deny { 2 not input . tags . department 3 }
1 { 2 "tags" : { 3 "environment" : "staging" 4 } 5 }
אם היינו מעריכים את הקלט הזה מול החוק שלמעלה, היינו רואים שה-deny מחזיר true כי חסר לו מאפיין המחלקה הנדרש:
1 { 2 "deny" : true 3 }
הערכת כלל לדוגמה באמצעות OPA
בואו נתנסה במושגים שדנו בהם בפוסט זה בבלוג על ידי הערכת כלל לדוגמה. כמו ב-Part 1 , נתמקד בשתי דרכים לאינטראקציה עם OPA:
להנחיות לשימוש בממשקים אלה, ראה Part 1 .
הפעם אנו משתמשים בדוגמה מציאותית יותר הכוללת Pod של Kubernetes. הנה המניפסט בפורמט JSON בו נשתמש כקלט:
1 { 2 "apiVersion" : "v1" , 3 "kind" : "Pod" , 4 "metadata" : { 5 "name" : "nginx-demo" , 6 "labels" : { 7 "release" : "stable" 8 } 9 }, 10 "spec" : { 11 "containers" : [ 12 { 13 "name" : "nginx" , 14 "image" : "nginx:1.14.2" , 15 "ports" : [ 16 { 17 "containerPort" : 80 18 } 19 ] 20 } 21 ] 22 } 23 }
והנה החוק שלפיו נעריך את הקלט, שכתבנו כדי לאכוף את מדיניות החברה: "Kubernetes pods must be labeled with release and environment":
1 deny [ msg ] { 2 input . kind == "Pod" 3 not input . metadata . labels . release 4 msg : = sprintf ( "Pod %v is missing release label" , [input . metadata . name ] ) 5 } { 6 input . kind == "Pod" 7 not input . metadata . labels . environment 8 msg : = sprintf ( "Pod %v is missing environment label" , [input . metadata . name ] ) 9 }
כלל זה מדגים כמה מושגים שדנו בפוסט זה בבלוג:
• שימוש ב-deny[msg] כדי להחזיר קבוצה של הודעות מותאמות אישית במקום true או false/undefined
• מבנה חוק המשתמש גם ב-AND וגם ב-OR: תן הודעת דחייה (Deny) אם אובייקט ה-Kubernetes הוא Pod AND חסרה לו תווית השחרור (release), OR: