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

Présentation détaillée de la CLI Gemini

1. Introduction

Bonjour, Je m'appelle Sparky ! Nous sommes ravis de vous accueillir. Je suis venu tout droit d'un cluster GKE dans us-central1 pour être ici aujourd'hui. Bienvenue dans cet atelier de programmation.

J'ai passé toute ma vie à parcourir les flux de données de Google Cloud, et j'ai tout vu. J'ai vu des architectes et des ingénieurs comme vous créer des choses incroyables. Mais je t'ai aussi vu rester coincé dans les ronces. Vous voyez ce que je veux dire ! Ce sentiment de changement de contexte lorsque vous déboguez un pod dans GKE. Vous passez de kubectl logs à la console GCP pour vérifier l'état du nœud, à votre IDE pour examiner le code source déployé et à un onglet de navigateur avec la documentation officielle de Kubernetes sur les hooks de cycle de vie des pods. Chaque saut est une perte de concentration !

Et les outils complexes ! gcloud, kubectl, terraform… chacun avec son propre DSL et une montagne de flags. Cela conduit à une recherche constante de documentation. Vous finissez par rechercher la commande gcloud idéale avec la bonne combinaison d'indicateurs --filter et --format pour obtenir les données dont vous avez besoin. C'est comme essayer de trouver une noix spécifique dans une forêt de millions d'arbres. Et ne me lancez pas sur les tâches répétitives. J'ai vu que vous aviez écrit les mêmes Dockerfile et cloudbuild.yaml pour un nouveau service Python à plusieurs reprises. Le code doit probablement avoir un déjà-vu.

Je suis là pour vous montrer une meilleure façon de faire. Un sentier secret à travers les bois. C'est exactement l'objectif de la CLI Gemini !

Qu'est-ce que la CLI Gemini ?

Alors, quel est ce raccourci magique qui m'enthousiasme autant ?

Considérez la CLI Gemini comme votre compagnon cloud personnel, directement dans votre terminal. C'est une conversation, un partenariat ! Il est contextuel, ce qui signifie qu'il ne se contente pas d'écouter, mais qu'il comprend. Il peut lire vos fichiers, apprendre les conventions de votre projet (par exemple, si vous utilisez des tabulations ou des espaces) et comprendre ce que vous essayez de faire. C'est comme si je pouvais sentir les glands que vous essayez de ramasser !

