Guía de Despliegue Empresarial en GCP - Energent.ai

Energent.ai ofrece agentes virtuales de escritorio impulsados por IA que automatizan flujos de trabajo complejos de múltiples aplicaciones para usuarios empresariales. Esta guía proporciona especificaciones completas de despliegue en Google Cloud Platform utilizando una arquitectura moderna nativa de la nube con GKE, diseño multi-inquilino y controles de seguridad de nivel empresarial.

• Clasificación del Documento: Público
• Versión: 3.0
• Última Actualización: 2025-05-28
• Arquitectura: GCP GKE + Híbrido sin servidor
• Cumplimiento: SOC 2, Mejores Prácticas de Seguridad de Google Cloud

Tabla de Contenidos

1. Descripción General de la Arquitectura
2. Requisitos de Infraestructura GCP
3. Especificaciones del Clúster GKE
4. Arquitectura de Capa de Datos
5. Componentes sin Servidor
6. Seguridad y Cumplimiento
7. Arquitectura de Red
8. Pipeline CI/CD
9. Monitoreo y Observabilidad
10. Proceso de Despliegue
11. Operaciones y Mantenimiento
12. Soporte y Escalamiento

1. Descripción General de la Arquitectura

1.1 Arquitectura Multi-Inquilino Nativa de la Nube

Energent.ai se despliega en Google Cloud Platform utilizando una arquitectura moderna y escalable que combina orquestación con Kubernetes y componentes sin servidor para un rendimiento óptimo y eficiencia de costos.

┌──────────────────────────────────────────────────────────────────┐
│                        ENTORNO EN LA NUBE GCP                    │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐   │
│  │   CLÚSTER GKE   │  │   SIN SERVIDOR   │  │   CAPA DE DATOS  │   │
│  │                 │  │                 │  │                 │   │
│  │ • Multi-inquilino │  │ • Funciones Auth│  │ • Firestore     │   │
│  │ • n2-standard-4 │  │ • Funciones Bill│  │ • Almacenamiento │   │
│  │ • Auto-escalado │  │ • API Gateway   │  │ • Filestore      │   │
│  │ • Flux GitOps   │  │ • Pub/Sub       │  │ • Gestor de Secretos │   │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘   │
│           │                     │                    │           │
│           └─────────────────────┼────────────────────┘           │
│                                 │                                │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                    LÍMITE DE SEGURIDAD VPC                  │ │
│  │  • Subredes Privadas • Cloud NAT    • Reglas de Firewall    │ │
│  │  • Túneles IAP       • Endpoints VPC • Balanceador de Carga │ │
│  └─────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

1.2 Modelos de Despliegue

2. Requisitos de Infraestructura GCP

2.1 Especificaciones Mínimas de Infraestructura

2.2 Dependencias de Servicios GCP

3. Especificaciones del Clúster GKE

3.1 Configuración del Clúster

# Configuración de Clúster GKE con Terraform
resource "google_container_cluster" "energent_cluster" {
name     = "energent-production"
location = var.gcp_region

remove_default_node_pool = true
initial_node_count       = 1

network    = google_compute_network.vpc.name
subnetwork = google_compute_subnetwork.subnet.name

networking_mode = "VPC_NATIVE"
ip_allocation_policy {
cluster_secondary_range_name  = "k8s-pod-range"
services_secondary_range_name = "k8s-service-range"
}

private_cluster_config {
enable_private_nodes    = true
enable_private_endpoint = false
master_ipv4_cidr_block  = "172.16.0.0/28"
}

master_auth {
client_certificate_config {
issue_client_certificate = false
}
}

workload_identity_config {
workload_pool = "${var.project_id}.svc.id.goog"
}

addons_config {
gcp_filestore_csi_driver_config {
enabled = true
}

network_policy_config {
disabled = false
}
}

cluster_telemetry {
type = "ENABLED"
}

logging_config {
enable_components = [
"SYSTEM_COMPONENTS",
"WORKLOADS",
"API_SERVER"
]
}

monitoring_config {
enable_components = [
"SYSTEM_COMPONENTS",
"WORKLOADS"
]
}
}

