Installer le fournisseur Compute Engine Symphony

Ce document explique comment installer et configurer le fournisseur IBM Symphony pour Compute Engine. Vous apprendrez à configurer Pub/Sub pour surveiller les événements d'instance de machine virtuelle (VM), à créer et installer le plug-in du fournisseur, et à configurer l'instance du fournisseur dans votre environnement d'usine hôte Symphony.

Pour en savoir plus sur les connecteurs Symphony pour Google Cloud, consultez Intégrer IBM Spectrum Symphony à Google Cloud.

Avant de commencer

Pour installer le fournisseur Symphony pour Compute Engine, vous devez disposer des ressources suivantes :

Un cluster IBM Spectrum Symphony en cours d'exécution avec le service Host Factory activé. Vous disposez du nom d'hôte de votre hôte principal IBM Spectrum Symphony.
Un compte de service dédié disposant des rôles requis. Pour en savoir plus sur la création de ce compte de service, consultez Créer un compte de service.

Règle de pare-feu que vous avez configurée pour autoriser la communication entre l'hôte principal Symphony et Compute Engine. Exemple :

gcloud compute firewall-rules create allow-symphony-primary-to-compute \
    --project=PROJECT_ID \
    --direction=INGRESS \
    --priority=1000 \
    --network=NETWORK_NAME \
    --allow=all \
    --source-tags=NETWORK_TAGS_MASTER \
    --target-tags=NETWORK_TAGS

gcloud compute firewall-rules create allow-symphony-compute-to-primary \
    --project=PROJECT_ID \
    --direction=INGRESS \
    --priority=1000 \
    --network=NETWORK_NAME \
    --allow=all \
    --source-tags=NETWORK_TAGS \
    --target-tags=NETWORK_TAGS_MASTER

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud.
NETWORK_NAME : nom du réseau VPC dans lequel vos ressources Symphony sont déployées.
NETWORK_TAGS_MASTER : tag réseau appliqué à la VM hôte principale Symphony.
NETWORK_TAGS : tag réseau appliqué à vos VM de nœuds de calcul Symphony.

Pour en savoir plus, consultez Créer des règles de pare-feu VPC.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer et gérer des instances utilisant un compte de service, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1)
Utilisateur du compte de service (roles/iam.serviceAccountUser)

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Préparer votre environnement Compute Engine

Pour permettre à la fabrique d'hôtes Symphony de créer et de gérer des VM, vous devez configurer plusieurs ressources Google Cloud :

Modèle d'instance : plan qui définit la configuration des VM de calcul Symphony créées par la fabrique d'hôtes.
Groupe d'instances géré (MIG) : groupe de VM identiques créées à l'aide d'un modèle d'instance. La fabrique d'hôtes augmente ou diminue la taille de ce groupe en ajoutant ou en supprimant des VM en fonction de la demande de charge de travail.
Sujet et abonnement Pub/Sub : service de messagerie qui informe le fournisseur Symphony des événements du cycle de vie des VM, tels que les préemptions ou les suppressions. Ce service permet au fournisseur de maintenir un état précis du cluster.

Créer un modèle d'instance

Créez un modèle d'instance pour les hôtes de calcul Symphony à l'aide de la commande gcloud compute instance-templates create. Ce modèle définit les propriétés des VM qu'il crée. Ces VM doivent avoir Symphony installé. Vous pouvez utiliser une image avec Symphony préinstallé ou un script de démarrage pour installer Symphony après avoir créé les VM. Pour savoir comment installer Symphony sur une VM hôte de calcul, consultez Installation sur un hôte de calcul Linux dans la documentation IBM.

  gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --network-interface=nic-type=GVNIC,stack-type=IPV4_ONLY,subnet=SUBNET_NAME,no-address \
    --instance-template-region=REGION \
    --service-account=SERVICE_ACCOUNT_EMAIL \
    --scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append \
    --tags=NETWORK_TAGS \
    --create-disk=auto-delete=yes,boot=yes,device-name=INSTANCE_TEMPLATE_NAME,image-family=rocky-linux-9,image-project=rocky-linux-cloud,mode=rw,size=20,type=pd-balanced \
    --shielded-secure-boot \
    --shielded-vtpm \
    --shielded-integrity-monitoring

