Sécuriser une application à l'aide du plug-in Google Cloud Developer dans Antigravity

1. Introduction

Dans cet atelier de programmation, vous allez créer et déployer l'application Web de calcul gCurrenC sur Google Cloud, puis la protéger contre les accès indésirables. À l'aide de Google Antigravity, du plug-in Google Cloud Developer et du serveur MCP Developer Knowledge (DK), vous concevez et implémentez une architecture de sécurité qui contrôle qui peut accéder à l'application et la protège contre toute utilisation non autorisée.

Dans cet atelier, vous allez connecter Google Antigravity au serveur MCP DK, qui ancre Antigravity dans la documentation Google Cloud officielle en temps réel. Au lieu de s'appuyer sur des données d'entraînement statiques ou des pondérations de modèle obsolètes, Antigravity récupère de manière dynamique les modèles architecturaux actuels, la dernière syntaxe de la CLI gcloud et les paramètres de sécurité, ce qui réduit les hallucinations et ancre les réponses dans des connaissances à jour.

Ce que vous allez faire

  • Charge de travail de calcul privée : deux machines virtuelles (VM) Compute Engine exécutant l'application Web gCurrenC calculator dans un réseau cloud privé virtuel (VPC) personnalisé sans adresse IP publique.
  • Pipeline d'entrée sécurisé : équilibreur de charge d'application externe global avec un sous-réseau proxy réservé qui achemine le trafic Internet via des serveurs Google Front End (GFE) vers vos VM privées sans les exposer à l'Internet public.
  • Pipeline de sortie sécurisé : une passerelle Cloud Router et Cloud NAT associée à Cloud Next Generation Firewall (Cloud NGFW) Enterprise et Certificate Authority Service (CAS) au niveau du projet pour effectuer une inspection TLS à la volée et une analyse IPS (Intrusion Prevention Service) sur le trafic HTTPS sortant de l'API de change.

Points abordés

  • Installez le plug-in google-cloud-developer à l'aide de la CLI Antigravity et configurez le serveur MCP DK dans Antigravity.
  • Déployez et testez une application Web privée isolée sur Compute Engine à l'aide du transfert TCP Identity-Aware Proxy (IAP).
  • Utilisez le prompting multitour ancré dans Antigravity pour concevoir une architecture de sécurité d'entrée et de sortie au niveau du projet.
  • Générez, auditez et exécutez un script de déploiement bash pour l'équilibrage de charge d'application externe global, Cloud NAT, CAS et Cloud NGFW Enterprise.

2. Avant de commencer

Prérequis

Avant de commencer cet atelier de programmation, assurez-vous de disposer des éléments suivants :

  1. Un compte Google et le navigateur Google Chrome.
  2. Un nouveau projet Google Cloud avec la facturation activée. Notez l'ID de votre projet (PROJECT_ID), car vous l'utiliserez tout au long de cet atelier de programmation pour activer les API, créer votre clé API et déployer des ressources Google Cloud.
  3. Autorisations Identity and Access Management (IAM) dans votre projet Google Cloud pour créer des clés API, des ressources Compute Engine, des réseaux VPC, des pools d'autorités de certification, un tunnel IAP et des points de terminaison Cloud NGFW.
  4. Authentifiez-vous avec la CLI gcloud, définissez votre projet Google Cloud actif et activez les API requises :
    1. Dans votre terminal ou dans Cloud Shell, vérifiez que vous êtes déjà authentifié :
      gcloud auth list
      
      Si vous devez authentifier votre compte, exécutez la commande suivante :
      gcloud auth login
      
    2. Vérifiez que la CLI gcloud est configurée pour utiliser votre projet :
      gcloud config list project
      
      Si votre projet n'est pas défini ou si un autre projet est actif, définissez l'ID de votre projet. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud :
      export PROJECT_ID=PROJECT_ID
      gcloud config set project PROJECT_ID
      
    3. Activez les API requises dans votre projet Google Cloud :
      gcloud services enable \
         compute.googleapis.com \
         iap.googleapis.com \
         networksecurity.googleapis.com \
         privateca.googleapis.com \
         developerknowledge.googleapis.com \
         apikeys.googleapis.com
      
  5. Installez Antigravity 2.0 sur votre système local à partir de la page de téléchargement de Google Antigravity.

Installer le plug-in Google Cloud Developer à l'aide de la CLI Antigravity

Pour installer le plug-in Google Cloud Developer à l'aide de la CLI Antigravity, procédez comme suit :

  1. Pour installer la CLI Antigravity sur votre poste de travail local, procédez comme suit :
    1. Ouvrez votre terminal local.
    2. Exécutez le script d'installation :
      curl -fsSL https://antigravity.google/cli/install.sh | bash
      
    3. Fermez et rouvrez votre session de terminal pour que le binaire de la CLI Antigravity agy soit disponible dans votre PATH système.
  2. Dans votre terminal local, exécutez la commande suivante pour installer le plug-in google-cloud-developer :
    agy plugin install https://github.com/google/skills/plugins/cloud/google-cloud-developer
    
    Vous obtenez un résultat semblable à celui-ci :
    Cloning plugin from https://github.com/google/skills.git...
      [ok]    google-cloud-developer
              ✔ skills      : 5 processed
              - agents      : skipped (not found)
              - commands    : skipped (not found)
              ✔ mcpServers  : 1 processed
              - hooks       : skipped (not found)
    
    Pour en savoir plus sur l'ensemble des compétences et fonctionnalités disponibles incluses dans le plug-in, consultez la documentation du plug-in Google Cloud Developer et l'atelier de programmation Premiers pas avec le plug-in Google Cloud Developer.

