Estimer vos coûts GKE dès le début du cycle de développement à l'aide de GitHub

Last reviewed 2022-12-15 UTC

Autopilot Standard

Ce tutoriel présente la bonne pratique qui consiste à transférer la visibilité des coûts Google Kubernetes Engine (GKE) à votre équipe de développement. Cette pratique de décalage à gauche vous permet de comprendre les coûts dès le début de la procédure et d'éviter les surprises sur votre facture Google Cloud.

Ce tutoriel est destiné aux développeurs, aux opérateurs et aux professionnels FinOps qui souhaitent optimiser les coûts des clusters GKE et utilisent GitHub en production. Si vous utilisez GitLab, consultez la page Estimer les coûts GKE dès le début du cycle de développement à l'aide de GitLab.

Le tutoriel suppose que vous connaissez bienDocker, GitHub, Kubernetes, GKE, Cloud Build et Linux.

Présentation

De nombreuses équipes qui adoptent le cloud public ne sont pas habituées à la facturation à l'utilisation. Il est fréquent qu'ils ne comprennent pas complètement l'environnement sur lequel leurs applications s'exécutent, à savoir dans le cas présent, GKE. Le modèle d'exploitation FinOps favorise cette culture de la responsabilité financière. Une bonne pratique FinOps consiste à fournir aux équipes des informations en temps réel sur leurs dépenses afin de résoudre les problèmes de coûts dès qu'ils surviennent.

Ce document vous explique comment aller plus loin en estimant les coûts avant qu'ils ne deviennent une dépense sur votre facture. Comme indiqué sur le site Web GitHub, "sur GitHub, des outils de révision de code légers sont intégrés à chaque demande d'extraction." Vous pouvez ainsi "faire évoluer des projets, proposer de nouvelles fonctionnalités et discuter des détails de la mise en œuvre avant de modifier votre code source". Le meilleur moment pour estimer les coûts doit se situer au début du processus, au cours du développement et au moment de la révision du code. De cette façon, les professionnels peuvent comprendre et discuter des alternatives pour l'impact au niveau du coût des nouvelles fonctionnalités et corrections de bugs avant que cela ne devienne un problème. Le diagramme suivant résume une telle pratique.

Il s'agit d'une bonne pratique consistant à estimer les coûts de manière anticipée.

Comme le montre le schéma, un développeur estime les coûts liés à GKE dans son environnement local, de préférence au moment de la compilation. Cette estimation leur donne une bonne compréhension du coût mensuel de la charge de travail de production. Lorsque la fonctionnalité ou la correction de bug est terminée sur le plan du code, elles proposent une demande d'extraction qui déclenche la vérification de Cloud Build de la différence entre l'ancien et le nouveau coût. Si les augmentations dépassent un seuil prédéfini, elles peuvent demander un nouvel examen du code. Cette pratique aide les développeurs à prendre connaissance de la capacité de leur charge de travail et à corriger les problèmes d'application de manière proactive au lieu d'ajouter des ressources chaque fois qu'une instabilité est détectée en production.

Objectifs

Créer et transférer l'image Kubernetes de cost-estimator
Créez un dépôt GitHub.
Connectez Cloud Build à votre dépôt GitHub.
Transférer l'exemple de code dans votre dépôt GitHub
Modifiez le code et proposez une demande d'extraction pour voir l'estimation des coûts en action.

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.

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 Google Cloud Console, accédez à la page de sélection du projet.

Accéder au sélecteur de 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.

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Préparer votre environnement

Dans Cloud Shell, clonez le dépôt GitHub gke-shift-left-cost :
```
git clone https://github.com/GoogleCloudPlatform/gke-shift-left-cost
cd gke-shift-left-cost
```
Le code dans ce dépôt est structuré avec les dossiers suivants :
- Racine: contient un fichier Dockerfile utilisé pour créer l'image cost-estimator et le fichier main.go qui met en œuvre la logique de ligne de commande pour l'estimateur.
- api/: contient l'API Golang pour manipuler les objets Kubernetes et effectuer l'estimation des coûts.
- samples/: contient des exemples de fichiers manifestes Kubernetes afin que vous puissiez tester le processus avant de le mettre en œuvre dans votre organisation.
Définissez votre ID de projet Google Cloud, votre utilisateur GitHub et votre adresse e-mail, ainsi qu'un autre utilisateur GitHub pour agir en tant qu'examinateur FinOps :
```
export GCP_PROJECT_ID=YOUR_PROJECT_ID
export GITHUB_USER=YOUR_GITHUB_USER
export GITHUB_EMAIL=YOUR_GITHUB_EMAIL_ADDRESS
export GITHUB_FINOPS_REVIEWER_USER=ANOTHER_GITHUB_USER
```
Remplacez les éléments suivants :
- YOUR_PROJECT_ID : ID du projet Google Cloud que vous utilisez dans ce tutoriel.
- YOUR_GITHUB_USER: l'utilisateur avec lequel vous vous connectez à votre compte GitHub.
- YOUR_GITHUB_EMAIL_ADDRESS: adresse e-mail que vous utilisez dans votre compte GitHub.
- ANOTHER_GITHUB_USER: autre utilisateur GitHub agissant en tant qu'examinateur FinOps. Notez que ce tutoriel nécessite d'ajouter cet utilisateur en tant que collaborateur du dépôt. Il ne peut donc pas être vous-même. Pour éviter de rester bloqué pendant les étapes du tutoriel, assurez-vous que cet utilisateur accepte votre invitation dès que vous créez l'invitation.

