Déployer un outil d'autoscaling par projet ou centralisé pour Spanner

Ce tutoriel explique comment configurer l'infrastructure de l'outil d'autoscaling pour Spanner. Ce tutoriel présente deux façons de configurer l'infrastructure, en fonction de vos besoins :

Topologie de déploiement par projet : Nous recommandons cette topologie aux équipes indépendantes qui souhaitent gérer leurs propres configuration et infrastructure d'Autoscaler. Une topologie de déploiement par projet constitue également un bon point de départ pour tester les fonctionnalités d'Autoscaler.
Topologie de déploiement centralisée : Nous recommandons cette topologie aux équipes qui gèrent la configuration et l'infrastructure d'une ou de plusieurs instances Spanner, tout en maintenant les composants et la configuration d'Autoscaler dans un emplacement centralisé. Dans la topologie centralisée, en plus d'un projet Autoscaler, vous configurez un deuxième projet, appelé projet d'application dans ce tutoriel. Le projet d'application contient les ressources de l'application, y compris Spanner. Dans ce tutoriel, configurez et activez la facturation et les API séparément pour ces deux projets.

Ce document fait partie d'une série :

Autoscaling Spanner
Déployer un outil d'autoscaler centralisé ou par projet pour Spanner (ce document)
Déployer un outil d'autoscaling distribué pour Spanner

Cette série est destinée aux équipes chargées de l'informatique, des opérations et de l'ingénierie en fiabilité des sites (SRE) qui souhaitent réduire les coûts opérationnels et optimiser les coûts de déploiement de Spanner.

Objectifs

Déployer Autoscaler à l'aide d'une topologie de déploiement centralisée ou par projet
Importer des instances Spanner existantes dans l'état Terraform
Configurer l'Autoscaler.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Les coûts associés au fonctionnement des composants d'Autoscaler lors de la mise en œuvre de ce tutoriel doivent être de zéro ou proches de zéro. Toutefois, cette estimation n'inclut pas les coûts des instances Spanner. Pour obtenir un exemple de calcul des coûts des instances Spanner, consultez la page Autoscaling Spanner.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

Dans Cloud Shell, clonez le dépôt GitHub suivant :

git clone https://github.com/cloudspannerecosystem/autoscaler

Exportez les variables pour les répertoires de travail dans lesquels se trouvent les fichiers de configuration Terraform pour chaque topologie :
```
export AUTOSCALER_DIR="$(pwd)/autoscaler/terraform/cloud-functions/per-project"
```

Préparer le projet Autoscaler

Dans cette section, vous allez préparer votre projet Autoscaler pour le déploiement.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activer les API Identity and Access Management (IAM), Resource Manager, App Engine Admin, Firestore, Spanner, Pub/Sub, Cloud Functions, Cloud Build, and Cloud Scheduler.
Activer les API
Dans Cloud Shell, définissez les variables d'environnement avec l'ID de votre projet Autoscaler :
```
export PROJECT_ID=INSERT_YOUR_PROJECT_ID
gcloud config set project "${PROJECT_ID}"
```
Définissez la région et la zone et l'emplacement App Engine (pour Cloud Scheduler et Firestore pour l'infrastructure d'Autoscaler :
```
export REGION=us-central1
export ZONE=us-central1-c
export APP_ENGINE_LOCATION=us-central
```
Créez un compte de service que Terraform peut utiliser pour créer toutes les ressources de votre infrastructure :
```
gcloud iam service-accounts create terraformer --display-name "Terraform service account"
```

Attribuez le rôle de propriétaire du projet (roles/owner) au compte de service :

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member "serviceAccount:terraformer@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/owner

Créez un fichier de clé de compte de service :

gcloud iam service-accounts keys create \
    --iam-account "terraformer@${PROJECT_ID}.iam.gserviceaccount.com" "${AUTOSCALER_DIR}/key.json"

Si votre projet ne possède pas encore d'instance Firestore, créez-en une :

gcloud app create --region="${APP_ENGINE_LOCATION}"
gcloud alpha firestore databases create --region="${APP_ENGINE_LOCATION}"

