Installa il provider Compute Engine Symphony

Questo documento descrive come installare e configurare il provider IBM Symphony per Compute Engine. Scopri come configurare Pub/Sub per monitorare gli eventi delle istanze di macchine virtuali (VM), creare e installare il plug-in del provider e configurare l'istanza del provider all'interno dell'ambiente host factory di Symphony.

Per ulteriori informazioni su Symphony Connectors per Google Cloud, vedi Integrare IBM Spectrum Symphony con Google Cloud.

Prima di iniziare

Per installare il provider Symphony per Compute Engine, devi disporre delle seguenti risorse:

Un cluster IBM Spectrum Symphony in esecuzione con il servizio Host Factory attivato. Hai il nome host dell'host principale di IBM Spectrum Symphony.
Un account di servizio dedicato con i ruoli richiesti. Per maggiori informazioni su come creare questoaccount di serviziot, vedi Creare un service account.

Una regola firewall che hai configurato per consentire la comunicazione tra l'host primario di Symphony e Compute Engine. Ad esempio:

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

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo Google Cloud progetto.
NETWORK_NAME: il nome della rete VPC in cui vengono implementate le risorse Symphony.
NETWORK_TAGS_MASTER: il tag di rete applicato alla VM host principale di Symphony.
NETWORK_TAGS: il tag di rete applicato alle VM dei nodi di calcolo di Symphony.

Per saperne di più, consulta Creare regole firewall VPC.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare e gestire istanze che utilizzano un account di servizio, chiedi all'amministratore di concederti i seguenti ruoli IAM sul progetto:

Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1)
Utente Service Account (roles/iam.serviceAccountUser)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Preparare l'ambiente Compute Engine

Per consentire alla fabbrica di host Symphony di creare e gestire le VM, devi configurare diverse risorse Google Cloud :

Modello di istanza: una blueprint che definisce la configurazione delle VM di calcolo Symphony create dalla fabbrica host.
Gruppo di istanze gestite (MIG): un gruppo di VM identiche create utilizzando un modello di istanza. La fabbrica di host esegue lo scale up o lo scale down di questo gruppo aggiungendo o rimuovendo VM in base alla domanda del workload.
Argomento e sottoscrizione Pub/Sub: un servizio di messaggistica che notifica al provider Symphony gli eventi del ciclo di vita della VM, ad esempio i preempt o le eliminazioni. Questo servizio consente al provider di mantenere uno stato accurato del cluster.

Crea un modello di istanza

Crea un modello di istanza per gli host di calcolo Symphony utilizzando il comando gcloud compute instance-templates create. Questo template definisce le proprietà delle VM che crea. Su queste VM deve essere installato Symphony. Puoi utilizzare un'immagine con Symphony preinstallato oppure utilizzare uno script di avvio per installare Symphony dopo aver creato le VM. Per informazioni sull'installazione di Symphony su una VM host di calcolo, consulta Installazione su un host di calcolo Linux nella documentazione di 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

Sostituisci quanto segue:

INSTANCE_TEMPLATE_NAME: un nome per il nuovo template di istanza.
MACHINE_TYPE: il tipo di macchina per le istanze di calcolo. Per saperne di più, consulta Crea una VM con un tipo di macchina personalizzata.
SUBNET_NAME: il nome della subnet per le tue istanze. Per saperne di più, consulta Visualizzare la configurazione di rete di un'istanza.
SERVICE_ACCOUNT_EMAIL: l'email del service account che hai configurato nella sezione Prima di iniziare. Assicurati che questo account di servizio disponga dei ruoli specificati nella sezione Ruoli richiesti.
REGION: la Google Cloud regione in cui vuoi creare le risorse.
NETWORK_TAGS: un tag di rete da applicare alle istanze, che può essere utilizzato per le regole firewall, ad esempio symphony-compute.

Creare un gruppo di istanze gestite

