You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by pc...@apache.org on 2024/05/23 15:27:48 UTC
(camel-k-examples) 01/02: (#56) Remove usage of deprecated VS Code Didact
This is an automated email from the ASF dual-hosted git repository.
pcongiusti pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-k-examples.git
commit b7815729c6f21177f9e4a7f2adb35a65e9fef0fc
Author: Thomas Diesler <td...@redhat.com>
AuthorDate: Wed May 22 12:57:08 2024 +0200
(#56) Remove usage of deprecated VS Code Didact
---
.vscode/extensions.json | 1 -
01-basic/Basic.java | 34 ---
01-basic/Routing.java | 63 -----
01-basic/readme.didact.md | 301 ---------------------
01-basic/readme.md | 1 -
01-basic/routing.properties | 22 --
02-serverless-api/API.java | 43 ---
02-serverless-api/openapi.yaml | 53 ----
02-serverless-api/readme.didact.md | 294 --------------------
02-serverless-api/readme.md | 1 -
02-serverless-api/s3.properties | 17 --
02-serverless-api/test/crud.feature | 65 -----
02-serverless-api/test/minio.properties | 17 --
02-serverless-api/test/minio.yaml | 71 -----
02-serverless-api/test/yaks-config.yaml | 14 -
03-knative-source-basic/readme.didact.md | 173 ------------
03-knative-source-basic/readme.md | 1 -
03-knative-source-basic/telegram-channel.yaml | 7 -
03-knative-source-basic/telegram-consumer.groovy | 9 -
03-knative-source-basic/telegram-source.yaml | 31 ---
03-knative-source-basic/telegram.properties | 4 -
.../aws-kinesis-channel.yaml | 7 -
.../aws-kinesis-consumer.groovy | 13 -
.../aws-kinesis-producer.groovy | 13 -
.../aws-kinesis-source.yaml | 37 ---
04-aws-kinesis-source-basic/aws-kinesis.properties | 3 -
04-aws-kinesis-source-basic/readme.didact.md | 185 -------------
04-aws-kinesis-source-basic/readme.md | 1 -
05-knative-source-jira/README.md | 180 ------------
05-knative-source-jira/jira-channel.yaml | 5 -
05-knative-source-jira/jira-consumer.groovy | 7 -
05-knative-source-jira/jira-new-issues.yaml | 40 ---
05-knative-source-jira/jira.properties | 4 -
05-knative-source-jira/readme.didact.md | 180 ------------
.../aws-kinesis-firehose-producer.groovy | 9 -
06-aws-kinesis-firehose-basic/aws-s3-channel.yaml | 7 -
.../aws-s3-consumer.groovy | 8 -
06-aws-kinesis-firehose-basic/aws-s3-source.yaml | 36 ---
.../aws-services.properties | 6 -
06-aws-kinesis-firehose-basic/readme.didact.md | 185 -------------
06-aws-kinesis-firehose-basic/readme.md | 1 -
07-aws-sqs-source-basic/aws-sqs-channel.yaml | 7 -
07-aws-sqs-source-basic/aws-sqs-consumer.groovy | 6 -
07-aws-sqs-source-basic/aws-sqs-producer.groovy | 9 -
07-aws-sqs-source-basic/aws-sqs-source.yaml | 37 ---
07-aws-sqs-source-basic/aws-sqs.properties | 3 -
07-aws-sqs-source-basic/readme.didact.md | 183 -------------
07-aws-sqs-source-basic/readme.md | 1 -
.../azure-storage-blob-channel.yaml | 7 -
.../azure-storage-blob-consumer.groovy | 21 --
.../azure-storage-blob-producer.groovy | 69 -----
.../azure-storage-blob-source.yaml | 32 ---
.../azure-storage-blob.properties | 5 -
08-azure-storage-blob-basic/readme.didact.md | 181 -------------
08-azure-storage-blob-basic/readme.md | 181 -------------
.../azure-storage-queue-channel.yaml | 7 -
.../azure-storage-queue-consumer.groovy | 9 -
.../azure-storage-queue-producer.groovy | 11 -
.../azure-storage-queue-source.yaml | 31 ---
.../azure-storage-queue.properties | 3 -
09-azure-storage-queue-basic/readme.didact.md | 181 -------------
09-azure-storage-queue-basic/readme.md | 181 -------------
.../SalesforceConsumer.java | 13 -
10-knative-source-salesforce/readme.didact.md | 216 ---------------
10-knative-source-salesforce/readme.md | 1 -
.../salesforce-channel.yaml | 7 -
.../salesforce-source.yaml | 32 ---
10-knative-source-salesforce/salesforce.properties | 5 -
11-knative-source-slack/readme.didact.md | 177 ------------
11-knative-source-slack/readme.md | 1 -
11-knative-source-slack/slack-channel.yaml | 7 -
11-knative-source-slack/slack-consumer.groovy | 9 -
11-knative-source-slack/slack-source.yaml | 31 ---
11-knative-source-slack/slack.properties | 4 -
.../aws-secret-manager.properties | 3 -
12-aws-secret-manager-vault/readme.md | 47 ----
.../timer-finnhub-aws-secret-manager.yaml | 33 ---
.../aws-kinesis-channel.yaml | 7 -
.../aws-kinesis-consumer.groovy | 16 --
.../aws-kinesis-producer.groovy | 13 -
.../aws-kinesis-source.yaml | 52 ----
.../aws-kinesis.properties | 2 -
.../extra/custom-kinesis-configuration/pom.xml | 52 ----
.../k/examples/CustomKinesisConfiguration.java | 127 ---------
.../extra/localstack.yaml | 40 ---
.../readme.didact.md | 208 --------------
90-aws-kinesis-customized-event-source/readme.md | 1 -
README.md | 31 +--
generic-examples/languages/README.md | 2 +-
89 files changed, 3 insertions(+), 4448 deletions(-)
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index c580dfb..2d51b39 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,6 +1,5 @@
{
"recommendations": [
- "redhat.vscode-didact",
"redhat.apache-camel-extension-pack"
]
}
diff --git a/01-basic/Basic.java b/01-basic/Basic.java
deleted file mode 100755
index fb060a7..0000000
--- a/01-basic/Basic.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// camel-k: language=java
-
-import org.apache.camel.builder.RouteBuilder;
-
-public class Basic extends RouteBuilder {
- @Override
- public void configure() throws Exception {
-
- from("timer:java?period=1000")
- .setHeader("example")
- .constant("Java")
- .setBody()
- .simple("Hello World! Camel K route written in ${header.example}.")
- .to("log:info");
-
- }
-}
diff --git a/01-basic/Routing.java b/01-basic/Routing.java
deleted file mode 100755
index 9497060..0000000
--- a/01-basic/Routing.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// camel-k: language=java
-
-import java.util.Random;
-
-import org.apache.camel.PropertyInject;
-import org.apache.camel.builder.RouteBuilder;
-
-public class Routing extends RouteBuilder {
-
- private Random random = new Random();
-
- @PropertyInject("priority-marker")
- private String priorityMarker;
-
- @Override
- public void configure() throws Exception {
-
- from("timer:java?period=3000")
- .id("generator")
- .bean(this, "generateRandomItem({{items}})")
- .choice()
- .when().simple("${body.startsWith('{{priority-marker}}')}")
- .transform().body(String.class, item -> item.substring(priorityMarker.length()))
- .to("direct:priorityQueue")
- .otherwise()
- .to("direct:standardQueue");
-
- from("direct:standardQueue")
- .id("standard")
- .log("Standard item: ${body}");
-
- from("direct:priorityQueue")
- .id("priority")
- .log("!!Priority item: ${body}");
-
- }
-
- public String generateRandomItem(String items) {
- if (items == null || items.equals("")) {
- return "[no items configured]";
- }
- String[] list = items.split("\\s");
- return list[random.nextInt(list.length)];
- }
-
-}
diff --git a/01-basic/readme.didact.md b/01-basic/readme.didact.md
deleted file mode 100644
index 57d8d8a..0000000
--- a/01-basic/readme.didact.md
+++ /dev/null
@@ -1,301 +0,0 @@
-# Camel K Basic Example
-
-This example demonstrates how to get started with Camel K by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Available online
-
-If you don't want to setup your own Kubernetes cluster or your IDE and you just want to get started quickly, this example is also available online in the following places:
-
-- [Camel K Basic Example at learn.openshift.com](https://learn.openshift.com/middleware/courses/middleware-camelk/camel-k-basic).
-
-You don't need to follow the remainder of this readme if you choose to follow the online version.
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 01-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2001-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-basic` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-basic&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-basic` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-basic&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-basic` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Running a basic integration
-
-This repository contains a simple Camel K integration that periodically prints
-a "Hello World..." message.
-
-The integration is all contained in a single file named `Basic.java` ([open](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/Basic.java&completion=Opened%20the%20Basic.java%20file "Opens the Basic.java file"){.didact}).
-
-> **Note:** the `Basic.java` file contains a simple integration that uses the `timer` and `log` components.
-> Dependency management is automatically handled by Camel K that imports all required libraries from the Camel
-> catalog via code inspection. This means you can use all 300+ Camel components directly in your routes.
-
-We're ready to run the integration on our `camel-basic` project in the cluster.
-
-Use the following command to run it in "dev mode", in order to see the logs in the integration terminal:
-
-```
-kamel run Basic.java --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20Basic.java%20--dev&completion=Camel%20K%20basic%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running and continuously printing "Hello World!..." in the terminal window.
-
-When running in dev mode, you can change the integration code and let Camel K redeploy the changes automatically.
-
-To try this feature,
-[open the `Basic.java` file](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/Basic.java&completion=Opened%20the%20Basic.java%20file "Opens the Basic.java file"){.didact}
-and change "Hello World" into "Ciao Mondo", then save the file.
-You should see the new integration starting up in the terminal window and replacing the old one.
-
-[**To exit dev mode and terminate the execution**, just click here](didact://?commandId=vscode.didact.sendNamedTerminalCtrlC&text=camelTerm&completion=Camel%20K%20basic%20integration%20interrupted. "Interrupt the current operation on the terminal"){.didact}
-or hit `ctrl+c` on the terminal window.
-
-> **Note:** When you terminate a "dev mode" execution, also the remote integration will be deleted. This gives the experience of a local program execution, but the integration is actually running in the remote cluster.
-
-To keep the integration running and not linked to the terminal, you can run it without "dev mode", just run:
-
-```
-kamel run Basic.java
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20Basic.java&completion=Camel%20K%20basic%20integration%20run. "Opens a new terminal and sends the command above"){.didact})
-
-
-
-After executing the command, you should be able to see it among running integrations:
-
-```
-kubectl get integrations
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrations&completion=Getting%20running%20integrations. "Opens a new terminal and sends the command above"){.didact})
-
-An integration named `basic` should be present in the list and it should be in status `Running`. There's also a `kamel get` command which is an alternative way to list all running integrations.
-
-> **Note:** the first time you've run the integration, an IntegrationKit (basically, a container image) has been created for it and
-> it took some time for this phase to finish. When you run the integration a second time, the existing IntegrationKit is reused
-> (if possible) and the integration reaches the "Running" state much faster.
->
-
-
-Even if it's not running in dev mode, you can still see the logs of the integration using the following command:
-
-```
-kamel log basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20log%20basic&completion=Show%20integration%20logs. "Opens a new terminal and sends the command above"){.didact})
-
-The last parameter ("basic") is the name of the running integration for which you want to display the logs.
-
-[**Click here to terminate the log stream**](didact://?commandId=vscode.didact.sendNamedTerminalCtrlC&text=camelTerm&completion=Camel%20K%20basic%20integration%20interrupted. "Interrupt the current operation on the terminal"){.didact}
-or hit `ctrl+c` on the terminal window.
-
-> **Note:** Your IDE may provide an "Apache Camel K Integrations" panel where you can see the list of running integrations and also open a window to display the logs.
-
-
-## 3. Applying configuration and routing
-
-The second example is a bit more complex as it shows how to configure the integration using external properties and
-also a simple content-based router.
-
-The integration is contained in a file named `Routing.java` ([open](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/Routing.java&completion=Opened%20the%20Routing.java%20file "Opens the Routing.java file"){.didact}).
-
-The routes use two configuration properties named `items` and `priority-marker` that should be provided using an external file such
-as the `routing.properties` ([open](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/routing.properties&completion=Opened%20the%20routing.properties%20file "Opens the routing.properties file"){.didact}).
-
-The `Routing.java` file shows how to inject properties into the routes via property placeholders and also the usage of the `@PropertyInject` annotation.
-
-To run the integration, we should link the integration to the property file providing configuration for it:
-
-```
-kamel run Routing.java --property file:./routing.properties --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20Routing.java%20--property%20file:./routing.properties%20--dev&completion=Run%20Routing.java%20integration. "Opens a new terminal and sends the command above"){.didact})
-
-Wait for the integration to be running (you should see the logs streaming in the terminal window).
-
-You can now open both the [Routing.java](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/Routing.java&completion=Opened%20the%20Routing.java%20file "Opens the Routing.java file"){.didact} file or
-the [routing.properties](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/routing.properties&completion=Opened%20the%20routing.properties%20file "Opens the routing.properties file"){.didact}
-file, make some changes and see the integration redeployed.
-For example, change the word `door` with `*door` to see it sent to the priority queue.
-
-[**Click here to exit dev mode and terminate the execution**](didact://?commandId=vscode.didact.sendNamedTerminalCtrlC&text=camelTerm&completion=Camel%20K%20basic%20integration%20interrupted. "Interrupt the current operation on the terminal"){.didact},
-or hit `ctrl+c` on the terminal window.
-
-This will also terminate the execution of the integration.
-
-## 4. Running integrations as Kubernetes CronJobs
-
-The previous example can be automatically deployed as a Kubernetes CronJob if the delay between executions is changed into a value that can be expressed by a cron tab expression.
-
-For example, you can change the first endpoint (`timer:java?period=3000`) into the following: `timer:java?period=60000` (1 minute between executions). [Open the Routing.java file](didact://?commandId=vscode.openFolder&projectFilePath=01-basic/Routing.java&completion=Opened%20the%20Routing.java%20file "Opens the Routing.java file"){.didact} to apply the changes.
-
-Now you can run the integration again:
-
-```
-kamel run Routing.java --property file:./routing.properties
-```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20Routing.java%20--property%20file:./routing.properties&completion=Run%20Routing.java%20integration%20as%20CronJob. "Opens a new terminal and sends the command above"){.didact})
-
-Now you'll see that Camel K has materialized a cron job:
-
-```
-kubectl get cronjob
-```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20cronjob&completion=Get%20CronJobs. "Opens a new terminal and sends the command above"){.didact})
-
-You'll find a Kubernetes CronJob named "routing".
-
-The running behavior changes, because now there's no pod always running (beware you should not store data in memory when using the cronJob strategy).
-
-You can see the pods starting and being destroyed by watching the namespace:
-
-```
-kubectl get pod -w
-```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20pod%20-w&completion=Watch%20Pods. "Opens a new terminal and sends the command above"){.didact})
-
-[**Click here to exit the current command**](didact://?commandId=vscode.didact.sendNamedTerminalCtrlC&text=camelTerm&completion=Camel%20K%20basic%20integration%20interrupted. "Interrupt the current operation on the terminal"){.didact},
-or hit `ctrl+c` on the terminal window.
-
-To see the logs of each integration starting up, you can use the `kamel log` command:
-
-```
-kamel log routing
-```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20log%20routing&completion=Watch%20integration%20logs. "Opens a new terminal and sends the command above"){.didact})
-
-You should see every minute a JVM starting, executing a single operation and terminating.
-
-[**Click here to exit the current command**](didact://?commandId=vscode.didact.sendNamedTerminalCtrlC&text=camelTerm&completion=Camel%20K%20basic%20integration%20interrupted. "Interrupt the current operation on the terminal"){.didact},
-or hit `ctrl+c` on the terminal window.
-
-The CronJob behavior is controlled via a Trait called `cron`. Traits are the main way to configure high level Camel K features, to
-customize how integrations are rendered.
-
-To disable the cron feature and use the deployment strategy, you can run the integration with:
-
-```
-kamel run Routing.java --property file:./routing.properties -t cron.enabled=false
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20Routing.java%20--property%20file:./routing.properties%20-t%20cron.enabled=false&completion=Run%20Routing.java%20integration%20without%20CronJobs. "Opens a new terminal and sends the command above"){.didact})
-
-This will disable the cron trait and restore the classic behavior (always running pod).
-
-You should see it reflected in the logs (which will be printed every minute by the same JVM):
-
-```
-kamel log routing
-```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20log%20routing&completion=Watch%20integration%20logs. "Opens a new terminal and sends the command above"){.didact})
-
-
-[**Click here to exit the current command**](didact://?commandId=vscode.didact.sendNamedTerminalCtrlC&text=camelTerm&completion=Camel%20K%20basic%20integration%20interrupted. "Interrupt the current operation on the terminal"){.didact},
-or hit `ctrl+c` on the terminal window.
-
-You can continue to hack on the examples.
-
-## 5. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-basic```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-basic&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/01-basic/readme.md b/01-basic/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/01-basic/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/01-basic/routing.properties b/01-basic/routing.properties
deleted file mode 100644
index faf3fca..0000000
--- a/01-basic/routing.properties
+++ /dev/null
@@ -1,22 +0,0 @@
-# ---------------------------------------------------------------------------
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ---------------------------------------------------------------------------
-
-# List of items for random generation
-items=*radiator *engine door window
-
-# Marker to identify priority items
-priority-marker=*
diff --git a/02-serverless-api/API.java b/02-serverless-api/API.java
deleted file mode 100755
index cf28a9a..0000000
--- a/02-serverless-api/API.java
+++ /dev/null
@@ -1,43 +0,0 @@
-// camel-k: language=java dependency=camel-quarkus-openapi-java
-
-import org.apache.camel.builder.AggregationStrategies;
-import org.apache.camel.builder.RouteBuilder;
-
-public class API extends RouteBuilder {
- @Override
- public void configure() throws Exception {
-
- // All endpoints starting from "direct:..." reference an operationId defined
- // in the "openapi.yaml" file.
-
- // List the object names available in the S3 bucket
- from("direct:list")
- .to("aws2-s3://{{api.bucket}}?operation=listObjects")
- .split(simple("${body}"), AggregationStrategies.groupedBody())
- .transform().simple("${body.key}")
- .end()
- .marshal().json();
-
-
- // Get an object from the S3 bucket
- from("direct:get")
- .setHeader("CamelAwsS3Key", simple("${header.name}"))
- .to("aws2-s3://{{api.bucket}}?operation=getObject")
- .convertBodyTo(String.class);
-
-
- // Upload a new object into the S3 bucket
- from("direct:create")
- .setHeader("CamelAwsS3Key", simple("${header.name}"))
- .to("aws2-s3://{{api.bucket}}")
- .setBody().constant("");
-
-
- // Delete an object from the S3 bucket
- from("direct:delete")
- .setHeader("CamelAwsS3Key", simple("${header.name}"))
- .to("aws2-s3://{{api.bucket}}?operation=deleteObject")
- .setBody().constant("");
-
- }
-}
diff --git a/02-serverless-api/openapi.yaml b/02-serverless-api/openapi.yaml
deleted file mode 100644
index 42e9f6e..0000000
--- a/02-serverless-api/openapi.yaml
+++ /dev/null
@@ -1,53 +0,0 @@
----
-openapi: 3.0.2
-info:
- title: Camel K Object API
- version: 1.0.0
- description: A CRUD API for an object store
-paths:
- /:
- get:
- responses:
- "200":
- content:
- application/json:
- schema:
- type: array
- items:
- type: string
- description: Object list
- operationId: list
- summary: List the objects
- /{name}:
- get:
- responses:
- "200":
- content:
- application/octet-stream: {}
- description: The object content
- operationId: get
- summary: Get the content of an object
- put:
- requestBody:
- description: The object content
- content:
- application/octet-stream: {}
- required: true
- responses:
- "200":
- description: The object has been created
- operationId: create
- summary: Save an object
- delete:
- responses:
- "204":
- description: Object has been deleted
- operationId: delete
- summary: Delete an object
- parameters:
- - name: name
- description: Name of the object
- schema:
- type: string
- in: path
- required: true
diff --git a/02-serverless-api/readme.didact.md b/02-serverless-api/readme.didact.md
deleted file mode 100644
index 1b2678c..0000000
--- a/02-serverless-api/readme.didact.md
+++ /dev/null
@@ -1,294 +0,0 @@
-# Camel K Serverless API Example
-
-This example demonstrates how to write an API based Camel K integration, from the design of the OpenAPI definition
-to the implementation of the specific endpoints up to the deployment as serverless API in Knative.
-
-In this specific example, the API enables users to store generic objects, such as files, in a backend system, allowing all CRUD operation on them.
-
-The backend is an Amazon AWS S3 bucket that you might provide. In alternative, you'll be given instructions on how to
-create a simple [Minio](https://min.io/) backend, which uses a S3 compatible protocol.
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/docs/getting-started/quickstart-install/) for information on how to install it in your cluster.
-
-[Check if the Knative is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 02-serverless-api
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2002-serverless-api&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-api` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-api
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-api&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-api` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-api
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-api&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-api` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Configuring the object storage backend
-
-You have two alternative options for setting up the S3 backend that will be used to store the objects via the Camel K API:
-you can use an existing S3 bucket of your own or you can set up a local S3 compatible object storage.
-
-### 2.1 [Alternative 1] I don't have a S3 bucket: let's install a Minio backend
-
-The `test` directory contains an all-in-one configuration file for creating a Minio backend that will provide a S3 compatible protocol
-for storing the objects.
-
-Open the ([test/minio.yaml](didact://?commandId=vscode.open&projectFilePath=02-serverless-api/test/minio.yaml "Opens the Minio configuration"){.didact}) file to check its content before applying.
-
-To create the minio backend, just apply the provided file:
-
-```
-kubectl apply -f test/minio.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20test/minio.yaml&completion=Created%20Minio%20backend. "Opens a new terminal and sends the command above"){.didact})
-
-That's enough to have a test object storage to use with the API integration.
-
-### 2.1 [Alternative 2] I have a S3 bucket
-
-If you have a S3 bucket and you want to use it instead of the test backend, you can do it. The only
-things that you need to provide are a **AWS Access Key ID and Secret** that you can obtain from the Amazon AWS console.
-
-Edit the ([s3.properties](didact://?commandId=vscode.open&projectFilePath=02-serverless-api/s3.properties "Opens the S3 configuration"){.didact}) to set the right value for the properties `camel.component.aws-s3.access-key` and `camel.component.aws-s3.secret-key`.
-Those properties will be automatically injected into the Camel `aw3-s3` component.
-
-## 3. Designing the API
-
-An object store REST API is provided in the [openapi.yaml](didact://?commandId=vscode.open&projectFilePath=02-serverless-api/openapi.yaml "Opens the OpenAPI definition"){.didact} file.
-
-It contains operations for:
-- Listing the name of the contained objects
-- Creating a new object
-- Getting the content of an object
-- Deleting an object
-
-The file can be edited manually or better using an online editor, such as [Apicurio](https://studio.apicur.io/).
-
-## 4. Running the API integration
-
-The endpoints defined in the API can be implemented in a Camel K integration using a `direct:<operationId>` endpoint.
-This has been implemented in the [API.java](didact://?commandId=vscode.open&projectFilePath=02-serverless-api/API.java "Opens the integration file"){.didact} file.
-
-To run the integration, you need to link it to the proper configuration, that depends on what configuration you've chosen (either S3 or Minio). Additionally you need to expose the OpenAPI spec. as ConfigMap:
-
-```
-kubectl create configmap my-openapi --from-file=openapi.yaml
-```
-
-### 4.1 [Alternative 1] Using the test Minio server
-
-As alternative, to connect the integration to the **test Minio server** deployed before:
-
-```
-kamel run API.java --open-api configmap:my-openapi --property file:test/minio.properties --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20API.java%20--property%20file%3Atest%2Fminio.properties&completion=Integration%20run. "Opens a new terminal and sends the command above"){.didact})
-
-In case you run on Minikube then you can't use `http://minio:9000` as your S3 endpoint in `minio.properties` because the `EXTERNAL-IP` of your load balancer service would be `<pending>`. For this to work you can run [Minikube service](https://minikube.sigs.k8s.io/docs/commands/service/) to get the URL for the connection to use:
-
-```
-$> minikube service -n camel-api minio
-|-----------|-------|-------------|-----------------------------|
-| NAMESPACE | NAME | TARGET PORT | URL |
-|-----------|-------|-------------|-----------------------------|
-| camel-api | minio | 9000 | http://192.168.105.26:32393 |
-|-----------|-------|-------------|-----------------------------|
-```
-
-Given the example above then use the following configuration in `minio.properties`:
-
-```
-camel.component.aws2-s3.uri-endpoint-override=http://192.168.105.26:32393
-```
-
-### 4.2 [Alternative 2] Using the S3 service
-
-To connect the integration to the **AWS S3 service**:
-
-```
-kamel run API.java --open-api configmap:my-openapi --property file:s3.properties --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20API.java%20--property%20file%3As3.properties&completion=Integration%20run. "Opens a new terminal and sends the command above"){.didact})
-
-
-## 5. Using the API
-
-After running the integration API, you should be able to call the API endpoints to check its behavior.
-
-Make sure the integration is running, by checking its status:
-
-```
-kubectl get integrations
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrations&completion=Getting%20running%20integrations. "Opens a new terminal and sends the command above"){.didact})
-
-An integration named `api` should be present in the list and it should be in status `Running`. There's also a `kamel get` command which is an alternative way to list all running integrations.
-
-NOTE: it may take some time, the first time you run the integration, for it to reach the `Running` state.
-
-After the integraiton has reached the running state, you can get the route corresponding to it via the following command:
-
-```
-URL=$(kubectl get routes.serving.knative.dev api -o jsonpath='{.status.url}')
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$URL%3D%24%28kubectl%20get%20routes.serving.knative.dev%20api%20-o%20jsonpath%3D%27%7B.status.url%7D%27%29&completion=Getting%20route. "Opens a new terminal and sends the command above"){.didact})
-
-You can print the route to check if it's correct:
-
-```
-echo $URL
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$echo%20$URL&completion=Print%20route. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: ensure that you've followed all the instructions in the Knative documentation during installation, especially the DNS part is fundamental for being able to contact the API.
-
-You can now play with it! What follows is a list of commands that you can run to use the API and check if it's working.
-
-Get the list of objects:
-```
-curl -i $URL/
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$curl%20-i%20$URL&completion=Use%20the%20API. "Opens a new terminal and sends the command above"){.didact})
-
-Looking at the pods, you should find a pod corresponding to the API integration:
-
-```
-kubectl get pods
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20pods&completion=Getting%20running%20pods. "Opens a new terminal and sends the command above"){.didact})
-
-If you wait **at least one minute** without invoking the API, you'll find that the pod will disappear.
-Calling the API again will make the pod appear to serve the request. This is done to save resources and it's one the main features of Knative Serving.
-
-You can continue with other commands.
-
-Upload an object:
-```
-curl -i -X PUT --header "Content-Type: application/octet-stream" --data-binary "@API.java" $URL/example
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$curl%20-i%20-X%20PUT%20--header%20%22Content-Type%3A%20application%2Foctet-stream%22%20--data-binary%20%22%40API.java%22%20%24URL%2Fexample&completion=Use%20the%20API. "Opens a new terminal and sends the command above"){.didact})
-
-Get the new list of objects:
-```
-curl -i $URL/
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$curl%20-i%20$URL&completion=Use%20the%20API. "Opens a new terminal and sends the command above"){.didact})
-
-Get the content of a file:
-```
-curl -i $URL/example
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$curl%20-i%20%24URL%2Fexample&completion=Use%20the%20API. "Opens a new terminal and sends the command above"){.didact})
-
-Delete the file:
-```
-curl -i -X DELETE $URL/example
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$curl%20-i%20-X%20DELETE%20%24URL%2Fexample&completion=Use%20the%20API. "Opens a new terminal and sends the command above"){.didact})
-
-Get (again) the new list of objects:
-```
-curl -i $URL/
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$curl%20-i%20$URL&completion=Use%20the%20API. "Opens a new terminal and sends the command above"){.didact})
-
-
-## 6. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-api```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-api&completion=Removed%20the%20project%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/02-serverless-api/readme.md b/02-serverless-api/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/02-serverless-api/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/02-serverless-api/s3.properties b/02-serverless-api/s3.properties
deleted file mode 100644
index 7d8f9e0..0000000
--- a/02-serverless-api/s3.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-# S3 Configuration
-
-# This configuration should not be kept together with the source code in production.
-
-# Bucket (referenced in the routes)
-api.bucket=camel-k
-# Region of the buket
-camel.component.aws2-s3.region=eu-west-1
-# AWS Access Key ID
-camel.component.aws2-s3.access-key=<put-your-aws-access-key-id-here>
-# AWS Access Key Secret
-camel.component.aws2-s3.secret-key=<put-your-aws-access-key-secret-here>
-# Autocreate the bucket if it doesn't exist
-camel.component.aws2-s3.autoCreateBucket=true
-
-# General configuration
-camel.rest.api-context-path=/openapi.json
\ No newline at end of file
diff --git a/02-serverless-api/test/crud.feature b/02-serverless-api/test/crud.feature
deleted file mode 100644
index ebcea50..0000000
--- a/02-serverless-api/test/crud.feature
+++ /dev/null
@@ -1,65 +0,0 @@
-Feature: the API allows CRUD operations on a S3 bucket
-
-
- Background:
- Given integration api is running
- Given URL: http://api
-
-
- Scenario: LIST objects
- When send GET /
- Then verify HTTP response header Content-Type="application/json"
- And receive HTTP 200 OK
-
-
- Scenario: SAVE object
- Given variable objectName is "citrus:randomString(10)"
- Given variable sampleText is "This is a sample text"
- Given HTTP request header Content-Type is "application/octet-stream"
- Given HTTP request body
- """
- ${sampleText}
- """
- When send PUT /${objectName}
- Then receive HTTP 200 OK
- Then verify HTTP response body
- """
- ${sampleText}
- """
-
-
- Scenario: GET object
- Given variable objectName is "citrus:randomString(10)"
- Given variable sampleText is "This is another sample text"
- Given HTTP request body
- """
- ${sampleText}
- """
- Given HTTP request header Content-Type is "application/octet-stream"
- Given send PUT /${objectName}
- Given receive HTTP 200 OK
- When send GET /${objectName}
- Then receive HTTP 200 OK
- Then verify HTTP response body
- """
- ${sampleText}
- """
-
-
- Scenario: DELETE object
- Given variable objectName is "citrus:randomString(10)"
- Given variable sampleText is "This is yet another sample text"
- Given HTTP request body
- """
- ${sampleText}
- """
- Given HTTP request header Content-Type is "application/octet-stream"
- Given send PUT /${objectName}
- Given receive HTTP 200 OK
- When send DELETE /${objectName}
- Then receive HTTP 204 OK
-
-
- Scenario: expose OpenAPI
- When send GET /openapi.json
- Then receive HTTP 200 OK
diff --git a/02-serverless-api/test/minio.properties b/02-serverless-api/test/minio.properties
deleted file mode 100644
index 03e10c2..0000000
--- a/02-serverless-api/test/minio.properties
+++ /dev/null
@@ -1,17 +0,0 @@
-# S3 Configuration
-
-# This configuration should not be kept together with the source code in production.
-
-# Bucket (referenced in the routes)
-api.bucket=camel-k
-
-# Camel AWS2 S3
-camel.component.aws2-s3.region=eu-west-1
-camel.component.aws2-s3.access-key=minio
-camel.component.aws2-s3.secret-key=minio123
-camel.component.aws2-s3.uri-endpoint-override=http://minio:9000
-camel.component.aws2-s3.override-endpoint=true
-camel.component.aws2-s3.autoCreateBucket=true
-
-# General configuration
-camel.rest.api-context-path=/openapi.json
\ No newline at end of file
diff --git a/02-serverless-api/test/minio.yaml b/02-serverless-api/test/minio.yaml
deleted file mode 100644
index eecfcad..0000000
--- a/02-serverless-api/test/minio.yaml
+++ /dev/null
@@ -1,71 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
- name: minio
-spec:
- selector:
- matchLabels:
- app: minio
- strategy:
- type: Recreate
- template:
- metadata:
- labels:
- app: minio
- spec:
- volumes:
- - name: data
- persistentVolumeClaim:
- claimName: minio-pv-claim
- containers:
- - name: minio
- volumeMounts:
- - name: data
- mountPath: "/data"
- image: minio/minio
- args:
- - server
- - /data
- env:
- - name: MINIO_ROOT_USER
- value: minio
- - name: MINIO_ROOT_PASSWORD
- value: minio123
- ports:
- - containerPort: 9000
- readinessProbe:
- httpGet:
- path: /minio/health/ready
- port: 9000
- initialDelaySeconds: 10
- periodSeconds: 10
- livenessProbe:
- httpGet:
- path: /minio/health/live
- port: 9000
- initialDelaySeconds: 120
- periodSeconds: 20
----
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata:
- name: minio-pv-claim
-spec:
- accessModes:
- - ReadWriteOnce
- resources:
- requests:
- storage: 10Gi
----
-apiVersion: v1
-kind: Service
-metadata:
- name: minio
-spec:
- type: LoadBalancer
- ports:
- - port: 9000
- targetPort: 9000
- protocol: TCP
- selector:
- app: minio
diff --git a/02-serverless-api/test/yaks-config.yaml b/02-serverless-api/test/yaks-config.yaml
deleted file mode 100644
index 514cfe4..0000000
--- a/02-serverless-api/test/yaks-config.yaml
+++ /dev/null
@@ -1,14 +0,0 @@
-config:
- namespace:
- temporary: true
-pre:
-- name: minio installation
- run: |
- kubectl apply -f minio.yaml -n ${YAKS_NAMESPACE}
- kubectl wait pod -l app=minio --for condition=Ready -n ${YAKS_NAMESPACE} --timeout=5m
-
-- name: integration
- run: |
- kamel install -w -n ${YAKS_NAMESPACE}
-
- kamel run API.java --property file:test/minio.properties -w -n ${YAKS_NAMESPACE}
diff --git a/03-knative-source-basic/readme.didact.md b/03-knative-source-basic/readme.didact.md
deleted file mode 100644
index a9e3ff6..0000000
--- a/03-knative-source-basic/readme.didact.md
+++ /dev/null
@@ -1,173 +0,0 @@
-# Camel Knative Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 03-knative-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2003-knative-source-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-source` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [telegram.properties](didact://?commandId=vscode.openFolder&projectFilePath=03-knative-source-basic/telegram.properties&completion=Opened%20the%20telegram.properties%20file "Opens the telegram.properties file"){.didact} that can be used to generate a Kubernetes Secret with the Telegram Bot Token obtained with the [@BotFather](https://telegram.me/botfather) by replacing `
-<token-from-botfather>` with the actual token.
-
-```
-kubectl create secret generic telegram --from-file=telegram.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20telegram%20--from-file%3Dtelegram.properties&completion=secret%20%22telegram%22%20created. "Create a secret with Telegram credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f telegram-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20telegram-channel.yaml&completion=inmemorychannel.messaging.knative.dev/telegram$20created. "Create a Knative InMemoryChannel named Telegam"){.didact})
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Telegram component](https://camel.apache.org/components/latest/telegram-component.html) that forward messages received by the bot to a Knative channel named `telegram`
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f telegram-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20telegram-source.yaml&completion=camelsource.sources.knative.dev/camel-telegram-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-
-## 2. Running a basic integration to echo messages from Telegam in the console
-
-
-```
-kamel run telegram-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20telegram-consumer.groovy%20--dev&completion=Camel%20K%20telegram-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running and printing the mesage you have sent to tour Telegram Bot.
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-source&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/03-knative-source-basic/readme.md b/03-knative-source-basic/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/03-knative-source-basic/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/03-knative-source-basic/telegram-channel.yaml b/03-knative-source-basic/telegram-channel.yaml
deleted file mode 100644
index 3e66f6d..0000000
--- a/03-knative-source-basic/telegram-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: telegram
\ No newline at end of file
diff --git a/03-knative-source-basic/telegram-consumer.groovy b/03-knative-source-basic/telegram-consumer.groovy
deleted file mode 100644
index b078279..0000000
--- a/03-knative-source-basic/telegram-consumer.groovy
+++ /dev/null
@@ -1,9 +0,0 @@
-// camel-k: dependency=camel-jackson
-//
-// Apache Camel Telegram Consumer
-//
-from('knative:channel/telegram')
- .unmarshal()
- .json()
- .setBody { it.in.body.text }
- .log('Received: ${body}')
diff --git a/03-knative-source-basic/telegram-source.yaml b/03-knative-source-basic/telegram-source.yaml
deleted file mode 100644
index d888fed..0000000
--- a/03-knative-source-basic/telegram-source.yaml
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-# Apache Camel Telegram Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-telegram-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: telegram
- dependencies:
- - camel:jackson
- flow:
- from:
- uri: telegram:bots
- parameters:
- # Telegram token obtained by BotFather and defined
- # in the telegram.properties
- authorizationToken: "{{telegram.token}}"
- steps:
- - to: "log:received?showAll=true&multiline=true"
- - marshal:
- json: {}
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: telegram
diff --git a/03-knative-source-basic/telegram.properties b/03-knative-source-basic/telegram.properties
deleted file mode 100644
index 4931752..0000000
--- a/03-knative-source-basic/telegram.properties
+++ /dev/null
@@ -1,4 +0,0 @@
-#
-# Telegram Secret
-#
-telegram.token = <token-from-botfather>
\ No newline at end of file
diff --git a/04-aws-kinesis-source-basic/aws-kinesis-channel.yaml b/04-aws-kinesis-source-basic/aws-kinesis-channel.yaml
deleted file mode 100644
index 4381711..0000000
--- a/04-aws-kinesis-source-basic/aws-kinesis-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: aws-kinesis
\ No newline at end of file
diff --git a/04-aws-kinesis-source-basic/aws-kinesis-consumer.groovy b/04-aws-kinesis-source-basic/aws-kinesis-consumer.groovy
deleted file mode 100644
index e1da006..0000000
--- a/04-aws-kinesis-source-basic/aws-kinesis-consumer.groovy
+++ /dev/null
@@ -1,13 +0,0 @@
-// camel-k: dependency=camel-aws-kinesis dependency=camel-base64
-//
-// Apache Camel Kinesis Consumer
-//
-
-// So we unmarshal it, extract the data element which is in base64 format and decode it
-from('knative:channel/aws-kinesis')
- .unmarshal()
- .json()
- .setBody { it.in.body.data }
- .unmarshal()
- .base64()
- .log('Received: ${body}')
diff --git a/04-aws-kinesis-source-basic/aws-kinesis-producer.groovy b/04-aws-kinesis-source-basic/aws-kinesis-producer.groovy
deleted file mode 100644
index d96a29b..0000000
--- a/04-aws-kinesis-source-basic/aws-kinesis-producer.groovy
+++ /dev/null
@@ -1,13 +0,0 @@
-// camel-k: dependency=camel-aws-kinesis
-//
-// Apache Camel Kinesis Consumer
-//
-// This is just a sample producer for AWS that creates 100 messages every 3 seconds
-from('timer:java?period=3000&repeatCount=100')
- .setHeader("CamelAwsKinesisPartitionKey")
- .constant("p-01123")
- .setHeader("CamelAwsKinesisSequenceNumber")
- .constant(1)
- .setBody()
- .simple('Hello Camel K')
- .to('aws-kinesis:stream?accessKey={{aws.kinesis.accessKey}}&secretKey={{aws.kinesis.secretKey}}®ion={{aws.kinesis.region}}')
diff --git a/04-aws-kinesis-source-basic/aws-kinesis-source.yaml b/04-aws-kinesis-source-basic/aws-kinesis-source.yaml
deleted file mode 100644
index cf6549f..0000000
--- a/04-aws-kinesis-source-basic/aws-kinesis-source.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-#
-# Apache Camel AWS Kinesis Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-aws-kinesis-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: aws-kinesis
- dependencies:
- # Needed for the json part on the flow/steps below
- - camel:jackson
- # Needed for the AWS Kinesis component
- - camel:camel-aws-kinesis
- - mvn:com.fasterxml.jackson.dataformat/jackson-dataformat-cbor/2.10.4
- flow:
- from:
- # On the URI below, the Kinesis stream named 'stream' can be adjusted
- # to any value suitable in your scenario (ie.: aws-kinesis:my-stream-name)
- uri: aws-kinesis:stream
- parameters:
- secretKey: "{{aws.kinesis.secretKey}}"
- accessKey: "{{aws.kinesis.accessKey}}"
- region: "{{aws.kinesis.region}}"
- steps:
- - to: "log:received?showAll=true&multiline=true"
- - marshal:
- json: {}
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: aws-kinesis
diff --git a/04-aws-kinesis-source-basic/aws-kinesis.properties b/04-aws-kinesis-source-basic/aws-kinesis.properties
deleted file mode 100644
index a9d43a2..0000000
--- a/04-aws-kinesis-source-basic/aws-kinesis.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-aws.kinesis.accessKey=accessKey
-aws.kinesis.secretKey=secretKey
-aws.kinesis.region=region
diff --git a/04-aws-kinesis-source-basic/readme.didact.md b/04-aws-kinesis-source-basic/readme.didact.md
deleted file mode 100644
index 3068c45..0000000
--- a/04-aws-kinesis-source-basic/readme.didact.md
+++ /dev/null
@@ -1,185 +0,0 @@
-# Camel AWS Kinesis Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-You must create an AWS Kinesis stream named `stream` on your AWS account.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 04-aws-kinesis-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2004-aws-kinesis-source-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `aws-kinesis-event-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace aws-kinesis-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20aws-kinesis-source-basic&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `aws-kinesis-source-basic` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=aws-kinesis-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Daws-kinesis-source-basic&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `aws-kinesis-source-basic` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [aws-kinesis.properties](didact://?commandId=vscode.openFolder&projectFilePath=04-aws-kinesis-source-basic/aws-kinesis.properties&completion=Opened%20the%aws-kinesis.properties%20file "Opens the aws-kinesis.properties file"){.didact} that contains the access key and secret key for accessing the AWS Kinesis stream.
-
-```
-kubectl create secret generic aws-kinesis --from-file=aws-kinesis.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20aws-kinesis%20--from-file%3Daws-kinesis.properties&completion=secret%20%22aws-kinesis%22%20created. "Create a secret with AWS Kinesis credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f aws-kinesis-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-kinesis-channel.yaml&completion=inmemorychannel.messaging.knative.dev/aws-kinesis$20created. "Create a Knative InMemoryChannel named aws-kinesis"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [AWS Kinesis component](https://camel.apache.org/components/latest/aws-kinesis-component.html) that forward streaming events received on the AWS Kinesis stream to a Knative channel named `aws-kinesis`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f aws-kinesis-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-kinesis-source.yaml&completion=camelsource.sources.knative.dev/camel-aws-kinesis-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create Kinesis events for consumption by the Camel Source
-
-You need a producer adding data to a Kinesis stream to try this example. This integration
-comes with a sample producer that will send 100 messages with the text `Hello Camel K`
-every 3 seconds.
-
-```
-kamel run --secret aws-kinesis aws-kinesis-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20aws-kinesis%20aws-kinesis-producer.groovy&completion=Camel%20K%20aws-kinesis-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration to forward Kinesis events to the console
-
-```
-kamel run aws-kinesis-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20aws-kinesis-consumer.groovy%20--dev&completion=Camel%20K%20aws-kinesis-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace aws-kinesis-source-basic```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20aws-kinesis-source-basic&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/04-aws-kinesis-source-basic/readme.md b/04-aws-kinesis-source-basic/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/04-aws-kinesis-source-basic/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/05-knative-source-jira/README.md b/05-knative-source-jira/README.md
deleted file mode 100644
index 14512e4..0000000
--- a/05-knative-source-jira/README.md
+++ /dev/null
@@ -1,180 +0,0 @@
-# Camel Knative JIRA Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 05-knative-source-jira
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2005-knative-source-jira&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-jira-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-jira-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-jira-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-jira-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-jira-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-jira-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-jira-source` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install --maven-repository https://maven.atlassian.com/repository/public
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install%20--maven-repository%20https://maven.atlassian.com/repository/public&completion=Installing%20Camel-K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-We need also add atlassian repository so jira client can be sucessfully downloaded.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [jira.properties](didact://?commandId=vscode.openFolder&projectFilePath=0x-jira-service-event-source/jira.properties&completion=Opened%20the%jira.properties%20file "Opens the jira.properties file"){.didact} that contains basic configuration properties for the jira component:
-
- - `jira.url` URL to jira instance
- - `jira.username` Username for jira
- - `jira.password` - password/access token *
- - `jira.jql` - JQL that contains at least PROJECT (`PROJECT=CAMEL`)
-
-NOTE: For atlassian cloud jira password can't be used so it's necessary to create an API token and use it instead of user password. https://confluence.atlassian.com/cloud/api-tokens-938839638.html
-
-```
-kubectl create secret generic jira --from-file=jira.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20jira%20--from-file%3Djira.properties&completion=secret%20%22jira%22%20created. "Create a secret with jira configuration"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f jira-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20jira-channel.yaml&completion=inmemorychannel.messaging.knative.dev/telegram$20created. "Create a Knative InMemoryChannel named jira"){.didact})
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Jira component](https://camel.apache.org/components/latest/jira-component.html) that sends new comments/issues created in certain jira project. To forward new comments change uri defined in source definiton from ` uri: jira:newIssues` to `uri: jira:newComments`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f jira-new-issues.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20jira-new-issues.yaml&completion=camelsource.sources.knative.dev/camel-telegram-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-
-## 2. Running a basic integration to see new issues in the console
-
-
-```
-kamel run jira-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20jira-consumer.groovy%20--dev&completion=Camel%20K%20jira-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running and printing the mesage you have sent to tour Telegram Bot.
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-jira-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-jira-source&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/05-knative-source-jira/jira-channel.yaml b/05-knative-source-jira/jira-channel.yaml
deleted file mode 100644
index 8e14b62..0000000
--- a/05-knative-source-jira/jira-channel.yaml
+++ /dev/null
@@ -1,5 +0,0 @@
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: jira
-
diff --git a/05-knative-source-jira/jira-consumer.groovy b/05-knative-source-jira/jira-consumer.groovy
deleted file mode 100644
index 347ae1c..0000000
--- a/05-knative-source-jira/jira-consumer.groovy
+++ /dev/null
@@ -1,7 +0,0 @@
-from('knative:channel/jira')
-.unmarshal()
-.json()
-.setBody { "KEY:"+ it.in.body.key+"| Summary"+ it.in.body.summary }
-.log('Recieved: ${body}')
-.setBody {}
-
diff --git a/05-knative-source-jira/jira-new-issues.yaml b/05-knative-source-jira/jira-new-issues.yaml
deleted file mode 100644
index e42cd09..0000000
--- a/05-knative-source-jira/jira-new-issues.yaml
+++ /dev/null
@@ -1,40 +0,0 @@
-#
-# Apache Camel jira Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-jira-new-issues-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: jira
- dependencies:
- - camel:jackson
- - mvn:org.apache.httpcomponents:httpclient:jar:4.5.12
- - mvn:com.atlassian.jira:jira-rest-java-client-core:jar:5.2.1
- - mvn:com.atlassian.jira:jira-rest-java-client-api:jar:5.2.1
- - mvn:org.codehaus.jettison:jettison:jar:1.4.1
- flow:
- from:
- uri: jira:newIssues
- parameters:
- # in the jira.properties
- jiraUrl: "{{jira.url}}"
- username: "{{jira.username}}"
- #if jira cloud is used, use created API token instead of your password.
- password: "{{jira.password}}"
- jql: "{{jira.jql}}"
- delay: "500"
- steps:
- - to: "log:received?showAll=true&multiline=true"
- - marshal:
- json: {}
-
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1alpha1
- kind: InMemoryChannel
- name: jira
diff --git a/05-knative-source-jira/jira.properties b/05-knative-source-jira/jira.properties
deleted file mode 100644
index 58b4508..0000000
--- a/05-knative-source-jira/jira.properties
+++ /dev/null
@@ -1,4 +0,0 @@
-jira.url=<JIRA_URL>
-jira.username=<USERNAME>
-jira.password=<PASSWORD>
-jira.jql=PROJECT=<PROJECT>
diff --git a/05-knative-source-jira/readme.didact.md b/05-knative-source-jira/readme.didact.md
deleted file mode 100644
index 29d1888..0000000
--- a/05-knative-source-jira/readme.didact.md
+++ /dev/null
@@ -1,180 +0,0 @@
-# Camel Knative JIRA Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/ for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 05-knative-source-jira
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2005-knative-source-jira&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-jira-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-jira-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-jira-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-jira-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-jira-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-jira-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-jira-source` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install --maven-repository https://maven.atlassian.com/repository/public
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install%20--maven-repository%20https://maven.atlassian.com/repository/public&completion=Installing%20Camel-K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-We need also add atlassian repository so jira client can be sucessfully downloaded.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [jira.properties](didact://?commandId=vscode.openFolder&projectFilePath=0x-jira-service-event-source/jira.properties&completion=Opened%20the%jira.properties%20file "Opens the jira.properties file"){.didact} that contains basic configuration properties for the jira component:
-
- - `jira.url` URL to jira instance
- - `jira.username` Username for jira
- - `jira.password` - password/access token *
- - `jira.jql` - JQL that contains at least PROJECT (`PROJECT=CAMEL`)
-
-NOTE: For atlassian cloud jira password can't be used so it's necessary to create an API token and use it instead of user password. https://confluence.atlassian.com/cloud/api-tokens-938839638.html
-
-```
-kubectl create secret generic jira --from-file=jira.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20jira%20--from-file%3Djira.properties&completion=secret%20%22jira%22%20created. "Create a secret with jira configuration"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f jira-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20jira-channel.yaml&completion=inmemorychannel.messaging.knative.dev/telegram$20created. "Create a Knative InMemoryChannel named jira"){.didact})
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Jira component](https://camel.apache.org/components/latest/jira-component.html) that sends new comments/issues created in certain jira project. To forward new comments change uri defined in source definiton from ` uri: jira:newIssues` to `uri: jira:newComments`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f jira-new-issues.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20jira-new-issues.yaml&completion=camelsource.sources.knative.dev/camel-telegram-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-
-## 2. Running a basic integration to see new issues in the console
-
-
-```
-kamel run jira-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20jira-consumer.groovy%20--dev&completion=Camel%20K%20jira-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running and printing the mesage you have sent to tour Telegram Bot.
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-jira-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-jira-source&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/06-aws-kinesis-firehose-basic/aws-kinesis-firehose-producer.groovy b/06-aws-kinesis-firehose-basic/aws-kinesis-firehose-producer.groovy
deleted file mode 100644
index 34939ca..0000000
--- a/06-aws-kinesis-firehose-basic/aws-kinesis-firehose-producer.groovy
+++ /dev/null
@@ -1,9 +0,0 @@
-// camel-k: dependency=camel-aws2-kinesis
-//
-// Apache Camel Kinesis Consumer
-//
-// This is just a sample producer for AWS that creates 100 messages every 3 seconds
-from('timer:java?period=3000&repeatCount=100')
- .setBody()
- .simple('Hello Camel K')
- .to('aws2-kinesis-firehose:stream?accessKey={{aws.kinesis.accessKey}}&secretKey={{aws.kinesis.secretKey}}®ion={{aws.kinesis.region}}')
diff --git a/06-aws-kinesis-firehose-basic/aws-s3-channel.yaml b/06-aws-kinesis-firehose-basic/aws-s3-channel.yaml
deleted file mode 100644
index f9f2fa7..0000000
--- a/06-aws-kinesis-firehose-basic/aws-s3-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: aws-s3-kinesis-firehose
diff --git a/06-aws-kinesis-firehose-basic/aws-s3-consumer.groovy b/06-aws-kinesis-firehose-basic/aws-s3-consumer.groovy
deleted file mode 100644
index f58d8e3..0000000
--- a/06-aws-kinesis-firehose-basic/aws-s3-consumer.groovy
+++ /dev/null
@@ -1,8 +0,0 @@
-// camel-k: dependency=camel-aws2-s3 dependency=camel-base64
-//
-// Apache Camel S3 Consumer
-//
-
-// So we unmarshal it, extract the data element which is in base64 format and decode it
-from('knative:channel/aws-s3-kinesis-firehose')
- .log('Received: ${body}')
diff --git a/06-aws-kinesis-firehose-basic/aws-s3-source.yaml b/06-aws-kinesis-firehose-basic/aws-s3-source.yaml
deleted file mode 100644
index e0fa44c..0000000
--- a/06-aws-kinesis-firehose-basic/aws-s3-source.yaml
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-# Apache Camel AWS S3 Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-aws-s3-kinesis-firehose-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: aws-services
- dependencies:
- # Needed for the json part on the flow/steps below
- - camel:jackson
- # Needed for the AWS S3 component component
- - camel:camel-aws2-s3
- flow:
- from:
- uri: aws2-s3:datalake25
- parameters:
- secretKey: "{{aws.s3.secretKey}}"
- accessKey: "{{aws.s3.accessKey}}"
- region: "{{aws.s3.region}}"
- moveAfterRead: "true"
- deleteAfterRead: "true"
- destinationBucket: "backupdatalake25"
- autocloseBody: "false"
- steps:
- - to: "log:received?showAll=true&multiline=true"
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: aws-s3-kinesis-firehose
diff --git a/06-aws-kinesis-firehose-basic/aws-services.properties b/06-aws-kinesis-firehose-basic/aws-services.properties
deleted file mode 100644
index 20b72aa..0000000
--- a/06-aws-kinesis-firehose-basic/aws-services.properties
+++ /dev/null
@@ -1,6 +0,0 @@
-aws.kinesis.accessKey=accessKey
-aws.kinesis.secretKey=secretKey
-aws.kinesis.region=region
-aws.s3.accessKey=accessKey
-aws.s3.secretKey=secretKey
-aws.s3.region=region
diff --git a/06-aws-kinesis-firehose-basic/readme.didact.md b/06-aws-kinesis-firehose-basic/readme.didact.md
deleted file mode 100644
index 864e468..0000000
--- a/06-aws-kinesis-firehose-basic/readme.didact.md
+++ /dev/null
@@ -1,185 +0,0 @@
-# Camel AWS Kinesis Firehose Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-You must create an AWS Kinesis Firehose delivery stream named `stream` and point it to an S3 bucket called `datalake` followed by a random number on your AWS account.
-Also you'll need to create a bucket `backupdatalake` followed by a random number on your AWS account. This bucket will be used to move the file once consumed from the bucket `datalake` as backup.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 05-aws-kinesis-firehose-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2005-aws-kinesis-firehose-source-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `aws-kinesis-firehose-event-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace aws-kinesis-firehose-event-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20aws-kinesis-firehose-event-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `aws-kinesis-firehose-event-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=aws-kinesis-firehose-event-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Daws-kinesis-firehose-event-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `aws-kinesis-firehose-event-source` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [aws-services.properties](didact://?commandId=vscode.openFolder&projectFilePath=04-aws-kinesis-source-basic/aws-services.properties&completion=Opened%20the%aws-services.properties%20file "Opens the aws-kinesis.properties file"){.didact} that contains the access key and secret key for accessing the AWS Kinesis stream.
-
-```
-kubectl create secret generic aws-services --from-file=aws-services.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20aws-services%20--from-file%3Daws-services.properties&completion=secret%20%22aws-services%22%20created. "Create a secret with AWS Kinesis credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f aws-s3-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-s3-channel.yaml&completion=inmemorychannel.messaging.knative.dev/aws-s3$20created. "Create a Knative InMemoryChannel named aws-kinesis"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [AWS Kinesis component](https://camel.apache.org/components/latest/aws-kinesis-component.html) that forward streaming events received on the AWS Kinesis delivery stream to a Knative channel named `aws-s3-kinesis-firehose`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f aws-s3-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-s3-source.yaml&completion=camelsource.sources.knative.dev/camel-aws-s3-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create Kinesis events for consumption by the Camel Source
-
-You need a producer adding data to a Kinesis stream to try this example. This integration
-comes with a sample producer that will send 100 messages with the text `Hello Camel K`
-every 3 seconds.
-
-```
-kamel run --secret aws-services aws-kinesis-firehose-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20aws-kinesis%20aws-kinesis-firehose-producer.groovy&completion=Camel%20K%20aws-kinesis-firehose-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration to forward Kinesis events to the console
-
-```
-kamel run aws-s3-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20aws-s3-consumer.groovy%20--dev&completion=Camel%20K%20aws-s3-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace aws-kinesis-firehose-event-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20aws-kinesis-source-basic&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/06-aws-kinesis-firehose-basic/readme.md b/06-aws-kinesis-firehose-basic/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/06-aws-kinesis-firehose-basic/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/07-aws-sqs-source-basic/aws-sqs-channel.yaml b/07-aws-sqs-source-basic/aws-sqs-channel.yaml
deleted file mode 100644
index 43333d3..0000000
--- a/07-aws-sqs-source-basic/aws-sqs-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: aws-sqs
diff --git a/07-aws-sqs-source-basic/aws-sqs-consumer.groovy b/07-aws-sqs-source-basic/aws-sqs-consumer.groovy
deleted file mode 100644
index 35dfbc0..0000000
--- a/07-aws-sqs-source-basic/aws-sqs-consumer.groovy
+++ /dev/null
@@ -1,6 +0,0 @@
-// camel-k: dependency=camel-aws2-sqs dependency=camel-base64
-//
-// Apache Camel SQS Consumer
-//
-from('knative:channel/aws-sqs')
- .log('Received: ${body}')
diff --git a/07-aws-sqs-source-basic/aws-sqs-producer.groovy b/07-aws-sqs-source-basic/aws-sqs-producer.groovy
deleted file mode 100644
index a9e38b6..0000000
--- a/07-aws-sqs-source-basic/aws-sqs-producer.groovy
+++ /dev/null
@@ -1,9 +0,0 @@
-// camel-k: dependency=camel-aws2-sqs
-//
-// Apache Camel SQS Producer
-//
-// This is just a sample producer for AWS that creates 100 messages every 3 seconds
-from('timer:java?period=3000&repeatCount=30')
- .setBody()
- .simple('Hello Camel K')
- .to('aws2-sqs:eventqueue?accessKey={{aws.sqs.accessKey}}&secretKey={{aws.sqs.secretKey}}®ion={{aws.sqs.region}}')
diff --git a/07-aws-sqs-source-basic/aws-sqs-source.yaml b/07-aws-sqs-source-basic/aws-sqs-source.yaml
deleted file mode 100644
index 1fe7c93..0000000
--- a/07-aws-sqs-source-basic/aws-sqs-source.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-#
-# Apache Camel AWS Kinesis Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-aws-sqs-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: aws-sqs
- dependencies:
- # Needed for the json part on the flow/steps below
- - camel:jackson
- # Needed for the AWS Kinesis component
- - camel:camel-aws2-sqs
- flow:
- from:
- # On the URI below, the queue named 'eventqueue' can be adjusted
- # to any value suitable in your scenario (ie.: aws-sqs:my-queue)
- uri: aws2-sqs:eventqueue
- parameters:
- secretKey: "{{aws.sqs.secretKey}}"
- accessKey: "{{aws.sqs.accessKey}}"
- region: "{{aws.sqs.region}}"
- deleteAfterRead: "true"
- steps:
- - to: "log:received?showAll=true&multiline=true"
- - marshal:
- json: {}
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: aws-sqs
diff --git a/07-aws-sqs-source-basic/aws-sqs.properties b/07-aws-sqs-source-basic/aws-sqs.properties
deleted file mode 100644
index a072f05..0000000
--- a/07-aws-sqs-source-basic/aws-sqs.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-aws.sqs.accessKey=accesskey
-aws.sqs.secretKey=secretkey
-aws.sqs.region=region
diff --git a/07-aws-sqs-source-basic/readme.didact.md b/07-aws-sqs-source-basic/readme.didact.md
deleted file mode 100644
index 7ccfbcd..0000000
--- a/07-aws-sqs-source-basic/readme.didact.md
+++ /dev/null
@@ -1,183 +0,0 @@
-# Camel AWS SQS Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 07-aws-sqs-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2007-aws-sqs-source-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `aws-sqs-source-basic` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace aws-sqs-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20aws-sqs-source-basic&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `aws-sqs-source-basic` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=aws-sqs-source-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Daws-sqs-source-basic&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `aws-sqs-source-basic` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [aws-sqs.properties](didact://?commandId=vscode.openFolder&projectFilePath=07-aws-sqs-source-basic/aws-sqs.properties&completion=Opened%20the%aws-sqs.properties%20file "Opens the aws-sqs.properties file"){.didact} that contains the access key and secret key for accessing the AWS SQS eventqueue queue.
-
-```
-kubectl create secret generic aws-sqs --from-file=aws-sqs.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20aws-sqs%20--from-file%3Daws-sqs.properties&completion=secret%20%22aws-sqs%22%20created. "Create a secret with AWS SQS credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f aws-sqs-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-sqs-channel.yaml&completion=inmemorychannel.messaging.knative.dev/aws-sqs$20created. "Create a Knative InMemoryChannel named aws-sqs"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [AWS SQS component](https://camel.apache.org/components/latest/aws-sqs-component.html) that forward messages events received on the AWS SQS queue events to a Knative channel named `aws-sqs`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f aws-sqs-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-sqs-source.yaml&completion=camelsource.sources.knative.dev/camel-aws-sqs-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create SQS events for consumption by the Camel Source
-
-You need a producer adding data to a SQS queue to try this example. This integration
-comes with a sample producer that will send 30 messages with the text `Hello Camel K`
-every 3 seconds.
-
-```
-kamel run --secret aws-sqs aws-sqs-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20aws-sqs%20aws-sqs-producer.groovy&completion=Camel%20K%20aws-sqs-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration to forward SQS events to the console
-
-```
-kamel run aws-sqs-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20aws-sqs-consumer.groovy%20--dev&completion=Camel%20K%20aws-sqs-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace aws-sqs-source-basic```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20aws-sqs-source-basic&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/07-aws-sqs-source-basic/readme.md b/07-aws-sqs-source-basic/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/07-aws-sqs-source-basic/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/08-azure-storage-blob-basic/azure-storage-blob-channel.yaml b/08-azure-storage-blob-basic/azure-storage-blob-channel.yaml
deleted file mode 100644
index 1d1e08a..0000000
--- a/08-azure-storage-blob-basic/azure-storage-blob-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: azure-blob
diff --git a/08-azure-storage-blob-basic/azure-storage-blob-consumer.groovy b/08-azure-storage-blob-basic/azure-storage-blob-consumer.groovy
deleted file mode 100644
index 6aa78d3..0000000
--- a/08-azure-storage-blob-basic/azure-storage-blob-consumer.groovy
+++ /dev/null
@@ -1,21 +0,0 @@
-// camel-k: dependency=camel-azure-storage-blob
-//
-// Apache Camel Azure Storage Blob Consumer
-//
-import static org.apache.camel.support.processor.idempotent.MemoryIdempotentRepository.memoryIdempotentRepository
-
-from('knative:channel/azure-blob')
- .setHeader('orderId', xpath("/order/@id",String.class))
-//use idempotent consumer to process an order only once
- .idempotentConsumer(header("orderId"), memoryIdempotentRepository(50))
- .log('Received:\n${body}')
- .split()
- .xpath('/order/item')
- .setHeader('lineItemId', xpath("/item/@id",String.class))
- .setHeader('CamelAzureStorageBlobBlobName', simple('${header.lineItemId}-${header.orderId}.xml'))
- .log('Uploading Item ${header.CamelAzureStorageBlobBlobName}:\n${body}')
- .to('azure-storage-blob:{{azure.blob.accountName}}/{{azure.blob.itemsContainerName}}?accessKey=RAW({{azure.blob.accessKey}})&operation=uploadBlockBlob')
-
-
-
-
diff --git a/08-azure-storage-blob-basic/azure-storage-blob-producer.groovy b/08-azure-storage-blob-basic/azure-storage-blob-producer.groovy
deleted file mode 100644
index e866bfa..0000000
--- a/08-azure-storage-blob-basic/azure-storage-blob-producer.groovy
+++ /dev/null
@@ -1,69 +0,0 @@
-// camel-k: dependency=camel-azure-storage-blob
-//
-// Apache Camel Azure Storage Blob Producer
-//
-// This is just a sample producer for Azure that creates a blob in a container
-import com.azure.storage.blob.models.BlobStorageException
-
-from('timer:java?period=3000&repeatCount=1')
-//create needed containers if not exist
- .doTry()
- .to('azure-storage-blob:{{azure.blob.accountName}}/{{azure.blob.ordersContainerName}}?accessKey=RAW({{azure.blob.accessKey}})&operation=createBlobContainer')
- .doCatch(BlobStorageException.class)
- .log('{{azure.blob.ordersContainerName}} container already exist! ')
- .end()
-
- .doTry()
- .to('azure-storage-blob:{{azure.blob.accountName}}/{{azure.blob.itemsContainerName}}?accessKey=RAW({{azure.blob.accessKey}})&operation=createBlobContainer')
- .doCatch(BlobStorageException.class)
- .log('{{azure.blob.itemsContainerName}} container already exist!')
- .end()
-//send the order
- .setBody()
- .constant('''
-<?xml version="1.0" encoding="UTF-8"?>
-<order id="5ece4797eaf5e">
- <item id="item1">
- <name>Precision</name>
- <mfg>Fender</mfg>
- </item>
- <item id="item2">
- <name>Jazz</name>
- <mfg>Fender</mfg>
- </item>
- <item id="item3">
- <name>Thunderbird</name>
- <mfg>Gibson</mfg>
- </item>
- <item id="item4">
- <name>Ripper</name>
- <mfg>Gibson</mfg>
- </item>
- <item id="item5">
- <name>4003</name>
- <mfg>Rickenbacker</mfg>
- </item>
- <item id="item6">
- <name>Metroline</name>
- <mfg>Sadowsky</mfg>
- </item>
- <item id="item7">
- <name>Imperial Elite</name>
- <mfg>Fodera</mfg>
- </item>
- <item id="item8">
- <name>Yin Yang Std 4</name>
- <mfg>Fodera</mfg>
- </item>
- <item id="item9">
- <name>BN5</name>
- <mfg>Furlanetto</mfg>
- </item>
- <item id="item10">
- <name>VF4-P</name>
- <mfg>Furlanetto</mfg>
- </item>
-</order>
-''')
- .to('azure-storage-blob:{{azure.blob.accountName}}/{{azure.blob.ordersContainerName}}?accessKey=RAW({{azure.blob.accessKey}})&blobName={{azure.blob.blobName}}&operation=uploadBlockBlob')
- .log('Message sent: ${body}')
diff --git a/08-azure-storage-blob-basic/azure-storage-blob-source.yaml b/08-azure-storage-blob-basic/azure-storage-blob-source.yaml
deleted file mode 100644
index 3c21342..0000000
--- a/08-azure-storage-blob-basic/azure-storage-blob-source.yaml
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Apache Camel Azure Storage Blob Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-azure-storage-blob
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: azure-storage-blob
- dependencies:
- # Needed for the Azure Storage Blob component
- - camel:camel-azure-storage-blob
- flow:
- from:
- # On the URI below, the Azure account name named 'camelazure' and container name named 'orders'
- # can be adjusted to any values suitable in your scenario
- uri: azure-storage-blob:camelazure/orders
- parameters:
- blobName: "{{azure.blob.blobName}}"
- accessKey: "{{azure.blob.accessKey}}"
-
- steps:
- - to: "log:received?showAll=true&multiline=true"
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: azure-blob
diff --git a/08-azure-storage-blob-basic/azure-storage-blob.properties b/08-azure-storage-blob-basic/azure-storage-blob.properties
deleted file mode 100644
index 4f65533..0000000
--- a/08-azure-storage-blob-basic/azure-storage-blob.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-azure.blob.accessKey=FillMe
-azure.blob.accountName=FillMe
-azure.blob.ordersContainerName=orders
-azure.blob.itemsContainerName=line-item-outbox
-azure.blob.blobName=orders.xml
diff --git a/08-azure-storage-blob-basic/readme.didact.md b/08-azure-storage-blob-basic/readme.didact.md
deleted file mode 100644
index 538f58c..0000000
--- a/08-azure-storage-blob-basic/readme.didact.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Camel Azure Storage Blob Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 08-azure-storage-blob-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2008-azure-storage-blob-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-k-azure-blob-knative` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-k-azure-blob-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-k-azure-blob-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `camel-k-azure-blob-knative` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-k-azure-blob-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-k-azure-blob-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-k-azure-blob-knative` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [azure-storage-blob.properties](didact://?commandId=vscode.openFolder&projectFilePath=08-azure-storage-blob-basic/azure-storage-blob.properties&completion=Opened%20the%azure-storage-blob.properties%20file "Opens the azure-storage-blob.properties file"){.didact} that contains the access key for accessing the Azure Storage Blob containers.
-
-```
-kubectl create secret generic azure-storage-blob --from-file=azure-storage-blob.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20azure-storage-blob%20--from-file%3Dazure-storage-blob.properties&completion=secret%20%22azure-storage-blob%22%20created. "Create a secret with Azure Storage credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f azure-storage-blob-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-blob-channel.yaml&completion=inmemorychannel.messaging.knative.dev/azure-blob$20created. "Create a Knative InMemoryChannel named azure-blob"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Azure Storage Blob Service component](https://camel.apache.org/components/latest/azure-storage-blob-component.html) that forward messages events received on the Azure Blob container orders to a Knative channel named `azure-blob`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f azure-storage-blob-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-blob-source.yaml&completion=camelsource.sources.knative.dev/camel-azure-storage-blob%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create Azure Storage Blob for consumption by the Camel Source
-
-You need a producer adding data to `orders` Azure Blob Container to try this example. This integration
-comes with a sample producer that will upload a xml file.
-
-```
-kamel run --secret azure-storage-blob azure-storage-blob-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20azure-storage-blob%20azure-storage-blob-producer.groovy&completion=Camel%20K%20azure-storage-blob-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration that split the order in line items and forward them to `line-item-outbox` container
-```
-kamel run azure-storage-blob-consumer.groovy --dev --secret azure-storage-blob
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20azure-storage-blob-consumer.groovy%20--dev%20--secret%20azure-storage-blob&completion=Camel%20K%20azure-storage-blob-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-k-azure-blob-knative```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-k-azure-blob-knative&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/08-azure-storage-blob-basic/readme.md b/08-azure-storage-blob-basic/readme.md
deleted file mode 100644
index 888260f..0000000
--- a/08-azure-storage-blob-basic/readme.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Camel Azure Storage Blob Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 08-azure-storage-blob-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2008-azure-storage-blob-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-k-azure-blob-knative` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-k-azure-blob-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-k-azure-blob-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `camel-k-azure-blob-knative` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-k-azure-blob-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-k-azure-blob-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-k-azure-blob-knative` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [azure-storage-blob.properties](didact://?commandId=vscode.openFolder&projectFilePath=08-azure-storage-blob-basic/azure-storage-blob.properties&completion=Opened%20the%azure-storage-blob.properties%20file "Opens the azure-storage-blob.properties file"){.didact} that contains basic configuration properties for the Azure Storage Blob component.
-
-```
-kubectl create secret generic azure-storage-blob --from-file=azure-storage-blob.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20azure-storage-blob%20--from-file%3Dazure-storage-blob.properties&completion=secret%20%22azure-storage-blob%22%20created. "Create a secret with Azure Storage credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f azure-storage-blob-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-blob-channel.yaml&completion=inmemorychannel.messaging.knative.dev/azure-blob$20created. "Create a Knative InMemoryChannel named azure-blob"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Azure Storage Blob Service component](https://camel.apache.org/components/latest/azure-storage-blob-component.html) that forward messages events received on the Azure Blob container orders to a Knative channel named `azure-blob`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f azure-storage-blob-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-blob-source.yaml&completion=camelsource.sources.knative.dev/camel-azure-storage-blob%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create Azure Storage Blob for consumption by the Camel Source
-
-You need a producer adding data to `orders` Azure Blob Container to try this example. This integration
-comes with a sample producer that will upload a xml file.
-
-```
-kamel run --secret azure-storage-blob azure-storage-blob-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20azure-storage-blob%20azure-storage-blob-producer.groovy&completion=Camel%20K%20azure-storage-blob-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration that split the order in line items and forward them to `line-item-outbox` container
-```
-kamel run azure-storage-blob-consumer.groovy --dev --secret azure-storage-blob
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20azure-storage-blob-consumer.groovy%20--dev%20--secret%20azure-storage-blob&completion=Camel%20K%20azure-storage-blob-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-k-azure-blob-knative```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-k-azure-blob-knative&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
\ No newline at end of file
diff --git a/09-azure-storage-queue-basic/azure-storage-queue-channel.yaml b/09-azure-storage-queue-basic/azure-storage-queue-channel.yaml
deleted file mode 100644
index 8cda507..0000000
--- a/09-azure-storage-queue-basic/azure-storage-queue-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: azure-queue
diff --git a/09-azure-storage-queue-basic/azure-storage-queue-consumer.groovy b/09-azure-storage-queue-basic/azure-storage-queue-consumer.groovy
deleted file mode 100644
index 19af50c..0000000
--- a/09-azure-storage-queue-basic/azure-storage-queue-consumer.groovy
+++ /dev/null
@@ -1,9 +0,0 @@
-// camel-k: dependency=camel-azure-storage-queue
-//
-// Apache Camel Azure Storage Queue Consumer
-//
-
-from('knative:channel/azure-queue')
- .log('Received: ${body}')
-
-
diff --git a/09-azure-storage-queue-basic/azure-storage-queue-producer.groovy b/09-azure-storage-queue-basic/azure-storage-queue-producer.groovy
deleted file mode 100644
index c6d4b5c..0000000
--- a/09-azure-storage-queue-basic/azure-storage-queue-producer.groovy
+++ /dev/null
@@ -1,11 +0,0 @@
-// camel-k: dependency=camel-azure-storage-queue
-//
-// Apache Camel Azure Storage Queue Producer
-//
-// This is just a sample producer for Azure that sends messages to an Azure storage queue
-
-import static org.apache.camel.component.azure.storage.queue.QueueConstants.MESSAGE_TEXT
-
-from('timer:java?period=3000&repeatCount=30')
- .setHeader(MESSAGE_TEXT, constant('Hello Camel K'))
- .to('azure-storage-queue:{{azure.queue.accountName}}/{{azure.queue.queueName}}?accessKey=RAW({{azure.queue.accessKey}})&operation=sendMessage')
\ No newline at end of file
diff --git a/09-azure-storage-queue-basic/azure-storage-queue-source.yaml b/09-azure-storage-queue-basic/azure-storage-queue-source.yaml
deleted file mode 100644
index 5a405e2..0000000
--- a/09-azure-storage-queue-basic/azure-storage-queue-source.yaml
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-# Apache Camel Azure Storage Queue Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-azure-storage-queue
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: azure-storage-queue
- dependencies:
- # Needed for the Azure Storage Queue component
- - camel:camel-azure-storage-queue
- flow:
- from:
- # On the URI below, the Azure account name named 'camelazure' and queue name named 'messages'
- # can be adjusted to any values suitable in your scenario
- uri: azure-storage-queue:camelazure/messages
- parameters:
- accessKey: "{{azure.queue.accessKey}}"
-
- steps:
- - to: "log:received?showAll=true&multiline=true"
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: azure-queue
diff --git a/09-azure-storage-queue-basic/azure-storage-queue.properties b/09-azure-storage-queue-basic/azure-storage-queue.properties
deleted file mode 100644
index 8418913..0000000
--- a/09-azure-storage-queue-basic/azure-storage-queue.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-azure.queue.accessKey=FillMe
-azure.queue.accountName=FillMe
-azure.queue.queueName=messages
\ No newline at end of file
diff --git a/09-azure-storage-queue-basic/readme.didact.md b/09-azure-storage-queue-basic/readme.didact.md
deleted file mode 100644
index c6b0d84..0000000
--- a/09-azure-storage-queue-basic/readme.didact.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Camel Azure Storage Queue Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 09-azure-storage-queue-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2009-azure-storage-queue-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-k-azure-queue-knative` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-k-azure-queue-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-k-azure-queue-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `camel-k-azure-queue-knative` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-k-azure-queue-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-k-azure-queue-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-k-azure-queue-knative` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [azure-storage-queue.properties](didact://?commandId=vscode.openFolder&projectFilePath=09-azure-storage-queue-basic/azure-storage-queue.properties&completion=Opened%20the%azure-storage-queue.properties%20file "Opens the azure-storage-queue.properties file"){.didact} that contains the access key for accessing the Azure Storage Queue containers.
-
-```
-kubectl create secret generic azure-storage-queue --from-file=azure-storage-queue.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20azure-storage-queue%20--from-file%3Dazure-storage-queue.properties&completion=secret%20%22azure-storage-queue%22%20created. "Create a secret with Azure Storage credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f azure-storage-queue-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-queue-channel.yaml&completion=inmemorychannel.messaging.knative.dev/azure-queue$20created. "Create a Knative InMemoryChannel named azure-queue"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Azure Storage Queue Service component](https://camel.apache.org/components/latest/azure-storage-queue-component.html) that forward messages events received on the Azure Queue container orders to a Knative channel named `azure-queue`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f azure-storage-queue-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-queue-source.yaml&completion=camelsource.sources.knative.dev/camel-azure-storage-queue%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create Azure Storage Queue for consumption by the Camel Source
-
-You need a producer sending messages to `messages` Azure Storage Queue to try this example. This integration
-comes with a sample producer that will send messages with the text `Hello Camel K` every 3 seconds.
-
-```
-kamel run --secret azure-storage-queue azure-storage-queue-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20azure-storage-queue%20azure-storage-queue-producer.groovy&completion=Camel%20K%20azure-storage-queue-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration
-```
-kamel run azure-storage-queue-consumer.groovy --dev --secret azure-storage-queue
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20azure-storage-queue-consumer.groovy%20--dev%20--secret%20azure-storage-queue&completion=Camel%20K%20azure-storage-queue-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-k-azure-queue-knative```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-k-azure-queue-knative&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/09-azure-storage-queue-basic/readme.md b/09-azure-storage-queue-basic/readme.md
deleted file mode 100644
index c6b0d84..0000000
--- a/09-azure-storage-queue-basic/readme.md
+++ /dev/null
@@ -1,181 +0,0 @@
-# Camel Azure Storage Queue Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 09-azure-storage-queue-basic
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2009-azure-storage-queue-basic&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-k-azure-queue-knative` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-k-azure-queue-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-k-azure-queue-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `camel-k-azure-queue-knative` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-k-azure-queue-knative
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-k-azure-queue-knative&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-k-azure-queue-knative` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-This repository contains a simple [azure-storage-queue.properties](didact://?commandId=vscode.openFolder&projectFilePath=09-azure-storage-queue-basic/azure-storage-queue.properties&completion=Opened%20the%azure-storage-queue.properties%20file "Opens the azure-storage-queue.properties file"){.didact} that contains the access key for accessing the Azure Storage Queue containers.
-
-```
-kubectl create secret generic azure-storage-queue --from-file=azure-storage-queue.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20azure-storage-queue%20--from-file%3Dazure-storage-queue.properties&completion=secret%20%22azure-storage-queue%22%20created. "Create a secret with Azure Storage credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f azure-storage-queue-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-queue-channel.yaml&completion=inmemorychannel.messaging.knative.dev/azure-queue$20created. "Create a Knative InMemoryChannel named azure-queue"){.didact})
-
-
-## 2. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Azure Storage Queue Service component](https://camel.apache.org/components/latest/azure-storage-queue-component.html) that forward messages events received on the Azure Queue container orders to a Knative channel named `azure-queue`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f azure-storage-queue-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20azure-storage-queue-source.yaml&completion=camelsource.sources.knative.dev/camel-azure-storage-queue%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 2. Running a basic integration to create Azure Storage Queue for consumption by the Camel Source
-
-You need a producer sending messages to `messages` Azure Storage Queue to try this example. This integration
-comes with a sample producer that will send messages with the text `Hello Camel K` every 3 seconds.
-
-```
-kamel run --secret azure-storage-queue azure-storage-queue-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20azure-storage-queue%20azure-storage-queue-producer.groovy&completion=Camel%20K%20azure-storage-queue-producer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 3. Running a basic integration
-```
-kamel run azure-storage-queue-consumer.groovy --dev --secret azure-storage-queue
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20azure-storage-queue-consumer.groovy%20--dev%20--secret%20azure-storage-queue&completion=Camel%20K%20azure-storage-queue-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 4. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-k-azure-queue-knative```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-k-azure-queue-knative&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/10-knative-source-salesforce/SalesforceConsumer.java b/10-knative-source-salesforce/SalesforceConsumer.java
deleted file mode 100644
index 60f27e6..0000000
--- a/10-knative-source-salesforce/SalesforceConsumer.java
+++ /dev/null
@@ -1,13 +0,0 @@
-// camel-k: dependency=camel-jackson
-// camel-k: language=java
-
-import org.apache.camel.builder.RouteBuilder;
-
-public class SalesforceConsumer extends RouteBuilder {
- public void configure() {
- from("knative:channel/salesforce")
- .unmarshal().json()
- .log("New Salesforce contact was created: [ID:${body[Id]}, Name:${body[Name]}, Email:${body[Email]}, Phone: ${body[Phone]}]")
- .marshal().json(); // To avoid a WARN - https://github.com/apache/camel-k-runtime/issues/390
- }
-}
diff --git a/10-knative-source-salesforce/readme.didact.md b/10-knative-source-salesforce/readme.didact.md
deleted file mode 100644
index 6032d2d..0000000
--- a/10-knative-source-salesforce/readme.didact.md
+++ /dev/null
@@ -1,216 +0,0 @@
-# Camel Knative Source Salesforce Example
-
-This example demonstrates how to create a Camel based Knative source for Salesforce and a Camel route which consumes it.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 10-knative-source-salesforce
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2010-knative-source-salesforce&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-source` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install&completion=Installing%20Camel%20K. "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 2. Preparing the environment
-
-### 2.1. Collecting Salesforce credentials
-
-This examples uses OAuth 2.0 Refresh Token Flow, which requires 3 credentials collected from Salesforce - `Client ID`, `Client Secret` and `Refresh Token`.
-
-you might want to sign up with your own Developer account at developer.salesforce.com. After you have done that, you’ll need to create a Connected Application for your integration.
-
-Here is an example workflow of creating a Connected Application and get required credentials.For more details, please check Salesforce online manual
-https://help.salesforce.com/articleView?id=extend_code_overview.htm&type=5
-
-Note: This was written with Salesforce Lightening user interface. Classic user interface might have slightly different menu and/or workflow.
-
-#### 2.1.1. Creating a Connected Application
-1. Go to `PLATFORM TOOLS > Apps > App Manager` in a navigation tree at the left of Salesforce Setup screen
-1. Click `New Connected App` button at the upper right
-1. Enter `camelk_knative_source_salesforce` for Connected App Name
-1. Enter your email address for Contact Email
-1. Check Enable OAuth Settings
-1. Enter `https://login.salesforce.com/services/oauth2/success` for Callback URL
-1. Choose 2 OAuth scopes, `Access and manage your data (api)` and `Perform requests on your behalf at any time (refresh_token, offline_access)`, then click Add button
-1. Click Save button and then click Continue button
-1. You will be redirected to `Manage Connected Apps` page. `Consumer Key` and `Consumer Secret` are available in API section. Use `Consumer Key` as a `Client ID` and `Consumer Secret` as a `Client Secret`.
-1. Go to `PLATFORM TOOLS > Apps > Connected Apps > Manage Connected Apps`
-1. Click `Edit` next to the `camelk_knative_source_salesforce`
-1. In OAuth Policies section,
- 1. Choose `Relax IP restrictions` for IP Relaxation
- 1. Choose `Refresh token is valid until revoked`
-1. Click `Save`
-
-#### 2.1.2. Getting an OAuth refresh token
-In your browser go to the URL change the `__YOUR_CLIENT_ID_HERE__` with your connected application Consumer Key:
-
-```
-https://login.salesforce.com/services/oauth2/authorize?response_type=token&client_id=YOUR_CLIENT_ID_HERE&redirect_uri=https://login.salesforce.com/services/oauth2/success&display=touch
-```
-
-Allow access to the application, and you’ll end up on a page with `refresh_token`, something like:
-
-```
-https://login.salesforce.com/services/oauth2/success#access_token=..&refresh_token=<refresh_token>&instance_url=...&issued_at=...&signature=...&scope=...&token_type=Bearer
-```
-
-### 2.2. Creating a Kubernetes Secret from Salesforce credentials
-
-This repository contains a simple [salesforce.properties](didact://?commandId=vscode.openFolder&projectFilePath=10-knative-source-salesforce/salesforce.properties&completion=Opened%20the%salesforce.properties%20file "Opens the salesforce.properties file"){.didact} that can be used to generate a Kubernetes Secret with the Salesforce credential by replacing `<Your Client ID>`, `<Your Client Secret>` and `<Your Refresh Token>` with the actual values.
-
-```
-kubectl create secret generic salesforce --from-file=salesforce.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20salesforce%20--from-file%3Dsalesforce.properties&completion=secret%20%22salesforce%22%20created. "Create a secret with Salesforce credentials"){.didact})
-
-### 2.3. Creating a Knative Eventing channel
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f salesforce-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20salesforce-channel.yaml&completion=inmemorychannel.messaging.knative.dev/salesforce$20created. "Create a Knative InMemoryChannel named Salesforce"){.didact})
-
-## 3. Running a Camel Source
-
-This repository contains a Camel Source based on the [Salesforce component](https://camel.apache.org/components/latest/salesforce-component.html) that forward Salesforce event notifications to a Knative channel named `salesforce`
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f salesforce-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20salesforce-source.yaml&completion=camelsource.sources.knative.dev/camel-salesforce-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-
-## 4. Running a basic integration to echo a message in the console when a Salesforce Contact is created
-
-
-```
-kamel run SalesforceConsumer.java --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20SalesforceConsumer.java%20--dev&completion=Camel%20K%20salesforce-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running and printing the message when you create a Contact in Salesforce.
-
-## 5. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-source&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
diff --git a/10-knative-source-salesforce/readme.md b/10-knative-source-salesforce/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/10-knative-source-salesforce/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/10-knative-source-salesforce/salesforce-channel.yaml b/10-knative-source-salesforce/salesforce-channel.yaml
deleted file mode 100644
index b51def7..0000000
--- a/10-knative-source-salesforce/salesforce-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: salesforce
diff --git a/10-knative-source-salesforce/salesforce-source.yaml b/10-knative-source-salesforce/salesforce-source.yaml
deleted file mode 100644
index 4c83552..0000000
--- a/10-knative-source-salesforce/salesforce-source.yaml
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Apache Camel Salesforce Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-salesforce-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: salesforce
- flow:
- from:
- uri: salesforce:camelTestTopic
- parameters:
- notifyForFields: ALL
- updateTopic: true
- notifyForOperationCreate: true
- notifyForOperationUpdate: false
- notifyForOperationDelete: false
- notifyForOperationUndelete: false
- sObjectQuery: SELECT Id, Name, Email, Phone FROM Contact
- steps:
- - to: "log:received?showAll=true&multiline=true"
-
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: salesforce
diff --git a/10-knative-source-salesforce/salesforce.properties b/10-knative-source-salesforce/salesforce.properties
deleted file mode 100644
index bfd9b9a..0000000
--- a/10-knative-source-salesforce/salesforce.properties
+++ /dev/null
@@ -1,5 +0,0 @@
-camel.component.salesforce.config.raw-payload=true
-camel.component.salesforce.login-config.type=REFRESH_TOKEN
-camel.component.salesforce.login-config.client-id=<Your Client ID>
-camel.component.salesforce.login-config.client-secret=<Your Client Secret>
-camel.component.salesforce.login-config.refresh-token=<Your Refresh Token>
diff --git a/11-knative-source-slack/readme.didact.md b/11-knative-source-slack/readme.didact.md
deleted file mode 100644
index 1f5a8fe..0000000
--- a/11-knative-source-slack/readme.didact.md
+++ /dev/null
@@ -1,177 +0,0 @@
-# Camel Knative Source Slack Example
-
-This example demonstrates how to use a Camel based Knative source to receive messages written to a Slack channel.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the root [README.md](../README.md) file for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the Camel K [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/v0.15-docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases/tag/v0.15.0).
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. Creating the Slack App
-
-Slack Apps have access to the full scope of the platform, including sending messages to conversations and receiving event notifications.
-
-1. Go to the [Slack API](https://api.slack.com/) website and create a new Slack App.
-1. Go to the OAuth & Permissions page and add the `channels:history` user token scope to your app to grant it permission to view messages in the user’s public channels.
-1. Install the app to your workspace.
-1. Copy the generated token and set it as the value of the `slack.token` property in [slack.properties](didact://?commandId=vscode.openFolder&projectFilePath=11-knative-source-slack/slack.properties "Opens the slack.properties file"){.didact}.
-
-## 2. Preparing the namespace
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 11-knative-source-slack
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2011-knative-source-slack "Opens a new terminal and sends the command above"){.didact})
-
-
-We're going to create a namespace named `camel-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace camel-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20camel-source "Opens a new terminal and sends the command above"){.didact})
-
-
-Now we can set the `camel-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=camel-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Dcamel-source "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `camel-source` namespace (or globally in the whole cluster).
-In many settings (e.g. OpenShift, CRC), it's sufficient to execute the following command to install Camel K:
-
-```
-kamel install
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20install "Opens a new terminal and sends the command above"){.didact})
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-## 3. Preparing the environment
-
-Create a Kubernetes Secret with the [slack.properties](didact://?commandId=vscode.openFolder&projectFilePath=11-knative-source-slack/slack.properties "Opens the slack.properties file"){.didact} file.
-
-```
-kubectl create secret generic slack --from-file=slack.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20slack%20--from-file%3Dslack.properties "Create a secret with lack credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/v0.15-docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f slack-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20slack-channel.yaml "Create a Knative InMemoryChannel named 'slack'"){.didact})
-
-## 4. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [Slack component](https://camel.apache.org/components/latest/slack-component.html) that forward messages written to the `generic` Slack channel to a Knative channel.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f slack-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20slack-source.yaml "Opens a new terminal and sends the command above"){.didact})
-
-## 5. Running a basic integration to echo messages from Slack in the console
-
-```
-kamel run slack-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20slack-consumer.groovy%20--dev "Opens a new terminal and sends the command above"){.didact})
-
-If everything is OK, after the build phase finishes, you should see the Camel integration running and printing the messages you write in the `generic` Slack channel.
-
-## 6. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace camel-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20camel-source "Cleans up the cluster after running the example"){.didact})
diff --git a/11-knative-source-slack/readme.md b/11-knative-source-slack/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/11-knative-source-slack/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/11-knative-source-slack/slack-channel.yaml b/11-knative-source-slack/slack-channel.yaml
deleted file mode 100644
index b42ec20..0000000
--- a/11-knative-source-slack/slack-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: slack
diff --git a/11-knative-source-slack/slack-consumer.groovy b/11-knative-source-slack/slack-consumer.groovy
deleted file mode 100644
index 011e512..0000000
--- a/11-knative-source-slack/slack-consumer.groovy
+++ /dev/null
@@ -1,9 +0,0 @@
-// camel-k: dependency=camel-jackson
-//
-// Apache Camel Slack Consumer
-//
-from('knative:channel/slack')
- .unmarshal()
- .json()
- .setBody { it.in.body.text }
- .log('Received: ${body}')
diff --git a/11-knative-source-slack/slack-source.yaml b/11-knative-source-slack/slack-source.yaml
deleted file mode 100644
index c2fa5f4..0000000
--- a/11-knative-source-slack/slack-source.yaml
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-# Apache Camel Slack Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-slack-source
-spec:
- source:
- integration:
- configuration:
- - type: secret
- value: slack
- dependencies:
- - camel:jackson
- flow:
- from:
- uri: slack:general
- parameters:
- # Slack token defined in slack.properties
- token: "{{slack.token}}"
- maxResults: 1
- steps:
- - to: "log:received?showAll=true&multiline=true"
- - marshal:
- json: {}
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: slack
diff --git a/11-knative-source-slack/slack.properties b/11-knative-source-slack/slack.properties
deleted file mode 100644
index fa5523e..0000000
--- a/11-knative-source-slack/slack.properties
+++ /dev/null
@@ -1,4 +0,0 @@
-#
-# Slack Secret
-#
-slack.token = <token>
diff --git a/12-aws-secret-manager-vault/aws-secret-manager.properties b/12-aws-secret-manager-vault/aws-secret-manager.properties
deleted file mode 100644
index c0e160e..0000000
--- a/12-aws-secret-manager-vault/aws-secret-manager.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-camel.vault.aws.accessKey = <access_key>
-camel.vault.aws.secretKey = <secret_key>
-camel.vault.aws.region = <region>
diff --git a/12-aws-secret-manager-vault/readme.md b/12-aws-secret-manager-vault/readme.md
deleted file mode 100644
index da9a9af..0000000
--- a/12-aws-secret-manager-vault/readme.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# Camel AWS Secret Manager Vault Example
-
-This example demonstrates how to use AWS Secret Manager to retrieves secret values directly from the Cloud service, in Camel K.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-## Setting up AWS Credentials
-
-Open the aws-secret-manager.properties file and correctly set the credentials values.
-
-## Create a secret on AWS Secret Manager
-
-You'll need to create a secret for using Finnhub for this example.
-
-You can obtain a token by looking at [Finnhub.io](https://finnhub.io) website.
-
-The secret name must be finnhub-token.
-
-## Running the example
-
-Once you have Camel K running you should run the example in the following way:
-
-```
-kamel run --build-property quarkus.camel.service.discovery.include-patterns=META-INF/services/org/apache/camel/properties-function/* -p file:aws-secret-manager.properties timer-finnhub-aws-secret-manager.yaml
-```
-
-Once the integration has been deployed, you should see the following in the logs:
-
-```
-2022-04-21 16:28:23,724 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.16.0 (camel-1) is starting
-2022-04-21 16:28:23,746 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Routes startup (total:3 started:3)
-2022-04-21 16:28:23,746 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started route1 (kamelet://timer-source)
-2022-04-21 16:28:23,746 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started timer-source-1 (timer://tick)
-2022-04-21 16:28:23,746 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Started log-sink-2 (kamelet://source)
-2022-04-21 16:28:23,746 INFO [org.apa.cam.imp.eng.AbstractCamelContext] (main) Apache Camel 3.16.0 (camel-1) started in 1s373ms (build:0ms init:1s351ms start:22ms)
-2022-04-21 16:28:23,750 INFO [io.quarkus] (main) camel-k-integration 1.9.0 on JVM (powered by Quarkus 2.8.0.Final) started in 5.803s.
-2022-04-21 16:28:23,750 INFO [io.quarkus] (main) Profile prod activated.
-2022-04-21 16:28:23,750 INFO [io.quarkus] (main) Installed features: [camel-aws-secrets-manager, camel-bean, camel-core, camel-http, camel-k-core, camel-k-runtime, camel-kamelet, camel-log, camel-timer, camel-yaml-dsl, cdi]
-2022-04-21 16:28:25,424 INFO [info] (Camel (camel-1) thread #1 - timer://tick) Exchange[ExchangePattern: InOnly, BodyType: org.apache.camel.converter.stream.CachedOutputStream.WrappedInputStream, Body: {"c":169.93,"d":2.7,"dp":1.6145,"h":171.53,"l":168.445,"o":168.91,"pc":167.23,"t":1650558475}]
-```
diff --git a/12-aws-secret-manager-vault/timer-finnhub-aws-secret-manager.yaml b/12-aws-secret-manager-vault/timer-finnhub-aws-secret-manager.yaml
deleted file mode 100644
index ef32327..0000000
--- a/12-aws-secret-manager-vault/timer-finnhub-aws-secret-manager.yaml
+++ /dev/null
@@ -1,33 +0,0 @@
-## ---------------------------------------------------------------------------
-## Licensed to the Apache Software Foundation (ASF) under one or more
-## contributor license agreements. See the NOTICE file distributed with
-## this work for additional information regarding copyright ownership.
-## The ASF licenses this file to You under the Apache License, Version 2.0
-## (the "License"); you may not use this file except in compliance with
-## the License. You may obtain a copy of the License at
-##
-## http://www.apache.org/licenses/LICENSE-2.0
-##
-## Unless required by applicable law or agreed to in writing, software
-## distributed under the License is distributed on an "AS IS" BASIS,
-## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-## See the License for the specific language governing permissions and
-## limitations under the License.
-## ---------------------------------------------------------------------------
-
-# camel-k: dependency=camel:aws-secrets-manager
-
-- route:
- from:
- uri: "kamelet:timer-source"
- parameters:
- period: 10000
- message: 'test'
- steps:
- - to:
- uri: "https://finnhub.io/api/v1/quote?symbol=AAPL&token={{aws:finnhub-token}}"
- - to:
- uri: "kamelet:log-sink"
- parameters:
- showStreams: true
- showHeaders: true
diff --git a/90-aws-kinesis-customized-event-source/aws-kinesis-channel.yaml b/90-aws-kinesis-customized-event-source/aws-kinesis-channel.yaml
deleted file mode 100644
index 4381711..0000000
--- a/90-aws-kinesis-customized-event-source/aws-kinesis-channel.yaml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Knative Channel
-#
-apiVersion: messaging.knative.dev/v1alpha1
-kind: InMemoryChannel
-metadata:
- name: aws-kinesis
\ No newline at end of file
diff --git a/90-aws-kinesis-customized-event-source/aws-kinesis-consumer.groovy b/90-aws-kinesis-customized-event-source/aws-kinesis-consumer.groovy
deleted file mode 100644
index 09dac08..0000000
--- a/90-aws-kinesis-customized-event-source/aws-kinesis-consumer.groovy
+++ /dev/null
@@ -1,16 +0,0 @@
-// camel-k: dependency=camel-aws-kinesis dependency=camel-base64
-//
-// Apache Camel Kinesis Consumer
-//
-
-// Typical data when using cbor looks like this:
-// {"sequenceNumber":"1222","approximateArrivalTimestamp":1123,"data":"SGVsbG8gQ2FtZWwgSw==","partitionKey":"p-01123"...}
-//
-// So we unmarshal it, extract the data element which is in base64 format and decode it
-from('knative:channel/aws-kinesis')
- .unmarshal()
- .json()
- .setBody { it.in.body.data }
- .unmarshal()
- .base64()
- .log('Received: ${body}')
diff --git a/90-aws-kinesis-customized-event-source/aws-kinesis-producer.groovy b/90-aws-kinesis-customized-event-source/aws-kinesis-producer.groovy
deleted file mode 100644
index bb843ff..0000000
--- a/90-aws-kinesis-customized-event-source/aws-kinesis-producer.groovy
+++ /dev/null
@@ -1,13 +0,0 @@
-// camel-k: dependency=camel-aws-kinesis dependency=mvn:org.apache.camel.k.examples:custom-kinesis-configuration:1.0.3
-//
-// Apache Camel Kinesis Consumer
-//
-// This is just a sample producer for AWS that creates 100 messages every 3 seconds
-from('timer:java?period=3000&repeatCount=100')
- .setHeader("CamelAwsKinesisPartitionKey")
- .constant("p-01123")
- .setHeader("CamelAwsKinesisSequenceNumber")
- .constant(1)
- .setBody()
- .simple('Hello Camel K')
- .to('aws-kinesis:stream?accessKey={{aws.kinesis.accessKey}}&secretKey={{aws.kinesis.accessKey}}')
diff --git a/90-aws-kinesis-customized-event-source/aws-kinesis-source.yaml b/90-aws-kinesis-customized-event-source/aws-kinesis-source.yaml
deleted file mode 100644
index efe6d3b..0000000
--- a/90-aws-kinesis-customized-event-source/aws-kinesis-source.yaml
+++ /dev/null
@@ -1,52 +0,0 @@
-#
-# Apache Camel AWS Kinesis Source
-#
-apiVersion: sources.knative.dev/v1alpha1
-kind: CamelSource
-metadata:
- name: camel-aws-kinesis-source
-spec:
- source:
- integration:
- configuration:
- # What other types do we have?
- - type: secret
- value: aws-kinesis
- - type: property
- value: amazon.host=localstack:4568
- - type: property
- value: camel.component.aws-kinesis.configuration=#class:org.apache.camel.k.examples.CustomKinesisConfiguration
- dependencies:
- # Needed for the json part on the flow/steps below
- - camel:jackson
- # Needed for the component
- #
- # NOTE: the dependencies used by the source may change under different
- # circumstances. In the case of this example, it is showing how to use a
- # LocalStack instance to simulate a AWS Kinesis stream, which is useful for
- # testing. In this case, one of the things that the custom client does is
- # disabling cbor so that the response is parseable.
- # However, when pointing to a real AWS Kinesis instance it may be necessary to
- # adjust the dependencies so that jackson-dataformat-cbor is included on the
- # dependencies. As a general recommendation, checking the example
- # 04-aws-kinesis-source-basic which targets AWS Kinesis is also recommended to
- # verify what dependencies, restrictions or requirements apply when using an
- # actual AWS Kinesis instance.
- - camel:camel-aws-kinesis
- # Provides the custom Kinesis configuration
- - mvn:org.apache.camel.k.examples/custom-kinesis-configuration:1.0.3
- flow:
- from:
- uri: aws-kinesis:stream
- parameters:
- secretKey: "{{aws.kinesis.secretKey}}"
- accessKey: "{{aws.kinesis.accessKey}}"
- steps:
- - to: "log:received?showAll=true&multiline=true"
- - marshal:
- json: {}
- sink:
- ref:
- apiVersion: messaging.knative.dev/v1beta1
- kind: InMemoryChannel
- name: aws-kinesis
diff --git a/90-aws-kinesis-customized-event-source/aws-kinesis.properties b/90-aws-kinesis-customized-event-source/aws-kinesis.properties
deleted file mode 100644
index 446bf1d..0000000
--- a/90-aws-kinesis-customized-event-source/aws-kinesis.properties
+++ /dev/null
@@ -1,2 +0,0 @@
-aws.kinesis.accessKey=accesskey
-aws.kinesis.secretKey=secretkey
\ No newline at end of file
diff --git a/90-aws-kinesis-customized-event-source/extra/custom-kinesis-configuration/pom.xml b/90-aws-kinesis-customized-event-source/extra/custom-kinesis-configuration/pom.xml
deleted file mode 100644
index ef83582..0000000
--- a/90-aws-kinesis-customized-event-source/extra/custom-kinesis-configuration/pom.xml
+++ /dev/null
@@ -1,52 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
-
- <groupId>org.apache.camel.k.examples</groupId>
- <artifactId>custom-kinesis-configuration</artifactId>
- <version>1.0.3</version>
-
- <properties>
- <version.maven.compiler>3.8.1</version.maven.compiler>
- <version.java>1.8</version.java>
- <version.camel>3.3.0</version.camel>
- <version.aws-sdk>1.11.714</version.aws-sdk>
- </properties>
-
- <dependencies>
- <dependency>
- <groupId>org.apache.camel</groupId>
- <artifactId>camel-support</artifactId>
- <version>${version.camel}</version>
- </dependency>
-
- <dependency>
- <groupId>org.apache.camel</groupId>
- <artifactId>camel-aws-kinesis</artifactId>
- <version>${version.camel}</version>
- </dependency>
-
- <dependency>
- <groupId>com.amazonaws</groupId>
- <artifactId>aws-java-sdk-kinesis</artifactId>
- <version>${version.aws-sdk}</version>
- <scope>compile</scope>
- </dependency>
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>${version.maven.compiler}</version>
- <configuration>
- <source>${version.java}</source>
- <target>${version.java}</target>
- <encoding>UTF-8</encoding>
- </configuration>
- </plugin>
- </plugins>
- </build>
-</project>
\ No newline at end of file
diff --git a/90-aws-kinesis-customized-event-source/extra/custom-kinesis-configuration/src/main/java/org/apache/camel/k/examples/CustomKinesisConfiguration.java b/90-aws-kinesis-customized-event-source/extra/custom-kinesis-configuration/src/main/java/org/apache/camel/k/examples/CustomKinesisConfiguration.java
deleted file mode 100644
index 5cf4bf3..0000000
--- a/90-aws-kinesis-customized-event-source/extra/custom-kinesis-configuration/src/main/java/org/apache/camel/k/examples/CustomKinesisConfiguration.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.camel.k.examples;
-
-import org.apache.camel.PropertyInject;
-import com.amazonaws.ClientConfiguration;
-import com.amazonaws.Protocol;
-import com.amazonaws.auth.AWSCredentials;
-import com.amazonaws.auth.AWSCredentialsProvider;
-import com.amazonaws.client.builder.AwsClientBuilder;
-import com.amazonaws.regions.Regions;
-import com.amazonaws.services.kinesis.AmazonKinesis;
-import com.amazonaws.services.kinesis.AmazonKinesisClientBuilder;
-import com.amazonaws.services.kinesis.model.CreateStreamResult;
-import com.amazonaws.services.kinesis.model.DescribeStreamResult;
-import com.amazonaws.services.kinesis.model.ResourceNotFoundException;
-import org.apache.camel.component.aws.kinesis.KinesisConfiguration;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class CustomKinesisConfiguration extends KinesisConfiguration {
- private static final Logger LOG = LoggerFactory.getLogger(CustomKinesisConfiguration.class);
-
- private AmazonKinesis amazonKinesis;
-
- @PropertyInject("amazon.host")
- private String amazonHost;
-
- static {
- /* This makes the Localstack response parseable but is not necessary
- * when using AWS Kinesis
- */
- System.setProperty("com.amazonaws.sdk.disableCbor", "true");
- }
-
- private void createStream() {
- CreateStreamResult result = amazonKinesis.createStream(getStreamName(), 1);
- if (result.getSdkHttpMetadata().getHttpStatusCode() != 200) {
- LOG.error("Failed to create the stream");
- } else {
- LOG.info("Stream created successfully");
- }
- }
-
- public void setAmazonHost(String amazonHost) {
- this.amazonHost = amazonHost;
- }
-
- public String getAmazonHost() {
- return amazonHost;
- }
-
- private AmazonKinesis buildClient() {
- LOG.info("Using Amazon host: {}", amazonHost);
-
- ClientConfiguration clientConfiguration = new ClientConfiguration();
- clientConfiguration.setProtocol(Protocol.HTTP);
-
- String region = Regions.US_EAST_1.getName();
-
- AmazonKinesisClientBuilder clientBuilder = AmazonKinesisClientBuilder.standard();
- clientBuilder
- .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(amazonHost, region))
- .withClientConfiguration(clientConfiguration)
- .withCredentials(new AWSCredentialsProvider() {
- public AWSCredentials getCredentials() {
- return new AWSCredentials() {
- public String getAWSAccessKeyId() {
- return "accesskey";
- }
-
- public String getAWSSecretKey() {
- return "secretkey";
- }
- };
- }
-
- public void refresh() {
-
- }
- });
-
- LOG.info("Building the client");
- return clientBuilder.build();
- }
-
- @Override
- public AmazonKinesis getAmazonKinesisClient() {
- if (amazonKinesis == null) {
- amazonKinesis = buildClient();
-
- final String streamName = getStreamName();
- LOG.info("Checking if the stream {} exists", streamName);
-
- try {
- DescribeStreamResult describeStreamResult = amazonKinesis.describeStream(streamName);
- if (describeStreamResult.getSdkHttpMetadata().getHttpStatusCode() != 200) {
- LOG.info("The stream does not exist, auto creating it ...");
-
- createStream();
- } else {
- LOG.info("The stream already exists, therefore skipping auto-creation");
- }
- } catch (ResourceNotFoundException e) {
- LOG.info("The stream does not exist, auto creating it ...");
- createStream();
- }
- }
-
- return amazonKinesis;
- }
-}
diff --git a/90-aws-kinesis-customized-event-source/extra/localstack.yaml b/90-aws-kinesis-customized-event-source/extra/localstack.yaml
deleted file mode 100644
index 3cffce8..0000000
--- a/90-aws-kinesis-customized-event-source/extra/localstack.yaml
+++ /dev/null
@@ -1,40 +0,0 @@
----
-# ------------------- Internal Services ------------------- #
-apiVersion: v1
-kind: Service
-metadata:
- name: localstack
-spec:
- type: ClusterIP
- ports:
- - port: 4568
- selector:
- app: localstack
- component: localstack
-
----
-# ------------------- Deployment ------------------- #
-apiVersion: apps/v1
-kind: Deployment
-metadata:
- name: localstack
-spec:
- replicas: 1
- selector:
- matchLabels:
- component: localstack
- app: localstack
- template:
- metadata:
- labels:
- component: localstack
- app: localstack
- spec:
- containers:
- - name: localstack
- image: localstack/localstack
- ports:
- - containerPort: 4568
- env:
- - name: SERVICES
- value: kinesis
diff --git a/90-aws-kinesis-customized-event-source/readme.didact.md b/90-aws-kinesis-customized-event-source/readme.didact.md
deleted file mode 100644
index 15aea34..0000000
--- a/90-aws-kinesis-customized-event-source/readme.didact.md
+++ /dev/null
@@ -1,208 +0,0 @@
-# Camel Knative Source Basic Example
-
-This example demonstrates how to get started with Camel based Knative sources by showing you some of the most important
-features that you should know before trying to develop more complex examples. This extends the ideas presented on the [AWS Kinesis Source Basic](../04-aws-kinesis-source-basic) example and shows how to customize the Kinesis client. In this example we
-show how to configure a custom Kinesis client for testing using a [LocalStack](https://github.com/localstack/localstack) instance
-instead of a real AWS Kinesis instance. Although this example focuses on a general scenario aimed at testing, the overall idea and design is also applicable for scenarios when a custom client configuration is necessary.
-
-You can find more information about Apache Camel and Apache Camel K on the [official Camel website](https://camel.apache.org).
-
-## Before you begin
-
-Read the general instructions in the [root README.md file](../README.md) for setting up your environment and the Kubernetes cluster before looking at this example.
-
-Make sure you've read the [installation instructions](https://camel.apache.org/camel-k/latest/installation/installation.html) for your specific
-cluster before starting the example.
-
-You should open this file with [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact) if available on your IDE.
-
-You need a Maven repository where the custom client can be deployed.
-
-## Requirements
-
-<a href='didact://?commandId=vscode.didact.validateAllRequirements' title='Validate all requirements!'><button>Validate all Requirements at Once!</button></a>
-
-**Kubectl CLI**
-
-The Kubernetes `kubectl` CLI tool will be used to interact with the Kubernetes cluster.
-
-[Check if the Kubectl CLI is installed](didact://?commandId=vscode.didact.cliCommandSuccessful&text=kubectl-requirements-status$$kubectl%20help&completion=Checked%20kubectl%20tool%20availability "Tests to see if `kubectl help` returns a 0 return code"){.didact}
-
-*Status: unknown*{#kubectl-requirements-status}
-
-**Connection to a Kubernetes cluster**
-
-You need to connect to a Kubernetes cluster in order to run the example.
-
-[Check if you're connected to a Kubernetes cluster](didact://?commandId=vscode.didact.cliCommandSuccessful&text=cluster-requirements-status$$kubectl%20get%20pod&completion=Checked%20Kubernetes%20connection "Tests to see if `kubectl get pod` returns a 0 return code"){.didact}
-
-*Status: unknown*{#cluster-requirements-status}
-
-**Apache Camel K CLI ("kamel")**
-
-You need the Apache Camel K CLI ("kamel") in order to access all Camel K features.
-
-[Check if the Apache Camel K CLI ("kamel") is installed](didact://?commandId=vscode.didact.requirementCheck&text=kamel-requirements-status$$kamel%20version$$Camel%20K%20Client&completion=Checked%20if%20Camel%20K%20CLI%20is%20available%20on%20this%20system. "Tests to see if `kamel version` returns a result"){.didact}
-
-*Status: unknown*{#kamel-requirements-status}
-
-**Knative installed on the cluster**
-
-The cluster also needs to have Knative installed and working. Refer to the [official Knative documentation](https://knative.dev/docs/install/) for information on how to install it in your cluster.
-
-[Check if the Knative Serving is installed](didact://?commandId=vscode.didact.requirementCheck&text=kserving-project-check$$kubectl%20api-resources%20--api-group=serving.knative.dev$$kservice%2Cksvc&completion=Verified%20Knative%20services%20installation. "Verifies if Knative Serving is installed"){.didact}
-
-*Status: unknown*{#kserving-project-check}
-
-[Check if the Knative Eventing is installed](didact://?commandId=vscode.didact.requirementCheck&text=keventing-project-check$$kubectl%20api-resources%20--api-group=messaging.knative.dev$$inmemorychannels&completion=Verified%20Knative%20eventing%20services%20installation. "Verifies if Knative Eventing is installed"){.didact}
-
-*Status: unknown*{#keventing-project-check}
-
-**Knative Camel Source installed on the cluster**
-
-The cluster also needs to have installed the Knative Camel Source from the camel.yaml in the [Eventing Sources release page](https://github.com/knative/eventing-contrib/releases)
-
-[Check if the Knative Camel Source is installed](didact://?commandId=vscode.didact.requirementCheck&text=kservice-project-check$$kubectl%20api-resources%20--api-group=sources.knative.dev$$camelsources&completion=Verified%20Knative%20Camel%20Source%20installation. "Verifies if Knative Camel Source is installed"){.didact}
-
-*Status: unknown*{#kservice-project-check}
-
-### Optional Requirements
-
-The following requirements are optional. They don't prevent the execution of the demo, but may make it easier to follow.
-
-**VS Code Extension Pack for Apache Camel**
-
-The VS Code Extension Pack for Apache Camel provides a collection of useful tools for Apache Camel K developers,
-such as code completion and integrated lifecycle management. They are **recommended** for the tutorial, but they are **not**
-required.
-
-You can install it from the VS Code Extensions marketplace.
-
-[Check if the VS Code Extension Pack for Apache Camel by Red Hat is installed](didact://?commandId=vscode.didact.extensionRequirementCheck&text=extension-requirement-status$$redhat.apache-camel-extension-pack&completion=Camel%20extension%20pack%20is%20available%20on%20this%20system. "Checks the VS Code workspace to make sure the extension pack is installed"){.didact}
-
-*Status: unknown*{#extension-requirement-status}
-
-## 1. First steps
-
-Let's open a terminal and go to the example directory:
-
-```
-cd 90-aws-kinesis-customized-event-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$cd%2090-aws-kinesis-customized-event-source&completion=Executed%20command. "Opens a new terminal and sends the command above"){.didact})
-
-We're going to create a namespace named `aws-kinesis-customized-event-source` for running the example. To create it, execute the following command:
-
-```
-kubectl create namespace aws-kinesis-customized-event-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20namespace%20aws-kinesis-customized-event-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-Now we can set the `aws-kinesis-customized-event-source` namespace as default namespace for the following commands:
-
-```
-kubectl config set-context --current --namespace=aws-kinesis-customized-event-source
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20config%20set-context%20--current%20--namespace%3Daws-kinesis-customized-event-source&completion=New%20project%20creation. "Opens a new terminal and sends the command above"){.didact})
-
-You need to install Camel K in the `aws-kinesis-customized-event-source` namespace (or globally in the whole cluster).
-For this example to run, you must configure Camel K to include your Maven repository in its configuration, so that
-dependencies can be downloaded from it. To do so, execute the following command replacing `https://url.of.the.repository`
-with the actual URL of the repository:
-
-```
-kamel install --maven-repository https://url.of.the.repository
-```
-
-NOTE: The `kamel install` command requires some prerequisites to be successful in some situations, e.g. you need to enable the registry addon on Minikube. Refer to the [Camel K install guide](https://camel.apache.org/camel-k/latest/installation/installation.html) for cluster-specific instructions.
-
-To check that Camel K is installed we'll retrieve the IntegrationPlatform object from the namespace:
-
-```
-kubectl get integrationplatform
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20get%20integrationplatform&completion=Executed%20Command. "Opens a new terminal and sends the command above"){.didact})
-
-You should find an IntegrationPlatform in status `Ready`.
-
-You can now proceed to the next section.
-
-
-## 2. Deploy the custom client to a Maven repository
-
-
-Deploy the custom client to a maven repository, adjusting the command below so that the
-repository ID and the URL matches the ones used in your Maven repository.
-
-```
-mvn -f extra/custom-kinesis-configuration/pom.xml -DaltDeploymentRepository="id-of-the-repository::default::https://url.of.the.repository" deploy
-```
-
-## 3. Deploy LocalStack in the cluster
-
-Deploy the a LocalStack instance for testing:
-
-```
-kubectl apply -f extra/localstack.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20extra%2Flocalstack.yaml&completion=deployment%20%22localstack%22%20created. "Create a LocalStack deployment"){.didact})
-
-
-## 4. Preparing the environment
-
-This repository contains a simple [aws-kinesis.properties](didact://?commandId=vscode.openFolder&projectFilePath=05-aws-kinesis-source-advanced/aws-kinesis.properties&completion=Opened%20the%aws-kinesis.properties%20file "Opens the aws-kinesis.properties file"){.didact} that contains the access key and secret key for accessing the AWS Kinesis stream.
-
-```
-kubectl create secret generic aws-kinesis --from-file=aws-kinesis.properties
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20create%20secret%20generic%20aws-kinesis%20--from-file%3Daws-kinesis.properties&completion=secret%20%22aws-kinesis%22%20created. "Create a secret with AWS Kinesis credentials"){.didact})
-
-As the example levareges [Knative Eventing channels](https://knative.dev/docs/eventing/channels/), we need to create the one that the example will use:
-
-```
-kubectl apply -f aws-kinesis-channel.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-kinesis-channel.yaml&completion=inmemorychannel.messaging.knative.dev/aws-kinesis$20created. "Create a Knative InMemoryChannel named aws-kinesis"){.didact})
-
-
-## 5. Running a Camel Source
-
-This repository contains a simple Camel Source based on the [AWS Kinesis component](https://camel.apache.org/components/latest/aws-kinesis-component.html) that forward streaming events received on the AWS Kinesis stream to a Knative channel named `aws-kinesis`.
-
-Use the following command to deploy the Camel Source:
-
-```
-kubectl apply -f aws-kinesis-source.yaml
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20apply%20-f%20aws-kinesis-source.yaml&completion=camelsource.sources.knative.dev/camel-aws-kinesis-source%20created. "Opens a new terminal and sends the command above"){.didact})
-
-## 6. Running a basic integration to create Kinesis events for consumption by the Camel Source
-
-You need a producer adding data to a Kinesis stream to try this example. This integration
-comes with a sample producer that will send 100 messages with the text `Hello Camel K`
-every 3 seconds.
-
-```
-kamel run --secret aws-kinesis --dependency mvn:org.apache.camel.k.examples:custom-kinesis-configuration:1.0.3 --property camel.component.aws-kinesis.configuration=#class:org.apache.camel.k.examples.CustomKinesisConfiguration --property amazon.host=localstack:4568 aws-kinesis-producer.groovy
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20--secret%20aws-kinesis%20--dependency%20mvn:org.apache.camel.k.examples:custom-kinesis-configuration:1.0.3%20--property%20camel.component.aws-kinesis.configuration=%23class:org.apache.camel.k.examples.CustomKinesisConfiguration%20--property%20amazon.host=localstack:4568%20aws-kinesis-producer.groovy&completion=Ran%20the%20AWS%20Kinesis%20producer. "Opens a terminal and runs the command a [...]
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-## 7. Running a basic integration to forward Kinesis events to the console
-
-```
-kamel run aws-kinesis-consumer.groovy --dev
-```
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kamel%20run%20aws-kinesis-consumer.groovy%20--dev&completion=Camel%20K%20aws-kinesis-consumer%20integration%20run%20in%20dev%20mode. "Opens a new terminal and sends the command above"){.didact})
-
-If everything is ok, after the build phase finishes, you should see the Camel integration running.
-
-
-## 8. Uninstall
-
-To cleanup everything, execute the following command:
-
-```kubectl delete namespace aws-kinesis-customized-event-source```
-
-([^ execute](didact://?commandId=vscode.didact.sendNamedTerminalAString&text=camelTerm$$kubectl%20delete%20namespace%20aws-kinesis-customized-event-source&completion=Removed%20the%20namespace%20from%20the%20cluster. "Cleans up the cluster after running the example"){.didact})
\ No newline at end of file
diff --git a/90-aws-kinesis-customized-event-source/readme.md b/90-aws-kinesis-customized-event-source/readme.md
deleted file mode 120000
index c0bf82f..0000000
--- a/90-aws-kinesis-customized-event-source/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-readme.didact.md
\ No newline at end of file
diff --git a/README.md b/README.md
index cccf356..c7ce132 100644
--- a/README.md
+++ b/README.md
@@ -14,17 +14,6 @@ To better work on all examples, make sure you have all them locally by checking
git clone git@github.com:apache/camel-k-examples.git
```
-We suggest you to open the examples with [VSCode](https://code.visualstudio.com/) because it provides useful extensions for working with Camel K files.
-If you've already installed it on your machine, after cloning the repository, you can open the examples on the IDE executing:
-
-```
-code camel-k-examples
-```
-
-We suggest you to install the following extensions for VSCode (The IDE should automatically prompt to ask you to install them):
-- [Extension Pack for Apache Camel](https://marketplace.visualstudio.com/items?itemName=redhat.apache-camel-extension-pack): provides auto-completion, error handling as well as integrated IDE tools to manage the lifecycle of Camel K integrations
-- [Didact](https://marketplace.visualstudio.com/items?itemName=redhat.vscode-didact): Provides a better getting started experience when following readme files in the various examples
-
### Have your Kubernetes cluster ready
All examples require that you are connected to a Kubernetes/OpenShift cluster, even a local instance such as [Minikube](https://github.com/kubernetes/minikube) or [CRC](https://github.com/code-ready/crc). Some advanced examples may have additional requirements.
@@ -40,24 +29,8 @@ All examples need at least the following CLI tools installed on your system:
## Generic Examples
-We are providing also a folder containing multiple generic examples in [Generic Examples](./generic-examples) folder.
+In [Generic Examples](./generic-examples) we are providing multiple generic examples folder.
## Kamelets
-In the [Kamelets](./kamelets) folder, you'll get a set of examples based on Kamelets.
-
-## Custom Examples
-
-Examples are contained in directories ordered by level of difficulty.
-
-Most examples provide a `readme.didact.md` file instead of the standard readme file. For those, if you're using VSCode with Didact installed, you can **right click on the `readme.didact.md` file and hit "Didact: Start Didact Tutorial from File"**.
-
-This is the current list of examples:
-
-- [01 Basic](./01-basic): Getting started with Camel K by learning the most important features that you should know before trying to develop more complex examples.
-- [02 Serverless API](./02-serverless-api): Learn how to design an API that manages files in a remote storage location and leverages *Knative* Serving to scale automatically (even to zero instances) based on the current load.
-- [03 Knative Source Basic](./03-knative-source-basic): Getting started with Knative Camel Source by learning the most important concepts you should know before trying to develop more complex examples.
-- [04 AWS Kinesis Source Basic](./04-aws-kinesis-source-basic): Learn how to consume AWS Kinesis events using Knative Camel Source.
-- [10 Knative Source Salesforce](./10-knative-source-salesforce): Learn how to create a Knative Camel Source for Salesforce.
-- [11 Knative Source Slack](./11-knative-source-slack): Getting started with Slack integration using Knative Camel Source.
-- [90 AWS Kinesis Source With a Custom Configuration](./90-aws-kinesis-customized-event-source): Learn how to use a custom AWS Kinesis configuration when consuming AWS Kinesis events using Knative Camel Source.
+In [Kamelets](./kamelets) we have a set of examples based on Kamelets.
diff --git a/generic-examples/languages/README.md b/generic-examples/languages/README.md
index 20f0851..d04cca5 100644
--- a/generic-examples/languages/README.md
+++ b/generic-examples/languages/README.md
@@ -16,7 +16,7 @@ cluster before starting the example.
- [routes.yaml](./hello.xml): defines a route that every 5 secs, transforms the message content to uppercase and logs it.
- [simple.js](./simple.js): logs message periodically, the `multiline` query parameter is set to true, thus each information is output on a newline
- [hello.xml](./hello.xml): defines a route that logs a message to a logger very 3 seconds.
-- [simple.groovy](./simple.groovy): logs a message every second, the `showAll` query parameter is set to false, thus only a limited information is shown.
+- [simple.groovy](./simple.groovy): logs a message every second, the `showAll` query parameter is set to false, thus only limited information is shown.
- [Sample.java](./Sample.java): defines a route that logs a message periodically.
## Running the Examples