3.2 Configuración del Grupo de Nodos

# Grupo de Nodos Primario
resource "google_container_node_pool" "energent_nodes" {
name       = "energent-node-pool"
location   = var.gcp_region
cluster    = google_container_cluster.energent_cluster.name
node_count = 3

autoscaling {
min_node_count = 2
max_node_count = 20
}

node_config {
preemptible  = false
machine_type = "n2-standard-4"
disk_size_gb = 100
disk_type    = "pd-ssd"

service_account = google_service_account.gke_service_account.email
oauth_scopes = [
"https://www.googleapis.com/auth/logging.write",
"https://www.googleapis.com/auth/monitoring",
"https://www.googleapis.com/auth/cloud-platform"
]

workload_metadata_config {
mode = "GKE_METADATA"
}

labels = {
env = "production"
app = "energent-ai"
}

taint {
key    = "workload"
value  = "energent-ai"
effect = "NO_SCHEDULE"
}
}

management {
auto_repair  = true
auto_upgrade = true
}
}

3.3 Asignación de Recursos Multi-Inquilino

4. Arquitectura de Capa de Datos

4.1 Arquitectura de Almacenamiento

4.1.1 Configuración de Almacenamiento en la Nube

# Cloud Storage Bucket para Almacenamiento de Objetos
resource "google_storage_bucket" "energent_storage" {
  name     = "energent-${var.environment}-storage-${random_id.bucket_suffix.hex}"
  location = var.gcp_region

  uniform_bucket_level_access = true

  versioning {
    enabled = true
  }

  encryption {
    default_kms_key_name = google_kms_crypto_key.storage_key.id
  }

  lifecycle_rule {
    condition {
      age = 90
    }
    action {
      type          = "SetStorageClass"
      storage_class = "NEARLINE"
    }
  }

  retention_policy {
    retention_period = 2592000  # 30 días
  }

  labels = {
    environment = var.environment
    purpose     = "energent-object-storage"
  }
}

resource "google_storage_bucket_iam_member" "storage_admin" {
  bucket = google_storage_bucket.energent_storage.name
  role   = "roles/storage.admin"
  member = "serviceAccount:${google_service_account.gke_service_account.email}"
}

4.1.2 Configuración de Firestore

# Base de Datos Firestore para Metadatos y Configuración
resource "google_firestore_database" "energent_metadata" {
  project     = var.project_id
  name        = "energent-metadata-${var.environment}"
  location_id = var.gcp_region
  type        = "FIRESTORE_NATIVE"

  concurrency_mode = "OPTIMISTIC"
  app_engine_integration_mode = "DISABLED"

  point_in_time_recovery_enablement = "POINT_IN_TIME_RECOVERY_ENABLED"
  delete_protection_state = "DELETE_PROTECTION_ENABLED"
}

# Reglas de Seguridad de Firestore
resource "google_firestore_database" "security_rules" {
  depends_on = [google_firestore_database.energent_metadata]

  # El contenido de las reglas de seguridad se definiría aquí
  # Implementación de aislamiento de inquilinos y controles de acceso
}

4.1.3 Almacenamiento Compartido Filestore

# Filestore para Sistema de Archivos Compartido
resource "google_filestore_instance" "energent_shared" {
name     = "energent-shared-${var.environment}"
location = var.gcp_zone
tier     = "BASIC_HDD"

file_shares {
capacity_gb = 1024
name        = "energent-share"
}

networks {
network = google_compute_network.vpc.name
modes   = ["MODE_IPV4"]
}

labels = {
environment = var.environment
purpose     = "shared-storage"
}
}

5. Componentes Serverless

5.1 Funciones en la Nube

5.1.1 Servicio de Autenticación