Préparer le projet d'application

Si vous déployez Autoscaler en mode par projet, vous pouvez passer à la section Déployer l'autoscaler.

Dans la topologie de déploiement centralisée, tous les composants d'Autoscaler résident dans le même projet. Les instances Spanner peuvent être situées dans différents projets.

Dans cette section, vous allez configurer le projet d'application où réside votre instance Spanner. L'instance Spanner diffuse une ou plusieurs applications spécifiques. Dans ce tutoriel, les équipes chargées de ces applications sont supposées être distinctes de l'équipe responsable de l'infrastructure et de la configuration d'Autoscaler.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activez l'API Spanner
Activer l'API
Dans Cloud Shell, définissez les variables d'environnement :
```
export APP_PROJECT_ID=INSERT_YOUR_APP_PROJECT_ID
```
Remplacez INSERT_YOUR_APP_PROJECT_ID par l'ID du projet d'application.
Attribuez le rôle de propriétaire (roles/owner) au compte de service terraformer que vous avez créé dans le projet d'application :
```
gcloud projects add-iam-policy-binding "${APP_PROJECT_ID}" \
    --member "serviceAccount:terraformer@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/owner
```
L'attribution de ce rôle au compte de service lui permet de créer des ressources.
Définissez l'ID du projet d'application dans la variable d'environnement Terraform correspondante :
```
export TF_VAR_app_project_id="${APP_PROJECT_ID}"
```

Déployer l'Autoscaler

Dans cette section, vous allez déployer les composants d'Autoscaler à l'aide de modules Terraform préconfigurés. Les fichiers Terraform qui définissent ces modules se trouvent dans les répertoires suivants :

Annuaire	Contenu du répertoire
`terraform/`	Configuration de premier niveau, qui inclut chacune des options de déploiement et les modules réutilisables.
`terraform/cloud-functions/per-project/`	Instructions concernant l'option de déploiement par projet.
`terraform/modules/autoscaler-functions/`	Configuration de la fonction d'interrogation et de la fonction de scaling Cloud Functions et des sujets Pub/Sub.
`terraform/modules/scheduler/`	Configuration de Cloud Scheduler pour déclencher l'interrogation.
`terraform/modules/spanner/`	Configuration de la base de données Spanner
`terraform/cloud-functions/centralized/`	Instructions pour l'option de déploiement centralisé.

Dans Cloud Shell, définissez l'ID du projet, la région et la zone dans les variables d'environnement Terraform correspondantes :
```
export TF_VAR_project_id="${PROJECT_ID}"
export TF_VAR_region="${REGION}"
export TF_VAR_zone="${ZONE}"
```
Au cours de cette étape, vous allez configurer une instance existante que l'autoscaler doit surveiller, ou créer et configurer une instance.

Si vous disposez déjà d'une instance Spanner, définissez son nom dans la variable suivante :
```
export TF_VAR_spanner_name=INSERT_YOUR_SPANNER_INSTANCE_NAME
```
Si vous souhaitez créer une instance Spanner pour tester l'autoscaler, définissez la variable suivante :
```
export TF_VAR_terraform_spanner=true
```
L'instance Spanner créée par Terraform est nommée autoscale-test.

Pour en savoir plus sur la configuration de Terraform pour gérer votre instance Spanner, consultez la page Importer des instances Spanner.
Remplacez votre répertoire de travail par le répertoire Terraform par projet :
```
cd "${AUTOSCALER_DIR}"
terraform init
```
Cette commande initialise également le répertoire Terraform par projet.

Importez l'application App Engine existante dans l'état Terraform :

terraform import module.scheduler.google_app_engine_application.app "${PROJECT_ID}"

Créez l'infrastructure d'Autoscaler :
```
terraform apply -parallelism=2
```
Le message suivant vous demande de vérifier que la liste des ressources que Terraform doit créer est correcte :
```
   Do you want to perform these actions?
   Terraform will perform the actions described above.
   Only 'yes' will be accepted to approve.
   Enter a value:
   
```
Après avoir vérifié les ressources, saisissez yes lorsque vous y êtes invité.

