יכול להיות שחלק מהמידע בדף הזה או כולו לא רלוונטי ל-Cloud de Confiance by S3NS. פרטים נוספים מופיעים במאמר מה ההבדל מ-Google Cloud.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

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

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

מידע נוסף על Symphony Connectors for Cloud de Confiance by S3NSזמין במאמר Integrate IBM Spectrum Symphony withCloud de Confiance.

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

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

קלאסטר פעיל של IBM Spectrum Symphony עם שירות Host Factory מופעל.
אשכול GKE פעיל. הוראות ליצירת אשכול זמינות במאמר סקירה כללית של GKE.
חשבון שירות עם ההרשאות המתאימות. פרטים נוספים מופיעים בקטע תפקידים נדרשים.
כלי שורת הפקודה kubectl מותקן ומוגדר לתקשורת עם אשכול ה-GKE.

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

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

כדי לנהל משאבי Kubernetes: Kubernetes Engine Admin (roles/container.admin)

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

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

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

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

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

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

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

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

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

מנווטים לספרייה k8s-operator:
```
cd symphony-gcp-connector/k8s-operator
```
מגדירים את משתני הסביבה לשם התמונה, למאגר ולתג:
```
export IMAGE="gcp-symphony-operator"
export REGISTRY="IMAGE_REPO"
export TAG="TAG"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫IMAGE_REPO: מאגר התמונות שבו מאוחסנת תמונת המפעיל. לדוגמה, אפשר להשתמש ב-Artifact Registry כדי לאחסן תמונות של אופרטורים. מידע נוסף זמין במאמר יצירת מאגרי Docker.
- ‫TAG: התג של תמונת האופרטור, לדוגמה, 0.0.1.

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

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.

כדי ליצור את המניפסטים, משתמשים בפקודה export-manifests עם תמונת האופרטור:
```
docker run --rm gcp-symphony-operator:latest export-manifests > manifests.yaml
```
פותחים את הקובץ manifests.yaml בכלי לעריכת טקסט לבחירתכם.
בקטע spec.template.spec.containers, מאתרים את השדה image ומעדכנים את הערך שלו לנתיב המלא של התמונה שהועלתה למאגר.
```
...
containers:
- image: IMAGE_REPO/gcp-symphony-operator:TAG
  name: manager
...
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫IMAGE_REPO: הנתיב למאגר התמונות שבו העליתם את תמונת האופרטור.
- ‫TAG: התג שהקציתם לתמונת האופרטור כשבניתם אותה.
אופציונלי: אפשר גם לשנות את הערך imagePullPolicy כך שיתאים לשיטות שלכם לניהול אשכולות.

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

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

‫kubectl: כדי להחיל את המניפסטים באמצעות kubectl, מריצים את הפקודה הבאה:
```
kubectl apply -f manifests.yaml
```
‫Cluster Toolkit: אם התשתית של GKE מנוהלת על ידי Cluster Toolkit, צריך להוסיף מקור modules/management/kubectl-apply לתוכנית ה-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:

הוספת מאגר yum עבור Cloud de Confiance by S3NS 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

מתקינים את חבילת הספק ל-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 של ספריית הפלאגין של הספק, פועלים לפי השלבים הבאים:

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

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

מנווטים לספרייה hf-provider:
```
cd PROJECT_ROOT/hf-provider
```
מחליפים את PROJECT_ROOT בנתיב של הספרייה ברמה העליונה שמכילה את הספרייה hf-provider, לדוגמה /home/user/symphony-gcp-connector.
אם uv לא מותקן, צריך להתקין אותו:
```
pip install uv
```
יוצרים סביבה וירטואלית של Python באמצעות מנהל חבילות Python‏ uv:
```
uv venv
```
מפעילים את הסביבה הווירטואלית:
```
source .venv/bin/activate
```
מתקינים את יחסי התלות הנדרשים בפרויקט:
```
uv pip install .
```
מתקינים את PyInstaller, שמאגד את אפליקציית Python לקובץ הפעלה עצמאי:
```
uv pip install pyinstaller
```
יוצרים את hf-gke CLI לאשכולות של Google Kubernetes Engine:
```
uv run pyinstaller hf-gke.spec --clean
```
כדי לוודא שההתקנה בוצעה, מריצים את הפקודה --help לקובץ הפעלה. אם לא תגדירו את משתני הסביבה הנדרשים, יכול להיות שתופיע שגיאה.
```
dist/hf-gke --help
```
אם יוצרים את הספק באופן ידני, צריך ליצור ספריות של פלאגין ספק עבור הקובץ הבינארי והסקריפטים:
```
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts
```
מעתיקים את 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.

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

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

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

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

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

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

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

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

בספרייה של מופע הספק ($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 כשמתייחסים למופע של Cloud de Confiance by S3NS 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`

באותה ספרייה, יוצרים או מגדירים את הקובץ 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"
        }
    ]
}

באותה ספרייה, יוצרים קובץ kubeconfig שהוא קובץ תצורה חוקי של kubectl עבור אשכול Kubernetes.
בספריית מופע הספק, יוצרים או עורכים את הקובץ 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
```

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

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

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

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

פותחים את הקובץ $HF_TOP/conf/providers/hostProviders.json.
מוסיפים קטע של מופע ספק 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. לאחר מכן, שירות המפעל של המארח משתמש במשתנים האלה כדי ליצור את הנתיבים המלאים בזמן ריצה.

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

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

פותחים את הקובץ $HF_TOP/conf/requestors/hostRequestors.json.
במופע המתאים של השולח, מוסיפים 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"]}
```

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

פתרון בעיות במחברים של IBM Spectrum Symphony