Architecture de haut niveau (jetons un coup d'œil sous le capot !)

Comment cela fonctionne-t-il ? Il s'agit d'un mélange de plusieurs éléments intéressants qui fonctionnent en harmonie :

Un puissant modèle de langage : c'est le cerveau ! Plus précisément, il s'agit d'un grand modèle multimodal entraîné par Google. Le terme multimodal signifie qu'il ne comprend pas seulement le texte, mais aussi la structure et la signification du code. Cela lui permet de raisonner sur votre logiciel, et pas seulement de le lire.
Votre contexte local : c'est un élément essentiel. L'interface de ligne de commande Gemini s'exécute en tant que processus sur votre machine locale, avec les mêmes autorisations que votre compte utilisateur. Cela signifie qu'il peut accéder à votre système de fichiers pour vous fournir une aide spécifique à votre projet. Il ne s'agit pas d'un service cloud distant qui devine votre code, mais d'un outil qui est là, avec vous.
Écosystème d'outils : c'est la façon dont le modèle interagit avec le monde. Il dispose d'un ensemble de fonctions bien défini qu'il peut appeler, comme read_file ou run_shell_command. Considérez-le comme une API sécurisée. Le modèle décide quoi faire et quel outil utiliser, puis il génère un bloc tool_code pour l'exécuter. Ses actions sont donc prévisibles et fiables.
Exécution de commandes Shell : c'est là que la magie opère ! Il peut exécuter n'importe quelle commande dans un sous-shell bash -c <command>. Il capture stdout, stderr et exit code. C'est énorme ! Cela signifie que Gemini CLI peut exécuter une commande, vérifier si elle a échoué, puis essayer de la corriger en fonction du message d'erreur.
Le filet de sécurité : c'est ma partie préférée ! Avant l'exécution de ce bloc tool_code, le client CLI vous montrera la commande ou le code exact et vous demandera de confirmer. Il s'agit d'une vérification côté client. Vous avez donc le dernier mot avant que quoi que ce soit ne touche votre système. C'est toujours vous qui décidez !

Ce n'est pas qu'un chatbot, c'est un assistant ! Un assistant actif dans votre aventure de codage.

Concept clé : impératif ou déclaratif

Le changement le plus important et le plus impressionnant consiste à passer de la méthode how (comment) à la méthode what (quoi).

Impératif (l'ancienne méthode, plus complexe) : vous devez indiquer chaque étape. Vous devez être un expert dans le langage spécifique au domaine de l'outil. Comme cette commande monstrueuse :
```
gcloud compute instances create my-vm --project=my-project --zone=us-central1-a --machine-type=e2-medium --image-family=debian-11 --image-project=debian-cloud --metadata-from-file startup-script=./startup.sh --tags=http-server,dev
```
Ouh là ! Regardez tout ça ! Vous devez connaître la syntaxe du type de machine, de la famille d'images, des métadonnées et des tags. Si vous en oubliez une, vous obtiendrez une erreur obscure.
Déclaratif (le raccourci Sparky) : Il vous suffit de dire ce que vous voulez en anglais simple.

Create a new e2-medium VM for my web server in us-central1, run the startup.sh script, and tag it for http traffic.

Et voilà ! Gemini analyse votre requête, la mappe aux paramètres de l'outil gcloud, détermine la syntaxe correcte pour chaque indicateur et crée cette grande commande effrayante pour vous. Il vous le présente ensuite pour approbation. L'idée est de vous permettre de réfléchir à la situation dans son ensemble, et non de mémoriser les options de ligne de commande.

Étendre la puissance de Gemini : présentation des extensions CLI

Bien que la Gemini CLI soit un outil puissant dès sa sortie, son véritable potentiel se révèle grâce aux extensions. Les extensions sont des ensembles d'invites, d'outils et de commandes personnalisées qui améliorent les fonctionnalités de l'interface de ligne de commande. Elles vous permettent de l'adapter à vos besoins et workflows spécifiques.

Rechercher et installer des extensions

La CLI Gemini dispose d'un écosystème d'extensions en pleine croissance, développées à la fois par Google et par des développeurs tiers. Vous pouvez parcourir le répertoire officiel des extensions sur geminicli.com/extensions.

Pour installer une extension, vous pouvez utiliser la commande gemini extensions install avec l'URL du dépôt Git de l'extension. Par exemple, pour installer l'extension officielle Cloud SQL pour PostgreSQL, vous devez exécuter la commande suivante :

gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgresql

Bon, assez parlé ! Mettons la main à la pâte et essayons cette fonctionnalité !

2. Avant de commencer

Bonjour, futurs magiciens du cloud ! Sparky, à votre service. Avant de commencer notre grande aventure, nous devons nous assurer que votre environnement d'atelier est prêt. Imaginez que nous préparons nos sacs avec tous les outils et glands magiques avant de partir dans la forêt. Suivez-moi !

Si vous disposez déjà d'un projet Google Cloud, vous pouvez utiliser la Gemini CLI dans Google Cloud Shell, car elle est préinstallée. Vous pouvez également suivre ces étapes pour le configurer sur votre ordinateur local.

Étape 1 : Les bases (prérequis)

Tout bon aventurier a besoin d'une base solide. Avant de pouvoir installer la CLI Gemini, vous devez configurer quelques éléments sur votre machine locale.

SDK Google Cloud (gcloud) : il s'agit de la boîte à outils principale pour Google Cloud. La CLI Gemini fait partie de cette famille.

Vérifiez si le package est installé : exécutez gcloud --version. Si un numéro de version s'affiche, vous n'avez rien d'autre à faire.
Si ce n'est pas le cas : suivez les instructions officielles sur cloud.google.com/sdk/docs/install.

Git : nous en aurons besoin pour cloner le dépôt de l'atelier pratique.

Vérifiez si le package est installé : exécutez git --version.
Si Git n'est pas installé : vous pouvez le télécharger sur git-scm.com/downloads.

Projet GCP et authentification :

Assurez-vous de disposer d'un projet Google Cloud avec la facturation activée. C'est très important !
Connectez-vous à votre compte Google en exécutant la commande suivante :

gcloud auth login

Définissez votre projet pour la session. Recherchez votre ID de projet dans la console GCP et exécutez la commande suivante :

gcloud config set project YOUR_PROJECT_ID

(Remplacez YOUR_PROJECT_ID par l'ID de votre projet.)

Node.js version 20 ou ultérieure

Étape 2 : Profitez de la magie ! (Installer la Gemini CLI)

Maintenant que nous avons vu les bases, passons à l'événement principal ! Nous allons installer la CLI Gemini.

Exécuter instantanément avec npx

# Using npx (no installation required)
npx https://github.com/google-gemini/gemini-cli

Installer globalement avec npm

npm install -g @google/gemini-cli

Installer de manière globale avec Homebrew (macOS/Linux)

brew install gemini-cli

Vérifier la version de Gemini

gemini --version

Un numéro de version devrait s'afficher. Cela confirme que l'installation a réussi.

Étape 3 : Mise sous tension (configuration)

Maintenant que la CLI Gemini est installée, nous devons lui donner les clés du royaume. Pour commencer, lancez-le en exécutant la commande gemini dans le terminal. L'écran suivant devrait s'afficher :

Pour plus de simplicité, vous pouvez vous authentifier avec votre compte Google, ce qui vous donne accès à Gemini 2.5 Pro avec une fenêtre de contexte d'un million de jetons, ainsi qu'à 60 requêtes/minute et 1 000 requêtes/jour maximum, sans avoir à gérer de clé API.

Si vous souhaitez accéder à des modèles Gemini spécifiques ou passer à des limites supérieures si nécessaire, utilisez la clé API Gemini comme méthode d'authentification.

Si vous avez déjà configuré un projet Google et un compte de facturation pour vos équipes Enterprise et vos charges de travail de production, utilisez Vertex AI pour bénéficier d'une sécurité et d'une conformité avancées.

Selon l'option que vous avez choisie, vous serez invité à suivre les étapes suivantes pour configurer l'authentification. Pour en savoir plus sur ces options, consultez la documentation sur la CLI Gemini.

Si vous prévoyez d'utiliser la plate-forme Vertex AI de Google Cloud, quittez d'abord la Gemini CLI en appuyant deux fois sur Ctrl+c, puis définissez les variables d'environnement requises.

Quelle que soit la méthode d'authentification choisie, vous devrez généralement définir les variables GOOGLE_CLOUD_PROJECT et GOOGLE_CLOUD_LOCATION.

Pour définir ces variables :

# Replace with your project ID and desired location (e.g., us-central1)
export GOOGLE_CLOUD_PROJECT="YOUR_PROJECT_ID"
export GOOGLE_CLOUD_LOCATION="YOUR_PROJECT_LOCATION"

Connectons-nous maintenant à Google Cloud :

gcloud auth application-default login

Une fois que vous vous êtes authentifié avec la méthode précédente, relancez la CLI Gemini en exécutant la commande gemini dans le terminal. Dans les options d'authentification, sélectionnez Vertex AI.

Étape 4 : Le test d'étincelle ! (Vérification de votre configuration)

C'est le moment de vérité ! Vérifions si tout fonctionne. Exécutez ces commandes pour vous assurer que tous les voyants sont verts.

Saisissez le prompt suivant :

What is my current directory?

La CLI Gemini devrait vous indiquer votre répertoire de travail actuel. Cela permet de tester le modèle de langage principal et l'intégration du shell.

Tester la connexion GCP :

list my gcs buckets

Si vous avez des buckets GCS, ils devraient être listés. Si ce n'est pas le cas, il vous indiquera qu'il n'y en a pas. Cela confirme qu'il est correctement associé à votre projet GCP.

Étape 5 : Donner plus de super pouvoirs à votre chaîne (Installer des extensions)

Nous allons maintenant améliorer les capacités de la CLI Gemini en installant quelques extensions qui vous seront utiles plus tard dans l'atelier.

Cloud Run

gemini extensions install https://github.com/GoogleCloudPlatform/cloud-run-mcp

Sécurité de la CLI Gemini

gemini extensions install https://github.com/gemini-cli-extensions/security

gcloud

gemini extensions install https://github.com/gemini-cli-extensions/gcloud

Cloud SQL pour PostgreSQL

gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgresql

Si toutes ces commandes ont fonctionné, vous êtes officiellement prêt pour l'atelier ! Votre environnement est configuré et vous êtes prêt à booster votre productivité. À bientôt dans le premier atelier !

3. Concepts fondamentaux et interaction avec l'espace de travail local

OK, prêt à mettre la main à la pâte ? Nous allons maintenant examiner les outils de votre nouvelle boîte à outils Gemini. Je les considère comme mes superpouvoirs pour explorer et créer dans le cloud ! Entrons un peu plus dans les détails de leur fonctionnement.

Fonctionnalités de base

Je regroupe mes pouvoirs en deux catégories : voir ce qui existe et faire des choses concrètes.

Comprendre votre environnement (mes super-sens !)

Avant de construire un nouveau nid, il faut d'abord examiner l'arbre, n'est-ce pas ? Ces outils vous permettent de vous familiariser avec le terrain.

list_directory : il s'agit de mon outil de base pour "renifler" les environs. Il s'agit d'un wrapper simple autour de la liste des répertoires au niveau de l'OS standard. Mais le plus intéressant, c'est que le modèle peut analyser cette sortie structurée pour prendre des décisions, comme choisir d'explorer un sous-répertoire nommé src.
glob : celui-ci est mon "chercheur de glands" ! Il utilise des modèles glob standards, tels que *, **, ? et [], que vous connaissez déjà grâce à des outils comme .gitignore. Vous pouvez donc demander "Trouve tous les fichiers *.py dans le répertoire app" en utilisant le modèle app/**/*.py. Il s'agit d'un moyen efficace de rassembler un ensemble spécifique de fichiers à analyser par le modèle.
search_file_content : C'est ma vision à rayons X ! Il utilise des expressions régulières complètes pour ses recherches, et pas seulement une simple correspondance de chaînes. C'est incroyablement puissant. Vous pouvez lui demander de trouver des modèles complexes, comme "Trouve toutes les routes Flask qui utilisent une méthode POST", ce qui peut générer une expression régulière comme app\.route\(.*methods=\['POST'\].*\). Il renvoie le chemin d'accès au fichier, le numéro de ligne et la ligne correspondante, ce qui fournit au modèle tout le contexte dont il a besoin.
read_file : une fois que vous avez trouvé un fichier intéressant, vous devez l'ouvrir. read_file est optimisé pour cela. Vous pouvez lire un fichier entier ou, pour les fichiers volumineux, utiliser les paramètres offset et limit pour le lire par blocs. Cela signifie que le modèle peut analyser efficacement même d'énormes fichiers journaux sans expirer.

De la compréhension à l'action (place à la création !)

Vous avez exploré le terrain. Il est maintenant temps de créer votre nid ! Ces outils vous permettent d'apporter des modifications et d'effectuer des tâches.

**write_file** : vous devez créer un fichier à partir de zéro ? write_file est une opération atomique qui écrit l'intégralité du contenu que vous fournissez dans un chemin d'accès spécifié. Il est idéal pour échafauder de nouveaux modules ou créer un Dockerfile à partir de zéro en fonction des besoins de votre projet.
**replace** : cet outil est destiné aux modifications chirurgicales. Il ne s'agit pas d'une simple recherche et remplacement. Vous fournissez un old_string et un new_string. Pour que cela fonctionne de manière sécurisée, le old_string doit être un extrait unique du fichier, généralement avec plusieurs lignes de contexte avant et après la partie que vous modifiez. Cela permet de s'assurer que nous ne modifions que la partie exact du code que vous souhaitez.
**run_shell_command** : le bonus ultime ! Elle exécute la commande donnée dans un sous-shell bash -c <command>. Le modèle récupère stdout, stderr et exit code. C'est essentiel pour créer des workflows. Le modèle peut exécuter un terraform plan, lire le résultat et, si le plan est réussi (code de sortie 0), il peut vous demander s'il doit l'appliquer.

Le filet de sécurité (ma promesse)

L'exécution de commandes peut être intimidante. J'ai compris ! C'est pourquoi le filet de sécurité est si important. Lorsque le modèle génère un bloc tool_code contenant un appel à run_shell_command ou write_file, le client Gemini CLI l'intercepte. Il vous indique la commande exacte ou le contenu complet du fichier à écrire, et vous invite à répondre par [y/n]. Rien ne se passe sans votre autorisation explicite. Vous êtes toujours aux commandes.

4. Explorer un projet

Objectif : utiliser la CLI Gemini pour comprendre un codebase inconnu sans quitter le terminal.

Scénario : Vous êtes un nouveau développeur et vous devez vous familiariser rapidement avec ce projet.

Tâche 0 : Configuration – Cloner le projet

Tout d'abord, nous devons obtenir le code. Il se trouve dans un dépôt public sur GitHub, dans un "arbre" appelé quickpoll. Demandons à Gemini CLI de le cloner pour nous. Avant cela, créons un répertoire de travail et lançons Gemini CLI à partir de ce répertoire :

mkdir workdir
cd workdir
gemini

Saisissez maintenant cette requête :

clone the github repository from the URL: https://github.com/gauravkakad-google/quickpoll.git

Gemini comprendra que "cloner" signifie utiliser la commande git clone. Il générera un appel d'outil run_shell_command avec un élément tel que git clone https://github.com/gauravkakad-google/quickpoll.git. Une fois que vous l'aurez approuvé, le dépôt sera téléchargé.

Maintenant, quittons la Gemini CLI en appuyant deux fois sur ctrl+c, accédons au dépôt d'exemples et relançons la Gemini CLI :

cd quickpoll
gemini

Parfait ! Maintenant que nous sommes dans l'arborescence du projet, nous pouvons commencer à explorer !

Tâche 1 : Lister tous les fichiers du projet

Maintenant que nous sommes à l'intérieur, cartographions toute la forêt. Nous voulons voir tous les fichiers. Demandez à Gemini :

List all the files in the project.

Gemini utilisera probablement l'outil glob avec le modèle **/*. Cette commande liste de manière récursive tous les fichiers, ce qui vous donne un manifeste complet du codebase. C'est un excellent point de départ pour comprendre la structure du projet.

Tâche 2 : Rechercher tous les fichiers qui importent "google.cloud.sql.connector"

D'accord, je suis curieux. Où ce projet communique-t-il avec Google Cloud Storage ? Faisons une petite enquête. Posez-lui cette question :

Find all files that import the 'google.cloud.sql.connector' library.

Grâce à sa puissance search_file_content, Gemini trouvera les fichiers exacts contenant cette instruction d'importation. Cela vous permet de vous concentrer immédiatement sur les parties du code qui gèrent l'interaction avec Cloud SQL. Dans ce projet, il devrait trouver backend/main.py.

Tâche 3 : Afficher le contenu du fichier Dockerfile principal

J'ai trouvé un Dockerfile ! Il s'agit du plan de notre conteneur. Jetons un coup d'œil à l'intérieur. Il vous suffit de demander :

Show me the contents of the main Dockerfile.

Gemini utilisera read_file pour afficher Dockerfile. Vous pouvez analyser l'image de base (FROM), les dépendances en cours d'installation (RUN pip install...) et la commande finale (CMD). Cela vous donne des informations sur l'environnement d'exécution de l'application.

Tâche 4 : Quel est l'objectif du fichier `main.py` ?

Il est temps d'examiner le cœur du code. Demandons à Gemini de nous guider. Dites :

What's the purpose of the `main.py` file?

C'est là que la CLI Gemini brille vraiment. Il appellera d'abord read_file sur backend/main.py. Son modèle de langage multimodal analysera ensuite le code Python. Il identifiera qu'il s'agit d'une application FastAPI qui fournit une API REST pour une application de sondage. Il expliquera ensuite les points de terminaison de l'API et leur fonctionnement. Vous n'avez pas besoin de tout lire et de tout déchiffrer vous-même. Vous pouvez également poser des questions complémentaires pour obtenir des explications détaillées sur certaines de ces fonctionnalités. Plutôt sympa, non ? Allez-y, essayez !

5. De Local à Live ! Déployer l'application avec Cloud Run et Cloud SQL

Très bien, aventurier du cloud, vous avez exploré le territoire. Il est maintenant temps de construire votre propre cabane dans le cloud ! Nous allons transformer notre application de sondage rapide en une véritable application Web en ligne que tout le monde pourra consulter.

Objectif : Déployer l'application de sondage rapide sur Cloud Run, avec un backend Cloud SQL pour PostgreSQL.

Tâche 1 : Une branche solide pour nos données (configurer Cloud SQL)

Toute bonne application a besoin d'un endroit pour stocker ses précieux glands… Je veux dire, les données ! Nous allons utiliser Cloud SQL pour PostgreSQL. C'est comme un jardin magique et autonome pour notre base de données, qui nous permet de nous concentrer sur les choses amusantes.

Demandons à la CLI Gemini de planter la graine de notre base de données.

Please create a new Cloud SQL for PostgreSQL instance for me in project <myproject>. Call it quickpoll-db and put it in us-central1. Lets use the Development preset for now, and make the root password a-very-secure-password!.

La Gemini CLI se mettra au travail à l'aide de son extension Cloud SQL. L'appel d'outil create_instance s'affiche. N'hésitez pas à l'approuver !

Une fois l'instance créée, un résultat semblable à celui-ci doit s'afficher :

Vous pouvez créer un fichier .env avec la variable d'environnement ci-dessus et l'utiliser avant de redémarrer l'interface de ligne de commande Gemini, afin qu'elle ait accès à ces variables.

Pendant que notre instance se développe, préparons le terrain. Nous avons besoin d'une base de données et d'un utilisateur pour notre application.

In the quickpoll-db instance, create a new database named quickpolldb.

L'interface de ligne de commande Gemini utilisera l'outil create_database dans l'extension Cloud SQL pour PostgreSQL afin de créer la base de données pour vous.

Ajoutons maintenant un utilisateur pour s'en occuper :

In the quickpoll-db instance, create a built in user named quickpoll-user with the password another-secure-password!.

Cette fois-ci, Gemini CLI utilisera l'outil create_user.

Tâche 2 : Le chemin secret (connecter le backend)

Notre backend doit connaître le chemin secret vers notre nouvelle base de données. Jetons un coup d'œil à backend/main.py pour voir comment il s'y prend.

show me how would the backend/main.py connect to the database

Eurêka Vous voyez ? Il utilise le connecteur Python Cloud SQL et recherche des variables d'environnement telles que CLOUD_SQL_POSTGRES_INSTANCE, CLOUD_SQL_POSTGRES_USER, CLOUD_SQL_POSTGRES_PASSWORD et CLOUD_SQL_POSTGRES_DATABASE. Nous devrons les fournir à notre service Cloud Run.

Nous avons d'abord besoin de CLOUD_SQL_POSTGRES_INSTANCE. C'est comme une poignée de main secrète.

What are the details for the Cloud SQL instance quickpoll-db in us-central1?

Vous verrez de nombreux détails. Recherchez le nom de la connexion et copiez cette valeur. Elle doit ressembler à ceci : your-project-id:us-central1:quickpoll-db.

Avant de déployer l'application sur Cloud Run, instancions la base de données avec les tables requises. Comme nous avons créé une base de données et un utilisateur distincts, quittons l'interface de ligne de commande Gemini et mettons à jour le fichier .env que nous avons créé précédemment avec les nouvelles valeurs :

export CLOUD_SQL_POSTGRES_USER=quickpoll-user
export CLOUD_SQL_POSTGRES_PASSWORD=password-you-provided
export CLOUD_SQL_POSTGRES_DATABASE=quickpolldb

Redémarrez maintenant la CLI Gemini et saisissez ce qui suit :

execute backend/database.sql file on quickpolldb database as quickpolluser in quickpoll-db instance

Il a automatiquement déterminé que l'outil execute_sql n'était pas compatible avec l'exécution de plusieurs commandes SQL en un seul appel. Il a donc exécuté chaque commande SQL séparément.

Tâche 3 : Backend, Take Flight! (Déploiement sur Cloud Run)

Il est temps que notre backend quitte le nid ! Nous allons demander à Gemini de déployer le dossier backend sur Cloud Run et de lui indiquer le chemin secret vers la base de données.

Deploy the backend folder to a new Cloud Run service called quickpoll-be in us-central1. Here are the secrets (environment variables):
CLOUD_SQL_POSTGRES_INSTANCE=your-project-id:us-central1:quickpoll-db
CLOUD_SQL_POSTGRES_USER=quickpoll-user
CLOUD_SQL_POSTGRES_PASSWORD=password-you-provided
CLOUD_SQL_POSTGRES_DATABASE=quickpolldb

Gemini empaquettera votre code, créera une image de conteneur et la déploiera sur Cloud Run. Une fois l'opération terminée (ce qui peut prendre quelques minutes), vous obtiendrez l'URL de votre nouveau service de backend. Gardez cette URL à portée de main.

Tâche 4 : Les touches finales (configurer et déployer l'interface)

Notre interface est comme le visage amical de notre application. Il doit savoir où trouver le backend. Indiquons-lui où aller.

Deploy the frontend folder to a new Cloud Run service called quickpoll-fe in us-central1. Here are the secrets (environment variables):
BACKEND_URL=backend-url

Tâche 5 : La grande révélation !

C'est tout ! C'est le moment de vérité ! Récupérez l'URL de votre service quickpoll-fe et ouvrez-la dans votre navigateur Web.

Votre application QuickPoll devrait s'afficher, en direct et prête à l'emploi ! Allez-y, créez un sondage, votez et voyez les résultats se mettre à jour en temps réel.

Bravo ! Vous avez transféré un projet depuis votre ordinateur local et l'avez déployé sur Google Cloud. Et vous avez tout fait depuis votre terminal, avec votre fidèle acolyte, la CLI Gemini.

C'est ce que j'appelle la productivité !

6. Pour les développeurs : accélérer le cycle de vie du développement

Développeurs, c'est là que les choses sérieuses commencent ! Nous avons exploré un projet, mais il est maintenant temps de créer. Je vais vous montrer comment Gemini peut devenir votre partenaire de codage ultime, en vous aidant à passer d'une simple idée à un code prêt pour la production plus rapidement qu'un écureuil ne trouve une noix !

De l'idée au code

Pensez au cycle de développement typique. Il ne s'agit pas seulement d'écrire du code, n'est-ce pas ? Il s'agit de l'échafaudage, de l'ajout de la gestion des erreurs, de la refactorisation et de l'écriture des tests. Gemini peut vous aider à faire tout cela !

Texte passe-partout et tâches répétitives : dites adieu au copier-coller !

Vous disposez maintenant des fonctionnalités de base de votre application. Vous devez maintenant ajouter la journalisation et gérer les erreurs potentielles, n'est-ce pas ? Cela représente généralement beaucoup de blocs try...except répétitifs. Plus maintenant ! Commençons par demander à la CLI Gemini d'analyser le code et de suggérer des recommandations de bonnes pratiques pour la journalisation des erreurs et la gestion des exceptions :

What are the best practices for error handling and logging that should also be included in this application?

La Gemini CLI analysera le fichier existant et vous fournira des recommandations de bonnes pratiques. Considérez-le comme un assistant expert qui peut vous faire gagner du temps en effectuant ces recherches à votre place.

Maintenant, demandons-lui d'appliquer ces recommandations pour vous :

please go ahead and implement these in the existing app

Le résultat réel peut être différent dans votre cas, mais vous devriez voir les détails des modifications apportées. Par exemple, dans la capture d'écran ci-dessous, vous pouvez voir qu'il a ajouté structlog pour générer des journaux au format JSON, implémenté une gestion centralisée des exceptions et amélioré la façon dont les réponses aux requêtes sont enregistrées. Pensez à tout ce que vous venez d'économiser comme saisie !

Refactorisation : votre relecteur de code personnel

Nous voulons tous écrire du code clair et efficace. Mais parfois, nous sommes pressés. Gemini peut faire office de réviseur de code personnel. Voici des exemples de questions que vous pouvez lui poser :

please perform a comprehensive code review for best practices and security

Gemini comprend les bonnes pratiques spécifiques à chaque langue. Encore une fois, le résultat réel dans votre cas peut être différent de celui des captures d'écran ci-dessus, mais si vous lisez le résultat, vous apprécierez le niveau de détail de la CLI Gemini pour analyser le code. Il vous aide à apprendre et à améliorer votre code en même temps.

Génération de tests : le meilleur pour la fin !

C'est mon tour préféré ! Nous savons tous que nous devons écrire des tests, mais cela peut être fastidieux, surtout lorsque vous devez simuler des éléments. Regarde ça. Il vous suffit de demander :

Add a test suite to this application

Gemini analysera votre fonction, identifiera ses entrées et sorties, et déterminera ses dépendances. Il générera ensuite un fichier test_main.py complet avec plusieurs cas de test, y compris un "chemin de réussite" et peut-être une condition d'erreur. C'est un énorme gain de productivité !

Exécutez les tests. (Un défi pour vous)

C'est là que les choses deviennent vraiment intéressantes ! Je vais vous laisser explorer cette partie de manière autonome. N'hésitez pas à demander à la Gemini CLI d'exécuter les scénarios de test qu'elle a générés. Il ne vous reste plus qu'à vous asseoir et à observer la magie opérer.

7. Au-delà de localhost : intégration à GitHub

Nous avons fait un travail incroyable sur notre machine locale, notre propre petit coin de forêt. Mais la véritable puissance du cloud réside dans la collaboration et la connexion. Il est temps de prendre votre envol et de découvrir comment Gemini peut interagir avec le monde extérieur, en commençant par le plus grand arbre de la forêt des développeurs : GitHub !

Concept : votre assistant DevOps intégré

Jusqu'à présent, nous avons utilisé Gemini comme assistant de programmation local. Nous allons maintenant le transformer en assistant DevOps intégré. Tout cela grâce à l'intégration du protocole MCP (Model Context Protocol). Ce nom peut paraître sophistiqué, mais il signifie simplement que Gemini peut communiquer de manière sécurisée avec d'autres services en votre nom. Le premier que nous allons maîtriser est GitHub.

Réfléchissez-y un instant. À quelle fréquence devez-vous quitter votre terminal pour consulter une demande d'extraction, créer un problème ou parcourir un dépôt sur GitHub ? Encore plus de changement de contexte ! Avec l'ensemble d'outils github, vous pouvez effectuer toutes ces opérations directement ici. Il transforme Gemini en interface native pour GitHub.

La documentation officielle du serveur GitHub MCP fournit de nombreuses informations sur les outils et les options de configuration exposés. Vous pouvez choisir entre un fonctionnement local ou distant, car la CLI Gemini est entièrement compatible avec les serveurs MCP distants.

Ce tutoriel vous explique comment configurer l'option de serveur MCP distant pour GitHub. Tout d'abord, vous aurez besoin d'un jeton d'accès personnel (PAT) de GitHub.

Une fois que vous avez obtenu votre PAT, il est temps d'ajouter l'objet MCP Server à votre fichier settings.json. Vous trouverez ci-dessous l'intégralité de mon fichier settings.json. Toutefois, vous pouvez simplement vous assurer que votre objet mcpServers correspond à ce que vous voyez ici :

{
  "security": {
    "auth": {
      "selectedType": "vertex-ai"
    }
  },
 "mcpServers": {
    "github": {
      "httpUrl": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "GITHUB_PAT"
      },
      "timeout": 5000
    }
  }
}

Une fois que vous avez mis à jour votre fichier settings.json avec la configuration du serveur GitHub MCP, il vous suffit de redémarrer Gemini CLI ou d'exécuter la commande /mcp refresh. La capture d'écran ci-dessous montre le serveur MCP GitHub désormais amorcé sur mon système, qui présente l'éventail d'outils puissants que la CLI Gemini peut désormais utiliser avec le Model Context Protocol.

Présentation des commandes principales

Gemini est doté d'un tout nouvel ensemble de superpouvoirs spécialement conçus pour GitHub. Voici quelques-uns de mes préférés :

github.list_repositories : vous souhaitez afficher tous les dépôts de votre organisation sans ouvrir de navigateur ? C'est votre outil ! Il vous suffit de demander "Liste tous les dépôts de mon organisation".
github.create_issue : vous avez trouvé un bug ? Ne changez pas de fenêtre pour créer un problème. Vous pouvez simplement dire à Gemini : "Crée un problème dans le dépôt sample-flask-app intitulé "Corrige le bug de connexion" avec cette description…" et pouf, le problème est créé.
github.get_pull_request : Vous devez vérifier une demande de modification ? Vous pouvez demander "Montre-moi les détails de la demande de pull n° 42 dans le dépôt sample-flask-app". Gemini récupère le titre, la description, l'état et les noms des réviseurs.
github.get_file_contents : celui-ci est vraiment cool. Vous pouvez lire un fichier à partir d'un dépôt distant sans avoir à le cloner au préalable. C'est un excellent moyen de vérifier rapidement un fichier de configuration ou le fichier README d'un projet que vous n'avez pas localement.

8. Exploration GitHub

Assez parlé, passons à l'action ! Nous allons utiliser nos nouveaux pouvoirs GitHub pour explorer une organisation et un projet, le tout depuis notre terminal.

Objectif : utiliser Gemini pour explorer et comprendre un projet hébergé sur GitHub.

Scénario : vous devez vous familiariser avec un projet sur GitHub sur lequel vous n'avez jamais travaillé.

Tâche 1 : Lister les dépôts d'une organisation

Commençons par afficher tous les projets d'une organisation GitHub. Pour cet atelier, vous pouvez utiliser votre propre nom d'utilisateur GitHub ou une organisation à laquelle vous appartenez. Demandons à Gemini de les lister.

List the repositories in the `[your-org-or-username]` GitHub organization.

(N'oubliez pas de remplacer [your-org-or-username] par vos informations.) Gemini utilisera l'outil github.list_repositories et vous montrera la liste de tous les projets. Formidable !

Tâche 2 : Rechercher un dépôt spécifique

OK, une liste de dépôts s'affiche. Maintenant, comme un vrai développeur, vous devez parcourir cette liste et trouver le projet qui vous intéresse. Pour cet atelier, imaginons que nous recherchons le dépôt quickpoll que nous avons cloné précédemment. Vous n'avez pas besoin de commande pour cette partie. Il vous suffit de lire le résultat de la dernière étape et de trouver le dépôt.

Tâche 3 : Lister les demandes d'extraction ouvertes

Maintenant que nous avons identifié notre dépôt cible, voyons ce qui s'y passe. Existe-t-il des demandes d'extraction ouvertes ? Demandons :

List the open pull requests for the `quickpoll` repository in the `[your-org-or-username]` organization.

Gemini utilisera l'outil github.list_pull_requests en filtrant sur l'état open. Il liste ensuite toutes les demandes d'extraction ouvertes, en indiquant leur numéro, leur titre et leur auteur. Vous pouvez ainsi suivre en temps réel le développement du projet. Vous pouvez essayer avec un dépôt auquel vous contribuez activement et vérifier les résultats.

Tâche 4 : Examiner une demande d'extraction

Supposons qu'une demande de pull intéressante figure dans cette liste. Nous voulons en savoir plus ! Nous voulons voir la description et les fichiers qui ont été modifiés. Sélectionnez un numéro de demande de modification dans la liste (si aucun ne s'affiche, vous pouvez passer cette étape, mais imaginons qu'il y en ait un).

Show me the details and files changed in PR number 1 in the `quickpoll` repo.

Voici un excellent exemple de tâche en plusieurs étapes pour Gemini. Tout d'abord, il utilisera probablement github.get_pull_request pour récupérer les informations principales (titre, corps, auteur, etc.). Ensuite, pour obtenir les modifications apportées au fichier, il utilisera un deuxième outil, github.get_pull_request_files. Il combinera ensuite toutes ces informations dans un résumé clair et concis. Vous venez d'examiner une demande d'extraction sans quitter votre terminal. N'est-ce pas incroyable ?

9. Du PRD au commit initial

Vous avez appris à explorer, à créer et à tester. Nous allons maintenant mettre tout cela en pratique dans un scénario réel. C'est le moment où nous transformons un plan en produit. Nous allons passer d'un document de spécifications techniques à notre premier commit. Créons quelque chose d'extraordinaire !

Objectif : Simuler une tâche de développement réelle de bout en bout, en combinant le contexte local et distant.

Scénario : Une nouvelle fonctionnalité vous a été attribuée ! Les exigences vous attendent dans un fichier PRD du dépôt GitHub du projet.

Tâche 1 : Comprendre – Lire le PRD

Il s'agit de l'étape la plus importante. Avant même de penser à écrire une seule ligne de code, vous devez absolument comprendre le plan. Les exigences de notre nouvelle fonctionnalité sont indiquées dans le fichier prd/NEW_FEATURE.md. Ouvrons-le pour voir ce qu'il y a à l'intérieur.

explain the requirements mentioned in prd/NEW_FEATURE.md

La CLI Gemini utilisera read_file pour afficher le contenu du PRD. Plongez ! Il présentera la nouvelle fonctionnalité : un bouton "Actualiser" permettant aux utilisateurs de mettre à jour manuellement la liste des sondages actifs. Consultez toujours le plan en premier.

Tâche 2 : Coder – Transformer les exigences en réalité

C'est le moment magique ! Nous allons prendre les exigences du PRD et demander à Gemini d'écrire le code pour nous. Soyons précis et indiquons-lui exactement ce que nous voulons.

Implement the changes as per the PRD

L'interface de ligne de commande Gemini se met en action et, au bout d'un instant, vous obtenez un résultat semblable à celui-ci. Notre nouveau code brillant a désormais un emplacement confortable !

Tâche 3 : Vérifier vos modifications

Nous avons créé un fichier avec un nouveau code. La dernière étape de cet atelier consiste à déployer la modification sur Cloud Run et à la valider.

let's deploy the changes made to frontend to Cloud Run. The existing service on Cloud Run is quickpoll-fe in us-central1.

Notez que cette requête a fourni des informations supplémentaires, comme le nom du service Cloud Run existant et sa région de déploiement. Être précis vous permet de gagner du temps, mais la CLI Gemini vous demandera toujours les informations manquantes si vous les oubliez.

Si votre service Cloud Run mis à jour rencontre une erreur, demandez simplement à la CLI Gemini de déboguer et de corriger le code. N'oubliez pas qu'il s'agit de votre compagnon surpuissant !

10. Félicitations

Et voilà ! Vous venez de terminer un cycle de développement complet. Vous êtes passé d'un document d'exigences à une nouvelle fonctionnalité, prête à être validée et déployée. Vous avez combiné le contexte local, le contexte distant, les opérations du système de fichiers et la génération de code. Vous n'êtes pas seulement un développeur, vous êtes un architecte cloud super productif ! Félicitations !