Red Hat build of Apache Camel for Quarkus リファレンス

Camel AMQP コンポーネントは、jakarta.jms.Message および org.apache.camel.Message 間のメッセージマッピングをサポートします。Camel メッセージ本文タイプ org.w3c.dom.Node を変換する場合は、camel-quarkus-xml-jaxp エクステンションがクラスパスに存在することを確認する必要があります。

JMS メッセージペイロードを jakarta.jms.ObjectMessage として送信する場合、シリアル化のために登録する関連クラスに @RegisterForReflection(serialization = true) でアノテーションを付ける必要があります。このエクステンションは、quarkus.camel.native.reflection.serialization-enabled = true を自動的に設定することに注意してください。詳細は、ネイティブモードのユーザーガイド を参照してください。

quarkus-pooled-jms エクステンションを使用すると、接続のプーリングサポートを取得できます。詳細は、quarkus-pooled-jms エクステンションドキュメントを参照してください。

以下の依存関係を pom.xml に追加するだけで、接続のプーリングサポートを取得できます。

<dependency>
    <groupId>io.quarkiverse.messaginghub</groupId>
    <artifactId>quarkus-pooled-jms</artifactId>
</dependency>

プーリングのサポートを有効にするには、以下の設定を application.properties に追加する必要があります。

quarkus.qpid-jms.wrap=true

必要に応じて、Quarkus Amazon DynamoDB エクステンションを Camel Quarkus AWS 2 DynamoDB と組み合わせて使用することができます。これは完全に任意であり、必須ではないことに注意してください。Quarkus のドキュメント に従ってください。ただし、次の注意事項に注意してください。

quarkus-amazon-lambda エクステンションを使用すると、Quarkus を使用して AWS Lambda をビルドできますが、Camel コンポーネントは既存の関数を管理 (デプロイ、アンデプロイなど) します。したがって、quarkus-amazon-lambda を aws2-lambda エクステンションのクライアントとして使用することはできません。

必要に応じて、Quarkus Amazon S3 エクステンションを Camel Quarkus AWS 2 S3 Storage Service と組み合わせて使用することができます。これは完全に任意であり、必須ではないことに注意してください。Quarkus のドキュメント に従ってください。ただし、次の注意事項に注意してください。

必要に応じて、Quarkus Amazon SNS エクステンションを Camel Quarkus AWS 2 Simple Notification System (SNS) と組み合わせて使用することができます。これは完全に任意であり、必須ではないことに注意してください。Quarkus のドキュメント に従ってください。ただし、次の注意事項に注意してください。

必要に応じて、Quarkus Amazon SQS エクステンションを Camel Quarkus AWS 2 Simple Queue Service (SQS) と組み合わせて使用することができます。これは完全に任意であり、必須ではないことに注意してください。Quarkus のドキュメント に従ってください。ただし、次の注意事項に注意してください。

Reactor Netty トランスポートの Micrometer メトリクスのコレクションを有効にする場合は、quarkus-micrometer の依存関係を宣言して、Quarkus メトリクス HTTP エンドポイント経由で利用できるようにします。

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-micrometer</artifactId>
</dependency>

Reactor Netty トランスポートの Micrometer メトリクスのコレクションを有効にする場合は、quarkus-micrometer の依存関係を宣言して、Quarkus メトリクス HTTP エンドポイント経由で利用できるようにします。

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-micrometer</artifactId>
</dependency>

このエクステンションの実装は、Quarkus Hibernate Validator エクステンション を利用します。

そのため、Camel のプロパティー (constraintValidatorFactory、messageInterpolator、traversableResolver、validationProviderResolver、validatorFactory) によって ValidatorFactory を設定することはできません。

デフォルトの ValidatorFactory (Quarkus によって作成される) に注入される Bean を作成して ValidatorFactory を設定できます。詳細は、Quarkus CDI のドキュメント を参照してください。

ネイティブモードでカスタム検証グループを使用する場合は、反映するためにすべてのインターフェイスを登録する必要があります (ドキュメント を参照)。

以下に例を示します。

@RegisterForReflection
public interface OptionalChecks {
}

ネイティブモードで CassandraAggregationRepository などの Cassandra 集約リポジトリーを使用するには、ネイティブシリアライズのサポートを有効化 する必要があります。

さらに、エクスチェンジボディがカスタムタイプである場合、クラス宣言に @RegisterForReflection(serialization = true) のアノテーションを付けてシリアライズ用に登録する必要があります。

camel-quarkus-cxf-soap は、CXF Extensions for Quarkus プロジェクト (quarkus-cxf) のエクステンションを使用します。

これは、サポートされるユースケースと WS 仕様のセットの大部分が quarkus-cxf によって提供されることを意味します。

Red Hat build of Apache Camel for Quarkus は、CXF および quarkus-cxf のバージョンを 管理 します。これらのプロジェクトと互換性があるバージョンを選択する必要はありません。

camel-quarkus-cxf-soap (追加の依存関係は不要) を使用すると、CXF クライアントを Camel ルートでプロデューサーとして使用できます。

import org.apache.camel.builder.RouteBuilder;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.context.SessionScoped;
import jakarta.enterprise.inject.Produces;
import jakarta.inject.Named;

@ApplicationScoped
public class CxfSoapClientRoutes extends RouteBuilder {

    @Override
    public void configure() {

        /* You can either configure the client inline */
        from("direct:cxfUriParamsClient")
                .to("cxf://http://localhost:8082/calculator-ws?wsdlURL=wsdl/CalculatorService.wsdl&dataFormat=POJO&serviceClass=org.foo.CalculatorService");

        /* Or you can use a named bean produced below by beanClient() method */
        from("direct:cxfBeanClient")
                .to("cxf:bean:beanClient?dataFormat=POJO");

    }

    @Produces
    @SessionScoped
    @Named
    CxfEndpoint beanClient() {
        final CxfEndpoint result = new CxfEndpoint();
        result.setServiceClass(CalculatorService.class);
        result.setAddress("http://localhost:8082/calculator-ws");
        result.setWsdlURL("wsdl/CalculatorService.wsdl"); // a resource in the class path
        return result;
    }
}

CalculatorService は以下のようになります。

import jakarta.jws.WebMethod;
import jakarta.jws.WebService;

@WebService(targetNamespace = CalculatorService.TARGET_NS) 1
public interface CalculatorService {

