הכנה של רשתות סביבתיות ב-GKE

בדף הזה מוסבר איך להפעיל את Ambient Networking באשכול חדש או קיים, לרשום מרחבי שמות ועומסי עבודה כדי להפעיל הפניית תנועה בסביבה, ולהגדיר כללי מדיניות של mTLS והרשאות.

בסקירה הכללית על Ambient Networking מוסבר בהרחבה על הארכיטקטורה, היתרונות והיכולות של Ambient Networking.

דרישות מוקדמות ומגבלות

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

  • ‫GKE: נדרשת גרסה ‎1.36.4-gke.1391000‎ או גרסה חדשה יותר.
  • ‫Google Cloud CLI: נדרשת גרסה 592.0.0 ואילך.
  • תמיכה אזורית: צריך ליצור את האשכולות באזור שנתמך על ידי Regional Cloud Service Mesh.
  • יכולת פעולה הדדית של עומסי עבודה: עומסי עבודה שרשומים ל-Ambient Networking לא יכולים לפעול באופן הדדי עם עומסי עבודה שהוחדר להם sidecar או עם gRPC בלי שרת Proxy.
  • תכונות שלא נתמכות:
    • שדה trafficDistribution של שירות Kubernetes.
    • שירותים ללא נקודת קצה (Headless Services).
    • ‫GKE Sandbox ‏(gVisor).
  • הודעת אבטחה: אם הרכיב gke-ambient-nriplugin לא זמין בצומת, יכול להיות שיתבצע מעקף של אכיפת האימות וההרשאה של תנועה נכנסת.

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

מבצעים את השלבים הבאים להגדרה מראש ב- Cloud de Confiance by S3NS:

  1. יוצרים או בוחרים פרויקט.
  2. מפעילים את ממשקי ה-API הנדרשים:

    gcloud services enable \
        privateca.googleapis.com \
        gkehub.googleapis.com \
        compute.googleapis.com \
        container.googleapis.com \
        trafficdirector.googleapis.com \
        networkservices.googleapis.com \
        networksecurity.googleapis.com \
        telemetry.googleapis.com \
        monitoring.googleapis.com \
        logging.googleapis.com
    
  3. הגדרת אימות של ניהול זהויות ב-Workload Identity ל-GKE.

הפעלת Ambient Networking באשכול חדש

מריצים את הפקודה הבאה כדי ליצור אשכול GKE חדש עם רשתות אווירה:

  1. יצירת אשכול GKE עם Ambient Networking מופעל

    gcloud container clusters create CLUSTER_NAME \
        --machine-type=e2-standard-4 \
        --enable-ambient-networking \
        --enable-dataplane-v2 \
        --enable-fleet \
        --gateway-api=standard \
        --location=CLUSTER_LOCATION \
        --release-channel=rapid \
        --workload-pool=PROJECT_ID.s3ns.svc.id.goog
    

    עכשיו פועלים שני DaemonSets במרחב השמות gke-managed-ambient.

הפעלת Ambient Networking באשכול קיים

כדי להפעיל רשת סביבתית באשכול GKE קיים:

  1. מוודאים שהאשכול עומד בדרישות הבאות:

    • גרסה 1.36.4-gke.1391000 ומעלה.
    • GKE Dataplane V2 מופעל.
    • סוג המכונה חייב להיות e2-standard-4 או גדול יותר.
    • צריך להוסיף את האשכול לצי.
    • ב-cluster צריך להפעיל את Gateway API ואת Workload Identity.
  2. הפעלת Ambient Networking באשכול קיים:

    gcloud container clusters update CLUSTER_NAME \
        --enable-ambient-networking \
        --location=CLUSTER_LOCATION \
        --enable-fleet
    

    עכשיו פועלים שני DaemonSets במרחב השמות gke-managed-ambient.

  3. כדי לאמת, מפנים את ה-CLI לאשכול:

    gcloud container clusters get-credentials CLUSTER_NAME \
        --location=CLUSTER_LOCATION
    
  4. מציגים את ה-daemonsets במרחב השמות gke-managed-ambient:

    kubectl get daemonset -n gke-managed-ambient
    

    הפלט אמור להיראות כך:

    NAME                    DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   AGE
    gke-ambient-nriplugin   9         9         9       9            9           4d1h
    gke-ambient-proxy       9         9         9       9            9           4d1h
    