3. Configurer Antigravity et le serveur MCP DK

Dans cette section, vous allez configurer le serveur MCP DK dans Antigravity à l'aide d'une clé API Google Cloud restreinte.

  1. Ouvrez Antigravity, saisissez /goal et appuyez sur Entrée pour activer le mode objectif, puis collez le prompt suivant pour créer une clé API restreinte et configurer le serveur MCP DK. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud de la section Avant de commencer. Pour en savoir plus, consultez Plug-in google-cloud-developer.
    Set up Antigravity to use the Developer Knowledge MCP server on my local machine. Run the necessary terminal commands to complete the following:
    
    1. Create a restricted API key named 'DKP-MCP-Key' that can only target the Developer Knowledge API. Use the PROJECT_ID to create the API key.
    2. Retrieve the actual key string of the newly created API key.
    3. Create or safely update my ~/.gemini/config/mcp_config.json file (preserve any existing MCP servers) with the correct JSON structure to connect the developer-knowledge server using that API key in the headers.
    You MUST use the following JSON structure for the new server:
    
       "developer-knowledge": {
          "serverUrl": "https://developerknowledge.googleapis.com/mcp",
          "headers": {
          "x-goog-api-key": "<INSERT_RETRIEVED_API_KEY_HERE>"
          }
       }
    
    When you are done, confirm that the setup is complete.
    
  2. Pour vérifier que le serveur MCP DK est actif, saisissez la requête suivante dans la fenêtre de chat Antigravity :
    Which MCP servers are available?
    
    Antigravity liste developer-knowledge et ses outils disponibles (search_documents, answer_query et get_documents) :Vérifier les serveurs MCP disponibles dans Antigravity

4. Créer et déployer l'application

Dans cette section, vous allez déployer l'application gCurrenC calculator sur deux VM Compute Engine privées au sein d'un réseau VPC personnalisé.

L'application fournit les éléments suivants :

  • Un convertisseur de devises en temps réel compatible avec USD, EUR, GBP, JPY, CAD, INR et AUD, qui utilise la bibliothèque standard http.server intégrée de Python sur le port 8080 avec un point de terminaison de vérification d'état /healthz.
  • Une console de vérification de la sécurité pour exécuter des sondes de connectivité API sortante et de prévention des menaces chiffrées en temps réel.
  • Une règle de pare-feu d'entrée autorisant la plage IAP de Google à atteindre les ports 22 et 8080 pour les tests d'administration sans exposer d'adresses IP publiques.