Crea un gruppo di istanze gestite (MIG) utilizzando il modello di istanza del passaggio precedente. Il provider di fabbrica host esegue la scalabilità di questo gruppo aggiungendo o rimuovendo istanze in base alla domanda del carico di lavoro.

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

Sostituisci quanto segue:

INSTANCE_GROUP_NAME: il nome che hai scelto per il gruppo di istanze gestite.
PROJECT_ID: l'ID del tuo Google Cloud progetto. Per saperne di più, consulta Trovare il nome, il numero e l'ID del progetto.
INSTANCE_TEMPLATE_NAME: il nome del template di istanza che hai creato nel passaggio precedente.
REGION: la regione in cui si trovano le risorse, ad esempio us-east.
ZONE: la zona all'interno della regione selezionata, ad esempio a.

Per saperne di più sulla creazione di MIG, vedi Crea un MIG in un'unica zona.

Configurare Pub/Sub

Per consentire al provider Symphony di ricevere notifiche sugli eventi del ciclo di vita delle VM, configura un argomento e un abbonamento Pub/Sub:

Sull'host principale di Symphony, imposta le seguenti variabili di ambiente:
```
export GCP_PROJECT=PROJECT_ID
export PUBSUB_TOPIC=PUBSUB_TOPIC
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID del tuo Google Cloud progetto.
- PUBSUB_TOPIC: un nome per l'argomento Google Cloud , ad esempio hf-gce-vm-events.

Crea un argomento Pub/Sub:

gcloud pubsub topics create $PUBSUB_TOPIC

Utilizza il comando gcloud logging sinks create per creare un sink di logging per esportare gli audit log in 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"

L'output di questo comando include un account di servizio che utilizzerai nel passaggio successivo.

Concedi il ruolo Publisher Pub/Sub (roles/pubsub.publisher) al account di servizio del passaggio precedente:
```
gcloud pubsub topics add-iam-policy-binding $PUBSUB_TOPIC \
    --member="serviceAccount:LOGGING_SINK_SERVICE_ACCOUNT" \
    --role="roles/pubsub.publisher"
```
Sostituisci LOGGING_SINK_SERVICE_ACCOUNT con il nome del account di servizio dall'output di creazione del sink di logging.

Crea un abbonamento per ricevere i log:

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

Verifica che il account di servizio disponga delle autorizzazioni corrette per abbonarsi all'abbonamento:
```
gcloud pubsub subscriptions add-iam-policy-binding ${PUBSUB_TOPIC}-sub \
    --member="serviceAccount:SERVICE_ACCOUNT_EMAIL" \
    --role="roles/pubsub.subscriber"
