Guia de Implantação GCP Empresarial - Energent.ai

A Energent.ai oferece agentes virtuais de desktop com inteligência artificial que automatizam fluxos de trabalho complexos de múltiplas aplicações para usuários empresariais. Este guia fornece especificações abrangentes de implantação na Google Cloud Platform usando arquitetura moderna nativa da nuvem com GKE, design multi-inquilino e controles de segurança de nível empresarial.

• Classificação do Documento: Público
• Versão: 3.0
• Última Atualização: 2025-05-28
• Arquitetura: GCP GKE + Híbrido Serverless
• Conformidade: SOC 2, Melhores Práticas de Segurança do Google Cloud

Índice

1. Visão Geral da Arquitetura
2. Requisitos de Infraestrutura GCP
3. Especificações do Cluster GKE
4. Arquitetura da Camada de Dados
5. Componentes Serverless
6. Segurança e Conformidade
7. Arquitetura de Rede
8. Pipeline CI/CD
9. Monitoramento e Observabilidade
10. Processo de Implantação
11. Operações e Manutenção
12. Suporte e Escalonamento

1. Visão Geral da Arquitetura

1.1 Arquitetura Multi-Inquilino Nativa da Nuvem

A Energent.ai é implantada na Google Cloud Platform usando uma arquitetura moderna e escalável que combina orquestração Kubernetes com componentes serverless para desempenho e eficiência de custos ideais.

┌──────────────────────────────────────────────────────────────────┐
│                        AMBIENTE NUVEM GCP                        │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐   │
│  │   CLUSTER GKE   │  │   SERVERLESS    │  │   CAMADA DE DADOS│   │
│  │                 │  │                 │  │                 │   │
│  │ • Multi-inquilino│ │ • Funções Auth  │  │ • Firestore     │   │
│  │ • n2-standard-4 │  │ • Funções Bill  │  │ • Cloud Storage │   │
│  │ • Auto-escalon. │  │ • API Gateway   │  │ • Filestore     │   │
│  │ • Flux GitOps   │  │ • Pub/Sub       │  │ • Secret Mgr    │   │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘   │
│           │                     │                    │           │
│           └─────────────────────┼────────────────────┘           │
│                                 │                                │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                    LIMITE DE SEGURANÇA VPC                  │ │
│  │  • Sub-redes Privadas • Cloud NAT    • Regras de Firewall   │ │
│  │  • Túneis IAP        • Endpoints VPC • Balanceador de Carga │ │
│  └─────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

1.2 Modelos de Implantação

2. Requisitos de Infraestrutura GCP

2.1 Especificações Mínimas de Infraestrutura

2.2 Dependências de Serviços GCP

3. Especificações do Cluster GKE

3.1 Configuração do Cluster

# Configuração do Cluster GKE com 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 Configuração do Node Pool

# Node Pool Primário
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 Alocação de Recursos Multi-Inquilino

4. Arquitetura da Camada de Dados

4.1 Arquitetura de Armazenamento

4.1.1 Configuração do Cloud Storage

# Bucket de Armazenamento em Nuvem para Armazenamento 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 dias
  }

  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 Configuração do Firestore

# Banco de Dados Firestore para Metadados e Configuração
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"
}

# Regras de Segurança do Firestore
resource "google_firestore_database" "security_rules" {
  depends_on = [google_firestore_database.energent_metadata]

  # O conteúdo das regras de segurança seria definido aqui
  # Implementação de isolamento de locatários e controles de acesso
}

4.1.3 Armazenamento Compartilhado Filestore

# Filestore para Sistema de Arquivos Compartilhado
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 Funções em Nuvem

5.1.1 Serviço de Autenticação

# Função em Nuvem para Autenticação
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 Serviço de Cobrança

# Função em Nuvem para Cobrança
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 Configuração do API Gateway

# API Gateway para Funções 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. Segurança e Conformidade

6.1 Segurança de Rede

6.1.1 Configuração de VPC

# Rede VPC e Regras 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 Regras de Firewall

6.2 Padrões de Criptografia

6.3 IAM e Contas de Serviço

6.3.1 Contas de Serviço do GKE

# Conta de Serviço do GKE
resource "google_service_account" "gke_service_account" {
  account_id   = "energent-gke-${var.environment}"
  display_name = "Energent GKE Service Account"
  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}"
}

# Vinculação de Identidade de Trabalho
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. Arquitetura de Rede

7.1 Design de VPC

