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

Configurer votre environnement

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

1. Dans la console Google Cloud, activez Cloud Shell.

   Activer Cloud Shell

2. Définissez des variables pour l'ID et le numéro du projet Google 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.

3. Définissez des variables pour la région de déploiement :

   export REGION=us-central1
   export ZONE=us-central1-a
   

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

5. 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é

1. Créez un dépôt GitHub privé pour le dépôt DRY. Notez le nom que vous donnez au dépôt.

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

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

4. 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é

1. Créez un dépôt GitHub privé pour le dépôt hydraté. Notez le nom que vous donnez au dépôt.

2. 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='[email protected]:$REPO_OWNER/$HYDRATED_REPO_NAME.git'
   

   Remplacez YOUR_PRIVATE_HYDRATED_REPO par le nom de votre dépôt hydraté.

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

4. Imprimez la clé générée :

   cat $(pwd)/active-assist-robot.pub
   

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

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

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

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

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

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

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

   Accéder à la page de l'application Cloud Build

2. Cliquez sur Setup with Google Cloud Build (Configurer avec Google Cloud Build).

3. Si vous y êtes invité, connectez-vous à GitHub.

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

5. Cliquez sur Installer.

6. Connectez-vous à Google Cloud. La page "Autorisation" s'affiche et vous invite à autoriser l'application Google Cloud Build à se connecter à Google Cloud.

7. Cliquez sur Autoriser Google Cloud Build par GoogleCloudBuild. Vous êtes redirigé vers Google Cloud Console.

8. Sélectionnez votre projet Google Cloud.

9. Cochez la case pour accorder votre autorisation, puis cliquez sur Suivant.

10. Cliquez sur Installer.

11. Connectez-vous à Google Cloud. La page "Autorisation" s'affiche et vous invite à autoriser l'application Google Cloud Build à se connecter à Google Cloud.

12. Cliquez sur Autoriser Google Cloud Build par GoogleCloudBuild. Vous êtes redirigé vers Google Cloud Console.

13. Sélectionnez votre projet Google Cloud.

14. Cochez la case pour accorder votre autorisation, puis cliquez sur Suivant.

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

16. Cliquez sur Connect (Connecter), puis sur Done (OK).

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

1. Dans Cloud Shell, exécutez la commande suivante :

   envsubst < cloudbuild.template.yaml > cloudbuild.yaml
   

   La commande génère un fichier cloudbuild.yaml.

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

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

1. 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é

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

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

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

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

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

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

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

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

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

   Ouvrir la page Déclencheurs de compilation

2. Sélectionnez le déclencheur ActiveAssistScheduledRecommendations.

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