פריסת אפליקציות ASP.NET עם אימות Windows במאגרי GKE Windows

במדריך הזה נסביר איך ליצור אפליקציית אינטרנט של ASP.NET שמשתמשת ב-IIS עם אימות משולב של Windows, ואיך לפרוס אותה באמצעות קונטיינר של Windows באשכול Google Kubernetes Engine ‏ (GKE) שיש בו צמתים של Windows Server שמצורפים לדומיין. ההגדרה הזו שימושית לפריסת אפליקציות ASP.NET בקונטיינרים של Windows ב- Google Cloud, כדי שהאפליקציות יוכלו לבצע אימות למשאבים אחרים של Windows. במדריך מוסבר גם איך ליצור חשבון שירות מנוהל קבוצתי (gMSA) ב-Active Directory ואיך להגדיר את פריסת אפליקציית האינטרנט ב-GKE כדי להשתמש בו.

המדריך הזה מיועד לאדמינים של מערכות. ההנחה היא שאתם מכירים את Active Directory ויש לכם ניסיון בעבודה עם Google Kubernetes Engine ‏ (GKE).

מטרות

  • יוצרים אשכול GKE עם צמתים של Windows Server שמצורפים לדומיין, ומגדירים את האשכול כך שיתמוך ב-gMSA של Active Directory.
  • יוצרים ופורסים קובץ אימג' של קונטיינר של אפליקציית אינטרנט ב-ASP.NET שמשתמשת ב-IIS עם אימות משולב של Windows.

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

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

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

  1. פועלים לפי השלבים במדריך בנושא הגדרת Active Directory למכונות וירטואליות כדי שיצטרפו אוטומטית לדומיין כדי ליצור את שירות Cloud Run של צירוף לדומיין Active Directory.

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

    אחרי שתשלימו את ההדרכה השנייה, יהיה לכם שירות חדש של Cloud Run וכתובת ה-URL שלו תודפס בחלון PowerShell (הערך של המשתנה $RegisterUrl). חשוב לשים לב לכתובת של השירות, כי תצטרכו להשתמש בה במדריך הזה.

  3. מוודאים שהפעלתם את ממשקי ה-API של Compute Engine,‏ GKE,‏ Cloud Build,‏ Artifact Registry ו-Cloud Resource Manager API:

    הפעלת ממשקי ה-API

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

ארכיטקטורה

אפליקציות מבוססות-Windows שפועלות ב-Windows Server שמחובר לדומיין משתמשות בדרך כלל בזהויות של Microsoft Active Directory‏ (AD) כדי לאמת משתמשים ואפליקציות. תרחישי שימוש נפוצים:

  • יצירת אפליקציות אינטרנט של ASP.NET שמשתמשות באימות Windows משולב כדי לאמת משתמשי Active Directory כשהם מנסים להיכנס לאפליקציית האינטרנט.
  • יצירת אפליקציות שמשתמשות בחשבון המחשב של Active Directory בשרת כדי לגשת למשאבים ברשת, כמו שיתוף SMB מרוחק או מופע מרוחק של Microsoft SQL Server.

אי אפשר לצרף קונטיינרים של Windows לדומיין, ולכן אין להם חשבונות מחשב ב-Active Directory. לכן, אפליקציות אינטרנט של ASP.NET שפועלות במאגרי Windows לא יכולות לאמת משתמשי Active Directory באמצעות אימות משולב של Windows, ולכן הן לא יכולות לגשת למשאבים מאובטחים ברשת. מידע נוסף על האופן שבו ASP.NET ניגש למשאבים מאובטחים זמין במאמר Application Pool Identities במסמכי התיעוד של Microsoft.

במקום להשתמש בחשבון מחשב, קונטיינרים של Windows יכולים להשתמש בזהות של חשבון שירות מנוהל (gMSA) של קבוצת Active Directory כדי לגשת ל-Active Directory ולמשאבים מאובטחים אחרים ברשת, כמו שיתופי קבצים ומכונות של SQL Server. למידע נוסף, קראו את המאמר Group Managed Service Accounts Overview במרכז העזרה של Microsoft.

בתרשים הארכיטקטורה הבא מוצגים המשאבים שבהם נעשה שימוש במדריך הזה:

קונטיינרים של שרת Windows שמצורפים לדומיין Active Domain ב-GKE.

בתרשים מוצגים האלמנטים הבאים:

  • Development VM. במדריך הזה יוצרים מכונה וירטואלית של Windows Server שמשמשת ליצירת קובץ אימג' של קונטיינר של אפליקציית האינטרנט ASP.NET וליצירת gMSA.
  • אשכולות וצמתים של GKE. באשכול GKE שבמדריך הזה יש מאגר צמתים של Linux ומאגר צמתים של Windows Server, והם משמשים למטרות הבאות:
    • בצומתי Linux פועלים רכיבי מערכת שפועלים רק במערכות ההפעלה של Linux, כמו שרת המדדים של GKE.
    • הצמתים של Windows Server משמשים לאירוח קונטיינרים של Windows Server ומצורפים לדומיין של Active Directory.
  • תשתית Active Directory. כדי להצטרף לדומיין עם צמתי GKE Windows, צריך קודם לעבור על המדריך הגדרת Active Directory למכונות וירטואליות כדי להצטרף לדומיין באופן אוטומטי. במדריך הזה יוצרים שירות Cloud Run שאחראי על רישום מחשבים חדשים (מכונות) ב-Active Directory, ומספקים לכל מכונה חדשה סיסמה זמנית שמשמשת את המכונה להשלמת תהליך ההצטרפות לדומיין. כל מופע חדש במאגר הצמתים של Windows Server קורא לשירות Cloud Run כדי להצטרף לדומיין Active Directory.
  • מאזן עומסי רשת. כשמשתמש מקומי פותח את הדפדפן שלו ומעיין באפליקציית האינטרנט של ASP.NET, התנועה עוברת דרך מאזן עומסים ברשת. מאזן העומסים נוצר על ידי GKE כשיוצרים שירות LoadBalancer של GKE לאפליקציית האינטרנט. המשתמש גם מאמת את אפליקציית האינטרנט על ידי העברת פרטי הכניסה שלו ב-Active Directory לאפליקציית האינטרנט.