# Función en la Nube para Autenticación
resource "google_cloudfunctions2_function" "auth_service" {
name     = "energent-auth-${var.environment}"
location = var.gcp_region

build_config {
runtime     = "python311"
entry_point = "auth_handler"
source {
storage_source {
bucket = google_storage_bucket.functions_source.name
object = google_storage_bucket_object.auth_source.name
}
}
}

service_config {
max_instance_count = 100
min_instance_count = 1
available_memory   = "512Mi"
timeout_seconds    = 60

environment_variables = {
FIRESTORE_PROJECT = var.project_id
SECRET_MANAGER_PROJECT = var.project_id
ENVIRONMENT = var.environment
}

vpc_connector = google_vpc_access_connector.connector.id
vpc_connector_egress_settings = "ALL_TRAFFIC"

service_account_email = google_service_account.functions_service_account.email
}

event_trigger {
trigger_region = var.gcp_region
event_type     = "google.cloud.pubsub.topic.v1.messagePublished"
pubsub_topic   = google_pubsub_topic.auth_events.id
}

labels = {
environment = var.environment
service     = "authentication"
}
}

5.1.2 Servicio de Facturación

# Función en la Nube para Facturación
resource "google_cloudfunctions2_function" "billing_service" {
name     = "energent-billing-${var.environment}"
location = var.gcp_region

build_config {
runtime     = "python311"
entry_point = "billing_handler"
source {
storage_source {
bucket = google_storage_bucket.functions_source.name
object = google_storage_bucket_object.billing_source.name
}
}
}

service_config {
max_instance_count = 50
min_instance_count = 0
available_memory   = "1Gi"
timeout_seconds    = 300

environment_variables = {
FIRESTORE_PROJECT = var.project_id
STORAGE_BUCKET = google_storage_bucket.energent_storage.name
}

service_account_email = google_service_account.functions_service_account.email
}
}

5.2 Configuración de API Gateway

# API Gateway para Funciones Serverless
resource "google_api_gateway_api" "energent_api" {
provider = google-beta
api_id   = "energent-api-${var.environment}"
project  = var.project_id

labels = {
environment = var.environment
service     = "api-gateway"
}
}

resource "google_api_gateway_api_config" "energent_api_config" {
provider      = google-beta
api           = google_api_gateway_api.energent_api.api_id
api_config_id = "energent-config-${var.environment}"
project       = var.project_id

openapi_documents {
document {
path     = "spec.yaml"
contents = base64encode(templatefile("${path.module}/api-spec.yaml", {
project_id = var.project_id
region     = var.gcp_region
}))
}
}

lifecycle {
create_before_destroy = true
}
}

resource "google_api_gateway_gateway" "energent_gateway" {
provider   = google-beta
gateway_id = "energent-gateway-${var.environment}"
api_config = google_api_gateway_api_config.energent_api_config.id
location   = var.gcp_region
project    = var.project_id

labels = {
environment = var.environment
service     = "api-gateway"
}
}

6. Seguridad y Cumplimiento

6.1 Seguridad de Red

6.1.1 Configuración de VPC

# Red VPC y Reglas de Firewall
resource "google_compute_network" "vpc" {
name                    = "energent-vpc-${var.environment}"
auto_create_subnetworks = false
mtu                     = 1460
}

resource "google_compute_subnetwork" "subnet" {
name          = "energent-subnet-${var.environment}"
ip_cidr_range = "10.0.0.0/16"
region        = var.gcp_region
network       = google_compute_network.vpc.id

secondary_ip_range {
range_name    = "k8s-pod-range"
ip_cidr_range = "10.1.0.0/16"
}

secondary_ip_range {
range_name    = "k8s-service-range"
ip_cidr_range = "10.2.0.0/16"
}

private_ip_google_access = true
}

resource "google_compute_firewall" "allow_internal" {
name    = "energent-allow-internal"
network = google_compute_network.vpc.name

allow {
protocol = "tcp"
ports    = ["0-65535"]
}

allow {
protocol = "udp"
ports    = ["0-65535"]
}

allow {
protocol = "icmp"
}

source_ranges = ["10.0.0.0/8"]
}

resource "google_compute_firewall" "allow_https" {
name    = "energent-allow-https"
network = google_compute_network.vpc.name

allow {
protocol = "tcp"
ports    = ["443"]
}

source_ranges = ["0.0.0.0/0"]
target_tags   = ["https-server"]
}

6.1.2 Reglas de Firewall

6.2 Estándares de Cifrado

6.3 IAM y Cuentas de Servicio

6.3.1 Cuentas de Servicio de GKE

