This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-website.git
The following commit(s) were added to refs/heads/main by this push:
new ca76c8c chore: mirror my latest blog post (#665)
ca76c8c is described below
commit ca76c8cf1b3cb7eefcd5e2d3c347abc66c2df5ac
Author: Nicola Ferraro <[email protected]>
AuthorDate: Fri Nov 12 15:08:15 2021 +0100
chore: mirror my latest blog post (#665)
---
content/blog/2021/11/low-code-camel/index.md | 98 ++++++++++++++++++++++++
content/blog/2021/11/low-code-camel/karavan.png | Bin 0 -> 464789 bytes
2 files changed, 98 insertions(+)
diff --git a/content/blog/2021/11/low-code-camel/index.md
b/content/blog/2021/11/low-code-camel/index.md
new file mode 100644
index 0000000..6efe398
--- /dev/null
+++ b/content/blog/2021/11/low-code-camel/index.md
@@ -0,0 +1,98 @@
+---
+title: "Low Code Camel"
+date: 2021-11-08
+authors: [nicolaferraro]
+categories: ["Kamelets", "Camel K", "Tooling"]
+preview: "How Kamelets enable a low code integration experience."
+---
+
+NOTE: this post originally appeared [in the author's
blog](https://www.nicolaferraro.me/2021/11/03/low-code-camel/).
+
+Apache Camel is a project in constant transformation. Anyone knows that Camel
has been able to adapt to any new kinds of protocols and systems that have
emerged in the past 15 years. But it's not only that: Camel is also able to
adapt to any new ways of dealing with integration problems in the cloud era.
+While Camel K represented a fundamental shift towards a new approach to
cloud-native integration,
["Kamelets"](https://www.nicolaferraro.me/2020/10/12/kamelets/) are driving a
deeper transformation towards "low code" development.
+
+When I talk about **"low code"**, I refer to a platform for *developers* where
you can achieve most of your goals without writing any code. But at the same
time, a low code platform should be customizable enough to let you show your
development skills when it's time to solve critical issues. It needs to be
abstract in order to easily deal with the most common problems, even using a
UI. But it should not prevent a developer to play with the low level details in
order to extend the capabil [...]
+
+If you're a bit familiar with how
[Kamelets](https://www.nicolaferraro.me/2020/10/12/kamelets/) work, I think
you've already got my point here.
+
+## Bindings and Karavans
+
+It's really easy to use Kamelets, especially in combination with [Camel
K](https://github.com/apache/camel-k). I've shown in [a recent presentation at
ApacheCon @Home](https://www.youtube.com/watch?v=xVL1gJ5AJVg) that moving data
from Knative or Kafka into an S3 bucket using streaming upload is as simple as
writing something like this:
+
+```yaml
+apiVersion: camel.apache.org/v1alpha1
+kind: KameletBinding
+metadata:
+ name: events-to-s3
+spec:
+ source:
+ ref:
+ apiVersion: messaging.knative.dev/v1
+ kind: Channel
+ name: messages
+ # Or a Strimzi "KafkaTopic", if you prefer
+ sink:
+ ref:
+ kind: Kamelet
+ apiVersion: camel.apache.org/v1alpha1
+ name: aws-s3-streaming-upload-sink
+ properties:
+ bucketNameOrArn: "my-bucket"
+ accessKey: "<your-key>"
+ # ...
+```
+
+([source](https://github.com/nicolaferraro/apachecon-home-2021/blob/main/s3-sink-binding.yaml),
[S3 Kamelet Documentation]())
+
+You write this file, apply it to a Kubernetes cluster where Camel K is
installed: **done!**
+
+And it's **completely declarative**. You just specify where you want to move
data from and to: no need to care about lower level details.
+
+If writing YAML is not your favourite sport, you can also opt for a visual UI.
I've shown in the [previous video](https://www.youtube.com/watch?v=xVL1gJ5AJVg)
how the OpenShift dev console is already instructed to use Kamelets in
combination with Knative. But there's a new project in the horizon at Apache
that will bring this model even further...
+
+[**Karavan**](https://github.com/apache/camel-karavan) is a new project
started at Apache by [Marat Gubaidullin](https://github.com/mgubaidullin). It
is a generic visual UI that can design integrations based
+on Kamelets. If you either need to create a simple source/sink integration or
a more complex one, Karavan can help designing it with ease. There's also a
[blog post about Karavan](/blog/2021/10/camel-karavan-preview-release/) if you
want to learn more.
+
+
+*The Karavan UI*
+{: style="color:gray; font-size: 90%; text-align: center;"}
+
+After you finish to configure the integration, the output you get from the UI
is an `Integration` custom resource, that you can direcly apply to any
Kubernetes cluster (having Camel K installed) and it will automatically run.
+
+We have now a wider [catalog of Kamelets](/camel-kamelets/next/) available
upstream and it will cover many use cases that you may have in mind. They are
the building blocks for letting you connect systems **without writing any
code**: just choose if you want to use the YAML configuration or let the
Karavan UI create it for you.
+
+## Where's my Kamelet?
+
+There's no doubt you'll find a use case which is not covered by a Kamelet. For
example, what about moving data between parts of your organization?
+
+In traditional Camel the approach you would have taken to address this problem
is to create one or more ad hoc integrations to
+fullfill any of your needs. You'd develop a custom integration route for each
use case you have in mind.
+
+The Kamelet approach is completely different. You develop a reusable Kamelet
that is responsible of taking specific data out of your system (a **source**),
or putting some data back into your system (a **sink**).
+Once you've done that, you can **treat it as a high level connector in the
Karavan UI** and use it, whenever you need, in multiple scenarios where you
need to move data around, without having to code everything from scratch each
time.
+
+Writing a Kamelet is easy, *much easier than writing a Camel component*, if
you've ever tried doing so. We've written
+an extended [Kamelet developer
guide](/camel-k/next/kamelets/kamelets-dev.html) that covers
+both easy and complex scenarios.
+
+We know that creating a source or a sink and also **doing it right** may be
difficult (integration is hard, that's why we have Apache Camel) and involve
multiple enterprise integration patterns. The
+Kamelet developer guide contains a [section about an "Earthquake"
source](/camel-k/next/kamelets/kamelets-dev.html#_step_5_wrap_it_into_a_kamelet)
that is complicated on purpose, to mimic a Kamelet that may be developed for
handling data inside an organization.
+
+When writing a new Kamelet, you can use plain YAML to describe a route
template, add Java (or Groovy, or ...) code snippets
+if you need them, or also link an external Maven project in case you want to
add a more complex behavior to it (we did it in the
[camel-kamelets](https://github.com/apache/camel-kamelets/blob/1480bd372d42df0a185b4980b465ec245f2de0c5/avro-serialize-action.kamelet.yaml#L34)
repository, where we build the default catalog of Kamelets).
+
+What does not change is that, once a Kamelet is written, the logic inside it
is **well encapsulated** and you can treat it
+as **any other connector**, in a Binding or in the Karavan UI.
+
+A Kamelet is then the element that enables low code development: it's easy to
configure and embeddable in any UI (such as we've done in Karavan), and allows
you to fully customize its behavior, even writing various degrees of custom
code, up to the lowest level elements of a Camel integration route.
+
+## Where to go next
+
+Check out the [Karavan repository](https://github.com/apache/camel-karavan),
where you can build an run the Karavan designer. There's also a [VSCode
extension](https://marketplace.visualstudio.com/items?itemName=camel-karavan.karavan)
that will let you design integrations directly from the IDE.
+
+Then start playing with Karavan in combination with [Camel K](/camel-k/next/)
and
+the [Kamelet catalog](/camel-kamelets/next/).
+
+And finally look at how easy is to [create and use your own
Kamelets](/camel-k/next/kamelets/kamelets-dev.html).
+
+We'd love to hear your feedback!
diff --git a/content/blog/2021/11/low-code-camel/karavan.png
b/content/blog/2021/11/low-code-camel/karavan.png
new file mode 100644
index 0000000..60966ae
Binary files /dev/null and b/content/blog/2021/11/low-code-camel/karavan.png
differ
