Installer le fournisseur Google Kubernetes Symphony

Pour intégrer IBM Symphony à Google Kubernetes Engine (GKE) pour la gestion dynamique des ressources, vous devez installer et configurer le fournisseur Symphony pour GKE. Ce fournisseur permet à Symphony de provisionner et de gérer les ressources de calcul en tant que pods dans votre cluster GKE, ce qui permet un scaling efficace des charges de travail grâce à l'orchestration Kubernetes.

Pour activer cette intégration, vous devez installer un opérateur Kubernetes dans votre cluster, installer le plug-in du fournisseur sur votre hôte principal Symphony et configurer le service de fabrique d'hôtes de Symphony pour qu'il communique avec GKE.

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 GKE, vous devez disposer des ressources suivantes :

Un cluster IBM Spectrum Symphony en cours d'exécution avec le service Host Factory activé.
Un cluster GKE en cours d'exécution. Pour en créer un, consultez la présentation de GKE.
Un compte de service disposant des autorisations appropriées. Pour en savoir plus, consultez la section Rôles requis.
L'outil de ligne de commande kubectl installé et configuré pour communiquer avec votre cluster GKE.

Rôles requis

Pour obtenir les autorisations nécessaires pour installer l'opérateur et gérer les pods Symphony, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Pour gérer les ressources Kubernetes : Administrateur Kubernetes Engine (roles/container.admin)

Pour en savoir plus sur l'attribution de rôles, consultez 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.

Installer l'opérateur Kubernetes

Avant d'installer le fournisseur GKE, vous devez installer l'opérateur Kubernetes associé. L'opérateur gère le cycle de vie des pods de calcul Symphony dans votre cluster GKE.

Créer l'image de l'opérateur

Pour générer et déployer les fichiers manifestes Kubernetes pour l'opérateur, vous devez d'abord créer l'image de conteneur de l'opérateur. Les fichiers manifestes incluent la définition de ressource personnalisée (CRD) que l'opérateur utilise pour gérer Symphony. Pour obtenir l'image, vous pouvez la créer à partir de la source.

Pour créer l'image de l'opérateur à partir de la source, 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 k8s-operator :
```
cd symphony-gcp-connector/k8s-operator
```
Définissez les variables d'environnement pour le nom, le registre et le tag de l'image :
```
export IMAGE="gcp-symphony-operator"
export REGISTRY="IMAGE_REPO"
export TAG="TAG"
```
Remplacez les éléments suivants :
- IMAGE_REPO : dépôt d'images où l'image de l'opérateur est stockée. Par exemple, vous pouvez utiliser Artifact Registry pour stocker vos images d'opérateurs. Pour en savoir plus, consultez Créer des dépôts Docker.
- TAG : tag de l'image de l'opérateur, par exemple 0.0.1.

Créez et transférez l'image de l'opérateur :

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'

Configurer les fichiers manifestes de l'opérateur

Une fois l'image de l'opérateur obtenue, vous devez générer et configurer les fichiers manifestes Kubernetes.

Pour générer les fichiers manifestes, utilisez la commande export-manifests avec l'image de l'opérateur :
```
docker run --rm gcp-symphony-operator:latest export-manifests > manifests.yaml
```
Ouvrez le fichier manifests.yaml dans un éditeur de texte de votre choix.
Dans la section spec.template.spec.containers, recherchez le champ image et remplacez sa valeur par le chemin d'accès complet de l'image que vous avez transférée vers votre registre.
```
...
containers:
- image: IMAGE_REPO/gcp-symphony-operator:TAG
  name: manager
...
```
Remplacez les éléments suivants :
- IMAGE_REPO : chemin d'accès au dépôt d'images dans lequel vous avez transféré l'image de l'opérateur.
- TAG : tag que vous avez attribué à l'image de l'opérateur lorsque vous l'avez créée.
Facultatif : Vous pouvez également modifier la valeur imagePullPolicy pour l'adapter à vos pratiques de gestion des clusters.

Appliquer les fichiers manifestes de l'opérateur

Une fois les fichiers manifestes configurés, appliquez-les à votre cluster Kubernetes. Vous pouvez appliquer les fichiers manifestes à l'aide de kubectl ou de Cluster Toolkit.

