Guide de Déploiement GCP Entreprise - Energent.ai

Energent.ai fournit des agents de bureau virtuels alimentés par l'IA qui automatisent des flux de travail complexes multi-applications pour les utilisateurs en entreprise. Ce guide offre des spécifications de déploiement complètes sur Google Cloud Platform en utilisant une architecture moderne native du cloud avec GKE, un design multi-locataires et des contrôles de sécurité de niveau entreprise.

• Classification du Document : Public
• Version : 3.0
• Dernière Mise à Jour : 2025-05-28
• Architecture : GCP GKE + Hybride Sans Serveur
• Conformité : SOC 2, Meilleures Pratiques de Sécurité Google Cloud

Table des Matières

1. Aperçu de l'Architecture
2. Exigences d'Infrastructure GCP
3. Spécifications du Cluster GKE
4. Architecture de la Couche de Données
5. Composants Sans Serveur
6. Sécurité & Conformité
7. Architecture Réseau
8. Pipeline CI/CD
9. Surveillance & Observabilité
10. Processus de Déploiement
11. Opérations & Maintenance
12. Support & Escalade

1. Aperçu de l'Architecture

1.1 Architecture Multi-Locataires Native du Cloud

Energent.ai se déploie sur Google Cloud Platform en utilisant une architecture moderne et évolutive qui combine l'orchestration Kubernetes avec des composants sans serveur pour une performance et une efficacité de coûts optimales.

┌──────────────────────────────────────────────────────────────────┐
│                        ENVIRONNEMENT CLOUD GCP                   │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐   │
│  │   CLUSTER GKE   │  │   SANS SERVEUR  │  │   COUCHE DE DONNÉES │   │
│  │                 │  │                 │  │                 │   │
│  │ • Multi-locataires │  │ • Auth Fonctions │  │ • Firestore     │   │
│  │ • n2-standard-4 │  │ • Facturation Fonctions │  │ • Cloud Storage │   │
│  │ • Auto-scaling  │  │ • API Gateway   │  │ • Filestore     │   │
│  │ • Flux GitOps   │  │ • Pub/Sub       │  │ • Gestion des Secrets │   │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘   │
│           │                     │                    │           │
│           └─────────────────────┼────────────────────┘           │
│                                 │                                │
│  ┌─────────────────────────────────────────────────────────────┐ │
│  │                    LIMITE DE SÉCURITÉ VPC                   │ │
│  │  • Sous-réseaux privés • Cloud NAT    • Règles de pare-feu  │ │
│  │  • Tunnels IAP     • Points de terminaison VPC • Load Balancer │ │
│  └─────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

1.2 Modèles de Déploiement

2. Exigences d'Infrastructure GCP

2.1 Spécifications Minimales d'Infrastructure

2.2 Dépendances des Services GCP

3. Spécifications du Cluster GKE

3.1 Configuration du Cluster

# Configuration Terraform du Cluster GKE
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 Configuration du Pool de Nœuds

# Pool de Nœuds Principal
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 Allocation de Ressources Multi-Locataires

4. Architecture de la Couche de Données

4.1 Architecture de Stockage

4.1.1 Configuration de Cloud Storage

# Cloud Storage Bucket pour le stockage d'objets
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 jours
  }

  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 Configuration de Firestore

# Base de données Firestore pour les métadonnées et la configuration
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"
}

# Règles de sécurité Firestore
resource "google_firestore_database" "security_rules" {
  depends_on = [google_firestore_database.energent_metadata]

  # Le contenu des règles de sécurité serait défini ici
  # Mise en œuvre de l'isolation des locataires et des contrôles d'accès
}

4.1.3 Stockage partagé Filestore

# Filestore pour le système de fichiers partagé
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. Composants Serverless

5.1 Fonctions Cloud

5.1.1 Service d'authentification

# Fonction Cloud pour l'authentification
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 Service de facturation

# Fonction Cloud pour la facturation
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 Configuration de l'API Gateway

# API Gateway pour les fonctions 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.id
location   = var.gcp_region
project    = var.project_id

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

6. Sécurité et conformité

6.1 Sécurité réseau

6.1.1 Configuration du VPC

# Réseau VPC et règles de pare-feu
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 Règles de pare-feu

6.2 Normes de chiffrement

6.3 IAM et comptes de service

6.3.1 Comptes de service GKE

# Compte de service GKE
resource "google_service_account" "gke_service_account" {
  account_id   = "energent-gke-${var.environment}"
  display_name = "Compte de service GKE Energent"
  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}"
}

# Liaison d'identité de charge de travail
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. Architecture réseau

7.1 Conception VPC