Définissez le projet Google Cloud et activez les API requises :

gcloud config set project $GCP_PROJECT_ID

gcloud services enable cloudbilling.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com

Créer et transférer l'image Kubernetes de cost-estimator

L'outil d'estimation des coûts de Kubernetes fourni avec ce tutoriel n'est qu'un exemple. Il offre la possibilité d'estimer les coûts des objets Kubernetes DaemonSet, Deployment, StatefulSet, ReplicaSet, HorizontalPodAutoScaler et PersistentVolumeClaim. Vous pouvez également mettre en œuvre votre propre outil d'estimation des coûts ou proposer des demandes d'extraction avec les améliorations souhaitées.

Dans Cloud Shell, autorisez application-default à utiliser vos identifiants:
```
gcloud auth application-default login
```

Créez le binaire cost-estimator Kubernetes :

mkdir ./bin
go test ./api
go build -v -o ./bin/k8s-cost-estimator .

Testez le binaire en exécutant l'estimation des coûts dans un exemple de dossier:

./bin/k8s-cost-estimator \
    --k8s ./samples/k8s-cost-estimator-local/app-v1  \
    --config ./samples/k8s-cost-estimator-local/example-conf.yaml --v trace

Dans le résultat, vous voyez un tableau Markdown qui détaille les coûts mensuels estimés pour le dossier ./samples/k8s-cost-estimator-local/app-v1/. Pour mieux comprendre le coût mensuel de production de leurs applications, les développeurs peuvent exécuter cette étape avant de procéder au transfert vers le dépôt distant.

INFO[0000] Starting cost estimation (version v0.0.1)...
...

|         KIND          | MIN REQUESTED (USD) | MIN REQ + HPA CPU BUFFER (USD) | MAX REQUESTED (USD) | MIN LIMITED (USD) | MAX LIMITED (USD) |
|-----------------------|---------------------|--------------------------------|---------------------|-------------------|-------------------|
| Deployment            |             $133.31 |                        $198.71 |             $266.54 |           $312.83 |           $579.29 |
| StatefulSet           |              $36.33 |                         $36.33 |              $36.33 |            $72.67 |            $72.67 |
| DaemonSet             |              $29.68 |                         $29.68 |              $29.68 |            $53.19 |            $53.19 |
| PersistentVolumeClaim |              $28.88 |                         $28.88 |              $28.88 |            $33.68 |            $33.68 |
| **TOTAL**             |         **$228.20** |                    **$293.60** |         **$361.43** |       **$472.38** |       **$738.83** |

INFO[0002] Finished cost estimation!

Créez l'image du conteneur cost-estimator Kubernetes:

docker build . -t us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Créez le dépôt Docker Artifact Registry pour stocker l'image:

gcloud artifacts repositories create docker-repo \
        --repository-format=docker \
        --location=us-central1 \
        --description="Docker repository"

Enregistrez gcloud en tant qu'assistant d'identification dans le fichier de configuration de Docker. Si vous y êtes invité, confirmez la mise à jour du fichier.
```
gcloud auth configure-docker us-central1-docker.pkg.dev
```

Transfert de l'image vers Artifact Registry

docker push us-central1-docker.pkg.dev/$GCP_PROJECT_ID/docker-repo/k8s-cost-estimator:v0.0.1

Créer un dépôt GitHub

Dans Cloud Shell, remplacez les répertoires par l'exemple GitHub:
```
cd samples/k8s-cost-estimator-github
```
Dans GitHub, créez un jeton d'accès:

Accédez à la page Jetons d'accès personnels GitHub.
1. Dans le champ Note, saisissez une description du jeton.
2. Sous Sélectionner des champs d'application, cochez les cases repo, admin:public_key et delete_repo.
3. Cliquez sur Générer un jeton et copiez la valeur de votre nouveau jeton d'accès personnel en haut de la page.
Dans Cloud Shell, enregistrez votre jeton d'accès personnel dans une variable.
```
GITHUB_TOKEN=YOUR_NEW_PERSONAL_ACCESS_TOKEN
```
Remplacez l'élément suivant :
- YOUR_NEW_PERSONAL_ACCESS_TOKEN: jeton d'accès personnel que vous venez de créer.