    public static final String TARGET_NS = "http://acme.org/wscalculator/Calculator";

    @WebMethod 2
    public int add(int intA, int intB);

    @WebMethod 3
    public int subtract(int intA, int intB);

    @WebMethod 4
    public int divide(int intA, int intB);

    @WebMethod 5
    public int multiply(int intA, int intB);
}

$ docker run -p 8082:8080 quay.io/l2x6/calculator-ws:1.2

camel-quarkus-cxf-soap を使用すると、SOAP エンドポイントを Camel ルートのコンシューマーとして公開できます。このユースケースには、追加の依存関係は必要ありません。

import org.apache.camel.builder.RouteBuilder;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.inject.Produces;
import jakarta.inject.Named;

@ApplicationScoped
public class CxfSoapRoutes extends RouteBuilder {

    @Override
    public void configure() {
        /* A CXF Service configured through a CDI bean */
        from("cxf:bean:helloBeanEndpoint")
                .setBody().simple("Hello ${body} from CXF service");

        /* A CXF Service configured through Camel URI parameters */
        from("cxf:///hello-inline?wsdlURL=wsdl/HelloService.wsdl&serviceClass=org.foo.HelloService")
                        .setBody().simple("Hello ${body} from CXF service");
    }

    @Produces
    @ApplicationScoped
    @Named
    CxfEndpoint helloBeanEndpoint() {
        final CxfEndpoint result = new CxfEndpoint();
        result.setServiceClass(HelloService.class);
        result.setAddress("/hello-bean");
        result.setWsdlURL("wsdl/HelloService.wsdl");
        return result;
    }
}

これら 2 つのサービスが提供されるパスは、たとえば application.properties で設定できる quarkus.cxf.path 設定プロパティー の値によって異なります。

quarkus.cxf.path = /soap-services

この設定を適用すると、http://localhost:8080/soap-services/hello-bean および http://localhost:8080/soap-services/hello-inline で、2 つのサービスにそれぞれアクセスできます。

WSDL には、上記の URL に ?wsdl を追加することでアクセスできます。

org.apache.cxf.ext.logging.LoggingFeature を使用して、クライアントとサーバーの両方の SOAP メッセージの詳細ロギングを有効にできます。

import org.apache.camel.builder.RouteBuilder;
import org.apache.cxf.ext.logging.LoggingFeature;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.context.SessionScoped;
import jakarta.enterprise.inject.Produces;
import jakarta.inject.Named;

@ApplicationScoped
public class MyBeans {

    @Produces
    @ApplicationScoped
    @Named("prettyLoggingFeature")
    public LoggingFeature prettyLoggingFeature() {
        final LoggingFeature result = new LoggingFeature();
        result.setPrettyLogging(true);
        return result;
    }

    @Inject
    @Named("prettyLoggingFeature")
    LoggingFeature prettyLoggingFeature;

    @Produces
    @SessionScoped
    @Named
    CxfEndpoint cxfBeanClient() {
        final CxfEndpoint result = new CxfEndpoint();
        result.setServiceClass(CalculatorService.class);
        result.setAddress("https://acme.org/calculator");
        result.setWsdlURL("wsdl/CalculatorService.wsdl");
        result.getFeatures().add(prettyLoggingFeature);
        return result;
    }

    @Produces
    @ApplicationScoped
    @Named
    CxfEndpoint helloBeanEndpoint() {
        final CxfEndpoint result = new CxfEndpoint();
        result.setServiceClass(HelloService.class);
        result.setAddress("/hello-bean");
        result.setWsdlURL("wsdl/HelloService.wsdl");
        result.getFeatures().add(prettyLoggingFeature);
        return result;
    }
}

サポートされる WS 仕様の範囲は、Quarkus CXF プロジェクトによって提供されます。

camel-quarkus-cxf-soap は、io.quarkiverse.cxf:quarkus-cxf エクステンションを介して、以下の仕様のみをカバーします。

アプリケーションが WS-Security や WS-Trust などの他の WS 仕様を必要とする場合は、それをカバーする Quarkus CXF 依存関係を追加する必要があります。どの WS 仕様がどの Quarkus CXF エクステンションでカバーされているかを確認するには、Quarkus CXF の Reference ページを参照してください。

quarkus-cxf は、以下の 2 つの CXF ツールをラップします。

quarkus.cxf.codegen.wsdl2java.additional-params = -validate

同じルートが複数の JVM にデプロイされている場合、このエクステンションを マスターのエクステンション と組み合わせて使用すると便利な場合があります。このようなセットアップでは、キャメルマスター namespace 全体で一度に 1 つのコンシューマーがアクティブになります。

たとえば、以下のルートを複数の JVM にデプロイするとします。

from("master:ns:timer:test?period=100").log("Timer invoked on a single JVM at a time");

以下のようなプロパティーを使用して、ファイルクラスターサービスを有効にすることができます。

quarkus.camel.cluster.file.enabled = true
quarkus.camel.cluster.file-root = target/cluster-folder-where-lock-file-will-be-held

その結果、1 つのコンシューマーが ns camel マスター namespace 全体でアクティブになります。これは、ある時点で、1 つのタイマーだけがすべての JVM 間でエクスチェンジを生成することを意味します。つまり、メッセージは一度に 1 つの JVM で 100 ミリ秒ごとにログに記録されます。

ファイルクラスターサービスは、quarkus.camel.cluster.file.* プロパティーを微調整できます。

{doc-link-icon-lock}[title=Fixed at build time] 設定プロパティーはビルド時に修正されました。その他の設定プロパティーはすべて、ランタイム時にオーバーライドが可能です。

Camel Quarkus gRPC は、.proto ファイルの gRPC サービススタブを生成できます。Maven を使用する場合は、プロジェクトビルドで quarkus-maven-plugin の generate-code ゴールが有効になっていることを確認してください。

<build>
    <plugins>
        <plugin>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-maven-plugin</artifactId>
            <version>${quarkus.platform.version}</version>
            <extensions>true</extensions>
            <executions>
                <execution>
                    <goals>
                        <goal>build</goal>
                        <goal>generate-code</goal>
                        <goal>generate-code-tests</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

この設定を使用すると、サービス定義とメッセージ定義を src/main/proto ディレクトリーに配置でき、quarkus-maven-plugin が .proto ファイルからコードを生成します。

