Google Kubernetes Symphony-Anbieter installieren

Wenn Sie IBM Symphony in Google Kubernetes Engine (GKE) für die dynamische Ressourcenverwaltung einbinden möchten, müssen Sie den Symphony-Anbieter für GKE installieren und konfigurieren. Mit diesem Anbieter kann Symphony Rechenressourcen als Pods in Ihrem GKE-Cluster bereitstellen und verwalten. Dies ermöglicht eine effiziente Skalierung von Arbeitslasten durch die Kubernetes-Orchestrierung.

Um diese Integration zu aktivieren, installieren Sie einen Kubernetes-Operator in Ihrem Cluster, installieren Sie das Anbieter-Plug-in auf Ihrem primären Symphony-Host und konfigurieren Sie den Host Factory-Dienst von Symphony für die Kommunikation mit GKE.

Weitere Informationen zu Symphony Connectors for Google Cloudfinden Sie unter IBM Spectrum Symphony inGoogle Cloudeinbinden.

Hinweise

Für die Installation des Symphony-Anbieters für GKE benötigen Sie die folgenden Ressourcen:

Ein ausgeführter IBM Spectrum Symphony-Cluster mit aktiviertem Host Factory-Dienst.
Ein laufender GKE-Cluster. Informationen zum Erstellen eines Clusters finden Sie in der GKE-Übersicht.
Ein Dienstkonto mit den entsprechenden Berechtigungen. Weitere Informationen finden Sie im Abschnitt Erforderliche Rollen.
Das kubectl-Befehlszeilentool ist installiert und für die Kommunikation mit Ihrem GKE-Cluster konfiguriert.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, damit Sie die nötigen Berechtigungen zum Installieren des Operators und zum Verwalten von Symphony-Pods haben:

So verwalten Sie Kubernetes-Ressourcen: Kubernetes Engine-Administrator (roles/container.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Kubernetes-Operator installieren

Bevor Sie den GKE-Anbieter installieren, müssen Sie den zugehörigen Kubernetes-Operator installieren. Der Operator verwaltet den Lebenszyklus von Symphony-Compute-Pods in Ihrem GKE-Cluster.

Operator-Image erstellen

Wenn Sie die Kubernetes-Manifeste für den Operator generieren und bereitstellen möchten, müssen Sie zuerst das Operator-Container-Image erstellen. Die Manifeste enthalten die benutzerdefinierte Ressourcendefinition (Custom Resource Definition, CRD), die der Operator zum Verwalten von Symphony verwendet. Sie können das Image aus dem Quellcode erstellen.

Führen Sie die folgenden Schritte aus, um das Operator-Image aus der Quelle zu erstellen:

Klonen Sie das Repository symphony-gcp-connector aus GitHub:

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

Rufen Sie das Verzeichnis k8s-operator auf:
```
cd symphony-gcp-connector/k8s-operator
```
Legen Sie die Umgebungsvariablen für den Imagenamen, die Registry und das Tag fest:
```
export IMAGE="gcp-symphony-operator"
export REGISTRY="IMAGE_REPO"
export TAG="TAG"
```
Ersetzen Sie Folgendes:
- IMAGE_REPO: das Image-Repository, in dem das Operator-Image gespeichert ist. Sie können beispielsweise Artifact Registry zum Speichern Ihrer Operator-Images verwenden. Weitere Informationen finden Sie unter Docker-Repositories erstellen.
- TAG: Das Tag für das Operator-Image, z. B. 0.0.1.

Erstellen Sie das Operator-Image und übertragen Sie es per Push:

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'

Operator-Manifeste konfigurieren

Nachdem Sie das Operator-Image haben, müssen Sie die Kubernetes-Manifeste generieren und konfigurieren.

Verwenden Sie zum Generieren der Manifeste den Befehl export-manifests mit dem Operator-Image:
```
docker run --rm gcp-symphony-operator:latest export-manifests > manifests.yaml
```
Öffnen Sie die Datei manifests.yaml in einem Texteditor Ihrer Wahl.
Suchen Sie im Abschnitt spec.template.spec.containers das Feld image und aktualisieren Sie seinen Wert auf den vollständigen Pfad des Images, das Sie in Ihre Registry übertragen haben.
```
...
containers:
- image: IMAGE_REPO/gcp-symphony-operator:TAG
  name: manager
...
```
Ersetzen Sie Folgendes:
- IMAGE_REPO: der Pfad zum Image-Repository, in das Sie das Operator-Image übertragen haben.
- TAG: Das Tag, das Sie dem Operator-Image beim Erstellen zugewiesen haben.
Optional: Sie können auch den Wert imagePullPolicy an Ihre Clusterverwaltungsverfahren anpassen.

Operator-Manifeste anwenden

Nachdem Sie die Manifeste konfiguriert haben, wenden Sie sie auf Ihren Kubernetes-Cluster an. Sie können die Manifeste mit kubectl oder dem Cluster Toolkit anwenden.

kubectl: Wenn Sie die Manifeste mit kubectl anwenden möchten, führen Sie den folgenden Befehl aus:
```
kubectl apply -f manifests.yaml
```
Cluster Toolkit: Wenn Ihre GKE-Infrastruktur von Cluster Toolkit verwaltet wird, fügen Sie Ihrem GKE-Blueprint eine modules/management/kubectl-apply-Quelle hinzu, um die Manifeste anzuwenden. Im Folgenden sehen Sie ein Beispiel für eine Konfiguration, bei der davon ausgegangen wird, dass sich die Datei manifests.yaml im selben Verzeichnis wie der GKE-Blueprint befindet:
```
  -   id: symphony_operator_install
      source: modules/management/kubectl-apply
      use: [gke_cluster]
      settings:
      apply_manifests:
        -   source: $(ghpc_stage("manifests.yaml"))
```
Weitere Informationen finden Sie in der Übersicht zum Cluster Toolkit.

Umgebungsvariablen der Host-Factory laden

Bevor Sie die Host Factory-Dienste konfigurieren oder verwalten können, müssen Sie die Symphony-Umgebungsvariablen in Ihre Shell-Sitzung laden. Führen Sie auf Ihrer primären Symphony-Host-VM den folgenden Befehl aus:

source INSTALL_FOLDER/profile.platform

Ersetzen Sie INSTALL_FOLDER durch den Pfad zu Ihrem Installationsordner. Der Standardpfad für den Symphony-Installationsordner ist /opt/ibm/spectrumcomputing. Wenn Sie Symphony jedoch an einem anderen Ort installiert haben, müssen Sie den richtigen Pfad für Ihre Umgebung verwenden.

Mit diesem Befehl wird das Skript profile.platform ausgeführt, das wichtige Umgebungsvariablen wie $EGO_TOP und $HF_TOP exportiert und die Symphony-Befehlszeilentools zum PATH Ihrer Shell hinzufügt. Sie müssen diesen Befehl für jede neue Terminalsitzung ausführen, damit die Umgebung richtig konfiguriert ist.

Anbieter-Plug-in installieren

Wenn Sie den GKE-Anbieter in die Host Factory von Symphony einbinden möchten, installieren Sie das vorgefertigte Anbieter-Plug-in aus dem RPM-Paket oder erstellen Sie den Anbieter aus dem Quellcode.

Vordefiniertes Anbieter-Plug-in installieren

So installieren Sie das Anbieter-Plug-in mit RPM-Paketen auf Ihrer primären Symphony-Host-VM:

Fügen Sie das yum-Repository für die Google Cloud Symphony-Connectors hinzu:

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

Installieren Sie das Anbieterpaket für GKE:

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

Bei der RPM-Installation werden die ausführbaren Dateien und Skripts des Anbieters automatisch in den richtigen Verzeichnissen für den Symphony-Host-Factory-Dienst platziert. Nach der Installation sieht die Verzeichnisstruktur für das Anbieter-Plug-in für den Pfad $HF_TOP/$HF_VERSION/providerplugins/gcpgke so aus:

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

Anbieter aus dem Quellcode erstellen

So erstellen und installieren Sie die ausführbare CLI-Datei im Verzeichnis bin des Anbieter-Plug-in-Verzeichnisses:

Klonen Sie das Repository symphony-gcp-connector aus GitHub:

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

Rufen Sie das Verzeichnis hf-provider auf:
```
cd PROJECT_ROOT/hf-provider
```
Ersetzen Sie PROJECT_ROOT durch den Pfad zum Verzeichnis der obersten Ebene, das das Verzeichnis „hf-provider“ enthält, z. B. /home/user/symphony-gcp-connector.
Wenn uv nicht installiert ist, installieren Sie es:
```
pip install uv
```
Erstellen Sie eine virtuelle Python-Umgebung mit dem Python-Paketmanager uv:
```
uv venv
```
Aktivieren Sie die virtuelle Umgebung:
```
source .venv/bin/activate
```
Installieren Sie die erforderlichen Projektabhängigkeiten.
```
uv pip install .
```
Installieren Sie PyInstaller, das die Python-Anwendung in eine eigenständige ausführbare Datei bündelt:
```
uv pip install pyinstaller
```
Erstellen Sie die hf-gke-CLI für Google Kubernetes Engine-Cluster:
```
uv run pyinstaller hf-gke.spec --clean
```
Führen Sie den Befehl --help für eine ausführbare Datei aus, um die Installation zu überprüfen. Wenn Sie die erforderlichen Umgebungsvariablen nicht festlegen, wird möglicherweise ein Fehler angezeigt.
```
dist/hf-gke --help
```
Wenn Sie den Anbieter manuell erstellen, erstellen Sie Anbieter-Plug-in-Verzeichnisse für die Binärdatei und die Skripts:
```
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts
```
Kopieren Sie die Binärdatei hf-gke und die Skripts in die Verzeichnisse des Anbieter-Plug-ins. Die hf-gke-Binärdatei befindet sich im Verzeichnis dist/, das von PyInstaller erstellt wurde, und die Skripts befinden sich im Verzeichnis scripts/gcpgke/:
```
cp dist/hf-gke $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin/
cp scripts/gcpgke/* $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts/
```
Nach der Installation sieht die Verzeichnisstruktur für das Anbieter-Plug-in für den Pfad $HF_TOP/$HF_VERSION/providerplugins/gcpgke so aus:

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

Anbieter-Plug-in aktivieren

Um das GKE-Anbieter-Plug-in zu aktivieren, müssen Sie es in der Host-Factory-Konfiguration registrieren.

Öffnen Sie die Datei ${HF_TOP}/conf/providerplugins/hostProviderPlugins.json.

Mit dem source-Befehl wird die Umgebungsvariable $HF_TOP in Ihrer Umgebung definiert. Der Wert ist der Pfad zum Installationsverzeichnis der obersten Ebene für den IBM Spectrum Symphony-Hostfactory-Dienst.

Fügen Sie einen gcpgke-Anbieter-Plug-in-Abschnitt hinzu:

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

Anbieterinstanz einrichten

Erstellen Sie eine Provider-Instanz, um den GKE-Provider für Ihre Umgebung zu konfigurieren.

Wenn Sie den Connector manuell erstellen, erstellen Sie ein Verzeichnis für die Anbieterinstanz, z. B. $HF_TOP/conf/providers/gcpgkeinst/.

Die Umgebungsvariable $HF_TOP ist in Ihrer Umgebung definiert, wenn Sie profile.platform script als Quelle verwendet haben. Der Wert ist der Pfad zum Installationsverzeichnis der obersten Ebene für den IBM Spectrum Symphony-Hostfactory-Dienst.

Erstellen oder konfigurieren Sie die Datei gcpgkeinstprov_config.json im Verzeichnis der Anbieterinstanz ($HF_TOP/conf/providers/gcpgkeinst/). Diese Datei enthält die Hauptkonfiguration für den Anbieter.

Wenn Sie das Anbieter-Plug-in mit dem RPM-Paket installiert haben, können Sie die Beispielkonfigurationsdatei kopieren und dann anpassen:
```
cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json
```
Wenn Sie den Anbieter aus dem Quellcode erstellt haben, erstellen Sie eine gcpgkeinstprov_config.json-Datei.

In dieser Datei müssen Sie in der Regel nur die Variable GKE_KUBECONFIG konfigurieren, die den Pfad zu einer Standard-kubectl-Konfigurationsdatei für den zugehörigen GKE-Cluster definiert. Wenn Sie keinen Pfad angeben, wird standardmäßig kubeconfig im Verzeichnis der Anbieterinstanz verwendet. Sie müssen dafür sorgen, dass dieser Pfad auf eine gültige kubectl-Konfigurationsdatei für den Kubernetes-Cluster verweist, der von dieser Anbieterinstanz verwendet wird.

Hier sehen Sie eine Beispielkonfiguration:

{
  "GKE_KUBECONFIG": "kubeconfig"
}

Die folgenden Konfigurationsvariablen werden unterstützt:

Variablenname	Beschreibung	Standardwert
`GKE_KUBECONFIG`	Der Pfad zur Konfigurationsdatei, die vom kubectl-Befehl verwendet wird.	Keine
`GKE_CRD_NAMESPACE`*	Definiert den Kubernetes-Namespace, in dem alle Ressourcen erstellt werden.	`gcp-symphony`
`GKE_CRD_GROUP`*	Die Ressourcengruppe, die zum Identifizieren benutzerdefinierter Ressourcen für den GKE-Hostfactory-Operator verwendet wird.	`accenture.com`
`GKE_CRD_VERSION`*	Die Version, die zum Identifizieren benutzerdefinierter Ressourcen für den GKE-Hostfactory-Operator verwendet wird.	`v1`
`GKE_CRD_KIND`*	Der Name der benutzerdefinierten Ressourcendefinition, die eine Anfrage für Rechenressourcen (Pods) definiert.	`GCP Symphony Resource`
`GKE_CRD_SINGULAR`*	Wird in API-Aufrufen verwendet, wenn auf eine Instanz des benutzerdefinierten Ressourcenobjekts Google Cloud Symphony `Resource` verwiesen wird.	`gcp-symphony-resource`
`GKE_CRD_RETURN_REQUEST_KIND`*	Der Name der benutzerdefinierten Ressourcendefinition, die eine Anfrage zum Zurückgeben von Computeressourcen (Pods) definiert.	`Machine Return Request`
`GKE_CRD_RETURN_REQUEST_SINGULAR`*	Wird in API-Aufrufen verwendet, wenn auf eine einzelne benutzerdefinierte `MachineReturnRequest`-Ressourceninstanz verwiesen wird.	`machine-return-request`
`GKE_REQUEST_TIMEOUT`	Die Dauer in Sekunden, die eine Anfrage an die GKE-Steuerungsebene auf eine Antwort wartet.	`300`
`LOG_LEVEL`	Steuert die Detailebene der Protokolle, die der GKE-Anbieter in die Logdatei schreibt. Die Optionen sind `CRITICAL`, `WARNING`, `ERROR`, `INFO`, `DEBUG`.	`WARNING`

Erstellen oder konfigurieren Sie im selben Verzeichnis die Datei gcpgkeinstprov_templates.json. Diese Datei definiert die Vorlagen für die Pods, die der Anbieter erstellen kann.

Wenn Sie das Anbieter-Plug-in mit dem RPM-Paket installiert haben, können Sie die Beispielvorlagendatei kopieren und dann anpassen:

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

Wenn Sie den Anbieter aus dem Quellcode erstellt haben, erstellen Sie eine gcpgkeinstprov_templates.json-Datei.

Die Vorlagenattribute sollten mit den Ressourcen in einer Pod-Spezifikation übereinstimmen. Hier ist ein Beispiel für eine Vorlage:

{
    "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"
        }
    ]
}