kubectl : pour appliquer les fichiers manifestes à l'aide de kubectl, exécutez la commande suivante :
```
kubectl apply -f manifests.yaml
```
Cluster Toolkit : si votre infrastructure GKE est gérée par Cluster Toolkit, ajoutez une source modules/management/kubectl-apply à votre plan GKE pour appliquer les fichiers manifestes. Voici un exemple de configuration, en supposant que le fichier manifests.yaml se trouve dans le même répertoire que le blueprint GKE :
```
  -   id: symphony_operator_install
      source: modules/management/kubectl-apply
      use: [gke_cluster]
      settings:
      apply_manifests:
        -   source: $(ghpc_stage("manifests.yaml"))
```
Pour en savoir plus, consultez la présentation de Cluster Toolkit.

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. Toutefois, si vous avez installé Symphony ailleurs, vous devez utiliser le chemin d'accès approprié à 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 à 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 GKE à la fabrique d'hôtes de Symphony, 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 du fournisseur à l'aide de packages RPM, procédez comme suit sur votre VM hôte principale 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 GKE :

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

L'installation du RPM place automatiquement les exécutables et les scripts du fournisseur dans les répertoires appropriés pour le service de fabrique d'hôtes Symphony. Après l'installation, la structure de répertoire du plug-in du fournisseur se présente comme suit pour le chemin $HF_TOP/$HF_VERSION/providerplugins/gcpgke :