# Cuenta de Servicio de GKE
resource "google_service_account" "gke_service_account" {
  account_id   = "energent-gke-${var.environment}"
  display_name = "Cuenta de Servicio de Energent GKE"
  project      = var.project_id
}

resource "google_project_iam_member" "gke_permissions" {
  for_each = toset([
    "roles/logging.logWriter",
    "roles/monitoring.metricWriter",
    "roles/monitoring.viewer",
    "roles/storage.objectViewer"
  ])

  project = var.project_id
  role    = each.value
  member  = "serviceAccount:${google_service_account.gke_service_account.email}"
}

# Vinculación de Identidad de Carga de Trabajo
resource "google_service_account_iam_member" "workload_identity" {
  service_account_id = google_service_account.gke_service_account.name
  role               = "roles/iam.workloadIdentityUser"
  member             = "serviceAccount:${var.project_id}.svc.id.goog[energent-ai/energent-platform]"
}

7. Arquitectura de Red

7.1 Diseño de VPC

┌─────────────────────────────────────────────────────────────────┐
│                         VPC (10.0.0.0/16)                       │
│                                                                 │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │  Subred Pública │    │  Subred Pública │    │ Subred Pub  │  │
│  │   (10.0.1.0/24) │    │   (10.0.2.0/24) │    │(10.0.3.0/24)│  │
│  │                 │    │                 │    │             │  │
│  │   Cloud NAT     │    │   Cloud NAT     │    │ Cloud NAT   │  │
│  │   Balanceador   │    │   Balanceador   │    │Balanceador  │  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
│           │                       │                     │       │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │ Subred Privada  │    │ Subred Privada  │    │Subred Priv  │  │
│  │  (10.1.0.0/16)  │    │  (10.1.0.0/16)  │    │(10.1.0.0/16)│  │
│  │                 │    │                 │    │             │  │
│  │  Nodos GKE      │    │  Nodos GKE      │    │ Nodos GKE   │  │
│  │  Funciones VPC  │    │  Funciones VPC  │    │ Funciones   │  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
│           │                       │                     │       │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │ Subred Servicios│    │ Subred Servicios│    │Subred Serv  │  │
│  │  (10.2.0.0/16)  │    │  (10.2.0.0/16)  │    │(10.2.0.0/16)│  │
│  │                 │    │                 │    │             │  │
│  │   Firestore     │    │   Firestore     │    │ Firestore   │  │
│  │   Cloud Storage │    │   Cloud Storage │    │Cloud Storage│  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
└─────────────────────────────────────────────────────────────────┘

7.2 Conexiones de Servicio Privadas

8. Pipeline CI/CD

8.1 Infraestructura como Código (Terraform)

8.1.1 Estructura de Terraform

terraform/
├── environments/
│   ├── dev/
│   ├── staging/
│   └── production/
├── modules/
│   ├── gke/
│   ├── networking/
│   ├── security/
│   └── storage/
├── shared/
│   └── backend.tf
└── global/
    └── iam.tf

8.1.2 Pipeline de Terraform (Cloud Build)

# cloudbuild.yaml
steps:
  # Terraform Init
  - name: 'hashicorp/terraform:1.6.0'
    entrypoint: 'sh'
    args:
      - '-c'
      - |
        cd terraform/environments/${_ENVIRONMENT}
        terraform init -backend-config="bucket=${_TF_STATE_BUCKET}"

  # Terraform Plan
  - name: 'hashicorp/terraform:1.6.0'
    entrypoint: 'sh'
    args:
      - '-c'
      - |
        cd terraform/environments/${_ENVIRONMENT}
        terraform plan -var-file="${_ENVIRONMENT}.tfvars" -out=tfplan

  # Terraform Apply (solo en la rama principal)
  - name: 'hashicorp/terraform:1.6.0'
    entrypoint: 'sh'
    args:
      - '-c'
      - |
        if [ "${BRANCH_NAME}" = "main" ]; then
          cd terraform/environments/${_ENVIRONMENT}
          terraform apply -auto-approve tfplan
        else
          echo "Skipping apply for non-main branch"
        fi