quarkus.camel.grpc.codegen.scan-for-proto=org.my.groupId1:my-artifact-id-1,org.my.groupId2:my-artifact-id-2

quarkus.camel.grpc.codegen.scan-for-proto-includes."<groupId>\:<artifactId>"=foo/**,bar/**,baz/a-proto.proto
quarkus.camel.grpc.codegen.scan-for-proto-excludes."<groupId>\:<artifactId>"=foo/private/**,baz/another-proto.proto

gRPC コンポーネントには、リソースをクラスパスから解決するさまざまなオプションがあります。

これらのオプションをネイティブモードで使用する場合は、そのようなリソースがネイティブイメージに含まれていることを確認する必要があります。

これは、設定プロパティー quarkus.native.resources.includes を application.properties に追加することで実現できます。たとえば、SSL/TLS キーと証明書を含めるには、次のように指定します。

quarkus.native.resources.includes = certs/*.pem,certs.*.key

現時点では、Camel Quarkus gRPC と Quarkus gRPC の統合はサポートされていません。クラスパスに camel-quarkus-grpc と quarkus-grpc エクステンションの両方の依存関係がある場合、アプリケーションをコンパイルすると、ビルド時に問題が発生する可能性があります。

ネイティブモードでオブジェクトをマーシャリングまたはアンマーシャリングする場合、シリアライズされたクラスはすべて リフレクションのために登録 する必要があります。そのため、GsonDataFormat.setUnmarshalType(…​)、GsonDataFormat.setUnmarshalTypeName(…​)、さらに GsonDataFormat.setUnmarshalGenericType(…​) を使用する場合は、アンマーシャリングタイプとサブフィールドタイプをリフレクション用に登録する必要があります。この インテグレーションテスト で実際の例を参照してください。

該当する Camel Infinispan コンポーネントおよびエンドポイントオプションで Infinispan クライアントを設定するか、Quarkus Infinispan エクステンション設定プロパティー を使用できます。

Quarkus Infinispan 設定プロパティーを使用することを選択した場合は、Camel Infinispan コンポーネントで検出できるようにするために、RemoteCacheManager のインジェクションポイントを 追加する必要がある ことに注意してください。以下に例を示します。

public class Routes extends RouteBuilder {
    // Injects the default unnamed RemoteCacheManager
    @Inject
    RemoteCacheManager cacheManager;

    // If configured, injects an optional named RemoteCacheManager
    @Inject
    @InfinispanClientName("myNamedClient")
    RemoteCacheManager namedCacheManager;

    @Override
    public void configure() {
        // Route configuration here...
    }
}

InfinispanRemoteAggregationRepository をネイティブモードで使用することを選択した場合は、ネイティブシリアライゼーションサポートを有効 にする必要があります。

JacksonDataFormat が使用する ObjectMapper を設定するには、いくつかの方法があります。これらの概要を以下に示します。

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.jackson.JacksonDataFormat;

public class Routes extends RouteBuilder {
    public void configure() {
        ObjectMapper mapper = new ObjectMapper();
        JacksonDataFormat dataFormat = new JacksonDataFormat();
        dataFormat.setObjectMapper(mapper);
        // Use the dataFormat instance in a route definition
        from("direct:my-direct").marshal(dataFormat)
    }
}

import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.jackson.JacksonDataFormat;

public class Routes extends RouteBuilder {
    public void configure() {
        JacksonDataFormat dataFormat = new JacksonDataFormat();
        // Make JacksonDataFormat discover the Quarkus Jackson `ObjectMapper` from the Camel registry
        dataFormat.setAutoDiscoverObjectMapper(true);
        // Use the dataFormat instance in a route definition
        from("direct:my-direct").marshal(dataFormat)
    }
}

import org.apache.camel.builder.RouteBuilder;

@ApplicationScoped
public class Routes extends RouteBuilder {
    public void configure() {
        restConfiguration().dataFormatProperty("autoDiscoverObjectMapper", "true");
        // REST definition follows...
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import io.quarkus.jackson.ObjectMapperCustomizer;

@Singleton
public class RegisterCustomModuleCustomizer implements ObjectMapperCustomizer {
    public void customize(ObjectMapper mapper) {
        mapper.registerModule(new CustomModule());
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.jackson.JacksonDataFormat;

@ApplicationScoped
public class Routes extends RouteBuilder {
    @Inject
    ObjectMapper mapper;

    public void configure() {
        JacksonDataFormat dataFormat = new JacksonDataFormat();
        dataFormat.setObjectMapper(mapper);
        // Use the dataFormat instance in a route definition
        from("direct:my-direct").marshal(dataFormat)
    }
}

JAXB アノテーションを持たない POJO クラスをインスタンス化するために、カスタム ObjectFactory で JAXB マーシャル操作を行う場合、それらの POJO クラスをネイティブモードでインスタンス化するために、リフレクションに登録する必要があります。たとえば、@RegisterForReflection アノテーションまたは設定プロパティー quarkus.camel.native.reflection.include-patterns を介した場合です。

詳細は、ネイティブモード のユーザーガイドを参照してください。

このエクステンションは、DataSource のサポートに Quarkus Agroal を活用します。DataSource の設定は、設定プロパティーを介して実行できます。JDBC エンドポイント URI で参照できるように、データソースの名前は明示的に付けることを推奨します。たとえば、to("jdbc:camel") のようになります。

quarkus.datasource.camel.db-kind=postgresql
quarkus.datasource.camel.username=your-username
quarkus.datasource.camel.password=your-password
quarkus.datasource.camel.jdbc.url=jdbc:postgresql://localhost:5432/your-database
quarkus.datasource.camel.jdbc.max-size=16

データソースに名前を付けないことを選択した場合は、to("jdbc:default") のようにエンドポイントを定義することでデフォルトの DataSource を解決できます。

Camel JMS コンポーネントは、jakarta.jms.Message および org.apache.camel.Message 間のメッセージマッピングをサポートします。Camel メッセージ本文タイプ org.w3c.dom.Node を変換する場合は、camel-quarkus-xml-jaxp エクステンションがクラスパスに存在することを確認する必要があります。

JMS メッセージペイロードを jakarta.jms.ObjectMessage として送信する場合、シリアル化のために登録する関連クラスに @RegisterForReflection(serialization = true) でアノテーションを付ける必要があります。

quarkus-pooled-jms エクステンションを使用して、JMS 接続のプーリングと XAのサポートを得ることができます。詳細は、quarkus-pooled-jms エクステンションドキュメントを参照してください。現在、このエクステンションは、quarkus-artemis-jms、quarkus-qpid-jms、および ibmmq-client で使用できます。依存関係を pom.xml に追加するだけです。

<dependency>
    <groupId>io.quarkiverse.messaginghub</groupId>
    <artifactId>quarkus-pooled-jms</artifactId>
</dependency>

プーリングはデフォルトで有効になっています。

XA を有効にするには、quarkus-narayana-jta エクステンションを追加する必要があります。

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-narayana-jta</artifactId>
</dependency>

続いて、次の設定を application.properties に追加します。

quarkus.pooled-jms.transaction=xa
quarkus.transaction-manager.enable-recovery=true

XA サポートは、quarkus-artemis-jms および ibmmq-client でのみ利用可能です。

トランザクションリカバリー を有効にすることを強く推奨します。

現在、ibmmq-client 用の quarkus エクステンションは存在しないため、独自にカスタム ConnectionFactory を作成してラップする必要があります。

以下に例を示します。

@Produces
public ConnectionFactory createXAConnectionFactory(PooledJmsWrapper wrapper) {
    MQXAConnectionFactory mq = new MQXAConnectionFactory();
    try {
        mq.setHostName(ConfigProvider.getConfig().getValue("ibm.mq.host", String.class));
        mq.setPort(ConfigProvider.getConfig().getValue("ibm.mq.port", Integer.class));
        mq.setChannel(ConfigProvider.getConfig().getValue("ibm.mq.channel", String.class));
        mq.setQueueManager(ConfigProvider.getConfig().getValue("ibm.mq.queueManagerName", String.class));
        mq.setTransportType(WMQConstants.WMQ_CM_CLIENT);
        mq.setStringProperty(WMQConstants.USERID,
            ConfigProvider.getConfig().getValue("ibm.mq.user", String.class));
        mq.setStringProperty(WMQConstants.PASSWORD,
            ConfigProvider.getConfig().getValue("ibm.mq.password", String.class));
    } catch (Exception e) {
        throw new RuntimeException("Unable to create new IBM MQ connection factory", e);
    }
    return wrapper.wrapConnectionFactory(mq);
}

CDI コンテナーの EntityManagerFactory と TransactionStrategy を使用して、JpaMessageIdRepository を設定する必要があります。

@Inject
EntityManagerFactory entityManagerFactory;

@Inject
TransactionStrategy transactionStrategy;

from("direct:idempotent")
    .idempotentConsumer(
        header("messageId"),
        new JpaMessageIdRepository(entityManagerFactory, transactionStrategy, "idempotentProcessor"));

通常、このコンポーネントはクラスパスからテンプレートをロードします。ネイティブモードでも機能させるには、quarkus.native.resources.includes プロパティーを使用して、テンプレートファイルをネイティブ実行可能ファイルに明示的に埋め込む必要があります。

たとえば、以下のルートは、transformation.json という名前のクラスパスリソースから JSLT スキーマを読み込みます。

from("direct:start").to("jslt:transformation.json");

これら (.json ファイルに保存されている可能性のある他のテンプレート) をネイティブイメージに含めるには、application.properties ファイルに次のようなものを追加する必要があります。

quarkus.native.resources.includes = *.json

camel-quarkus の JSLT 関数をネイティブモードで使用する場合、関数をホストするクラスを リフレクションに登録 する必要があります。ターゲット関数を登録できない場合、以下のようにスタブを書いてしまうことがあります。

@RegisterForReflection
public class MathFunctionStub {
    public static double pow(double a, double b) {
        return java.lang.Math.pow(a, b);
    }
}

ターゲット関数 Math.pow(…​) は、以下のようにコンポーネントに登録できる MathFunctionStub クラスを介してアクセスできるようになりました。

@Named
JsltComponent jsltWithFunction() throws ClassNotFoundException {
    JsltComponent component = new JsltComponent();
    component.setFunctions(singleton(wrapStaticMethod("power", "org.apache.cq.example.MathFunctionStub", "pow")));
    return component;
}

Camel Quarkus Kafka は、Quarkus Kafka Dev services を利用して、ローカルのコンテナー化された Kafka ブローカーでの開発およびテストを簡素化できます。

デフォルトで、Kafka Dev Services は開発およびテストモードで有効になっています。Camel Kafka コンポーネントは、brokers コンポーネントのオプションがローカルのコンテナー化された Kafka ブローカーを参照するように自動的に設定されます。つまり、このオプションを独自に設定する必要はありません。

この機能は、設定プロパティー quarkus.kafka.devservices.enabled=false を使用して無効にできます。

このエクステンションを使用すると、quarkus.camel.kamelet.identifiers プロパティーを使用して、ビルド時に一連の Kamelet をプリロードできます。

/camel-kamelets/latest[Kamelet Catalog] には事前に設定された Kamelets のセットがあります。カタログから Kamelet を使用するには、クラスパスのプロジェクトの yaml 定義 (camel-kamelet リポジトリー にあります) をコピーする必要があります。または、camel-kamelets-catalog アーティファクトを pom.xml に追加できます。

<dependency>
    <groupId>org.apache.camel.kamelets</groupId>
    <artifactId>camel-kamelets-catalog</artifactId>
</dependency>

このアーティファクトは、カタログで使用可能なすべての kamelets を Camel Quarkus アプリケーションに追加してビルドタイム処理を行います。アーティファクトがランタイムではなくビルドタイムクラスパスの一部でなければならないという条件 (provided) でスコープに含める場合、quarkus.camel.kamelet.identifiers プロパティーを介してリストされたすべての kamelets を事前にロードする必要があります。

エクステンションは、kubernetesClient という名前の Kubernetes クライアント Bean を自動的に登録します。次のように、ルートで Bean を参照できます。

from("direct:pods")
    .to("kubernetes-pods:///?kubernetesClient=#kubernetesClient&operation=listPods")

デフォルトでは、クライアントはローカルの kubeconfig ファイルから設定されます。application.properties 内のプロパティーを使用して、クライアント設定をカスタマイズできます。

quarkus.kubernetes-client.master-url=https://my.k8s.host
quarkus.kubernetes-client.namespace=my-namespace

設定オプションの完全なセットは、Quarkus Kubernetes Client ガイド に記載されています。

同じルートが複数の Pod にデプロイされている場合、このエクステンションを マスターのエクステンション と組み合わせて使用すると便利な場合があります。このようなセットアップでは、キャメルマスター namespace 全体で一度に 1 つのコンシューマーがアクティブになります。

たとえば、以下のルートを複数の Pod にデプロイするとします。

from("master:ns:timer:test?period=100").log("Timer invoked on a single pod at a time");

以下のようなプロパティーを使用して、kubernetes クラスターサービスを有効にすることができます。

quarkus.camel.cluster.kubernetes.enabled = true

その結果、1 つのコンシューマーが ns camel マスター namespace 全体でアクティブになります。これは、特定の時点で、単一のタイマーのみがクラスター全体でエクスチェンジを生成することを意味します。つまり、メッセージは一度に 1 つの Pod で 100 ミリ秒ごとにログに記録されます。

kubernetes クラスターサービスは、quarkus.camel.cluster.kubernetes.* プロパティーをさらに微調整できます。

{doc-link-icon-lock}[title=Fixed at build time] 設定プロパティーはビルド時に修正されました。その他の設定プロパティーはすべて、ランタイム時にオーバーライドが可能です。

言語エクステンションは、実行するスクリプトに Exchange を渡すことのみを処理します。言語を実装するエクステンションは依存関係として追加する必要があります。次のリストの言語が Core に実装されています。

他の言語を使用するには、対応する依存関係を追加する必要があります。詳細は、言語ガイド を参照してください。

ネイティブモードでクラスパスからスクリプトをロードする場合、スクリプトファイルへのパスを application.properties ファイルの quarkus.native.resources.includes プロパティーで指定する必要があります。以下に例を示します。

quarkus.native.resources.includes=script.txt

カスタム SSLSocketFactory (Configuring SSL セクションにあるものなど) をネイティブモードで使用する場合は、クラスをリフレクション用に登録する必要があります。そうしないと、クラスがクラスパスで使用可能になりません。次のように、クラス定義の上に @RegisterForReflection アノテーションを追加します。

@RegisterForReflection
public class CustomSSLSocketFactory extends SSLSocketFactory {
    // The class definition is the same as in the above link.
}

JMX は、次のいずれかの方法で Camel-Quarkus で有効または無効にすることができます。

JDK 17/20/Mandrel 23.0 の GraalVM のネイティブ実行可能ファイルに 実験的な JMX サポートが追加されました。この機能を有効にするには、以下の設定プロパティーを application.properties に追加します。

quarkus.native.monitoring=jmxserver

詳細は、Quarkus native guide を参照してください。

MapStruct を使用するには、アノテーションプロセッサーを使用するようにビルドを設定する必要があります。

<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
            <annotationProcessorPaths>
                <path>
                    <groupId>org.mapstruct</groupId>
                    <artifactId>mapstruct-processor</artifactId>
                    <version>{mapstruct-version}</version>
                </path>
            </annotationProcessorPaths>
        </configuration>
    </plugin>
</plugins>

dependencies {
    annotationProcessor 'org.mapstruct:mapstruct-processor:{mapstruct-version}'
    testAnnotationProcessor 'org.mapstruct:mapstruct-processor:{mapstruct-version}'
}

デフォルトでは、Red Hat build of Apache Camel for Quarkus は、@Mapper アノテーション付きインターフェイスまたは抽象クラスのパッケージパスを自動的に検出し、それらを Camel MapStruct コンポーネントに渡します。

スキャンされる特定のパッケージをより細かく制御する必要がある場合は、application.properties で設定プロパティーを設定できます。

camel.component.mapstruct.mapper-package-name = com.first.package,org.second.package

quarkus-micrometer-registry-jmx には現在ネイティブサポートがないため、JMX での Micrometer 統計の公開はネイティブモードでは利用できません。

Prometheus バックエンドは、Counter メトリクスのインクリメント中に負の値を無視します。

Red Hat build of Apache Camel for Quarkus では、JmxMeterRegistry の登録が簡素化されています。io.quarkiverse.micrometer.registry:quarkus-micrometer-registry-jmx の依存関係を追加すると、JmxMeterRegistry が自動的に作成されます。

一部のチェックはアプリケーションに自動的に登録されます。

Quarkus OpenTelemetry のデフォルトは、OpenTelemetry で定義された標準の OTLP エクスポーターです。追加のエクスポーターは、Quarkiverse quarkus-opentelemetry-exporter プロジェクトで利用可能になります。

Camel ルートから CDI Bean メソッドの実行をインストルメント化する場合、そのようなメソッドに io.opentelemetry.extension.annotations.WithSpan のアノテーションを付ける必要があります。@WithSpan アノテーションが付けられたメソッドは、新しい Span を作成し、現在のトレースコンテキストと必要な関係を確立します。

たとえば、Camel ルートから CDI Bean をインストルメント化するには、まず適切なメソッドに @WithTrace のアノテーションが付けられていることを確認します。

@ApplicationScoped
@Named("myBean")
public class MyBean {
    @WithSpan
    public String greet() {
        return "Hello World!";
    }
}

次に、Camel ルートで Bean を使用します。

public class MyRoutes extends RouteBuilder {
    @Override
    public void configure() throws Exception {
        from("direct:executeBean")
                .to("bean:myBean?method=greet");
    }
}

CDI インストルメンテーションの詳細は、Quarkus OpenTelemetry ガイドを参照してください。

/hello エンドポイントですべての HTTP メソッドを提供します。

from("platform-http:/hello").setBody(simple("Hello ${header.name}"));

/hello エンドポイントで GET リクエストのみを提供します。

from("platform-http:/hello?httpMethodRestrict=GET").setBody(simple("Hello ${header.name}"));

platform-http コンポーネントで Camel REST DSL を使用できるようにするには、pom.xml に camel-quarkus-rest を追加します。

<dependency>
    <groupId>org.apache.camel.quarkus</groupId>
    <artifactId>camel-quarkus-rest</artifactId>
</dependency>

その後、Camel REST DSL を使用できます。

rest()
    .get("/my-get-endpoint")
        .to("direct:handleGetRequest");

    .post("/my-post-endpoint")
        .to("direct:handlePostRequest");

ホワイトリストに登録して、アップロードを特定のファイル拡張子に制限することができます。

from("platform-http:/upload/multipart?fileNameExtWhitelist=html,txt&httpMethodRestrict=POST")
    .to("log:multipart")
    .process(e -> {
        final AttachmentMessage am = e.getMessage(AttachmentMessage.class);
        if (am.hasAttachments()) {
            am.getAttachments().forEach((fileName, dataHandler) -> {
                try (InputStream in = dataHandler.getInputStream()) {
                    // do something with the input stream
                } catch (IOException ioe) {
                    throw new RuntimeException(ioe);
                }
            });
        }
    });

Quarkus は、platform-http エンドポイントのセキュリティー保護に使用できるさまざまなセキュリティーおよび認証メカニズムを提供します。詳細は、Quarkus Security のドキュメント を参照してください。

ルート内で、認証されたユーザーとその関連する SecurityIdentity および Principal を取得できます。

from("platform-http:/secure")
    .process(e -> {
        Message message = e.getMessage();
        QuarkusHttpUser user = message.getHeader(VertxPlatformHttpConstants.AUTHENTICATED_USER, QuarkusHttpUser.class);
        SecurityIdentity securityIdentity = user.getSecurityIdentity();
        Principal principal = securityIdentity.getPrincipal();
        // Do something useful with SecurityIdentity / Principal. E.g check user roles etc.
    });

Quarkus ドキュメント で quarkus.http.body.* 設定オプション (特に次の項目) も確認してください。quarkus.http.body.handle-file-uploads、quarkus.http.body.uploads-directory および quarkus.http.body.delete-uploaded-files-on-end。

プラットフォーム HTTP コンポーネントはリバースプロキシーとして機能できます。その場合、Exchange.HTTP_URI、Exchange.HTTP_HOST ヘッダーは、HTTP 要求のリクエスト行で受信した絶対 URL から入力されます。

エクスチェンジを元のサーバーに単純にリダイレクトする HTTP プロキシーの例を次に示します。

from("platform-http:proxy")
    .toD("http://"
        + "${headers." + Exchange.HTTP_HOST + "}");

プラットフォーム HTTP サーバーの設定は Quarkus によって管理されます。設定オプションの完全なリストについては、Quarkus HTTP 設定ガイド を参照してください。

Platform HTTP サーバーの SSL を設定するには 、SSL ガイドを使用した安全な接続 に従ってください。SSLContextParameters を使用した SSL 用のサーバーの設定は現在サポートされていないことに注意してください。

アプリケーションがデフォルト以外のエンコーディングを使用してリクエストを送受信することが想定される場合は、ネイティブモードガイドの 文字エンコーディング のセクションを確認してください。

rest-openapi エクステンションを使用する場合は、RestProducerFactory 実装が使用可能である必要があります。現在知られている拡張子は次のとおりです。

Maven ユーザーは、これらの依存関係のいずれかを pom.xml に追加する必要があります。次に例を示します。

<dependency>
    <groupId>org.apache.camel.quarkus</groupId>
    <artifactId>camel-quarkus-http</artifactId>
</dependency>

OpenApi 仕様の読み込みに使用されるメカニズムによっては、追加の依存関係が必要になる場合があります。file リソースロケーターを使用する場合、org.apache.camel.quarkus:camel-quarkus-file 拡張子をプロジェクトの依存関係として追加する必要があります。ref または Bean を使用して仕様をロードする場合、org.apache.camel.quarkus:camel-quarkus-bean 依存関係を追加するだけでなく、Bean 自体に @RegisterForReflection のアノテーションを付ける必要があります。

ネイティブコードで classpath リソースロケーターを使用する場合、OpenAPI 仕様へのパスを application.properties ファイルの quarkus.native.resources.includes プロパティーで指定する必要があります。以下に例を示します。

quarkus.native.resources.includes=openapi.json

platform-http REST トランスポートを使用する場合、一部の文字はパスパラメーター名内で許可されません。これには、- および $ 文字が含まれます。

以下の例の REST /dashed/param ルートを正しく機能させるには、システムプロパティーを io.vertx.web.route.param.extended-pattern=true にする必要があります。

import org.apache.camel.builder.RouteBuilder;

public class CamelRoute extends RouteBuilder {

    @Override
    public void configure() {
        rest("/api")
            // Dash '-' is not allowed by default
            .get("/dashed/param/{my-param}")
            .to("direct:greet")

            // The non-dashed path parameter works by default
            .get("/undashed/param/{myParam}")
            .to("direct:greet");

            from("direct:greet")
                .setBody(constant("Hello World"));
    }
}

Vert.x Web ドキュメント には、これに関するいくつかの背景があります。

netty-http や servlet 等の別の REST トランスポートプロバイダーを使用するには、それぞれのエクステンションを依存関係としてプロジェクトへの追加し、RouteBuilder でプロバイダーを設定する必要があります。たとえば、servlet の場合、org.apache.camel.quarkus:camel-quarkus-servlet 依存関係を追加し、プロバイダーを次のように設定する必要があります。

import org.apache.camel.builder.RouteBuilder;

public class CamelRoute extends RouteBuilder {

    @Override
    public void configure() {
        restConfiguration()
                .component("servlet");
        ...
    }
}

プロジェクトの Salesforce DTO を生成するには、salesforce-maven-plugin を使用します。以下のサンプルコードスニペットは、Account オブジェクトの単一の DTO を作成します。

<plugin>
    <groupId>org.apache.camel.maven</groupId>
    <artifactId>camel-salesforce-maven-plugin</artifactId>
    <version>{camel-version}</version>
    <executions>
        <execution>
            <goals>
                <goal>generate</goal>
            </goals>
            <configuration>
                <clientId>${env.SALESFORCE_CLIENTID}</clientId>
                <clientSecret>${env.SALESFORCE_CLIENTSECRET}</clientSecret>
                <userName>${env.SALESFORCE_USERNAME}</userName>
                <password>${env.SALESFORCE_PASSWORD}</password>
                <loginUrl>https://login.salesforce.com</loginUrl>
                <packageName>org.apache.camel.quarkus.component.salesforce.generated</packageName>
                <outputDirectory>src/main/java</outputDirectory>
                <includes>
                    <include>Account</include>
                </includes>
            </configuration>
        </execution>
    </executions>
</plugin>

SAP コンポーネントはサードパーティーの JCo 3 および IDoc 3 ライブラリーに依存しているため、これらのライブラリーがサポートするプラットフォームにのみインストールできます。

SAP コンポーネントを使用するための前提条件は、SAP Java Connector (SAP JCo) ライブラリーと SAP IDoc ライブラリーが Java ランタイムの lib/ ディレクトリーにインストールされていることです。ターゲットオペレーティングシステムに適した SAP ライブラリーのセットを SAP Service Marketplace からダウンロードしていることを確認する必要があります。

ライブラリーファイルの名前は、次に示すように、対象のオペレーティングシステムによって異なります。

RFC 宛先エンドポイント (sap-srfc-destination、sap-trfc-destination、および sap-qrfc-destination) は、次の URI オプションをサポートしています。

SAP RFC サーバーエンドポイント (sap-srfc-server および sap-trfc-server) は、次の URI オプションをサポートしています。

SAP IDoc List Server エンドポイント (sap-idoclist-server) は、次の URI オプションをサポートしています。

SAP コンポーネントパッケージは、次の RFC および IDoc エンドポイントを提供します。

RFC 宛先エンドポイントは、SAP へのアウトバウンド通信をサポートします。これにより、これらのエンドポイントは、SAP の ABAP 関数モジュールへの RFC 呼び出しを行うことができます。RFC 宛先エンドポイントは、SAP インスタンスへの特定の接続を介して特定の ABAP 関数への RFC 呼び出しを行うように設定されています。RFC 宛先は、アウトバウンド接続の論理的な指定であり、一意の名前を持っています。RFC 宛先は、宛先データ と呼ばれる一連の接続パラメーターによって指定されます。

RFC 宛先エンドポイントは、受信した IN-OUT エクスチェンジの入力メッセージから RFC リクエストを抽出し、そのリクエストを関数呼び出しで SAP にディスパッチします。関数呼び出しからのレスポンスは、エクスチェンジの出力メッセージで返されます。SAP RFC 宛先エンドポイントはアウトバウンド通信のみをサポートするため、RFC 宛先エンドポイントは producer の作成のみをサポートします。

RFC サーバーエンドポイントは、SAP からのインバウンド通信をサポートします。これにより、SAP の ABAP アプリケーションがサーバーエンドポイントに対して RFC 呼び出しを行うことができます。ABAP アプリケーションは、リモート関数モジュールであるかのように RFC サーバーエンドポイントと対話します。RFC サーバーエンドポイントは、SAP インスタンスから特定の接続を介して特定の RFC 関数への RFC 呼び出しを受信するように設定されています。RFC サーバーは、インバウンド接続の論理的な指定であり、一意の名前を持っています。RFC サーバーは、サーバーデータ と呼ばれる一連の接続パラメーターによって指定されます。

RFC サーバーエンドポイントは、入力 RFC リクエストを処理し、それを IN-OUT エクスチェンジの入力メッセージとしてディスパッチします。エクスチェンジの出力メッセージは、RFC 呼び出しのレスポンスとして返されます。SAP RFC サーバーエンドポイントはインバウンド通信のみをサポートするため、RFC サーバーエンドポイントは consumer の作成のみをサポートします。

IDoc 宛先エンドポイントは、SAP へのアウトバウンド通信をサポートします。SAP は、IDoc メッセージに対してさらに処理を実行できます。IDoc ドキュメントはビジネストランザクションを表し、非 SAP システムと簡単にエクスチェンジできます。IDoc 宛先は、宛先データ と呼ばれる一連の接続パラメーターによって指定されます。

IDoc リスト宛先エンドポイントは、処理するメッセージが IDoc ドキュメントの リスト で構成されていることを除けば、IDoc 宛先エンドポイントと似ています。

IDoc リストサーバーエンドポイントは、SAP からのインバウンド通信をサポートし、Camel ルートが SAP システムから IDoc ドキュメントのリストを受信できるようにします。IDoc リストサーバーは、サーバーデータ と呼ばれる一連の接続パラメーターによって指定されます。

メタデータリポジトリーは、次の種類のメタデータを格納するために使用されます。

したがって、SAP 宛先およびサーバーエンドポイントは、RFC 呼び出しを送受信し、IDoc ドキュメントを送受信するために、リポジトリーへのアクセスを必要とします。RFC 呼び出しの場合、エンドポイントによって呼び出されて処理されるすべての機能モジュールのメタデータは、リポジトリー内に存在する必要があります。IDoc エンドポイントの場合、エンドポイントによって処理されるすべての IDoc タイプおよび IDoc タイプ拡張のメタデータは、リポジトリー内に存在する必要があります。宛先およびサーバーエンドポイントによって使用されるリポジトリーの場所は、それぞれの接続の宛先データおよびサーバーデータで指定されます。

SAP 宛先エンドポイントの場合、使用するリポジトリーは通常、SAP システムに存在し、接続先の SAP システムにデフォルト設定されます。このデフォルトでは、宛先データに明示的な設定は必要ありません。さらに、宛先エンドポイントが行うリモート関数呼び出しのメタデータは、それが呼び出す既存の関数モジュールのリポジトリーにすでに存在します。したがって、宛先エンドポイントによって行われる呼び出しのメタデータは、SAP コンポーネントで設定する必要はありません。

一方、サーバーエンドポイントによって処理される関数呼び出しのメタデータは、通常、SAP システムのリポジトリーには存在せず、代わりに SAP コンポーネントに存在するリポジトリーによって提供される必要があります。SAP コンポーネントは、名前付きメタデータリポジトリーのマップを維持します。リポジトリーの名前は、メタデータを提供するサーバーの名前に対応しています。

SAP コンポーネントは、宛先データ、サーバーデータ、およびリポジトリーデータを格納する 3 つのマップを維持します。コンポーネントのプロパティー destinationDataStore は宛先名をキーとする宛先データを格納し、プロパティー serverDataStore はサーバー名をキーとするサーバーデータを格納し、プロパティー repositoryDataStore はリポジトリー名をキーとするリポジトリーデータを格納します。これらの設定は、初期化中にコンポーネントに渡す必要があります。

public class SAPRouteBuilder extends RouteBuilder {
	@BindToRegistry("sap-configuration")
	public SapConnectionConfiguration sapConfiguration() {
		SapConnectionConfiguration configuration = new SapConnectionConfiguration();
		configuration.setDestinationDataStore(destinationData());
		configuration.setServerDataStore(serverData());
		return configuration;
	}

	/**
	 * Configures an Inbound SAP Connection
	 * Please enter the connection property values for your environment
	 */
	private Map<String, ServerData> serverData() {
		ServerData data = new ServerDataImpl();
		data.setGwhost("example.com");
		data.setGwserv("3300");
		data.setProgid("QUICKSTART");
		data.setRepositoryDestination("quickstartDest");
		data.setConnectionCount("2");
		return Map.of("quickstartServer", data);
	}

	/**
	 * Configures an Outbound SAP Connection
	 * Please enter the connection property values for your environment
	 */
	private Map<String, DestinationData> destinationData() {
		DestinationData data = new DestinationDataImpl();
		data.setAshost("example.com");
		data.setSysnr("00");
		data.setClient("000");
		data.setUser("username");
		data.setPasswd("password");
		data.setLang("en");
		return Map.of("quickstartDest", data);
	}

	@Override
	public void configure() throws Exception {
		// Routes definitions
	}
}

