https://github.com/kaotoio/kaoto-operator
The Kubernetes operator that helps with running Kaoto in K8s clusters
https://github.com/kaotoio/kaoto-operator
apache-camel camel components connectors eip integration integration-flow kubernetes openshift
Last synced: 2 months ago
JSON representation
The Kubernetes operator that helps with running Kaoto in K8s clusters
- Host: GitHub
- URL: https://github.com/kaotoio/kaoto-operator
- Owner: KaotoIO
- License: apache-2.0
- Created: 2022-05-24T09:27:21.000Z (about 4 years ago)
- Default Branch: main
- Last Pushed: 2026-04-01T08:31:43.000Z (2 months ago)
- Last Synced: 2026-04-01T09:48:29.514Z (2 months ago)
- Topics: apache-camel, camel, components, connectors, eip, integration, integration-flow, kubernetes, openshift
- Language: Go
- Size: 635 KB
- Stars: 8
- Watchers: 6
- Forks: 13
- Open Issues: 4
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
Kaoto - The Integration Designer for Apache Camel
Documentation |
Workshops |
Contribute |
Chat
# Kaoto
Kaoto is a visual editor for Apache Camel integrations. It offers support in creating and editing Camel Routes, Kamelets and Pipes. Kaoto also has a built-in catalog with available Camel components, Enterprise Integration Patterns and Kamelets provided by the Apache Camel community.
Have a quick look at our online demo instance:
https://kaotoio.github.io/kaoto/
# Kaoto operator
The Kubernetes operator that manages Kaoto instance within the Kubernetes clusters.
# Kubernetes resources
Multiresource yaml files to deploy to plain kubernetes.
## Install Kaoto
### Plain Kubernetes (Minikube)
- Install and run a Minikube instance with `ingress` addon enabled.
- Install Kaoto from the multi-resource yaml
```kubectl apply -k https://github.com/KaotoIO/kaoto-operator/config/standalone```
- this will create `kaoto-system` namespace and install Kaoto Operator
- Create sample Kaoto CR
```kubectl apply -f https://raw.githubusercontent.com/KaotoIO/kaoto-operator/main/config/samples/designer.yaml```
- Waith the the ingrees admits the endoint
``` ➜ k get kaotos.designer.kaoto.io -w
NAME PHASE ENDPOINT
designer Ready http://192.168.49.2/designer/
```
- Kaoto should be accessible at `http:/$(minikube ip)/designer`
### Using the Operator
- Clone `kaoto-operator` repository
- Run `make deploy` which creates `kaoto-system` project and deploy all necessary resources
- Deploy Kaoto Custom Resource sample: `kubectl apply -f config/samples/designer.yaml`
## Local development
### Run Operator inside the cluster
1. Start minikube with ingress controller enabled: `minikube start --addons ingress`
2. Point docker to minikube internal registry: `eval $(minikube -p minikube docker-env)`
3. Build the Operator: `make build`
4. Build the Operator Image: `make docker-build`
5. Deploy Operator: `make deploy`
6. Create sample Kaoto CR: `kubectl apply -f config/samples/designer.yaml`
7. (Optional) Undeploy everything: `make undeploy`
### Run locally outside the cluster
1. Start minikube win ingress controller enabled: `minikube start --addons ingress`
2. Run operator locally: `make run/local`
3. Create sample Kaoto CR: `kubectl apply -f config/samples/designer.yaml`
4. (Optional) Undeploy Kaoto: `kubectl delete kaoto kaoto-demo`
## Build and Push to Custom Registry
To build and push the operator and bundle images to your own registry:
### Prerequisites
- Docker/Podman logged into your registry
- Operator SDK will be automatically installed via `make bundle`
### Build Process
1. **Set environment variables:**
```bash
export MY_REGISTRY="your-registry.com"
export MY_REPO="your-username/kaoto"
export IMAGE_TAG_BASE="${MY_REGISTRY}/${MY_REPO}-operator"
export VERSION="0.0.5"
```
2. **Generate bundle:**
```bash
IMG=${IMAGE_TAG_BASE}:latest VERSION=${VERSION} make bundle
```
3. **Build and push operator and bundle images:**
```bash
IMG=${IMAGE_TAG_BASE}:latest BUNDLE_IMG=${IMAGE_TAG_BASE}-bundle:v${VERSION} make docker-build docker-push bundle-build bundle-push
```
### Deploy Options
#### Option 1: Direct Deployment
```bash
IMG=${IMAGE_TAG_BASE}:latest make deploy
kubectl apply -f config/samples/designer.yaml
```
#### Option 2: Deploy via OLM Bundle
1. **Create namespace:**
```bash
kubectl create namespace kaoto-system
```
2. **Install OLM (if not present):**
```bash
./bin/operator-sdk olm install
```
3. **Deploy bundle using operator-sdk:**
```bash
./bin/operator-sdk run bundle ${IMAGE_TAG_BASE}-bundle:v${VERSION} --namespace kaoto-system
```
4. **Create Kaoto instance:**
```bash
kubectl apply -f config/samples/designer.yaml
```
5. **Cleanup bundle (when done):**
```bash
./bin/operator-sdk cleanup kaoto-operator
```