1. Introduzione
In questo codelab, creerai ed eseguirai il deployment dell'applicazione web calcolatrice gCurrenC su Google Cloud, quindi la proteggerai da accessi indesiderati. Utilizzando Google Antigravity, il plug-in Google Cloud Developer e il server MCP Developer Knowledge (DK), progetti e implementi un'architettura di sicurezza che controlla chi può accedere all'applicazione e la protegge da utilizzi non autorizzati.
In questo lab, connetterai Google Antigravity al server MCP DK, che fornisce ad Antigravity la documentazione ufficiale di Google Cloud in tempo reale. Invece di fare affidamento su dati di addestramento statici o ponderazioni dei modelli obsolete, Antigravity recupera dinamicamente i pattern architetturali attuali, la sintassi più recente della CLI gcloud e i parametri di sicurezza, riducendo le allucinazioni e basando le risposte su conoscenze aggiornate.
Cosa creerai
- Workload di computing privato: due macchine virtuali (VM) Compute Engine che eseguono l'app web gCurrenC calculator all'interno di una rete Virtual Private Cloud (VPC) personalizzata senza indirizzi IP pubblici.
- Pipeline di ingresso protetta: un bilanciatore del carico delle applicazioni esterno globale con una subnet solo proxy dedicata che instrada il traffico internet tramite i Google Front End (GFE) alle tue VM private senza esporle alla rete internet pubblica.
- Pipeline di traffico in uscita protetta: un router Cloud e un gateway Cloud NAT accoppiati a Cloud Next Generation Firewall (Cloud NGFW) Enterprise e Certificate Authority Service (CAS) a livello di progetto per eseguire l'ispezione TLS on the fly e la scansione del servizio di prevenzione delle intrusioni (IPS) sul traffico API di cambio valuta HTTPS in uscita.
Obiettivi didattici
- Installa il plug-in
google-cloud-developerutilizzando l'interfaccia a riga di comando di Antigravity e configura il server DK MCP in Antigravity. - Esegui il deployment e testa un'applicazione web privata isolata su Compute Engine utilizzando l'inoltro TCP di Identity-Aware Proxy (IAP).
- Utilizza il prompting multi-turn basato su dati reali in Antigravity per progettare un'architettura di sicurezza per l'ingresso e l'uscita a livello di progetto.
- Genera, controlla autonomamente ed esegui uno script di deployment
bashper il bilanciamento del carico delle applicazioni esterno globale, Cloud NAT, CAS e Cloud NGFW Enterprise.
2. Prima di iniziare
Prerequisiti
Prima di iniziare questo codelab, assicurati di avere quanto segue:
- Un Account Google e il browser Google Chrome.
- Un nuovo progetto Google Cloud con la fatturazione abilitata. Prendi nota del tuo ID progetto (
PROJECT_ID), perché lo utilizzerai in questo codelab per abilitare le API, creare la chiave API ed eseguire il deployment delle risorse Google Cloud. - Autorizzazioni di Identity and Access Management (IAM) nel tuo progetto Google Cloud per creare chiavi API, risorse Compute Engine, reti VPC, pool CAS, tunnel IAP ed endpoint Cloud NGFW.
- Esegui l'autenticazione con l'interfaccia a riga di comando
gcloud, imposta il progetto cloud Google Cloud attivo e abilita le API richieste:- Nel terminale o in Cloud Shell, verifica di aver già eseguito l'autenticazione:
Se devi autenticare il tuo account, esegui questo comando:gcloud auth listgcloud auth login - Verifica che l'interfaccia a riga di comando
gcloudsia configurata per utilizzare il tuo progetto: Se il progetto non è impostato o se è attivo un progetto diverso, imposta l'ID progetto. Sostituiscigcloud config list projectPROJECT_IDcon l'ID progetto Google Cloud:export PROJECT_ID=PROJECT_ID gcloud config set project PROJECT_ID - Abilita le API richieste nel tuo progetto Google Cloud:
gcloud services enable \ compute.googleapis.com \ iap.googleapis.com \ networksecurity.googleapis.com \ privateca.googleapis.com \ developerknowledge.googleapis.com \ apikeys.googleapis.com
- Nel terminale o in Cloud Shell, verifica di aver già eseguito l'autenticazione:
- Installa Antigravity 2.0 sul tuo sistema locale dalla pagina di download di Google Antigravity.
Installa il plug-in Google Cloud Developer utilizzando l'interfaccia a riga di comando Antigravity
Per installare il plug-in Google Cloud Developer utilizzando Antigravity CLI, segui questi passaggi:
- Per installare Antigravity CLI sulla tua workstation locale, segui questi passaggi:
- Apri il terminale locale.
- Esegui lo script del programma di installazione:
curl -fsSL https://antigravity.google/cli/install.sh | bash - Chiudi e riapri la sessione del terminale in modo che il file binario dell'interfaccia a riga di comando di Antigravity
agysia disponibile nel tuo sistemaPATH.
- Nel terminale locale, esegui questo comando per installare il plug-in
google-cloud-developer: Viene visualizzato un output simile al seguente:agy plugin install https://github.com/google/skills/plugins/cloud/google-cloud-developer Per scoprire tutte le competenze e le funzionalità disponibili incluse nel plug-in, consulta la documentazione del plug-in Google Cloud Developer e il codelab Introduzione al plug-in Google Cloud Developer.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)
3. Configura Antigravity e il server MCP DK
In questa sezione, configurerai il server MCP DK in Antigravity utilizzando una chiave API Google Cloud con restrizioni.
- Apri Antigravity, digita
/goale premi Invio per attivare la modalità obiettivo, quindi incolla il seguente prompt per creare una chiave API limitata e configurare il server DK MCP. SostituisciPROJECT_IDcon l'ID progetto Google Cloud della sezione Prima di iniziare. Per saperne di più, consulta la sezione sul 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. - Per verificare che il server DK MCP sia attivo, inserisci il seguente prompt nella finestra della chat di Antigravity:
Antigravity elencaWhich MCP servers are available?developer-knowledgee i relativi strumenti disponibili (search_documents,answer_queryeget_documents):
4. Crea ed esegui il deployment dell'applicazione
In questa sezione eseguirai il deployment dell'applicazione gCurrenC calculator su due VM di Compute Engine private all'interno di una rete VPC personalizzata.
L'applicazione fornisce:
- Un convertitore di valuta in tempo reale che supporta
USD,EUR,GBP,JPY,CAD,INReAUDutilizzando la libreria standardhttp.serverintegrata di Python sulla porta8080con un endpoint di controllo di integrità/healthz. - Una console di verifica della sicurezza per eseguire la connettività API in uscita in tempo reale e i probe di prevenzione delle minacce crittografate.
- Una regola firewall in entrata che consente all'intervallo IAP di Google di raggiungere le porte
22e8080per i test amministrativi senza esporre indirizzi IP pubblici.
Esegui il deployment dell'applicazione
- Nella finestra della chat di Antigravity, inserisci
/goal, quindi esegui il seguente prompt: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 "==========================================================================" ```
Verifica la creazione dell'istanza VM
Dopo che Antigravity ha completato il deployment dell'applicazione sulle due VM Compute Engine private, verifica le istanze nella console Google Cloud:
- Nella console Google Cloud, vai a Istanze VM.
- Verifica che le due istanze VM siano in esecuzione con indirizzi IP interni e nessun indirizzo IP esterno:

5. testa l'applicazione
Poiché le VM private non hanno indirizzi IP esterni (--no-address) né un gateway Cloud NAT, non hanno una route verso internet e non possono raggiungere le API di cambio valuta esterne. Prima di configurare l'accesso in uscita sicuro, testa l'applicazione su un tunnel IAP locale per verificare che non sia presente l'accesso a internet.
- In modalità
/goal, esegui il seguente prompt nella finestra della chat di 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. - Dopo l'avvio del tunnel, apri
http://localhost:8080/nel browser web:
- Testa l'applicazione:
- Fai clic su Converti valuta. Il risultato della conversione mostra
Offline - Outbound internet blockedeOutbound connection unavailable. Questo risultato è previsto perché le VM private non possono connettersi a internet per recuperare i tassi di cambio più recenti. - Espandi Console di verifica della sicurezza e fai clic su Testa la connessione API in uscita. L'output mostra
verdict: BLOCKED_OR_FAILED() perhttps://api.frankfurter.dev/v1/latest. Questo risultato è previsto perché le VM private non possono connettersi a internet e recuperare i tassi di cambio dahttps://api.frankfurter.dev/v1/latest. - Fai clic su Simula minaccia criptata (EICAR). L'output mostra anche
verdict: BLOCKED_OR_FAILEDperhttps://secure.eicar.org/eicar.com.txt. Anche questo risultato è previsto, perché le VM private non hanno connessione a internet.
- Fai clic su Converti valuta. Il risultato della conversione mostra
Arresta il tunnel IAP locale
Prima di progettare ed eseguire il deployment dell'architettura di sicurezza, termina il tunnel IAP locale per liberare la porta 8080:
- In modalità
/goal, esegui il seguente prompt: Antigravity conferma che il tunnel IAP è terminato e che la porta localeFree 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).8080è libera.
6. Proteggi l'applicazione
Nelle sezioni precedenti, hai creato VM di Compute Engine private senza indirizzi IP pubblici e hai verificato due problemi principali di networking e sicurezza:
- Accesso in entrata (ingress): gli utenti di internet non possono raggiungere direttamente le istanze VM private e l'esposizione dell'applicazione web richiede il proxy del traffico tramite un bilanciatore del carico delle applicazioni esterno globale e una subnet dedicata solo proxy senza esporre le VM alla rete internet pubblica.
- Accesso in uscita (traffico in uscita): le VM private non hanno una route verso internet per eseguire query sulle API di cambio valuta HTTPS in tempo reale e l'abilitazione dell'accesso in uscita richiede l'ispezione del traffico criptato per rilevare malware ed esfiltrazione di dati senza interrompere l'attendibilità SSL/TLS.
In questa sezione, guiderai Antigravity attraverso un flusso di lavoro semplificato basato sulla documentazione ufficiale di Google Cloud (@retrieving-developer-knowledge) per progettare, eseguire l'autoverifica ed eseguire il deployment di un'architettura di sicurezza in entrata e in uscita a livello di progetto per la tua applicazione.
Progetta l'architettura di sicurezza unificata
- In modalità
/goal, esegui il seguente prompt per generare un diagramma dell'architettura end-to-end e una spiegazione che copra i flussi di traffico in entrata e in uscita: Antigravity esegue una query sul server MCP DK e restituisce un diagramma dell'architettura e una spiegazione che mostra come il bilanciamento del carico delle applicazioni esterno globale, la subnet solo proxy, Cloud NAT, CAS e Cloud NGFW Enterprise a livello di progetto si connettono tra loro.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.
Genera la struttura delle risorse architettoniche
- Inserisci il seguente prompt per strutturare il progetto in una struttura di risorse a livello di progetto categorizzata prima di generare lo script di deployment:
Antigravity produce una struttura di risorse strutturata mappata sull'infrastruttura VPC di base, sul bilanciamento del carico in entrata e sulla prevenzione delle minacce in uscita a livello di progetto.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.
Genera ed esegui l'autoverifica dello script di deployment
- In modalità
/goal, esegui il seguente prompt per generare uno script di deploymentbashcompleto e non interattivo ed eseguire automaticamente l'audit autonomo in base ai requisiti di conformità nello stesso turno: Antigravity genera lo scriptAct 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.bashcompleto, esegue l'autoverifica di ogni comando in base ai vincoli di conformità e restituisce il singolo blocco di script eseguibile racchiuso inset -euxo pipefail.
Esegui lo script di deployment della sicurezza
- In modalità
/goal, incolla lo scriptbashgenerato dal prompt precedente nella finestra della chat di Antigravity nel seguente formato per eseguire il deployment e generare l'URL dell'applicazione live (https://<LB_IP>):Run this script. <PASTED-SCRIPT>
7. Verifica l'applicazione protetta
Al termine dello script di deployment, Antigravity restituisce l'URL HTTPS esterno del bilanciatore del carico delle applicazioni esterno globale (https://<LB_IP>).
- Apri
https://<LB_IP>nel browser web e ignora l'avviso del certificato autofirmato del browser per caricare l'interfaccia del calcolatore gCurrenC:
- Testa l'applicazione per verificare sia la connettività in uscita sia la prevenzione delle minacce:
- Fai clic su Converti valuta. L'applicazione mostra immediatamente il tasso di cambio convertito in tempo reale. Ciò conferma che il bilanciamento del carico in entrata viene instradato senza problemi tramite i Google Front End (GFE) e la subnet solo proxy, mentre Cloud NAT recupera i tassi di cambio in tempo reale da
api.frankfurter.dev. - Espandi Console di verifica della sicurezza e fai clic su Testa la connessione API in uscita. L'applicazione visualizza
verdict: PERMITTED(HTTP 200). Ciò conferma che il routing di Cloud NAT funziona e che il sistema operativo della VM considera attendibile la CA radice di Certificate Authority Service privata per le sessioni HTTPS decriptate. - Fai clic su Simula minaccia criptata (EICAR). L'applicazione mostra
verdict: PERMITTED. Ciò conferma che Cloud NGFW Enterprise decripta la richiesta HTTPS in uscita utilizzando l'ispezione TLS supportata da CAS e ispeziona la firma di test EICAR con il servizio di prevenzione delle intrusioni (IPS).
- Fai clic su Converti valuta. L'applicazione mostra immediatamente il tasso di cambio convertito in tempo reale. Ciò conferma che il bilanciamento del carico in entrata viene instradato senza problemi tramite i Google Front End (GFE) e la subnet solo proxy, mentre Cloud NAT recupera i tassi di cambio in tempo reale da
8. Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse create in questo codelab, puoi eliminare solo le risorse del codelab o eliminare il progetto Google Cloud.
- Se vuoi mantenere il progetto Google Cloud e rimuovere solo le risorse create durante questo codelab, esegui il seguente prompt in modalità
/goalnella finestra di chat di Antigravity:Remove all resources created in this session, including the gcurrenc app and its resources. Don't delete the project. - Se hai creato un progetto Google Cloud dedicato per questo codelab e vuoi eliminarlo per intero, esegui il seguente prompt in modalità
/goalnella finestra di chat di 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. Complimenti
Complimenti! Hai eseguito il deployment e protetto l'applicazione web gCurrenC calculator su Google Cloud utilizzando il plug-in Google Cloud Developer (server MCP DK) in Google Antigravity.
Passaggi successivi
Consulta la documentazione ufficiale di Google Cloud per scoprire di più sui servizi utilizzati in questo codelab:
- Installa e utilizza il plug-in Google Cloud Developer in Antigravity
- Connettiti al server MCP per Developer Knowledge
- Libreria delle skill dell'agente
- Plug-in Developer Knowledge
- Panoramica del bilanciatore del carico delle applicazioni
- Documentazione di Certificate Authority Service
- Panoramica di Cloud Next Generation Firewall