Erstellen Sie im selben Verzeichnis eine kubeconfig-Datei, die eine gültige kubectl-Konfigurationsdatei für Ihren Kubernetes-Cluster ist.
Erstellen oder bearbeiten Sie die Datei pod-spec.yaml im Verzeichnis der Anbieterinstanz. Diese Datei dient als Vorlage, in der die Spezifikationen für die Symphony-Compute-Pods definiert sind, die in Ihrem GKE-Cluster erstellt werden.

Die aus dieser Spezifikation erstellten Pods fungieren als Rechenknoten und benötigen Zugriff auf die Symphony-Installation. Dieser Zugriff kann über das Container-Image, das die Symphony-Installation enthält, oder über eine gemeinsame Dateisystembereitstellung erfolgen, die die Installation enthält. Beim Start verwenden die Pods diesen Zugriff, um dem Symphony-Cluster beizutreten.

Die Schritte zum Erstellen der Datei hängen davon ab, wie Sie den Anbieter installiert haben:
- Wenn Sie den Anbieter über ein RPM-Paket installiert haben, kopieren Sie die Beispieldatei pod-spec.yaml.dist, die in der Installation enthalten war:
```
cp $HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml.dist
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml
```
- Wenn Sie den Anbieter aus dem Quellcode erstellt haben, erstellen Sie das Verzeichnis pod-specs und die Datei pod-spec.yaml manuell:
```
mkdir -p $HF_TOP/conf/providers/gcpgkeinst/pod-specs touch
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml
```