יצירת התשתית

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

  • מכונה וירטואלית של Windows Server שיש בה קובץ אימג' של קונטיינר של אפליקציית אינטרנט ASP.NET.
  • אשכול GKE שיש בו מאגר צמתים של Windows Server.
  • כללי חומת אש שנותנים ל-Pods של GKE גישה ל-Active Directory.
  • ‫Webhook באשכול GKE שמטפל בהגדרה ובאכלוס של משאבי gMSA בפריסות.

יצירת מכונה וירטואלית לפיתוח

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

במדריך הזה נעשה שימוש בגרסת Long-Term Servicing Channel‏ (LTSC) 2022 של Windows Server למכונה הווירטואלית, לצמתים של Windows Server ב-GKE ולקובץ אימג' של קונטיינר. מידע נוסף זמין במאמר בנושא מיפוי גרסאות בין גרסאות של Windows Server וגרסאות של GKE.

  1. מפעילים את Cloud Shell במסוף Google Cloud .

    הפעלת Cloud Shell

    בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

  2. אם PowerShell פתוח, סוגרים אותו על ידי הקלדת exit.
  3. מגדירים משתני סביבה לשם של הרשת ושל רשת המשנה, ולכתובת ה-URL של שירות ספריות Active Directory:

    export NETWORK_NAME=NETWORK-NAME
    export SUBNETWORK_NAME=SUBNETWORK-NAME
    export AD_JOIN_SERVICE_URL=AD-JOIN-SERVICE-URL
    

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫NETWORK-NAME: רשת ה-VPC שבה פורסים את המכונות הווירטואליות.
    • ‫SUBNETWORK-NAME: תת-הרשת שבה יופעלו המכונות הווירטואליות.
    • ‫AD-JOIN-SERVICE-URL: כתובת ה-URL של שירות Cloud Run שפרסתם בקטע לפני שמתחילים.
  4. מגדירים את מזהה הפרויקט והאזור של Google Cloud בסביבה הנוכחית:

    gcloud config set project PROJECT-ID
    gcloud config set compute/zone ZONE-NAME
    

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT-ID: מזהה הפרויקט ב- Google Cloud .
    • ‫ZONE-NAME: האזור שבו פורסים את כל המכונות הווירטואליות. כדי לצמצם את זמן האחזור, מומלץ לבחור אזור שנמצא באותו מיקום שבו פרסתם את שירות Cloud Run להצטרפות לדומיין של Active Directory.
  5. יוצרים חשבון שירות למכונה הווירטואלית לפיתוח:

    export SERVICE_ACCOUNT_NAME=dev-vm
    export SERVICE_ACCOUNT_EMAIL=$SERVICE_ACCOUNT_NAME@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
    
    gcloud iam service-accounts create $SERVICE_ACCOUNT_NAME \
        --display-name="Development VM Service Account"
    
  6. מעניקים לחשבון השירות גישה ל-Artifact Registry:

    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
        --member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
        --role="roles/artifactregistry.writer"
    
  7. נותנים לחשבון השירות גישה ל-GKE:

    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
        --member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
        --role="roles/container.admin"
    

    לחשבון השירות מוקצה התפקיד container.admin כי התפקיד הזה כולל הרשאות ליצירת אשכולות GKE בפרויקט ולניהול משאבים באשכולות, כולל משאבי בקרת גישה מבוססת-תפקידים (RBAC). כדי לקבוע לאיזה Pod מותר להשתמש ב-gMSA, צריך משאבי RBAC.

  8. יוצרים מכונה וירטואלית חדשה של Windows Server 2022:

    gcloud compute instances create gmsa-dev-vm \
        --image-project windows-cloud \
        --image-family windows-2022-core \
        --machine-type n1-standard-2 \
        --boot-disk-type=pd-ssd \
        --boot-disk-size=100GB \
        --network $NETWORK_NAME \
        --subnet $SUBNETWORK_NAME \
        --service-account=$SERVICE_ACCOUNT_EMAIL \
        --scopes https://www.googleapis.com/auth/cloud-platform \
        --metadata sysprep-specialize-script-ps1="iex((New-Object System.Net.WebClient).DownloadString('$AD_JOIN_SERVICE_URL')); Add-WindowsFeature RSAT-AD-PowerShell"
    

    אם אתם מתכננים לפרוס את האפליקציות שמופעלות באמצעות קונטיינרים בקונטיינרים של Windows Server 2019, צריך לשנות את ערך הפרמטר --image-family ל-windows-2019-core-for-containers.

    ההיקף https://www.googleapis.com/auth/cloud-platform מאפשר למכונה לגשת לכל ממשקי ה-API של Google Cloud , בהתאם לתפקידי ה-IAM שמוגדרים לחשבון השירות של המכונה.

    המכונה הווירטואלית נוצרת עם כתובת IP חיצונית כדי לאפשר לה לתקשר עם האינטרנט. למכונה הווירטואלית צריכה להיות גישה לאינטרנט כדי שתוכל להוריד כמה כלי שירות, כמו git ו-kubectl, ולהוריד את אפליקציית האינטרנט ASP.NET מ-GitHub.

    במהלך שלב sysprep, המופע החדש מצטרף לדומיין של Active Directory כדי לאפשר לכם לגשת למופע מרחוק באמצעות חשבון הדומיין. הסקריפט בפקודה sysprep מתקין גם את המודול של PowerShell ל-Active Directory.