宛先の設定は、SAP コンポーネントの destinationDataStore プロパティーで維持されます。このマップの各エントリーは、SAP インスタンスへの個別のアウトバウンド接続を設定します。各エントリーのキーはアウトバウンド接続の名前であり、URI 形式のセクションで説明されているように、宛先エンドポイント URI の destinationName コンポーネントで使用されます。

各エントリーの値は、アウトバウンド SAP 接続の設定を指定する宛先データ設定オブジェクト (org.fusesource.camel.component.sap.model.rfc.impl.DestinationDataImpl) です。

    @BindToRegistry("sap-configuration")
    public SapConnectionConfiguration sapConfiguration() {
        SapConnectionConfiguration configuration = new SapConnectionConfiguration();
        configuration.setDestinationDataStore(destinationData());
        return configuration;
    }

    private Map<String, DestinationData> destinationData() {
        DestinationData data = new DestinationDataImpl();
        data.setAshost("example.com");
        data.setSysnr("00");
        data.setClient("000");
        data.setUser("username");
        data.setPasswd("password");
        data.setLang("en");
        return Map.of("quickstartDest", data);
    }

    @Override
    public void configure() throws Exception {
        ((DefaultCamelContext) getCamelContext()).addInterceptStrategy(new CurrentProcessorDefinitionInterceptStrategy());
        // Routes definitions
    }