Prüfen Sie nach dem Erstellen dieser Dateien, ob das Verzeichnis Ihrer Anbieterinstanz so aussieht:

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

Anbieterinstanz aktivieren

Aktivieren Sie die Anbieterinstanz in der Host-Factory-Konfigurationsdatei, um sie zu aktivieren:

Öffnen Sie die Datei $HF_TOP/conf/providers/hostProviders.json.
Fügen Sie einen gcpgkeinst-Abschnitt für die Anbieterinstanz hinzu:
```
{
    "name": "gcpgkeinst",
    "enabled": 1,
    "plugin": "gcpgke",
    "confPath": "${HF_CONFDIR}/providers/gcpgkeinst/",
    "workPath": "${HF_WORKDIR}/providers/gcpgkeinst/",
    "logPath": "${HF_LOGDIR}/"
}
```
Sie müssen die Variablen ${HF_CONFDIR}, ${HF_WORKDIR} und ${HF_LOGDIR} in dieser Konfiguration nicht ersetzen, da es sich um Standardumgebungsvariablen handelt, die automatisch von der IBM Spectrum Symphony-Hostfactory-Umgebung definiert werden.

Wenn Sie Ihre Shell-Sitzung mit dem Befehl source command konfigurieren, werden diese Variablen in diesem Skript so festgelegt, dass sie auf die richtigen Unterverzeichnisse in Ihrer Symphony-Installation verweisen. Der Host-Factory-Dienst verwendet diese Variablen dann, um die vollständigen Pfade zur Laufzeit zu erstellen.

