Regen for commit 1ac2bdba1158c4f526c925d3c78d28384f1b9c79

Signed-off-by: GitHub <noreply@github.com>
1 file changed
tree: 3ce604f37650c272dca6fadbea4b480741ebf7cb
  1. .asf.yaml
  2. .github/
  3. .gitignore
  4. .mvn/
  5. Jenkinsfile
  6. Jenkinsfile.deploy
  7. KEYS
  8. LICENSE
  9. NOTICE
  10. README.md
  11. avro-deserialize-action.kamelet.yaml
  12. avro-serialize-action.kamelet.yaml
  13. aws-cloudwatch-sink.kamelet.yaml
  14. aws-ddb-streams-source.kamelet.yaml
  15. aws-ec2-sink.kamelet.yaml
  16. aws-kinesis-firehose-sink.kamelet.yaml
  17. aws-kinesis-sink.kamelet.yaml
  18. aws-kinesis-source.kamelet.yaml
  19. aws-lambda-sink.kamelet.yaml
  20. aws-s3-sink.kamelet.yaml
  21. aws-s3-source.kamelet.yaml
  22. aws-s3-streaming-upload-sink.kamelet.yaml
  23. aws-sns-fifo-sink.kamelet.yaml
  24. aws-sns-sink.kamelet.yaml
  25. aws-sqs-batch-sink.kamelet.yaml
  26. aws-sqs-fifo-sink.kamelet.yaml
  27. aws-sqs-sink.kamelet.yaml
  28. aws-sqs-source.kamelet.yaml
  29. aws-translate-action.kamelet.yaml
  30. azure-cosmosdb-source.kamelet.yaml
  31. azure-eventhubs-sink.kamelet.yaml
  32. azure-eventhubs-source.kamelet.yaml
  33. azure-storage-blob-sink.kamelet.yaml
  34. azure-storage-blob-source.kamelet.yaml
  35. azure-storage-queue-sink.kamelet.yaml
  36. azure-storage-queue-source.kamelet.yaml
  37. bitcoin-source.kamelet.yaml
  38. caffeine-action.kamelet.yaml
  39. cassandra-sink.kamelet.yaml
  40. cassandra-source.kamelet.yaml
  41. chuck-norris-source.kamelet.yaml
  42. chunk-template-action.kamelet.yaml
  43. cron-source.kamelet.yaml
  44. dns-dig-action.kamelet.yaml
  45. dns-ip-action.kamelet.yaml
  46. dns-lookup-action.kamelet.yaml
  47. docs/
  48. dropbox-sink.kamelet.yaml
  49. dropbox-source.kamelet.yaml
  50. earthquake-source.kamelet.yaml
  51. elasticsearch-index-sink.kamelet.yaml
  52. elasticsearch-search-source.kamelet.yaml
  53. exec-sink.kamelet.yaml
  54. extract-field-action.kamelet.yaml
  55. fhir-source.kamelet.yaml
  56. file-watch-source.kamelet.yaml
  57. freemarker-template-action.kamelet.yaml
  58. ftp-sink.kamelet.yaml
  59. ftp-source.kamelet.yaml
  60. ftps-sink.kamelet.yaml
  61. ftps-source.kamelet.yaml
  62. github-source.kamelet.yaml
  63. google-calendar-source.kamelet.yaml
  64. google-mail-source.kamelet.yaml
  65. google-pubsub-sink.kamelet.yaml
  66. google-pubsub-source.kamelet.yaml
  67. google-sheets-source.kamelet.yaml
  68. has-header-filter-action.kamelet.yaml
  69. header-matches-filter-action.kamelet.yaml
  70. hoist-field-action.kamelet.yaml
  71. http-secured-sink.kamelet.yaml
  72. http-secured-source.kamelet.yaml
  73. http-sink.kamelet.yaml
  74. http-source.kamelet.yaml
  75. infinispan-source.kamelet.yaml
  76. insert-field-action.kamelet.yaml
  77. insert-header-action.kamelet.yaml
  78. is-tombstone-filter-action.kamelet.yaml
  79. jira-source.kamelet.yaml
  80. jms-amqp-10-sink.kamelet.yaml
  81. jms-amqp-10-source.kamelet.yaml
  82. jms-apache-artemis-sink.kamelet.yaml
  83. jms-apache-artemis-source.kamelet.yaml
  84. json-deserialize-action.kamelet.yaml
  85. json-schema-validator-action.kamelet.yaml
  86. json-serialize-action.kamelet.yaml
  87. jsonata-action.kamelet.yaml
  88. kafka-manual-commit-action.kamelet.yaml
  89. kafka-not-secured-sink.kamelet.yaml
  90. kafka-not-secured-source.kamelet.yaml
  91. kafka-sink.kamelet.yaml
  92. kafka-source.kamelet.yaml
  93. kubernetes-namespaces-source.kamelet.yaml
  94. kubernetes-nodes-source.kamelet.yaml
  95. kubernetes-pods-source.kamelet.yaml
  96. library/
  97. log-sink.kamelet.yaml
  98. mail-imap-source.kamelet.yaml
  99. mariadb-sink.kamelet.yaml
  100. mariadb-source.kamelet.yaml
  101. mask-field-action.kamelet.yaml
  102. message-timestamp-router-action.kamelet.yaml
  103. minio-sink.kamelet.yaml
  104. minio-source.kamelet.yaml
  105. mongodb-sink.kamelet.yaml
  106. mongodb-source.kamelet.yaml
  107. mqtt-source.kamelet.yaml
  108. mustache-template-action.kamelet.yaml
  109. mvel-template-action.kamelet.yaml
  110. mvnw
  111. mvnw.cmd
  112. mysql-sink.kamelet.yaml
  113. mysql-source.kamelet.yaml
  114. nats-sink.kamelet.yaml
  115. nats-source.kamelet.yaml
  116. openai-classification-action.kamelet.yaml
  117. openai-completion-action.kamelet.yaml
  118. pdf-action.kamelet.yaml
  119. pom.xml
  120. postgresql-sink.kamelet.yaml
  121. postgresql-source.kamelet.yaml
  122. predicate-filter-action.kamelet.yaml
  123. protobuf-deserialize-action.kamelet.yaml
  124. protobuf-serialize-action.kamelet.yaml
  125. rabbitmq-source.kamelet.yaml
  126. regex-router-action.kamelet.yaml
  127. replace-field-action.kamelet.yaml
  128. salesforce-source.kamelet.yaml
  129. script/
  130. sftp-sink.kamelet.yaml
  131. sftp-source.kamelet.yaml
  132. slack-sink.kamelet.yaml
  133. slack-source.kamelet.yaml
  134. sqlserver-sink.kamelet.yaml
  135. sqlserver-source.kamelet.yaml
  136. ssh-source.kamelet.yaml
  137. string-template-action.kamelet.yaml
  138. telegram-sink.kamelet.yaml
  139. telegram-source.kamelet.yaml
  140. templates/
  141. test/
  142. timer-source.kamelet.yaml
  143. timestamp-router-action.kamelet.yaml
  144. topic-name-matches-filter-action.kamelet.yaml
  145. twitter-directmessage-source.kamelet.yaml
  146. twitter-search-source.kamelet.yaml
  147. twitter-timeline-source.kamelet.yaml
  148. update-kamelets.xml
  149. value-to-key-action.kamelet.yaml
  150. velocity-template-action.kamelet.yaml
  151. webhook-source.kamelet.yaml
  152. xj-identity-action.kamelet.yaml
  153. xj-template-action.kamelet.yaml