上記のように宛先を設定した後、次の URI を使用して、quickstartDest 宛先で BAPI_FLCUST_GETLIST リモート関数呼び出しを呼び出すことができます。

sap-srfc-destination:quickstartDest:BAPI_FLCUST_GETLIST

サーバーの設定は、SAP コンポーネントの serverDataStore プロパティーで維持されます。このマップの各エントリーは、SAP インスタンスからの個別のインバウンド接続を設定します。各エントリーのキーはアウトバウンド接続の名前であり、URI 形式のセクションで説明されているように、サーバーエンドポイント URI の serverName コンポーネントで使用されます。

各エントリーの値は、インバウンド SAP 接続の設定を定義する サーバーデータ設定オブジェクト、org.fusesource.camel.component.sap.model.rfc.impl.ServerDataImpl です。

@BindToRegistry("sap-configuration")
	public SapConnectionConfiguration sapConfiguration() {
		SapConnectionConfiguration configuration = new SapConnectionConfiguration();
		configuration.setDestinationDataStore(destinationData());
		configuration.setServerDataStore(serverData());
		return configuration;
	}

	/**
	 * Configures an Inbound SAP Connection
	 * Please enter the connection property values for your environment
	 */
	private Map<String, ServerData> serverData() {
		ServerData data = new ServerDataImpl();
		data.setGwhost("example.com");
		data.setGwserv("3300");
		data.setProgid("QUICKSTART");
		data.setRepositoryDestination("quickstartDest");
		data.setConnectionCount("2");
		return Map.of("quickstartServer", data);
	}

	/**
	 * Configures an Outbound SAP Connection
	 * Please enter the connection property values for your environment
	 */
	private Map<String, DestinationData> destinationData() {
		DestinationData data = new DestinationDataImpl();
		data.setAshost("example.com");
		data.setSysnr("00");
		data.setClient("000");
		data.setUser("username");
		data.setPasswd("password");
		data.setLang("en");
		return Map.of("quickstartDest", data);
	}