substitutions:
  _ENVIRONMENT: 'production'
  _TF_STATE_BUCKET: 'energent-terraform-state'

options:
  logging: CLOUD_LOGGING_ONLY
  machineType: 'E2_HIGHCPU_8'

timeout: 1200s

8.2 Kubernetes GitOps (Flux)

8.2.1 Configuración de Flux

# flux-system/gotk-sync.yaml
apiVersion: source.toolkit.fluxcd.io/v1beta2
kind: GitRepository
metadata:
  name: energent-k8s
  namespace: flux-system
spec:
  interval: 1m
  ref:
    branch: main
  url: https://github.com/energent-ai/k8s-manifests
---
apiVersion: kustomize.toolkit.fluxcd.io/v1beta2
kind: Kustomization
metadata:
  name: energent-apps
  namespace: flux-system
spec:
  interval: 10m
  path: './apps'
  prune: true
  sourceRef:
    kind: GitRepository
    name: energent-k8s
  validation: client

8.3 Despliegue Serverless (Cloud Build)

8.3.1 Configuración de Despliegue de Funciones

# cloudbuild-functions.yaml
steps:
  # Deploy Auth Function
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:latest'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        cd functions/auth
        gcloud functions deploy energent-auth-${_ENVIRONMENT} \
          --runtime python311 \
          --trigger-http \
          --entry-point auth_handler \
          --memory 512MB \
          --timeout 60s \
          --region ${_REGION} \
          --vpc-connector ${_VPC_CONNECTOR} \
          --set-env-vars ENVIRONMENT=${_ENVIRONMENT}

  # Deploy Billing Function
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:latest'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        cd functions/billing
        gcloud functions deploy energent-billing-${_ENVIRONMENT} \
          --runtime python311 \
          --trigger-topic billing-events \
          --entry-point billing_handler \
          --memory 1024MB \
          --timeout 300s \
          --region ${_REGION}

substitutions:
  _ENVIRONMENT: 'production'
  _REGION: 'us-central1'
  _VPC_CONNECTOR: 'energent-vpc-connector'

options:
  logging: CLOUD_LOGGING_ONLY

9. Monitoreo y Observabilidad

9.1 Configuración de Cloud Monitoring

9.1.1 Monitoreo de GKE

# Cloud Monitoring for GKE
resource "google_monitoring_dashboard" "gke_dashboard" {
  dashboard_json = jsonencode({
    displayName = "Energent GKE Dashboard"
    mosaicLayout = {
      tiles = [
        {
          width = 6
          height = 4
          widget = {
            title = "GKE Cluster CPU Utilization"
            xyChart = {
              dataSets = [{
                timeSeriesQuery = {
                  timeSeriesFilter = {
                    filter = "resource.type=\"k8s_cluster\" AND metric.type=\"kubernetes.io/container/cpu/core_usage_time\""
                  }
                }
              }]
            }
          }
        }
      ]
    }
  })
}

# Log-based Metrics
resource "google_logging_metric" "error_rate" {
  name   = "energent_error_rate"
  filter = "resource.type=\"k8s_container\" AND resource.labels.namespace_name=\"energent-ai\" AND severity=\"ERROR\""

  metric_descriptor {
    metric_kind = "GAUGE"
    value_type  = "INT64"
    display_name = "Energent Error Rate"
  }
}

9.2 Métricas de Aplicación

9.3 Registro de Auditoría

# Cloud Audit Logs Configuration
resource "google_project_iam_audit_config" "project_audit" {
  project = var.project_id
  service = "allServices"

  audit_log_config {
    log_type = "ADMIN_READ"
  }

  audit_log_config {
    log_type = "DATA_READ"
  }

  audit_log_config {
    log_type = "DATA_WRITE"
  }
}

# Log Sink for Security Events
resource "google_logging_project_sink" "security_sink" {
  name        = "energent-security-sink"
  destination = "storage.googleapis.com/${google_storage_bucket.audit_logs.name}"

  filter = "protoPayload.serviceName=\"container.googleapis.com\" OR protoPayload.serviceName=\"iam.googleapis.com\""

  unique_writer_identity = true
}

10. Proceso de Despliegue

