1. Introducción
En este codelab, compilarás e implementarás la aplicación web de calculadora gCurrenC en Google Cloud y, luego, la protegerás contra el acceso no deseado. Con Google Antigravity, el complemento de Google Cloud Developer y el servidor de MCP de Developer Knowledge (DK), diseñarás e implementarás una arquitectura de seguridad que controle quién puede acceder a la aplicación y la proteja del uso no autorizado.
Durante este lab, conectarás Google Antigravity al servidor de MCP de DK, que fundamenta Antigravity en la documentación oficial y en tiempo real de Google Cloud. En lugar de depender de datos de entrenamiento estáticos o pesos de modelos desactualizados, Antigravity recupera de forma dinámica los patrones de arquitectura actuales, la sintaxis de la CLI de gcloud más reciente y los parámetros de seguridad, lo que reduce las alucinaciones y fundamenta las respuestas en conocimientos actualizados.
Qué compilarás
- Carga de trabajo de procesamiento privado: Dos máquinas virtuales (VMs) de Compute Engine que ejecutan la app web gCurrenC calculator dentro de una red de nube privada virtual (VPC) personalizada sin direcciones IP públicas.
- Canalización de entrada protegida: Un balanceador de cargas de aplicaciones externo global con una subred dedicada solo de proxy que enruta el tráfico de Internet a través de Google Front Ends (GFE) a tus VMs privadas sin exponerlas a la Internet pública.
- Canalización de salida protegida: Una puerta de enlace de Cloud Router y Cloud NAT vinculada con Cloud Next Generation Firewall (Cloud NGFW) Enterprise y Certificate Authority Service (CAS) a nivel del proyecto para realizar inspecciones de TLS sobre la marcha y análisis del servicio de prevención de intrusiones (IPS) en el tráfico de la API de cambio de divisas HTTPS saliente.
Qué aprenderás
- Instalar el complemento
google-cloud-developercon la CLI de Antigravity y configurar el servidor de MCP de DK en Antigravity - Implementar y probar una aplicación web privada aislada en Compute Engine con el reenvío de TCP de Identity-Aware Proxy (IAP)
- Usa instrucciones de varios turnos fundamentadas en Antigravity para diseñar una arquitectura de seguridad de entrada y salida a nivel de proyecto.
- Generar, auditar de forma automática y ejecutar una secuencia de comandos de implementación de
bashpara el balanceo de cargas de aplicaciones externo global, Cloud NAT, CAS y Cloud NGFW Enterprise
2. Antes de comenzar
Requisitos previos
Antes de comenzar este codelab, asegúrate de tener lo siguiente:
- Una Cuenta de Google y el navegador Google Chrome
- Un proyecto de Google Cloud nuevo con la facturación habilitada. Anota tu ID del proyecto (
PROJECT_ID), ya que lo usarás en este codelab para habilitar las APIs, crear tu clave de API y, luego, implementar los recursos de Google Cloud. - Permisos de Identity and Access Management (IAM) en tu proyecto de Google Cloud para crear claves de API, recursos de Compute Engine, redes de VPC, grupos de CAS, túneles de IAP y extremos de Cloud NGFW
- Autentícate con la CLI de
gcloud, configura tu proyecto activo de Google Cloud y habilita las APIs necesarias:- En tu terminal o en Cloud Shell, verifica que ya te hayas autenticado:
Si necesitas autenticar tu cuenta, ejecuta el siguiente comando:gcloud auth listgcloud auth login - Verifica que la CLI de
gcloudesté configurada para usar tu proyecto: Si tu proyecto no está configurado o si hay otro proyecto activo, establece el ID del proyecto. Reemplazagcloud config list projectPROJECT_IDpor el ID del proyecto de Google Cloud:export PROJECT_ID=PROJECT_ID gcloud config set project PROJECT_ID - Habilita las API necesarias en tu proyecto de Google Cloud:
gcloud services enable \ compute.googleapis.com \ iap.googleapis.com \ networksecurity.googleapis.com \ privateca.googleapis.com \ developerknowledge.googleapis.com \ apikeys.googleapis.com
- En tu terminal o en Cloud Shell, verifica que ya te hayas autenticado:
- Instala Antigravity 2.0 en tu sistema local desde la página de descarga de Google Antigravity.
Instala el complemento de Google Cloud Developer con la CLI de Antigravity
Para instalar el complemento de Google Cloud Developer con la CLI de Antigravity, haz lo siguiente:
- Para instalar la CLI de Antigravity en tu estación de trabajo local, haz lo siguiente:
- Abre la terminal local.
- Ejecuta la secuencia de comandos del instalador:
curl -fsSL https://antigravity.google/cli/install.sh | bash - Cierra y vuelve a abrir la sesión de la terminal para que el objeto binario
agyde la CLI de Antigravity esté disponible en tu sistemaPATH.
- En tu terminal local, ejecuta el siguiente comando para instalar el complemento
google-cloud-developer: Verás un resultado similar al siguiente:agy plugin install https://github.com/google/skills/plugins/cloud/google-cloud-developer Para obtener información sobre todas las habilidades y funciones disponibles que se incluyen en el complemento, consulta la documentación del complemento de Google Cloud Developer y el codelab Introducción al complemento de 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 y el servidor de MCP de DK
En esta sección, configurarás el servidor de MCP de DK en Antigravity con una clave de API de Google Cloud restringida.
- Abre Antigravity, escribe
/goaly presiona Intro para activar el modo de objetivo. Luego, pega la siguiente instrucción para crear una clave de API restringida y configurar el servidor de MCP de DK. ReemplazaPROJECT_IDpor el ID del proyecto de Google Cloud de la sección Antes de comenzar. Para obtener más información, consulta el complemento 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. - Para verificar que el servidor de MCP de DK esté activo, ingresa la siguiente instrucción en la ventana de chat de Antigravity:
Antigravity enumeraWhich MCP servers are available?developer-knowledgey sus herramientas disponibles (search_documents,answer_queryyget_documents):
4. Crea e implementa la aplicación
En esta sección, implementarás la aplicación gCurrenC calculator en dos VMs privadas de Compute Engine dentro de una red de VPC personalizada.
La aplicación proporciona lo siguiente:
- Un conversor de monedas en tiempo real que admite
USD,EUR,GBP,JPY,CAD,INRyAUDcon la biblioteca estándarhttp.serverintegrada de Python en el puerto8080con un extremo de verificación de estado/healthz. - Una consola de verificación de seguridad para ejecutar conectividad de API saliente en tiempo real y sondeos de prevención de amenazas encriptados.
- Una regla de firewall de entrada que permite que el rango de IAP de Google llegue a los puertos
22y8080para realizar pruebas administrativas sin exponer direcciones IP públicas.
Implemente la aplicación
- En la ventana de chat de Antigravity, ingresa
/goaly, luego, ejecuta la siguiente instrucción: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 creación de la instancia de VM
Después de que Antigravity termine de implementar la aplicación en las dos VMs privadas de Compute Engine, verifica las instancias en la consola de Google Cloud:
- En la consola de Google Cloud, ve a Instancias de VM.
- Verifica que las dos instancias de VM se estén ejecutando con direcciones IP internas y sin direcciones IP externas:

