התקנה של ספק Google Kubernetes Symphony

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

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

מידע נוסף על Symphony Connectors for Google Cloudזמין במאמר Integrate IBM Spectrum Symphony withGoogle Cloud.

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

כדי להתקין את ספק Symphony ל-GKE, צריכים להיות לכם המשאבים הבאים:

התפקידים הנדרשים

כדי לקבל את ההרשאות שדרושות להתקנת האופרטור ולניהול של Podים של Symphony, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-IAM הבאים בפרויקט:

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

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

התקנת האופרטור של Kubernetes

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

יצירת תמונת המפעיל

כדי ליצור ולפרוס את המניפסטים של Kubernetes לאופרטור, צריך קודם ליצור את קובץ אימג' של קונטיינר של האופרטור. המניפסטים כוללים את Custom Resource Definition ‏ (CRD) שבו האופרטור משתמש כדי לנהל את Symphony. כדי להשיג את התמונה, אפשר ליצור אותה מהמקור.

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

  1. משכפלים את מאגר symphony-gcp-connector מ-GitHub:

    git clone https://github.com/GoogleCloudPlatform/symphony-gcp-connector.git

  2. מנווטים לספרייה k8s-operator:

    cd symphony-gcp-connector/k8s-operator

  3. מגדירים את משתני הסביבה לשם התמונה, למאגר ולתג:

    export IMAGE="gcp-symphony-operator"
export REGISTRY="IMAGE_REPO"
export TAG="TAG"

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

    • ‫IMAGE_REPO: מאגר התמונות שבו מאוחסנת תמונת המפעיל. לדוגמה, אפשר להשתמש ב-Artifact Registry כדי לאחסן תמונות של אופרטורים. מידע נוסף זמין במאמר יצירת מאגרי Docker.
    • ‫TAG: התג של תמונת האופרטור, לדוגמה, 0.0.1.

  4. יוצרים את קובץ האימג' של האופרטור ושולחים אותו:

    bash -c 'docker buildx build --platform linux/amd64 -t $IMAGE:$TAG -t $IMAGE:latest -t $REGISTRY/$IMAGE:$TAG -t $REGISTRY/$IMAGE:latest .'
bash -c 'docker push $REGISTRY/$IMAGE:$TAG && docker push $REGISTRY/$IMAGE:latest'

הגדרת מניפסטים של אופרטורים

אחרי שיש לכם את תמונת האופרטור, אתם צריכים ליצור ולהגדיר את מניפסטים של Kubernetes.

  1. כדי ליצור את קובצי המניפסט, משתמשים בפקודה export-manifests עם תמונת האופרטור:

    docker run --rm gcp-symphony-operator:latest export-manifests > manifests.yaml

  2. פותחים את הקובץ manifests.yaml בכלי לעריכת טקסט לבחירתכם.

  3. בקטע spec.template.spec.containers, מאתרים את השדה image ומעדכנים את הערך שלו לנתיב המלא של התמונה שהעליתם למאגר.

    ...
containers:
- image: IMAGE_REPO/gcp-symphony-operator:TAG
  name: manager
...

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

    • ‫IMAGE_REPO: הנתיב למאגר התמונות שאליו העליתם את תמונת האופרטור.

    • ‫TAG: התג שהקציתם לתמונת האופרטור כשבניתם אותה.

  4. אופציונלי: אפשר גם לשנות את הערך של imagePullPolicy כך שיתאים לשיטות שלכם לניהול אשכולות.

החלת המניפסטים של האופרטור

אחרי שמגדירים את קובצי המניפסט, מחילים אותם על אשכול Kubernetes. אפשר להחיל את המניפסטים באמצעות kubectl או Cluster Toolkit.

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

    kubectl apply -f manifests.yaml

  • ‫Cluster Toolkit: אם התשתית של GKE מנוהלת על ידי Cluster Toolkit, צריך להוסיף מקור modules/management/kubectl-apply לתוכנית ה-blueprint של GKE כדי להחיל את המניפסטים. הנה דוגמה להגדרה, בהנחה שהקובץ manifests.yaml נמצא באותה ספרייה כמו תוכנית ה-GKE:

      -   id: symphony_operator_install
      source: modules/management/kubectl-apply
      use: [gke_cluster]
      settings:
      apply_manifests:
        -   source: $(ghpc_stage("manifests.yaml"))

    מידע נוסף זמין במאמר סקירה כללית על Cluster Toolkit.

