https://github.com/codice/keip
Kubernetes Enterprise Integration Patterns
https://github.com/codice/keip
integration kubernetes kubernetes-operator
Last synced: about 2 months ago
JSON representation
Kubernetes Enterprise Integration Patterns
- Host: GitHub
- URL: https://github.com/codice/keip
- Owner: codice
- License: apache-2.0
- Created: 2023-11-15T18:23:21.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2025-10-02T22:34:28.000Z (7 months ago)
- Last Synced: 2025-10-03T00:23:10.718Z (7 months ago)
- Topics: integration, kubernetes, kubernetes-operator
- Language: Python
- Homepage:
- Size: 277 KB
- Stars: 0
- Watchers: 9
- Forks: 6
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
Awesome Lists containing this project
README
# keip - Kubernetes Enterprise Integration Patterns
**The communication backbone for microservices, AI toolchains, and enterprise integration on Kubernetes.**
## What is keip?
keip (Kubernetes Enterprise Integration Patterns) is a Kubernetes operator that serves as the communication backbone for modern distributed systems. Whether you're orchestrating microservices, building AI toolchains, or handling traditional enterprise integration, keip transforms complex data flow challenges into simple, declarative configurations.
Instead of writing, compiling, and deploying Java applications for service communication and data integration, define Spring Integration routes as Kubernetes resources and let keip handle the rest.
### The Problems It Solves
Modern distributed systems often need to:
- **Microservices Communication**: Orchestrate complex service-to-service interactions, event streaming, and API workflows
- **AI Toolchain Coordination**: Connect AI models, data pipelines, feature stores, and inference engines in sophisticated workflows
- **Enterprise Integration**: Move data between different systems (databases, message queues, APIs, files)
- **Data Transformation**: Convert formats (JSON to XML, CSV to database records, etc.) and enrich data in transit
- **Smart Routing**: Route messages based on content, rules, or dynamic conditions
- **Resilient Operations**: Handle errors, retries, and circuit breaking gracefully
- **Dynamic Scaling**: Scale integration workloads based on demand
- **Legacy Systems**: Bridge legacy systems with modern cloud applications and microservices
Traditionally, this requires:
- Writing Java code with Spring Integration
- Managing application lifecycle and deployments
- Handling scaling and resilience manually
- Complex CI/CD pipelines for every integration change
### The keip Solution
With keip, you define your integration logic in XML configuration and deploy it as a Kubernetes resource. The operator automatically:
- Creates and manages the underlying Spring Boot application with Spring Integration
- Provides access to the entire Spring ecosystem (hundreds of connectors, components, and enterprise patterns)
- Handles Kubernetes deployment, scaling, and lifecycle
- Provides cloud-native resilience and observability
- Enables runtime route updates without code compilation
## Key Features
- **Kubernetes Native**: Fully integrates with Kubernetes using custom resources and scales with cluster capabilities
- **Spring Ecosystem Powered**: Built on Spring Boot and Spring Integration with access to 300+ connectors and enterprise patterns
- **No Code Compilation**: Define integration routes in XML and deploy instantly
- **Auto-Scaling**: Leverages Kubernetes scaling capabilities for integration workloads
- **Runtime Flexibility**: Update integration routes without rebuilding applications
- **Enterprise Ready**: Battle-tested Spring components with comprehensive error handling and monitoring
- **Cloud-Native Observability**: Native Kubernetes monitoring and logging support
## Quick Start
### Prerequisites
- Kubernetes cluster (v1.24+ recommended)
- `kubectl` installed and configured to interact with your cluster
### Installation
Choose one of the following methods:
**Option A — Static manifest (recommended):**
```bash
kubectl apply -f https://github.com/codice/keip/releases/latest/download/install.yaml
```
**Option B — Remote kustomize:**
```bash
kubectl apply -k 'https://github.com/codice/keip/operator?ref=main'
```
**Option C — From source (development):**
```bash
git clone https://github.com/codice/keip.git && cd keip/operator
make deploy
```
All methods create the `keip` and `metacontroller` namespaces and deploy the necessary components.
**Verify installation:**
```bash
# Check metacontroller pod
kubectl -n metacontroller get po
# Check keip webhook pod
kubectl -n keip get po
```
### Your First Integration Route
Create a simple integration that prints a message every 5 seconds:
1. **Create the integration configuration:**
```bash
cat <
YAMEOF
```
2. **Deploy the integration route:**
```bash
cat <