5. Prueba la aplicación
Como las VMs privadas no tienen direcciones IP externas (--no-address) ni una puerta de enlace de Cloud NAT, no tienen una ruta a Internet y no pueden acceder a las APIs externas de cambio de divisas. Antes de configurar el acceso seguro de salida, prueba la aplicación a través de un túnel de IAP local para verificar que no haya acceso a Internet.
- En el modo
/goal, ejecuta la siguiente instrucción en la ventana de chat de 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. - Después de que se inicie el túnel, abre
http://localhost:8080/en tu navegador web:
- Prueba la aplicación:
- Haz clic en Convertir moneda. El resultado de la conversión muestra
Offline - Outbound internet blockedyOutbound connection unavailable. Este resultado es el esperado, ya que las VMs privadas no pueden conectarse a Internet para recuperar los tipos de cambio más recientes. - Expande Consola de verificación de seguridad y haz clic en Probar conexión de API saliente. En el resultado, se muestra
verdict: BLOCKED_OR_FAILED() parahttps://api.frankfurter.dev/v1/latest. Este resultado es el esperado, ya que las VMs privadas no pueden conectarse a Internet ni recuperar los tipos de cambio dehttps://api.frankfurter.dev/v1/latest. - Haz clic en Simular amenaza encriptada (EICAR). El resultado también muestra
verdict: BLOCKED_OR_FAILEDparahttps://secure.eicar.org/eicar.com.txt. Este resultado también es el esperado, ya que las VMs privadas no tienen conectividad a Internet.
- Haz clic en Convertir moneda. El resultado de la conversión muestra
Detén el túnel de IAP local
Antes de diseñar e implementar la arquitectura de seguridad, finaliza el túnel de IAP local para liberar el puerto 8080:
- En el modo
/goal, ejecuta la siguiente instrucción: Antigravity confirma que el túnel de IAP se cerró y que el puerto localFree 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).8080está libre.
6. Protege la aplicación
En las secciones anteriores, creaste VMs de Compute Engine privadas sin direcciones IP públicas y verificaste dos desafíos principales de redes y seguridad:
- Acceso entrante (ingreso): Los usuarios de Internet no pueden acceder directamente a las instancias de VM privadas, y exponer la aplicación web requiere dirigir el tráfico a través de un balanceador de cargas de aplicaciones externo global y una subred dedicada solo de proxy sin exponer las VMs al Internet público.
- Acceso saliente (salida): Las VMs privadas no tienen ruta a Internet para consultar las APIs de cambio de divisas HTTPS en vivo, y habilitar el acceso saliente requiere inspeccionar el tráfico encriptado en busca de malware y robo de datos sin romper la confianza de SSL/TLS.
En esta sección, guiarás a Antigravity a través de un flujo de trabajo optimizado basado en la documentación oficial de Google Cloud (@retrieving-developer-knowledge) para diseñar, auditar de forma autónoma e implementar una arquitectura de seguridad de entrada y salida a nivel del proyecto para tu aplicación.
Diseña la arquitectura de seguridad unificada
- En el modo
/goal, ejecuta la siguiente instrucción para generar un diagrama de arquitectura de extremo a extremo y una explicación que abarque los flujos de tráfico entrante y saliente: Antigravity consulta el servidor de MCP de DK y devuelve un diagrama de arquitectura y una explicación que muestran cómo se conectan el balanceo de cargas de aplicaciones externo global, la subred de solo proxy, Cloud NAT, CAS y Cloud NGFW Enterprise a nivel del proyecto.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 el esquema de recursos de arquitectura
- Ingresa la siguiente instrucción para estructurar el diseño en un esquema de recursos categorizados a nivel del proyecto antes de generar la secuencia de comandos de implementación:
Antigravity produce un esquema de recursos estructurado que se asigna a la infraestructura de VPC principal, el balanceo de cargas entrante y la prevención de amenazas salientes a nivel del proyecto.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 y audita automáticamente la secuencia de comandos de implementación
- En el modo
/goal, ejecuta la siguiente instrucción para generar una secuencia de comandos de implementación debashcompleta y no interactiva, y auditarla automáticamente en función de los requisitos de cumplimiento en el mismo turno: Antigravity genera la secuencia de comandosAct 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.bashcompleta, audita automáticamente cada comando en función de las restricciones de cumplimiento y genera el bloque de secuencia de comandos ejecutable único unido enset -euxo pipefail.
Ejecuta la secuencia de comandos de implementación de seguridad
- En el modo
/goal, pega la secuencia de comandosbashgenerada a partir de la instrucción anterior en la ventana de chat de Antigravity con el siguiente formato para ejecutar la implementación y generar la URL de la aplicación en vivo (https://<LB_IP>):Run this script. <PASTED-SCRIPT>
7. Verifica la aplicación protegida
Cuando finaliza la secuencia de comandos de implementación, Antigravity genera la URL HTTPS externa del balanceador de cargas de aplicaciones externo global (https://<LB_IP>).
- Abre
https://<LB_IP>en tu navegador web y omite la advertencia del certificado autofirmado del navegador para cargar la interfaz de la calculadora de gCurrenC:
- Prueba la aplicación para verificar la conectividad saliente y la prevención de amenazas:
- Haz clic en Convertir moneda. La aplicación muestra de inmediato el tipo de cambio convertido en tiempo real. Esto confirma que el balanceo de cargas de entrada se enruta sin problemas a través de Google Front Ends (GFE) y la subred de solo proxy, mientras que Cloud NAT recupera los tipos de cambio en vivo de
api.frankfurter.dev. - Expande Consola de verificación de seguridad y haz clic en Probar conexión de API saliente. La aplicación muestra
verdict: PERMITTED(HTTP 200). Esto confirma que el enrutamiento de Cloud NAT funciona y que el sistema operativo de la VM confía en la CA raíz de CAS privada para las sesiones HTTPS desencriptadas. - Haz clic en Simular amenaza encriptada (EICAR). La aplicación muestra
verdict: PERMITTED. Esto confirma que Cloud NGFW Enterprise desencripta la solicitud HTTPS saliente con la inspección de TLS respaldada por CAS y que inspecciona la firma de prueba de EICAR con su servicio de prevención de intrusiones (IPS).
- Haz clic en Convertir moneda. La aplicación muestra de inmediato el tipo de cambio convertido en tiempo real. Esto confirma que el balanceo de cargas de entrada se enruta sin problemas a través de Google Front Ends (GFE) y la subred de solo proxy, mientras que Cloud NAT recupera los tipos de cambio en vivo de
8. Limpia
Para evitar que se apliquen cargos continuos a tu cuenta de Google Cloud por los recursos que creaste en este codelab, puedes borrar solo los recursos del codelab o borrar tu proyecto de Google Cloud.
- Si quieres conservar tu proyecto de Google Cloud y quitar solo los recursos creados durante este codelab, ejecuta la siguiente instrucción en el modo
/goalen la ventana de chat de Antigravity:Remove all resources created in this session, including the gcurrenc app and its resources. Don't delete the project. - Si creaste un proyecto de Google Cloud dedicado para este codelab y quieres borrarlo por completo, ejecuta la siguiente instrucción en el modo
/goalen la ventana de chat de 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. Felicitaciones
¡Felicitaciones! Implementaste y protegiste la aplicación web de la calculadora de gCurrenC en Google Cloud con el complemento para desarrolladores de Google Cloud (servidor de MCP de DK) en Google Antigravity.
¿Qué sigue?
Explora la documentación oficial de Google Cloud para obtener más información sobre los servicios que se usan en este codelab:
- Instala y usa el complemento Google Cloud Developer en Antigravity
- Conéctate al servidor de MCP de Developer Knowledge
- Biblioteca de habilidades de agentes
- Complemento de Developer Knowledge
- Descripción general del balanceador de cargas de aplicaciones
- Documentación de Certificate Authority Service
- Descripción general de Cloud Next Generation Firewall