README.md

Apache Camel - Kamelet Catalog

This repository contains the default Kamelet catalog used by Apache Camel and its sub-projects.

Kamelets in this repository can be used natively in Apache Camel K integrations, without additional configuration steps: users just need to reference the Kamelets by name in the URI (e.g. kamelet:timer-source?message=Hello), or use them in a KameletBinding.

NOTE: Camel K (and other sub-projects) will only use a specific version of this Kamelet catalog. Refer to the release notes of the sub-project for more information.

Documents and guides about Kamelets can be found in the Kamelets User and Developer Guides.

Guidelines for contributions

Kamelets in this repository are intended to be generic connectors that any external platform can embed in order to leverage the Apache Camel integration capabilities.

All Kamelets posted here will be subject to the scrutiny of the Apache Camel PMC to assess their compliance with the ecosystem and, in any case, they MUST be in line with the general Apache Code of Conduct.

General Format

Kamelets MUST be provided in the Kubernetes YAML format, i.e. they MUST be resources that can be applied on a cluster using the Kubernetes kubectl CLI.

The file name of each Kamelet MUST follow this specific pattern: <kamelet-name>.kamelet.yaml. The <kamelet-name> MUST match field metadata -> name inside the Kamelet YAML.

For the time being, we'll accept only these kinds of Kamelets:

  • Sources: Kamelets producing data that can be forwarded to any chosen destination. In the Camel jargon, a source can be used consumer-side. Kamelets belonging to this category MUST be marked with label: camel.apache.org/kamelet.type=source.
  • Sinks: Kamelets that accept data with a specific datashape and forward it to an external system. In the Camel jargon, a sink can be used producer-side. Kamelets belonging to this category MUST be marked with label: camel.apache.org/kamelet.type=sink.
  • Actions: Kamelets that can be used as intermediate steps as they both accept and produce data, applying transformations to it or changing the behavior of the whole integration flow (e.g. using enterprise integration patterns). Kamelets belonging to this category MUST be marked with label: camel.apache.org/kamelet.type=action.

All Kamelets MUST provide a value for label camel.apache.org/kamelet.type.

All Kamelets MUST declare an icon in the camel.apache.org/kamelet.icon annotation using the embedded URL data:image format. An icon annotation CANNOT contain a link to an external location. A Kamelet SHOULD use the specific data:image/svg+xml;base64 format whenever it's possible.

Kamelets that are logically related (e.g. all Kamelets that allow doing things with Twitter) SHOULD be linked together using the label camel.apache.org/kamelet.group=<name of the group> (e.g. camel.apache.org/kamelet.group=Twitter) to ease visualization in tooling.