רישום מרחב שמות ל-Ambient Networking

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

  1. פורסים אפליקציה לדוגמה:

    kubectl apply -f - <<EOF
    apiVersion: v1
    kind: Namespace
    metadata:
      name: ambient-test
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: client
      namespace: ambient-test
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: server
      namespace: ambient-test
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: server
      namespace: ambient-test
      labels:
        app: server
    spec:
      ports:
      - port: 80
        protocol: TCP
      selector:
        app: server
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: client
      namespace: ambient-test
      labels:
        app: client
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: client
      template:
        metadata:
          labels:
            app: client
        spec:
          serviceAccountName: client
          containers:
          - name: nginx
            image: nginx:1.29.6
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: server
      namespace: ambient-test
      labels:
        app: server
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: server
      template:
        metadata:
          labels:
            app: server
        spec:
          serviceAccountName: server
          containers:
          - name: nginx
            image: nginx:1.29.6
            readinessProbe:
              httpGet:
                path: /
                port: 80
    EOF
    
  2. מוסיפים תווית למרחב השמות ambient-test כדי להפעיל הפניית תנועה דרך שרת ה-proxy של GKE:

    kubectl label namespace ambient-test networking.gke.io/dataplane-mode=ambient
    
  3. מוודאים שכל Pod במרחב השמות הוגדר להפניית תנועה:

    kubectl get pods -n ambient-test -o yaml | grep redirection
    

    הפלט אמור להיראות כך:

    ambient.networking.gke.io/redirection: enabled
    ambient.networking.gke.io/redirection: enabled
    
  4. בודקים את תעבורת הנתונים מהלקוח לשרת:

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  5. כדי לוודא שתנועת הטקסט הפשוט עוברת דרך gke-ambient-proxy, בודקים את יומני הגישה ב-Logs Explorer ומחפשים את שם היומן gke-ambient-node-proxy-accesslog:

    כניסה לדף Logs Explorer

הפעלת mTLS לשירות

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

  1. מגדירים מדיניות mTLS מתירנית בעומסי העבודה בצד השרת:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPServerTLSPolicy
    metadata:
      name: server
      namespace: ambient-test
    spec:
      mtlsMode: Permissive
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
    EOF
    

    המדיניות הזו גורמת ל-Pods לקבל גם תנועת mTLS וגם תנועת טקסט פשוט. חשוב לזכור שב-mTLS מתירני, המערכת משתמשת בהאזנה לתעבורת נתונים כדי לזהות אם התעבורה היא mTLS או טקסט פשוט. הפעולה הזו תפסיק את תעבורת הנתונים של האפליקציה שמשתמשת ב-TLS משלה או בפרוטוקול "server speaks first" כמו MySQL.

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

    kubectl describe gcpservertlspolicies -n ambient-test server | grep -A50 Status
    

    הפלט אמור להיראות כך:

    [...]
    
        Conditions:
        Last Transition Time:  2026-03-25T17:47:30Z
        Message:
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Controller Name:         networking.gke.io/dpv2-1n
    Events:
    Type    Reason  Age                   From                   Message
    ----    ------  ----                  ----                   -------
    Normal  Sync    108s (x2 over 2m20s)  sc-dpv2-1n-controller  Sync on Mesh dpv2-1n-fqtx-mesh succeeded
    

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

  3. מגדירים מדיניות mTLS בצד הלקוח שמטרגטת את השירות:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPClientTLSPolicy
    metadata:
      name: server-mtls
      namespace: ambient-test
    spec:
      targetRefs:
      - group: ""
        kind: Service
        name: server
      subjectAltNames:
      - uri: spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/server
    EOF
    

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

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

    kubectl describe gcpclienttlspolicies -n ambient-test server-mtls | grep -A50 Status
    

    הפלט אמור להיראות כך:

    [...]
    Status:
    Conditions:
        Last Transition Time:  2024-10-13T01:15:03Z
        Message:
        Observed Generation:   1
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
    
  5. בודקים את תעבורת הנתונים מהלקוח לשרת:

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    

    תעבורת הנתונים מהפודים שרשומים ל-Ambient Networking לשירות השרת במרחב השמות ambient-test אמורה עכשיו להשתמש ב-mTLS.

  6. כדי לוודא שהחיבורים משתמשים ב-mTLS, בודקים את יומני הגישה ב-Logs Explorer ומחפשים את שם היומן gke-ambient-node-proxy-accesslog:

    כניסה לדף Logs Explorer

  7. מעדכנים את GCPServerTLSPolicy הקיים כדי לשנות את mode מ-Permissive ל-Strict בשירות השרת, כך שהפודים של עומס העבודה לא יקבלו יותר תנועה בטקסט פשוט:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPServerTLSPolicy
    metadata:
      name: server
      namespace: ambient-test
    spec:
      mtlsMode: Strict
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
    EOF
    
  8. מוודאים שהמדיניות אושרה:

    kubectl describe gcpservertlspolicies -n ambient-test server | grep -A50 Status
    

    הפלט אמור להיראות כך:

    Name:         server
    
    <...>
    
    UID:                 e4f2a7a3-69aa-4528-8ea6-6f1bf2142011
    Spec:
    Mtls Mode:  Strict
    Target Refs:
    Group:
    Kind:   Pod
    Selector:
      Match Labels:
        App:  server
    Status:
    Ancestors:
        Ancestor Ref:
        Group:
        Kind:   Pod
        Name:   app=server
        Conditions:
        Last Transition Time:  2026-03-25T22:33:54Z
        Message:
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Controller Name:         networking.gke.io/dpv2-1n
    Events:
    Type    Reason  Age                  From                   Message
    ----    ------  ----                 ----                   -------
    Normal  Sync    43s (x5 over 4m57s)  sc-dpv2-1n-controller  Sync on Mesh dpv2-1n-2cdi-mesh succeeded
    

    כל תנועה בטקסט פשוט לשירות השרת תידחה.

  9. כדי לוודא שתנועה בטקסט פשוט נדחית עכשיו, שולחים תנועה לשירות השרת מלקוח שלא רשום ל-Ambient Networking:

    kubectl create namespace noambient-test && \
    kubectl run -it -n noambient-test --rm curl --image=nginx -- \
        /bin/curl -fsLSv http://server.ambient-test.svc.cluster.local
    

    החיבור אמור להיכשל ותופיע הודעה דומה לזו:

    * Request completely sent off
    * Empty reply from server
    * shutting down connection #0
    curl: (52) Empty reply from server
    