Déployer l'application

  1. Dans la fenêtre de chat Antigravity, saisissez /goal, puis exécutez le prompt suivant :
    You are a Cloud developer. Deploy the "gCurrenC calculator" app onto two (2) Compute Engine VMs with no external IP addresses (`--no-address`) inside a dedicated custom VPC network and private subnet.
    
    CRITICAL INSTRUCTIONS ON OUTPUT:
    - The VMs are strictly private with no external IP addresses and the local IAP tunnel has NOT been started yet. Any web URL is completely unreachable and will fail with a connection error.
    - In your final response, simply confirm that the private VMs and Managed Instance Group are deployed, and state that the user should establish the IAP tunnel. Do not output, format, or suggest any web preview link or URL (such as http://localhost:8080 or internal IP addresses) in your final response.
    
    Run this script in the terminal:
    
    ```bash
    #!/usr/bin/env bash
    set -euxo pipefail
    
    # Disable any interactive confirmation prompts so execution never hangs
    export CLOUDSDK_CORE_DISABLE_PROMPTS=1
    
    # --- User Configuration ---
    PROJECT_ID="[PROJECT_ID]"
    REGION="us-central1"
    ZONE="us-central1-a"
    NETWORK="gcurrenc-vpc"
    SUBNET="gcurrenc-app-subnet"
    SUBNET_RANGE="10.10.1.0/24"
    # --------------------------
    
    echo "==> [1/5] Configuring project, default region/zone, and enabling APIs..."
    gcloud config set project "${PROJECT_ID}"
    gcloud config set compute/region "${REGION}"
    gcloud config set compute/zone "${ZONE}"
    gcloud services enable compute.googleapis.com
    
    echo "==> [2/5] Creating custom VPC network and private workload subnet..."
    gcloud compute networks create "${NETWORK}" \
       --subnet-mode=custom \
       --description="Dedicated VPC for currency exchange app demo" 2>/dev/null || true
    
    gcloud compute networks subnets create "${SUBNET}" \
       --network="${NETWORK}" \
       --region="${REGION}" \
       --range="${SUBNET_RANGE}" \
       --enable-private-ip-google-access \
       --description="Private subnet hosting backend compute instances" 2>/dev/null || true
    
    echo "==> [3/5] Generating standalone Python standard-library startup script..."
    cat << 'STARTUP_EOF' > /tmp/private_app_startup.sh
    #!/bin/bash
    set -euxo pipefail
    
    mkdir -p /opt/gcurrenc-app
    
    # Pure Python standard-library application (zero pip/apt dependencies needed at boot)
    cat << 'APPEOF' > /opt/gcurrenc-app/app.py
    import os
    import sys
    import json
    import socket
    import urllib.request
    import urllib.parse
    import ssl
    from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
    
    SUPPORTED_CURRENCIES = ["USD", "EUR", "GBP", "JPY", "CAD", "INR", "AUD"]
    
    class CurrencyAppHandler(BaseHTTPRequestHandler):
       def address_string(self):
          return str(self.client_address[0])
    
       def do_GET(self):
          parsed = urllib.parse.urlparse(self.path)
          path = parsed.path
          params = urllib.parse.parse_qs(parsed.query)
    
          if path == "/favicon.ico":
                self.send_response(204)
                self.end_headers()
                return
    
          if path == "/healthz":
                self.send_response(200)
                self.send_header("Content-Type", "text/plain")
                self.end_headers()
                self.wfile.write(b"OK")
                return
    
          if path == "/api/security-test":
                mode = params.get("mode", ["safe"])[0]
                target = "https://secure.eicar.org/eicar.com.txt" if mode == "threat" else "https://api.frankfurter.dev/v1/latest?from=USD&to=EUR"
                try:
                   req = urllib.request.Request(target, headers={"User-Agent": "SecureCurrencyApp/1.0"})
                   ctx = ssl.create_default_context()
                   with urllib.request.urlopen(req, timeout=5, context=ctx) as resp:
                      data = {"verdict": "PERMITTED", "target": target, "http_status": resp.status}
                      code = 200
                except Exception as e:
                   data = {"verdict": "BLOCKED_OR_FAILED", "target": target, "error": str(e)}
                   code = 502
    
                self.send_response(code)
                self.send_header("Content-Type", "application/json")
                self.end_headers()
                self.wfile.write(json.dumps(data, indent=2).encode("utf-8"))
                return
    
          self.render_page()
    
       def do_POST(self):
          parsed = urllib.parse.urlparse(self.path)
          if parsed.path == "/generate":
                content_length = int(self.headers.get("Content-Length", 0))
                post_body = self.rfile.read(content_length).decode("utf-8")
                form = urllib.parse.parse_qs(post_body)
    
                base_curr = form.get("base_curr", ["USD"])[0]
                target_curr = form.get("target_curr", ["EUR"])[0]
                try:
                   amount = float(form.get("amount", ["2500.00"])[0])
                except ValueError:
                   amount = 2500.00
    
                rate_str = "Unavailable"
                total_str = "Rate lookup pending outbound internet activation"
                try:
                   if base_curr == target_curr:
                      rate = 1.0
                   else:
                      url = f"https://api.frankfurter.dev/v1/latest?from={base_curr}&to={target_curr}"
                      req = urllib.request.Request(url, headers={"User-Agent": "SecureCurrencyApp/1.0"})
                      with urllib.request.urlopen(req, timeout=4) as resp:
                            res_json = json.loads(resp.read().decode("utf-8"))
                            rate = res_json["rates"][target_curr]
                   rate_str = str(rate)
                   total_str = f"{round(amount * rate, 2):,.2f} {target_curr}"
                except Exception as e:
                   total_str = f"Outbound connection unavailable {str(e)}"
    
                self.render_page(base_curr, target_curr, amount, rate_str, total_str)
                return
    
          self.send_response(404)
          self.end_headers()
    
       def render_page(self, base_curr="USD", target_curr="EUR", amount=2500.00, fx_rate="1.00", total_str=""):
          hostname = socket.gethostname()
          curr_options_base = "".join([f'<option value="{c}" {"selected" if c == base_curr else ""}>{c}</option>' for c in SUPPORTED_CURRENCIES])
          curr_options_target = "".join([f'<option value="{c}" {"selected" if c == target_curr else ""}>{c}</option>' for c in SUPPORTED_CURRENCIES])
    
          result_block = ""
          if total_str:
                if fx_rate == "Unavailable":
                   rate_line = "<p style='margin: 6px 0;'>Exchange Rate: <span style='color: #d93025; font-weight: bold;'>⚠️ Offline-Outbound internet blocked</span></p>"
                else:
                   rate_line = f"<p style='margin: 6px 0; font-size: 14px; color: #137333;'>🟢 Exchange Rate: <strong>1 {base_curr} = {fx_rate} {target_curr}</strong> (Secured via Cloud NAT & Cloud NGFW)</p>"
    
                result_block = f"""
                <div style="margin-top: 22px; background: #e6f4ea; border: 1px solid #c6e1c6; border-left: 5px solid #34a853; padding: 18px 20px; border-radius: 8px;">
                   <h4 style="margin: 0 0 6px 0; text-transform: uppercase; font-size: 12px; color: #137333; letter-spacing: 0.5px;">Conversion Result</h4>
                   <div style="font-size: 24px; font-weight: 700; color: #202124; margin-bottom: 6px;">
                      {amount:,.2f} {base_curr} = <span style="color: #1a73e8;">{total_str}</span>
                   </div>
                   {rate_line}
                </div>
                """
    
          html = ("""<!DOCTYPE html>
    <html lang="en">
    <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>gCurrenC calculator</title>
       <style>
          body {
                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
                background: #f8f9fa;
                margin: 30px 15px;
                color: #202124;
                display: flex;
                justify-content: center;
          }
          .container {
                width: 100%;
                max-width: 860px;
          }
          .card {
                background: white;
                padding: 24px 28px;
                border-radius: 12px;
                box-shadow: 0 1px 3px rgba(60,64,67,0.12), 0 4px 8px rgba(60,64,67,0.06);
                border: 1px solid #dadce0;
                margin-bottom: 20px;
          }
          .header {
                display: flex;
                justify-content: space-between;
                align-items: center;
                border-bottom: 1px solid #e8eaed;
                padding-bottom: 14px;
                margin-bottom: 20px;
          }
          .header h2 {
                margin: 0 0 4px 0;
                font-size: 20px;
                font-weight: 600;
          }
          .header p {
                margin: 0;
                font-size: 13px;
                color: #5f6368;
          }
          .badge {
                background: #e8f0fe;
                color: #1a73e8;
                padding: 6px 12px;
                border-radius: 16px;
                font-weight: 600;
                font-size: 12px;
                border: 1px solid #d2e3fc;
                display: flex;
                align-items: center;
                gap: 6px;
          }
          .badge::before {
                content: "";
                width: 8px;
                height: 8px;
                border-radius: 50%;
                background-color: #34a853;
          }
          .form-row {
                display: flex;
                gap: 14px;
                align-items: flex-end;
                flex-wrap: wrap;
          }
          .form-group {
                display: flex;
                flex-direction: column;
                gap: 6px;
          }
          .form-group label {
                font-size: 12px;
                font-weight: 600;
                color: #5f6368;
                text-transform: uppercase;
                letter-spacing: 0.5px;
          }
          input, select {
                padding: 10px 14px;
                border: 1px solid #dadce0;
                border-radius: 6px;
                font-size: 14px;
                color: #202124;
                background-color: #fff;
                box-sizing: border-box;
                transition: border-color 0.15s, box-shadow 0.15s;
          }
          input:focus, select:focus {
                outline: none;
                border-color: #1a73e8;
                box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.15);
          }
          button {
                padding: 11px 20px;
                background: #1a73e8;
                color: white;
                border: none;
                border-radius: 6px;
                font-size: 14px;
                font-weight: 500;
                cursor: pointer;
                transition: background 0.15s, box-shadow 0.15s;
          }
          button:hover {
                background: #1557b0;
                box-shadow: 0 1px 2px rgba(60,64,67,0.3);
          }
          .danger-btn {
                background: #d93025;
          }
          .danger-btn:hover {
                background: #b31412;
          }
          pre {
                background: #202124;
                color: #8ab4f8;
                padding: 14px;
                border-radius: 6px;
                overflow-x: auto;
                font-family: "SF Mono", "Fira Code", Consolas, monospace;
                font-size: 13px;
                line-height: 1.5;
                margin: 0;
          }
          /* Collapsible Security Console */
          details.security-drawer {
                background: white;
                border-radius: 12px;
                box-shadow: 0 1px 3px rgba(60,64,67,0.12);
                border: 1px solid #dadce0;
                overflow: hidden;
                margin-bottom: 24px;
          }
          details.security-drawer summary {
                padding: 16px 20px;
                font-size: 14px;
                font-weight: 600;
                cursor: pointer;
                list-style: none;
                display: flex;
                justify-content: space-between;
                align-items: center;
                user-select: none;
                background: #fafafa;
                transition: background 0.15s;
          }
          details.security-drawer summary::-webkit-details-marker {
                display: none;
          }
          details.security-drawer summary:hover {
                background: #f1f3f4;
          }
          details.security-drawer[open] summary {
                border-bottom: 1px solid #dadce0;
                background: #ffffff;
          }
          .expand-toggle {
                font-size: 13px;
                font-weight: 500;
          }
          details.security-drawer summary .expand-toggle::before {
                content: "▶ Click to Expand";
                color: #1a73e8;
          }
          details.security-drawer[open] summary .expand-toggle::before {
                content: "▼ Click to Collapse";
                color: #5f6368;
          }
          .drawer-body {
                padding: 20px;
                background: #ffffff;
          }
          .drawer-body p {
                margin-top: 0;
                font-size: 13px;
                color: #5f6368;
          }
          .probe-buttons {
                display: flex;
                gap: 10px;
                margin-bottom: 14px;
          }
       </style>
    </head>
    <body>
    <div class="container">
       <div class="card">
          <div class="header">
                <div>
                   <h2>💱 gCurrenC calculator</h2>
    
                </div>
                <div class="badge">Serving host: {hostname}</div>
          </div>
          <form method="POST" action="/generate">
                <div class="form-row">
                   <div class="form-group" style="flex: 1.5; min-width: 140px;">
                      <label>Amount</label>
                      <input type="number" step="0.01" name="amount" value="{amount}" required>
                   </div>
                   <div class="form-group" style="flex: 1; min-width: 100px;">
                      <label>From</label>
                      <select name="base_curr">{curr_options_base}</select>
                   </div>
                   <div class="form-group" style="flex: 1; min-width: 100px;">
                      <label>To (Target)</label>
                      <select name="target_curr">{curr_options_target}</select>
                   </div>
                   <div class="form-group">
                      <button type="submit">Convert currency ➔</button>
                   </div>
                </div>
          </form>
          {result_block}
       </div>
    
       <!-- Collapsible Security Verification Console -->
       <details class="security-drawer">
          <summary>
                <span>🛡️ Security verification console</span>
                <span class="expand-toggle"></span>
          </summary>
          <div class="drawer-body">
                <p>Test outbound HTTPS traffic and threat prevention capabilities in real time:</p>
                <div class="probe-buttons">
                   <button type="button" onclick="runProbe('safe')">Test Outbound API Connection</button>
                   <button type="button" class="danger-btn" onclick="runProbe('threat')">Simulate Encrypted Threat (EICAR)</button>
                </div>
                <pre id="output">Waiting for command...</pre>
          </div>
       </details>
    </div>
    <script>
    function runProbe(mode) {
       const el = document.getElementById('output');
       el.innerText = 'Executing outbound request...';
       fetch('/api/security-test?mode=' + mode)
          .then(res => res.json())
          .then(data => el.innerText = JSON.stringify(data, null, 2))
          .catch(err => el.innerText = 'Connection dropped / reset by Firewall: ' + err);
    }
    </script>
    </body>
    </html>"""
             .replace("{hostname}", str(hostname))
             .replace("{amount}", str(amount))
             .replace("{curr_options_base}", curr_options_base)
             .replace("{curr_options_target}", curr_options_target)
             .replace("{result_block}", result_block)
          )
          self.send_response(200)
          self.send_header("Content-Type", "text/html; charset=utf-8")
          self.end_headers()
          self.wfile.write(html.encode("utf-8"))
    
    def run():
       server_address = ('0.0.0.0', 8080)
       httpd = ThreadingHTTPServer(server_address, CurrencyAppHandler)
       httpd.serve_forever()
    
    if __name__ == '__main__':
       run()
    APPEOF
    
    # Register and start systemd unit
    cat << 'SERVICEEOF' > /etc/systemd/system/gcurrenc-app.service
    [Unit]
    Description=Currency exchange calculator web application
    After=network.target
    
    [Service]
    Type=simple
    User=root
    WorkingDirectory=/opt/gcurrenc-app
    ExecStart=/usr/bin/python3 /opt/gcurrenc-app/app.py
    Restart=always
    
    [Install]
    WantedBy=multi-user.target
    SERVICEEOF
    
    systemctl daemon-reload
    systemctl enable gcurrenc-app
    systemctl start gcurrenc-app
    STARTUP_EOF
    
    echo "==> [4/5] Creating Firewall, Regional Instance Template, and 2-VM MIG..."
    gcloud compute firewall-rules create allow-iap-admin \
       --network="${NETWORK}" \
       --allow=tcp:22,tcp:8080 \
       --source-ranges=35.235.240.0/20 \
       --target-tags=gcurrenc-app-vm \
       --description="Allow IAP SSH and port 8080 access to private VMs" \
       --quiet 2>/dev/null || true
    
    # Explicitly pass both --region and --instance-template-region to avoid prompt
    gcloud compute instance-templates create gcurrenc-app-template \
       --instance-template-region="${REGION}" \
       --region="${REGION}" \
       --network="${NETWORK}" \
       --subnet="${SUBNET}" \
       --machine-type=e2-medium \
       --no-address \
       --tags=gcurrenc-app-vm \
       --metadata-from-file=startup-script=/tmp/private_app_startup.sh \
       --quiet
    
    gcloud compute instance-groups managed create gcurrenc-app-mig \
       --base-instance-name=gcurrenc-vm \
       --template="projects/${PROJECT_ID}/regions/${REGION}/instanceTemplates/gcurrenc-app-template" \
       --size=2 \
       --zone="${ZONE}" \
       --quiet
    
    gcloud compute instance-groups managed set-named-ports gcurrenc-app-mig \
       --named-ports=http-port:8080 \
       --zone="${ZONE}" \
       --quiet
    
    echo "==> [5/5] Verifying private VM deployment and internal status..."
    sleep 30
    
    gcloud compute instances list \
       --filter="name ~ '^gcurrenc-vm-'" \
       --zones="${ZONE}" \
       --format="table(name,zone.basename():label=ZONE,networkInterfaces[0].networkIP:label=INTERNAL_IP,status)"
    
    FIRST_VM=$(gcloud compute instances list \
       --filter="name ~ '^gcurrenc-vm-'" \
       --zones="${ZONE}" \
       --format="value(name)" \
       --limit=1)
    
    echo "Testing healthz on ${FIRST_VM} via IAP tunnel..."
    gcloud compute ssh "${FIRST_VM}" \
       --zone="${ZONE}" \
       --tunnel-through-iap \
       --quiet \
       --command="curl -fsS http://localhost:8080/healthz"
    
    echo ""
    echo "=========================================================================="
    echo "PREREQUISITE COMPLETE: 2 private VMs deployed with no external IPs."
    echo "VPC: ${NETWORK} | Subnet: ${SUBNET} (${SUBNET_RANGE})"
    echo "Instance Group: gcurrenc-app-mig (Zone: ${ZONE}, Port: 8080)"
    echo ""
    echo "The VMs are private and the IAP tunnel is not active. Set up the background IAP tunnel first to access the deployed app."
    echo ""
    echo "=========================================================================="
    ```
    

Vérifier la création de l'instance de VM

Une fois qu'Antigravity a déployé l'application sur les deux VM Compute Engine privées, vérifiez les instances dans la console Google Cloud :

  1. Dans la console Google Cloud, accédez à Instances de VM.
  2. Vérifiez que les deux instances de VM s'exécutent avec des adresses IP internes et sans adresse IP externe :Vérifier les deux instances de VM Compute Engine privées sans adresse IP externe

5. Tester l'application

Comme les VM privées n'ont pas d'adresse IP externe (--no-address) ni de passerelle Cloud NAT, elles n'ont pas de route vers Internet et ne peuvent pas accéder aux API de conversion de devises externes. Avant de configurer l'accès sortant sécurisé, testez l'application via un tunnel IAP local pour vérifier qu'il n'y a pas d'accès à Internet.

  1. En mode /goal, exécutez le prompt suivant dans la fenêtre de chat Antigravity :
    Automate the IAP tunnel configuration and health verification for the web app, then output the live test URL.
    
    Run a terminal script that performs the following steps non-interactively:
    
    1. Firewall Check:
       - Identify the active network ('gcurrenc-vpc' if it exists, otherwise 'default').
       - Idempotently ensure an ingress firewall rule exists permitting 'tcp:22,tcp:8080' from the Google IAP range '35.235.240.0/20' targeting 'gcurrenc-app-vm'.
    
    2. VM Health Verification:
       - Find the first running instance matching '^gcurrenc-vm-' in zone 'us-central1-a'.
       - Via 'gcloud compute ssh --tunnel-through-iap', verify that the 'gcurrenc-app' systemd service is active. If not active, restart it.
    
    3. Background IAP Tunnel:
       - Free up local port 8080 if an old tunnel or process is lingering (e.g., using 'lsof -ti:8080 | xargs kill -9' or 'fuser -k 8080/tcp').
       - Launch 'gcloud compute start-iap-tunnel <VM_NAME> 8080 --local-host-port=localhost:8080 --zone=us-central1-a' in the background using nohup, redirecting output to '/tmp/iap_tunnel.log'.
       - Wait up to 10 seconds for the tunnel to establish, checking with 'curl -fsS http://localhost:8080/healthz'.
    
    4. Output Web Preview URL:
       - Detect whether the environment is Google Cloud Shell (check if $CLOUD_SHELL is true) or a local workstation.
       - If Cloud Shell, print instructions and the direct web preview link.
       - If local machine, provide the clickable 'http://localhost:8080' URL.
    
  2. Une fois le tunnel démarré, ouvrez http://localhost:8080/ dans votre navigateur Web :Calculateur gCurrenC s'exécutant sur une VM privée sans accès à Internet sortant
  3. Testez l'application :
    1. Cliquez sur Convertir la devise. Le résultat de la conversion affiche Offline - Outbound internet blocked et Outbound connection unavailable. Ce résultat est attendu, car les VM privées ne peuvent pas se connecter à Internet pour récupérer les derniers taux de change.
    2. Développez Console de vérification de la sécurité, puis cliquez sur Tester la connexion API sortante. Le résultat affiche verdict: BLOCKED_OR_FAILED () pour https://api.frankfurter.dev/v1/latest. Ce résultat est attendu, car les VM privées ne peuvent pas se connecter à Internet ni récupérer les taux de change depuis https://api.frankfurter.dev/v1/latest.
    3. Cliquez sur Simuler une menace chiffrée (EICAR). Le résultat affiche également verdict: BLOCKED_OR_FAILED pour https://secure.eicar.org/eicar.com.txt. Ce résultat est également attendu, car les VM privées n'ont pas de connectivité Internet.

Arrêter le tunnel IAP local

Avant de concevoir et de déployer l'architecture de sécurité, arrêtez le tunnel IAP local pour libérer le port 8080 :

  1. En mode /goal, exécutez la requête suivante :
    Free up local port 8080 and terminate any running Google Cloud IAP tunnels (e.g., kill processes matching 'start-iap-tunnel' or listening on port 8080).
    
    Antigravity confirme que le tunnel IAP est arrêté et que le port local 8080 est libre.

6. Sécuriser l'application

Dans les sections précédentes, vous avez créé des VM Compute Engine privées sans adresse IP publique et vérifié deux défis majeurs en matière de mise en réseau et de sécurité :

  • Accès entrant (entrée) : les internautes ne peuvent pas accéder directement aux instances de VM privées. Pour exposer l'application Web, il faut acheminer le trafic via un équilibreur de charge d'application externe global et un sous-réseau proxy réservé, sans exposer les VM à l'Internet public.
  • Accès sortant (sortie) : les VM privées n'ont pas de route vers Internet pour interroger les API de taux de change HTTPS en direct. Pour activer l'accès sortant, il faut inspecter le trafic chiffré à la recherche de logiciels malveillants et d'exfiltration de données sans rompre la confiance SSL/TLS.

Dans cette section, vous allez guider Antigravity à travers un workflow simplifié basé sur la documentation officielle de Google Cloud (@retrieving-developer-knowledge) pour concevoir, auto-auditer et déployer une architecture de sécurité d'entrée et de sortie au niveau du projet pour votre application.

Concevoir l'architecture de sécurité unifiée

  1. En mode /goal, exécutez le prompt suivant pour générer un diagramme de l'architecture de bout en bout et une explication couvrant les flux de trafic entrant et sortant :
    You are a Google Cloud Network and Security Architect. We need to design an end-to-end security architecture for our "gCurrenC calculator" app running on private Compute Engine VMs with no external IP addresses inside 'gcurrenc-vpc'.
    
    We are operating in a standalone Google Cloud project without an Organization resource, so all security resources must be scoped at the project level.
    
    Use the @retrieving-developer-knowledge skill to consult official Google Cloud documentation and suggest an architecture diagram and explanation covering both flows:
    
    1. Ingress Flow:
       - How internet users securely reach the private VMs via a global external Application Load Balancer.
       - Why Envoy-based external Application Load Balancers require a dedicated proxy-only subnet, and how Google Front Ends (GFEs) proxy traffic to private backends without exposing VMs to the public internet.
    
    2. Egress Flow:
       - How private VMs reach the internet via Cloud NAT to query live currency exchange APIs, such as frankfurter.dev.
       - How Cloud NGFW Enterprise provides Layer 7 deep packet inspection and intrusion prevention (IPS) for outbound encrypted HTTPS traffic.
       - How TLS inspection backed by Certificate Authority Service (CAS) decrypts outbound HTTPS sessions on the fly, and what Root CA trust configuration the private VMs require.
    
    Provide a clear diagram and explain how these components connect together.
    
    Antigravity interroge le serveur MCP DK et renvoie un diagramme de l'architecture et une explication montrant comment l'équilibrage de charge d'application externe global, le sous-réseau proxy réservé, Cloud NAT, CAS et Cloud NGFW Enterprise au niveau du projet se connectent entre eux.

Générer le plan des ressources architecturales

  1. Saisissez le prompt suivant pour structurer la conception en un plan de ressources catégorisé au niveau du projet avant de générer le script de déploiement :
    Act as a Lead Network Security Architect. Using the @retrieving-developer-knowledge skill, provide an architectural outline of all the Google Cloud resources required to secure the "gCurrenC calculator" app.
    
    Our starting state:
    - The custom VPC ('gcurrenc-vpc'), workload subnet ('gcurrenc-app-subnet'), and 2-instance MIG ('gcurrenc-app-mig', port 8080) are already deployed.
    - All newly added security components must be project-level resources (no organization resources).
    
    Structure your resource outline into three distinct categories, indicating which resources are new additions:
    1. Core VPC Infrastructure: proxy-only subnet ('gcurrenc-proxy-subnet', 10.10.2.0/24), Cloud Router, and Cloud NAT gateway.
    2. Inbound security (ingress): global external ALB components (forwarding rule on port 443, target HTTPS proxy, SSL certificate, URL map, backend service attached to 'gcurrenc-app-mig' on port 8080, and HTTP health check on '/healthz') and ingress firewall rules.
    3. Outbound security (egress): CAS DevOps CA pool and root CA, project-level Cloud NGFW Enterprise components (Threat Prevention profile, Security Profile Group, Firewall Endpoint in zone us-central1-a, and Endpoint Association attaching the TLS policy), and global network firewall policy egress rules.
    
    For each resource, briefly state its role in the security boundary and how it connects to adjacent components.
    
    Antigravity produit un plan de ressources structuré mappé sur l'infrastructure VPC principale, l'équilibrage de charge entrant et la prévention des menaces sortantes au niveau du projet.

Générer et auditer vous-même le script de déploiement

  1. En mode /goal, exécutez le prompt suivant pour générer un script de déploiement bash complet et non interactif, et l'auto-auditer automatiquement par rapport aux exigences de conformité en même temps :
    Act as a Principal Infrastructure Engineer. Using the @retrieving-developer-knowledge skill, generate a complete, non-interactive Bash script to deploy this entire security architecture for our "gCurrenC calculator" app, and self-audit the script before outputting it.
    
    Requirements:
    - Discover the project ID, region, and zone dynamically from the existing 'gcurrenc-app-subnet' and 'gcurrenc-app-mig'.
    - Keep all resources scoped strictly to the project level (no Organization resource).
    - Deploy the proxy-only subnet, global external Application Load Balancer, Cloud Router, and Cloud NAT. Don't use Cloud Armor.
    - Deploy project-level Cloud NGFW Enterprise with CAS TLS inspection ('--tls-inspect' on the firewall policy egress rule and 'gcloud beta' for the project-level firewall endpoint association) and an explicit DENY override for malware and antivirus threats.
    - Distribute the root CA to the private VMs over IAP SSH with connection timeouts so the guest OS trust store is updated.
    - Print the final Load Balancer URL ('https://${LB_IP}') at the end.
    
    Wrap the script in 'set -euxo pipefail' and output only the single executable bash script block.
    
    Antigravity génère le script bash complet, audite automatiquement chaque commande par rapport aux contraintes de conformité et génère le bloc de script exécutable unique encapsulé dans set -euxo pipefail.

Exécuter le script de déploiement de sécurité

  1. En mode /goal, collez le script bash généré à partir de la requête précédente dans la fenêtre de chat Antigravity au format suivant pour exécuter le déploiement et afficher l'URL de l'application en ligne (https://<LB_IP>) :
    Run this script.
    <PASTED-SCRIPT>
    

7. Vérifier l'application sécurisée

Une fois le script de déploiement terminé, Antigravity affiche l'URL HTTPS externe de l'équilibreur de charge d'application externe global (https://<LB_IP>).

  1. Ouvrez https://<LB_IP> dans votre navigateur Web et ignorez l'avertissement du navigateur concernant le certificat autosigné pour charger l'interface du calculateur gCurrenC :Calculateur gCurrenC sécurisé avec un équilibreur de charge d'application externe global, Cloud NAT et Cloud NGFW Enterprise
  2. Testez l'application pour vérifier la connectivité sortante et la prévention des menaces :
    1. Cliquez sur Convertir la devise. L'application affiche immédiatement le taux de change converti en temps réel. Cela confirme que l'équilibrage de charge d'entrée achemine correctement le trafic via les Google Front Ends (GFE) et le sous-réseau proxy réservé, tandis que Cloud NAT récupère les taux de change en direct depuis api.frankfurter.dev.
    2. Développez Console de vérification de la sécurité, puis cliquez sur Tester la connexion API sortante. L'application affiche verdict: PERMITTED (HTTP 200). Cela confirme que le routage Cloud NAT fonctionne et que le système d'exploitation de la VM fait confiance à l'autorité de certification racine CAS privée pour les sessions HTTPS déchiffrées.
    3. Cliquez sur Simuler une menace chiffrée (EICAR). L'application affiche verdict: PERMITTED. Cela confirme que Cloud NGFW Enterprise déchiffre la requête HTTPS sortante à l'aide de l'inspection TLS basée sur CAS et inspecte la signature de test EICAR avec son service de prévention des intrusions (IPS).

8. Effectuer un nettoyage

Pour éviter que les ressources créées dans cet atelier de programmation soient facturées en permanence sur votre compte Google Cloud, vous pouvez supprimer uniquement les ressources de l'atelier de programmation ou supprimer votre projet Google Cloud.

  1. Si vous souhaitez conserver votre projet Google Cloud et ne supprimer que les ressources créées lors de cet atelier de programmation, exécutez la commande suivante en mode /goal dans la fenêtre de chat Antigravity :
    Remove all resources created in this session, including the gcurrenc app and its resources. Don't delete the project.
    
  2. Si vous avez créé un projet Google Cloud dédié pour cet atelier de programmation et que vous souhaitez le supprimer entièrement, exécutez la requête suivante en mode /goal dans la fenêtre de chat Antigravity :
    Clean up the demo environment by deleting the Google Cloud project. Run the following command in the terminal:
    gcloud projects delete "$(gcloud config get-value project 2>/dev/null)" --quiet
    

9. Félicitations

Félicitations ! Vous avez déployé et sécurisé l'application Web gCurrenC calculator sur Google Cloud à l'aide du plug-in Google Cloud Developer (serveur MCP DK) dans Google Antigravity.

Étape suivante

Consultez la documentation officielle de Google Cloud pour en savoir plus sur les services utilisés dans cet atelier de programmation :