Aller au contenu principal

Scaling

Topologie de l'application​

L'application GitGuardian se compose de plusieurs ressources Kubernetes. Voici les aspects clés selon le type d'installation :

  • Installations basées sur KOTS : permettent la configuration des réplicas, du CPU et des requêtes/limites de mémoire pour les principaux déploiements/pods.
  • Installations basées sur Helm : offrent une personnalisation plus complète, y compris :
    • La création de nouvelles classes de workers.
    • La personnalisation d'autres types de ressources telles que le stockage éphémère, les huge pages, etc.
    • La configuration de nodeSelector, de tolerations et de configurations supplémentaires.

Pour des informations détaillées sur les noms, types et utilisation des déploiements/pods, consultez la page Topologie de l'application GitGuardian.

Dimensionnement pour GitGuardian : scans historiques, scans en temps réel, API publique et moteur ML de secrets​

Lorsque vous utilisez GitGuardian pour surveiller des dépôts, il est crucial de dimensionner les ressources de manière appropriée pour les scans historiques, les scans en temps réel et les requêtes de l'API publique. Cela garantit un traitement efficace et rapide quelle que soit la charge. Ces recommandations concernent uniquement les installations sur un existing cluster.

Directives générales​

Réalisation de vos premiers scans historiques

Lorsque vous ajoutez un grand nombre de sources, envisagez d'augmenter temporairement le nombre de pods pendant la durée du scan historique initial. Par la suite, vous pourrez diminuer les réplicas et les ressources de ces pods.

Lors de la réalisation d'un scan historique sur un dépôt git, GitGuardian clone le dépôt sur le stockage éphémère du pod et parcourt toutes les branches et commits à la recherche de secrets potentiels. Le scan complet est effectué par un seul pod et peut durer de quelques secondes à plusieurs heures selon la taille du dépôt. Plus vous ajoutez de pods, plus de scans historiques peuvent être effectués simultanément. Lors du dimensionnement de vos nœuds, gardez à l'esprit que chaque pod doit disposer de suffisamment de stockage éphémère et de mémoire pour fonctionner. Pour améliorer les performances et réduire les temps de scan, il est recommandé d'utiliser des disques SSD pour le stockage éphémère.

Pour les scans en temps réel, ceux-ci sont déclenchés par les événements Push envoyés par le VCS à GitGuardian. Ces scans se terminent généralement en moins d'une seconde et devraient toujours être inférieurs à 3 secondes. Pour gérer les pics de push, vous pouvez augmenter le nombre de pods worker-worker qui traitent les scans en temps réel.

L'API publique, utilisée principalement par ggshield, est déployée sous le pod webapp-public_api. Ce pod est essentiel pour permettre les interactions entre ggshield et GitGuardian. Pour garantir que l'API publique puisse gérer le trafic attendu, vous devrez peut-être ajuster le nombre de pods webapp-public_api.

Les pods webapp-internal_api gèrent les requêtes internes du Dashboard, tandis que les pods webapp-internal_api_long gèrent les opérations de plus longue durée, assurant des performances fiables et évitant les timeouts lors des tâches prolongées.

Ajustez le nombre de pods et la capacité des nœuds en fonction de la taille et du nombre de dépôts, du volume attendu d'événements push et du volume attendu de requêtes API afin d'assurer un scan et des interactions efficaces.

Pour éviter le dimensionnement manuel, l'autoscaling peut vous intéresser pour vous adapter dynamiquement à la charge, voir Autoscaling.

Considérations sur le scan des container registries​

  • Configuration des réplicas : par défaut, les réplicas de container registry sont fixés à 0, ce qui fait que le scan des container registries se rabat sur les scanner workers. Il est recommandé de configurer un nombre de réplicas non nul pour des performances de scan de container registry dédiées.
  • Utilisation du cache : consomme une quantité importante de mémoire Redis et de stockage de base de données (plusieurs Go). Envisagez de dimensionner Redis ou d'utiliser une instance dédiée.
  • Pression sur la base de données : les pods scanner peuvent exercer une pression sur la base de données, en particulier lors des scans initiaux. Dimensionnez avec précaution en respectant les nombres minimaux de réplicas recommandés.
  • Coûts de transfert de données : le scan de grandes registries peut entraîner des coûts élevés de transfert réseau. Commencez avec quelques dépôts pour évaluer les coûts avant de passer à un scan complet.

