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

Utiliser la chaîne d'outils GKE Enterprise avec Active Assist

Ce document fait partie d'une série qui traite des modèles architecturaux que les entreprises peuvent utiliser pour optimiser leur empreinte cloud à grande échelle à l'aide d'Active Assist. Le tutoriel vous explique comment créer un pipeline d'automatisation pour les recommandations Active Assist fonctionnant avec la chaîne d'outils GKE Enterprise. Il est destiné aux personnes qui utilisent Config Sync pour gérer leurs environnements GKE Enterprise et Config Connector pour gérer les ressources Google Cloud . Les autres parties de la série sont les suivantes :

Schémas d'utilisation d'Active Assist à grande échelle
Utiliser des pipelines sans serveur avec Active Assist
Utiliser la chaîne d'outils GKE Enterprise avec Active Assist (ce document)

Le pipeline d'automatisation que vous créez dans ce tutoriel peut vous aider à atteindre les objectifs suivants :

Faire évoluer l'utilisation du portefeuille Active Assist dans votre organisation.
Intégrer Active Assist à votre pipeline d'intégration et de livraison continue (CI/CD).
Contrôler l'examen et l'activation des recommandations Active Assist à l'aide de constructions, telles que les problèmes GitHub et les demandes d'extraction.

Ce tutoriel utilise également kpt, une boîte à outils Open Source développée par Google pour vous aider à gérer, manipuler, personnaliser et appliquer des fichiers de données de configuration de ressources Kubernetes.

Architecture

Le schéma d'architecture suivant présente les composants que vous utilisez dans ce tutoriel.

Composants utilisés dans l'architecture

Les composants sont utilisés des manières suivantes :