上記のように宛先を設定した後、次の URI を使用して、呼び出し元クライアントからの quickstartDest リモート関数呼び出しで BAPI_FLCUST_GETLIST リモート関数呼び出しを処理できます。

sap-srfc-server:quickstartServer:BAPI_FLCUST_GETLIST

リポジトリーの設定は、SAP コンポーネントの repositoryDataStore プロパティーで維持されます。このマップの各エントリーは、個別のリポジトリーを設定します。各エントリーのキーはリポジトリーの名前であり、このキーはこのリポジトリーが接続されているサーバーの名前にも対応しています。

各エントリーの値は、メタデータリポジトリーのコンテンツを定義するリポジトリーデータ設定オブジェクト org.fusesource.camel.component.sap.model.rfc.impl.RepositoryDataImpl です。リポジトリーデータオブジェクトは、機能テンプレート設定オブジェクト org.fuesource.camel.component.sap.model.rfc.impl.FunctionTemplateImpl のマップです。このマップの各エントリーは汎用モジュールのインタフェースを指定し、各エントリーのキーは指定された汎用モジュールの名前です。

    @BindToRegistry("sap-configuration")
    public SapConnectionConfiguration sapConfiguration() {
        SapConnectionConfiguration configuration = new SapConnectionConfiguration();
        configuration.setRepositoryDataStore(repositoryData());
        return configuration;
    }

    private Map<String, RepositoryData> repositoryData() {
        RepositoryData data = new RepositoryDataImpl();
        FunctionTemplate bookFlightFunctionTemplate = new FunctionTemplateImpl();
        data.setFunctionTemplates(Map.of("BOOK_FLIGHT", bookFlightFunctionTemplate));
        return Map.of("nplServer", data);
    }