Créez un dépôt GitHub.

curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/repos \
  -d '{"name":"k8s-cost-estimator-github"}' | jq

Le résultat ressemble à ce qui suit :

{
  "id": 36099474,
  "node_id": "MDEwOldfsdjA5OTQ3Njc=",
  "name": "k8s-cost-estimator-github",
  ...
}

Ajoutez l'examinateur FinOps en tant que collaborateur dans votre dépôt:

curl -X PUT \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github/collaborators/$GITHUB_FINOPS_REVIEWER_USER  | jq -r .html_url

Le résultat ressemble à ce qui suit :

https://github.com/your-user/k8s-cost-estimator-github/invitations

Partagez l'URL de sortie avec l'utilisateur que vous avez défini dans la variable GITHUB_FINOPS_REVIEWER_USER afin qu'il puisse accepter l'invitation. Avant de passer à l'étape suivante, accédez à la même URL pour vous assurer que l'invitation a été acceptée.

Connecter Cloud Build à votre dépôt GitHub

Cette section vous explique comment installer leApplication GitHub Cloud Build. Cette installation vous permet de connecter votre dépôt GitHub à votre projet Google Cloud afin que Cloud Build puisse exécuter automatiquement l'outil d'estimation Kubernetes à chaque demande d'extraction.

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

Ouvrir Cloud Build
Configurez l'accès au compte GitHub pour l'application:
1. Si vous configurez une application dans GitHub pour la première fois, cliquez sur Configurer avec Google Cloud Build en bas de la page, puis sur Accorder l'accès à cette application à votre Compte GitHub.
2. Si vous avez déjà configuré une application dans GitHub, cliquez sur Configurer l'accès.
Sur la page Applications qui s'affiche, procédez comme suit:
1. Sur la ligne Google Cloud Build, cliquez sur Configurer.
2. Sélectionnez l'option Only select repositories (Sélectionner uniquement les dépôts).
3. Sélectionnez k8s-cost-estimator-github pour vous connecter au dépôt que vous venez de créer.
4. Cliquez sur Enregistrer ou sur Installer (le libellé du bouton change en fonction du flux que vous exécutez).
Vous êtes maintenant redirigé vers Google Cloud pour poursuivre l'installation. Connectez-vous avec votre compte Google Cloud. Si vous y êtes invité, autorisez l'intégration de Cloud Build à GitHub.
Sur la page Cloud Build, sélectionnez votre projet. Un assistant s'affiche.
Dans la section Sélectionner un dépôt de l'assistant, sélectionnez votre compte GitHub et le dépôt k8s-cost-estimator-github.
Si vous acceptez les conditions d'utilisation, cochez la case puis cliquez sur Connect (Se connecter).
Dans la section Créer un déclencheur, cliquez sur Créer un déclencheur, puis procédez comme suit :
1. Saisissez un nom de déclencheur
2. Dans la section Événement, sélectionnez Demande d'extraction (application GitHub uniquement).
3. Dans la section Source :
  - Assurez-vous que le champ Dépôt est automatiquement rempli avec your-github-user/k8s-cost-estimator-github (application GitHub).
  - Dans la liste déroulante Branche de base, sélectionnez .*.
4. Dans la section Type de configuration, sélectionnez Fichier de configuration Cloud Build (yaml ou json).
5. Dans la section Avancé, ajoutez les variables de substitution suivantes:
  - _GITHUB_TOKEN = YOUR_PERSONAL_ACCESS_TOKEN
  - _GITHUB_FINOPS_REVIEWER_USER = THE_GITHUB_FINOPS_REVIEWER_USER
  - _GITHUB_FINOPS_COST_USD_THRESHOLD = 10
  Remplacez l'élément suivant :
  - YOUR_PERSONAL_ACCESS_TOKEN: jeton d'accès personnel GitHub que vous avez créé. Ce jeton est disponible dans la variable GITHUB_TOKEN de Cloud Shell.
  - THE_GITHUB_FINOPS_REVIEWER_USER: utilisateur que vous avez invité en tant que collaborateur dans votre dépôt GitHub. Ce nom d'utilisateur est disponible dans la variable GITHUB_FINOPS_REVIEWER_USER de Cloud Shell.
Cliquez sur Créer.