```
Sostituisci SERVICE_ACCOUNT_EMAIL con l'email del account di servizio che gestisce il gruppo di istanze. Si tratta dello stesso account di servizio che hai configurato nella sezione Prima di iniziare.

La configurazione di Pub/Sub è stata completata. Per saperne di più su come configurare Pub/Sub, consulta Pubblicare e ricevere messaggi in Pub/Sub utilizzando Google Cloud CLI.

Carica le variabili di ambiente della fabbrica di host

Prima di poter configurare o gestire i servizi di fabbrica host, devi caricare le variabili di ambiente Symphony nella sessione della shell. Nella VM host primaria di Symphony, esegui questo comando:

source INSTALL_FOLDER/profile.platform

Sostituisci INSTALL_FOLDER con il percorso della cartella di installazione. Il percorso predefinito della cartella di installazione di Symphony è /opt/ibm/spectrumcomputing. Se hai installato Symphony in un'altra posizione, utilizza il percorso corretto per il tuo ambiente.

Questo comando esegue lo script profile.platform, che esporta le variabili di ambiente essenziali come $EGO_TOP e $HF_TOP e aggiunge gli strumenti a riga di comando di Symphony a PATH della shell. Devi eseguire questo comando per ogni nuova sessione del terminale per assicurarti che l'ambiente sia configurato correttamente.

Installare il plug-in del fornitore

Per integrare il provider Compute Engine con il servizio di fabbrica host Symphony, installa il plug-in del provider predefinito dal pacchetto RPM o crea il provider dal codice sorgente.

Installa il plug-in del fornitore predefinito

Per installare il plug-in del provider utilizzando i pacchetti RPM, segui questi passaggi sull'host primario di Symphony:

Aggiungi il repository yum per i Google Cloud connettori 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

Installa il pacchetto del provider per Compute Engine:
```
sudo yum install -y hf-gcpgce-provider.x86_64
```

Il pacchetto RPM installa gli eseguibili e gli script del fornitore nelle directory corrette per il servizio di fabbrica host Symphony. Dopo l'installazione, la struttura delle directory appare come segue:

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

Crea il provider dal codice sorgente

Per creare e installare l'eseguibile CLI nella directory bin della directory dei plug-in del provider, segui questi passaggi:

Clona il repository symphony-gcp-connector da GitHub:

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

Vai alla directory hf-provider nel tuo progetto:
```
cd PROJECT_ROOT/hf-provider
```
Sostituisci PROJECT_ROOT con il percorso della directory di primo livello che contiene la directory hf-provider, ad esempio /home/user/symphony-gcp-connector.
Se non hai installato uv, installalo:
```
pip install uv
```
Crea un ambiente virtuale Python utilizzando uv:
```
uv venv
```
Attiva l'ambiente virtuale:
```
source .venv/bin/activate
```
Installa le dipendenze del progetto richieste:
```
uv pip install .
```
Installa PyInstaller, che raggruppa l'applicazione Python in un eseguibile autonomo:
```
uv pip install pyinstaller
```
Crea la CLI hf-gce per i cluster Compute Engine:
```
uv run pyinstaller hf-gce.spec --clean
```
Per verificare l'installazione, esegui il comando --help per un eseguibile. Potresti visualizzare un errore se non imposti le variabili di ambiente richieste.
```
dist/hf-gce --help
```

Copia il file eseguibile nella directory bin del plug-in del provider:

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

Copia gli script nella directory scripts del plug-in del fornitore:
```
cp -R ./resources/gce_cli/1.2/providerplugins/gcpgce/scripts ${HF_TOP}/${HF_VERSION}/providerplugins/gcpgce/
```
Il sistema operativo deve supportare la versione di Python utilizzata per creare gli eseguibili. Gli eseguibili sono stati testati con Python 3.9.6.

Dopo l'installazione, la struttura di directory del plug-in del fornitore è simile a questo esempio:

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

Attiva il plug-in del provider

Per abilitare il plug-in del provider Compute Engine, registralo nella configurazione della fabbrica host:

Apri il file $HF_TOP/conf/providerplugins/hostProviderPlugins.json.

La variabile di ambiente $HF_TOP è definita nel tuo ambiente quando utilizzi il comando source. Il valore è il percorso della directory di installazione di primo livello per il servizio host factory di IBM Spectrum Symphony.
Aggiungi una sezione del plug-in del provider gcpgce:
```
{
    "name": "gcpgce",
    "enabled": 1,
    "scriptPath": "${HF_TOP}/${HF_VERSION}/providerplugins/gcpgce/scripts/"
}
```
Se utilizzi la versione 1.2 del plug-in del fornitore con il valore predefinito per $HF_TOP, il valore scriptPath risultante è: INSTALL_FOLDER/hostfactory/1.2/providerplugins/gcpgce/scripts/.

Configura un'istanza del fornitore

Per configurare il provider Compute Engine per il tuo ambiente, crea un'istanza del provider.

Configura la directory per l'istanza del fornitore:
- Se hai creato il provider dal codice sorgente, devi creare manualmente la directory e i file di configurazione:
```
mkdir -p $HF_TOP/conf/providers/gcpgceinst/
```
- Se hai eseguito l'installazione con RPM, questa directory esiste già e contiene file di configurazione di esempio. Copia i file di esempio per creare la configurazione:
```
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
```

Nella directory $HF_TOP/conf/providers/gcpgceinst/, crea o modifica un file gcpgceinstprov_config.json. Questo file contiene la configurazione principale per il provider. Il provider supporta le seguenti variabili di configurazione. Devi specificare le variabili che non hanno un valore predefinito in questa configurazione.

Nome variabile	Descrizione	Valore predefinito
`HF_DBDIR`	La posizione in cui questo fornitore archivia il database dello stato.	Definito nell'ambiente HostFactory come `$HF_DBDIR`.
`HF_TEMPLATES_FILENAME`	Il nome del file dei modelli.	`gcpgceinstprov_templates.json`
`GCP_CREDENTIALS_FILE`	Il percorso del file delle credenziali dell'account di servizio Google Cloud .	L'applicazione utilizza le credenziali predefinite se non specifichi questo valore.
`GCP_PROJECT_ID`	L'ID del progetto Google Cloud .	Nessuno
`GCP_INSTANCE_PREFIX`	Una stringa da anteporre a tutti gli host creati da questo fornitore.	`sym-`
`LOGFILE`	La posizione del file di log a cui il provider invia i log.	Un file con un nome generato, che si trova nella directory definita dalla variabile di ambiente HostFactory `HF_PROVIDER_LOGDIR`.
`LOG_LEVEL`	Il livello di log di Python	`WARNING`
`PUBSUB_TIMEOUT`	Se l'evento Pub/Sub più recente è precedente a questa durata, in secondi, il listener Pub/Sub si disconnette. Questo timeout si applica solo quando il listener di eventi Pub/Sub viene avviato automaticamente. In caso contrario, il listener viene eseguito a tempo indeterminato e l'amministratore deve controllare il ciclo di vita.	`600`
`PUBSUB_TOPIC`	Il nome dell'argomento Pub/Sub. Questa variabile è solo per la compatibilità con le versioni precedenti.	`hf-gce-vm-events`
`PUBSUB_SUBSCRIPTION`	Il nome della sottoscrizione Pub/Sub da monitorare per gli eventi VM.	`hf-gce-vm-events-sub`
`PUBSUB_LOCKFILE`	Il nome del file che indica se il listener di eventi Pub/Sub è attivo.	`/tmp/sym_hf_gcp_pubsub.lock`
`PUBSUB_AUTOLAUNCH`	Se impostato su `true`, il provider tenta di avviare automaticamente il listener di eventi Pub/Sub. Se `false`, devi avviare il listener di eventi Pub/Sub utilizzando il metodo che preferisci, con il comando `hf-gce monitorEvents`.	`true`

Il seguente esempio mostra una configurazione di base:

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

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo Google Cloud progetto.
PUBSUB_SUBSCRIPTION: il nome dell'iscrizione Pub/Sub che hai creato per monitorare gli eventi delle VM. Per saperne di più, consulta Configurare Pub/Sub.

Nella stessa directory, crea o modifica un file gcpgceinstprov_templates.json. Questo file definisce i modelli per le VM che il provider può creare. Gli attributi nel modello devono essere in linea con la configurazione del gruppo di istanze di supporto.
- Se hai eseguito l'installazione con RPM, utilizza il file gcpgceinstprov_templates.json che hai creato nei passaggi precedenti come punto di partenza.
- Se hai eseguito la compilazione dal codice sorgente, utilizza il seguente template di esempio:
```
{
    "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"
        }
    ]
}
```
  Sostituisci quanto segue:
  - GCP_ZONE: la zona Google Cloud in cui si trova il gruppo di istanze, ad esempio us-central1-a.
  - INSTANCE_GROUP_NAME: il nome del gruppo di istanze gestito dal provider, ad esempio symphony-compute-ig.
Dopo aver creato questi file, verifica che la directory dell'istanza del provider sia simile a questo esempio:
```
├── gcpgceinstprov_config.json
└── gcpgceinstprov_templates.json
```

Abilita l'istanza del provider

Per attivare l'istanza del fornitore, attivala nel file di configurazione della fabbrica host:

Apri il file $HF_TOP/conf/providers/hostProviders.json.
Aggiungi una sezione dell'istanza del provider gcpgceinst:
```
{
    "name": "gcpgceinst",
    "enabled": 1,
    "plugin": "gcpgce",
    "confPath": "${HF_CONFDIR}/providers/gcpgceinst/",
    "workPath": "${HF_WORKDIR}/providers/gcpgceinst/",
    "logPath": "${HF_LOGDIR}/"
}
```
Importante: non sostituire le variabili ${HF_CONFDIR}, ${HF_WORKDIR} e ${HF_LOGDIR} in questa configurazione. L'host factory di IBM Spectrum Symphony definisce automaticamente queste variabili di ambiente.

Quando configuri la sessione della shell utilizzando source command, questo script imposta queste variabili in modo che puntino alle sottodirectory corrette all'interno dell'installazione di Symphony. Il servizio di fabbrica dell'host utilizza queste variabili per costruire i percorsi completi in fase di runtime.

Abilitare l'istanza del richiedente

Per consentire a un componente Symphony specifico di utilizzare il provider Compute Engine per eseguire il provisioning delle risorse, abilitalo per il richiedente.

Apri il file $HF_TOP/conf/requestors/hostRequestors.json.
Nell'istanza del richiedente appropriata, aggiungi gcpgceinst al parametro providers:
```
"providers": ["gcpgceinst"],
```
Il valore del fornitore deve corrispondere al nome del fornitore che utilizzi in Attiva l'istanza del fornitore.

Avvia il servizio di fabbrica dell'host

Per applicare le modifiche alla configurazione, avvia il servizio di fabbrica dell'host. Nella VM host principale di Symphony, accedi come amministratore del cluster e avvia il servizio:

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

Sostituisci quanto segue:

SYMPHONY_USERNAME: il nome utente Symphony per l'autenticazione.
SYMPHONY_PASSWORD: la password per l'utente Symphony.

Testare i connettori

Crea una richiesta di risorse per testare il provider per Compute Engine.

Per farlo, utilizza uno dei seguenti metodi:

GUI di Symphony: per istruzioni su come creare una richiesta di risorse utilizzando la GUI di Symphony, consulta Pianificazione manuale delle richieste e dei ritorni di host cloud nella documentazione IBM.

API REST: per creare una richiesta di risorse utilizzando l'API REST, segui questi passaggi:

Trova l'host e la porta dell'API REST di Host Factory:

egosh client view REST_HOST_FACTORY_URL

L'output è simile a questo esempio:

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

Per creare una richiesta di risorse utilizzando l'API REST, utilizza il seguente comando:
```
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
```
Sostituisci quanto segue:
- PRIMARY_HOST: il nome host dell'host principale dall'output del comando precedente.
- PORT: il numero di porta dell'host principale dall'output del comando precedente, ad esempio 9080.
- SYMPHONY_TEMPLATE_ID: il templateId definito nel file gcpgceinstprov_templates.json, ad esempio template-gcp-01.
- SYMPHONY_USER: l'utente Symphony per l'autenticazione.
- SYMPHONY_PASSWORD: la password per l'utente Symphony.
Se l'operazione va a buon fine, l'output è simile a questo esempio:
```
{"scheduled_request_id":["SD-641ef442-1f9e-40ae-ae16-90e152ed60d2"]}
```

Installa il provider Compute Engine Symphony Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Ruoli obbligatori

Preparare l'ambiente Compute Engine

Crea un modello di istanza

Creare un gruppo di istanze gestite

Configurare Pub/Sub

Carica le variabili di ambiente della fabbrica di host

Installare il plug-in del fornitore

Installa il plug-in del fornitore predefinito

Crea il provider dal codice sorgente

Attiva il plug-in del provider

Configura un'istanza del fornitore

Abilita l'istanza del provider

Abilitare l'istanza del richiedente

Avvia il servizio di fabbrica dell'host

Testare i connettori

Passaggi successivi

Installa il provider Compute Engine Symphony