Cette page a été traduite par l'API Cloud Translation.

Déployer un outil Autoscaler centralisé ou par projet pour Spanner

Ce tutoriel explique comment configurer l'infrastructure de l'outil Autoscaler 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 Autoscaler centralisé ou par projet pour Spanner (ce document)
Déployer un outil Autoscaler distribué pour Spanner

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

Objectifs

Déployer Autoscaler à l'aide d'une topologie de déploiement centralisée ou par projet
Importer des instances Spanner existantes dans un é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. Cependant, cette estimation n'inclut pas les coûts des instances Spanner. Par exemple, comment calculer les coûts des instances Spanner, consultez 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

In the Google Cloud console, activate Cloud Shell.

Activate 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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
Enable the Identity and Access Management (IAM), Resource Manager, App Engine Admin, Firestore, Spanner, Pub/Sub, Cloud Run functions, Cloud Build, and Cloud Scheduler APIs.
Enable the APIs
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 Emplacement App Engine (pour Cloud Scheduler et Firestore pour l'infrastructure de l'autoscaler:
```
export REGION=us-central1
export ZONE=us-central1-c
export APP_ENGINE_LOCATION=us-central
```
créer un compte de service ; à utiliser pour créer toutes les ressources dans 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 comporte pas Firestore instance, 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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
Enable the Spanner API.
Enable the 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 des fonctions Cloud Run d'interrogation et de scaling, 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éer un fichier de configuration Terraform avec un fichier google_spanner_instance ressource:

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

Importer l'instance Spanner à 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 la section sur la fonction d'interrogation README.

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 des fonctions Cloud Run de scrutation et de scaling.

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 afficher uniquement les messages des fonctions Cloud Run du Scaler, cliquez sur le bouton Query Preview et remplacer le filtre précédent dans le texte du générateur de requêtes contenant 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 évolue sur 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 bien évolué sur 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 entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez é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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

É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 de Spanner
En savoir plus sur les métriques d'utilisation du processeur Spanner et les métriques de latence.
Découvrez les bonnes pratiques de conception de schémas de Spanner.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Cloud Architecture Center.