יצירת מאגר Docker ב-Artifact Registry

  1. ב-Cloud Shell, מגדירים את מיקום ברירת המחדל למאגרים חדשים ב-Artifact Registry:

    gcloud config set artifacts/location LOCATION
    

    מחליפים את LOCATION באזור שבו רוצים ליצור את המאגר ב-Artifact Registry. כדי לצמצם את זמן האחזור, מומלץ לבחור באותו אזור שבו פרסתם את ה-VM לפיתוח.

  2. יוצרים את מאגר Docker ב-Artifact Registry:

    gcloud artifacts repositories create windows-container-images \
        --repository-format=docker
    

יצירת אשכול GKE

  1. ב-Cloud Shell, מגדירים משתנה סביבה לשם של אשכול GKE:

    export GKE_CLUSTER_NAME=cluster-1
    
  2. יוצרים את אשכול ה-GKE:

    gcloud container clusters create $GKE_CLUSTER_NAME \
        --release-channel rapid \
        --network $NETWORK_NAME \
        --subnetwork $SUBNETWORK_NAME \
        --enable-ip-alias
    

    הגדרת הפרמטר --release-channel לערך rapid פורסת את אשכול GKE עם הגרסה האחרונה של Kubernetes. הפרמטר --enable-ip-alias מפעיל את כתובת ה-IP החלופית. נדרשת כתובת IP של כינוי לצמתים של Windows Server.

יצירת מאגר צמתים של Windows Server ב-GKE

כשיוצרים אשכול GKE חדש באמצעות CLI, האשכול נוצר עם מאגר צמתים של Linux. כדי להשתמש ב-Windows Server ב-GKE, יוצרים מאגר צמתים של Windows Server.

ב-GKE, לכל אשכול GKE צריך להיות לפחות צומת Linux אחד כדי להריץ את הקונטיינרים הפנימיים (מערכת) של האשכול. אי אפשר ליצור אשכול GKE עם צמתים של Windows Server בלבד.

  1. ב-Cloud Shell, מגדירים משתנה סביבה לשם של מאגר הצמתים של שרת Windows:

    export NODE_POOL_NAME=windows-server-pool
    
  2. יוצרים מאגר צמתים של GKE Windows Server:

    gcloud container node-pools create $NODE_POOL_NAME \
        --cluster $GKE_CLUSTER_NAME \
        --machine-type n1-standard-2 \
        --image-type WINDOWS_LTSC_CONTAINERD \
        --windows-os-version=ltsc2022 \
        --num-nodes 2 \
        --no-enable-autoupgrade \
        --metadata sysprep-specialize-script-ps1="iex((New-Object System.Net.WebClient).DownloadString('$AD_JOIN_SERVICE_URL'))"
    

    אם אתם מתכננים לפרוס את האפליקציות שמופעלות בקונטיינרים ב-Windows Server 2019, צריך לשנות את הפרמטר --windows-os-version ל-ltsc2019.

    מפתח המטא-נתונים sysprep-specialize-script-ps1 הוא מפתח מובנה שמפנה לסקריפט PowerShell שמופעל במהלך השלב GCESysprep, לפני שהמופע מופעל בפעם הראשונה.

    ה-cmdlet‏ iex מוריד את סקריפט PowerShell משירות צירוף הדומיין של Active Directory שפרסתם ב-Cloud Run. לאחר מכן, הסקריפט מופעל ומצטרף למופע החדש בדומיין Active Directory.

    הפרמטר --no-enable-autoupgrade משבית את השדרוג האוטומטי של הצמתים לכל הצמתים במאגר. הסיבה לכך היא ששדרוג קובץ האימג' של Windows בצומת יכול לגרום לחוסר תאימות בין גרסת Windows Server של הצומת לבין גרסת Windows Server של ה-Pod. מידע נוסף זמין במאמר שדרוג של מאגרי צמתים ב-Windows Server.

    אחרי שכל צומת נוצר, הסקריפט של domain-join PowerShell מצרף את הצומת לדומיין.

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

    kubectl get node \
    -l cloud.google.com/gke-nodepool=$NODE_POOL_NAME \
    -o custom-columns=":metadata.name" --no-headers \
        | xargs -I{} gcloud compute instances get-serial-port-output {} --port 1 \
        | grep "sysprep-specialize-script-ps1:.*success" --ignore-case
    

    אם הצמתים הצטרפו לדומיין, הפלט יהיה כזה:

    timestamp GCEMetadataScripts: sysprep-specialize-script-ps1: Successfully registered computer account.
    timestamp GCEMetadataScripts: sysprep-specialize-script-ps1: Computer successfully joined to domain
    
    Specify --start=152874 in the next get-serial-port-output invocation to get only the new output starting from here.
    

    כדי לראות את הפלט המלא של הסקריפט, מסירים את .*success מהפקודה grep.