Remplacez les éléments suivants :

INSTANCE_TEMPLATE_NAME : nom de votre nouveau modèle d'instance.
MACHINE_TYPE : type de machine pour vos instances de calcul. Pour en savoir plus, consultez Créer une VM avec un type de machine personnalisé.
SUBNET_NAME : nom du sous-réseau de vos instances. Pour en savoir plus, consultez Afficher la configuration réseau d'une instance.
SERVICE_ACCOUNT_EMAIL : adresse e-mail du compte de service que vous avez configuré dans la section Avant de commencer. Assurez-vous que ce compte de service dispose des rôles spécifiés dans la section Rôles requis.
REGION : région Google Cloud dans laquelle vous souhaitez créer vos ressources.
NETWORK_TAGS : tag réseau à appliquer à vos instances, qui peut être utilisé pour les règles de pare-feu (par exemple, symphony-compute).

Créer un groupe d'instances géré

Créez un groupe d'instances géré (MIG) à l'aide du modèle d'instance de l'étape précédente. Le fournisseur de fabrique d'hôtes met à l'échelle ce groupe en ajoutant ou en supprimant des instances en fonction de la demande de charge de travail.

gcloud compute instance-groups managed create INSTANCE_GROUP_NAME \
    --project=PROJECT_ID \
    --base-instance-name=INSTANCE_GROUP_NAME \
    --template=projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --size=0 \
    --zone=ZONE
    --default-action-on-vm-failure=repair \
    --no-force-update-on-repair \
    --standby-policy-mode=manual \
    --list-managed-instances-results=pageless

Remplacez les éléments suivants :

INSTANCE_GROUP_NAME : nom que vous avez choisi pour le groupe d'instances géré.
PROJECT_ID : ID de votre projet Google Cloud. Pour en savoir plus, consultez Trouver le nom, le numéro et l'ID du projet.
INSTANCE_TEMPLATE_NAME : nom du modèle d'instance que vous avez créé à l'étape précédente.
REGION : région où se trouvent vos ressources, par exemple us-east.
ZONE : zone dans la région sélectionnée, par exemple a.

Pour en savoir plus sur la création de MIG, consultez Créer un MIG dans une seule zone.

Configurer Pub/Sub

Pour permettre au fournisseur Symphony de recevoir des notifications concernant les événements de cycle de vie des VM, configurez un sujet et un abonnement Pub/Sub :

Sur votre hôte principal Symphony, définissez les variables d'environnement suivantes :
```
export GCP_PROJECT=PROJECT_ID
export PUBSUB_TOPIC=PUBSUB_TOPIC
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet Google Cloud .
- PUBSUB_TOPIC : nom de votre thèmeGoogle Cloud , tel que hf-gce-vm-events.

Créez un sujet Pub/Sub

gcloud pubsub topics create $PUBSUB_TOPIC

Utilisez la commande gcloud logging sinks create pour créer un récepteur de journaux permettant d'exporter les journaux d'audit vers Pub/Sub :

gcloud logging sinks create ${PUBSUB_TOPIC}-sink \
    pubsub.googleapis.com/projects/${GCP_PROJECT}/topics/${PUBSUB_TOPIC} \
    --log-filter="
    logName=\"projects/${GCP_PROJECT}/logs/cloudaudit.googleapis.com%2Factivity\"
    resource.type=(\"gce_instance_group_manager\" OR \"gce_instance\")
    protoPayload.methodName=(
        \"v1.compute.instanceGroupManagers.createInstances\"
        OR
        \"v1.compute.instanceGroupManagers.deleteInstances\"
        OR
        \"v1.compute.instances.insert\"
        OR
        \"v1.compute.instances.delete\"
    )
    " \
    --description="Exports MIG VM create/delete audit logs to Pub/Sub"

Le résultat de cette commande inclut un compte de service que vous utiliserez lors de la prochaine étape.

Attribuez le rôle Éditeur Pub/Sub (roles/pubsub.publisher) au compte de service de l'étape précédente :
```
gcloud pubsub topics add-iam-policy-binding $PUBSUB_TOPIC \
    --member="serviceAccount:LOGGING_SINK_SERVICE_ACCOUNT" \
    --role="roles/pubsub.publisher"