┌─────────────────────────────────────────────────────────────────┐
│                         VPC (10.0.0.0/16)                       │
│                                                                 │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │  Sub-rede Pública │    │  Sub-rede Pública │    │ Sub Pública │  │
│  │   (10.0.1.0/24) │    │   (10.0.2.0/24) │    │(10.0.3.0/24)│  │
│  │                 │    │                 │    │             │  │
│  │   Cloud NAT     │    │   Cloud NAT     │    │ Cloud NAT   │  │
│  │   Load Balancer │    │   Load Balancer │    │Load Balancer│  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
│           │                       │                     │       │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │ Sub-rede Privada │    │ Sub-rede Privada │    │Sub Privada │  │
│  │  (10.1.0.0/16)  │    │  (10.1.0.0/16)  │    │(10.1.0.0/16)│  │
│  │                 │    │                 │    │             │  │
│  │  Nós GKE        │    │  Nós GKE        │    │ Nós GKE     │  │
│  │  Funções VPC    │    │  Funções VPC    │    │ Funções     │  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
│           │                       │                     │       │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │ Sub-rede Serviços│    │ Sub-rede Serviços│    │Sub Serviços│  │
│  │  (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 Conexões de Serviço Privadas

8. Pipeline de CI/CD

8.1 Infraestrutura como Código (Terraform)

8.1.1 Estrutura do Terraform

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

8.1.2 Pipeline do 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 (only on main branch)
  - 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 Configuração do 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 Implantação Serverless (Cloud Build)

8.3.1 Configuração de Implantação de Funções

# 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. Monitoramento e Observabilidade

9.1 Configuração de Monitoramento na Nuvem

9.1.1 Monitoramento do 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 Aplicação

9.3 Logs de Auditoria

# 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. Processo de Implantação

10.1 Cronograma de Implantação

10.2 Comandos de Implantação

10.2.1 Implantação de Infraestrutura

# Implantação de Infraestrutura com Terraform
cd terraform/environments/production
terraform init -backend-config="bucket=energent-terraform-state"
terraform plan -var-file="production.tfvars"
terraform apply -auto-approve

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

10.2.2 Implantação de Aplicação

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

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

# Verificar implantação
kubectl get pods -n energent-ai
kubectl get ingress -n energent-ai

10.3 Validação da Implantação

# Endpoints de verificação de saúde
curl -k https://api.energent.example.com/health
curl -k https://api.energent.example.com/metrics

# Validação do Kubernetes
kubectl top nodes
kubectl get hpa -n energent-ai
kubectl logs -n energent-ai -l app=energent-platform

11. Operações e Manutenção

11.1 Backup e Recuperação de Desastres

11.1.1 Estratégia de Backup

11.1.2 Procedimentos de Recuperação de Desastres

# Backup do cluster GKE usando Velero
velero backup create energent-cluster-backup \
  --include-namespaces energent-ai \
  --storage-location gcp

# Recuperação pontual do Firestore
gcloud firestore databases restore \
  --source-database=energent-metadata-production \
  --destination-database=energent-metadata-restored \
  --backup-time=2025-05-28T10:00:00Z

11.2 Escalabilidade e Desempenho

11.2.1 Configuração de Autoescalonamento

# Horizontal Pod Autoscaler
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 Atualização e Manutenção

11.3.1 Atualizações Gradativas

# Atualização do cluster GKE
gcloud container clusters upgrade energent-production \
  --master \
  --cluster-version 1.30 \
  --region us-central1

# Atualização gradativa do aplicativo via Flux
git commit -am "Update energent-platform to v2.1.0"
git push origin main
# Flux detecta e aplica alterações automaticamente

12. Suporte e Escalonamento

12.1 Níveis de Suporte

12.2 Cobertura de Suporte 24/7

Suporte Empresarial:

• 📧 Email: support@energent.ai

Escalonamento de Emergência:

• 📧 Email de Emergência: emergency@energent.ai

12.3 Acordos de Nível de Serviço

Apêndices

Apêndice A: Custos de Serviço GCP

Apêndice B: Lista de Verificação de Conformidade de Segurança

• VPC com sub-redes privadas implantadas
• Regras de firewall com acesso de menor privilégio
• Criptografia Cloud KMS para todos os dados em repouso
• TLS 1.3 para todos os dados em trânsito
• IAM com permissões mínimas
• Logs de Auditoria na Nuvem habilitados
• Central de Comando de Segurança habilitada
• Restrições de Política da Organização habilitadas
• Gerenciador de Segredos para todas as credenciais
• Scans e avaliações de segurança regulares

Apêndice C: Guia de Solução de Problemas

Problemas Comuns:

1. Nós GKE Não Entram no Cluster

   • Verifique as permissões da conta de serviço
   • Verifique o roteamento de sub-rede e o Cloud NAT

2. Pods do Aplicativo em CrashLoop

   • Verifique os limites e solicitações de recursos
   • Verifique as reivindicações de volumes persistentes

3. Problemas de Conectividade de Rede

   • Verifique a configuração do conector VPC
   • Verifique as regras de firewall

• Classificação do Documento: Público
• Versão: 3.0
• Última Atualização: 2025-05-28
• Próxima Revisão: 2025-08-28
• Contato: support@energent.ai