Fonctionnalités

Capacités Principales

Framework d’Intégration d’Entreprise

GoCamel est un framework d’intégration léger et natif à Go, inspiré d’Apache Camel. Il fournit :

Architecture Modulaire — Conception basée sur les composants
Sécurité des Types — Sécurité de typage complète en Go
Concurrence — Construit sur les goroutines de Go
Zéro Dépendance Externe — Pilotes de base de données optionnels uniquement

Modèle de Route et d’Endpoint

context := gocamel.NewCamelContext()

route := context.CreateRouteBuilder().
    From("direct:input").      // Endpoint consommateur
    Process(myProcessor).      // Processeur personnalisé
    To("direct:output").       // Endpoint producteur
    Build()

context.AddRoute(route)
context.Start()

Modèle de Message

┌───────────────────────────────────────────────┐
│                    Exchange                     │
│  ┌─────────────────────────────────────────┐  │
│  │               Propriétés                │  │
│  │  correlationId: "abc-123"              │  │
│  │  routeId: "route-1"                    │  │
│  └─────────────────────────────────────────┘  │
│  ┌─────────────────────────────────────────┐  │
│  │                  In                     │  │
│  │  Headers: map[string]any                │  │
│  │    Content-Type: "application/json"    │  │
│  │                                        │  │
│  │  Body: any                              │  │
│  │    {"name": "John", "age": 30}         │  │
│  └─────────────────────────────────────────┘  │
│  ┌─────────────────────────────────────────┐  │
│  │                  Out                    │  │
│  │  Headers: map[string]any                │  │
│  │    X-Processed: "true"                 │  │
│  │                                        │  │
│  │  Body: any                              │  │
│  │    {"name": "John", "age": 31}         │  │
│  └─────────────────────────────────────────┘  │
└───────────────────────────────────────────────┘

Simple Language

Langage d’expressions dynamique pour le routage et les transformations :

// Accès aux headers
SimpleSetHeader("X-ID", "${uuid}")

// Manipulation du body
SimpleSetBody("Bonjour ${body}")

// Routage conditionnel
When("${header.priority} == 'high'")

// Accès null-safe
When("${body?.user?.name} != ''")

// Date/heure
When("${date:now:yyyy-MM-dd}")

Écosystème de Composants

Noyau (Intégré)

Direct — Routage en mémoire
Timer — Exécution planifiée

Sécurité

Validation des Chemins — Protection contre les attaques de traversée de répertoire
Prévention des Injections SQL — Liaison de paramètres ; la requête est une configuration de confiance, jamais interpolée avec les données du message
Assainissement des Entrées — Suppression des octets nuls et caractères de contrôle
Opérations de Chemins Sécurisées — Vérification des limites pour les opérations sur fichiers, avec résolution des liens symboliques pour qu’un lien placé dans le répertoire de base ne puisse pas s’en échapper
Aucune Réflexion d’Identifiants — le consumer HTTP ne renvoie jamais les headers de la requête entrante dans sa réponse
Lectures de Corps Bornées — les corps de requête et de réponse HTTP sont limités en taille (32 Mio par défaut) pour prévenir l’épuisement mémoire
Confinement des Panics — un processeur qui panique fait échouer son exchange, pas le processus

Transfert de Fichiers

File — Système de fichiers local
FTP/FTPS — File Transfer Protocol
SFTP — Transfert de fichiers SSH
SMB — Partages Windows

Réseau

HTTP — Serveur/client HTTP

Messagerie

Telegram — Bot API
Mail — SMTP/IMAP/POP3

IA

OpenAI — Modèles GPT

Base de Données

SQL — Exécution de requêtes
SQL-Stored — Procédures stockées

Planification

Cron — Expressions cron

Transformation

XSLT — Transformation XML
XSD — Validation de schéma
Template — Templates Go
Exec — Exécution de commandes

Enterprise Integration Patterns

Pattern	Description	Statut
Choice	Routeur basé sur le contenu	✅
Split	Découpage de message	✅
Aggregate	Agrégateur de messages	✅
Multicast	Destinations multiples	✅
Filter	Filtrage conditionnel	✅
Transform	Transformation de message	✅
ToD	Endpoint dynamique	✅
Stop	Arrêt du routage	✅
Pipeline	Branches séquentielles	✅
SetHeader	Manipulation de headers	✅
SetProperty	Manipulation de propriétés	✅

API REST de Management

Surveiller et contrôler les routes via HTTP :

mgmt := gocamel.NewManagementServer(context)
mgmt.Start(":8081")

Endpoints :

GET /routes — Lister les routes
GET /routes/{id} — Détails d’une route
POST /routes/{id}/start — Démarrer une route
POST /routes/{id}/stop — Arrêter une route
GET /health — Vérification de santé

Configuration

Plusieurs sources d’identification :

Directement dans l’URI — ftp://user:pass@host
Paramètres de requête — ?username=user&password=pass
Variables d’environnement — FTP_PASSWORD (recommandé)

builder.From("ftp://host?username=${env:FTP_USER}")

Support de Test

import "testing"

func TestRoute(t *testing.T) {
    ctx := gocamel.NewCamelContext()

    // Construire la route de test
    route := ctx.CreateRouteBuilder().
        From("direct:test").
        SetBody("traité").
        To("direct:result").
        Build()

    ctx.AddRoute(route)
    ctx.Start()
    defer ctx.Stop()

    // Envoyer le message de test
    exchange := gocamel.NewExchange(context.Background())
    exchange.GetIn().SetBody("entrée")

    endpoint, _ := ctx.CreateEndpoint("direct:test")
    producer, _ := endpoint.CreateProducer()
    producer.Send(exchange)

    // Vérifier
    result := exchange.GetOut().GetBody()
    if result != "traité" {
        t.Fail()
    }
}

Performance

Allocations minimales — Pooling d’objets
Efficacité des goroutines — Threads légers
Pas de réflexion — Opérations type-safe
Initialisation paresseuse — Chargement à la demande

Extensibilité

// Composant personnalisé
type CustomComponent struct{}

func (c *CustomComponent) CreateEndpoint(uri string) (gocamel.Endpoint, error) {
    return &CustomEndpoint{}, nil
}

type CustomEndpoint struct{}

func (e *CustomEndpoint) CreateProducer() (gocamel.Producer, error) {
    return &CustomProducer{}, nil
}

func (e *CustomEndpoint) CreateConsumer(p gocamel.Processor) (gocamel.Consumer, error) {
    return &CustomConsumer{}, nil
}

// Enregistrer
ctx.AddComponent("custom", &CustomComponent{})

Bonnes Pratiques

Utiliser les variables d’environnement pour les identifiants
Définir des IDs de route pour la gestion
Implémenter la gestion des erreurs dans les processeurs
Utiliser un stockage approprié pour les agrégations
Configurer des timeouts pour les systèmes externes
Activer l’API REST pour la surveillance en production