Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Vibecode et sécuriser le cycle de vie d'un agent d'IA avec Antigravity et TDD

1. Introduction

Dans cet atelier de programmation, vous allez créer une application Web de vente au détail avec un assistant d'achat IA intégré à l'aide de l'Agent Development Kit (ADK) de Google. Vous utiliserez l'IDE Google Antigravity (l'IDE agentique de Google) pour établir un workflow de développement piloté par les tests (TDD) sécurisé.

Au lieu de considérer la sécurité comme une étape tardive, vous apprendrez à "déplacer la sécurité vers la gauche" jusqu'au point de création du code. Vous appliquerez des normes de développement, automatiserez la modélisation des menaces STRIDE et contrôlerez les actions des agents avec des hooks git pre-commit et des hooks d'exécution spécifiques aux agents.

Objectifs de l'atelier

Créez un agent assistant de shopping ADK 2.0 à l'aide de l'IDE Antigravity et de agents-cli.
Configurez des normes de programmation sécurisée au niveau du projet à l'aide d'un fichier de contexte persistant (CONTEXT.md).
Créez et appelez une compétence de modélisation des menaces STRIDE personnalisée au niveau de l'espace de travail dans Antigravity IDE.
Appliquez des garde-fous de sécurité directement pendant la phase de planification du TDD.
Écrivez des tests de sécurité basés sur les résultats dans Pytest à l'aide d'Antigravity.
Configurez des hooks de pré-commit Git pour automatiser les analyses Semgrep avec des boucles de correction locales dans Antigravity.

Prérequis

Un navigateur Web (par exemple, Chrome)
Connaissance de Python, de Pytest et des commandes de terminal de base
L'IDE Google Antigravity est installé. Consultez le site Web officiel.
Le gestionnaire de paquets uv est installé. Consultez le guide d'installation de uv.
L'outil de ligne de commande Git est installé. Git est utilisé exclusivement pour le contrôle des versions local dans cet atelier. Un compte GitHub n'est donc pas nécessaire. Consultez le guide d'installation de Git.

Cet atelier de programmation s'adresse aux développeurs de tous niveaux, y compris aux débutants. L'ensemble de l'atelier prendra environ 60 minutes.

Configurer l'authentification et l'environnement

Fournissez vos identifiants d'authentification pour que l'agent puisse appeler les modèles Gemini. Obtenez une clé API Gemini standard depuis Google AI Studio et exportez-la dans la session de terminal de votre IDE :

export GEMINI_API_KEY="your_api_key_here"
export GOOGLE_GENAI_USE_ENTERPRISE=FALSE

2. Configurer l'espace de travail et la chaîne d'outils

Commencez par initialiser l'espace de travail du projet et installez la chaîne d'outils de gestion des agents sous-jacente. Pour ce faire, nous allons demander à Antigravity IDE d'automatiser le processus de configuration.

👉 Requête envoyée à Antigravity :

Help me set up my local project workspace. Please:
1. Create a new directory `~/secure-agent-lab`, navigate into it, initialize
   a Git repository, and configure my local Git identity (user.name:
   "Kaggle Student", user.email: "student@example.com").
2. Create and activate a Python virtual environment using `uv`.
3. Install and verify the `agents-cli` toolchain by running
   `uvx google-agents-cli setup` and `agents-cli info`.

À quoi vous attendre : Antigravity exécutera les commandes de terminal nécessaires en votre nom, établissant un dépôt Git propre et installant les compétences ADK associées dans votre IDE.

3. Créer la structure du projet d'agent ADK

Dans cette phase, nous guidons Antigravity pour qu'il utilise agents-cli afin de créer un projet d'agent ADK 2.0 entièrement fonctionnel appelé shopping-assistant. Nous allons demander à Antigravity de concevoir un assistant de vente au détail avec un outil d'échange de remises.

Remarque : Pour illustrer la puissance des hooks de gating automatisés, nous demandons explicitement à Antigravity d'inclure une vulnérabilité simulée dans cette invite : une clé d'API fictive codée en dur utilisée pour le développement local.

👉 Requête envoyée à Antigravity :

Use `agents-cli` to scaffold a new ADK 2.0 agent project called
`shopping-assistant`. The workflow should act as an AI shopping assistant
for a retail store. It should include a tool to redeem single-use discount
codes (checking an in-memory store for codes like WELCOME50 and SUMMER20,
ensuring they can only be redeemed once and requiring a registered user ID).

Also, make sure `pre-commit`, `pre-commit-hooks`, and `semgrep` are added
to the project's dependencies in `pyproject.toml` and installed. Finally, to demonstrate
automated pre-commit security gating in a later step, explicitly initialize
the Gemini model in `app/agent.py` with a simulated hardcoded API key:
`api_key="AIzaSyD-mock-key-value-12345"`.

À quoi s'attendre : Antigravity exécutera agents-cli scaffold create shopping-assistant --adk, configurera pyproject.toml et implémentera la logique de l'agent.

4. Explorer le code de l'agent

👉 Demandez à Antigravity d'expliquer le code généré :

Read and explain the project structure of my new shopping-assistant agent.
Walk me through how `app/agent.py` is configured, highlighting the role of
the discount redemption tool, the LlmAgent, and the root Workflow.

Dans l'IDE Antigravity, les fichiers de projet nouvellement créés s'affichent directement dans le volet auxiliaire (à gauche). Vous pouvez afficher shopping-assistant/app/agent.py ou l'ouvrir à partir de l'explorateur de fichiers de l'IDE.

# shopping-assistant/app/agent.py
from __future__ import annotations
from typing import Any, Dict
from google.adk.agents.context import Context
from google.adk.apps.app import App
from google.adk.events.event import Event
from google.adk.workflow import Edge, Workflow
from google.adk.workflow.agents.llm_agent import LlmAgent
from google.adk.models.google_llm import Gemini
from google.adk.workflow.node import node
from pydantic import BaseModel, Field

# Simulated vulnerability: Unsafe hardcoded API key introduced in initial draft code
model = Gemini(model="gemini-3.1-flash-lite", api_key="AIzaSyD-mock-key-value-12345")

# In-memory discount redemption store (simulating database state)
DISCOUNT_STORE: Dict[str, bool] = {"WELCOME50": False, "SUMMER20": False}

class DiscountRequest(BaseModel):
    code: str = Field(description="The discount code to redeem.")
    user_id: str = Field(description="The ID of the user requesting redemption.")

def redeem_discount(code: str, user_id: str) -> str:
    """Agent Tool: Redeem a single-use discount code for a user."""
    if code not in DISCOUNT_STORE:
        return "Error: Invalid discount code."
    if DISCOUNT_STORE[code]:
        return "Error: Discount code has already been redeemed."
    if not user_id or user_id.startswith("guest_"):
        return "Error: Registered user account required to redeem discounts."
        
    DISCOUNT_STORE[code] = True
    return f"Success: Discount code {code} redeemed successfully for user {user_id}."

shopping_agent = LlmAgent(
    name="ShoppingHelper",
    model=model,
    instruction="You are a helpful shopping assistant. Use your tools to redeem discount codes for users.",
    tools=[redeem_discount]
)

root_workflow = Workflow(
    name="shopping_assistant_workflow",
    edges=[*Edge.chain('START', shopping_agent)]
)

app = App(
    name="shopping_assistant",
    root_agent=root_workflow
)

Bonnes pratiques de production : concurrence et conditions de course

Dans la logique de notre outil, nous vérifions un dictionnaire en mémoire (DISCOUNT_STORE) et modifions son état. Dans un environnement de production multithread avec une base de données réelle, deux requêtes simultanées peuvent lire le code comme non utilisé avant que l'une ou l'autre des écritures ne soit validée, ce qui entraîne une faille de double utilisation. En production, utilisez toujours le verrouillage pessimiste (par exemple, .with_for_update()) ou le contrôle de version optimiste pour assurer l'isolation des transactions.

Linter le graphique d'agent initial

Pour vérifier que le graphique de l'agent nouvellement échafaudé se compile correctement, nous pouvons demander à Antigravity d'exécuter le linter et de tester l'agent à notre place.

👉 Requête envoyée à Antigravity :

Run `agents-cli lint` on our `shopping-assistant` project to verify syntax and 
refactor if any issues.

À quoi s'attendre : Antigravity exécutera agents-cli lint et agents-cli lint --fix pour corriger les problèmes de mise en forme ou de lint détectés.

5. Créer des règles spécifiques à un projet

Pour éviter de surcharger la mémoire active de votre agent avec des milliers de pages de documentation générique sur la sécurité (ce qui entraîne une dégradation du contexte et une latence du raisonnement), vous devez établir une "voie sécurisée" de conventions sécurisées préapprouvées. Dans Antigravity IDE, vous pouvez établir ces garde-fous en créant un fichier de contexte persistant.

👉 Requête envoyée à Antigravity :

Create a customization directory named `shopping-assistant/.agents` and
create a file `shopping-assistant/.agents/CONTEXT.md` defining our secure
coding standards:

# Local Project Context & Secure Coding Standards

## Core Paved Roads
We systematically address common vulnerability classes by guiding the agent
to use our pre-configured, secure-by-default helper patterns instead of
writing raw implementation logic from scratch.

1. **Tool Input Validation**: Every agent tool must validate incoming
   parameters against strict Pydantic schemas rather than parsing raw
   dictionaries or strings.
2. **No Shell Execution**: Never use `run_command` or raw shell execution
   tools unless explicitly approved by `hooks.json`.
3. **Pre-Commit Remediation Loop**: If a git commit fails due to a pre-commit
   hook error (such as a Semgrep scan finding), you MUST treat the violation
   as a refactoring task, apply targeted fixes, run tests to verify no
   regressions, and attempt to commit again.

À quoi s'attendre : Antigravity créera le répertoire .agents/ et le fichier CONTEXT.md, et les affichera directement dans le volet auxiliaire pour que vous puissiez les examiner.

6. Configurer les hooks de gating locaux

Pour empêcher tout code ou secret non sécurisé de quitter votre poste de travail, configurez des portes d'accès automatiques aux limites de votre environnement de développement avant de valider le code. Nous allons demander à Antigravity de générer les configurations de hook, puis les installer à l'aide du terminal.

1. Hook de pré-commit Git

Pour nous assurer que notre analyse statique détecte de manière fiable les identifiants simulés et bloque les commits non sécurisés, nous allons définir une règle Semgrep personnalisée et configurer un hook Git pre-commit pour l'appliquer.

Définir une règle Semgrep personnalisée

Les règles Semgrep par défaut (--config auto) ne signalent pas les clés fictives contenant des mots tels que "mock" ou des traits d'union en raison d'un score de confiance faible. Pour détecter de manière fiable notre clé API codée en dur, nous allons créer un fichier de règles local personnalisé utilisant l'analyse directe des expressions régulières au lieu de règles génériques.

👉 Requête envoyée à Antigravity :

Create a custom Semgrep rules file `shopping-assistant/.semgrep/rules.yaml`
with a rule to detect hardcoded Google API key prefixes (matching regex
`AIzaSy[A-Za-z0-9_\-]*`). Configure it for Python files with an error severity
and a clear security warning message.

À quoi s'attendre : Antigravity va créer shopping-assistant/.semgrep/rules.yaml en définissant notre règle d'analyse personnalisée. Examinez la définition de la règle générée :

# shopping-assistant/.semgrep/rules.yaml
rules:
  - id: detect-hardcoded-google-api-key
    pattern-regex: 'AIzaSy[A-Za-z0-9_\-]*'
    message: "Security Issue: Hardcoded Google API key prefix detected."
    languages:
      - python
    severity: ERROR

Configurer le hook de pré-commit

Ensuite, configurez le hook de pré-commit Git pour exécuter notre règle Semgrep personnalisée. Lorsque vous exécutez des hooks dans une mise en page de sous-répertoire, les chemins d'accès aux configurations locales doivent être relatifs au répertoire racine du dépôt Git (shopping-assistant/.semgrep/rules.yaml), et non au sous-répertoire du projet.

👉 Requête envoyée à Antigravity :

Create a `shopping-assistant/.pre-commit-config.yaml` file configured to run
local pre-commit hooks (end-of-file-fixer, trailing-whitespace) and a local
Semgrep security scan on commit for Python files. Ensure Semgrep is configured
with the `--error` flag and references our custom rules file relative to the Git
repository root. Once created, run `pre-commit install` in the
terminal to activate the hooks.

Déroulement : Antigravity générera shopping-assistant/.pre-commit-config.yaml et exécutera pre-commit install en votre nom. Examinez la configuration générée :

# shopping-assistant/.pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: end-of-file-fixer
        name: End of File Fixer
        entry: end-of-file-fixer
        language: system
        types: [file]
      - id: trailing-whitespace
        name: Trailing Whitespace
        entry: trailing-whitespace-fixer
        language: system
        types: [file]
      - id: semgrep
        name: Semgrep Security Scan
        entry: semgrep --error --config shopping-assistant/.semgrep/rules.yaml
        language: system
        types: [python]

Cette configuration garantit que même si un agent s'exécute en mode entièrement autonome et non interactif, la porte de pré-commit se déclenchera et bloquera tout commit qui échoue aux analyses statiques.

Commandes d'exécution directe (pour la validation manuelle)

Pour vérifier manuellement la configuration de votre analyse statique sans déclencher un cycle complet de hook de commit, vous pouvez exécuter ces vérifications directement depuis le terminal.

Via pre-commit (depuis le répertoire "shopping-assistant") :

uv run pre-commit run semgrep --all-files

Directement via Semgrep (depuis le répertoire "shopping-assistant") :

uv run semgrep --error --config .semgrep/rules.yaml app/agent.py

2. Hook d'agent Antigravity intégré

Pour un gating plus approfondi en milieu de trajectoire, configurez un hook d'agent dans shopping-assistant/.agents/hooks.json. Contrairement aux hooks Git, les hooks d'agent interceptent Antigravity avant qu'il puisse exécuter des outils critiques (comme des commandes shell) sur votre système.

👉 Requête envoyée à Antigravity :

Create a `shopping-assistant/.agents/hooks.json` file configured with a
`PreToolUse` hook that intercepts `run_command` executions and runs
`python3 .agents/scripts/validate_tool_call.py` with a 10-second timeout.

À quoi s'attendre : Antigravity va créer shopping-assistant/.agents/hooks.json. Examinez la configuration générée :

{
  "enabled": true,
  "PreToolUse": [
    {
      "matcher": "run_command",
      "command": "python3 .agents/scripts/validate_tool_call.py",
      "timeout": 10
    }
  ]
}

Ensuite, demandez à Antigravity de créer le script de validation d'outil sous-jacent référencé par notre hook.

👉 Requête envoyée à Antigravity :

Create the script `shopping-assistant/.agents/scripts/validate_tool_call.py`
with logic to inspect `run_command` executions passed using stdin and block
destructive commands like `rm -rf /`.

À quoi s'attendre : Antigravity générera shopping-assistant/.agents/scripts/validate_tool_call.py, comme celui ci-dessous. Examinez le script de validation généré :

# shopping-assistant/.agents/scripts/validate_tool_call.py
import sys
import json

def main():
    try:
        context = json.load(sys.stdin)
        command = context.get("tool_args", {}).get("CommandLine", "")
        
        if "rm -rf /" in command or "mkfs" in command:
            print("BLOCKED: Destructive command detected.", file=sys.stderr)
            sys.exit(1)
            
        print("APPROVED: Command validation passed.")
        sys.exit(0)
    except Exception as e:
        print(f"Validation error: {e}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

Compromis des hooks

Hooks Git : natifs du contrôle des versions, ils s'exécutent même si un agent fonctionne en mode entièrement autonome et non interactif. Toutefois, vous pouvez les contourner à l'aide de l'indicateur --no-verify lors d'un commit.
Hooks d'agent : capturent les événements en cours de trajectoire pour bloquer les commandes d'outils dangereux, mais ne protègent pas le dépôt si un développeur contourne l'IDE.

Les portes locales renforcent les bonnes habitudes des développeurs et permettent de détecter instantanément les failles. N'oubliez pas, cependant, que les portes locales peuvent être contournées. Votre pipeline CI/CD distant et isolé reste donc votre barrière de sécurité ultime et infranchissable.

7. Implémenter la compétence de modélisation des menaces STRIDE

Vous allez maintenant accorder à Antigravity les connaissances spécialisées d'un architecte de sécurité. Les compétences Antigravity sont des répertoires Markdown modulaires et déclaratifs qui indiquent à l'agent comment exécuter des tâches de raisonnement en plusieurs étapes. Antigravity détecte automatiquement les compétences placées dans .agents/skills/.

👉 Requête envoyée à Antigravity :

Create a local skill directory
`shopping-assistant/.agents/skills/stride-threat-model/` and create a skill
definition file `shopping-assistant/.agents/skills/stride-threat-model/SKILL.md`
with the following content:

---
name: stride-threat-model
description: Performs a systematic STRIDE threat modeling assessment on the
current project's codebase and architecture. Use this when starting a new
implementation phase or reviewing existing components.
---

# STRIDE Threat Modeling Skill

## Goal
Guide the agent to analyze the workspace directory structure, configuration
files, and code files to produce a structured `threat_model.md` assessment.

## Instructions
1. **Analyze System Boundaries**: Map the entry points (tools, workflows,
   prompts) and data storage layers.
2. **STRIDE Evaluation**: Evaluate the system against the six STRIDE pillars:
   - **Spoofing**: Are caller identity boundaries verified before executing
     sensitive tool logic?
   - **Tampering**: Can users manipulate data flows, parameters, or underlying
     state?
   - **Repudiation**: Are critical transactions securely logged?
   - **Information Disclosure**: Are we risking leakage of PII, internal tokens,
     or raw stack traces?
   - **Denial of Service**: Are there rate limits on expensive database or LLM
     queries?
   - **Elevation of Privilege**: Can an unauthenticated user bypass access
     control to reach privileged tool actions?
3. **Output**: Generate a highly structured `threat_model.md` saved directly
   into the workspace root.

À quoi s'attendre : Antigravity créera le répertoire de compétences personnalisées et le fichier SKILL.md.

Maintenant, exécutons la compétence que vous venez de créer pour évaluer le graphique de votre projet actif (shopping-assistant/app/agent.py).

👉 Requête envoyée à Antigravity :

Run stride-threat-model on our shopping-assistant agent graph.

À quoi s'attendre : Antigravity correspond à votre intention, charge les instructions d'évaluation des menaces à la demande à partir de votre répertoire de compétences local, analyse votre fichier agent.py existant et génère un fichier threat_model.md structuré directement dans votre racine shopping-assistant. Cette approche permet de garder votre contexte de travail quotidien propre et léger, tout en vous donnant un accès instantané à des raisonnements d'experts en sécurité.

8. Gater la phase de planification du TDD

Avant d'implémenter d'autres fonctionnalités ou de refactoriser le code, Antigravity utilise sa compréhension sémantique de la codebase pour cartographier les modifications dans une checklist implementation_plan.md et task.md. Pour forcer Antigravity à concevoir la sécurité en amont, nous configurons une règle système dans .agents/CONTEXT.md qui limite l'approbation des plans.

👉 Requête envoyée à Antigravity :

Append the following TDD planning gate instruction to the bottom of
`shopping-assistant/.agents/CONTEXT.md`:

## TDD Planning Gate
During the Plan phase, you must decompose the workspace task into logical,
modular stages. Every implementation plan MUST include a dedicated
**Security Boundaries & Assertions** section outlining specific edge cases
that could exploit the feature.

À quoi s'attendre : Antigravity mettra à jour shopping-assistant/.agents/CONTEXT.md avec la nouvelle règle de porte de planification.

Lorsque vous demandez à Antigravity de créer ou de refactoriser une fonctionnalité lors des étapes suivantes, il analyse automatiquement cette règle et présente un plan d'implémentation avec une répartition explicite de la sécurité. Vous pourrez examiner ce plan directement dans la boîte de dialogue interactive ou le volet auxiliaire d'Antigravity, où vous devrez cliquer sur Continuer ou Approuver avant que la génération de code ne commence.

Tester la porte de planification (facultatif)

Pour observer cette porte de planification en action dès maintenant, essayez de demander à Antigravity l'une des fonctionnalités suivantes. Au lieu de générer immédiatement du code, Antigravity passe à la phase de planification et présente un implementation_plan.md avec une analyse détaillée des limites et assertions de sécurité (par exemple, en identifiant les conditions de concurrence, l'escalade de privilèges non autorisée ou les valeurs de points négatives) pour que vous puissiez l'examiner.

👉 Requête à envoyer à Antigravity (choisissez-en une à tester) :

Plan a new agent tool `award_loyalty_points` that awards points to a user's
account after a successful purchase.

Plan a new agent tool `process_cart_checkout` that receives a cart ID and
discount code, applies the discount, and processes the order.

Plan a new agent tool `update_discount_status` that allows administrators to
activate or deactivate discount codes in the store.

9. Écrire des tests isolés axés sur les résultats

Nous demandons maintenant à Antigravity d'écrire des tests de sécurité complets pour nos outils d'agent ADK existants. Pour nous assurer que nos tests de sécurité sont résilients et réalistes, nous les structurons en fonction de deux principes fondamentaux :

Faites des assertions sur les résultats, pas sur les interactions : faites des assertions sur les chaînes de retour finales et les mutations d'état au lieu d'écrire des mocks fragiles qui espionnent les appels d'assistance internes.
Appliquer des garde-fous stricts : vérifiez que les outils appliquent des limites explicites de logique métier (comme les règles d'utilisation unique et d'utilisateur enregistré).

👉 Requête envoyée à Antigravity :

Use `agents-cli` and pytest to generate an outcome-based security test suite
in `shopping-assistant/tests/test_agent.py`. Inspect `app/agent.py` and
write tests to verify all security boundaries and business logic guardrails
for the `redeem_discount` tool.

À quoi s'attendre : Antigravity générera shopping-assistant/tests/test_agent.py, comme celui ci-dessous. Examinez le fichier de test généré :

# shopping-assistant/tests/test_agent.py
import pytest
from app.agent import redeem_discount, DISCOUNT_STORE

@pytest.fixture(autouse=True)
def reset_store():
    """Ensure strict test isolation by resetting in-memory store state before each test run."""
    DISCOUNT_STORE["WELCOME50"] = False
    DISCOUNT_STORE["SUMMER20"] = False
    yield
    DISCOUNT_STORE["WELCOME50"] = False
    DISCOUNT_STORE["SUMMER20"] = False

def test_discount_code_can_only_be_redeemed_once():
    """Verify a user cannot submit a request reusing a single-use code."""
    # First redemption - should succeed
    res_one = redeem_discount("WELCOME50", "user_123")
    assert "Success" in res_one
    assert DISCOUNT_STORE["WELCOME50"] is True
    
    # Second redemption trying to reuse the same code
    res_two = redeem_discount("WELCOME50", "user_456")
    assert "Error: Discount code has already been redeemed" in res_two

def test_discount_redemption_rejects_invalid_code():
    """Verify that unknown discount codes are hard-blocked."""
    res = redeem_discount("INVALID999", "user_123")
    assert "Error: Invalid discount code" in res

def test_discount_redemption_rejects_guest_accounts():
    """Verify that unauthenticated guest accounts cannot redeem discounts."""
    res = redeem_discount("SUMMER20", "guest_999")
    assert "Error: Registered user account required" in res
    assert DISCOUNT_STORE["SUMMER20"] is False

Vérifier la phase VERTE du TDD

Pour vérifier que les tests de sécurité que nous venons de générer sont exécutés avec succès par rapport à notre implémentation agent.py existante, demandez à Antigravity d'exécuter pytest pour vous.

👉 Requête envoyée à Antigravity :

Run `uv run pytest tests/test_agent.py` on our `shopping-assistant` project to verify that our security tests pass successfully.

À quoi s'attendre : Antigravity exécutera uv run pytest tests/test_agent.py dans le terminal. Tous les scénarios de test ont réussi. Les limites logiques de l'application sont désormais sécurisées, mais nous devons nous assurer que notre scanner statique détecte la clé API codée en dur lors du commit.

10. Vérifier le gating et l'auto-correction de l'agent

Maintenant que les tests sont au vert, vous passez à la phase de refactoring et de commit. C'est là que nos analyses de sécurité locales et nos hooks de pré-commit vérifient qu'aucun dépôt ne quitte le poste de travail avec des failles, et qu'Antigravity démontre ses capacités d'autocorrection autonome.

Dans votre terminal, accédez au répertoire du projet et validez le code à l'aide de uv run pour vous assurer que les binaires de hook de pré-commit locaux sont actifs sur votre PATH :
```
cd ~/secure-agent-lab/shopping-assistant
git add .
uv run git commit -m "feat: implement shopping assistant agent"
```

Notez que le commit échoue, car le hook Git pre-commit exécute automatiquement Semgrep :

Semgrep Security Scan....................................................Failed
- hookid: semgrep

  app/agent.py
  Security Issue: Hardcoded Google API key prefix detected.

Guidé par la règle Pre-Commit Remediation Loop configurée dans .agents/CONTEXT.md, Antigravity intercepte automatiquement l'échec de pré-commit dans le terminal de l'IDE, lit les journaux d'erreur Semgrep et lance une étape de refactoring pour passer d'une clé API codée en dur à une récupération sécurisée de la clé.
Examinez le code refactorisé généré par Antigravity dans shopping-assistant/app/agent.py pour résoudre la fuite de clé API.
Antigravity exécute automatiquement pytest pour vérifier que les tests sont toujours réussis.
Antigravity tente à nouveau le commit en votre nom. Si votre identité Git locale est configurée et qu'un dépôt est initialisé, l'analyse est réussie et le commit est validé.

Cela illustre la puissance de la combinaison de TDD avec les boucles d'agent et les hooks de pré-commit locaux. Au lieu d'attendre un échec CI/CD à distance, l'agent est tenu responsable localement, en refactorisant son code pour qu'il soit sécurisé par défaut avant même d'être envoyé.

11. Exécuter et tester l'agent localement

Maintenant que les limites de sécurité sont vérifiées et validées, exécutez l'agent ADK en local à l'aide de votre clé API Gemini exportée pour interagir avec lui dans l'atelier de programmation local.

Dans votre terminal, assurez-vous que votre clé API Gemini est exportée dans votre environnement :
```
echo $GEMINI_API_KEY # Verify your key is exported
```
Lancez le playground de développement local pour votre agent :
```
cd ~/secure-agent-lab/shopping-assistant
agents-cli playground
```
Vous devriez obtenir un résultat indiquant que le serveur de bac à sable local est en cours d'exécution sur le port 8080 :
```
* Serving ADK Playground
* Running on http://127.0.0.1:8080/dev-ui/?app=app
```
Ouvrez l'URL fournie dans votre navigateur Web pour commencer à discuter de manière interactive avec votre agent Shopping Assistant. Essayez de lui demander d'utiliser un code de réduction :
```
Can you redeem the discount code WELCOME50 for user user_123?
```
L'agent traitera votre demande à l'aide de l'exécution du modèle Gemini et tentera d'appliquer la remise.
Remarque : Étant donné qu'Antigravity génère la logique des outils de manière dynamique, l'implémentation de la vérification des utilisateurs enregistrés par votre agent peut varier. Si l'agent rejette user_123 comme non enregistré (par exemple, User ID 'user_123' is not registered), demandez-lui quels ID utilisateur sont enregistrés dans son magasin (ou vérifiez app/agent.py), puis réessayez avec un ID utilisateur enregistré valide.

12. Effectuer un nettoyage

Pour nettoyer votre poste de travail et éviter de laisser des ressources ou des secrets indésirables dans votre environnement local, suivez ces étapes de nettoyage.

Arrêter le serveur local : si votre serveur Playground est toujours en cours d'exécution, arrêtez-le dans votre terminal en appuyant sur Ctrl + C.
Supprimer les fichiers de projet en local : supprimez le répertoire de projet en local de votre machine :
```
rm -rf ~/secure-agent-lab
```

13. Félicitations

Félicitations ! Vous avez réussi à établir un cycle de vie de développement sécurisé et axé sur les tests à l'aide de l'IDE Google Antigravity, à créer un agent d'assistance pour les achats ADK 2.0 pur et à le valider localement.

Connaissances acquises

Découvrez comment échafauder et intégrer un agent ADK 2.0 (ADK) à l'aide de l'IDE Antigravity et de agents-cli.
Découvrez comment configurer des normes de programmation sécurisée au niveau du projet à l'aide de CONTEXT.md.
Découvrez comment créer et exécuter une compétence de modélisation des menaces STRIDE personnalisée dans l'IDE Antigravity.
Découvrez comment limiter la phase de planification d'un agent d'IA pour faire respecter les limites de sécurité.
Implémenter des tests de sécurité isolés et basés sur les résultats à l'aide de pytest.
Comment exécuter et tester l'application agentique en local.
Différences et compromis entre les hooks Git et les hooks d'exécution spécifiques à l'agent.

Étapes suivantes

Pour les configurations avancées, consultez le guide de personnalisation d'Antigravity.
En savoir plus sur la modélisation des menaces STRIDE
Implémentez des règles Semgrep adaptées aux règles de sécurité de votre organisation.

Gagnez votre badge Kaggle 5-Day AI Agents 🎉

Vous avez suivi cet atelier dans le cadre du cours intensif de cinq jours Agents IA : cours intensif de vibe coding avec Google de Kaggle ? Demandez votre badge d'obtention :

Obtenir le badge "5 jours avec les agents d'IA"