Lorsque vous exécutez cette commande dans Cloud Shell, vous pouvez rencontrer le message d'erreur suivant :

"Error: cannot assign requested address"

Il s'agit d'un problème connu dans Terraform Google Provider. Dans ce cas, réessayez avec la commande suivante : terraform apply -parallelism=1.

Importer vos instances Spanner

Si vous avez des instances Spanner existantes que vous souhaitez importer pour que Terraform les gère, suivez les instructions de cette section. Sinon, passez directement à la section Configurer l'autoscaler.

Dans Cloud Shell, répertoriez vos instances Spanner :
```
gcloud spanner instances list
```
Définissez la variable suivante avec le nom d'instance devant être soumis à un autoscaling :
```
SPANNER_INSTANCE_NAME=YOUR_SPANNER_INSTANCE_NAME
```

Créez un fichier de configuration Terraform avec une ressource google_spanner_instance vide :

echo "resource \"google_spanner_instance\" \"${SPANNER_INSTANCE_NAME}\" {}" > "${SPANNER_INSTANCE_NAME}.tf"

Importez l'instance Spanner dans l'état Terraform :

terraform import "google_spanner_instance.${SPANNER_INSTANCE_NAME}" "${SPANNER_INSTANCE_NAME}"

Une fois l'importation terminée, mettez à jour le fichier de configuration Terraform de votre instance avec l'attribut d'instance réel :
```
terraform state show -no-color "google_spanner_instance.${SPANNER_INSTANCE_NAME}" \
    | grep -vE "(id|num_nodes|state|timeouts).*(=|\{)" \
    > "${SPANNER_INSTANCE_NAME}.tf"
```
Si vous avez d'autres instances Spanner à importer, répétez le processus d'importation.

Configurer l'autoscaler

Après avoir déployé l'autoscaler, vous allez configurer ses paramètres.

Dans Google Cloud Console, accédez à la page Cloud Scheduler.

Accéder à Cloud Scheduler
Cochez la case à côté de la tâche poll-main-instance-metrics créée par le déploiement de l'autoscaler.
Cliquez sur Modifier.

Modifiez les paramètres de l'autoscaler affiché dans le champ de charge utile.

Voici un exemple de charge utile :

    [
        {
            "projectId": "my-spanner-project",
            "instanceId": "spanner1",
            "scalerPubSubTopic": "projects/my-spanner-project/topics/spanner-scaling",
            "units": "NODES",
            "minSize": 1,
            "maxSize": 3
        },{
            "projectId": "different-project",
            "instanceId": "another-spanner1",
            "scalerPubSubTopic": "projects/my-spanner-project/topics/spanner-scaling",
            "units": "PROCESSING_UNITS",
            "minSize": 500,
            "maxSize": 3000,
            "scalingMethod": "DIRECT"
        }
    ]

La charge utile est définie à l'aide d'un tableau JSON. Chaque élément du tableau représente une instance Spanner partageant la même planification de tâches que l'autoscaler.

Pour en savoir plus sur les paramètres et leurs valeurs par défaut, consultez l'README pour le composant Poller.

Pour enregistrer les modifications, cliquez sur Mettre à jour.

L'autoscaler est maintenant configuré et prêt à commencer la surveillance et la mise à l'échelle de vos instances lors de la prochaine exécution de tâche planifiée.

Si votre charge utile JSON contient des erreurs de syntaxe, vous pouvez les examiner dans Google Cloud Console depuis la page Explorateur de journaux en tant qu'entrées de journal de la fonction tf-poller-function.

Accéder à l'explorateur de journaux

Voici un exemple d'erreur possible :

SyntaxError: Unexpected token errortext in JSON at position 15 JSON.parse

Pour éviter les erreurs de syntaxe, utilisez un éditeur permettant de reformater et de valider le format JSON.

Surveiller l'autoscaler

Au cours de cette étape, vous allez configurer la surveillance de la fonction d'interrogation et de la fonction de scaling Cloud Functions.

