החלת כללי מדיניות מותאמים אישית לאבטחה ברמת ה-Pod באמצעות Gatekeeper

בדף הזה מוסבר איך להשתמש בבקר הגישה של Gatekeeper כדי להחיל אמצעי אבטחה ברמת ה-Pod על אשכולות Google Kubernetes Engine‏ (GKE). בדף הזה מוסבר איך להשתמש ב-Gatekeeper כדי להחיל אילוצים שמאפשרים להחיל מדיניות אבטחה, כדי לעמוד בדרישות האבטחה של הארגון.

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

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

סקירה כללית על שומרי הסף

Gatekeeper הוא בקר קבלה שמאמת בקשות ליצירה ולעדכון של Pods באשכולות Kubernetes, באמצעות Open Policy Agent‏ (OPA).

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

הוא יכול גם:

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

מושגי מפתח בנושא שומרי סף

ב-Gatekeeper יש שני מושגים שמאפשרים לאדמינים לשלוט באשכול בצורה יעילה וגמישה: אילוצים ותבניות אילוצים. שני המושגים האלה נלקחו מ-Constraint Framework של Open Policy Agent.

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

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

תבנית האילוצים הבאה, ממאגר Gatekeeper, בודקת אם קיים securityContext.privileged במפרט של Pod:

apiVersion: templates.gatekeeper.sh/v1beta1
kind: ConstraintTemplate
metadata:
  name: k8spspprivilegedcontainer
spec:
  crd:
    spec:
      names:
        kind: K8sPSPPrivilegedContainer
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8spspprivileged

        violation[{"msg": msg, "details": {}}] {
            c := input_containers[_]
            c.securityContext.privileged
            msg := sprintf("Privileged container is not allowed: %v, securityContext: %v", [c.name, c.securityContext])
        }
        input_containers[c] {
            c := input.review.object.spec.containers[_]
        }
        input_containers[c] {
            c := input.review.object.spec.initContainers[_]
        }

כדי להרחיב את הדוגמה הקודמת של תבנית האילוצים, האילוץ הבא מגדיר את ההיקף (kinds) לאכיפה הספציפית של תבנית האילוצים הזו במצב dryrun:

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sPSPPrivilegedContainer
metadata:
  name: psp-privileged-container
spec:
  enforcementAction: dryrun
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]

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

‫Google Cloud מספק גרסה מנוהלת ונתמכת באופן רשמי של Gatekeeper בקוד פתוח, שנקראת Policy Controller. ‫Google לא תומכת באופן רשמי בפרויקט Gatekeeper בקוד פתוח.

לפני שמתחילים

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

  • מפעילים את Google Kubernetes Engine API.
  • הפעלת Google Kubernetes Engine API
  • כדי להשתמש ב-Google Cloud CLI למשימה הזו, מתקינים ואז מאתחלים את ה-CLI של gcloud. אם כבר התקנתם את ה-CLI של gcloud, הריצו את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שבגרסאות קודמות של ה-CLI של gcloud אי אפשר להריץ את הפקודות שבמסמך הזה.

הפעלת Gatekeeper באשכול באמצעות Policy Controller

‫Policy Controller הוא מנוע מדיניות שמבוסס על פרויקט הקוד הפתוח Gatekeeper. ‫Google ממליצה להשתמש ב-Policy Controller כי הוא כולל תכונות נוספות שעוזרות לאכוף את המדיניות בקנה מידה נרחב, כולל מדיניות כקוד, תמיכה בכמה אשכולות, שילוב עם Cloud Logging ואפשרות לראות את סטטוס המדיניות במסוף Google Cloud . ‫Policy Controller זמין ב-GKE, אבל אתם יכולים להתקין את Gatekeeper באשכול במקום זאת.

כדי להפעיל את Policy Controller באשכול, פועלים לפי המדריך להתקנת Policy Controller.

הפעלת אילוצים ותבניות אילוצים

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

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

בדוגמה הבאה, היקף ההרשאות מוגבל ל-Pods שנמצאים במרחב השמות production, על ידי הגדרתם בהצהרת ההתאמה של האילוץ:

...
spec:
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]
    namespaces:
      - "production"

מידע נוסף על האפשרויות הזמינות לאובייקטים מסוג Constraint ו-ConstraintTemplate זמין במאמר איך משתמשים ב-Gatekeeper.