├── bin
│   ├── hf-gke
│   └── README.md
└── 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 :
```
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 du gestionnaire de packages Python 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-gke pour les clusters Google Kubernetes Engine :
```
uv run pyinstaller hf-gke.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-gke --help
```
Si vous créez manuellement le fournisseur, créez des répertoires de plug-in de fournisseur pour le binaire et les scripts :
```
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts
```
Copiez le fichier binaire et les scripts hf-gke dans les répertoires de plug-ins du fournisseur. Le fichier binaire hf-gke se trouve dans le répertoire dist/ créé par PyInstaller, et les scripts se trouvent dans le répertoire scripts/gcpgke/ :
```
cp dist/hf-gke $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin/
cp scripts/gcpgke/* $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts/
```
Après l'installation, la structure de répertoire du plug-in du fournisseur s'affiche comme suit pour le chemin d'accès $HF_TOP/$HF_VERSION/providerplugins/gcpgke :

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

Activer le plug-in du fournisseur

Pour activer le plug-in du fournisseur GKE, vous devez l'enregistrer dans la configuration de la fabrique d'hôtes.

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

La commande source définit la variable d'environnement $HF_TOP dans votre environnement. 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 gcpgke :

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

Configurer une instance de fournisseur

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

Si vous créez le connecteur manuellement, créez un répertoire pour l'instance de fournisseur, par exemple $HF_TOP/conf/providers/gcpgkeinst/.

La variable d'environnement $HF_TOP est définie dans votre environnement si vous avez sourcé profile.platform script. 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.

Dans le répertoire de l'instance du fournisseur ($HF_TOP/conf/providers/gcpgkeinst/), créez ou configurez le fichier gcpgkeinstprov_config.json. Ce fichier contient la configuration principale du fournisseur.

Si vous avez installé le plug-in de fournisseur à l'aide du package RPM, vous pouvez copier l'exemple de fichier de configuration, puis le personnaliser :
```
cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json
```
Si vous avez créé le fournisseur à partir de la source, créez un fichier gcpgkeinstprov_config.json.

Pour ce fichier, vous n'avez généralement besoin de configurer que la variable GKE_KUBECONFIG, qui définit le chemin d'accès à un fichier de configuration kubectl standard pour le cluster GKE associé. Si vous ne spécifiez pas de chemin, la valeur par défaut est kubeconfig dans le répertoire de l'instance du fournisseur. Vous devez vous assurer que ce chemin d'accès pointe vers un fichier de configuration kubectl valide pour le cluster Kubernetes utilisé par cette instance de fournisseur.

Voici un exemple de configuration :

{
  "GKE_KUBECONFIG": "kubeconfig"
}

Les variables de configuration suivantes sont acceptées :

Nom de la variable	Description	Valeur par défaut
`GKE_KUBECONFIG`	Chemin d'accès au fichier de configuration utilisé par la commande kubectl.	Aucun
`GKE_CRD_NAMESPACE`*	Définit l'espace de noms Kubernetes dans lequel toutes les ressources sont créées.	`gcp-symphony`
`GKE_CRD_GROUP`*	Groupe de ressources utilisé pour identifier les ressources personnalisées de l'opérateur de fabrique d'hôtes GKE.	`accenture.com`
`GKE_CRD_VERSION`*	Version utilisée pour identifier les ressources personnalisées de l'opérateur GKE Host Factory.	`v1`
`GKE_CRD_KIND`*	Nom donné à la définition de ressource personnalisée qui définit une demande de ressources de calcul (pods).	`GCP Symphony Resource`
`GKE_CRD_SINGULAR`*	Utilisé dans les appels d'API pour faire référence à une instance de la ressource personnalisée `Resource` Symphony. Google Cloud	`gcp-symphony-resource`
`GKE_CRD_RETURN_REQUEST_KIND`*	Nom donné à la définition de ressource personnalisée qui définit une requête pour renvoyer des ressources de calcul (pods).	`Machine Return Request`
`GKE_CRD_RETURN_REQUEST_SINGULAR`*	Utilisé dans les appels d'API pour faire référence à une seule instance de ressource personnalisée `MachineReturnRequest`.	`machine-return-request`
`GKE_REQUEST_TIMEOUT`	Durée, en secondes, pendant laquelle une requête envoyée au plan de contrôle GKE attend une réponse.	`300`
`LOG_LEVEL`	Contrôle le niveau de détail des journaux que le fournisseur GKE écrit dans le fichier journal. Les options sont `CRITICAL`, `WARNING`, `ERROR`, `INFO` et `DEBUG`.	`WARNING`

Dans le même répertoire, créez ou configurez le fichier gcpgkeinstprov_templates.json. Ce fichier définit les modèles pour les pods que le fournisseur peut créer.

Si vous avez installé le plug-in de fournisseur à l'aide du package RPM, vous pouvez copier le fichier de modèles d'exemple, puis le personnaliser :
```
cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_templates.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_templates.json
```

Si vous avez créé le fournisseur à partir de la source, créez un fichier gcpgkeinstprov_templates.json.

Les attributs du modèle doivent être alignés sur les ressources d'une spécification de pod. Voici un exemple de modèle :

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

Dans le même répertoire, créez un fichier kubeconfig qui est un fichier de configuration kubectl valide pour votre cluster Kubernetes.
Dans le répertoire de l'instance du fournisseur, créez ou modifiez le fichier pod-spec.yaml. Ce fichier sert de modèle et définit les spécifications des pods de calcul Symphony créés dans votre cluster GKE.

Les pods créés à partir de cette spécification fonctionnent comme des nœuds de calcul et nécessitent un accès à l'installation Symphony. Cet accès peut être fourni via l'image de conteneur, qui inclut l'installation de Symphony, ou via un montage de système de fichiers partagé contenant l'installation. Au démarrage, les pods utilisent cet accès pour rejoindre le cluster Symphony.

La procédure de création du fichier dépend de la façon dont vous avez installé le fournisseur :
- Si vous avez installé le fournisseur à partir d'un package RPM, copiez l'exemple de fichier pod-spec.yaml.dist inclus dans l'installation :
```
cp $HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml.dist
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml
```
- Si vous avez créé le fournisseur à partir de la source, créez manuellement le répertoire pod-specs et le fichier pod-spec.yaml :
```
mkdir -p $HF_TOP/conf/providers/gcpgkeinst/pod-specs touch
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml
```

Une fois ces fichiers créés, vérifiez que le répertoire de votre instance de fournisseur se présente comme suit :

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

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 gcpgkeinst :
```
{
    "name": "gcpgkeinst",
    "enabled": 1,
    "plugin": "gcpgke",
    "confPath": "${HF_CONFDIR}/providers/gcpgkeinst/",
    "workPath": "${HF_WORKDIR}/providers/gcpgkeinst/",
    "logPath": "${HF_LOGDIR}/"
}
```
Vous n'avez pas besoin de remplacer les variables ${HF_CONFDIR}, ${HF_WORKDIR} et ${HF_LOGDIR} dans cette configuration, car il s'agit de variables d'environnement standards qui sont automatiquement définies par l'environnement de fabrique d'hôtes IBM Spectrum Symphony.

Lorsque vous configurez votre session shell en exécutant 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 GKE 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 gcpgkeinst au paramètre providers :
```
"providers": ["gcpgkeinst"],
```
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 ressources pour tester le fournisseur pour GKE.

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=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
```
  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 gcpgkeinstprov_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"]}
```

Étapes suivantes

Résoudre les problèmes liés aux connecteurs IBM Spectrum Symphony