Dans Google Cloud Console, ouvrez la page Explorateur de journaux.

Accéder à l'explorateur de journaux
Cliquez sur Query preview (Aperçu de la requête) et saisissez le filtre suivant dans le générateur de requêtes :
```
resource.type="cloud_function"
resource.labels.function_name=~"tf-.*-function"
```
Cliquez sur Exécuter la requête (Run Query).

Sous "Résultats de la requête", vous pouvez afficher tous les messages des fonctions de l'autoscaler. Comme l'interrogation ne s'exécute que toutes les deux minutes, vous devrez peut-être réexécuter la requête pour recevoir les messages de journal.
Pour n'afficher que les messages de la fonction de scaling Cloud Functions, cliquez dans le champ Aperçu de la requête et remplacez le filtre précédent dans la zone de texte du générateur de requêtes par ce qui suit :
```
resource.type="cloud_function"
resource.labels.function_name="tf-scaler-function"
```
Cliquez sur Exécuter la requête (Run Query).

Sous Résultats de la requête, en raison du filtre appliqué à la charge utile du texte, vous ne voyez que les messages de la fonction de scaling associés aux suggestions et aux décisions de scaling.

À l'aide d'une requête de filtre ou de filtres similaires, vous pouvez créer des métriques basées sur les journaux. Ces métriques sont utiles pour des fonctions telles que l'enregistrement de la fréquence des événements d'autoscaling, ou dans les graphiques et règles d'alerte de Cloud Monitoring.

Tester l'autoscaler

Dans cette section, vous allez vérifier le fonctionnement de l'autoscaler en modifiant la taille minimale de l'instance et en surveillant les journaux.

Lorsque vous déployez un autoscaler avec une base de données de test, l'autoscaler est configuré pour utiliser NODES comme unité de capacité de calcul. Vous pouvez vérifier si l'outil fonctionne en définissant le paramètre de la taille minimale (minSize) sur 2. Si l'outil s'exécute comme prévu, l'instance Spanner effectue un scaling horizontal pour passer à deux nœuds. Si vous avez utilisé une base de données existante pour ce tutoriel, vous pouvez obtenir des valeurs différentes.

Dans la console Google Cloud, accédez à la page Cloud Scheduler.

Accéder à Cloud Scheduler
Cochez la case à côté de la tâche poll-main-instance-metrics créée par le déploiement de l'autoscaler.
Cliquez sur Modifier.
Dans le champ Charge utile de la tâche, remplacez la valeur minSize de 1 par 2 :
```
"minSize": 2
```
Pour enregistrer les modifications, cliquez sur Mettre à jour.
Accédez à la page Explorateur de journaux.

Ouvrir l'Explorateur de journaux
Cliquez sur Query preview (Aperçu de la requête) et saisissez le filtre suivant dans le générateur de requêtes :
```
resource.type="cloud_function"
resource.labels.function_name="tf-scaler-function"
```
Cliquez sur Exécuter la requête (Run Query).
Cliquez sur Heure actuelle jusqu'à ce que le message de journal suivant s'affiche :

Scaling spanner instance to 2 NODES
Pour vérifier que Spanner a été étendu à deux nœuds, accédez à la page de la console Spanner dans la console Google Cloud.

Accéder à Spanner
Cliquez sur l'instance autoscale-test.

Sous "Présentation", vérifiez que le nombre de nœuds correspond maintenant à 2. Ce test rapide montre un événement de scaling en modifiant les paramètres de l'autoscaler. Vous pouvez effectuer un test de charge à l'aide d'un outil tel que YCSB pour simuler un autoscaler déclenchant un événement de scaling en fonction de l'utilisation.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Découvrez l'architecture des autoscalers.
Découvrez comment déployer un autoscaler en mode distribué.
En savoir plus sur les seuils recommandés Spanner.
Apprenez-en plus sur les métriques d'utilisation du processeur et les métriques de latence dans Spanner.
Découvrez les bonnes pratiques pour concevoir un schéma Spanner.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.