הגדרת מדיניות הרשאה בשכבה 4

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

  1. כדי לאכוף את המדיניות שרק הלקוח יכול לתקשר עם השרת, צריך להחיל את המדיניות הבאה:

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPAuthzPolicy
    metadata:
      name: allow-client
      namespace: ambient-test
    spec:
      action: ALLOW
      enforcementLevel: L4
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
      rules:
      - from:
          sources:
          - principals:
            - principalSelector: CLIENT_CERT_URI_SAN
              principal:
                type: Exact
                value: spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client
    EOF
    

    המדיניות הזו נאכפת על תנועה לפודים של השרת במרחב השמות ambient-test. היא מוודאת שתנועה מותרת רק ממקורות עם זהות SPIFFE‏ spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client.

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

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  3. כדי לוודא שאכיפת המדיניות לא מותרת, שולחים בקשה לדוגמה מחשבון השירות server.

    kubectl exec -it deploy/server -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    

    הפלט אמור להיראות כך:

    curl: (52) Empty reply from server
    command terminated with exit code 52
    
  4. אתם יכולים להשתמש ב-Logs Explorer כדי לראות את רישום אכיפת ההרשאות ביומן. במסוף Cloud de Confiance , נכנסים לדף Logs Explorer ומחפשים בקשות שנדחו באמצעות שם היומן gke-ambient-node-proxy-accesslog:

    resource.type="k8s_container"
    logName="projects/PROJECT_ID/logs/gke-ambient-node-proxy-accesslog"
    jsonPayload.error_details=~"rbac_access_denied"
    

    כניסה לדף Logs Explorer

הפעלת מדדים של שכבה 4

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

לפני שמפעילים את יצירת המדדים של שכבה 4, צריך לוודא שהפעלתם את telemetry.googleapis.com ואת monitoring.googleapis.com, ושהחלתם את networking.gke.io/dataplane-mode=ambient על מרחב השמות.

  1. מפעילים יצירת מדדים של שכבה 4 לעומסי עבודה במרחב השמות:

    kubectl label namespace ambient-test networking.gke.io/ambient-network-metrics=enabled
    
  2. מוודאים שהאפשרות ליצירת מדדים בשכבה 4 מופעלת:

    kubectl get namespace ambient-test --show-labels
    

    הפלט אמור להיראות כך:

    NAME           STATUS   AGE   LABELS
    ambient-test   Active   15m   kubernetes.io/metadata.name=ambient-test,networking.gke.io/ambient-network-metrics=enabled,networking.gke.io/dataplane-mode=ambient
    

    אחרי שמחילים את התווית networking.gke.io/ambient-network-metrics=enabled והתנועה זורמת בין עומסי העבודה הרשומים, המדדים של שכבה 4 זמינים ב-Cloud Monitoring. אתם יכולים להשתמש במעקב אחרי שירותי רשת כדי לראות ולנתח אותם.

  3. נכנסים לדף Network Services Monitoring במסוף Cloud de Confiance by S3NS .

    למעבר אל Network Services Monitoring

    למידע נוסף, קראו את המאמר הצגת מדדים ואת ההפניה למדדי המעקב של Network Services.