You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@camel.apache.org by GitBox <gi...@apache.org> on 2018/09/21 06:57:17 UTC
[GitHub] nicolaferraro closed pull request #109: Add asciidoc documentation
with sub-documents and some badges
nicolaferraro closed pull request #109: Add asciidoc documentation with sub-documents and some badges
URL: https://github.com/apache/camel-k/pull/109
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/README.adoc b/README.adoc
new file mode 100644
index 0000000..c77302d
--- /dev/null
+++ b/README.adoc
@@ -0,0 +1,169 @@
+Apache Camel K
+==============
+
+image:https://goreportcard.com/badge/github.com/apache/camel-k["Go Report Card", link="https://goreportcard.com/report/github.com/apache/camel-k"]
+image:https://godoc.org/github.com/apache/camel-k?status.svg["GoDoc", link="https://godoc.org/github.com/apache/camel-k"]
+image:https://img.shields.io/github/license/openshift/origin.svg?maxAge=2592000["Licensed under Apache License version 2.0", link="https://www.apache.org/licenses/LICENSE-2.0"]
+
+Apache Camel K (a.k.a. Kamel) is a lightweight integration framework built from Apache Camel that runs natively on Kubernetes and is specifically designed for serverless and microservice architectures.
+
+[[getting-started]]
+== Getting Started
+
+Camel K allows to run integrations directly on a Kubernetes or Openshift cluster.
+To use it, you need to be connected to a cloud environment or to a local cluster created for development purposes.
+
+If you need help on how to create a local development environment based on *Minishift* or *Minikube* (Minikube will be supported soon, stay tuned!), you can follow the link:/docs/cluster-setup.adoc[local cluster setup guide].
+
+[[installation]]
+=== Installation
+
+To start using Camel K you need the **"kamel"** binary, that can be used to both configure the cluster and run integrations.
+Look into the https://github.com/apache/camel-k/releases[release page] for latest version of the `kamel` tool.
+
+If you want to contribute, you can also **build it from source!** Refer to the link:/docs/developers.adoc[developer's guide]
+for information on how to do it.
+
+Once you have the "kamel" binary, log into your cluster using the standard "oc" (Openshift) or "kubectl" (Kubernetes) client tool and execute the following command to install Camel K:
+
+```
+kamel install
+```
+
+This will configure the cluster with the Camel K custom resource definitions and install the operator on the current namespace.
+
+IMPORTANT: Custom Resource Definitions (CRD) are cluster-wide objects and you need admin rights to install them. Fortunately this
+operation can be done *once per cluster*. So, if the `kamel install` operation fails, you'll be asked to repeat it when logged as admin.
+For Minishift, this means executing `oc login -u system:admin` then `kamel install --cluster-setup` only for first-time installation.
+
+=== Running a Integration
+
+After the initial setup, you can run a Camel integration on the cluster by executing:
+
+```
+kamel run runtime/examples/Sample.java
+```
+
+A "Sample.java" file is included in the link:/runtime/examples[/runtime/examples] folder of this repository. You can change the content of the file and execute the command again to see the changes.
+
+=== Running Integrations in "Dev" Mode for Fast Feedback
+
+If you want to iterate quickly on a integration to have fast feedback on the code you're writing, you can use run it in **"dev" mode**:
+
+```
+kamel run runtime/examples/Sample.java --dev
+```
+
+The `--dev` flag deploys immediately the integration and shows the integration logs in the console. You can then change the code and see
+the **changes automatically applied (instantly)** to the remote integration pod.
+
+The console follows automatically all redeploys of the integration.
+
+Here's an example of the output:
+
+```
+[nferraro@localhost camel-k]$ kamel run runtime/examples/Sample.java --dev
+integration "sample" created
+integration "sample" in phase Building
+integration "sample" in phase Deploying
+integration "sample" in phase Running
+[1] Monitoring pod sample-776db787c4-zjhfr[1] Starting the Java application using /opt/run-java/run-java.sh ...
+[1] exec java -javaagent:/opt/prometheus/jmx_prometheus_javaagent.jar=9779:/opt/prometheus/prometheus-config.yml -XX:+UseParallelGC -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -XX:MinHeapFreeRatio=20 -XX:MaxHeapFreeRatio=40 -XX:+ExitOnOutOfMemoryError -cp .:/deployments/* org.apache.camel.k.jvm.Application
+[1] [INFO ] 2018-09-20 21:24:35.953 [main] Application - Routes: file:/etc/camel/conf/Sample.java
+[1] [INFO ] 2018-09-20 21:24:35.955 [main] Application - Language: java
+[1] [INFO ] 2018-09-20 21:24:35.956 [main] Application - Locations: file:/etc/camel/conf/application.properties
+[1] [INFO ] 2018-09-20 21:24:36.506 [main] DefaultCamelContext - Apache Camel 2.22.1 (CamelContext: camel-1) is starting
+[1] [INFO ] 2018-09-20 21:24:36.578 [main] ManagedManagementStrategy - JMX is enabled
+[1] [INFO ] 2018-09-20 21:24:36.680 [main] DefaultTypeConverter - Type converters loaded (core: 195, classpath: 0)
+[1] [INFO ] 2018-09-20 21:24:36.777 [main] DefaultCamelContext - StreamCaching is not in use. If using streams then its recommended to enable stream caching. See more details at http://camel.apache.org/stream-caching.html
+[1] [INFO ] 2018-09-20 21:24:36.817 [main] DefaultCamelContext - Route: route1 started and consuming from: timer://tick
+[1] [INFO ] 2018-09-20 21:24:36.818 [main] DefaultCamelContext - Total 1 routes, of which 1 are started
+[1] [INFO ] 2018-09-20 21:24:36.820 [main] DefaultCamelContext - Apache Camel 2.22.1 (CamelContext: camel-1) started in 0.314 seconds
+
+```
+
+=== Dependencies and Component Resolution
+
+Camel components used in a integration are automatically resolved. For example, take the following integration:
+
+```
+from("imap://admin@myserver.com")
+ .to("seda:output")
+```
+
+Since the integration is using the **"imap:" prefix**, Camel K is able to **automatically add the "camel-mail" component** to the list of required dependencies.
+This will be transparent to the user, that will just see the integration running.
+
+Automatic resolution is also a nice feature in `--dev` mode, because you are allowed to add all components you need without exiting the dev loop.
+
+You can also use the `-d` flag to pass additional explicit dependencies to the Camel client tool:
+
+```
+kamel run -d mvn:com.google.guava:guava:26.0-jre -d camel-mina2 Integration.java
+```
+
+=== Not Just Java
+
+Camel K supports multiple languages for writing integrations:
+
+.Languages
+[options="header"]
+|=======================
+| Language | Description
+| Java | Both integrations in source `.java` files or compiled `.class` file can be run.
+| XML | Integrations written in plain XML DSL are supported (Spring XML or Blueprint not supported).
+| Groovy | Groovy `.groovy` files are supported (experimental).
+| JavaScript | JavaScript `.js` files are supported (experimental).
+|=======================
+
+Integrations written in different languages are provided in the link:/runtime/examples[examples] directory.
+
+An example of integration written in JavaScript is the link:/runtime/examples/dns.js[/runtime/examples/dns.js] integration.
+Here's the content:
+
+```
+// Lookup every second the 'www.google.com' domain name and log the output
+from('timer:dns?period=1s')
+ .routeId('dns')
+ .setHeader('dns.domain')
+ .constant('www.google.com')
+ .to('dns:ip')
+ .to('log:dns');
+```
+
+To run it, you need just to execute:
+
+```
+kamel run runtime/examples/dns.js
+```
+
+=== Monitoring the Status
+
+Camel K integrations follow a lifecycle composed of several steps before getting into the `Running` state.
+You can check the status of all integrations by executing the following command:
+
+```
+kamel get
+```
+
+[[contributing]]
+== Contributing
+
+We love contributions and we want to make Camel K great!
+
+Contributing is easy, just take a look at our link:/docs/developers.adoc[developer's guide].
+
+[[uninstalling]]
+== Uninstalling
+
+If you really need to, it is possible to completely uninstall Camel K from OpenShift or Kubernetes with the following command, using the "oc" or "kubectl" tool:
+
+```
+# kubectl on plain Kubernetes
+oc delete all,pvc,configmap,rolebindings,clusterrolebindings,secrets,sa,roles,clusterroles,crd -l 'app=camel-k'
+```
+
+[[licensing]]
+== Licensing
+
+This software is licensed under the terms you may find in the file named LICENSE in this directory.
\ No newline at end of file
diff --git a/README.md b/README.md
deleted file mode 100644
index 4bbdf09..0000000
--- a/README.md
+++ /dev/null
@@ -1,229 +0,0 @@
-# Apache Camel K
-
-Apache Camel K (a.k.a. Kamel) is a lightweight integration framework built from Apache Camel that runs natively on Kubernetes and is specifically designed for serverless and microservice architectures.
-
-## Getting Started
-
-Camel K allows to run integrations on a Kubernetes or Openshift cluster. If you don't have a cloud instance of Kubernetes or Openshift, you can create a development cluster following the instructions below.
-
-### Creating a Development Cluster
-There are various options for creating a development cluster:
-
-**Minishift**
-
-You can run Camel K integrations on Openshift using the Minishift cluster creation tool.
-Follow the instructions in the [getting started guide](https://github.com/minishift/minishift#getting-started) for the installation.
-
-After installing the `minishift` binary, you need to enable the `admin-user` addon:
-
-```
-minishift addons enable admin-user
-```
-
-Then you can start the cluster with:
-
-```
-minishift start
-```
-
-**Minikube**
-
-Minikube and Kubernetes are not yet supported (but support is coming soon).
-
-### Setting Up the Cluster
-
-To start using Camel K you need the **"kamel"** binary, that can be used to both configure the cluster and run integrations.
-Look into the [release page](https://github.com/apache/camel-k/releases) for latest version of the `kamel` tool.
-
-If you wanto to contribute, you can also **build it from source!** Refer to the [contributing guide](#contributing)
-for information on how to do it.
-
-Once you have the "kamel" binary, log into your cluster using the "oc" or "kubectl" tool and execute the following command to install Camel K:
-
-```
-kamel install
-```
-
-This will configure the cluster with the Camel K custom resource definitions and install the operator on the current namespace.
-
-**Note:** Custom Resource Definitions (CRD) are cluster-wide objects and you need admin rights to install them. Fortunately this
-operation can be done once per cluster. So, if the `kamel install` operation fails, you'll be asked to repeat it when logged as admin.
-For Minishift, this means executing `oc login -u system:admin` then `kamel install --cluster-setup` only for first-time installation.
-
-### Running a Integration
-
-After the initial setup, you can run a Camel integration on the cluster executing:
-
-```
-kamel run runtime/examples/Sample.java
-```
-
-A "Sample.java" file is included in the folder runtime/examples of this repository. You can change the content of the file and execute the command again to see the changes.
-
-A JavaScript integration has also been provided as example, to run it:
-
-```
-kamel run runtime/examples/routes.js
-```
-
-### Monitoring the Status
-
-Camel K integrations follow a lifecycle composed of several steps before getting into the `Running` state.
-You can check the status of all integrations by executing the following command:
-
-```
-kamel get
-```
-
-## Contributing
-
-We love contributions!
-
-The project is written in [Go](https://golang.org/) and contains some parts written in Java for the [integration runtime](/runtime).
-Camel K is built on top of Kubernetes through *Custom Resource Definitions*. The [Operator SDK](https://github.com/operator-framework/operator-sdk) is used
-to manage the lifecycle of those custom resources.
-
-### Requirements
-
-In order to build the project, you need to comply with the following requirements:
-- **Go version 1.10+**: needed to compile and test the project. Refer to the [Go website](https://golang.org/) for the installation.
-- **Dep version 0.5.0**: for managing dependencies. You can find installation instructions in the [dep GitHub repository](https://github.com/golang/dep).
-- **Operator SDK v0.0.6+**: used to build the operator and the Docker images. Instructions in the [Operator SDK website](https://github.com/operator-framework/operator-sdk).
-- **GNU Make**: used to define composite build actions. This should be already installed or available as package if you have a good OS (https://www.gnu.org/software/make/).
-
-### Checking Out the Sources
-
-You can create a fork of this project from Github, then clone your fork with the `git` command line tool.
-
-You need to put the project in your $GOPATH (refer to [Go documentation](https://golang.org/doc/install) for information).
-So, make sure that the **root** of the github repo is in the path:
-
-```
-$GOPATH/src/github.com/apache/camel-k/
-```
-
-### Structure
-
-This is a high level overview of the project structure:
-
-- [/cmd](/cmd): contains the entry points (the *main* functions) for the **camel-k-operator** binary and the **kamel** client tool.
-- [/build](/build): contains scripts used during make operations for building the project.
-- [/deploy](/deploy): contains Kubernetes resource files that are used by the **kamel** client during installation. The `/deploy/resources.go` file is kept in sync with the content of the directory (`make build-embed-resources`), so that resources can be used from within the go code.
-- [/pkg](/pkg): this is where the code resides. The code is divided in multiple subpackages.
-- [/runtime](/runtime): the Java runtime code that is used inside the integration Docker containers.
-- [/test](/test): include integration tests to ensure that the software interacts correctly with Kubernetes and Openshift.
-- [/tmp](/tmp): scripts and Docker configuration files used by the operator-sdk.
-- [/vendor](/vendor): project dependencies.
-- [/version](/version): contains the global version of the project.
-
-### Building
-
-Go dependencies in the *vendor* directory are not included when you clone the project.
-
-Before compiling the source code, you need to sync your local *vendor* directory with the project dependencies, using the following command:
-
-```
-make dep
-```
-
-The `make dep` command runs `dep ensure -v` under the hood, so make sure that `dep` is properly installed.
-
-To build the whole project you now need to run:
-
-```
-make
-```
-
-This execute a full build of both the Java and Go code. If you need to build the components separately you can execute:
-- `make build-operator`: to build the operator binary only.
-- `make build-kamel`: to build the `kamel` client tool only.
-- `make build-runtime`: to build the Java-based runtime code only.
-
-After a successful build, if you're connected to a Docker daemon, you can build the operator Docker image by running:
-
-```
-make images
-```
-
-### Testing
-
-Unit tests are executed automatically as part of the build. They use the standard go testing framework.
-
-Integration tests (aimed at ensuring that the code integrates correctly with Kubernetes and Openshift), need special care.
-
-The **convention** used in this repo is to name unit tests `xxx_test.go`, and name integration tests `yyy_integration_test.go`.
-Integration tests are all in the [/test](/test) dir.
-
-Since both names end with `_test.go`, both would be executed by go during build, so you need to put a special **build tag** to mark
-integration tests. A integration test should start with the following line:
-
-```
-// +build integration
-```
-
-An [example is provided here](https://github.com/apache/camel-k/blob/ff672fbf54c358fca970da6c59df378c8535d4d8/pkg/build/build_manager_integration_test.go#L1).
-
-Before running a integration test, you need to:
-- Login to a Kubernetes/Openshift cluster.
-- Set the `KUBERNETES_CONFIG` environment variable to point to your Kubernetes configuration file (usually `<home-dir>/.kube/config`).
-- Set the `WATCH_NAMESPACE` environment variable to a Kubernetes namespace you have access to.
-- Set the `OPERATOR_NAME` environment variable to `camel-k-operator`.
-
-When the configuration is done, you can run the following command to execute **all** integration tests:
-
-```
-make test-integration
-```
-
-### Running
-
-If you want to install everything you have in your source code and see it running on Kubernetes, you need to run the following command:
-- Run `make install-minishift` (or just `make install`): to build the project and install it in the current namespace on Minishift
-- You can specify a different namespace with `make install-minishift project=myawesomeproject`
-
-This command assumes you have an already running Minishift instance.
-
-Now you can play with Camel K:
-
-```
-./kamel run runtime/examples/Sample.java
-```
-
-To add additional dependencies to your routes:
-
-```
-./kamel run -d camel:dns runtime/examples/dns.js
-```
-
-### Debugging and Running from IDE
-
-Sometimes it's useful to debug the code from the IDE when troubleshooting.
-
-**Debugging the `kamel` binary**
-
-It should be straightforward: just execute the [/cmd/kamel/kamel.go]([/cmd/kamel/kamel.go]) file from the IDE (e.g. Goland) in debug mode.
-
-**Debugging the operator**
-
-It is a bit more complex (but not so much).
-
-You are going to run the operator code **outside** Openshift in your IDE so, first of all, you need to **stop the operator running inside**:
-
-```
-oc scale deployment/camel-k-operator --replicas 0
-```
-
-You can scale it back to 1 when you're done and you have updated the operator image.
-
-You can setup the IDE (e.g. Goland) to execute the [/cmd/camel-k-operator/camel_k_operator.go]([/cmd/camel-k-operator/camel_k_operator.go]) file in debug mode.
-
-When configuring the IDE task, make sure to add all required environment variables in the *IDE task configuration screen* (such as `KUBERNETES_CONFIG`, as explained in the [testing](#testing) section).
-
-## Uninstalling Camel K
-
-If required, it is possible to completely uninstall Camel K from OpenShift or Kubernetes with the following command, using the "oc" or "kubectl" tool:
-
-```
-# kubectl if using kubernetes
-oc delete all,pvc,configmap,rolebindings,clusterrolebindings,secrets,sa,roles,clusterroles,crd -l 'app=camel-k'
-```
diff --git a/cmd/camel-k-operator/kamel_k_operator.go b/cmd/camel-k-operator/camel_k_operator.go
similarity index 100%
rename from cmd/camel-k-operator/kamel_k_operator.go
rename to cmd/camel-k-operator/camel_k_operator.go
diff --git a/docs/cluster-setup.adoc b/docs/cluster-setup.adoc
new file mode 100644
index 0000000..2564b78
--- /dev/null
+++ b/docs/cluster-setup.adoc
@@ -0,0 +1,28 @@
+[[creating-cluster]]
+Creating a Development Cluster
+==============================
+
+There are various options for creating a development cluster:
+
+[[minishift]]
+== Minishift
+
+You can run Camel K integrations on Openshift using the Minishift cluster creation tool.
+Follow the instructions in the https://github.com/minishift/minishift#getting-started[getting started guide] for the installation.
+
+After installing the `minishift` binary, you need to enable the `admin-user` addon:
+
+```
+minishift addons enable admin-user
+```
+
+Then you can start the cluster with:
+
+```
+minishift start
+```
+
+[[minikube]]
+== Minikube
+
+Minikube and Kubernetes are not yet supported (but support is coming soon).
diff --git a/docs/developers.adoc b/docs/developers.adoc
new file mode 100644
index 0000000..24affc4
--- /dev/null
+++ b/docs/developers.adoc
@@ -0,0 +1,164 @@
+[[developers]]
+Developer's Guide
+=================
+
+We love contributions!
+
+The project is written in https://golang.org/[go] and contains some parts written in Java for the [integration runtime](/runtime).
+Camel K is built on top of Kubernetes through *Custom Resource Definitions*. The https://github.com/operator-framework/operator-sdk[Operator SDK] is used
+to manage the lifecycle of those custom resources.
+
+[[requirements]]
+== Requirements
+
+In order to build the project, you need to comply with the following requirements:
+
+* **Go version 1.10+**: needed to compile and test the project. Refer to the https://golang.org/[Go website] for the installation.
+* **Dep version 0.5.0**: for managing dependencies. You can find installation instructions in the https://github.com/golang/dep[dep GitHub repository].
+* **Operator SDK v0.0.6+**: used to build the operator and the Docker images. Instructions in the https://github.com/operator-framework/operator-sdk[Operator SDK website].
+* **GNU Make**: used to define composite build actions. This should be already installed or available as package if you have a good OS (https://www.gnu.org/software/make/).
+
+[[checking-out]]
+== Checking Out the Sources
+
+You can create a fork of this project from Github, then clone your fork with the `git` command line tool.
+
+You need to put the project in your $GOPATH (refer to https://golang.org/doc/install[Go documentation] for information).
+So, make sure that the **root** of the github repo is in the path:
+
+```
+$GOPATH/src/github.com/apache/camel-k/
+```
+
+[[structure]]
+== Structure
+
+This is a high level overview of the project structure:
+
+.Structure
+[options="header"]
+|=======================
+| Path | Content
+| link:/cmd[/cmd] | Contains the entry points (the *main* functions) for the **camel-k-operator** binary and the **kamel** client tool.
+| link:/build[/build] | Contains scripts used during make operations for building the project.
+| link:/deploy[/deploy] | Contains Kubernetes resource files that are used by the **kamel** client during installation. The `/deploy/resources.go` file is kept in sync with the content of the directory (`make build-embed-resources`), so that resources can be used from within the go code.
+| link:/docs[/docs] | Contains this documentation.
+| link:/pkg[/pkg] | This is where the code resides. The code is divided in multiple subpackages.
+| link:/runtime[/runtime] | The Java runtime code that is used inside the integration Docker containers.
+| link:/test[/test] | Include integration tests to ensure that the software interacts correctly with Kubernetes and Openshift.
+| link:/tmp[/tmp] | Scripts and Docker configuration files used by the operator-sdk.
+| /vendor | Project dependencies (not staged in git).
+| link:/version[/version] | Contains the global version of the project.
+|=======================
+
+
+[[building]]
+== Building
+
+Go dependencies in the *vendor* directory are not included when you clone the project.
+
+Before compiling the source code, you need to sync your local *vendor* directory with the project dependencies, using the following command:
+
+```
+make dep
+```
+
+The `make dep` command runs `dep ensure -v` under the hood, so make sure that `dep` is properly installed.
+
+To build the whole project you now need to run:
+
+```
+make
+```
+
+This execute a full build of both the Java and Go code. If you need to build the components separately you can execute:
+
+* `make build-operator`: to build the operator binary only.
+* `make build-kamel`: to build the `kamel` client tool only.
+* `make build-runtime`: to build the Java-based runtime code only.
+
+After a successful build, if you're connected to a Docker daemon, you can build the operator Docker image by running:
+
+```
+make images
+```
+
+[[testing]]
+== Testing
+
+Unit tests are executed automatically as part of the build. They use the standard go testing framework.
+
+Integration tests (aimed at ensuring that the code integrates correctly with Kubernetes and Openshift), need special care.
+
+The **convention** used in this repo is to name unit tests `xxx_test.go`, and name integration tests `yyy_integration_test.go`.
+Integration tests are all in the link:/test[/test] dir.
+
+Since both names end with `_test.go`, both would be executed by go during build, so you need to put a special **build tag** to mark
+integration tests. A integration test should start with the following line:
+
+```
+// +build integration
+```
+
+Look into the link:/test[/test] directory for examples of integration tests.
+
+Before running a integration test, you need to be connected to a Kubernetes/Openshift namespace.
+After you log in into your cluster, you can run the following command to execute **all** integration tests:
+
+```
+make test-integration
+```
+
+[running]
+== Running
+
+If you want to install everything you have in your source code and see it running on Kubernetes, you need to run the following command:
+
+* Run `make install-minishift` (or just `make install`): to build the project and install it in the current namespace on Minishift
+* You can specify a different namespace with `make install-minishift project=myawesomeproject`
+
+This command assumes you have an already running Minishift instance.
+
+Now you can play with Camel K:
+
+```
+./kamel run runtime/examples/Sample.java
+```
+
+To add additional dependencies to your routes:
+
+```
+./kamel run -d camel:dns runtime/examples/dns.js
+```
+
+[[debugging]]
+== Debugging and Running from IDE
+
+Sometimes it's useful to debug the code from the IDE when troubleshooting.
+
+.**Debugging the `kamel` binary**
+
+It should be straightforward: just execute the link:/cmd/kamel/kamel.go[/cmd/kamel/kamel.go] file from the IDE (e.g. Goland) in debug mode.
+
+.**Debugging the operator**
+
+It is a bit more complex (but not so much).
+
+You are going to run the operator code **outside** Openshift in your IDE so, first of all, you need to **stop the operator running inside**:
+
+```
+// use kubectl in plain Kubernetes
+oc scale deployment/camel-k-operator --replicas 0
+```
+
+You can scale it back to 1 when you're done and you have updated the operator image.
+
+You can setup the IDE (e.g. Goland) to execute the link:/cmd/camel-k-operator/camel_k_operator.go[/cmd/camel-k-operator/camel_k_operator.go] file in debug mode.
+
+When configuring the IDE task, make sure to add all required environment variables in the *IDE task configuration screen*:
+
+* Set the `KUBERNETES_CONFIG` environment variable to point to your Kubernetes configuration file (usually `<homedir>/.kube/config`).
+* Set the `WATCH_NAMESPACE` environment variable to a Kubernetes namespace you have access to.
+* Set the `OPERATOR_NAME` environment variable to `camel-k-operator`.
+
+After you setup the IDE task, you can run and debug the operator process.
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services