Considérations sur les check runs​

  • Configuration des réplicas : par défaut, les réplicas de check runs sont fixés à 0, ce qui fait que le traitement des check runs est pris en charge par worker-worker. Si vous rencontrez des volumes élevés de check runs GitHub, vous pouvez activer des pods worker-check-runs dédiés en configurant celeryWorkers.check-runs.replicas pour décharger la file check_run de worker-worker.
  • Check runs basés sur le scan (à partir de 2026.6.0, installations basées sur Helm uniquement) : par défaut, celeryWorkers.check-run-scanners.replicas est à 0, donc la file check_run_scan (scans limités aux PR) se rabat sur worker-scanners et entre en concurrence avec les scans historiques. Définissez-la sur une valeur non nulle pour exécuter ces scans sur des pods worker-check-run-scanners dédiés. Chaque pod demande par défaut 100m CPU, 500Mi de mémoire et 5Gi de stockage éphémère. La métrique d'autoscaling par défaut est {"check_run_scan":10}.

Considérations sur le scan de Slack​

  • Configuration des réplicas : par défaut, les réplicas de scanners Slack sont fixés à 0, ce qui fait que le scan de registry Slack se rabat sur les scanner workers. Il est recommandé de configurer un nombre de réplicas non nul pour des performances de scan de registry Slack dédiées. Configurer un grand nombre de réplicas est inutile, car le scan Slack est limité à un canal à la fois en raison des limites de débit de l'API Slack.

Considérations sur le scan de Jira Cloud et Confluence Cloud​

  • Configuration des réplicas : par défaut, les réplicas de scanners-db-less-jira-cloud et scanners-db-less-confluence-cloud sont fixés à 0, ce qui fait que les scans historiques de Jira Cloud et Confluence Cloud se rabattent sur les workers scanners-ods, ou sur les scanner workers lorsque scanners-ods a 0 réplica. Ce sont les workers qui traitent déjà les scans de Jira Cloud et Confluence Cloud, donc aucune action n'est requise après une mise à niveau. Pour des performances de scan dédiées sur de grands sites Jira Cloud ou Confluence Cloud, définissez celeryWorkers.scanners-db-less-jira-cloud.replicas ou celeryWorkers.scanners-db-less-confluence-cloud.replicas sur une valeur supérieure à 0. Sur les installations basées sur KOTS, utilisez les paramètres Jira Cloud (Non-VCS Sources) Worker et Confluence Cloud (Non-VCS Sources) Worker de l'Admin Console.
  • Fallback : les workers scanners-ods ou scanner ne traitent ces scans que tant que le worker dédié a 0 réplica. Si vous définissez des réplicas et que les pods dédiés ne peuvent pas démarrer, les scans Jira Cloud ou Confluence Cloud restent en attente. Pour rétablir le fallback, redéfinissez les réplicas à 0.
  • Pas d'accès à la base de données : ces workers ne se connectent pas à la base de données. Ils lisent les identifiants d'intégration depuis Redis.

Considérations sur le scan des fichiers binaires​

Le scan des fichiers binaires n'est actuellement disponible que pour Microsoft Sharepoint Online et Microsoft OneDrive. Lors de la réalisation d'un scan historique sur des sources contenant des fichiers binaires, les fichiers seront téléchargés localement sur le stockage éphémère du pod. Pour améliorer les performances et réduire les temps de scan, il est recommandé d'utiliser des disques SSD pour le stockage éphémère et de provisionner suffisamment de stockage éphémère pour ces pods (100 Go).

Considérations sur le scan des package registries​

  • Configuration des réplicas : scanners-db-less.replicas doit être défini sur une valeur supérieure à 0 pour les intégrations JFrog Package Registries, SharePoint et OneDrive. Par défaut, les réplicas sont fixés à 0.
  • Utilisation du cache : l'instance Redis commit-cache est utilisée pour le scan des JFrog Package Registries. Si commit-cache n'est pas configuré, l'instance Redis principale sera utilisée à la place.