All Kamelets present in this repository MUST have the annotation camel.apache.org/provider set to "Apache Software Foundation".

We provide an example of Kamelet to give more context to the following sections:

apiVersion: camel.apache.org/v1alpha1
kind: Kamelet
metadata:
  name: timer-source
  annotations:
    camel.apache.org/kamelet.icon: data:image/svg+xml;base64,PD94...
    camel.apache.org/provider: "Apache Software Foundation"
  labels:
    camel.apache.org/kamelet.type: source
spec:
  definition:
    title: Timer Source
    description: Produces periodic events with a custom payload
    required:
      - message
    properties:
      period:
        title: Period
        description: The interval between two events in milliseconds
        type: integer
        default: 1000
      message:
        title: Message
        description: The message to generate
        type: string
        example: hello world
  types:
    out:
      mediaType: text/plain
  flow:
    from:
      uri: timer:tick
      parameters:
        period: "{{period}}"
      steps:
        - set-body:
            constant: "{{message}}"
        - to: kamelet:sink

Flow Code

The Camel route that defines the behavior of the Kamelet MUST be provided in YAML flow syntax. The Kamelet MAY declare additional supporting routes that MUST be written in YAML syntax (to provide better support in all Camel subprojects).

The code of a “source” Kamelet must send data to the kamelet:sink special endpoint. The code of a “sink” Kamelet must consume data from the special endpoint kamelet:source.

The Kamelet MAY declare dependencies on Camel components using the syntax camel:<component-name> (e.g. camel:telegram). Some Camel dependencies are implicitly added by the runtime when a certain Camel URI is used (e.g. there's no need to declare explicit dependency on camel:timer if the flow section uses the timer URI).

The Kamelet CAN declare dependencies on artifacts of one of the Camel subprojects. In case it does, the Kamelet must contain label camel.apache.org/requires.runtime=<name-of-the-project> (e.g. camel.apache.org/requires.runtime=camel-quarkus).

The Kamelet CAN declare dependencies on other artifacts in Maven Central, provided that they are released with a license compatible with Apache License 2.0 (syntax is mvn:group:artifact:version).

All source code dependencies (e.g. github:organization:project) MUST link to Apache Camel repositories only. Contributors are welcome to use this same repository to share libraries in the form of source code.

All these should be added to the spec -> dependencies section, like in the following example:

# ...
spec:
  # ...
  dependencies:
  - camel:telegram
  - mvn:org.apache.commons:commons-vfs2:2.7.0
  - github:apache/camel-kamelets
  flow:
    # ...

Configuration properties

Kamelets SHOULD declare their configuration properties in the spec -> definition section as a JSON-schema specification.

The top-level part of the JSON-schema document refer to the Kamelet itself, so the following properties are MANDATORY:

  • title: the visual name of the Kamelet
  • description: a detailed description of what the Kamelet is useful for

The properties part can then contain a set of configuration properties available for the Kamelet.

Property name id is reserved and implicit for all Kamelets.

Data Types

Kamelets SHOULD declare the mediaType of data that they produce or consume when it's known in advance. If technically possible, they SHOULD also indicate the schema of the corresponding data.

Kamelets MAY choose not to declare a mediaType when it varies depending on the configuration of the parameters. Contributors MAY consider to split a Kamelet into multiple instances if that can help determining unique types and schemas.

Testing

Kamelets SHOULD be accompained with testing code that verifies their correct behavior.

Yaks is the testing framework of choice for Kamelets and the one implemented in the CI.

Test code must be submitted in the test/<kamelet-name>/ directory in the root of this repository.

Kamelets submitted with tests that verify their correctness MUST be labeled with camel.apache.org/kamelet.verified=true.

NOTE: there‘s no way at the moment to inject credentials for external systems into the CI in order to write more advanced tests, but we can expect we’ll find an usable strategy in the long run

Releasing

This project is released as standard Apache Camel module.

To release it, first set the next release version in the kamelets:

export CAMEL_KAMELET_VERSION=x.y.z

./mvnw clean install -DreleaseVersion=$CAMEL_KAMELET_VERSION

Stage the commits in SVN:

git commit -am "Update Kamelets for release $CAMEL_KAMELET_VERSION"

git push upstream main

Check that everything is alright with a dryRun:

./mvnw release:prepare -Prelease \
  -DdryRun \
  -DreleaseVersion=$CAMEL_KAMELET_VERSION \
  -DdevelopmentVersion=main-SNAPSHOT \
  -Dtag=v$CAMEL_KAMELET_VERSION

Check the signatures of the files, then clean and prepare the actual release:

./mvnw release:clean -Prelease
./mvnw release:prepare -Prelease \
  -DreleaseVersion=$CAMEL_KAMELET_VERSION \
  -DdevelopmentVersion=main-SNAPSHOT \
  -Dtag=v$CAMEL_KAMELET_VERSION

Then perform the release:

./mvnw release:perform -Prelease

Restore Kamelets:

./mvnw clean install

Update remote git:

git commit -am "Restore Kamelets for development"

git push upstream main