טעינה של משתני הסביבה של המארח

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

source INSTALL_FOLDER/profile.platform

מחליפים את הערך ב-INSTALL_FOLDER בנתיב לתיקיית ההתקנה. נתיב תיקיית ההתקנה של Symphony שמוגדר כברירת מחדל הוא /opt/ibm/spectrumcomputing. עם זאת, אם התקנתם את Symphony במקום אחר, אתם צריכים להשתמש בנתיב הנכון לסביבה שלכם.

הפקודה הזו מפעילה את הסקריפט profile.platform, שמייצא משתני סביבה חיוניים כמו $EGO_TOP ו-$HF_TOP, ומוסיף את כלי שורת הפקודה של Symphony אל PATH של המעטפת. כדי לוודא שהסביבה מוגדרת בצורה נכונה, צריך להריץ את הפקודה הזו בכל סשן חדש של מסוף.

התקנת הפלאגין של הספק

כדי לשלב את ספק GKE עם מפעל המארחים של Symphony, מתקינים את פלאגין הספק שנבנה מראש מחבילת ה-RPM או בוחרים לבנות את הספק מקוד המקור.

התקנת פלאגין מוכן מראש של ספק

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

  1. מוסיפים את מאגר yum עבור Google Cloud Symphony Connectors:

    sudo tee /etc/yum.repos.d/google-cloud-symphony-connector.repo << EOM
[google-cloud-symphony-connector] name=Google Cloud Symphony Connector
baseurl=https://packages.cloud.google.com/yum/repos/google-cloud-symphony-connector-x86-64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg
       https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOM

  2. מתקינים את חבילת הספק ל-GKE:

    sudo yum install -y hf-gcpgke-provider.x86_64

התקנת ה-RPM ממקמת באופן אוטומטי את קובצי ההפעלה והסקריפטים של הספק בספריות הנכונות בשביל שירות המפעל של מארח Symphony. אחרי ההתקנה, מבנה הספריות של פלאגין הספק יופיע כך בנתיב $HF_TOP/$HF_VERSION/providerplugins/gcpgke:

├── bin
│   ├── hf-gke
│   └── README.md
└── scripts
    ├── getAvailableTemplates.sh
    ├── getRequestStatus.sh
    ├── getReturnRequests.sh
    ├── requestMachines.sh
    └── requestReturnMachines.sh

בניית הספק מקוד המקור

כדי ליצור ולהתקין את קובץ ההפעלה של ה-CLI בספרייה bin של ספריית הפלאגין של הספק, פועלים לפי השלבים הבאים:

  1. משכפלים את מאגר symphony-gcp-connector מ-GitHub:

    git clone https://github.com/GoogleCloudPlatform/symphony-gcp-connector.git

  2. מנווטים לספרייה hf-provider:

    cd PROJECT_ROOT/hf-provider

    מחליפים את PROJECT_ROOT בנתיב לספרייה ברמה העליונה שמכילה את הספרייה hf-provider, לדוגמה /home/user/symphony-gcp-connector.

  3. אם לא מותקנת אצלכם גרסת uv, צריך להתקין אותה:

    pip install uv

  4. יוצרים סביבה וירטואלית של Python באמצעות מנהל חבילות Python‏ uv:

    uv venv

  5. מפעילים את הסביבה הווירטואלית:

    source .venv/bin/activate

  6. מתקינים את יחסי התלות הנדרשים בפרויקט:

    uv pip install .

  7. מתקינים את PyInstaller, שמאגד את אפליקציית Python לקובץ הפעלה עצמאי:

    uv pip install pyinstaller

  8. יוצרים את hf-gke CLI לאשכולות של Google Kubernetes Engine:

    uv run pyinstaller hf-gke.spec --clean

  9. כדי לוודא שההתקנה בוצעה, מריצים את הפקודה --help עבור קובץ הפעלה. יכול להיות שתופיע שגיאה אם לא תגדירו את משתני הסביבה הנדרשים.

    dist/hf-gke --help

  10. אם יוצרים את הספק באופן ידני, צריך ליצור ספריות של פלאגין ספק עבור הקובץ הבינארי והסקריפטים:

    mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts

  11. מעתיקים את הקובץ הבינארי ואת הסקריפטים אל ספריות הפלאגין של הספק.hf-gke קובץ ה-hf-gke הבינארי נמצא בספרייה dist/ שנוצרה על ידי PyInstaller, והסקריפטים נמצאים בספרייה scripts/gcpgke/:

    cp dist/hf-gke $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin/