Considérations sur le recalcul des emplacements de secrets​

  • Configuration des réplicas (installations basées sur Helm uniquement) : par défaut, celeryWorkers.incidents-disk.replicas est à 0, donc la file incidents_disk, qui recalcule les emplacements de secrets, se rabat sur worker-scanners. Définissez-la sur une valeur non nulle (à partir de 2026.8.0) pour exécuter ce travail sur des pods worker-incidents-disk dédiés. Chaque pod demande par défaut 1Gi de mémoire (limite 2Gi) et 5Gi de stockage éphémère. La métrique d'autoscaling par défaut est {"incidents_disk":10}.

Considérations sur Public Monitoring​

  • Configuration des réplicas (installations basées sur Helm uniquement) : worker-public-monitoring (à partir de 2026.7.0) n'est déployé qu'une fois que Public Monitoring est activé sur votre licence et que l'application a été redéployée avec un helm upgrade. Il est alors par défaut à 1 réplica avec une demande de mémoire de 1Gi et une limite de mémoire de 2Gi. Il consomme les files public_monitoring, public_monitoring_continuous_scan, public_monitoring_historical_scan et public_monitoring_realtime_scan. Augmentez celeryWorkers.public-monitoring.replicas si ces files s'accumulent.

Premium Scan Retry Worker​

info

Disponible uniquement pour les installations basées sur Helm.

premium-scanners-retry est un scanner de secours pour les dépôts plus volumineux. Lorsqu'un scan échoue sur un pod worker-scanners standard — généralement une erreur de dépassement de mémoire (OOM) sur un gros dépôt — le job est remis en file dans premium_repo_scan_retry et réessayé sur un pod à plus grande mémoire. Cela vous permet de dimensionner vos scanners de base pour le cas courant plutôt que pour votre plus gros dépôt. Vous pouvez activer ce worker si certains scans VCS échouent de manière répétée avec une erreur « Worker Error ».

  • Désactivé par défaut (replicas: 0) : ne consomme aucune ressource tant qu'il n'est pas activé. Tant qu'il est désactivé, worker-scanners consomme la file premium_repo_scan_retry comme fallback, donc aucune action n'est requise.
  • Ressources : par défaut une demande de mémoire et une limite de 120Gi — intentionnel, dimensionné pour la récupération OOM de jobs qui ont déjà échoué sur des pods standards. Choisissez un nœud qui s'ajuste au plus près (par exemple ~128 Go allouables) pour éviter de provisionner un nœud surdimensionné.
  • Mise à l'échelle à zéro : à associer avec l'Horizontal Pod Autoscaling (métrique sur premium_repo_scan_retry, seuil 1) afin que le grand nœud ne soit provisionné que lorsqu'il y a un scan à réessayer.
celeryWorkers:
premium-scanners-retry:
replicas: 1 # 0 disables the dedicated worker (retries fall back to worker-scanners)
resources:
requests:
memory: 120Gi
limits:
memory: 120Gi

Considérations sur le dimensionnement du moteur ML de secrets​

Le moteur ML de secrets nécessite une allocation de ressources et des considérations de dimensionnement spécifiques. Pour des instructions de configuration détaillées, consultez la documentation Machine Learning.

  • Ressources par pod : 3 vCPU et 2,5 Gio de RAM chacun.
  • Recommandation d'instance : utilisez des instances AWS Gen 7 Intel (M7i) avec une architecture amd64. Les instances CPU uniquement sont bien plus rentables que les instances GPU (g4dn/p3) pour l'analyse ML.
  • Mise à l'échelle : utilisez les recommandations de dimensionnement ci-dessous (Small/Medium/Large) comme configuration de base. Pour une mise à l'échelle dynamique pendant les backfills, envisagez de configurer l'Horizontal Pod Autoscaling (HPA) pour le worker ml-api-priority.

ClickHouse​

Certaines fonctionnalités nécessitent ClickHouse, un composant in-cluster facultatif avec ses propres considérations de dimensionnement, distinctes des composants système de base ci-dessus. Consultez la page dédiée Dimensionnement et durcissement pour les tableaux de dimensionnement et les recommandations matérielles.

Analytics​

Advanced Analytics nécessite des ressources supplémentaires lorsqu'il est activé. Le job s'exécute une fois par jour et possède la configuration de ressources par défaut suivante :

  • Demande de mémoire : 8 Go
  • Limite de mémoire : 12 Go
  • Augmentation de l'utilisation de la base de données : 15-20 % (minimum 5-6 Go)
  • Stockage éphémère : le job exécute un pipeline Spark qui écrit des données de shuffle et de spill dans /tmp sur le disque local du nœud. Sur les grands workspaces, cela peut dépasser la limite de stockage éphémère du nœud et faire échouer le job quotidien. Prévoyez de 5 à 20 Go d'espace de travail selon votre volume de données.