מתן גישה ל-Pods של GKE ל-Active Directory

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

  • Kerberos ‏ (UDP/88, ‏ TCP/88)
  • NTP (UDP/123)
  • ‫RPC ‏ (TCP/135, ‏ TCP/49152-65535)
  • LDAP ‏ (UDP/389, ‏ TCP/389)
  • SMB (UDP/445, TCP/445)
  • ‫LDAP GC‏ (TCP/3268)
  • Active Directory Web Services (TCP/9389)‎

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

אם אתם משתמשים בשירות מנוהל ל-Microsoft Active Directory (Microsoft AD מנוהל), אתם יכולים לדלג על התהליך הזה.

  1. ב-Cloud Shell, מקבלים את טווח כתובות ה-IP של ה-Pods באשכול GKE:

    CLUSTER_IP_RANGE=`gcloud container clusters describe $GKE_CLUSTER_NAME --format="value(clusterIpv4Cidr)"`
    
  2. יוצרים כלל של חומת אש שנותן ל-Pods של GKE גישה ל-Active Directory:

    gcloud compute firewall-rules create allow-gke-pods-to-ad \
        --network $NETWORK_NAME \
        --allow udp:88,tcp:88,udp:123,tcp:135,tcp:49152-65535,udp:389,tcp:389,udp:445,tcp:445,tcp:3268,tcp:9389 \
        --source-ranges=$CLUSTER_IP_RANGE \
        --target-tags DC-TAG
    

    מחליפים את DC-TAG בתג הרשת שהוקצה למכונות הווירטואליות של בקרי הדומיין.

הגדרת GKE לתמיכה בשימוש ב-gMSA

כדי להשתמש ב-gMSA בצמתי Windows Server, צריך ליצור את אובייקט ה-gMSA ב-Active Directory, ליצור משאב gMSA תואם ב-GKE ולאפשר ל-Pods שנוצרו לאחרונה לאחזר את פרטי הכניסה שלהם ל-gMSA.

  1. ב-Cloud Shell, מורידים ומריצים את סקריפט ה-webhook של gMSA:

    export K8S_GMSA_DEPLOY_DOWNLOAD_REV=b685a27adc40511bb5756dfb3ada2e8578ee72e1
    curl https://raw.githubusercontent.com/kubernetes-sigs/windows-gmsa/$K8S_GMSA_DEPLOY_DOWNLOAD_REV/admission-webhook/deploy/deploy-gmsa-webhook.sh -o deploy-gmsa-webhook.sh && chmod +x deploy-gmsa-webhook.sh
    
    ./deploy-gmsa-webhook.sh --file ./gmsa-webhook.yml --namespace gmsa-webhook --overwrite
    rm -drf gmsa-webhook-certs
    

    הסקריפט מוסיף את מניפסט הגדרת המשאב המותאם אישית (CRD) של gMSA לאשכול GKE ומבצע פריסה של webhook שמספק את המפרטים של gMSA ל-Pods. עכשיו אתם יכולים לאחסן את המפרטים של gMSA באשכול ולהגדיר gMSA לפודים ולמאגרים.

    למידע נוסף על Kubernetes ו-gMSA, קראו את המאמר הגדרת GMSA לפודים ולמאגרים של Windows.

אשכול GKE מוכן עכשיו להפעלת אפליקציות Windows שנדרש בהן שימוש ב-gMSA. לדוגמה, אתם יכולים להריץ אפליקציית אינטרנט של ASP.NET בצמתי Windows Server. אתם יכולים להגדיר את האפליקציה כך שהמשתמשים יתחברו אליה באמצעות אימות Windows, או שהאפליקציה תשתמש ב-gMSA של ה-Pod כדי לגשת לשיתוף רשת מרוחק או למסד נתונים של SQL Server.

שילוב עם Active Directory

לאחר מכן, יוצרים gMSA לאפליקציית האינטרנט ASP.NET ב-Active Directory, מגדירים איך אפשר להשתמש בו ומי יכול להשתמש בו, ואז מוסיפים את ההגדרה שלו ל-GKE.

התחברות והפעלת PowerShell

  1. מתחברים ל-VM‏ gmsa-dev-vm.
  2. מתחברים ל-Windows באמצעות חשבון Active Directory שיש לו הרשאה ליצור gMSA.

    החשבון צריך להיות חבר בקבוצה Domain Admins או להיות מסוגל ליצור אובייקטים מסוג msDS-GroupManagedServiceAccount. מידע נוסף זמין במאמר בנושא הקצאת חשבונות שירות מנוהלים לקבוצות.

    אם אתם משתמשים בשירות מנוהל ל-Microsoft AD, החשבון שלכם צריך להיות חבר בקבוצה Cloud Service Managed Service Account Administrators. מידע נוסף זמין במאמר בנושא הענקת הרשאות ניהול לחשבונות שירות מנוהלים.

  3. מקלידים 15 כדי לצאת מהתפריט לשורת הפקודה (PowerShell).

התקנה של זמן ריצה של קונטיינר

כדי ליצור ולהריץ קונטיינרים של Windows, ב-Windows Server 2022 צריך סביבת זמן ריצה של קונטיינר, כמו Docker Community Edition (CE). מידע נוסף על התקנת זמן ריצה של קונטיינר ב-Windows Server זמין במאמר תחילת העבודה: הכנת Windows לקונטיינרים במסמכי Microsoft.

