cpra — CPRA est un système de surveillance d'infrastructure haute performance conçu pour les équipes de plateforme gérant des architectures de microservices à grande échelle. Basé sur l'architecture Entity-Component-System (ECS) et les principes de la théorie des files d'attente, CPRA gère plus de 1 000 000 de contrôles de santé simultanés avec une mise à l'échelle automatique du pool de travailleurs pour atteindre les objectifs SLO. | Kitploit

Métrique	Valeur
Moniteurs concurrents max	1 000 000+
Débit	10 000+ contrôles/s/pipeline
Latence (P95)	< 100 ms (configurable via SLO)
Mémoire par moniteur	~100 octets
Mémoire totale (1M moniteurs)	~100 Mo + surcoût du pool de workers
Dimensionnement des workers	Dynamique (basé sur M/M/c)

# Prérequis : Go 1.25 ou ultérieur
go version  # Devrait afficher go1.25 ou supérieur

# Compiler à partir des sources
git clone https://github.com/ziad/cpra.git
cd cpra
go build .

# Exécuter avec une configuration d'exemple
./cpra --yaml mock-servers/test_10k.yaml

Starting CPRA Optimized Controller for 1M Monitors
Profiling server listening at http://localhost:6060/debug/pprof/
Loading monitors from mock-servers/test_10k.yaml...
Monitor loading completed in 1.2s
[INFO] Controller started successfully
[INFO] Pulse pipeline processing 10,000 monitors
[INFO] Worker pool scaled to 143 workers (target SLO: 100ms)

Cloner le dépôt :

git clone https://github.com/ziad/cpra.git
cd cpra

Télécharger les dépendances :
```
go mod download
```
Compiler l'application :
```
go build .
```
Vérifier l'installation :
```
./cpra --help
```

Construire l'image Docker :

docker build -f docker/Dockerfile -t cpra:latest .

Exécuter le conteneur :

docker run -it --rm \
  -v $(pwd)/my-monitors.yaml:/app/monitors.yaml \
  cpra:latest \
  ./cpra --yaml monitors.yaml

monitors:
  - name: "my-service-health-check"
    pulse_check:
      type: http
      interval: 30s
      timeout: 5s
      max_failures: 3
      config:
        method: GET
        url: http://my-service.example.com/health
        retries: 2
    intervention:
      action: docker
      config:
        container: my-service-container
        action: restart
    codes:
      red:
        dispatch: true
        notify: pagerduty
        config:
          url: https://events.pagerduty.com/v2/enqueue
      yellow:
        dispatch: true
        notify: log
        config:
          file: /var/log/cpra-alerts.log

package main

import (
    "cpra/internal/controller"
)

func main() {
    config := controller.DefaultConfig()

    // Mode débogage
    config.Debug = true

    // Paramètres du pool de workers (s'applique aux trois pipelines)
    config.WorkerConfig.MinWorkers = 10
    config.WorkerConfig.MaxWorkers = 500

    // Paramètres de la file d'attente
    config.QueueCapacity = 131072  // Doit être une puissance de 2

    // Réglage des performances
    config.BatchSize = 2000
    config.SizingServiceTime = 20 * time.Millisecond  // Durée moyenne d'un job
    config.SizingSLO = 100 * time.Millisecond         // Latence cible
    config.SizingHeadroomPct = 0.15                   // Marge de sécurité de 15 %

    ctrl := controller.NewController(config)
    // ... suite de l'initialisation
}

Option	Type	Défaut	Description
`--yaml`	string	`internal/loader/replicated_test.yaml`	Chemin vers le fichier YAML des moniteurs
`--config`	string	-	Chemin vers le fichier de configuration (optionnel)
`--debug`	bool	`false`	Activer la journalisation de niveau débogage
`--pprof`	bool	`true`	Activer le serveur de profilage pprof
`--pprof.addr`	string	`localhost:6060`	Adresse d'écoute du serveur pprof

# Exécuter avec journalisation de débogage
./cpra --yaml monitors.yaml --debug

# Exécuter avec un port pprof personnalisé
./cpra --yaml monitors.yaml --pprof.addr localhost:8080

# Désactiver le profilage
./cpra --yaml monitors.yaml --pprof=false

cpra

Populaires

À propos

Pourquoi CPRA ?

Fonctionnalités clés

🚀 Massive évolutivité

⚡ Haute performance

🔄 Remédiation automatisée

🧠 Dimensionnement intelligent

🏗️ Architecture orientée données

🔧 Prêt pour la production

Caractéristiques de performance

Architecture

Trois pipelines de traitement indépendants

Architecture de la file d'attente et du pool de workers

Démarrage rapide

Option 1 : Compiler et exécuter localement

Installation

Prérequis

Compilation à partir des sources

Déploiement Docker

Configuration

Configuration des moniteurs (YAML)

Configuration de l'application

Options en ligne de commande

Documentation

Guides complets

Ressources supplémentaires

Dépannage

Problèmes courants

Obtenir de l'aide

Contribuer

Licence

Remerciements