Un dépôt GitHub DRY (Don't Repeat Yourself – Ne vous répétez pas), utilisé pour les modèles Config Connector que vous déployez sur les projets de votre organisation Google Cloud .
Un ou plusieurs dépôts GitHub spécifiques à un projet ou à un environnement contenant des fichiers de configuration hydratés. Ces dépôts hydratés sont destinés aux environnements gérés par Config Sync. Ils utilisent Config Connector pour activer et gérer les ressources Google Cloud dans l'organisation Google Cloud .
Un cluster GKE qui utilise Config Sync pour le contrôle des versions et la détection des dérives. Config Connector est également installé sur ce cluster. Config Connector permet au cluster de gérer les ressources Google Cloud dans l'organisation Google Cloud .
Un déclencheur Cloud Build qui déclenche une compilation lorsqu'un modèle est transféré vers le dépôt GitHub DRY.
Un déclencheur Cloud Build planifié qui déclenche périodiquement une compilation La tâche de compilation utilise une fonction kpt. La fonction appelle les API Recommender d'Active Assist pour récupérer les recommandations actives. Les recommandations sont examinées et analysées pour déterminer si les ressourcesGoogle Cloud gérées par Config Connector doivent être redimensionnées ou optimisées. La fonction kpt crée un problème GitHub dans le dépôt DRY avec les détails de la modification recommandée si les ressources Google Cloud gérées par Config Connector doivent être redimensionnées ou optimisées.

Le workflow de cette architecture est le suivant :

Les équipes autorisées ayant accès au dépôt DRY créent et gèrent des modèles Config Connector dans le dépôt.
Une tâche Cloud Build est déclenchée lorsqu'un modèle est créé ou modifié, et qu'il est enregistré dans la branche main.
La tâche Cloud Build hydrate les modèles en appelant des setters kpt. La tâche transfère les fichiers de configuration hydratés vers le dépôt GitHub hydraté. Les clés de déploiement GitHub pour le dépôt privé sont stockées dans Secret Manager.
Config Sync surveille les modifications du dépôt hydraté et applique les mises à jour trouvées dans le dépôt au cluster géré.
Config Connector surveille les modifications et active les ressources Google Cloudsi des ressources doivent être créées ou mises à jour à la suite des modifications du modèle de ressource Kubernetes (KRM) appliquées par Config Sync.
Un déclencheur Cloud Build planifié s'exécute régulièrement pour appeler l'API Recommender afin de récupérer les recommandations actives pour les projets gérés par Config Connector.
La tâche Cloud Build planifiée exécute une fonction kpt personnalisée pour appeler l'API Recommender et récupérer et analyser les recommandations actives.
La fonction kpt crée un problème GitHub qui compare la configuration actuelle de la ressource à la configuration recommandée pour la ressource. Avec cette approche, les problèmes GitHub sont créés dans le dépôt DRY, ce qui facilite le suivi des modifications de dépôt.

Configurer votre environnement

Dans ce tutoriel, vous allez exécuter toutes les commandes dans Cloud Shell.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Définissez des variables pour l'ID et le numéro du projetGoogle Cloud build actuel :

export RECO_MGR_PROJECT=PROJECT_ID
gcloud config set project $RECO_MGR_PROJECT
export RECO_MGR_PROJECT_NUMBER=$(gcloud projects describe $RECO_MGR_PROJECT --format='value(projectNumber)')

Remplacez PROJECT_ID par l'ID de projet que vous avez noté dans la section précédente.

Définissez des variables pour la région de déploiement :
```
export REGION=us-central1
export ZONE=us-central1-a
```
Clonez le dépôt contenant le code de l'exemple d'application utilisé dans ce tutoriel :
```
git clone https://github.com/GoogleCloudPlatform/activeassist-anthos-toolchain.git
```
Accédez au répertoire du projet :
```
cd activeassist-anthos-toolchain
```

Créer le pipeline

Dans cette section, vous allez créer les composants pour créer le pipeline. Les recommandations Active Assist sont générées en fonction des modèles d'utilisation et des métriques système. Chaque catégorie de recommandations peut utiliser une période par défaut différente pour analyser les données d'utilisation et les métriques en fonction des recommandations générées. Pour tester le pipeline de bout en bout, le dépôt que vous avez cloné dans le cadre de ce tutoriel fournit des exemples de recommandations (simulations) que vous utilisez pour exécuter le pipeline de bout en bout.

Si vous exécutez le pipeline dans un exemple de projet comportant des ressources et des recommandations, vous pouvez apporter les modifications appropriées à l'exemple de code, puis exécuter le pipeline.

Configurer des exemples de dépôts GitHub privés

Dans les sections suivantes, vous allez configurer les exemples de dépôts GitHub pour ce tutoriel.

Configurer un dépôt GitHub DRY privé

Créez un dépôt GitHub privé pour le dépôt DRY. Notez le nom que vous donnez au dépôt.
Dans Cloud Shell, créez une variable d'environnement pour votre nom d'utilisateur GitHub et le nom du dépôt DRY :
```
export REPO_OWNER=YOUR_GITHUB_USERNAME
export DRY_REPO_NAME=YOUR_PRIVATE_DRY_REPO
```
Remplacez les éléments suivants :
- YOUR_GITHUB_USERNAME : votre nom d'utilisateur GitHub.
- YOUR_PRIVATE_DRY_REPO : le nom de votre dépôt DRY.
Créez un jeton d'accès personnel (PAT) pour créer des problèmes dans ce dépôt. Le pipeline crée des problèmes GitHub s'il existe des recommandations Active Assist à examiner. Pour en savoir plus sur la création de PAT dans GitHub, consultez la documentation GitHub.

Lorsque vous définissez un champ d'application pour ce jeton, sélectionnez Contrôle total des dépôts privés.
Dans Cloud Shell, créez une variable d'environnement pour le jeton d'accès personnel que vous avez généré :
```
export GITHUB_TOKEN=YOUR_PERSONAL_ACCESS_TOKEN
```
Remplacez YOUR_PERSONAL_ACCESS_TOKEN par votre propre jeton.

Configurer un dépôt GitHub hydraté privé

Créez un dépôt GitHub privé pour le dépôt hydraté. Notez le nom que vous donnez au dépôt.
Dans Cloud Shell, définissez une variable d'environnement pour le dépôt hydraté :
```
export HYDRATED_REPO_NAME=YOUR_PRIVATE_HYDRATED_REPO
export HYDRATED_REPO='git@github.com:$REPO_OWNER/$HYDRATED_REPO_NAME.git'
```
Remplacez YOUR_PRIVATE_HYDRATED_REPO par le nom de votre dépôt hydraté.
Créez une paire de clés de déploiement :
```
ssh-keygen -t rsa -b 4096 \
-C 'active-assist-robot' \
-N '' \
-f $(pwd)/active-assist-robot
```
Une clé de déploiement vous permet de déployer des fichiers dans votre dépôt GitHub privé lorsque vous exécutez une tâche Cloud Build pour hydrater des fichiers de configuration.
Imprimez la clé générée :
```
cat $(pwd)/active-assist-robot.pub
```
Ajoutez la clé de déploiement au dépôt GitHub privé. Veillez à sélectionner Autoriser l'accès en écriture lorsque vous ajoutez la clé de déploiement. Pour savoir comment ajouter des clés de déploiement à des dépôts GitHub, consultez la documentation GitHub sur la gestion des clés de déploiement.

Importer des clés GitHub dans Secret Manager

Dans Cloud Shell, créez un secret pour stocker la clé privée de la paire de clés de déploiement :
```
gcloud secrets create github-ssh-key \
  --data-file=$(pwd)/active-assist-robot
```

Créez un secret pour stocker le jeton d'accès personnel :

echo $GITHUB_TOKEN | gcloud secrets create github-pat --data-file=-

Créer un cluster GKE

Dans cette section, vous allez créer un cluster GKE avec le module complémentaire Config Connector, créer une identité et configurer Config Connector. Vous devez également configurer Config Sync. Vous pouvez utiliser Config Sync pour créer une configuration commune à l'ensemble de votre infrastructure (y compris des règles personnalisées) s'appliquant aussi bien sur site que dans le cloud. Config Sync identifie les modifications apportées et les déploie sur tous vos clusters afin de refléter systématiquement l'état désiré dans vos clusters.

Dans Cloud Shell, créez un cluster GKE avec le module complémentaire Config Connector activé :

gcloud container clusters create sample-ops \
  --machine-type n1-standard-4 \
  --zone $ZONE \
  --release-channel regular \
  --addons ConfigConnector \
  --workload-pool=$RECO_MGR_PROJECT.svc.id.goog \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias

Renseignez les sections suivantes du guide Installer avec le module complémentaire GKE pour créer une identité et configurer Config Connector.
1. Créer une identité
2. Configurer Config Connector
Installez Config Sync dans le cluster GKE que vous avez créé. Lorsque vous configurez Config Sync, vous devez effectuer les opérations suivantes :
1. Utilisez un jeton pour accorder à Config Sync un accès en lecture seule à Git. Utilisez le jeton GitHub que vous avez créé lors de la configuration d'un dépôt GitHub DRY privé. Le jeton est disponible via la variable d'environnement $GITHUB_TOKEN.
2. Configurez Config Sync à l'aide de gcloud. Définissez les paramètres suivants :
  1. sourceFormat : hierarchy
  2. syncRepo : https://github.com/YOUR_GITHUB_USERNAME/YOUR_PRIVATE_HYDRATED_REPO
  3. syncBranch : main
  4. secretType : token
  5. policyDir : ne remplissez pas cette option

Créer un déclencheur Cloud Build à transférer vers le dépôt hydraté

Dans les sections suivantes, vous allez créer un déclencheur Cloud Build qui se déclenche lorsque des modèles sont transférés vers la branche principale de votre dépôt YOUR_PRIVATE_DRY_REPO. Ce déclencheur exécute les étapes qui hydratent les modèles KRM "configuration en tant que données" dans le dépôt YOUR_PRIVATE_DRY_REPO, puis transfère les fichiers de configuration hydratés vers votre dépôt YOUR_PRIVATE_HYDRATED_REPO.

Connectez Cloud Build à votre dépôt GitHub.

Dans cette section, vous allez connecter les dépôts GitHub YOUR_PRIVATE_DRY_REPO et YOUR_PRIVATE_HYDRATED_REPO à Cloud Build.

Accédez à la page GitHub Marketplace pour l'application Cloud Build.

Accéder à la page de l'application Cloud Build
Cliquez sur Setup with Google Cloud Build (Configurer avec Google Cloud Build).
Si vous y êtes invité, connectez-vous à GitHub.
Sélectionnez Sélectionner uniquement les dépôts.

Utilisez la liste déroulante Sélectionner des dépôts pour autoriser l'accès à vos dépôts YOUR_PRIVATE_DRY_REPO et YOUR_PRIVATE_HYDRATED_REPO via l'application Cloud Build.
Cliquez sur Installer.
Connectez-vous à Google Cloud. La page Autorisation s'affiche et vous invite à autoriser l'application Google Cloud Build à se connecter à Google Cloud.
Cliquez sur Autoriser Google Cloud Build par GoogleCloudBuild. Vous êtes redirigé vers la console Google Cloud .
Sélectionnez votre projet Google Cloud .
Cochez la case pour accorder votre autorisation, puis cliquez sur Suivant.
Cliquez sur Installer.
Connectez-vous à Google Cloud. La page Autorisation s'affiche et vous invite à autoriser l'application Google Cloud Build à se connecter à Google Cloud.
Cliquez sur Autoriser Google Cloud Build par GoogleCloudBuild. Vous êtes redirigé vers la console Google Cloud .
Sélectionnez votre projet Google Cloud .
Cochez la case pour accorder votre autorisation, puis cliquez sur Suivant.
Sur la page Sélectionner un dépôt qui s'affiche, sélectionnez les dépôts GitHub suivants :
- YOUR_PRIVATE_DRY_REPO
- YOUR_PRIVATE_HYDRATED_REPO
Cliquez sur Connect (Connecter), puis sur Done (OK).

Créer un déclencheur Cloud Build pour le dépôt DRY

Dans Cloud Shell, exécutez la commande suivante :
```
envsubst < cloudbuild.template.yaml > cloudbuild.yaml
```
La commande génère un fichier cloudbuild.yaml.

Créez le déclencheur :

gcloud beta builds triggers create github \
  --name ActiveAssistDemo \
  --repo-name=$DRY_REPO_NAME \
  --repo-owner=$REPO_OWNER \
  --branch-pattern="main" \
  --build-config=cloudbuild.yaml

Autorisez le compte de service Cloud Build à accéder à Secret Manager :

gcloud secrets add-iam-policy-binding github-ssh-key  \
  --member="serviceAccount:${RECO_MGR_PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

gcloud secrets add-iam-policy-binding github-pat  \
  --member="serviceAccount:${RECO_MGR_PROJECT_NUMBER}@cloudbuild.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

Créer un déclencheur Cloud Build planifié pour les recommandations Active Assist

Dans les sections suivantes, vous allez créer un déclencheur Cloud Build planifié qui s'exécute régulièrement. Ce déclencheur extrait les recommandations Active Assist à l'aide d'une fonction kpt et détermine s'il existe des recommandations actives pour les ressources de votre dépôt YOUR_PRIVATE_HYDRATED_REPO. La fonction kpt crée également un problème GitHub dans votre dépôt YOUR_PRIVATE_HYDRATED_REPO si des recommandations actives de configuration de ressources doivent être examinées et activées.

Générer une image Cloud Build

Dans cette section, vous allez générer une image Cloud Build comportant des composants kpt, gh et Node.

Dans Cloud Shell, créez et transférez une image Docker vers Container Registry :

gcloud auth configure-docker

docker build -t gcr.io/$RECO_MGR_PROJECT/kpt-dev-gh:1 ./recommender-kpt-function

docker push gcr.io/$RECO_MGR_PROJECT/kpt-dev-gh:1

Créer un déclencheur Cloud Build pour votre dépôt hydraté

Dans Cloud Shell, créez le fichier de configuration nécessaire à la configuration du déclencheur Cloud Build planifié :
```
 envsubst < cloudbuild-scheduled-recommendations.template.yaml > cloudbuild-scheduled-recommendations.yaml
```

Créez le déclencheur Cloud Build :

gcloud beta builds triggers create github \
  --name ActiveAssistScheduledRecommendations \
  --repo-name=YOUR_PRIVATE_HYDRATED_REPO \
  --repo-owner=$REPO_OWNER \
  --branch-pattern="main" \
  --build-config=cloudbuild-scheduled-recommendations.yaml

Obtenez l'ID de ce déclencheur :

export TRIGGER_ID=`gcloud beta builds triggers describe \
  ActiveAssistScheduledRecommendations \
  --format="value(id)"`

Créer une tâche Cloud Scheduler pour appeler votre déclencheur

Dans Cloud Shell, créez un compte de service à l'aide des commandes suivantes :

gcloud iam service-accounts create build-invoker \
   --description "Service Account used by Cloud Scheduler to invoke the sample scheduled Cloud Build job" \
   --display-name "recommender-scheduler-sa" \
   --project $RECO_MGR_PROJECT

Les tâches Cloud Scheduler utilisent ce compte de service pour exécuter le service recommender-parser.

Accordez au compte de service les autorisations nécessaires pour appeler une tâche Cloud Build :

gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:build-invoker@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/cloudbuild.builds.editor \
  --project $RECO_MGR_PROJECT

 gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
   --member serviceAccount:build-invoker@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
   --role roles/serviceusage.serviceUsageConsumer \
   --project $RECO_MGR_PROJECT

Créez une tâche Cloud Scheduler pour appeler le déclencheur que vous avez créé à l'étape précédente :

gcloud scheduler jobs create http scheduled-build \
   --project $RECO_MGR_PROJECT \
   --time-zone "America/Los_Angeles" \
   --schedule="0 */3 * * *" \
   --uri="https://cloudbuild.googleapis.com/v1/projects/${RECO_MGR_PROJECT}/triggers/${TRIGGER_ID}:run" \
   --description="Scheduler job to invoke Cloud Build" \
   --oauth-service-account-email="build-invoker@$RECO_MGR_PROJECT.iam.gserviceaccount.com" \
   --headers="Content-Type=application/json" \
   --http-method="POST" \

Sélectionnez Y si le message suivant s'affiche :

There is no App Engine app in the project.

Si vous êtes invité à choisir la région dans laquelle vous souhaitez déployer votre application App Engine, sélectionnez la région us-central.

Procéder au commit et au transfert des fichiers de configuration Cloud Build vers GitHub

Transférez les deux fichiers de configuration Cloud Build que vous avez créés vers votre dépôt YOUR_PRIVATE_DRY_REPO :

git remote add dry https://github.com/$REPO_OWNER/$DRY_REPO_NAME.git

git add cloudbuild.yaml
git add cloudbuild-scheduled-recommendations.yaml
git commit -m "Added cloudbuild configuration YAMLs"
git push dry main

Vous serez peut-être invité à saisir vos identifiants GitHub lorsque vous transférerez des données vers votre dépôt privé.

Examiner le résultat de la tâche Cloud Build

Lorsque vous procédez au commit et au transfert des modifications dans votre dépôt YOUR_PRIVATE_DRY_REPO, la tâche Cloud Build est déclenchée. Si la tâche Cloud Build s'exécute correctement, plusieurs ressources sont créées. Dans cette section, vous allez vérifier si les ressources sont créées une fois la tâche Cloud Build terminée.

Dans Cloud Shell, dans votre cluster sample-ops, vérifiez que vous disposez d'un espace de noms appelé activeassist-kcc :
```
kubectl get ns | grep activeassist-kcc
```
Config Connector déploie un exemple d'instance Compute Engine en cours d'exécution dans votre projet PROJECT_ID.

Vérifiez que l'instance Compute Engine se trouve dans le projet :
```
 gcloud compute instances list | grep \
 computeinstance-sample-cloudmachine
```
Le type MACHINE_TYPE pour cette machine est n1-standard-1.

Exécuter des tests de bout en bout

Pour vous permettre de tester le pipeline de bout en bout, le dépôt que vous avez cloné pour ce tutoriel fournit des exemples de recommandations (simulations). Vous utilisez ces simulations pour exécuter le pipeline de bout en bout. La simulation imite la charge utile d'une recommandation Active Assist et recommande de modifier le type de machine de l'instance Compute Engine déployée du type d'instance n1-standard-1 vers le type d'instance g1-small.

Dans cette section, vous allez appeler manuellement le déclencheur Cloud Build planifié pour exécuter la tâche qui utilise une fonction kpt afin de récupérer les recommandations Active Assist. Vous vérifiez également qu'un problème GitHub est créé dans votre dépôt YOUR_PRIVATE_DRY_REPO.

Ouvrez la page Déclencheurs de compilation dans la console Google Cloud .

Ouvrir la page Déclencheurs de compilation
Sélectionnez le déclencheur ActiveAssistScheduledRecommendations.
Pour tester manuellement le déclencheur, cliquez sur Exécuter sur l'entrée de votre déclencheur dans la liste des déclencheurs.

Le déclencheur crée un problème GitHub dans votre dépôt YOUR_PRIVATE_DRY_REPO. Le résultat ressemble à ce qui suit :
```
gcloud auth configure-docker

docker build -t gcr.io/$RECO_MGR_PROJECT/kpt-dev-gh:1 ./recommender-kpt-function

docker push gcr.io/$RECO_MGR_PROJECT/kpt-dev-gh:1
```
Dans l'exemple de problème, le résultat de la fonction kpt indique que le type MACHINE_TYPE actuel de l'instance Compute Engine est le type n1-standard-1. La recommandation Active Assist consiste à le remplacer par le type g1-small.

Les réviseurs de contrôle des versions de votre entreprise peuvent examiner les problèmes GitHub automatisés et les corriger en fonction de vos besoins.