Planifiez la capacité de votre cluster et de votre base de données en conséquence.

À partir de 2026.7.0, vous pouvez déplacer l'espace de travail Spark sur un volume dédié et dimensionné au lieu du disque local du nœud. Voir Stockage éphémère pour l'analytics in-app.

Small​

Composants système de base​

Pour jusqu'à 2000 dépôts, gérant jusqu'à 500 push par heure et jusqu'à 1000 requêtes API par heure :

ComposantCapacité requiseNombre
Nœuds de calcul Kubernetes4 vCPU
16 Go de mémoire
50 Go d'espace disque éphémère, 10 Go d'espace disque persistant
3
PostgreSQL Master4 vCPU
8 Go de mémoire
200 Go d'espace disque
1
Redis2 vCPU
2 Go de mémoire
20 Go d'espace disque
1
Total18 vCPU
58 Go de mémoire
150 Go d'espace disque éphémère, 250 Go d'espace disque persistant
5

Si vous prévoyez d'utiliser le stockage éphémère global, ajoutez 20 Go à l'espace disque persistant sur chacun de vos nœuds de calcul Kubernetes.

Scans historiques (jusqu'à 5 Go)​

ComposantCapacité requiseNombre
Pods worker-scannersDemande et limite de mémoire : 6 Go4

Scans en temps réel (jusqu'à 500 push/h)​

ComposantCapacité requiseNombre
Pods worker-workerParamètres de ressources par défaut2

API publique (jusqu'à 1k requêtes/h)​

ComposantCapacité requiseNombre
Pods webapp-public_apiParamètres de ressources par défaut2
Pods nginx (dashboard et API)Paramètres de ressources par défaut2

Dashboard (jusqu'à 200 utilisateurs actifs)​

ComposantCapacité requiseNombre
Pods webapp-internal_apiParamètres de ressources par défaut2
Pods webapp-internal_api_longParamètres de ressources par défaut2

Machine learning (jusqu'à 500 événements/h)​

ComposantCapacité requiseNombre
Pods ml-secret-engineParamètres de ressources par défaut1
Pods worker-ml-api-priorityParamètres de ressources par défaut1

Scans historiques et scans en temps réel pour les container registries​

ComposantCapacité requiseNombre
Pods worker-container-registriesDemande et limite de mémoire : 4 Go2

Scans historiques pour Slack​

ComposantCapacité requiseNombre
Pods worker-scanners-slackParamètres de ressources par défaut1

Scans historiques pour Sharepoint / OneDrive​

ComposantCapacité requiseNombre
Pods worker-scanners-ods-highdiskParamètres de ressources par défaut1
Pods apacheTikaParamètres de ressources par défaut1

Scan des package registries​

ComposantCapacité requiseNombre
Pods worker-scanners-db-lessParamètres de ressources par défaut1

Medium​

Composants système de base​

Pour jusqu'à 10000 dépôts, gérant jusqu'à 1000 push par heure et jusqu'à 25000 requêtes API par heure :

ComposantCapacité requiseNombre
Nœuds de calcul Kubernetes8 vCPU
32 Go de mémoire
50 Go d'espace disque éphémère, 10 Go d'espace disque persistant
5
PostgreSQL Master8 vCPU
32 Go de mémoire
250 Go d'espace disque
1
Redis4 vCPU
8 Go de mémoire
40 Go d'espace disque
1
Total52 vCPU
200 Go de mémoire
250 Go d'espace disque éphémère, 340 Go d'espace disque persistant
7

Si vous prévoyez d'utiliser le stockage éphémère global, ajoutez 120 Go à l'espace disque persistant sur chacun de vos nœuds de calcul Kubernetes.

Scans historiques (jusqu'à 10 Go)​

ComposantCapacité requiseNombre
Pods worker-scannersDemande et limite de mémoire : 11 Go12

Scans en temps réel (jusqu'à 1k push/h)​

ComposantCapacité requiseNombre
Pods worker-workerParamètres de ressources par défaut4

API publique (jusqu'à 25k requêtes/h)​

ComposantCapacité requiseNombre
Pods webapp-public_apiParamètres de ressources par défaut4
Pods nginx (dashboard et API)Paramètres de ressources par défaut2

Dashboard (jusqu'à 500 utilisateurs actifs)​

ComposantCapacité requiseNombre
Pods webapp-internal_apiParamètres de ressources par défaut4
Pods webapp-internal_api_longParamètres de ressources par défaut2

Machine learning (jusqu'à 1k événements/h)​

ComposantCapacité requiseNombre
Pods ml-secret-engineParamètres de ressources par défaut2
Pods worker-ml-api-priorityParamètres de ressources par défaut2

Scans historiques et scans en temps réel pour les container registries​

ComposantCapacité requiseNombre
Pods worker-container-registriesDemande et limite de mémoire : 4 Go4

Scans historiques pour Slack​

ComposantCapacité requiseNombre
Pods worker-scanners-slackParamètres de ressources par défaut2

Scans historiques pour Sharepoint / OneDrive​

ComposantCapacité requiseNombre
Pods worker-scanners-ods-highdiskDemande, limite de mémoire : 4 Gio, 6 Gio4
Pods apacheTikaParamètres de ressources par défaut2

Scan des package registries​

ComposantCapacité requiseNombre
Pods worker-scanners-db-lessParamètres de ressources par défaut2

Large​

Composants système de base​

Pour jusqu'à 40000 dépôts, gérant jusqu'à 2000 push par heure et jusqu'à 50000 requêtes API par heure :

ComposantCapacité requiseNombre
Nœuds de calcul Kubernetes8 vCPU
64 Go de mémoire
50 Go d'espace disque éphémère, 10 Go d'espace disque persistant
7
PostgreSQL Master16 vCPU
64 Go de mémoire
300 Go d'espace disque
1
Redis8 vCPU
16 Go de mémoire
100 Go d'espace disque
1
Total80 vCPU
528 Go de mémoire
350 Go d'espace disque éphémère, 470 Go d'espace disque persistant
9

Si vous prévoyez d'utiliser le stockage éphémère global, ajoutez 160 Go à l'espace disque persistant sur chacun de vos nœuds de calcul Kubernetes.

Scans historiques (jusqu'à 15 Go)​

ComposantCapacité requiseNombre
Pods worker-scannersDemande et limite de mémoire : 16 Go16
Pods worker-scanners-odsDemande et limite de mémoire : 4 Go10

Définissez des pods worker-scanners-ods spécifiques, surtout si vous intégrez de grandes instances Slack ou MS Teams (plus de 5k canaux). Il est préférable d'isoler ces charges de travail. Sinon, il est acceptable de partager la même file et les mêmes workers avec la charge de travail worker-scanners.

Scans en temps réel (jusqu'à 2k push/h)​

ComposantCapacité requiseNombre
Pods worker-workerParamètres de ressources par défaut8

API publique (jusqu'à 50k requêtes/h)​

ComposantCapacité requiseNombre
Pods webapp-public_apiParamètres de ressources par défaut6
Pods nginx (dashboard et API)Paramètres de ressources par défaut2

Dashboard (jusqu'à 1k utilisateurs actifs)​

ComposantCapacité requiseNombre
Pods webapp-internal_apiParamètres de ressources par défaut6
Pods webapp-internal_api_longParamètres de ressources par défaut2

Machine learning (jusqu'à 2k événements/h)​

ComposantCapacité requiseNombre
Pods ml-secret-engineParamètres de ressources par défaut2
Pods worker-ml-api-priorityParamètres de ressources par défaut2

Scans historiques et scans en temps réel pour les container registries​

ComposantCapacité requiseNombre
Pods worker-container-registriesDemande et limite de mémoire : 4 Go6

Scans historiques pour Slack​

ComposantCapacité requiseNombre
Pods worker-scanners-slackParamètres de ressources par défaut2

Scans historiques pour Sharepoint / OneDrive​

ComposantCapacité requiseNombre
Pods worker-scanners-ods-highdiskDemande, limite de mémoire : 4 Gio, 6 Gio4
Pods apacheTikaParamètres de ressources par défaut2

Scan des package registries​

ComposantCapacité requiseNombre
Pods worker-scanners-db-lessParamètres de ressources par défaut4

Configurer les paramètres de dimensionnement​

Vous pouvez dimensionner votre infrastructure selon les recommandations ci-dessus, mais vous pouvez également utiliser l'autoscaling Kubernetes pour vous adapter dynamiquement à la charge, voir Autoscaling.

Installation basée sur KOTS​

attention

Assurez-vous de mettre à jour le Kubernetes Application RBAC en ajoutant la permission patch à la ressource servicemonitors.

Naviguez sous Config > Scaling dans la KOTS Admin Console, vous aurez accès aux options de dimensionnement des workers.

  • Front replicas : dimensionne les pods nginx.
  • API replicas : dimensionne les pods api.
  • Workers replicas : dimensionne les pods workers (y compris les pods scanners)
info

La modification de ces valeurs n'affecte pas la stratégie de mise à niveau par déploiement progressif.
Les workers sont configurés pour se répartir sur les nœuds s'il y a plusieurs nœuds. Si vous avez configuré votre cluster pour la haute disponibilité, n'utilisez pas moins de 2 workers de chaque type.

Intégration des sources Non-VCS :

Pour les intégrations non-VCS (messagerie, documentation, ticketing et container registries), la configuration des workers varie selon le type d'intégration :

  • Certaines intégrations peuvent éventuellement utiliser des workers VCS génériques mais bénéficient de workers dédiés
  • D'autres nécessitent leurs propres workers spécialisés et ne peuvent pas partager les workers VCS
  • Par défaut, tous les workers de sources non-VCS sont désactivés (réplicas fixés à 0)

Pour des instructions de configuration détaillées, les exigences relatives aux workers et les étapes d'activation, consultez la documentation Sources Non-VCS.

Cette page de dimensionnement se concentre sur l'optimisation des performances après l'activation initiale.

Installation basée sur Helm​

Personnalisez les applications Helm à l'aide de votre fichier local-values.yaml, soumis avec la commande helm.

Configurez les déploiements avec replicas : use webapps.[name].replicas pour les pods web, celeryWorkers.[name].replicas pour les workers asynchrones et secretEngine.replicas pour le moteur ML de secrets (Machine Learning Secret Engine). De plus, définissez les requests et limits de ressources selon vos besoins.

Exemple

migration:
# Set resources for pre-deploy and post-deploy jobs
resources:
limits:
cpu: 1000m
memory: 500Mi
front:
nginx:
# Set resources for nginx init containers
init:
resources:
limits:
cpu: 1000m
memory: 500Mi
replicas: 2
resources:
limits:
memory: 1Gi
webapps:
public_api:
replicas: 5
resources:
requests:
cpu: 200m
memory: 500Mi
limits:
memory: 4Gi
celeryWorkers:
scanners:
replicas: 8
resources:
requests:
cpu: 200m
memory: 4Gi
limits:
memory: 16Gi
secretEngine:
replicas: 2

Consultez la documentation de référence des values pour plus de détails.

Recommandation de dimensionnement

Pour des performances optimales, envisagez de dimensionner les pods suivants à un minimum de 2 réplicas chacun : hook, internal-api-long, public-api, worker-email, worker-long et worker-worker.

Réglage supplémentaire du stockage éphémère​

info

Disponible uniquement pour les installations basées sur Helm.

Dans certains scénarios, l'optimisation des configurations de stockage éphémère devient essentielle pour obtenir de meilleures performances et une meilleure stabilité, en particulier pour les workers scanners. Cette section décrit des configurations supplémentaires pour affiner le stockage éphémère, en se concentrant sur l'exploitation de nœuds « On Demand » avec des disques nvme et l'intégration de Generic Ephemeral Inline Volumes.

Nœuds « On Demand » avec disques nvme​

Dans l'exemple suivant, nous spécifions que les workers scanners n'utilisent que des VM « On Demand » avec des disques nvme et que le stockage éphémère des pods utilisera ces disques

celeryWorkers:
scanners:
replicas: 8
localStoragePath: /nvme/disk # Used for pods ephemeral storage
nodeSelector: # Must run on "On Demand" nodes with nvme disks
eks.amazonaws.com/capacityType: ON_DEMAND
local-nvme-ready: 'true'
tolerations:
- key: worker-highdisk
operator: Equal
value: 'true'
effect: NoSchedule
resources:
requests:
cpu: 200m
memory: 16Gi
limits:
memory: 16Gi

Generic Ephemeral Inline Volumes​

Dans l'exemple suivant, nous exploitons les Generic Ephemeral Inline Volumes de Kubernetes au sein des charts Helm. Cette fonctionnalité facilite le provisionnement et la récupération dynamiques du stockage, particulièrement utile lorsque l'on traite de petites limites de stockage éphémère. Notez qu'elle est prise en charge à partir de Kubernetes 1.23 (en savoir plus).

celeryWorkers:
scanners:
replicas: 8
resources:
requests:
cpu: 200m
memory: 4Gi
limits:
memory: 16Gi
# -- Worker ephemeral storage
ephemeralStorage:
enabled: true
size: 2Gi

Stockage éphémère pour l'analytics in-app​

Le job analytics in-app exécute un pipeline Spark qui écrit par défaut des données de shuffle et de spill dans /tmp sur le disque local du nœud. Sur les grands workspaces, cela peut dépasser la limite de stockage éphémère du nœud et faire échouer le job quotidien.

À partir de 2026.7.0, vous pouvez attacher un Generic Ephemeral Inline Volume dédié au pod analytics. Lorsqu'il est activé, GitGuardian le monte sur /ephemeral et dirige l'espace de travail de Spark (SPARK_LOCAL_DIRS) vers celui-ci au lieu de /tmp.

inAppAnalytics:
ephemeralStorage:
enabled: true
size: 20Gi
storageClass: '' # Optional: defaults to the cluster's default StorageClass

Dimensionnez le volume en fonction de votre volume de données. Une plage de 5 à 20 Go est un bon point de départ.

Planification par affinité de nœud​

Utilisez le paramètre nodeSelector dans les values Helm pour planifier les pods de workers sur des nœuds spécifiques, en veillant à ce qu'ils s'exécutent dans des zones désignées ou répondent à des critères spécifiques (en savoir plus).

celeryWorkers:
long:
nodeSelector:
topology.kubernetes.io/zone: eu-central-1c
scanners:
nodeSelector:
topology.kubernetes.io/zone: eu-central-1c
worker:
nodeSelector:
topology.kubernetes.io/zone: eu-central-1c

Anti-affinité de pod​

Le chart Helm de GitGuardian fournit des paramètres d'anti-affinité de pod configurables pour contrôler la façon dont les pods sont répartis sur les nœuds de votre cluster Kubernetes. Cette fonctionnalité vous permet d'optimiser la disponibilité et l'utilisation des ressources en garantissant que les pods sont répartis uniformément sur différents nœuds et zones de disponibilité.

Configuration par défaut :

Par défaut, le chart applique une configuration podAntiAffinityPreset: soft pour les webApps et les workers. Cette préférence d'anti-affinité soft tente de répartir les pods sur les nœuds mais ne garantit pas une répartition uniforme. Le planificateur essaiera de placer les pods sur différents nœuds lorsque cela est possible, mais planifiera tout de même les pods même si la répartition préférée ne peut pas être atteinte.

Configuration durcie :

Pour les environnements nécessitant une répartition uniforme garantie des pods, vous pouvez spécifier podAntiAffinityPreset: hard. Cette configuration applique des règles strictes d'anti-affinité qui garantissent que les pods sont répartis uniformément sur :

  • Les zones de disponibilité (clé de topologie : topology.kubernetes.io/zone)
  • Les nœuds individuels (clé de topologie : kubernetes.io/hostname)

Pour activer l'anti-affinité de pod stricte pour le composant scanner worker, configurez vos values Helm comme suit :

celeryWorkers:
scanners:
replicas: 10
podAntiAffinityPreset: hard

Cette configuration garantira que chaque pod scanner worker s'exécute sur un nœud différent, offrant une répartition et une tolérance aux pannes maximales.

Exigences de capacité des nœuds :

Le preset d'anti-affinité hard nécessite que vous disposiez de suffisamment de nœuds dans votre cluster pour satisfaire le nombre souhaité de réplicas. Si votre cluster ne dispose pas d'assez de nœuds pour accueillir tous les pods avec les règles strictes d'anti-affinité, certains pods resteront à l'état « Pending » jusqu'à ce que des nœuds supplémentaires deviennent disponibles. Par exemple, si vous configurez 10 réplicas avec une anti-affinité stricte mais que vous ne disposez que de 8 nœuds disponibles, 2 pods resteront en attente jusqu'à ce que davantage de nœuds soient ajoutés au cluster.