Anfragende Instanz aktivieren

Damit eine bestimmte Symphony-Komponente den GKE-Anbieter zum Bereitstellen von Ressourcen verwenden kann, müssen Sie sie für diesen Anforderer aktivieren.

Öffnen Sie die Datei $HF_TOP/conf/requestors/hostRequestors.json.
Fügen Sie in der entsprechenden Anfragestellerinstanz gcpgkeinst zum Parameter providers hinzu:
```
"providers": ["gcpgkeinst"],
```
Der Anbieterwert muss mit dem Anbieternamen übereinstimmen, den Sie in Anbieterinstanz aktivieren verwenden.

Host-Factory-Dienst starten

Starten Sie den Host-Factory-Dienst, um die Konfigurationsänderungen anzuwenden. Melden Sie sich auf Ihrer primären Symphony-Host-VM als Clusteradministrator an und starten Sie den Dienst:

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

Ersetzen Sie Folgendes:

SYMPHONY_USERNAME: Der Symphony-Nutzername für die Authentifizierung.
SYMPHONY_PASSWORD: Das Passwort für den Symphony-Nutzer.

Connectors testen

Erstellen Sie eine Ressourcenanfrage, um den Anbieter für GKE zu testen.

Verwenden Sie dazu eine der folgenden Methoden:

Symphony-GUI: Eine Anleitung zum Erstellen einer Ressourcenanfrage über die Symphony-GUI finden Sie in der IBM-Dokumentation unter Manually scheduling cloud host requests and returns (Cloud-Host-Anfragen und ‑Rückgaben manuell planen).

REST API: So erstellen Sie eine Ressourcenanfrage mit der REST API:

Suchen Sie den Host und den Port der Host Factory REST API:

egosh client view REST_HOST_FACTORY_URL

Die Ausgabe sieht etwa so aus:

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

Verwenden Sie zum Erstellen einer Ressourcenanfrage mit der REST API den folgenden Befehl:
```
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
```
Ersetzen Sie Folgendes:
- PRIMARY_HOST: Der Hostname Ihres primären Hosts aus der Ausgabe des vorherigen Befehls.
- PORT: die Portnummer Ihres primären Hosts aus der Ausgabe des vorherigen Befehls, z. B. 9080.
- SYMPHONY_TEMPLATE_ID: Die in der Datei gcpgkeinstprov_templates.json definierte templateId, z. B. template-gcp-01.
- SYMPHONY_USER: Der Symphony-Nutzer für die Authentifizierung.
- SYMPHONY_PASSWORD: Das Passwort für den Symphony-Nutzer.
Bei Erfolg sieht die Ausgabe etwa so aus:
```
{"scheduled_request_id":["SD-641ef442-1f9e-40ae-ae16-90e152ed60d2"]}
```

Nächste Schritte

Fehlerbehebung bei IBM Spectrum Symphony-Connectors