מדיניות בדיקות

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

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

  1. מחילים את ההגדרות של Gatekeeper כדי לשכפל נתונים לפונקציונליות של ביקורת והרצה (dry-run):

    kubectl create -f- <<EOF
    apiVersion: config.gatekeeper.sh/v1alpha1
    kind: Config
    metadata:
      name: config
      namespace: "gatekeeper-system"
    spec:
      sync:
        syncOnly:
          - group: ""
            version: "v1"
            kind: "Namespace"
          - group: ""
            version: "v1"
            kind: "Pod"
    EOF
    
  2. בלי להחיל אילוצים, מריצים עומס עבודה עם הרשאות מורחבות:

    kubectl create -f- <<EOF
    apiVersion: v1
    kind: Pod
    metadata:
      name: nginx
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        securityContext:
          privileged: true
    EOF
    
  3. טוענים את תבנית האילוצים הקודמת של k8spspprivilegedcontainer:

    kubectl create -f- <<EOF
    apiVersion: templates.gatekeeper.sh/v1beta1
    kind: ConstraintTemplate
    metadata:
      name: k8spspprivilegedcontainer
    spec:
      crd:
        spec:
          names:
            kind: K8sPSPPrivilegedContainer
      targets:
        - target: admission.k8s.gatekeeper.sh
          rego: |
            package k8spspprivileged
    
            violation[{"msg": msg, "details": {}}] {
                c := input_containers[_]
                c.securityContext.privileged
                msg := sprintf("Privileged container is not allowed: %v, securityContext: %v", [c.name, c.securityContext])
            }
            input_containers[c] {
                c := input.review.object.spec.containers[_]
            }
            input_containers[c] {
                c := input.review.object.spec.initContainers[_]
            }
    EOF
    
  4. כדי להרחיב את תבנית האילוצים הזו, צריך ליצור אילוץ חדש. הפעם, מגדירים את enforcementAction לערך dryrun:

    kubectl create -f- <<EOF
    apiVersion: constraints.gatekeeper.sh/v1beta1
    kind: K8sPSPPrivilegedContainer
    metadata:
      name: psp-privileged-container
    spec:
      enforcementAction: dryrun
      match:
        kinds:
          - apiGroups: [""]
            kinds: ["Pod"]
    EOF
    
  5. כדי לבדוק אם נמצאו הפרות, בודקים את ה-status של האילוץ, בזמן ש-Gatekeeper מסנכרן את נתוני האובייקטים שפועלים ובודק באופן פסיבי אם יש הפרות:

    kubectl get k8spspprivilegedcontainer.constraints.gatekeeper.sh/psp-privileged-container -o yaml
    
    apiVersion: constraints.gatekeeper.sh/v1beta1
    kind: K8sPSPPrivilegedContainer
    metadata:
    ...
     name: psp-privileged-container
    ...
    spec:
     enforcementAction: dryrun
     match:
       kinds:
       - apiGroups:
         - ""
         kinds:
         - Pod
    status:
     auditTimestamp: "2019-12-15T22:19:54Z"
     byPod:
     - enforced: true
       id: gatekeeper-controller-manager-0
     violations:
     - enforcementAction: dryrun
       kind: Pod
       message: 'Privileged container is not allowed: nginx, securityContext: {"privileged":
         true}'
       name: nginx
       namespace: default
    
  6. כדי לוודא שהמדיניות לא מפריעה לפריסות, מריצים Pod אחר עם הרשאות:

    kubectl create -f- <<EOF
    apiVersion: v1
    kind: Pod
    metadata:
      name: privpod
      labels:
        app: privpod
    spec:
      containers:
      - name: nginx
        image: nginx
        securityContext:
          privileged: true
    EOF
    

    ה-Pod החדש ייפרס בהצלחה.

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

    kubectl delete k8spspprivilegedcontainer.constraints.gatekeeper.sh/psp-privileged-container
    kubectl delete constrainttemplate k8spspprivilegedcontainer
    kubectl delete pod/nginx
    kubectl delete pod/privpod
    

אכיפת כללי המדיניות

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

בהתבסס על הדוגמאות ששימשו לאימות המדיניות שלמעלה, השלבים הבאים מדגימים איך מפתח, מפעיל או אדמין יכולים להחיל תבניות אילוצים ואילוצים כדי לאכוף מדיניות:

  1. טוענים את תבנית האילוצים k8spspprivilegedcontainer שהוזכרה קודם:

    kubectl create -f- <<EOF
    apiVersion: templates.gatekeeper.sh/v1beta1
    kind: ConstraintTemplate
    metadata:
      name: k8spspprivilegedcontainer
    spec:
      crd:
        spec:
          names:
            kind: K8sPSPPrivilegedContainer
      targets:
        - target: admission.k8s.gatekeeper.sh
          rego: |
            package k8spspprivileged
    
            violation[{"msg": msg, "details": {}}] {
                c := input_containers[_]
                c.securityContext.privileged
                msg := sprintf("Privileged container is not allowed: %v, securityContext: %v", [c.name, c.securityContext])
            }
            input_containers[c] {
                c := input.review.object.spec.containers[_]
            }
            input_containers[c] {
                c := input.review.object.spec.initContainers[_]
            }
    EOF
    
  2. כדי להרחיב את תבנית האילוצים הזו, צריך ליצור אילוץ חדש. הפעם, אל תגדירו את המפתח enforcementAction. כברירת מחדל, המפתח enforcementAction מוגדר לערך deny:

    kubectl create -f- <<EOF
    apiVersion: constraints.gatekeeper.sh/v1beta1
    kind: K8sPSPPrivilegedContainer
    metadata:
      name: psp-privileged-container
    spec:
      match:
        kinds:
          - apiGroups: [""]
            kinds: ["Pod"]
    EOF
    
  3. ניסיון לפרוס קונטיינר שמצהיר על הרשאות מיוחדות:

    kubectl create -f- <<EOF
    apiVersion: v1
    kind: Pod
    metadata:
      name: nginx
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        securityContext:
          privileged: true
    EOF
    

    אמורה להופיע הודעת השגיאה הבאה:

    Error from server ([denied by psp-privileged-container] Privileged container is not allowed:
    nginx, securityContext: {"privileged": true}): error when creating "STDIN": admission webhook "validation.gatekeeper.sh" denied the request: [denied by psp-privileged-container]
    Privileged container is not allowed: nginx, securityContext: {"privileged": true}
    
  4. כדי לנקות, מריצים את הפקודות הבאות:

    kubectl delete k8spspprivilegedcontainer.constraints.gatekeeper.sh/psp-privileged-container
    kubectl delete constrainttemplate k8spspprivilegedcontainer
    

חלופות ל-Gatekeeper

באמצעות Gatekeeper אפשר להצהיר על כללי מדיניות אבטחה מותאמים אישית ברמת ה-Pod ולהחיל אותם. אפשר גם להשתמש ב-PodSecurity admission controller המובנה של Kubernetes כדי להחיל כללי מדיניות אבטחה מוגדרים מראש ברמת ה-Pod. כללי המדיניות המוגדרים מראש תואמים לרמות שמוגדרות בתקני האבטחה של Pod.

המאמרים הבאים

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