```
Remplacez LOGGING_SINK_SERVICE_ACCOUNT par le nom du compte de service indiqué dans le résultat de la création du récepteur de journaux.

Créez un abonnement pour recevoir les journaux :

gcloud pubsub subscriptions create ${PUBSUB_TOPIC}-sub \
    --topic=${PUBSUB_TOPIC}

Vérifiez que votre compte de service dispose des autorisations appropriées pour s'abonner à l'abonnement :
```
gcloud pubsub subscriptions add-iam-policy-binding ${PUBSUB_TOPIC}-sub \
    --member="serviceAccount:SERVICE_ACCOUNT_EMAIL" \
    --role="roles/pubsub.subscriber"
```
Remplacez SERVICE_ACCOUNT_EMAIL par l'adresse e-mail du compte de service qui gère votre groupe d'instances. Il s'agit du même compte de service que celui que vous avez configuré dans la section Avant de commencer.

La configuration de Pub/Sub est terminée. Pour en savoir plus sur la configuration de Pub/Sub, consultez Publier et recevoir des messages dans Pub/Sub à l'aide de la Google Cloud CLI.

Charger les variables d'environnement de la fabrique d'hôtes

Avant de pouvoir configurer ou gérer les services de la fabrique d'hôtes, vous devez charger les variables d'environnement Symphony dans votre session de shell. Sur votre VM hôte principal Symphony, exécutez la commande suivante :

source INSTALL_FOLDER/profile.platform

Remplacez INSTALL_FOLDER par le chemin d'accès à votre dossier d'installation. Le chemin d'accès au dossier d'installation Symphony par défaut est /opt/ibm/spectrumcomputing. Si vous avez installé Symphony à un autre emplacement, utilisez le chemin d'accès approprié pour votre environnement.

Cette commande exécute le script profile.platform, qui exporte les variables d'environnement essentielles telles que $EGO_TOP et $HF_TOP, et ajoute les outils en ligne de commande Symphony au PATH de votre shell. Vous devez exécuter cette commande pour chaque nouvelle session de terminal afin de vous assurer que l'environnement est correctement configuré.

Installer le plug-in du fournisseur

Pour intégrer le fournisseur Compute Engine au service Symphony Host Factory, installez le plug-in de fournisseur prédéfini à partir du package RPM ou créez le fournisseur à partir du code source.

Installer le plug-in de fournisseur prédéfini

Pour installer le plug-in de fournisseur à l'aide de packages RPM, procédez comme suit sur votre hôte principal Symphony :

Ajoutez le dépôt yum pour les connecteurs Google Cloud Symphony :

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

Installez le package de fournisseur pour Compute Engine :
```
sudo yum install -y hf-gcpgce-provider.x86_64
```

Le package RPM installe les exécutables et les scripts du fournisseur dans les répertoires appropriés pour le service Symphony Host Factory. Une fois l'installation terminée, la structure de répertoire se présente comme suit :

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

Compiler le fournisseur à partir du code source

Pour compiler et installer l'exécutable CLI dans le répertoire bin du répertoire du plug-in du fournisseur, procédez comme suit :

Clonez le dépôt symphony-gcp-connector depuis GitHub :

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

Accédez au répertoire hf-provider de votre projet :
```
cd PROJECT_ROOT/hf-provider
```
Remplacez PROJECT_ROOT par le chemin d'accès au répertoire de premier niveau contenant le répertoire hf-provider, par exemple /home/user/symphony-gcp-connector.
Si uv n'est pas installé, installez-le :
```
pip install uv
```
Créez un environnement virtuel Python à l'aide de uv :
```
uv venv
```
Activez l'environnement virtuel :
```
source .venv/bin/activate
```
Installez les dépendances de projet requises :
```
uv pip install .
```
Installez PyInstaller, qui regroupe l'application Python dans un exécutable autonome :
```
uv pip install pyinstaller
```
Créez la CLI hf-gce pour les clusters Compute Engine :
```
uv run pyinstaller hf-gce.spec --clean
```
Pour vérifier l'installation, exécutez la commande --help pour un exécutable. Une erreur peut s'afficher si vous ne définissez pas les variables d'environnement requises.
```
dist/hf-gce --help
```

Copiez l'exécutable dans le répertoire bin du plug-in du fournisseur :

mkdir -p ${HF_TOP}/${HF_VERSION}/providerplugins/gcpgce/bin
cp dist/hf-gce ${HF_TOP}/${HF_VERSION}/providerplugins/gcpgce/bin/

Copiez les scripts dans le répertoire scripts du plug-in du fournisseur :
```
cp -R ./resources/gce_cli/1.2/providerplugins/gcpgce/scripts ${HF_TOP}/${HF_VERSION}/providerplugins/gcpgce/
```
L'OS doit être compatible avec la version de Python utilisée pour créer les exécutables. Les exécutables ont été testés avec Python 3.9.6.

Après l'installation, la structure de répertoire du plug-in du fournisseur est semblable à cet exemple :

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

Activer le plug-in du fournisseur

Pour activer le plug-in du fournisseur Compute Engine, enregistrez-le dans la configuration de la fabrique d'hôtes :

Ouvrez le fichier $HF_TOP/conf/providerplugins/hostProviderPlugins.json.

La variable d'environnement $HF_TOP est définie dans votre environnement lorsque vous utilisez la commande source. La valeur correspond au chemin d'accès au répertoire d'installation de premier niveau pour le service de fabrique d'hôtes IBM Spectrum Symphony.
Ajoutez une section de plug-in de fournisseur gcpgce :
```
{
    "name": "gcpgce",
    "enabled": 1,
    "scriptPath": "${HF_TOP}/${HF_VERSION}/providerplugins/gcpgce/scripts/"
}
```
Si vous utilisez la version 1.2 du plug-in de fournisseur avec la valeur par défaut pour $HF_TOP, la valeur scriptPath résultante est la suivante : INSTALL_FOLDER/hostfactory/1.2/providerplugins/gcpgce/scripts/.

Configurer une instance de fournisseur

Pour configurer le fournisseur Compute Engine pour votre environnement, créez une instance de fournisseur.

Configurez le répertoire pour l'instance de fournisseur :
- Si vous avez compilé le fournisseur à partir du code source, vous devez créer manuellement le répertoire et les fichiers de configuration :
```
mkdir -p $HF_TOP/conf/providers/gcpgceinst/
```
- Si vous avez installé avec RPM, ce répertoire existe déjà et contient des exemples de fichiers de configuration. Copiez les fichiers exemples pour créer votre configuration :
```
cp $HF_TOP/conf/providers/gcpgceinst/gcpgceinstprov_config.json.dist $HF_TOP/conf/providers/gcpgceinst/gcpgceinstprov_config.json
cp $HF_TOP/conf/providers/gcpgceinst/gcpgceinstprov_templates.json.dist $HF_TOP/conf/providers/gcpgceinst/gcpgceinstprov_templates.json
```

Dans le répertoire $HF_TOP/conf/providers/gcpgceinst/, créez ou modifiez un fichier gcpgceinstprov_config.json. Ce fichier contient la configuration principale du fournisseur. Le fournisseur est compatible avec les variables de configuration suivantes. Dans cette configuration, vous devez spécifier les variables qui n'ont pas de valeur par défaut.

Nom de la variable	Description	Valeur par défaut
`HF_DBDIR`	Emplacement où ce fournisseur stocke sa base de données d'état.	Défini dans l'environnement HostFactory comme `$HF_DBDIR`.
`HF_TEMPLATES_FILENAME`	Nom du fichier de modèles.	`gcpgceinstprov_templates.json`
`GCP_CREDENTIALS_FILE`	Emplacement du fichier d'identifiants du compte de service Google Cloud .	L'application utilise les identifiants par défaut si vous ne spécifiez pas cette valeur.
`GCP_PROJECT_ID`	ID du projet Google Cloud .	Aucun
`GCP_INSTANCE_PREFIX`	Chaîne à ajouter à tous les hôtes créés par ce fournisseur.	`sym-`
`LOGFILE`	Emplacement du fichier journal auquel le fournisseur envoie les journaux.	Fichier portant un nom généré, situé dans le répertoire défini par la variable d'environnement HostFactory `HF_PROVIDER_LOGDIR`.
`LOG_LEVEL`	Niveau de journalisation Python	`WARNING`
`PUBSUB_TIMEOUT`	Si l'événement Pub/Sub le plus récent est plus ancien que cette durée (en secondes), l'écouteur Pub/Sub se déconnecte. Ce délai n'est appliqué que lorsque l'écouteur d'événements Pub/Sub est lancé automatiquement. Sinon, l'écouteur s'exécute indéfiniment et l'administrateur doit contrôler le cycle de vie.	`600`
`PUBSUB_TOPIC`	Nom du sujet Pub/Sub. Cette variable est uniquement destinée à la rétrocompatibilité.	`hf-gce-vm-events`
`PUBSUB_SUBSCRIPTION`	Nom de l'abonnement Pub/Sub à surveiller pour les événements de VM.	`hf-gce-vm-events-sub`
`PUBSUB_LOCKFILE`	Nom du fichier qui indique si l'écouteur d'événements Pub/Sub est actif.	`/tmp/sym_hf_gcp_pubsub.lock`
`PUBSUB_AUTOLAUNCH`	Si la valeur est définie sur `true`, le fournisseur tente de lancer automatiquement l'écouteur d'événements Pub/Sub. Si la valeur est `false`, vous devez lancer l'écouteur d'événements Pub/Sub à l'aide de la méthode de votre choix, avec la commande `hf-gce monitorEvents`.	`true`

L'exemple suivant montre une configuration de base :

{
    "GCP_PROJECT_ID": "PROJECT_ID",
    "LOG_LEVEL":"INFO",
    "PUBSUB_SUBSCRIPTION": "PUBSUB_SUBSCRIPTION",
    "PUBSUB_TIMEOUT": 100
}

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud .
PUBSUB_SUBSCRIPTION : nom de l'abonnement Pub/Sub que vous avez créé pour surveiller les événements de VM. Pour en savoir plus, consultez Configurer Pub/Sub.

Dans le même répertoire, créez ou modifiez un fichier gcpgceinstprov_templates.json. Ce fichier définit les modèles pour les VM que le fournisseur peut créer. Les attributs du modèle doivent correspondre à la configuration du groupe d'instances associé.
- Si vous avez installé avec RPM, utilisez le fichier gcpgceinstprov_templates.json que vous avez créé lors des étapes précédentes comme point de départ.
- Si vous avez créé à partir de la source, utilisez le modèle d'exemple suivant :
```
{
    "templates": [
        {
            "templateId": "template-gcp-01",
            "maxNumber": 10,
            "attributes": {
                "type": [ "String", "X86_64" ],
                "ncpus": [ "Numeric", "1" ],
                "nram": [ "Numeric", "1024" ]
            },
            "gcp_zone": "GCP_ZONE",
            "gcp_instance_group": "INSTANCE_GROUP_NAME"
        }
    ]
}
```
  Remplacez les éléments suivants :
  - GCP_ZONE : zone Google Cloud où se trouve votre groupe d'instances, par exemple us-central1-a.
  - INSTANCE_GROUP_NAME : nom du groupe d'instances géré par le fournisseur, tel que symphony-compute-ig.
Une fois ces fichiers créés, vérifiez que le répertoire de votre instance de fournisseur ressemble à cet exemple :
```
├── gcpgceinstprov_config.json
└── gcpgceinstprov_templates.json
```

Activer l'instance de fournisseur

Pour activer l'instance de fournisseur, activez-la dans le fichier de configuration de la fabrique d'hôtes :

Ouvrez le fichier $HF_TOP/conf/providers/hostProviders.json.
Ajoutez une section d'instance de fournisseur gcpgceinst :
```
{
    "name": "gcpgceinst",
    "enabled": 1,
    "plugin": "gcpgce",
    "confPath": "${HF_CONFDIR}/providers/gcpgceinst/",
    "workPath": "${HF_WORKDIR}/providers/gcpgceinst/",
    "logPath": "${HF_LOGDIR}/"
}
```
Important : Ne remplacez pas les variables ${HF_CONFDIR}, ${HF_WORKDIR} et ${HF_LOGDIR} dans cette configuration. L'usine d'hôtes IBM Spectrum Symphony définit automatiquement ces variables d'environnement.

Lorsque vous configurez votre session shell à l'aide de source command, ce script définit ces variables pour qu'elles pointent vers les sous-répertoires appropriés de votre installation Symphony. Le service de fabrique d'hôtes utilise ensuite ces variables pour construire les chemins d'accès complets au moment de l'exécution.

Activer l'instance du demandeur

Pour permettre à un composant Symphony spécifique d'utiliser le fournisseur Compute Engine pour provisionner des ressources, activez-le pour ce demandeur.

Ouvrez le fichier $HF_TOP/conf/requestors/hostRequestors.json.
Dans l'instance de demandeur appropriée, ajoutez gcpgceinst au paramètre providers :
```
"providers": ["gcpgceinst"],
```
La valeur du fournisseur doit correspondre au nom du fournisseur que vous utilisez dans Activer l'instance de fournisseur.

Démarrer le service de fabrique d'hôtes

Pour appliquer vos modifications de configuration, démarrez le service Host Factory. Sur votre VM hôte principale Symphony, connectez-vous en tant qu'administrateur du cluster et démarrez le service :

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

Remplacez les éléments suivants :

SYMPHONY_USERNAME : nom d'utilisateur Symphony pour l'authentification.
SYMPHONY_PASSWORD : mot de passe de l'utilisateur Symphony.

Tester les connecteurs

Créez une demande de ressource pour tester le fournisseur pour Compute Engine.

Pour ce faire, utilisez l'une des méthodes suivantes :

Interface utilisateur graphique Symphony : pour savoir comment créer une demande de ressources à l'aide de l'interface utilisateur graphique Symphony, consultez Planifier manuellement les demandes et les retours d'hôtes cloud dans la documentation IBM.
API REST : pour créer une demande de ressources à l'aide de l'API REST, procédez comme suit :
1. Recherchez l'hôte et le port de l'API REST de l'usine d'hôtes :
```
egosh client view REST_HOST_FACTORY_URL
```
  Le résultat est semblable à cet exemple :
```
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. Pour créer une demande de ressource à l'aide de l'API REST, utilisez la commande suivante :
```
HOST=PRIMARY_HOST
PORT=PORT
TEMPLATE_NAME=INSTANCE_TEMPLATE_NAME
PROVIDER_NAME=gcpgceinst

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
```
  Remplacez les éléments suivants :
  - PRIMARY_HOST : nom d'hôte de votre hôte principal issu du résultat de la commande précédente.
  - PORT : numéro de port de votre hôte principal issu de la sortie de la commande précédente, tel que 9080.
  - SYMPHONY_TEMPLATE_ID : templateId défini dans le fichier gcpgceinstprov_templates.json, tel que template-gcp-01.
  - SYMPHONY_USER : utilisateur Symphony pour l'authentification.
  - SYMPHONY_PASSWORD : mot de passe de l'utilisateur Symphony.
  Si l'opération réussit, le résultat est semblable à celui-ci :
```
{"scheduled_request_id":["SD-641ef442-1f9e-40ae-ae16-90e152ed60d2"]}
```

Installer le fournisseur Compute Engine Symphony Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Rôles requis

Préparer votre environnement Compute Engine

Créer un modèle d'instance

Créer un groupe d'instances géré

Configurer Pub/Sub

Charger les variables d'environnement de la fabrique d'hôtes

Installer le plug-in du fournisseur

Installer le plug-in de fournisseur prédéfini

Compiler le fournisseur à partir du code source

Activer le plug-in du fournisseur

Configurer une instance de fournisseur

Activer l'instance de fournisseur

Activer l'instance du demandeur

Démarrer le service de fabrique d'hôtes

Tester les connecteurs

Étapes suivantes

Installer le fournisseur Compute Engine Symphony