אם יצרתם את מכונת ה-VM לפיתוח באמצעות תמונת windows-2019-core-for-containers, אתם יכולים לדלג על התהליך הבא, כי Docker כבר מותקן בתמונה.

  1. מתקינים את Docker Community Edition (CE):

    Invoke-WebRequest -UseBasicParsing -o install-docker-ce.ps1 `
       "https://raw.githubusercontent.com/microsoft/Windows-Containers/Main/helpful_tools/Install-DockerCE/install-docker-ce.ps1"
    .\install-docker-ce.ps1
    

    אם במהלך תהליך ההתקנה חיבור שולחן העבודה המרוחק נסגר, צריך להתחבר מחדש ל-VM.

  2. מחכים שתהליך ההתקנה יסתיים ומקלידים exit כדי לסגור את חלון PowerShell החדש.

  3. מקלידים 15 כדי לצאת מהתפריט לשורת הפקודה (PowerShell).

יצירת מפתח בסיס ב-KDS

לפני שיוצרים gMSA, צריך לוודא שבבקר הדומיין של Active Directory יש מפתח שורש של Key Distribution Services ‏ (KDS). ‫Active Directory משתמש במפתח הבסיס של KDS כדי ליצור סיסמאות ל-gMSA.

אם אתם משתמשים בשירות מנוהל ל-Microsoft AD, אתם יכולים לדלג על התהליך הבא כי שירות מנוהל ל-Microsoft AD יוצר את מפתח הבסיס של KDS כשאתם יוצרים את הדומיין.

  1. ב-gmsa-dev-vm, בודקים אם כבר יש ב-Active Directory את מפתח הבסיס של KDS:

    Get-KdsRootKey
    

    הפקודה הזו מציגה את מזהה המפתח, אם הוא קיים.

  2. אם לא קיבלתם מזהה מפתח בתגובה, צרו את המפתח:

    Add-KdsRootKey -EffectiveTime ((get-date).addhours(-10))
    

יצירת חשבון gMSA

כשיוצרים gMSA, צריך לספק את שמות המחשבים שיש להם גישה ל-gMSA. השיטה המומלצת לשמירה על האבטחה היא להעניק הרשאה לחשבון gMSA רק למופעים שבהם האפליקציה פועלת. כשיוצרים מאגר של צומתי Windows Server שמצורפים לדומיין, נוצרת קבוצת Active Directory חדשה למחשבים של מאגר הצמתים. השם של הקבוצה זהה לשם של קבוצת מופעי מכונה מנוהלים (MIG) ש-GKE יוצרת עבור מאגר הצמתים.

  1. ב-PowerShell, מגדירים משתנים עבור Google Cloud מזהה הפרויקט, שם האשכול שם מאגר הצמתים של Windows, שם ה-gMSA ושם הדומיין של AD:

    $ProjectId = "PROJECT-ID"
    $GkeClusterName = "cluster-1"
    $PermittedNodePool = "windows-server-pool"
    $GmsaName = "WebApp-01"
    $AdDomain = (Get-ADDomain).DNSRoot
    

    מחליפים את PROJECT-ID במזהה הפרויקט ב- Google Cloud .

  2. מגדירים את ההגדרה של האשכול לכלי gcloud:

    gcloud config set project $ProjectId
    gcloud config set compute/zone "ZONE-NAME"
    

    מחליפים את ZONE-NAME באזור שבו פרסתם את אשכול GKE.

  3. מאחזרים את שם הדומיין של קבוצת Active Directory שנוצרה עבור מאגר הצמתים:

    $InstanceGroupUri = gcloud container node-pools describe $PermittedNodePool `
        --cluster $GkeClusterName `
        --format="value(instanceGroupUrls)"
    $InstanceGroupName=([System.Uri]$instanceGroupUri).Segments[-1]
    $GroupDN=(Get-ADGroup -Filter "name -eq '$InstanceGroupName'")
    
    Write-Host $GroupDN.DistinguishedName
    
  4. יוצרים את חשבון ה-gMSA:

    New-ADServiceAccount -Name $GmsaName `
    -DNSHostName "$GmsaName.$AdDomain" `
    -PrincipalsAllowedToRetrieveManagedPassword $GroupDN
    
  5. מוודאים שחשבון ה-gMSA נוצר:

    Get-ADServiceAccount -Identity $GmsaName
    

    אם חשבון ה-gMSA נוצר, הפלט ייראה כך:

    DistinguishedName : CN=WebApp01,CN=Managed Service Accounts,DC=corp,DC=example,DC=com
    Enabled           : True
    Name              : WebApp01
    ObjectClass       : msDS-GroupManagedServiceAccount
    ObjectGUID        : 5afcff45-cf15-467d-aaeb-d65e53288253
    SamAccountName    : WebApp01$
    SID               : S-1-5-21-780151012-601164977-3226406772-2103
    UserPrincipalName :
    

הוספת ה-gMSA ל-GKE

כדי להשתמש ב-gMSA באשכול Kubernetes, צריך ליצור משאב gMSA ב-Kubernetes ולהגדיר אילו מרחבי שמות וחשבונות מורשים להשתמש בו.

  1. ב-gmsa-dev-vm, ב-PowerShell, מתקינים את הכלי git:

    Install-Script -Name Install-Git -Force
    Install-Git.ps1
    $env:Path += ";c:\program files\git\bin"
    
  2. מתקינים את הכלי kubectl:

    $version = (Invoke-WebRequest -UseBasicParsing -Uri "https://dl.k8s.io/release/stable.txt").Content
    $uri = "https://dl.k8s.io/release/$version/bin/windows/amd64/kubectl.exe"
    New-Item -Type Directory $env:ProgramFiles\kubectl
    Start-BitsTransfer -Source $uri -Destination $env:ProgramFiles\kubectl\
    $env:Path += ";$env:ProgramFiles\kubectl"
    
  3. מתקינים את הקובץ הבינארי של gke-gcloud-auth-plugin:

    gcloud components install gke-gcloud-auth-plugin
    

    מחכים כמה דקות עד שתהליך ההתקנה יסתיים.

  4. מאתחלים את הכלי kubectl באמצעות פרטי הכניסה של אשכול GKE:

    gcloud container clusters get-credentials $GkeClusterName
    
  5. יוצרים את קובץ gMSA credentials specification:

    Install-Module CredentialSpec -Force
    $GmsaName = $GmsaName.ToLower()
    $CredSpecFile = Join-Path $env:TEMP "$GmsaName-credspec.json"
    New-CredentialSpec -AccountName $GmsaName -Path $CredSpecFile
    
    $CredentialsSpec=@{
    "apiVersion" = "windows.k8s.io/v1";
    "kind" = "GMSACredentialSpec";
    "metadata" = @{"name" = $GmsaName}
    "credspec" = (Get-Content $CredSpecFile | ConvertFrom-Json)
    }
    
    $CredentialsSpec | ConvertTo-Json -Depth 5 | Set-Content $CredSpecFile
    

    השם של משאב GMSACredentialSpec ב-Kubernetes חייב להשתמש באותיות קטנות.

    הסקריפט משנה את האותיות הרישיות במשתנה $GmsaName כדי לעמוד במגבלה הזו.

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

  6. מוסיפים את מפרט פרטי הכניסה של gMSA לאשכול GKE:

    kubectl apply -f $CredSpecFile
    
  7. משכפלים את המאגר ב-GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    cd kubernetes-engine-samples/windows/aspnet-gmsa/
    
  8. מוסיפים את אובייקטי ה-RBAC של gMSA לאשכול:

    kubectl apply -f gmsa-rbac-webapp-01.yaml
    

    הפקודה gmsa-rbac-webapp-01.yaml יוצרת אובייקט RBAC מסוג ClusterRole עבור gMSA, ואז מקשרת את תפקיד האשכול החדש לחשבון השירות שמוגדר כברירת מחדל במרחב השמות default. אם אתם פורסים את האפליקציה במרחב שמות אחר, צריך לערוך את הקובץ gmsa-rbac-webapp-01.yaml ולשנות את מרחב השמות של קשירת התפקיד ושל חשבון השירות.

פריסה ושימוש באפליקציית האינטרנט

בשלב הבא, בונים את אפליקציית האינטרנט ואת קובץ האימג' של הקונטיינר, פורסים את קובץ האימג' החדש של הקונטיינר באשכול GKE ופותחים את אפליקציית האינטרנט בדפדפן כדי לוודא שאפשר להשתמש ב-gMSA באפליקציית האינטרנט.

פיתוח ופריסה של אפליקציית האינטרנט ב-ASP.NET

  1. ב-gmsa-dev-vm, ב-PowerShell, מגדירים משתנים למיקום ברישום, לשם ברישום ולתג התמונה:

    $RegistryLocation = "LOCATION-docker.pkg.dev"
    $ProjectsRegistry = "$RegistryLocation/$ProjectId"
    $ImageTag = "$ProjectsRegistry/windows-container-images/test-gmsa:latest"
    

    מחליפים את LOCATION במיקום שבו יצרתם את המאגר ב-Artifact Registry.

  2. יוצרים את קובץ האימג' של הקונטיינר:

    docker build -t $ImageTag -f Dockerfile-WINDOWS_LTSC2022 .
    

    כדי ליצור קובצי אימג' של קונטיינרים ל-Windows Server 2019, מגדירים את הערך של הפרמטר -f ל-Dockerfile-WINDOWS_LTSC2019.

  3. מעבירים את קובץ האימג' של הקונטיינר ל-Artifact Registry:

    gcloud auth configure-docker $RegistryLocation --quiet
    docker push $ImageTag
    
  4. מורידים את קובץ ה-YAML של האפליקציה ומעדכנים אותו בהגדרות של gMSA:

    $ApplicationYaml = Join-Path $env:TEMP "gmsa-test-webapp-01.yaml"
    
    (Get-Content gmsa-test-webapp-01.yaml.template) `
    -Replace '\${image_path}',$ImageTag | `
    Set-Content $ApplicationYaml
    

    אם יוצרים צמתים של Windows Server 2019 ב-GKE, צריך לערוך את קובץ ה-YAML של האפליקציה ולשנות את הערך של cloud.google.com/gke-windows-os-version מ-2022 ל-2019.

  5. פורסים את אפליקציית האינטרנט באשכול GKE:

    kubectl apply -f $ApplicationYaml
    

מוודאים שאפליקציית האינטרנט של ASP.NET פועלת

אפליקציית האינטרנט נחשפת לאינטרנט באמצעות שירות LoadBalancer. לפני שתוכלו לעבור לאפליקציית האינטרנט, תצטרכו להמתין עד שה-Pod והשירות ייפרסו. פריסת ה-Pod עשויה להימשך כמה דקות כי קובצי האימג' של קונטיינרים של Windows Server Core הם גדולים (קובץ האימג' של אפליקציית האינטרנט גדול מ-7GB), ולוקח זמן עד שהצומת מוריד את קובץ האימג' ויוצר את הקונטיינר.

  1. בודקים את הסטטוס של ה-Pod:

    kubectl get pods --selector=app=gmsa-test-webapp-01
    

    חוזרים על הפקודה עד שהפלט מראה שהסטטוס של ה-Pod הוא Running:

    NAME                                   READY     STATUS    RESTARTS   AGE
    gmsa-test-webapp-01-76c6d64975-zrtgq   1/1       Running   0          28s
    

    אם הסטטוס של ה-Pod נשאר Pending ולא משתנה ל-ContainerCreating או ל-Running, צריך לבדוק את תמונת המקור של צומת Windows כדי לוודא שהוא Windows Server 2022. אפשר גם לבדוק את טבלת מיפוי הגרסאות כדי לראות איך גרסאות GKE ממופות לגרסאות Windows Server. אם הגרסאות לא תואמות, משכפלים את הקובץ Dockerfile-WINDOWS_LTSC2022, מגדירים את קובץ אימג' של קונטיינר בקובץ החדש כך שתתאים לגרסת Windows Server של הצמתים, ואז חוזרים על השלבים לבנייה ולפריסה של אפליקציית האינטרנט ASP.NET.

  2. בודקים את הסטטוס של השירות:

    kubectl get service --selector=app=gmsa-test-webapp-01
    

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

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP      PORT(S)        AGE
    gmsa-test-webapp-01    LoadBalancer   10.44.2.112   external-ip    80:32233/TCP   17s
    
  3. שימו לב לערך external-ip בפלט, כי תצטרכו אותו בהמשך.

הרצת בדיקות מקדימות באפליקציית האינטרנט ASP.NET

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

  1. בדפדפן, נכנסים לכתובת http://EXTERNAL-IP כדי לראות את אפליקציית האינטרנט לבדיקת gMSA.

    מחליפים את EXTERNAL-IP בכתובת ה-IP שקיבלתם בתהליך הקודם.

  2. גוללים לקטע Preflight Checks (בדיקות לפני הפעלה) ולוחצים על הלחצן Run Preflight Checks (הפעלת בדיקות לפני הפעלה) כדי לוודא שכל הבדיקות עברו בהצלחה.

    אם הבדיקות עוברות, הפלט הוא:

    [PASS]  Active Directory RSAT PowerShell Module Installed
    
    [PASS]  IIS Document Root found
            C:\inetpub\wwwroot\
    
    [PASS]  PowerShell Scripts Folder found
            C:\inetpub\wwwroot\Powershell\
    
    [PASS]  Container Diagnostic Script found
            C:\inetpub\wwwroot\Powershell\\containerDiag.ps1
    
    [PASS]  Domain Diagnostic Script found
            C:\inetpub\wwwroot\Powershell\\domainDiag.ps1
    
    [RES]   Result: PASS   All checks passed! Please proceed to run the different tests.
    
  3. גוללים לקטע Container Information ולוחצים על הכפתור Run Script. מוודאים שמוצג מידע על הקונטיינר ועל הצומת, ושלא מוצגת שגיאה.

שימוש ב-gMSA בקונטיינרים של Windows

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

אימות הגדרות מאגר ה-gMSA

  • גוללים לקטע Domain Connectivity (קישוריות לדומיין), מקלידים את השם של חשבון ה-gMSA‏ (WebApp-01) בתיבה Account Name (שם החשבון) ולוחצים על Run Script (הרצת הסקריפט). ממתינים כמה שניות עד שהבדיקות יסתיימו.

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

    *****   C O N T A I N E R   D I A G N O S T I C S   *****
    
    [INFO]  Starting script execution at 01-05-2021-13:53:11
    
    [INFO]  Using gMSA: WebApp-01
    
    [PASS]  gMSA Account found in Active Directory
            CN=WebApp01,CN=Managed Service Accounts,DC=corp,DC=example,DC=com
    
    [PASS]  This Container (gmsa-test-webapp01-5bc485b8d5-9lbb7) is running on a GKE Windows Node that is authorized to use WebApp01
    
    [INFO]  Script execution complete at 01-05-2021-13:53:12
    
    *****      E N D   O F   D I A G N O S T I C S      *****
    

    הסקריפט משתמש בשני cmdlets של PowerShell כדי לבדוק את הגישה ל-gMSA:

    • ‫Get-ADServiceAccount: ה-cmdlet הזה מאחזר מידע על gMSA. אם הפקודה הזו פועלת בהצלחה, סימן שהמאגר פועל עם gMSA תקין.
    • ‫Test-ADServiceAccount: ה-cmdlet הזה בודק אם הוא יכול לאחזר את פרטי הכניסה של gMSA. אם הפקודה cmdlt פועלת בהצלחה, סימן שהקונטיינר פועל בצומת Windows Server שיש לו הרשאה לגשת לפרטי הכניסה של gMSA.

כניסת משתמשים באמצעות אימות של Windows

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

    אחרי שתעברו את תהליך האימות, יוצג הדף מאובטח. מוודאים שמופיעים שלושת הקטעים הבאים:

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

בנוסף לתמיכה ב-Integrated Windows Authentication, אפליקציית האינטרנט של ASP.NET יכולה להשתמש ב-gMSA שלה לאימות כשמתבצעת קריאה לשרתים מרוחקים. באמצעות gMSA, אפליקציית האינטרנט וכל אפליקציה אחרת שפועלת במאגר Windows יכולות לגשת למשאבים ברשת שדורשים אימות של Windows, כמו מופעים של SQL Server ושיתופי רשת מבוססי SMB.

פתרון בעיות

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

שיקולים נוספים לגבי אפליקציות בסביבת ייצור

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

שיקולים לגבי מאגר צמתים של Windows Server

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

במדריך הזה תיצרו מאגר צמתים יחיד של Windows Server לאירוח האפליקציות שלכם. עם זאת, יכול להיות שתרצו ליצור כמה מאגרי צמתים של Windows Server באשכול שלכם – למשל, מאגר צמתים אחד עם Persistent Disk מסוג HDD ומאגר צמתים אחר עם Persistent Disk מסוג SSD. אם אתם צריכים לפרוס את האפליקציה לכמה מאגרי צמתים, אתם יכולים לספק מערך של אובייקטים של קבוצות Active Directory לפרמטר PrincipalsAllowedToRetrieveManagedPassword כשיוצרים את gMSA באמצעות פקודת ה-cmdlet‏ New-ADServiceAccount.

שיקולים לגבי gMSA ושם שירות ראשי (SPN)

אם האפליקציה שלכם דורשת אימות משתמשים באמצעות Kerberos (לדוגמה, כדי לתמוך בהעברת הרשאות), אתם צריכים לגשת לאפליקציה באמצעות DNS בהתאמה אישית ולהגדיר את חשבון השירות המנוהל עם שם שירות ראשי (SPN). לדוגמה, אם מאזן העומסים חושף את האפליקציה ב-GKE דרך https://my-web-app/, צריך ליצור SPN בשם HTTP/my-web-app באחת מהדרכים הבאות:

  • אם מדובר ב-gMSA חדש, יוצרים את ה-gMSA עם ה-SPN הנדרשים. לדוגמה:

    New-ADServiceAccount -Name $GmsaName `
    -DNSHostName "$GmsaName.$AdDomain" `
    -PrincipalsAllowedToRetrieveManagedPassword $Groups `
    -ServicePrincipalNames "HTTP/my-web-app", "HTTP/my-web-app.$AdDomain"
    
  • אם יש לכם gMSA קיים, אתם יכולים לבצע קריאה ל-Set-ADServiceAccount כדי להוסיף את ה-SPN הנדרש ל-gMSA. לדוגמה:

    Set-ADServiceAccount $GmsaName -ServicePrincipalNames @{Add="HTTP/my-web-app", "HTTP/my-web-app.$AdDomain"}
    

