https://gocamel.tranchida.cloud/fr/index.htmlFramework d’Intégration d’Entreprise pour Go Bienvenue dans la documentation GoCamel. Liens Rapides Installation Démarrage Rapide Concepts Fondamentaux Composants Fonctionnalités Référence API Fonctionnalités Architecture de Routes et d’Endpoints - DSL fluide pour construire des flux d’intégration Gestion des Messages - Body et headers avec typage Enterprise Integration Patterns - Split, Aggregate, Multicast, Choice, et plus Simple Language - Expressions dynamiques avec ${body}, ${header.name} et fonctions Composants Multiples - HTTP, File, FTP, SFTP, SMB, Mail, SQL, Telegram, OpenAI, Cron, et plus Sécurité Intégrée - Protection path traversal, prévention injection SQL, assainissement des entrées Note de Sécurité GoCamel inclut des utilitaires de sécurité intégrés (security.go) pour se protéger contre les vulnérabilités courantes :Hugofrhttps://gocamel.tranchida.cloud/fr/features/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/features/index.htmlCapacité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 :https://gocamel.tranchida.cloud/fr/quickstart/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/quickstart/index.htmlHello World package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() route := ctx.CreateRouteBuilder(). From("timer:tick?period=5s"). SetBody("Hello World"). Log("${body}"). Build() ctx.AddRoute(route) ctx.Start() select {} } Traitement de Fichiers route := ctx.CreateRouteBuilder(). From("file://input?delete=true"). Log("Traitement: ${body}"). To("file://output"). Build() Endpoint HTTP route := ctx.CreateRouteBuilder(). From("http://localhost:8080/hello"). SetBody("Bonjour ${header.name}!"). Build()https://gocamel.tranchida.cloud/fr/concepts/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/concepts/index.htmlMessage L’unité fondamentale d’échange contenant: Body: Le contenu du message (n’importe quel type) Headers: Métadonnées clé-valeur (map[string]any) Les messages fournissent des accesseurs typés pour plus de commodité : body, _ := msg.GetBodyAsString() count, _ := msg.GetHeaderAsInt("X-Count") Exchange Conteneur pour les messages traversant une route:https://gocamel.tranchida.cloud/fr/architecture/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/architecture/index.htmlVue d’ensemble GoCamel suit une architecture modulaire inspirée d’Apache Camel mais adaptée aux idiomes Go. graph LR subgraph "Core Layer" A[CamelContext] --> B[Registry] A --> C[RouteController] A --> D[TypeConverter] end subgraph "Integration Layer" E[Components] --> F[Endpoints] F --> G[Consumers] F --> H[Producers] end subgraph "DSL Layer" I[RouteBuilder] --> J[Processors] J --> K[EIP Patterns] end C --> E K --> G K --> H Couches 1. Core Layer Le cœur de GoCamel, indépendant des transports:https://gocamel.tranchida.cloud/fr/components/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/components/index.htmlVue d’ensemble Référence complète de tous les composants GoCamel disponibles. Les composants fournissent la connectivité à divers systèmes et services. Composants Principaux Direct Routage synchrone en mémoire entre routes dans le même contexte.https://gocamel.tranchida.cloud/fr/eip/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/eip/index.htmlLes patterns d’intégration enterprise implémentés dans GoCamel. Split Divise un message en plusieurs parties traitées individuellement. builder.From("direct:start"). Split(func(e *gocamel.Exchange) (any, error) { body := e.GetIn().GetBody().(string) return strings.Split(body, ","), nil }). Log("Partie: ${body}"). To("direct:process"). End() Propriétés de l’Exchange: CamelSplitIndex — Index actuel (0-based) CamelSplitSize — Nombre total de parties CamelSplitComplete — Dernière partie ? Ces propriétés sont limitées à la branche Elles décrivent une partie, pas le message entier, et sont retirées au moment où le résultat agrégé est publié sur l’exchange parent. Un processeur placé après le Split ne voit donc pas un CamelSplitComplete=true résiduel de la dernière partie, et un Split imbriqué n’écrase pas la comptabilité de celui qui l’englobe. La même règle s’applique à CamelMulticast*, CamelRecipientList* et CamelRoutingSlip*.https://gocamel.tranchida.cloud/fr/simple-language/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/simple-language/index.htmlVue d’Ensemble Simple Language est un langage d’expressions dynamiques inspiré d’Apache Camel. Il permet d’insérer des placeholders d’expressions dans des chaînes pour le routage dynamique, la transformation de messages et le traitement conditionnel. Syntaxe Les expressions sont encadrées par ${...} :https://gocamel.tranchida.cloud/fr/installation/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/installation/index.htmlPrérequis Go 1.21 ou ultérieur Projet Go avec modules (go.mod) Installation go get gitlab.com/tranchida/gocamel Ou ajoutez à go.mod: require gitlab.com/tranchida/gocamel v0.1.0 Puis: go mod tidy Vérification package main import ( "fmt" "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() fmt.Println("Contexte GoCamel créé avec succès!") } Exécutez:https://gocamel.tranchida.cloud/fr/configuration/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/configuration/index.htmlAperçu GoCamel supporte plusieurs stratégies de configuration pour les credentials, les endpoints et les paramètres des composants. Sources de credentials gocamel.GetConfigValue(url, key) est le point d’entrée unique utilisé par tous les composants pour résoudre une valeur de configuration. Il consulte quatre sources dans l’ordre suivant — la première valeur non vide gagne :https://gocamel.tranchida.cloud/fr/examples/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/examples/index.htmlPrésentation Collection d’exemples pratiques démontrant les fonctionnalités de GoCamel. Hello World package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() route := ctx.CreateRouteBuilder(). From("timer:tick?period=5s"). SetBody("Hello GoCamel!"). Log("${body}"). Build() ctx.AddRoute(route) ctx.Start() select {} } Intégration OpenAI package main import ( "fmt" "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() ctx.AddComponent("openai", gocamel.NewOpenAIComponent()) // Utilisation manuelle du producer endpoint, _ := ctx.CreateEndpoint("openai:chat?model=gpt-3.5-turbo") producer, _ := endpoint.CreateProducer() exchange := gocamel.NewExchange(nil) exchange.GetIn().SetBody("Explique l'intégration en Go") producer.Send(exchange) fmt.Println(exchange.GetOut().GetBody()) } Traitement de fichiers Fichier vers Fichier package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() // Déplacer les fichiers de input vers output route := ctx.CreateRouteBuilder(). From("file://input?delete=true"). Log("Traitement: ${header.CamelFileName}"). To("file://output"). Build() ctx.AddRoute(route) ctx.Start() select {} } Fichier vers Fichier avec transformation route := ctx.CreateRouteBuilder(). From("file://input?include=*.txt&delete=true"). ProcessFunc(func(e *gocamel.Exchange) error { content := e.GetIn().GetBody().(string) // Transformer le contenu e.GetOut().SetBody(strings.ToUpper(content)) return nil }). SetHeader("CamelFileName", "${header.CamelFileName}.processed"). To("file://output"). Build() Endpoints HTTP Serveur Echo HTTP package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() ctx.AddComponent("http", gocamel.NewHTTPComponent()) route := ctx.CreateRouteBuilder(). From("http://localhost:8080/hello"). SetBody("Hello ${header.name}!"). Build() ctx.AddRoute(route) // API de gestion mgmt := gocamel.NewManagementServer(ctx) mgmt.Start(":8081") ctx.Start() select {} } Consommateur HTTP avec traitement route := ctx.CreateRouteBuilder(). From("http://localhost:8080/api/process"). Choice(). When("${header.Content-Type} == 'application/json'"). ProcessFunc(func(e *gocamel.Exchange) error { // Traiter le JSON e.GetOut().SetBody(`{"status":"ok"}`) e.GetOut().SetHeader("Content-Type", "application/json") return nil }). Otherwise(). SetBody("Type de contenu non supporté"). EndChoice(). Build() Intégration FTP Téléchargement FTP package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() ctx.AddComponent("ftp", gocamel.NewFTPComponent()) // Télécharger depuis FTP route := ctx.CreateRouteBuilder(). From("ftp://ftp.example.com/incoming?delete=true&passiveMode=true"). Log("Téléchargé: ${header.CamelFileName}"). To("file://downloads"). Build() ctx.AddRoute(route) ctx.Start() select {} } SFTP avec authentification par clé route := ctx.CreateRouteBuilder(). From("sftp://secure.example.com/data?username=admin"). SetHeader("CamelFileName", "${header.CamelFileName}.secure"). To("file://secure-downloads"). Build() Routage basé sur le contenu Routage par choix (Choice) package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() route := ctx.CreateRouteBuilder(). From("direct:start"). Choice(). When("${header.priority == 'high'}"). SimpleSetBody("🚨 HIGH PRIORITY: ${body}"). SetHeader("X-Urgent", "true"). To("direct:urgent-queue"). When("${header.priority == 'medium'}"). SimpleSetBody("⚠️ MEDIUM: ${body}"). To("direct:normal-queue"). When("${body['count'] > 100}"). SimpleSetBody("📦 LARGE BATCH: ${body['count']} items"). To("direct:batch-queue"). Otherwise(). SimpleSetBody("📄 LOW: ${body}"). To("direct:low-queue"). EndChoice(). Build() ctx.AddRoute(route) ctx.Start() select {} } Langage Simple Transformation avec expressions Simple package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() route := ctx.CreateRouteBuilder(). From("direct:start"). SimpleSetBody("📨 Message: ${body}"). SimpleSetHeader("X-Timestamp", "${date:now}"). SimpleSetHeader("X-Request-ID", "${uuid}"). Log("Traitement à ${header.X-Timestamp}"). To("direct:output"). Build() ctx.AddRoute(route) ctx.Start() select {} } Traitement JSON avec Simple Language package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() // Body attendu: {"user": {"name": "John", "email": "john@example.com"}} route := ctx.CreateRouteBuilder(). From("direct:api"). Choice(). When("${header.Content-Type == 'application/json'}"). SimpleSetHeader("X-User-Name", "${body['user']['name']}"). SimpleSetHeader("X-User-Email", "${body['user']['email']}"). SimpleSetBody("👤 User ${body['user']['name']} registered"). Log("📝 Enregistrement utilisateur: ${body}"). To("direct:process-json"). When("${header.Content-Type == 'text/plain'}"). SimpleSetBody("📝 Message reçu: ${body}"). To("direct:process-text"). Otherwise(). SimpleSetBody("❌ Type non supporté: ${body}"). To("direct:error"). EndChoice(). Build() ctx.AddRoute(route) ctx.Start() select {} } Null-safe et Collections package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() // Body: [{"name": "A"}, {"name": "B"}, {"name": "C"}] route := ctx.CreateRouteBuilder(). From("direct:start"). Log("Premier: ${body[0]['name']}"). Log("Dernier: ${body[last]['name']}"). Log("User (null-safe): ${body?.user?.name}"). SimpleSetHeader("X-First-Item", "${body[0]['name']}"). SimpleSetHeader("X-Last-Item", "${body[last]['name']}"). To("direct:output"). Build() ctx.AddRoute(route) ctx.Start() select {} } Découpage de messages Traitement CSV route := ctx.CreateRouteBuilder(). From("file://csv-input"). Split(func(e *gocamel.Exchange) (any, error) { body := e.GetIn().GetBody().(string) // Découper le CSV en lignes return strings.Split(body, "\n"), nil }). Log("Traitement ligne ${in.header.CamelSplitIndex}/${in.header.CamelSplitSize}"). ProcessFunc(func(e *gocamel.Exchange) error { // Traiter chaque ligne return nil }). To("direct:processed"). End(). // Fin du split Log("Toutes les lignes traitées"). Build() Agrégation Split & Aggregate package main import ( "strings" "gitlab.com/tranchida/gocamel" ) type StringConcatStrategy struct{} func (s *StringConcatStrategy) Aggregate( oldExchange, newExchange *gocamel.Exchange, ) *gocamel.Exchange { if oldExchange == nil { return newExchange } oldBody := oldExchange.GetOut().GetBody().(string) newBody := newExchange.GetOut().GetBody().(string) oldExchange.GetOut().SetBody(oldBody + newBody) return oldExchange } func main() { ctx := gocamel.NewCamelContext() strategy := &StringConcatStrategy{} repo := gocamel.NewMemoryAggregationRepository() route := ctx.CreateRouteBuilder(). From("direct:start"). Split(func(e *gocamel.Exchange) (any, error) { body := e.GetIn().GetBody().(string) return strings.Split(body, ","), nil }). To("direct:transform"). End(). Aggregate(gocamel.NewAggregator( func(e *gocamel.Exchange) string { return "group" }, strategy, repo, ).SetCompletionSize(3)). Build() ctx.AddRoute(route) ctx.Start() select {} } Agrégation de commandes type OrderAggregationStrategy struct{} func (s *OrderAggregationStrategy) Aggregate( oldEx, newEx *gocamel.Exchange, ) *gocamel.Exchange { if oldEx == nil { return newEx } // Combiner les commandes avec le même ID old := oldEx.GetIn().GetBody() new := newEx.GetIn().GetBody() combined := fmt.Sprintf("%s + %s", old, new) oldEx.GetIn().SetBody(combined) return oldEx } // Utilisation strategy := &OrderAggregationStrategy{} repo := gocamel.NewMemoryAggregationRepository() aggregator := gocamel.NewAggregator("${header.orderId}", strategy, repo). SetCompletionSize(3). SetCompletionTimeout(30000) route := ctx.CreateRouteBuilder(). From("direct:line-items"). Aggregate(aggregator). Log("Commande complète: ${body}"). To("direct:fulfillment"). End(). Build() Multicast Traitement parallèle route := ctx.CreateRouteBuilder(). From("direct:incoming"). Multicast().ParallelProcessing(). To("direct:archive"). To("direct:audit"). To("direct:cache"). End(). Log("Multicast terminé"). Build() Tâches planifiées Timer package main import ( "gitlab.com/tranchida/gocamel" ) func main() { ctx := gocamel.NewCamelContext() // Exécuter toutes les 5 secondes route := ctx.CreateRouteBuilder(). From("timer:tick?period=5s"). Log("Tick à ${date:now}"). Build() ctx.AddRoute(route) ctx.Start() select {} } Expression Cron ctx.AddComponent("cron", gocamel.NewCronComponent()) // Exécuter chaque minute route := ctx.CreateRouteBuilder(). From("cron://group/minutely?cron=0+*+*+*+*+*"). Log("Déclencheur cron à ${header.fireTime}"). Build() Intégration de bases de données Requête SQL import ( "database/sql" _ "github.com/mattn/go-sqlite3" "gitlab.com/tranchida/gocamel" ) func main() { db, _ := sql.Open("sqlite3", "app.db") defer db.Close() ctx := gocamel.NewCamelContext() sqlComp := gocamel.NewSQLComponent() sqlComp.RegisterDataSource("appdb", db) ctx.AddComponent("sql", sqlComp) route := ctx.CreateRouteBuilder(). From("timer:poll?period=60s"). To("sql://appdb?query=SELECT+*+FROM+events+WHERE+processed=false"). Split(). Log("Événement: ${body}"). To("direct:process-event"). End(). Build() ctx.AddRoute(route) ctx.Start() select {} } Insertion SQL route := ctx.CreateRouteBuilder(). From("direct:new-user"). SetHeader("CamelSqlParameters", []any{ "${header.name}", "${header.email}", }). To("sql://appdb?query=INSERT+INTO+users(name,email)+VALUES(?,?)"). Log("Utilisateur créé, lignes affectées: ${header.CamelSqlRowCount}"). Build() Bot Telegram package main import ( "gitlab.com/tranchida/gocamel" ) func main() { // Définir la variable d'environnement TELEGRAM_AUTHORIZATIONTOKEN ctx := gocamel.NewCamelContext() ctx.AddComponent("telegram", gocamel.NewTelegramComponent()) route := ctx.CreateRouteBuilder(). From("telegram:bots"). Log("Message de ${header.chatId}: ${body}"). SetBody("Echo: ${body}"). To("telegram:bots"). Build() ctx.AddRoute(route) ctx.Start() select {} } Traitement de templates Génération de messages formatés avec templates Go natifs (inspiré du composant Velocity d’Apache Camel).https://gocamel.tranchida.cloud/fr/reference/index.htmlMon, 01 Jan 0001 00:00:00 +0000https://gocamel.tranchida.cloud/fr/reference/index.htmlCamelContext func NewCamelContext() *CamelContext Méthodes Méthode Description AddRoute(route *Route) Enregistrer une route AddComponent(name, component) Enregistrer un composant CreateEndpoint(uri) Créer un endpoint Start() Démarrer toutes les routes Stop() Arrêter toutes les routes CreateRouteBuilder() Créer un route builder RouteBuilder Source Méthode Description From(uri) Définir l’endpoint source Traitement Méthode Description To(uri) Envoyer vers endpoint ToD(uri) Destination dynamique Process(p) Processeur personnalisé ProcessFunc(fn) Processeur fonction ProcessRef(name) Référence depuis le registre Log(msg) Log message statique LogSimple(expr) Log expression dynamique Accesseurs Message / Exchange Méthodes communes sur Message et relayées sur Exchange (accès au message In) :