10.1 Cronograma de Despliegue

10.2 Comandos de Despliegue

10.2.1 Despliegue de Infraestructura

# Despliegue de Infraestructura con Terraform
cd terraform/environments/production
terraform init -backend-config="bucket=energent-terraform-state"
terraform plan -var-file="production.tfvars"
terraform apply -auto-approve

# Verificar clúster GKE
gcloud container clusters get-credentials energent-production --region us-central1
kubectl get nodes

10.2.2 Despliegue de Aplicación

# Instalar Flux GitOps
flux bootstrap github \
  --owner=energent-ai \
  --repository=k8s-manifests \
  --branch=main \
  --path=./clusters/production

# Desplegar componentes serverless
gcloud builds submit --config cloudbuild-functions.yaml \
  --substitutions _ENVIRONMENT=production,_REGION=us-central1

# Verificar despliegue
kubectl get pods -n energent-ai
kubectl get ingress -n energent-ai

10.3 Validación del Despliegue

# Puntos de verificación de salud
curl -k https://api.energent.example.com/health
curl -k https://api.energent.example.com/metrics

# Validación de Kubernetes
kubectl top nodes
kubectl get hpa -n energent-ai
kubectl logs -n energent-ai -l app=energent-platform

11. Operaciones y Mantenimiento

11.1 Respaldo y Recuperación ante Desastres

11.1.1 Estrategia de Respaldo

11.1.2 Procedimientos de Recuperación ante Desastres

# Respaldo del clúster GKE usando Velero
velero backup create energent-cluster-backup \
  --include-namespaces energent-ai \
  --storage-location gcp

# Recuperación puntual de Firestore
gcloud firestore databases restore \
  --source-database=energent-metadata-production \
  --destination-database=energent-metadata-restored \
  --backup-time=2025-05-28T10:00:00Z

11.2 Escalabilidad y Rendimiento

11.2.1 Configuración de Autoescalado

# Autoscaler Horizontal de Pods
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: energent-platform-hpa
  namespace: energent-ai
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: energent-platform
  minReplicas: 3
  maxReplicas: 50
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80

11.3 Actualización y Mantenimiento

11.3.1 Actualizaciones Graduales

# Actualización del clúster GKE
gcloud container clusters upgrade energent-production \
  --master \
  --cluster-version 1.30 \
  --region us-central1

# Actualización gradual de la aplicación mediante Flux
git commit -am "Update energent-platform to v2.1.0"
git push origin main
# Flux detecta y aplica automáticamente los cambios

12. Soporte y Escalamiento

12.1 Niveles de Soporte

12.2 Cobertura de Soporte 24/7

Soporte Empresarial:

• 📧 Correo: support@energent.ai

Escalación de Emergencia:

• 📧 Correo de Emergencia: emergency@energent.ai

12.3 Acuerdos de Nivel de Servicio

Apéndices

Apéndice A: Costos de Servicios GCP

Apéndice B: Lista de Verificación de Cumplimiento de Seguridad

• VPC con subredes privadas implementadas
• Reglas de firewall con acceso de privilegio mínimo
• Cifrado con Cloud KMS para todos los datos en reposo
• TLS 1.3 para todos los datos en tránsito
• IAM con permisos mínimos
• Registros de Auditoría en la nube habilitados
• Centro de Comando de Seguridad habilitado
• Restricciones de políticas organizacionales habilitadas
• Secret Manager para todas las credenciales
• Escaneos y evaluaciones de seguridad regulares

Apéndice C: Guía de Resolución de Problemas

Problemas Comunes:

1. Nodos GKE que no se unen al clúster

   • Verificar permisos de cuenta de servicio
   • Revisar enrutamiento de subred y Cloud NAT

2. Pods de la Aplicación en CrashLoop

   • Verificar límites y solicitudes de recursos
   • Revisar reclamos de volúmenes persistentes

3. Problemas de Conectividad de Red

   • Verificar configuración del conector VPC
   • Revisar reglas de firewall

• Clasificación del Documento: Público
• Versión: 3.0
• Última Actualización: 2025-05-28
• Próxima Revisión: 2025-08-28
• Contacto: support@energent.ai