בהתאם להגדרת ה-DNS, יכול להיות שתצטרכו גם ליצור SPN עבור HTTP/www.my-web-app ו-HTTP/www.my-web-app.$AdDomain.

בפרוטוקולים שאינם HTTP, כמו שירות WCF שמוגדר עם TCP binding ו-Windows Authentication, יכול להיות שתצטרכו ליצור סוגים אחרים של SPN, כמו HOST/ SPN.

בחירת הזהות של מאגר האפליקציות של IIS

אפליקציות אינטרנט של ASP.NET פועלות ב-Windows בשרת האינטרנט של IIS. ב-IIS, מגדירים קבוצות של אפליקציות אינטרנט שמשתפות את אותו תהליך. הקבוצה הזו נקראת מאגר אפליקציות. כל מאגר אפליקציות מתארח בתהליך ייעודי שנקרא w3wp. מאגרי אפליקציות של IIS מספקים הגדרת תהליך, למשל אם התהליך הוא תהליך של 32 ביט או 64 ביט, והם מספקים את הזהות של התהליך. כשמריצים אפליקציית אינטרנט במאגר Windows, מגדירים את זהות התהליך של מאגר האפליקציות לשימוש בחשבון המובנה Network Service.

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

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

הסרת המשאבים

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

  1. במסוף Google Cloud , נכנסים לדף Manage resources.

    כניסה לדף Manage resources

  2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
  3. כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.