┌─────────────────────────────────────────────────────────────────┐
│                         VPC (10.0.0.0/16)                       │
│                                                                 │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │  Sous-réseau    │    │  Sous-réseau    │    │ Sous-réseau │  │
│  │   Public        │    │   Public        │    │ Public      │  │
│  │   (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│  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
│           │                       │                     │       │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │ Sous-réseau     │    │ Sous-réseau     │    │Sous-réseau  │  │
│  │  Privé          │    │  Privé          │    │ Privé       │  │
│  │  (10.1.0.0/16)  │    │  (10.1.0.0/16)  │    │(10.1.0.0/16)│  │
│  │                 │    │                 │    │             │  │
│  │  Nœuds GKE      │    │  Nœuds GKE      │    │ Nœuds GKE   │  │
│  │  Fonctions VPC  │    │  Fonctions VPC  │    │ Fonctions   │  │
│  └─────────────────┘    └─────────────────┘    └─────────────┘  │
│           │                       │                     │       │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐  │
│  │ Sous-réseau     │    │ Sous-réseau     │    │Sous-réseau  │  │
│  │  Services       │    │  Services       │    │ Services    │  │
│  │  (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 Connexions de Service Privées

8. Pipeline CI/CD

8.1 Infrastructure en tant que Code (Terraform)

8.1.1 Structure Terraform

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

8.1.2 Pipeline Terraform (Cloud Build)

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

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

  # Application Terraform (uniquement sur la branche principale)
  - 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 Configuration 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 Déploiement Serverless (Cloud Build)

8.3.1 Configuration de Déploiement des Fonctions

# cloudbuild-functions.yaml
steps:
  # Déployer la fonction Auth
  - 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}

  # Déployer la fonction Billing
  - 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. Surveillance et Observabilité

9.1 Configuration Cloud Monitoring

9.1.1 Surveillance GKE

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

# Métriques basées sur les journaux
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 = "Taux d'erreur Energent"
  }
}

9.2 Métriques d'Application

9.3 Journaux d'Audit

# Configuration des journaux d'audit Cloud
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"
  }
}

# Destination des journaux pour les événements de sécurité
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. Processus de Déploiement

10.1 Chronologie de Déploiement

10.2 Commandes de Déploiement

10.2.1 Déploiement de l'Infrastructure

# Déploiement de l'infrastructure avec Terraform
cd terraform/environments/production
terraform init -backend-config="bucket=energent-terraform-state"
terraform plan -var-file="production.tfvars"
terraform apply -auto-approve

# Vérifier le cluster GKE
gcloud container clusters get-credentials energent-production --region us-central1
kubectl get nodes

10.2.2 Déploiement de l'Application

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

# Déployer les composants serverless
gcloud builds submit --config cloudbuild-functions.yaml \
  --substitutions _ENVIRONMENT=production,_REGION=us-central1

# Vérifier le déploiement
kubectl get pods -n energent-ai
kubectl get ingress -n energent-ai

10.3 Validation du déploiement

# Points de contrôle de santé
curl -k https://api.energent.example.com/health
curl -k https://api.energent.example.com/metrics

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

11. Opérations & Maintenance

11.1 Sauvegarde & Récupération en cas de sinistre

11.1.1 Stratégie de sauvegarde

11.1.2 Procédures de récupération en cas de sinistre

# Sauvegarde du cluster GKE avec Velero
velero backup create energent-cluster-backup \
  --include-namespaces energent-ai \
  --storage-location gcp

# Récupération ponctuelle Firestore
gcloud firestore databases restore \
  --source-database=energent-metadata-production \
  --destination-database=energent-metadata-restored \
  --backup-time=2025-05-28T10:00:00Z

11.2 Mise à l'échelle & Performance

11.2.1 Configuration de l'auto-scaling

# 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 Mise à jour & Maintenance

11.3.1 Mises à jour progressives

# Mise à jour du cluster GKE
gcloud container clusters upgrade energent-production \
  --master \
  --cluster-version 1.30 \
  --region us-central1

# Mise à jour progressive de l'application via Flux
git commit -am "Update energent-platform to v2.1.0"
git push origin main
# Flux détecte et applique automatiquement les changements

12. Support & Escalade

12.1 Niveaux de support

12.2 Couverture de support 24/7

Support Entreprise :

• 📧 Email : support@energent.ai

Escalade d'urgence :

• 📧 Email d'urgence : emergency@energent.ai

12.3 Accords de niveau de service

Annexes

Annexe A : Coûts des services GCP

Annexe B : Liste de vérification de conformité de sécurité

• VPC avec sous-réseaux privés déployés
• Règles de pare-feu avec accès minimal
• Chiffrement Cloud KMS pour toutes les données au repos
• TLS 1.3 pour toutes les données en transit
• IAM avec permissions minimales
• Logs d'audit Cloud activés
• Security Command Center activé
• Contraintes de politique d'organisation activées
• Secret Manager pour toutes les informations d'identification
• Scans et évaluations de sécurité réguliers

Annexe C : Guide de dépannage

Problèmes courants :

1. Nœuds GKE ne rejoignant pas le cluster

   • Vérifiez les permissions du compte de service
   • Vérifiez le routage des sous-réseaux et Cloud NAT

2. Pods d'application en CrashLoop

   • Vérifiez les limites et demandes de ressources
   • Vérifiez les revendications de volumes persistants

3. Problèmes de connectivité réseau

   • Vérifiez la configuration du connecteur VPC
   • Vérifiez les règles de pare-feu

• Classification du document : Public
• Version : 3.0
• Dernière mise à jour : 2025-05-28
• Prochaine révision : 2025-08-28
• Contact : support@energent.ai