cp scripts/gcpgke/* $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts/

    אחרי ההתקנה, מבנה הספריות של פלאגין הספק יופיע כך בנתיב $HF_TOP/$HF_VERSION/providerplugins/gcpgke:

├── bin
│   └── hf-gke
└── scripts
    ├── getAvailableTemplates.sh
    ├── getRequestStatus.sh
    ├── getReturnRequests.sh
    ├── requestMachines.sh
    └── requestReturnMachines.sh

הפעלת פלאגין הספק

כדי להפעיל את פלאגין ספק GKE, צריך לרשום אותו בהגדרות של host factory.

  1. פותחים את הקובץ ${HF_TOP}/conf/providerplugins/hostProviderPlugins.json.

    פקודת המקור מגדירה את משתנה הסביבה $HF_TOP בסביבה שלכם. הערך הוא הנתיב לספריית ההתקנה ברמה העליונה של שירות המפעל של המארח IBM Spectrum Symphony.

  2. מוסיפים קטע של פלאגין ספק gcpgke:

    {
    "name": "gcpgke",
    "enabled": 1,
    "scriptPath": "${HF_TOP}/${HF_VERSION}/providerplugins/gcpgke/scripts/"
}

הגדרת מופע של ספק

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

  1. אם אתם יוצרים את המחבר באופן ידני, אתם צריכים ליצור ספרייה למופע של הספק, למשל: $HF_TOP/conf/providers/gcpgkeinst/.

    משתנה הסביבה $HF_TOP מוגדר בסביבה שלכם אם הפעלתם את הסקריפט profile.platform script. הערך הוא הנתיב לספריית ההתקנה ברמה העליונה של שירות IBM Spectrum Symphony host factory.

  2. בספרייה של מופע הספק ($HF_TOP/conf/providers/gcpgkeinst/), יוצרים או מגדירים את הקובץ gcpgkeinstprov_config.json. הקובץ הזה מכיל את התצורה הראשית של הספק.

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

      cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json

    • אם יצרתם את הספק ממקור, צריך ליצור קובץ gcpgkeinstprov_config.json.

    בדרך כלל צריך להגדיר בקובץ הזה רק את המשתנה GKE_KUBECONFIG, שמגדיר את הנתיב לקובץ תצורה רגיל של kubectl עבור אשכול GKE המשויך. אם לא מציינים נתיב, ברירת המחדל היא kubeconfig בספריית מופע הספק. צריך לוודא שהנתיב הזה מצביע על קובץ תצורה kubectl תקין עבור אשכול Kubernetes שמופע הספק הזה משתמש בו.

    דוגמה להגדרה:

    {
  "GKE_KUBECONFIG": "kubeconfig"
}

    המשתנים הבאים של ההגדרות נתמכים:

    שם המשתנה תיאור ערך ברירת המחדל
    GKE_KUBECONFIG הנתיב לקובץ התצורה שמשמש את פקודת kubectl. ללא
    GKE_CRD_NAMESPACE* ההגדרה מגדירה את מרחב השמות של Kubernetes שבו נוצרים כל המשאבים. gcp-symphony
    GKE_CRD_GROUP* קבוצת המשאבים שמשמשת לזיהוי משאבים מותאמים אישית עבור האופרטור של GKE host factory. accenture.com
    GKE_CRD_VERSION* הגרסה שמשמשת לזיהוי משאבים מותאמים אישית עבור האופרטור של GKE host factory. v1
    GKE_CRD_KIND* השם שניתן להגדרת משאב מותאם אישית שמגדיר בקשה למשאבי מחשוב (pods). GCP Symphony Resource
    GKE_CRD_SINGULAR* משמש בקריאות ל-API כשמפנים למופע של Google Cloud Symphony Resource CR. gcp-symphony-resource
    GKE_CRD_RETURN_REQUEST_KIND* השם שניתן להגדרת משאב מותאם אישית שמגדיר בקשה להחזרת משאבי מחשוב (pods). Machine Return Request
    GKE_CRD_RETURN_REQUEST_SINGULAR* משמש בקריאות ל-API כשמפנים למופע יחיד של משאב מותאם אישית MachineReturnRequest. machine-return-request
    GKE_REQUEST_TIMEOUT משך הזמן בשניות שבו בקשה למישור הבקרה של GKE ממתינה לתגובה. 300
    LOG_LEVEL קובעת את רמת הפירוט של היומן שספק GKE כותב לקובץ היומן. האפשרויות הן CRITICAL, ‏ WARNING, ‏ ERROR, ‏ INFO, ‏ DEBUG. WARNING

  3. באותה ספרייה, יוצרים או מגדירים את הקובץ gcpgkeinstprov_templates.json. בקובץ הזה מוגדרות התבניות של ה-pods שהספק יכול ליצור.

    • אם התקנתם את הפלאגין של הספק באמצעות חבילת ה-RPM, אתם יכולים להעתיק את קובץ התבניות לדוגמה ואז להתאים אותו אישית:

      cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_templates.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_templates.json

    • אם יצרתם את הספק ממקור, צריך ליצור קובץ gcpgkeinstprov_templates.json.

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

      {
    "templates": [
        {
            "templateId": "template-gcp-01",
            "maxNumber": 5000,
            "attributes": {
                "type": [ "String", "X86_64" ],
                "ncores": [ "Numeric", "1" ],
                "ncpus": [ "Numeric", "1" ],
                "nram": [ "Numeric", "2048" ]
            },
            "podSpecYaml": "pod-specs/pod-spec.yaml"
        }
    ]
}

  4. באותה ספרייה, יוצרים קובץ kubeconfig שהוא קובץ תצורה חוקי של kubectl לאשכול Kubernetes.

  5. בספריית מופע הספק, יוצרים או עורכים את הקובץ pod-spec.yaml. הקובץ הזה משמש כתבנית שמגדירה את המפרטים של פלטפורמות הענן של Symphony שנוצרות באשכול GKE.

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

    השלבים ליצירת הקובץ תלויים באופן שבו התקנתם את הספק:

    • אם התקנתם את הספק מחבילת RPM, מעתיקים את קובץ הדוגמה pod-spec.yaml.dist שנכלל בהתקנה:

      cp $HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml.dist
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml

    • אם יצרתם את הספק ממקור, אתם צריכים ליצור ידנית את הספרייה pod-specs ואת הקובץ pod-spec.yaml:

      mkdir -p $HF_TOP/conf/providers/gcpgkeinst/pod-specs touch
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml

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

    ├── gcpgkeinstprov_config.json
├── gcpgkeinstprov_templates.json
├── kubeconfig
└── pod-specs
    └── pod-spec.yaml

הפעלת מופע הספק

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

  1. פותחים את הקובץ $HF_TOP/conf/providers/hostProviders.json.

  2. מוסיפים קטע של מופע ספק gcpgkeinst:

    {
    "name": "gcpgkeinst",
    "enabled": 1,
    "plugin": "gcpgke",
    "confPath": "${HF_CONFDIR}/providers/gcpgkeinst/",
    "workPath": "${HF_WORKDIR}/providers/gcpgkeinst/",
    "logPath": "${HF_LOGDIR}/"
}

    אין צורך להחליף את המשתנים ${HF_CONFDIR}, ${HF_WORKDIR} ו-${HF_LOGDIR} בהגדרה הזו, כי הם משתני סביבה רגילים שמוגדרים אוטומטית על ידי סביבת המארח של IBM Spectrum Symphony.

    כשמגדירים את סשן ה-Shell על ידי הפעלת source command, הסקריפט הזה מגדיר את המשתנים האלה כך שיצביעו על תיקיות המשנה הנכונות בהתקנה של Symphony. לאחר מכן, שירות הפקטורי (factory) של המארח משתמש במשתנים האלה כדי ליצור את הנתיבים המלאים בזמן הריצה.

הפעלת המופע של מגיש הבקשה

כדי לאפשר לרכיב ספציפי של Symphony להשתמש בספק GKE כדי להקצות משאבים, צריך להפעיל אותו עבור מבקש ההרשאות הזה.

  1. פותחים את הקובץ $HF_TOP/conf/requestors/hostRequestors.json.

  2. במופע המתאים של השולח, מוסיפים gcpgkeinst לפרמטר providers:

    "providers": ["gcpgkeinst"],

    ערך הספק צריך להיות זהה לשם הספק שבו אתם משתמשים בקטע הפעלת מופע הספק.

הפעלת שירות המארח

כדי להחיל את שינויי ההגדרות, מפעילים את שירות המארח של המפעל. במכונה הווירטואלית של המארח הראשי של Symphony, נכנסים בתור אדמין האשכול ומפעילים את השירות:

sed -i -e "s|MANUAL|AUTOMATIC|g" $EGO_ESRVDIR/esc/conf/services/hostfactory.xml
egosh user logon -u "SYMPHONY_USERNAME -x "SYMPHONY_PASSWORD
egosh service start HostFactory

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

  • ‫SYMPHONY_USERNAME: שם המשתמש ב-Symphony לאימות.
  • ‫SYMPHONY_PASSWORD: הסיסמה של המשתמש ב-Symphony.

בדיקת מחברים

יוצרים בקשת משאבים כדי לבדוק את הספק ב-GKE.

כדי לעשות זאת, משתמשים באחת מהשיטות הבאות:

  • ממשק משתמש גרפי של Symphony: הוראות ליצירת בקשה למשאב מופיעות במאמר Manually scheduling cloud host requests and returns (תזמון ידני של בקשות להקצאת מארח בענן והחזרת מארח) במסמכי IBM.

  • ‫API בארכיטקטורת REST: כדי ליצור בקשת משאב באמצעות API בארכיטקטורת REST, פועלים לפי השלבים הבאים:

    1. מאתרים את המארח והיציאה של ה-API בארכיטקטורת REST של יצירת המארחים:

      egosh client view REST_HOST_FACTORY_URL

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

      CLIENT NAME: REST_HOST_FACTORY_URL
DESCRIPTION: http://sym2.us-central1-c.c.symphonygcp.internal:9080/platform/rest/hostfactory/
TTL        : 0
LOCATION   : 40531@10.0.0.33
USER       : Admin

CHANNEL INFORMATION:
CHANNEL             STATE
9                   CONNECTED

    2. כדי ליצור בקשה למשאב באמצעות API בארכיטקטורת REST, משתמשים בפקודה הבאה:

      HOST=PRIMARY_HOST
PORT=PORT
TEMPLATE_NAME=SYMPHONY_TEMPLATE_ID
PROVIDER_NAME=gcpgkeinst

curl -X POST -u "SYMPHONY_USER:SYMPHONY_PASSWORD" -H "Content-Type: application/json" -d "{ \"demand_hosts\": [ { \"prov_name\": \"$PROVIDER_NAME\", \"template_name\": \"$TEMPLATE_NAME\", \"ninstances\": 1 } ] }" \
http://$HOST:$PORT/platform/rest/hostfactory/requestor/admin/request

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

      • ‫PRIMARY_HOST: שם המארח של המארח הראשי שלכם מהפלט של הפקודה הקודמת.
      • ‫PORT: מספר היציאה של המארח הראשי שלכם מתוך הפלט של הפקודה הקודמת, למשל 9080.
      • ‫SYMPHONY_TEMPLATE_ID: templateId שמוגדר בקובץ gcpgkeinstprov_templates.json, למשל template-gcp-01.
      • ‫SYMPHONY_USER: המשתמש ב-Symphony לאימות.
      • ‫SYMPHONY_PASSWORD: הסיסמה של משתמש Symphony.

      אם הפעולה מצליחה, הפלט יהיה דומה לדוגמה הזו:

      {"scheduled_request_id":["SD-641ef442-1f9e-40ae-ae16-90e152ed60d2"]}

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