הסרת משאבים ספציפיים

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

ביטול השינויים ב-Active Directory

  1. מתחברים למכונה הווירטואלית של הפיתוח ונכנסים בתור משתמש עם גישת אדמין לדומיין Active Directory.
  2. במכונה הווירטואלית gmsa-dev-vm, אם PowerShell עדיין לא פתוח, פותחים אותו:

    PowerShell
    
  3. מוחקים את חשבון ה-gMSA:

    Remove-ADServiceAccount -Identity "WebApp-01" -Confirm:$false
    

מחיקת משאבים בענן

  1. במסוף Google Cloud , מפעילים את Cloud Shell.

    הפעלת Cloud Shell

  2. מאתחלים את הסביבה של gcloud:

    gcloud config set project PROJECT-ID
    gcloud config set compute/zone ZONE-NAME
    gcloud config set artifacts/location LOCATION
    

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT-ID: מזהה הפרויקט ב- Google Cloud .
    • ‫ZONE-NAME: האזור שבו פרסתם את אשכול GKE ואת מכונת הפיתוח.
    • ‫LOCATION: האזור שבו פרסתם את מאגר Artifact Registry.
  3. מוחקים את המכונה הווירטואלית לפיתוח:

    gcloud compute instances delete gmsa-dev-vm --quiet
    
  4. מוחקים את חשבון השירות:

    gcloud iam service-accounts delete dev-vm@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com --quiet
    
  5. מוחקים את אשכול ה-GKE:

    gcloud container clusters delete cluster-1 --quiet
    
  6. אם יצרתם כלל חומת אש עבור בקרי Active Directory, מחקו אותו:

    gcloud compute firewall-rules delete allow-gke-pods-to-ad --quiet
    
  7. מחיקת מאגר Docker ב-Artifact Registry:

    gcloud artifacts repositories delete windows-container-images --quiet
    

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

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