L'application GitHub Cloud Build est maintenant configurée et votre dépôt GitHub est lié à votre projet Google Cloud. Les demandes d'extraction vers votre dépôt GitHub déclenchent désormais des exécutions de Cloud Build, qui renvoient les résultats à GitHub à l'aide des vérifications GitHub.

Transférer l'exemple de code dans votre dépôt GitHub

Créez une paire de clés SSH pour pouvoir transférer l'exemple de code vers votre dépôt GitHub:

mkdir -p ssh && cd ssh
ssh-keygen -t rsa -b 4096 -N '' -f github-key
eval `ssh-agent` && ssh-add $(pwd)/github-key
curl -X POST \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/keys \
  -d "{\"title\":\"k8s-cost-estimator-key\", \"key\":\"$(cat github-key.pub)\"}" | jq
cd ..

Le résultat ressemble à ce qui suit :

{
  "id": 52356205,
  "key": "ssh-rsa AAAAB3NzaC….wJICyt0yvWjGFZGCWBPUw==",
  "url": "https://api.github.com/user/keys/526205",
  "title": "k8s-cost-estimator-key",
  "verified": true,
  "created_at": "2021-04-23T16:22:58Z",
  "read_only": false
}

Transférez le contenu vers votre nouveau dépôt GitHub:

sed "s/GCP_PROJECT_ID/$GCP_PROJECT_ID/g; s/GITHUB_USER/$GITHUB_USER/g; s/GITHUB_EMAIL/$GITHUB_EMAIL/g;" templates/cloudbuild.yaml.tpl > cloudbuild.yaml

GITHUB_SSH_URL_REPO=$(curl -X GET \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github | jq -r .ssh_url)
[ -z "$GITHUB_SSH_URL_REPO" ] && echo "GITHUB_SSH_URL_REPO is not exported" || echo "GITHUB_SSH_URL_REPO is $GITHUB_SSH_URL_REPO"

git init
git remote add origin $GITHUB_SSH_URL_REPO
git add -A .
git commit -m "Initial commit"
git checkout -b main
git push -u origin main

Modifier le code et créer une demande d'extraction pour tester l'estimation des coûts

Dans Cloud Shell, obtenez l'URL GitHub du fichier wordpress/wordpress_hpa.yaml:

echo "https://github.com/$GITHUB_USER/k8s-cost-estimator-github/edit/main/wordpress/wordpress_hpa.yaml"

Appuyez sur Ctrl+clic (Cmd+clic pour les utilisateurs Mac) sur l'URL de sortie pour accéder à GitHub et modifier le fichier wordpress/wordpress_hpa.yaml.
Dans GitHub, remplacez minReplicas par 5.
Sélectionnez Créer une branche pour ce commit et démarrer une demande de fusion, puis cliquez sur Proposer des modifications.
Sur l'écran Ouvrir une demande d'extraction, cliquez sur Créer une demande d'extraction.

Au-delà de la création d'une demande d'extraction, cette étape déclenche une exécution Cloud Build basée sur le fichier cloudbuild.yaml que vous avez créé précédemment. Cette exécution Cloud Build utilise l'image de conteneur que vous avez créée à la section Créer et transférer l'image Kubernetes cost-estimator et prend la décision lorsqu'un réviseur FinOps est requis.
Attendez environ une minute pour que le pipeline se termine. Une fois l'opération terminée, un commentaire avec les détails des coûts est ajouté à la demande d'extraction et, comme l'augmentation du coût du code que vous proposez a dépassé le seuil de 10 $, un examinateur FinOps est également demandé.

Le résultat ressemble à ce qui suit :

Vous savez maintenant comment permettre à vos développeurs de visualiser leurs dépenses dès le début du cycle de développement. Cette configuration vous aide, vous et votre organisation, à éviter les surprises sur votre facture Google Cloud.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel ne soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet.

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.

Supprimer le dépôt GitHub

Si vous ne souhaitez pas conserver votre dépôt GitHub, procédez comme suit:

Dans Cloud Shell, supprimez votre dépôt GitHub:

curl -X DELETE \
  -H "Accept: application/vnd.github.v3+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/repos/$GITHUB_USER/k8s-cost-estimator-github

Si vous perdez votre connexion avec Cloud Shell, vous devez réinitialiser les variables GITHUB_TOKEN et GITHUB_USER.

Étape suivante

Si vous utilisez GitLab, consultez la section Estimer les coûts GKE dès le début du cycle de développement à l'aide de GitLab.
Consultez la section Bonnes pratiques pour l'exécution d'applications Kubernetes à coût maîtrisé sur GKE pour en savoir plus sur l'optimisation des coûts sur GKE.
Découvrez des recommandations de conception et des bonnes pratiques pour optimiser le coût des charges de travail Google Cloud dans le framework d'architecture Google Cloud : optimisation des coûts.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.