Fuse on OpenShift ガイド

Red Hat Fuse 7.6

Red Hat Fuse on OpenShift でのインストールおよび開発

Red Hat Fuse Documentation Team

概要

Fuse on OpenShift の使用ガイド

前書き

Red Hat Fuse on OpenShift は、OpenShift Container Platform での Fuse アプリケーションのデプロイを可能にします。

第1章 作業を始める前に

リリースノート

本リリースに関する重要な情報は、『リリースノート』を参照してください。

バージョンの互換性とサポート

バージョンの互換性とサポートの詳細は、「Red Hat Fuse でサポートされる構成 」を参照してください。

Windows O/S のサポート

Fuse on OpenShift の開発者ツール (oc クライアントおよび Container Development Kit) は、Windows O/S で完全サポートされます。Linux コマンドライン構文で示された例は、Windows コマンドライン構文にしたがって適切に変更すれば、Windows O/S で動作します。

1.1. Fuse スタンドアロンと Fuse on OpenShift の比較

主な機能の違いは次のとおりです。

  • Fuse on OpenShift のアプリケーションデプロイメントは、1 つのアプリケーションと、Docker イメージ内にパッケージ化された必要なすべてのランタイムコンポーネントで構成されます。アプリケーションはランタイム (実行環境) にデプロイされません。アプリケーションイメージ自体が実行可能なランタイム (実行環境) であり、OpenShift によりデプロイおよび管理されます。
  • 各アプリケーションイメージが完全なランタイム環境であるため、OpenShift 環境でのパッチ適用は Fuse スタンドアロンとは異なります。パッチを適用する場合、アプリケーションイメージが再ビルドされ、OpenShift 内に再デプロイされます。主要の OpenShift 管理機能により、ローリングアップグレードやサイドバイサイドデプロイメントを使用して、アップグレード中にアプリケーションの可用性を維持することが可能になります。
  • Fuse の Fabric によって提供されるプロビジョニングおよびクラスタリング機能は、Kubernetes および OpenShift の同等の機能に置き換えられました。OpenShift は、アプリケーションのデプロイメントおよびスケーリングの一環として、自動的に子コンテナーを個別に作成および設定するため、手作業でこの作業を行う必要はありません。
  • Fabric エンドポイントは OpenShift 環境内で使用されません。代わりに、Kubernetes サービスを使用する必要があります。
  • メッセージングサービスは、OpenShift イメージの A-MQ を使用して作成および管理され、Karaf コンテナー内に直接含まれません。Fuse on OpenShift は、camel-amq コンポーネントの強化バージョンを提供し、Kubernetes を介して OpenShift のメッセージングサービスへのシームレスな接続を可能にします。
  • Karaf を使用して稼働中の Karaf インスタンスをライブ更新しないようにしてください。アプリケーションコンテナーを再起動またはスケールアップすると、更新は維持されません。これは、イミュータブルアーキテクチャーの基本原則であり、OpenShift 内でスケーラビリティーと柔軟性を実現するために必要となります。
  • Red Hat Fuse コンポーネントに直接リンクする Maven 依存関係は Red Hat によってサポートされます。ユーザーが導入したサードパーティー Maven 依存関係はサポートされません。
  • SSH エージェントは Apache Karaf マイクロコンテナーに含まれないため、bin/client コンソールクライアントを使用して接続できません。
  • プロトコル互換性と Fuse on OpenShift アプリケーション内の Camel コンポーネント: HTTP ベースでない通信は、TLS および SNI を使用して、OpenShift 外部から Fuse サービス (Camel コンシューマーエンドポイント) にルーティング可能である必要があります。

第2章 管理者向けの基本情報

OpenShift の管理者は、以下を行って Fuse on OpenShift デプロイメントの OpenShift クラスターを準備できます。

  1. Red Hat コンテナーレジストリーへの認証の設定。
  2. Fuse on OpenShift イメージおよびテンプレートのインストール。

2.1. Red Hat コンテナーレジストリーの認証設定

Red Hat Fuse on OpenShift イメージストリームおよびテンプレートをインポートおよび使用する前に、Red Hat コンテナーレジストリーへの認証を設定する必要があります。

手順

  1. 管理者として OpenShift サーバーにログインします。

    oc login -u system:admin
  2. イメージストリームをインストールする OpenShift プロジェクトにログインします。Fuse on OpenShift イメージストリームの openshift プロジェクトを使用することが推奨されます。

    oc project openshift
  3. Red Hat カスタマーポータルアカウントまたは Red Hat Developer Program アカウントのクレデンシャルを使用して、docker-registry シークレットを作成します。<pull_secret_name> は作成するシークレットの名前に置き換えてください。

    oc create secret docker-registry <pull_secret_name> \
      --docker-server=registry.redhat.io \
      --docker-username=CUSTOMER_PORTAL_USERNAME \
      --docker-password=CUSTOMER_PORTAL_PASSWORD \
      --docker-email=EMAIL_ADDRESS
    注記

    イメージストリームがある新しい namespace すべてと、registry.redhat.io を使用する namespace すべてに docker-registry シークレットを作成する必要があります。

  4. Pod のイメージをプルするためにシークレットを使用するには、シークレットをサービスアカウントに追加します。サービスアカウントの名前は、Pod が使用するサービスアカウントの名前と一致する必要があります。以下は、デフォルトのサービスアカウントである default を使用する例になります。

    oc secrets link default <pull_secret_name> --for=pull
  5. ビルドイメージをプッシュまたはプルするためにシークレットを使用するには、シークレットを Pod の内部にマウントできる必要があります。シークレットをマウントするには、以下のコマンドを使用します。

    oc secrets link builder <pull_secret_name>

Red Hat アカウントのユーザー名とパスワードを使用してシークレットを作成したくない場合は、レジストリーサービスアカウント を使用して 認証トークンを作成 してください。

詳細は以下を参照してください。

2.2. OpenShift 4.x サーバーでの Fuse イメージストリームおよびテンプレートのインストール

OpenShift Container Platform 4.1 は、OpenShift namespace で操作する Samples Operator を使用して、Red Hat Enterprise Linux (RHEL) ベースの OpenShift Container Platform イメージストリームおよびテンプレートをインストールおよび更新します。Fuse on OpenShift イメージストリームおよびテンプレートをインストールするには、以下を行います。

  • Samples Operator の再設定
  • Fuse イメージストリームとテンプレートを Skipped Imagestreams and Skipped Templates フィールドに追加します。

    • Skipped Imagestreams (スキップされるイメージストリーム): Samples Operator のインベントリーにあるが、クラスター管理者の希望により Operator が無視または管理しないようにするイメージストリーム。
    • Skipped Templates (スキップされるテンプレート): Samples Operator のインベントリーにあるが、クラスター管理者の希望により Operator が無視または管理しないようにするテンプレート。

前提条件

  • OpenShift サーバーにアクセスできる必要があります。
  • Red Hat コンテナーレジストリーへの認証が設定されている必要があります。
  • オプションで、インストール後に、OpenShift ダッシュボードに Fuse テンプレートを表示させる場合には、OpenShift ドキュメント (https://docs.openshift.com/container-platform/4.1/applications/service_brokers/installing-service-catalog.html) に記載されているように、サービスカタログとテンプレートサービスブローカーを先にインストールする必要があります。

手順

  1. OpenShift 4 サーバーを起動します。
  2. OpenShift サーバーに管理者としてログインします。

    oc login -u system:admin
  3. docker-registry シークレットを作成したプロジェクトを使用していることを確認します。

    oc project openshift
  4. Samples Operator の現在の設定を表示します。

    oc get configs.samples.operator.openshift.io -n openshift-cluster-samples-operator -o yaml
  5. Samples Operator が、追加された Fuse テンプレートおよびイメージストリームを無視するよう設定します。

    oc edit configs.samples.operator.openshift.io -n openshift-cluster-samples-operator
  6. Fuse imagestreams の Skipped Imagestreams セクションを追加し、Fuse および Spring Boot 2 のテンプレートを Skipped Templates セクションに追加します。

    [...]
    spec:
      architectures:
      - x86_64
      managementState: Managed
      skippedImagestreams:
      - fis-java-openshift
      - fis-karaf-openshift
      - fuse7-console
      - fuse7-eap-openshift
      - fuse7-java-openshift
      - fuse7-karaf-openshift
      - jboss-fuse70-console
      - jboss-fuse70-eap-openshift
      - jboss-fuse70-java-openshift
      - jboss-fuse70-karaf-openshift
      - fuse-apicurito-generator
      - apicurito-ui
      skippedTemplates:
      - s2i-fuse76-eap-camel-amq
      - s2i-fuse76-eap-camel-cdi
      - s2i-fuse76-eap-camel-cxf-jaxrs
      - s2i-fuse76-eap-camel-cxf-jaxws
      - s2i-fuse76-eap-camel-jpa
      - s2i-fuse76-karaf-camel-amq
      - s2i-fuse76-karaf-camel-log
      - s2i-fuse76-karaf-camel-rest-sql
      - s2i-fuse76-karaf-cxf-rest
      - s2i-fuse76-spring-boot-camel
      - s2i-fuse76-spring-boot-camel-amq
      - s2i-fuse76-spring-boot-camel-config
      - s2i-fuse76-spring-boot-camel-drools
      - s2i-fuse76-spring-boot-camel-infinispan
      - s2i-fuse76-spring-boot-camel-rest-sql
      - s2i-fuse76-spring-boot-camel-rest-3scale
      - s2i-fuse76-spring-boot-camel-xa
      - s2i-fuse76-spring-boot-camel-xml
      - s2i-fuse76-spring-boot-cxf-jaxrs
      - s2i-fuse76-spring-boot-2-camel-amq
      - s2i-fuse76-spring-boot-2-camel-config
      - s2i-fuse76-spring-boot-2-camel-drools
      - s2i-fuse76-spring-boot-2-camel-infinispan
      - s2i-fuse76-spring-boot-2-camel-rest-3scale
      - s2i-fuse76-spring-boot-2-camel-rest-sql
      - s2i-fuse76-spring-boot-2-camel
      - s2i-fuse76-spring-boot-2-camel-xa
      - s2i-fuse76-spring-boot-2-camel-xml
      - s2i-fuse76-spring-boot-2-cxf-jaxrs
      - s2i-fuse76-spring-boot-2-cxf-jaxws
      - s2i-fuse76-spring-boot-2-cxf-jaxrs-xml
      - s2i-fuse76-spring-boot-2-cxf-jaxws-xml
  7. Fuse on OpenShift イメージストリームをインストールします。

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003
    
    oc create -n openshift -f ${BASEURL}/fis-image-streams.json
    注記

    Error from server (AlreadyExists): imagestreams.image.openshift.io <imagestreamname> already exists というメッセージでエラーが表示された場合、以下のコマンドを使用して、既存のイメージストリームを最新のものに置き換えます。

    oc replace --force -n openshift -f ${BASEURL}/fis-image-streams.json
  8. Fuse on OpenShift のクイックスタートテンプレートをインストールします。

    for template in eap-camel-amq-template.json \
     eap-camel-cdi-template.json \
     eap-camel-cxf-jaxrs-template.json \
     eap-camel-cxf-jaxws-template.json \
     eap-camel-jpa-template.json \
     karaf-camel-amq-template.json \
     karaf-camel-log-template.json \
     karaf-camel-rest-sql-template.json \
     karaf-cxf-rest-template.json \
     spring-boot-camel-amq-template.json \
     spring-boot-camel-config-template.json \
     spring-boot-camel-drools-template.json \
     spring-boot-camel-infinispan-template.json \
     spring-boot-camel-rest-sql-template.json \
     spring-boot-camel-rest-3scale-template.json \
     spring-boot-camel-template.json \
     spring-boot-camel-xa-template.json \
     spring-boot-camel-xml-template.json \
     spring-boot-cxf-jaxrs-template.json \
     spring-boot-cxf-jaxws-template.json ;
     do
     oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/quickstarts/${template}
     done
  9. Spring Boot 2 のクイックスタートテンプレートをインストールします。

    for template in spring-boot-2-camel-amq-template.json \
     spring-boot-2-camel-config-template.json \
     spring-boot-2-camel-drools-template.json \
     spring-boot-2-camel-infinispan-template.json \
     spring-boot-2-camel-rest-3scale-template.json \
     spring-boot-2-camel-rest-sql-template.json \
     spring-boot-2-camel-template.json \
     spring-boot-2-camel-xa-template.json \
     spring-boot-2-camel-xml-template.json \
     spring-boot-2-cxf-jaxrs-template.json \
     spring-boot-2-cxf-jaxws-template.json \
     spring-boot-2-cxf-jaxrs-xml-template.json \
     spring-boot-2-cxf-jaxws-xml-template.json ;
     do oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-760039-redhat-00001/quickstarts/${template}
     done
  10. (任意手順) インストールされた Fuse on OpenShift テンプレートを表示します。

    oc get template -n openshift

2.2.1. OpenShift 4.x での Fuse Console の設定

OpenShift 4.x では、Fuse Console の設定に、セキュリティーのセキュア化、インストール、およびデプロイが必要になります。

最初にクライアント証明書を生成して、「OpenShift 4.x で Fuse Console をセキュア化するための証明書を生成」 の説明どおりに Fuse Console をセキュア化できるようにします。

クライアント証明書を生成した後に Fuse Console をインストールおよびデプロイする方法は複数あります。

注記
  • Fuse Console のユーザー管理は、OpenShift によって処理されます。
  • ロールベースアクセス制御 (デプロイ後に Fuse Console にアクセスするユーザーの場合) は現在 Fuse on OpenShift では使用できません。

2.2.1.1. OpenShift 4.x で Fuse Console をセキュア化するための証明書を生成

OpenShift 4.x で、Fuse Console プロキシーと Jolokia エージェントとの間の接続をセキュアにするには、Fuse Console をデプロイする前にクライアント証明書を生成する必要があります。サービス署名認証局の秘密鍵を使用して、クライアント証明書を署名する必要があります。

重要

各 OpenShift クラスターに別のクライアント証明書を生成し、署名する必要があります。複数のクラスターに同じ証明書を使用しないでください。

前提条件

  • OpenShift クラスターのcluster admin 権限を持っている必要があります。
  • 複数の OpenShift クラスターの証明書を生成し、現在のディレクトリーに別のクラスターの証明書を生成している場合は、以下のいずれかを実行して、現在のクラスターに別の証明書を生成するようにします。

    • 現在のディレクトリーから既存の証明書ファイル (ca.crtca.key、および ca.srl) を削除します。
    • 別の作業ディレクトリーに移動します。たとえば、現在の作業ディレクトリーの名前が cluster1 の場合、新しい cluster2 ディレクトリーを作成し、作業ディレクトリーをそのディレクトリーに変更します。

      mkdir ../cluster2

      cd ../cluster2

手順

  1. cluster admin 権限を持つユーザーとして OpenShift にログインします。

    oc login -u <user_with_cluster_admin_role>
  2. 以下のコマンドを実行して、サービス署名認証局のキーを取得します。

    • 以下を実行して、証明書を取得します。

      oc get secrets/signing-key -n openshift-service-ca -o "jsonpath={.data['tls\.crt']}" | base64 --decode > ca.crt
    • 以下を実行して、秘密鍵を取得します。

      oc get secrets/signing-key -n openshift-service-ca -o "jsonpath={.data['tls\.key']}" | base64 --decode > ca.key
  3. Kubernetes certificates administration」の説明にしたがって、easyrsaopenssl、または cfssl を使用して、クライアント証明書を生成します。

    以下に、openssl を使用したコマンドの例を示します。

    1. 秘密鍵を生成します。

      openssl genrsa -out server.key 2048
    2. CSR 設定ファイルを作成します。

      cat <<EOT >> csr.conf
        [ req ]
        default_bits = 2048
        prompt = no
        default_md = sha256
        distinguished_name = dn
      
        [ dn ]
        CN = fuse-console.fuse.svc
      
        [ v3_ext ]
        authorityKeyIdentifier=keyid,issuer:always
        keyUsage=keyEncipherment,dataEncipherment,digitalSignature
        extendedKeyUsage=serverAuth,clientAuth
      EOT
    3. CSR を生成します。

      openssl req -new -key server.key -out server.csr -config csr.conf
    4. 署名済みの証明書を発行します。

      openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 10000 -extensions v3_ext -extfile csr.conf

次のステップ

Fuse Console のインストール方法に応じて、以下のセクションの説明どおりに Fuse Console のシークレットを作成するには、この証明書が必要です。

2.2.1.2. OperatorHub を使用した OpenShift 4.x での Fuse Console のインストールおよびデプロイ

OpenShift 4.x に Fuse Console をインストールするには、OpenShift OperatorHub で提供される Fuse Console Operator を使用します。Fuse Console をデプロイするには、インストールされた Operator のインスタンスを作成します。

前提条件

手順

Fuse Console をインストールおよびデプロイするには、以下を行います。

  1. Web ブラウザーで、cluster admin 権限を持つユーザーとして OpenShift コンソールにログインします。
  2. Home > Projects と選択し、Fuse Console を追加するプロジェクトを選択します。
  3. Operators をクリックした後、OperatorHub をクリックします。
  4. 検索フィールドウインドウに Fuse Console と入力し、Operator のリストを絞り込みます。
  5. Fuse Console Operator をクリックします。
  6. Fuse Console Operator インストールウィンドウで Install をクリックします。

    Create Operator Subscription フォームが表示されます。

    • Install mode で、Fuse Console Operator を固有の namespace (現在の OpenShift プロジェクト) にインストールします。

      operator のインストール後に、Fuse Console をデプロイして、クラスター上の全 namespace でアプリケーションを監視するか、Fuse Console operator がインストールされた namespace だけでアプリケーションを監視するかを選択できる点に注意してください。

    • Approval Strategy では、Automatic または Manual を選択し、Fuse Console の更新が OpenShift によってどのように対処されるかを設定します。

      • Automatic (自動) 更新を選択した場合、新しいバージョンの Fuse Console Operator が使用できるようになると、人的な介入なしで OpenShfit Operator Lifecycle Manager (OLM) によって、Fuse Console の稼働中のインスタンスが自動的にアップグレードされます。
      • Manual (手動) 更新を選択した場合、Operator の新しいバージョンが使用できるようになると、OLM によって更新リクエストが作成されます。クラスター管理者は、更新リクエストを手動で承認して、Fuse Console Operator を新しいバージョンに更新する必要があります。
  7. Subscribe をクリックします。

    OpenShift によって、Fuse Console Operator が現在の namespace にインストールされます。

  8. インストールを確認するには、Operators をクリックした後、Installed Operators をクリックします。Operator のリストに Fuse Console が表示されます。
  9. ターミナルウインドウで以下のコマンドを使用して、「OpenShift 4.x で Fuse Console をセキュア化するための証明書の生成」で生成した証明書を使用してシークレットを作成し、Fuse Console にマウントします。コマンドの APP_NAME は、Fuse Console Deployment (例: fuse-console) の名前に置き換えます。

    oc create secret tls APP_NAME-tls-proxying --cert server.crt --key server.key

    たとえば、Fuse Console アプリケーションの名前が fuse-console の場合は、以下のコマンドを入力します。

    oc create secret tls fuse-console-tls-proxying --cert server.crt --key server.key

    コマンドの実行に成功すると、シークレットの作成を確認する以下のような応答が返されます。

    secret/fuse-console-operator-tls-proxying created
  10. OpenShift Web コンソールで Fuse Console をデプロイするには、以下を行います。

    1. Installed Operators のリストで、Name 列の Fuse Console をクリックします。
    2. Provided APIsOverview ページで、Create Instance をクリックします。新しいカスタムリソース定義 (CRD) ファイルが表示されます。

      デフォルトでは、Fuse Console は現在の namespace にデプロイされます。

    3. Fuse Console をデプロイして現在の namespace でアプリケーションを検出して管理する場合には、次の手順に進んでください。

      オプションで Fuse Console をデプロイしてクラスター上の (またはユーザー認証が済んでいる) 全 namespace でアプリケーションを検出して管理する場合には、spec.type フィールドの値を namespace から cluster に変更して、CRD ファイルを編集します。

    4. Create をクリックします。

      Fuse Console CRD ページが開き、新しい Fuse Console サービスが表示されます。

  11. Fuse Console を開くには以下を行います。

    1. Fuse Console の URL を取得します。

      • OpenShift Web コンソールから Networking > Routes の順に選択します。
      • コマンドラインで oc get routes コマンドを入力します。
    2. Web ブラウザーで、Fuse Console URL を開き、コンソールにログインします。

      ブラウザーに Authorize Access ページが表示され、必要なパーミッションが表示されます。

    3. Allow selected permissions をクリックします。

      Fuse Console がブラウザーで開き、アクセス権限のある Fuse アプリケーション Pod が表示されます。

  12. 表示するアプリケーションの Connect をクリックします。

    新しいブラウザーウィンドウが開かれ、Fuse Console にアプリケーションが表示されます。

2.2.1.3. コマンドラインを使用した OpenShift 4.x での Fuse Console のインストールおよびデプロイ

OpenShift 4.x では、次のデプロイメントオプションの 1 つを選択して、コマンドラインから Fuse Console をインストールおよびデプロイできます。

  • cluster - Fuse Console は、OpenShift クラスターで複数の namespace (プロジェクト) 全体にデプロイされた Fuse アプリケーションを検索し、接続することができます。このテンプレートをデプロイするには、OpenShift クラスターの管理者ロールが必要です。
  • namespace - Fuse Console は特定の OpenShift プロジェクト (namespace) にアクセスできます。このテンプレートをデプロイするには、OpenShift プロジェクトの管理者ロールが必要です。

Fuse Console テンプレートのパラメーターリストを表示するには、以下の OpenShift コマンドを実行します。

oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fuse-console-namespace-os4.json

前提条件

手順

  1. 以下のコマンドを実行してすべてのテンプレートのリストを取得し、Fuse Console イメージストリームがインストールされていることを確認します。

    oc get template -n openshift
  2. 任意で、すでにインストールされているイメージストリームを新しいリリースタグで更新する場合は、以下のコマンドを使用して openshift namespace に Fuse Console イメージをインポートします。

    oc import-image fuse7/fuse7-console:1.6 --from=registry.redhat.io/fuse7/fuse-console:1.6 --confirm -n openshift
  3. 以下のコマンドを実行して、Fuse Console の APP_NAME の値を取得します。

    • クラスターテンプレートの場合:

      oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fuse-console-cluster-os4.json
    • namespace テンプレートの場合:

      oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fuse-console-namespace-os4.json
  4. 以下のコマンドを使用して、「OpenShift 4.x で Fuse Console をセキュア化するための証明書の生成」で生成した証明書からシークレットを作成し、Fuse Console にマウントします。コマンドの APP_NAME は、Fuse Console アプリケーションの名前に置き換えます。

    oc create secret tls APP_NAME-tls-proxying --cert server.crt --key server.key
  5. 以下のコマンドを実行して、新しいアプリケーションを作成します。ここで、$project は OpenShift プロジェクトの名前、$APP_NAME は上記の手順で取得したアプリケーションの名前、$DOMAIN_NAME は Fuse Console にアクセスするためのホスト名に置き換えます。

    • クラスターテンプレートの場合:

      oc new-app -n $project -f {templates-base-url}/fuse-console-cluster-os4.json -p ROUTE_HOSTNAME=$APP_NAME.$DOMAIN_NAME -p APP_NAME=$APP_NAME
    • namespace テンプレートの場合:

      oc new-app -n myproject -f {templates-base-url}/fuse-console-namespace-os4.json
  6. 以下のコマンドを実行して、Fuse Console デプロイメントの状態と URL を取得します。

    oc status
  7. ブラウザーから Fuse Console にアクセスするには、6. で返される URL (例: https://fuse-console.192.168.64.12.nip.io) を使用します。

2.2.1.4. OpenShift 4.x での Fuse Console のアップグレード

Red Hat OpenShift 4.x では、Red Hat Fuse Operator などの Operator の更新が処理されます。詳細は、OpenShift ドキュメントの『Operator』を参照してください。

その後、アプリケーションの設定方法によっては、Operator の更新でアプリケーションのアップグレードをトリガーできるようになります。

Fuse Console アプリケーションでは、アプリケーションカスタムリソース定義の .spec.version フィールドを編集して、アプリケーションのアップグレードをトリガーすることもできます。

前提条件

  • OpenShift クラスターの管理者権限が必要です。

手順

Fuse Console アプリケーションをアップグレードするには、以下を行います。

  1. ターミナルウィンドウで、以下のコマンドを使用してアプリケーションカスタムリソース定義の .spec.version フィールドを変更します。

    oc patch <project-name> <custom-resource-name> --type='merge' -p '{"spec":{"version":"1.7.1"}}'

    以下に例を示します。

    oc patch myproject example-fuseconsole --type='merge' -p '{"spec":{"version":"1.7.1"}}'
  2. アプリケーションの状態が更新されたことを確認します。

     oc get myproject

    応答には、バージョン番号などのアプリケーションに関する情報が表示されます。

    NAME                  AGE   URL                                        IMAGE
    example-fuseconsole   1m    https://fuseconsole.192.168.64.38.nip.io   docker.io/fuseconsole/online:1.7.1

    .spec.version フィールドの値を変更すると、OpenShift によってアプリケーションが自動的に再デプロイされます。

  3. バージョンの変更によってトリガーされた再デプロイの状態をチェックするには、以下を実行します。

    oc rollout status deployment.v1.apps/example-fuseconsole

    正常にデプロイされた場合は以下の応答が表示されます。

    deployment "example-fuseconsole" successfully rolled out

2.2.2. OpenShift 4.x への API Designer のインストール

Red Hat Fuse on OpenShift では、REST API の設計に使用できる Web ベースの API デザイナーツールである API Designer が提供されます。API Designer Operator を使用すると、OpenShift Container Platform 4.x で API Designer を簡単にインストールおよびアップグレードできます。

OpenShift 管理者として、API Designer Operator を OpenShift プロジェクト (namespace) にインストールします。Operator はインストール後に、選択された namespace で実行されます。しかし、API Designer をサービスとして使用できるようにするには、OpenShift 管理者または開発者が API Designer のインスタンスを作成する必要があります。API Designer サービスによって、API Designer Web コンソールにアクセスするための URL が提供されます。

前提条件

  • OpenShift クラスターの管理者権限を持っている必要があります。
  • Red Hat コンテナーレジストリーへの認証が設定されている必要があります。

手順

  1. OpenShift 4.x サーバーを起動します。
  2. Web ブラウザーで OpenShift コンソールに移動します。ご自分のクレデンシャルでコンソールにログインします。
  3. Catalog をクリックした後、OperatorHub をクリックします。
  4. 検索フィールドに API Designer を入力します。

    右側のパネルに API Designer カードが表示されます。

  5. API Designer をクリックします。API Designer Operator のインストールウインドウが表示されます。
  6. Install をクリックします。Create Operator Subscription フォームが表示されます。

    1. Installation mode では、クラスターの namespace のリストから namespace (プロジェクト) を 1 つ選択します。
    2. Approval Strategy では、Automatic または Manual を選択し、API Designer Operator の更新が OpenShift によってどのように対処されるかを設定します。

      • Automatic (自動) 更新を選択した場合、新しいバージョンの API Designer Operator が使用できるようになると、人的な介入なしで OpenShfit Operator Lifecycle Manager (OLM) によって、API Designer の稼働中のインスタンスが自動的にアップグレードされます。
      • Manual (手動) 更新を選択した場合、Operator の新しいバージョンが使用できるようになると、OLM によって更新リクエストが作成されます。クラスター管理者は、更新リクエストを手動で承認して、API Designer Operator を新しいバージョンに更新する必要があります。
  7. Subscribe をクリックして、指定の namespace (プロジェクト) で API Designer Operator を使用できるようにします。
  8. API Designer がプロジェクトにインストールされていることを確認するには、Operators をクリックした後、Installed Operators をクリックし、リストに API Designer があることを確認します。

次のステップ

API Designer Operator のインストール後、API Designer のインスタンスを作成し、API Designer をサービスとして OpenShift プロジェクトに追加する必要があります。このタスクを実行する方法は 2 つあります。

2.2.2.1. API Designer をサービスとして OpenShift 4.x プロジェクトに追加

API Designer Operator を OpenShift 4.x プロジェクトにインストールした後、OpenShift 開発者はこれをサービスとして OpenShift プロジェクトに追加できます。開発者が API Designer Web コンソールへアクセスするために使用する URL は API Designer サービスによって提供されます。

注記

OpenShift 開発者が API Designer をサービスとして OpenShift 4.x プロジェクトに追加するための手順は、『API の設計』を参照してください。

前提条件

  • OpenShift クラスターの管理者権限を持っている必要があります。
  • API Designer Operator は現在の OpenShift プロジェクトにインストールされます。

手順

  1. OpenShift Web コンソールで、Operators をクリックした後、Installed Operators をクリックします。
  2. Name 列で、API Designer をクリックします。
  3. Provided APIsCreate Instance をクリックします。

    API Designer インスタンスの最小限の開始テンプレートがあるデフォルトのフォームが開かれます。

  4. デフォルト値を使用するか、任意で以下の値を編集します。

    • size: API Designer インスタンスの Pod の数。

      デフォルトは、API Designer の管理に特化したロジックが含まれる 3 つの新規リソースタイプの 3 つの Pod になります。

    • image: API Designer イメージ。このイメージを変更すると、API Designer Operator はクラスターで自動的にアップグレードされます。
  5. Create をクリックし、新しい apicurito-service を作成します。OpenShift は、新しい API Designer サービスの Pod、サービス、およびその他のコンポーネントを起動します。
  6. API Designer サービスが使用できることを確認するには、以下を実行します。

    1. Operators をクリックした後、Installed Operators をクリックします。
    2. Provided APIs 列で Apicurito CRD をクリックします。

      Operator Details ページに、apicurito-service のリストが表示されます。

  7. API Designer の URL を取得するには、以下を行います。

    1. Networking > Routes をクリックします。
    2. 正しいプロジェクトが選択されていることを確認してください。
    3. apicurito-service 行で、Location 列にある API Designer Web コンソールの URL を見つけます。

2.2.2.2. OpenShift 4.x での API Designer のアップグレード

Red Hat OpenShift 4.x では、Red Hat Fuse Operator などの Operator の更新が処理されます。詳細は OpenShift の『Operator』 を参照してください。

また、Operator の更新によってアプリケーションのアップグレードがトリガーされる可能性があります。アプリケーションのアップグレードの実行方法は、アプリケーションの設定によって異なります。

API Designer アプリケーションでは、API Designer Operator をアップグレードすると、OpenShift によってクラスターの API Designer アプリケーションもアップグレードされます。

2.3. OpenShift 3.x サーバーでの Fuse イメージストリームおよびテンプレートのインストール

Red Hat コンテナーレジストリーへの認証を設定した後、Red Hat Fuse on OpenShift イメージストリームおよびテンプレートをインポートおよび使用します。

手順

  1. OpenShift サーバーを起動します。
  2. OpenShift サーバーに管理者としてログインします。

    oc login -u system:admin
  3. docker-registry シークレットを作成したプロジェクトを使用していることを確認します。

    oc project openshift
  4. Fuse on OpenShift イメージストリームをインストールします。

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003
    
    oc create -n openshift -f ${BASEURL}/fis-image-streams.json
  5. クイックスタートテンプレートをインストールします。

    for template in eap-camel-amq-template.json \
     eap-camel-cdi-template.json \
     eap-camel-cxf-jaxrs-template.json \
     eap-camel-cxf-jaxws-template.json \
     eap-camel-jpa-template.json \
     karaf-camel-amq-template.json \
     karaf-camel-log-template.json \
     karaf-camel-rest-sql-template.json \
     karaf-cxf-rest-template.json \
     spring-boot-camel-amq-template.json \
     spring-boot-camel-config-template.json \
     spring-boot-camel-drools-template.json \
     spring-boot-camel-infinispan-template.json \
     spring-boot-camel-rest-sql-template.json \
     spring-boot-camel-rest-3scale-template.json \
     spring-boot-camel-template.json \
     spring-boot-camel-xa-template.json \
     spring-boot-camel-xml-template.json \
     spring-boot-cxf-jaxrs-template.json \
     spring-boot-cxf-jaxws-template.json ;
     do
     oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/quickstarts/${template}
     done
  6. Spring Boot 2 のクイックスタートテンプレートをインストールします。

    for template in spring-boot-2-camel-amq-template.json \
     spring-boot-2-camel-config-template.json \
     spring-boot-2-camel-drools-template.json \
     spring-boot-2-camel-infinispan-template.json \
     spring-boot-2-camel-rest-3scale-template.json \
     spring-boot-2-camel-rest-sql-template.json \
     spring-boot-2-camel-template.json \
     spring-boot-2-camel-xa-template.json \
     spring-boot-2-camel-xml-template.json \
     spring-boot-2-cxf-jaxrs-template.json \
     spring-boot-2-cxf-jaxws-template.json \
     spring-boot-2-cxf-jaxrs-xml-template.json \
     spring-boot-2-cxf-jaxws-xml-template.json ;
     do oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-760039-redhat-00001/quickstarts/${template}
     done
  7. Fuse Console のテンプレートをインストールします。

    oc create -n openshift -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-cluster-template.json
    oc create -n openshift -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-namespace-template.json
    注記

    Fuse Console のデプロイに関する詳細は、「OpenShift 4.x での Fuse Console の設定」を参照してください。

  8. Apicurito テンプレートをインストールします。

    oc create -n openshift -f ${BASEURL}/fuse-apicurito.yml
  9. (任意手順): インストールされた Fuse on OpenShift イメージおよびテンプレートを表示します。

    oc get template -n openshift

2.3.1. OpenShift 3.11 での Fuse Console の設定

OpenShift 3.11 では、Fuse Console の設定方法は 2 つあります。

  • プロジェクトで実行しているすべての Fuse コンテナーを監視できるように 集約型 の Fuse Console カタログアイテムをプロジェクトに追加して設定します。
  • 実行している 1 つの Fuse コンテナーを監視できるように特定の Pod から設定します。

OpenShift Console またはコマンドラインから Fuse Console をデプロイできます。

注記

Minishift または CDK ベースの環境変数に Fuse Console をインストールするには、以下の KCS の記事で説明されている手順に従います。

  • Minishift または CDK ベースの環境に Fuse Console をインストールするには、「KCS 4998441」を参照してください。
  • Jolokia 認証を無効にする必要がある場合は、「KCS 3988671」で説明されている回避策を参照してください。

前提条件

  • Fuse on OpenShift ガイド』の説明にしたがって、Fuse Console の Fuse on OpenShift イメージストリームおよびテンプレートをインストールする必要があります。
  • OpenShift 3.11 のクラスターモードでは、cluster admin ロールとクラスターモードテンプレートが必要です。以下のコマンドを実行します。

    oc adm policy add-cluster-role-to-user cluster-admin system:serviceaccount:openshift-infra:template-instance-controller
注記
  • クラスターモードテンプレートは、デフォルトでは OpenShift Container Platform の最新バージョンでのみ利用できます。OpenShift Online のデフォルトカタログでは提供されません。
  • Fuse Console のテンプレートは、デフォルトでエンドツーエンド暗号化を設定するため、Fuse Console のリクエストはブラウザーからクラスター内のサービスまでエンドツーエンドでセキュア化されます。
  • Fuse Console のユーザー管理は、OpenShift によって処理されます。
  • ロールベースアクセス制御 (デプロイ後に Fuse Console にアクセスするユーザーの場合) は現在 Fuse on OpenShift では使用できません。

「OpenShift 3.11 Console からの Fuse Console のデプロイ」

「OpenShift 3.11 の Fuse Console から単一の Fuse Pod を監視」

「コマンドラインからの Fuse Console のデプロイ」

2.3.1.1. OpenShift 3.11 Console からの Fuse Console のデプロイ

OpenShift 3.11 Console から OpenShift クラスターで Fuse Console をデプロイするには、以下の手順にしたがいます。

手順

  1. OpenShift コンソールで既存のプロジェクトを開くか、新しいプロジェクトを作成します。
  2. Fuse Console を OpenShift プロジェクトに追加します。

    1. Add to ProjectBrowse Catalog と選択します。

      Select an item to add to the current project ページが開きます。

    2. Search フィールドで Fuse Console を入力します。

      Red Hat Fuse 7.x Console および Red Hat Fuse 7.x Console (cluster) アイテムが検索結果として表示されるはずです。

注記

Red Hat Fuse Console アイテムが検索結果として表示されない場合や、表示されるアイテムが最新バージョンでない場合は、『Fuse on OpenShift ガイド』の「OpenShift サーバーの準備」にある説明にしたがって、Fuse Console テンプレートを手作業でインストールします。

  1. Red Hat Fuse Console アイテムの 1 つをクリックします。

    • Red Hat Fuse 7.x Console - このバージョンの Fuse Console は、現在の OpenShift プロジェクトにデプロイされた Fuse アプリケーションを検出し、接続します。
    • Red Hat Fuse 7.x Console (cluster) - このバージョンの Fuse Console は、OpenShift クラスターの複数のプロジェクトにデプロイされた Fuse アプリケーションを検出し、接続します。
  2. Red Hat Fuse Console ウィザードで Next をクリックします。ウィザードの Configuration ページが開きます。

    任意で、設定パラメーターのデフォルト値を変更できます。

    1. Create をクリックします。

      ウィザードの Results ページに Red Hat Fuse Console が作成されたことが表示されます。

    2. Continue to the project overview をクリックし、Fuse Console アプリケーションがプロジェクトに追加されたことを確認します。
    3. Fuse Console を開き、提供された URL をクリックした後にログインします。

      ブラウザーに Authorize Access ページが表示され、必要なパーミッションが表示されます。

    4. Allow selected permissions をクリックします。

      ブラウザーで Fuse Console が開かれ、プロジェクトで実行されている Fuse の Pod が表示されます。

    5. 表示するアプリケーションの Connect をクリックします。

      新しいブラウザーウィンドウが開かれ、Fuse Console にアプリケーションが表示されます。

2.3.1.2. OpenShift 3.11 の Fuse Console から単一の Fuse Pod を監視

OpenShift 3.11 で実行している Fuse Pod の Fuse Console を開きます。

  1. OpenShift プロジェクトの Applications → Pods ビューで、Pod 名をクリックし、実行している Fuse Pod の詳細を表示します。このページの右側に、コンテナーテンプレートの概要が表示されます。

    Container Template View

  2. このビューの Open Java Console リンクをクリックし、Fuse Console を開きます。

    Fuse Console view

    注記

    Pod ビューで Fuse Console へのリンクを表示するよう OpenShift を設定するには、Fuse on OpenShift イメージを実行している Pod が jolokia に設定された name 属性内で TCP ポートを宣言する必要があります。

    {
      "kind": "Pod",
      [...]
      "spec": {
        "containers": [
          {
            [...]
            "ports": [
              {
                "name": "jolokia",
                "containerPort": 8778,
                "protocol": "TCP"
              }

2.3.1.3. コマンドラインからの Fuse Console のデプロイ

表2.1「Fuse Console テンプレート」 は、Fuse アプリケーションのデプロイメントのタイプに応じて、コマンドラインから Fuse Console をデプロイするために使用する OpenShift 3.1 テンプレートについて説明しています。

表2.1 Fuse Console テンプレート

タイプ説明

fis-console-cluster-template.json

Fuse Console は、複数の namespace またはプロジェクトにまたがってデプロイされた Fuse アプリケーションを検出し、接続することができます。このテンプレートをデプロイするには、OpenShift の cluster-admin ロールが必要です。

fis-console-namespace-template.json

このテンプレートは、Fuse Console の現在の OpenShift プロジェクト (namespace) へのアクセスを制限するため、単一のテナントデプロイメントとして動作します。このテンプレートをデプロイするには、現在の OpenShift プロジェクトの admin ロールが必要です。

任意で以下のコマンドを実行すると、すべてのテンプレートのパラメーターの一覧を表示できます。

oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-namespace-template.json

手順

コマンドラインから Fuse Console をデプロイするには、以下を行います。

  1. 以下のコマンドの 1 つを実行して、Fuse Console テンプレートをベースとした新しいアプリケーションを作成します。コマンドの myproject はプロジェクトの名前に置き換えます。

    • Fuse Console の cluster テンプレートの場合は、以下のようになります。myhost は Fuse Console にアクセスするホストの名前になります。

      oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-cluster-template.json -p ROUTE_HOSTNAME=myhost
    • Fuse Console の namespace テンプレートの場合は以下のようになります。

      oc new-app -n myproject -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003/fis-console-namespace-template.json
      注記

      namespace テンプレートの route_hostname パラメーターは OpenShift によって自動的に生成されるため、省略することが可能です。

  2. 以下のコマンドを実行して、Fuse Console デプロイメントの状態と URL を取得します。

    oc status
  3. ブラウザーから Fuse Console にアクセスするには、提供される URL (例: https://fuse-console.192.168.64.12.nip.io) を使用します。

第3章 管理者でないユーザーで Fuse on OpenShift をインストール

アプリケーションを作成し、OpenShift にデプロイして Fuse on OpenShift の使用を開始することができます。最初に、Fuse on OpenShift イメージおよびテンプレートをインストールする必要があります。

3.1. 管理者でないユーザーでの Fuse on OpenShift イメージおよびテンプレートのインストール

前提条件

  • OpenShift サーバーへアクセスできる必要があります。CDK による仮想 OpenShift サーバーまたはリモート OpenShift サーバーのいずれかにアクセスできる必要があります。
  • Red Hat コンテナーレジストリーへの認証が設定されている必要があります。

詳細は以下を参照してください。

手順

  1. Fuse on OpenShift プロジェクトのビルドおよびデプロイを準備するため、以下のように OpenShift サーバーにログインします。

    oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443

    IP アドレスは常に同じではないため、OPENSHIFT_IP_ADDR は OpenShift サーバーの IP アドレスのプレースホルダーになります。この値を実際の IP アドレスに置き換えます。

    注記

    開発者パスワードを持つ開発者ユーザーは、CDK による仮想 OpenShift サーバーで自動作成される標準のアカウントです。リモートサーバーにアクセスする場合は、OpenShift 管理者が提供する URL とクレデンシャルを使用します。

  2. test という名前のプロジェクト namespace を新規作成します。

    oc new-project test

    test プロジェクト namespace がすでに存在する場合は、以下のコマンドを使用して切り替えます。

    oc project test
  3. Fuse on OpenShift イメージストリームをインストールします。

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003
    
    oc create -n test -f ${BASEURL}/fis-image-streams.json

    コマンド出力に、Fuse on OpenShift プロジェクトで使用できるようになった Fuse イメージストリームが表示されます。

  4. クイックスタートテンプレートをインストールします。

    for template in eap-camel-amq-template.json \
     eap-camel-cdi-template.json \
     eap-camel-cxf-jaxrs-template.json \
     eap-camel-cxf-jaxws-template.json \
     eap-camel-jpa-template.json \
     karaf-camel-amq-template.json \
     karaf-camel-log-template.json \
     karaf-camel-rest-sql-template.json \
     karaf-cxf-rest-template.json \
     spring-boot-camel-amq-template.json \
     spring-boot-camel-config-template.json \
     spring-boot-camel-drools-template.json \
     spring-boot-camel-infinispan-template.json \
     spring-boot-camel-rest-sql-template.json \
     spring-boot-camel-rest-3scale-template.json \
     spring-boot-camel-template.json \
     spring-boot-camel-xa-template.json \
     spring-boot-camel-xml-template.json \
     spring-boot-cxf-jaxrs-template.json \
     spring-boot-cxf-jaxws-template.json ;
     do
     oc create -n test -f \
     ${BASEURL}/quickstarts/${template}
     done
  5. Spring Boot 2 のクイックスタートテンプレートをインストールします。

    for template in spring-boot-2-camel-amq-template.json \
     spring-boot-2-camel-config-template.json \
     spring-boot-2-camel-drools-template.json \
     spring-boot-2-camel-infinispan-template.json \
     spring-boot-2-camel-rest-3scale-template.json \
     spring-boot-2-camel-template.json \
     spring-boot-2-camel-xa-template.json \
     spring-boot-2-camel-xml-template.json \
     spring-boot-2-cxf-jaxrs-template.json \
     spring-boot-2-cxf-jaxws-template.json \
     spring-boot-2-cxf-jaxrs-xml-template.json \
     spring-boot-2-cxf-jaxws-xml-template.json ;
     do oc create -n openshift -f \
     https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-sb2-760039-redhat-00001/quickstarts/${template}
     done
  6. Fuse Console のテンプレートをインストールします。

    oc create -n test -f ${BASEURL}/fis-console-cluster-template.json
    oc create -n test -f ${BASEURL}/fis-console-namespace-template.json
    注記

    Fuse Console のデプロイに関する詳細は、「OpenShift 4.x での Fuse Console の設定」を参照してください。

  7. (任意手順): インストールされた Fuse on OpenShift イメージおよびテンプレートを表示します。

    oc get template -n test
  8. ブラウザーで OpenShift コンソールに移動します。

    1. https://OPENSHIFT_IP_ADDR:8443 を使用します。OPENSHIFT_IP_ADDR は OpenShift サーバーの実際の IP アドレスに置き換えます。
    2. クレデンシャル (例: ユーザー名 developer とパスワード developer) を使用して OpenShift コンソールにログインします。

第4章 開発者向けの基本情報

4.1. 開発環境の準備

OpenShift サーバーにアクセスできることが、Fuse on OpenShift プロジェクトを開発およびテストするための基本要件になります。基本的な方法は次のとおりです。

4.1.1. ローカルマシンでの CDK (Container Development Kit) のインストール

開発者としてすぐ使用したい場合は、Red Hat CDK をローカルマシンにインストールすることが最も実用的な方法です。CDK を使用すると、Red Hat Enterprise Linux (RHEL) 7 上の OpenShift のイメージを実行する仮想マシン (VM) インスタンスを起動できます。CDK のインストールは、次の主なコンポーネントで構成されます。

  • 仮想マシン (libvirt、VirtualBox、または Hyper-V)
  • コンテナー開発環境を開始および管理する minishift
重要

Red Hat CDK は 開発での使用のみ を目的としています。本番環境などの他の環境での使用を目的としておらず、既知のセキュリティー脆弱性に対応しない場合があります。Docker 形式コンテナー内部でミッションクリティカルなアプリケーションを実行するためのフルサポートを受けるには、アクティブな RHEL 7 または RHEL Atomic サブスクリプションが必要です。詳細は、「Red Hat Container Development Kit (CDK) のサポート」を参照してください。

前提条件

  • Java バージョン

    開発者のマシンに、Fuse 7.6 がサポートするバージョンの Java がインストールされているようにしてください。サポートされる Java バージョンの詳細は「Red Hat Fuse でサポートされる構成 」を参照してください。

手順

ローカルマシンに CDK をインストールするには、以下を行います。

  1. Fuse on OpenShift では、バージョン 3.11 の CDK をインストールすることが推奨されます。CDK 3.11 をインストールおよび使用するための詳細手順は『Red Hat CDK 3.11 Getting Started Guide』を参照してください。
  2. Red Hat コンテナーレジストリーの認証設定」の手順にしたがって、OpenShift クレデンシャルを設定し、Red Hat コンテナーレジストリーにアクセスできるようにします。
  3. 2章管理者向けの基本情報 の説明にしたがって、Fuse on OpenShift イメージおよびテンプレートを手作業でインストールします。

    注記

    CDK のバージョンには Fuse on OpenShift イメージおよびテンプレートが事前にインストールされている可能性があります。ただし、OpenShift クレデンシャルの設定後に、Fuse on OpenShift イメージおよびテンプレートをインストール (または更新) する必要があります。

  4. 本章の例を参照する前に、『Red Hat CDK 3.11 Getting Started Guide』の内容を読み、理解するようにしてください。

4.1.2. 既存の OpenShift サーバーへのリモートアクセスを取得

IT 部門によってサーバーマシン上に OpenShift クラスターがすでに設定されている可能性があります。この場合、Fuse on OpenShift を使用するには以下の要件を満たしている必要があります。

  • サーバーマシンがサポートされるバージョンの OpenShift Container Platform を実行している必要があります (「Red Hat Fuse でサポートされる構成」を参照)。本ガイドの例は、バージョン 3.11 に対してテストされています。
  • OpenShift 管理者に、最新の Fuse on OpenShift コンテナーベースイメージと Fuse on OpenShift テンプレートを OpenShift サーバーにインストールするよう依頼します。
  • OpenShift 管理者に、通常の開発者権限 (OpenShift プロジェクトを作成、デプロイ、および実行できる権限) を持つユーザーアカウントを作成してもらいます。
  • 管理者に、OpenShift サーバーの URL (OpenShift コンソールの閲覧または oc コマンドラインクライアントを使用した OpenShfit への接続に使用) と、アカウントのログインクレデンシャルを提供するよう依頼します。

4.1.3. クライアント側ツールのインストール

開発者のマシンに以下のツールをインストールすることが推奨されます。

  • Apache Maven 3.6.x: OpenShift プロジェクトのローカルビルドに必要です。Apache Maven download ページから適切なパッケージをダウンロードします。バージョン 3.6.x 以上がインストールされているようにしてください。3.6.x 未満のバージョンを使用すると、プロジェクトのビルド時に依存関係の解決に関する問題が発生する可能性があります。
  • Git: OpenShift S2I ソースワークフローに必要で、通常 Fuse on OpenShift プロジェクトのソース制御用に推奨されます。Git Downloads ページから適切なパッケージをダウンロードします。
  • OpenShift client: CDK を使用している場合、シェルに入力する必要があるコマンドを表示する minishift oc-env を使用して、oc バイナリーを PATH に追加します。oc-env の出力は、OS とシェルのタイプによって異なります。

    $ minishift oc-env
    export PATH="/Users/john/.minishift/cache/oc/v1.5.0:$PATH"
    # Run this command to configure your shell:
    # eval $(minishift oc-env)

    詳細は、CDK 3.11『Getting Started Guide』の「Using the OpenShift Client Binary」を参照してください。

    CDK を使用しない場合は、『CLI Reference』の手順にしたがって、oc クライアントツールをインストールします。

  • (任意) Docker client: 上級ユーザーは Docker クライアントツールがインストールされていると便利である可能性があります (OpenShift サーバー上で実行されている docker デーモンとの通信に使用)。オペレーティングシステムに固有のバイナリーインストールに関する詳細は「Docker installation」サイトを参照してください。

    詳細は、CDK 3.11 『Getting Started Guide』の「Reusing the docker Daemon」を参照してください。

    重要

    OpenShift サーバーで稼働しているバージョンの OpenShift と互換性のあるバージョンの oc および docker ツールをインストールするようにしてください。

その他のリソース

(任意) Red Hat JBoss CodeReady Studio: Red Hat JBoss CodeReady Studio は、Fuse on OpenShift アプリケーションの開発サポートが含まれる Eclipse ベースの開発環境です。この開発環境のインストール方法に関する詳細は、Red Hat JBoss CodeReady Studio の『インストールガイド』を参照してください。

4.1.4. Maven リポジトリーの設定

ローカルマシンで Fuse on OpenShift プロジェクトをビルドするのに必要な archetype とアーティファクトを保持する Maven リポジトリーを設定します。

手順

  1. Maven settings.xml ファイルを開きます。通常、このファイルは Linux または macOS の場合は ~/.m2/settings.xml、Windows の場合は Documents and Settings\<USER_NAME>\.m2\settings.xml に配置されます。
  2. 以下の Maven リポジトリーを追加します。

4.2. Fuse on OpenShift でのアプリケーションの作成およびデプロイ

以下の OpenShift Source-to-Image (S2I) アプリケーション開発ワークフローの 1 つを使用してアプリケーションを作成し、OpenShift にデプロイして、Fuse on OpenShift の使用を開始することができます。

S2I バイナリーワークフロー
ビルド入力が バイナリーソース からの S2I です。このワークフローの特徴は、ビルドの一部が開発者自身のマシンで実行されることです。このワークフローはバイナリーパッケージをローカルでビルドした後、バイナリーパッケージを OpenShift に渡します。詳細は OpenShift 4.1『ビルド』の「バイナリー (ローカル) ソース」を参照してください。
S2I ソースワークフロー
ビルド入力が Git ソース からの S2I です。このワークフローの特徴は、ビルドがすべて OpenShift サーバー上でビルドされることです。詳細は OpenShift 4.1『ビルド』の「Git ソース」を参照してください。

4.2.1. S2I バイナリーを使用したアプリケーションの作成およびデプロイ

ここでは、OpenShift S2I バイナリーワークフローを使用して、Fuse on OpenShift プロジェクトを作成、ビルド、およびデプロイします。

手順

  1. Maven の archetype を使用して、新しい Fuse on OpenShift プロジェクトを作成します。この例では、サンプル Spring Boot Camel プロジェクトを作成する archetype を使用します。新しいシェルプロンプトを開き、以下の Maven コマンドを入力します。

    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
      -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001

    archetype プラグインが対話モードに切り替わり、残りのフィールドの入力を要求されます。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse76-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse76-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
     Y: : Y

    プロンプトが表示されたら、groupId の値には org.example.fisartifactId の値には fuse76-spring-boot を入力します。残りのフィールドではデフォルト値を使用します。

  2. 前のコマンドが BUILD SUCCESS 状態で終了した場合、fuse76-spring-boot サブディレクトリー内に新しい Fuse on OpenShift プロジェクトが作成されているはずです。XML DSL コードは fuse76-spring-boot/src/main/resources/spring/camel-context.xml ファイルで確認できます。デモンストレーションコードは、乱数が含まれるメッセージを継続的にログに送信する、シンプルな Camel ルートを定義します。
  3. Fuse on OpenShift プロジェクトのビルドおよびデプロイを準備するため、以下のように OpenShift サーバーにログインします。

    oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443

    IP アドレスは常に同じではないため、OPENSHIFT_IP_ADDR は OpenShift サーバーの IP アドレスのプレースホルダーになります。この値を実際の IP アドレスに置き換えます。

    注記

    developer パスワードを持つ developer ユーザーは、CDK による仮想 OpenShift サーバーで自動作成される標準のアカウントです。リモートサーバーにアクセスする場合は、OpenShift 管理者が提供する URL とクレデンシャルを使用します。

  4. openshift プロジェクトに切り替えていない場合は以下のように切り替えます。

    oc project openshift
  5. 以下のコマンドを実行し、Fuse on OpenShift イメージおよびテンプレートがすでにインストールされ、アクセス可能であることを確認します。

    oc get template -n openshift

    イメージおよびテンプレートが事前にインストールされていない場合や、提供されたバージョンが古い場合は、Fuse on OpenShift イメージおよびテンプレートを手作業でインストール (または更新) します。Fuse on OpenShift イメージのインストール方法に関する詳細は、2章管理者向けの基本情報 を参照してください。

  6. これで、fuse76-spring-boot プロジェクトをビルドおよびデプロイできるようになりました。OpenShift にログインしている状態で、fuse76-spring-boot プロジェクトのディレクトリーに移動し、以下のようにプロジェクトをビルドおよびデプロイします。

    cd fuse76-spring-boot
    mvn fabric8:deploy -Popenshift

    ビルドに成功すると、以下のような出力が表示されます。

    ...
    [INFO] OpenShift platform detected
    [INFO] Using project: openshift
    [INFO] Creating a Service from openshift.yml namespace openshift name fuse76-spring-boot
    [INFO] Created Service: target/fabric8/applyJson/openshift/service-fuse76-spring-boot.json
    [INFO] Using project: openshift
    [INFO] Creating a DeploymentConfig from openshift.yml namespace openshift name fuse76-spring-boot
    [INFO] Created DeploymentConfig: target/fabric8/applyJson/openshift/deploymentconfig-fuse76-spring-boot.json
    [INFO] Creating Route openshift:fuse76-spring-boot host: null
    [INFO] F8: HINT: Use the command `oc get pods -w` to watch your pods start up
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 05:38 min
    [INFO] Finished at: 2019-10-24T12:15:06+05:30
    [INFO] Final Memory: 63M/688M
    [INFO] ------------------------------------------------------------------------
    注記

    このコマンドを初めて実行する場合、Maven は多くの依存関係をダウンロードする必要があるため、数分かかることがあります。2 回目からはビルドが速くなります。

  7. ブラウザーで OpenShift コンソールに移動し、クレデンシャル (例: ユーザー名 developer およびパスワード developer) を使用してコンソールにログインします。
  8. 左側のパネルで Home を展開します。Projects をクリックしてから、プロジェクトダッシュボードに表示する openshift プロジェクトを選択します。
  9. fuse76-spring-boot をクリックし、クイックスタートの fuse76-spring-boot 情報ページを表示します。

    Overview

  10. 左側のパネルで Workloads を展開します。
  11. Pods をクリックします。openshift プロジェクトで稼働している Pod すべてが表示されます。
  12. Pod の Name (この例では fuse76-spring-boot-xxxxx) をクリックし、稼働中の Pod の詳細を表示します。

    Pod Details

  13. Logs タブをクリックしてアプリケーションログを表示し、ログを下方向にスクロールして、Camel アプリケーションによって生成された乱数のログメッセージを見つけます。

    ...
    06:45:54.311 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 130
    06:45:56.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 898
    06:45:58.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 414
    06:46:00.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 486
    06:46:02.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 093
    06:46:04.265 [Camel (MyCamel) thread #1 - timer://foo] INFO simple-route - >>> 080
  14. 稼働中の Pod を終了するには以下を行います。

    1. openshift プロジェクトの Project Status ページで、Workloads タブをクリックしてから、fuse76-spring-boot アプリケーションをクリックします。
    2. Overview タブをクリックし、アプリケーションの概要情報ページを表示します。
    3. Pod アイコンの隣りにある 下矢印 get started s2i binary 05 をクリックして、値をゼロにして Pod を停止します。

4.2.2. プロジェクトのアンデプロイおよび再デプロイ

以下のようにプロジェクトをアンデプロイまたは再デプロイできます。

手順

  • プロジェクトをアンデプロイするには、以下のコマンドを入力します。

    mvn fabric8:undeploy
  • プロジェクトを再デプロイするには、以下のコマンドを入力します。

    mvn fabric8:undeploy
    mvn fabric8:deploy -Popenshift

4.2.3. S2I ソースワークフローを使用したアプリケーションの作成およびデプロイ

ここでは、OpenShift S2I ソースワークフローを使用して、テンプレートをベースとした Fuse on OpenShift アプリケーションをビルドおよびデプロイします。最初に、リモート Git リポジトリーに保存されたクイックスタートプロジェクトを使用します。OpenShift コンソールを使用すると、このクイックスタートプロジェクトを OpenShift サーバーでダウンロード、ビルド、およびデプロイできます。

手順

  1. 次のように、OpenShift サーバーにログインします。

    oc login -u developer -p developer https://OPENSHIFT_IP_ADDR:8443

    IP アドレスは常に同じではないため、OPENSHIFT_IP_ADDR は OpenShift サーバーの IP アドレスのプレースホルダーになります。この値を実際の IP アドレスに置き換えます。

    注記

    developer パスワードを持つ developer ユーザーは、CDK による仮想 OpenShift サーバーで自動作成される標準のアカウントです。リモートサーバーにアクセスする場合は、OpenShift 管理者が提供する URL とクレデンシャルを使用します。

  2. openshift プロジェクトに切り替えていない場合は以下のように切り替えます。

    oc project openshift
  3. 以下のコマンドを実行し、Fuse on OpenShift テンプレートがすでにインストールされ、アクセス可能であることを確認します。

    oc get template -n openshift

    イメージおよびテンプレートが事前にインストールされていない場合や、提供されたバージョンが古い場合は、Fuse on OpenShift イメージおよびテンプレートを手作業でインストール (または更新) します。Fuse on OpenShift イメージのインストール方法に関する詳細は、2章管理者向けの基本情報 を参照してください。

  4. 以下のコマンドを入力し、Red Hat Fuse 7.6 Camel XML DSL with Spring Boot クイックスタートテンプレートの実行に必要なリソースを作成します。これにより、クイックスタートのデプロイメント設定およびビルド設定が作成されます。クイックスタートのデフォルトパラメーターや作成されたリソースの情報はターミナルに表示されます。

    oc new-app s2i-fuse76-spring-boot-camel-xml
    
    --> Deploying template "openshift/s2i-fuse76-spring-boot-camel-xml" to project openshift
    ...
    --> Creating resources ...
        imagestream.image.openshift.io "s2i-fuse76-spring-boot-camel-xml" created
        buildconfig.build.openshift.io "s2i-fuse76-spring-boot-camel-xml" created
        deploymentconfig.apps.openshift.io "s2i-fuse76-spring-boot-camel-xml" created
    --> Success
        Build scheduled, use 'oc logs -f bc/s2i-fuse76-spring-boot-camel-xml' to track its progress.
        Run 'oc status' to view your app.
  5. ブラウザーで https://OPENSHIFT_IP_ADDR の OpenShift Web コンソールに移動します (OPENSHIFT_IP_ADDR はクラスターの IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名 developer、パスワード developer) を使用して、コンソールにログインします。
  6. 左側のパネルで Home を展開します。Projects をクリックしてから、プロジェクトダッシュボードに表示する openshift プロジェクトを選択します。
  7. Workloads タブをクリックします。選択された namespace (例: openshift) の既存のアプリケーションがすべて表示されます。
  8. s2i-fuse76-spring-boot-camel-xml をクリックし、クイックスタートの Overview 情報ページを表示します。

    Spring Boot Camel XML Overview

  9. Resources タブをクリックした後に View logs をクリックし、アプリケーションのビルドログを表示します。

    Spring Boot Camel XML build logs

  10. 左側のパネルで Workloads を展開します。
  11. Pods をクリックした後、s2i-fuse76-spring-boot-camel-xml-xxxx をクリックします。アプリケーションの Pod の詳細が表示されます。

    Spring Boot Camel XML pod details

  12. 稼働中の Pod を終了するには以下を行います。

    1. openshift プロジェクトの Project Details ページで、Workloads タブをクリックしてから s2i-fuse76-spring-boot-camel-xml-xxxx アプリケーションをクリックします。
    2. Overview タブをクリックし、アプリケーションの概要情報ページを表示します。
    3. Pod アイコンの隣りにある 下矢印 get started s2i binary 05 をクリックして、値をゼロにして Pod を停止します。
    4. 下矢印を使用して値をゼロにし、Pod を停止します。

第5章 Spring Boot イメージのアプリケーションの開発

本章では、Spring Boot イメージのアプリケーションを開発する方法を説明します。

5.1. Maven archetype を使用した Spring Boot プロジェクトの作成

Maven archetype を使用して Spring Boot プロジェクトを作成するには、以下の手順にしたがいます。

手順

  1. システムの適切なディレクトリーに移動します。
  2. シェルプロンプトで以下の mvn コマンドを入力し、Spring Boot プロジェクトを作成します。

    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
      -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001

    archetype プラグインが対話モードに切り替わり、残りのフィールドの入力を要求されます。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse76-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse76-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
     Y: : Y

    プロンプトが表示されたら、groupId の値には org.example.fisartifactId の値には fuse76-spring-boot を入力します。残りのフィールドではデフォルト値を使用します。

  3. 上記のコマンドが BUILD SUCCESS 状態で終了した場合、fuse76-spring-boot サブディレクトリー内に新しい Fuse on OpenShift プロジェクトが作成されているはずです。
  4. これで、fuse76-spring-boot プロジェクトをビルドおよびデプロイできるようになりました。OpenShift にログインしている状態で、fuse76-spring-boot プロジェクトのディレクトリーに移動し、以下のようにプロジェクトをビルドおよびデプロイします。

    cd fuse76-spring-boot
    mvn fabric8:deploy -Popenshift
注記

使用できる Spring Boot archetype の完全リストは、「Spring Boot archetype カタログ」を参照してください。

5.2. Maven archetype を使用した Spring Boot 2 プロジェクトの作成

このクイックスタートでは、Maven archetype を使用して Spring Boot 2 プロジェクトを作成する方法を実証します。

手順

  1. システムの適切なディレクトリーに移動します。
  2. Shell プロンプトに以下の mvn コマンドを入力し、Spring Boot 2 プロジェクトを作成します。

    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
      -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-sb2-760038-redhat-00001/archetypes-catalog-2.2.0.fuse-sb2-760038-redhat-00001-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-sb2-760038-redhat-00001

    archetype プラグインが対話モードに切り替わり、残りのフィールドの入力を要求されます。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse76-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse76-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
     Y: : Y

    プロンプトが表示されたら、groupId の値には org.example.fisartifactId の値には fuse76-spring-boot を入力します。残りのフィールドではデフォルト値を使用します。

  3. 上記のコマンドが BUILD SUCCESS 状態で終了した場合、fuse76-spring-boot サブディレクトリー内に新しい Fuse on OpenShift プロジェクトが作成されているはずです。
  4. これで、fuse76-spring-boot プロジェクトをビルドおよびデプロイできるようになりました。OpenShift にログインしている状態で、fuse76-spring-boot プロジェクトのディレクトリーに移動し、以下のようにプロジェクトをビルドおよびデプロイします。

    cd fuse76-spring-boot
    mvn fabric8:deploy -Popenshift
注記

使用できる Spring Boot 2 archetype の完全リストは、「Spring Boot 2 archetype カタログ」を参照してください。

5.3. Camel Spring Boot アプリケーションの構造

Camel Spring Boot アプリケーションのディレクトリー構造は以下のようになります。

  ├── LICENSE.md
  ├── pom.xml
  ├── README.md
  ├── configuration
  │   └── settings.xml
  └── src
      ├── main
      │   ├── fabric8
      │   │   └── deployment.yml
      │   ├── java
      │   │   └── org
      │   │       └── example
      │   │           └── fis
      │   │               ├── Application.java
      │   │               └── MyTransformer.java
      │   └── resources
      │       ├── application.properties
      │       ├── logback.xml
      │       └── spring
      │           └── camel-context.xml
      └── test
          └── java
              └── org
                  └── example
                      └── fis

このうち、アプリケーションの開発に重要なファイルは次のとおりです。

pom.xml
追加の依存関係が含まれます。Spring Boot と互換性のある Camel コンポーネントは、camel-jdbc-startercamel-infinispan-starter などのスターターバージョンを利用できます。pom.xml にスターターが含まれると、スターターは自動的に設定され、起動時に Camel コンテンツと登録されます。application.properties ファイルを使用すると、コンポーネントのプロパティーを設定できます。
application.properties

設定の外部化を可能にし、異なる環境で同じアプリケーションコードを使って作業できるようになります。詳細は「Externalized Configuration」を参照してください。

たとえば、この Camel アプリケーションでアプリケーションの名前や IP アドレスなどの特定のプロパティーを設定できます。

application.properties

#spring.main.sources=org.example.fos

logging.config=classpath:logback.xml

# the options from org.apache.camel.spring.boot.CamelConfigurationProperties can be configured here
camel.springboot.name=MyCamel

# lets listen on all ports to ensure we can be invoked from the pod IP
server.address=0.0.0.0
management.address=0.0.0.0

# lets use a different management port in case you need to listen to HTTP requests on 8080
management.port=8081

# disable all management endpoints except health
endpoints.enabled = false
endpoints.health.enabled = true

Application.java

これはアプリケーションを実行するために重要なファイルです。ユーザーとして camel-context.xml ファイルをインポートし、Spring DSL を使用してルートを設定します。

Application.java file@SpringBootApplication アノテーションを指定します。これは、デフォルトの属性を持つ @Configuration@EnableAutoConfiguration、および @ComponentScan と同等です。

Application.java

@SpringBootApplication
// load regular Blueprint file from the classpath that contains the Camel XML DSL
@ImportResource({"classpath:blueprint/camel-context.xml"})

Spring Boot アプリケーションを実行するには main メソッドが必要です。

Application.java

public class Application {
    /**
     * A main method to start this application.
     */
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

camel-context.xml

src/main/resources/spring/camel-context.xml は、Camel ルートが含まれる、アプリケーションの開発に重要なファイルです。

注記

Spring Boot アプリケーションの開発に関する詳細は、「Developing your first Spring Boot Application」を参照してください。

src/main/fabric8/deployment.yml

fabric8-maven-plugin によって生成されるデフォルトの OpenShift 設定ファイルにマージされる追加設定を提供します。

注記

このファイルは Spring Boot アプリケーションの一部として使用されませんが、CPU やメモリー使用量などのリソースを制限するためにすべてのクイックスタートで使用されます。

5.4. Spring Boot archetype カタログ

Spring Boot archetype カタログには以下の例が含まれます。

表5.1 Spring Boot Maven archetype

名前説明

spring-boot-camel-archetype

fabric8 Java ベースイメージを基にして Apache Camel を Spring Boot と使用する方法を実証します。

spring-boot-camel-amq-archetype

Spring Boot アプリケーションを ActiveMQ ブローカーに接続する方法と、Kubernetes または OpenShift を使用して 2 つの Camel ルートの間で JMS メッセージングを使用する用法を実証します。

spring-boot-camel-config-archetype

Kubernetes ConfigMaps および Secret を使用して Spring Boot アプリケーションを設定する方法を実証します。

spring-boot-camel-drools-archetype

Apache Camel を使用して、リモート Kie Server で Kubernetes または OpenShift で実行している Spring Boot アプリケーションを統合する方法を実証します。

spring-boot-camel-infinispan-archetype

Hot Rod プロトコルを使用して Spring Boot アプリケーションを JBoss Data Grid または Infinispan サーバーに接続する方法を実証します。

spring-boot-camel-rest-3scale-archetype

Camel の REST DSL を使用して RESTful API を公開し、それを 3scale に公開する方法を実証します。

spring-boot-camel-rest-sql-archetype

Camel の REST DSL とともに JDBC を介して SQL を使用し、RESTful API を公開する方法を実証します。

spring-boot-camel-xa-archetype

Spring Boot、Camel、および XA トランザクション。この例は、2 つの外部トランザクションリソースである JMS リソース (A-MQ) とデータベース (PostgreSQL) の XA トランザクションをサポートする Spring Boot で Camel Service を実行する方法を実証します。このクイックスタートでは、PostgreSQL データベースと A-MQ ブローカーが最初にデプロイおよび実行されている必要があります。OpenShift サービスカタログに提供されるテンプレートを使用するのが、簡単な実行方法の 1 つです。

spring-boot-camel-xml-archetype

Blueprint 設定ファイルより、Spring Boot の Camel ルートを設定する方法を実証します。

spring-boot-cxf-jaxrs-archetype

fabric8 Java ベースイメージを基にして Spring Boot で Apache CXF を使用する方法を実証します。クイックスタートは Spring Boot を使用して、Swagger が有効な CXF JAXRS エンドポイントが含まれるアプリケーションを設定します。

spring-boot-cxf-jaxws-archetype

fabric8 Java ベースイメージを基にして Spring Boot で Apache CXF を使用する方法を実証します。クイックスタートは Spring Boot を使用して、CXF JAXWS エンドポイントが含まれるアプリケーションを設定します。

重要

テクノロジープレビューのクイックスタートを使用することもできます。Spring Boot Camel XA Transactions クイックスタートは、Spring Boot を使用して、XA トランザクションをサポートする Camel サービスを実行する方法を実証します。このクイックスタートは、2 つの外部トランザクションリソースである JMS (AMQ) ブローカーとデータベース (PostgreSQL) の使用方法を示します。このクイックスタートは https://github.com/jboss-fuse/spring-boot-camel-xa にあります。

テクノロジープレビューの機能は、Red Hat の本番環境のサービスレベルアグリーメント (SLA) ではサポートされず、機能的に完全ではないことがあるため、Red Hat は本番環境での使用は推奨しません。テクノロジープレビューの機能は、最新の技術をいち早く提供して、開発段階で機能のテストやフィードバックの収集を可能にするために提供されます。詳細は、「テクノロジプレビュー機能のサポート範囲」を参照してください。

5.5. Spring Boot 2 archetype カタログ

Spring Boot 2 archetype カタログには、以下の例が含まれます。

表5.2 Spring Boot 2 Maven archetype

名前説明

spring-boot-camel-archetype

fabric8 Java ベースイメージを基にして Apache Camel を Spring Boot と使用する方法を実証します。

spring-boot-camel-amq-archetype

Spring Boot アプリケーションを ActiveMQ ブローカーに接続する方法と、Kubernetes または OpenShift を使用して 2 つの Camel ルートの間で JMS メッセージングを使用する用法を実証します。

spring-boot-camel-drools-archetype

Apache Camel を使用して、リモート Kie Server で Kubernetes または OpenShift で実行している Spring Boot アプリケーションを統合する方法を実証します。

spring-boot-camel-infinispan-archetype

Hot Rod プロトコルを使用して Spring Boot アプリケーションを JBoss Data Grid または Infinispan サーバーに接続する方法を実証します。

spring-boot-camel-rest-3scale-archetype

Camel の REST DSL を使用して RESTful API を公開し、それを 3scale に公開する方法を実証します。

spring-boot-camel-rest-sql-archetype

Camel の REST DSL とともに JDBC を介して SQL を使用し、RESTful API を公開する方法を実証します。

spring-boot-camel-xml-archetype

Blueprint 設定ファイルより、Spring Boot の Camel ルートを設定する方法を実証します。

spring-boot-cxf-jaxrs-archetype

fabric8 Java ベースイメージを基にして Spring Boot で Apache CXF を使用する方法を実証します。クイックスタートは Spring Boot を使用して、Swagger が有効な CXF JAXRS エンドポイントが含まれるアプリケーションを設定します。

spring-boot-cxf-jaxws-archetype

fabric8 Java ベースイメージを基にして Spring Boot で Apache CXF を使用する方法を実証します。クイックスタートは Spring Boot を使用して、CXF JAXWS エンドポイントが含まれるアプリケーションを設定します。

spring-boot-cxf-jaxrs-xml-archetype

OpenShift 上の Spring Boot 2 と Apache CXF JAX-RS を使用する方法を実証します。このクイックスタートは Spring Boot2 を使用して、Swagger が有効な CXF JAXRS エンドポイントが含まれる Spring 設定ファイルベースの CXF アプリケーションを起動します。

spring-boot-cxf-jaxws-xml-archetype

OpenShift 上の Spring Boot 2 と Apache CXF JAX-WS を使用する方法を実証します。このクイックスタートは Spring Boot2 を使用して、CXF JAXWS エンドポイントが含まれる Spring 設定ファイルベースの CXF アプリケーションを起動します。

注記

以下の Spring Boot 2 の Maven archetype は、OpenShift でビルドおよびデプロイできません。詳細は『リリースノート』を参照してください。

  • spring-boot-camel-archetype
  • spring-boot-camel-infinspan-archetype
  • spring-boot-cxf-jaxrs-archetype
  • spring-boot-cxf-jaxws-archetype

この問題を回避するには、これらのクイックスタートの 1 つに Maven プロジェクトを生成した後に、プロジェクトの Maven pom.xml ファイルを編集し、以下の依存関係を追加します。

<dependency>
  <groupId>org.assertj</groupId>
  <artifactId>assertj-core</artifactId>
  <version>2.4.1</version>
  <scope>test</scope>
</dependency>

5.6. Spring Boot の BOM ファイル

Maven BOM (Bill of Materials) ファイルの目的は、正常に動作する Maven 依存関係バージョンのセットを提供し、各 Maven アーティファクトに対して個別にバージョンを定義する必要をなくすことです。

重要

使用している Spring Boot のバージョン (Spring Boot 1 または Spring Boot 2) に適した Fuse BOM が使用されているようにしてください。

Spring Boot の Fuse BOM には以下の利点があります。

  • Maven 依存関係のバージョンを定義するため、依存関係を POM に追加するときにバージョンを指定する必要がありません。
  • 特定バージョンの Fuse に対して完全にテストされ、完全にサポートする依存関係のセットを定義します。
  • Fuse のアップグレードを簡素化します。
重要

Fuse BOM によって定義される依存関係のセットのみが Red Hat によってサポートされます。

5.6.1. BOM ファイルの組み込み

Maven プロジェクトに BOM ファイルを組み込むには、以下の Spring Boot 2 および Spring Boot 1 の例のように、プロジェクトの pom.xml ファイル (または親 POM ファイル内の) dependencyManagement 要素を指定します。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- configure the versions you want to use here -->
    <fuse.version>7.6.0.fuse-sb2-760028-redhat-00001</fuse.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-springboot-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
</project>


<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- configure the versions you want to use here -->
    <fuse.version>7.6.0.fuse-760027-redhat-00001</fuse.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-springboot-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
</project>

依存関係管理のメカニズムを使用して BOM を指定した後、アーティファクトのバージョンを指定しなくても、Maven 依存関係を POM に追加できるようになります。たとえば、camel-hystrix コンポーネントの依存関係を追加するには、以下の XML フラグメントを POM の dependencies 要素に追加します。

<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-hystrix-starter</artifactId>
</dependency>

Camel アーティファクト ID が -starter 接尾辞とともに追加されていることに注意してください。つまり、Camel Hystrix コンポーネントを camel-hystrix ではなく camel-hystrix-starter として指定します。Camel スターターコンポーネントは、Spring Boot 環境に対して最適化されるようにパッケージ化されています。

5.7. Spring Boot Maven プラグイン

Spring Boot Maven プラグインは Spring Boot によって提供されます。これは、Spring Boot プロジェクトをビルドおよび実行するための開発者ユーティリティーです。

  • ビルド: プロジェクトディレクトリーでコマンド mvn package を入力し、Spring Boot アプリケーションの実行可能な Jar パッケージを作成します。ビルドの出力は、Maven プロジェクトの target/ サブディレクトリーに格納されます。
  • 実行: 新規ビルドされたアプリケーションは mvn spring-boot:start コマンドで実行することができます。

Spring Boot Maven プラグインをプロジェクトの POM ファイルに組み込むには、以下の例のように、プラグイン設定を pom.xml ファイルの project/build/plugins セクションに追加します。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- configure the versions you want to use here -->
    <fuse.version>7.6.0.fuse-760027-redhat-00001</fuse.version>

  </properties>
  ...
  <build>
    <plugins>
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <version>${fuse.version}</version>
        <executions>
          <execution>
            <goals>
              <goal>repackage</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  ...
</project>

第6章 Spring Boot での Apache Camel アプリケーションの実行

Apache Camel Spring Boot コンポーネントは、自動的に Camel コンテキストを Spring Boot に設定します。Camel コンテキストの自動設定によって、Spring コンテキストで使用できる Camel ルートが自動検出され、プロデューサーテンプレート、コンシューマーテンプレート、タイプコンバーターなどの主な Camel ユーティリティーが Bean として登録されます。Apache Camel コンポーネントには、スターターを使用して Spring Boot アプリケーションを開発できるようにする Spring Boot スターターモジュールが含まれます。

6.1. Camel Spring Boot コンポーネント

Camel Spring Boot アプリケーションはすべてプロジェクトの pom.xml にある dependencyManagement を使用して、依存関係の製品化バージョンを指定する必要があります。これらの依存関係は Red Hat Fuse BOM で定義され、特定バージョンの Red Hat Fuse でサポートされます。BOM からのバージョンをオーバーライドしないようにするため、追加のスターターのバージョン番号を省略することができます。詳細は、「quickstart pom 」を参照してください。

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.jboss.redhat-fuse</groupId>
			<artifactId>fuse-springboot-bom</artifactId>
			<version>${fuse.version}</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

注記

camel-spring-boot jar には spring.factories ファイルが含まれています。このファイルにより、依存関係をクラスパスに追加できるため、Spring Boot によって Camel コンテキストが自動的に設定されます。

6.2. Camel Spring Boot スターターモジュール

スターターは、Spring Boot アプリケーションでの使用を目的とする Apache Camel モジュールです。「スターターモジュールのない Camel コンポーネント一覧」 に記載されている一部の例外を除き、camel-xxx-starter モジュールは各 Camel コンポーネントにあります。

スターターは以下の要件を満たしています。

  • IDE ツールと互換性のあるネイティブ Spring Boot 設定システムを使用して、コンポーネントの自動設定を可能にします。
  • データ形式および言語の自動設定を可能にします。
  • 推移的なログの依存関係を管理し、Spring Boot ロギングシステムと統合します。
  • 追加の依存関係を含め、推移的な依存関係を合わせることで Spring Boot アプリケーションを作成するための労力を最小限にします。

各スターターの tests/camel-itest-spring-boot に独自の統合テストがあり、現在のリリースの Spring Boot との互換性を検証します。

注記

詳細は、ソースコードの サンプルアプリケーション を参照してください。

6.3. スターターモジュールのない Camel コンポーネント一覧

互換性の問題があるため、以下のコンポーネントにはスターターモジュールがありません。

  • camel-blueprint (OSGi のみを対象)
  • camel-cdi (CDI のみを対象)
  • camel-core-osgi (OSGi のみを対象)
  • camel-ejb (JEE のみを対象)
  • camel-eventadmin (OSGi のみを対象)
  • camel-ibatis (camel-mybatis-starter を含む)
  • camel-jclouds
  • camel-ibatis (camel-mina2-starter が含まれる)
  • camel-paxlogging (OSGi のみを対象)
  • camel-quartz (camel-quartz2-starter が含まれる)
  • camel-spark-rest
  • camel-openapi-java (camel-openapi-java-starter が含まれる)

6.4. Camel Spring Boot スターターの使用

Apache Camel では、Spring Boot アプリケーションをすぐに開発できるようにするスターターモジュールが提供されます。

手順

  1. 以下の依存関係を Spring Boot の pom.xml に追加します。

    <dependency>
        <groupId>org.apache.camel</groupId>
        <artifactId>camel-spring-boot-starter</artifactId>
    </dependency>
  2. 以下のスニペットのように、Camel ルートでクラスを追加します。これらのルートがクラスパスに追加されると、ルートは自動的に開始されます。

    package com.example;
    
    import org.apache.camel.builder.RouteBuilder;
    import org.springframework.stereotype.Component;
    
    @Component
    public class MyRoute extends RouteBuilder {
    
        @Override
        public void configure() throws Exception {
            from("timer:foo")
              .to("log:bar");
        }
    }
  3. 任意手順:Camel の稼働を維持するためにメインスレッドがブロックされた状態を維持するには、以下の 1 つを行います。

    1. spring-boot-starter-web 依存関係が含まれるようにする。
    2. camel.springboot.main-run-controller=trueapplication.properties または application.yml ファイルに追加する。

      application.properties または application.yml ファイルに camel.springboot.* properties を使用すると Camel アプリケーションをカスタマイズできます。

  4. 任意手順:Bean の ID 名を使用してカスタム Bean を参照するには、src/main/resources/application.properties または application.yml ファイルのオプションを設定します。以下の例は、Bean ID を使用して xslt コンポーネントがカスタム Bean を参照する方法を示しています。

    1. ID myExtensionFactory でカスタム Bean を参照します。

      camel.component.xslt.saxon-extension-functions=myExtensionFactory
    2. 次に、Spring Boot の @Bean アノテーションを使用してカスタム Bean を作成します。

      @Bean(name = "myExtensionFactory")
      public ExtensionFunctionDefinition myExtensionFactory() {
          }

      または、Jackson ObjectMapper の場合は、camel-jackson データ形式を以下のようにします。

      camel.dataformat.json-jackson.object-mapper=myJacksonMapper

6.5. Spring Boot の Camel コンテキストの自動設定

Camel Spring Boot auto-configuration は、CamelContext インスタンスを提供し、SpringCamelContext を作成します。また、コンテキストの初期化およびシャットダウンを実行します。この Camel コンテキストは、camelContext Bean 名で Spring アプリケーションコンテキストに登録され、他の Spring Bean と同様にアクセスできます。camelContext には次のようにアクセスできます。

@Configuration
public class MyAppConfig {

  @Autowired
  CamelContext camelContext;

  @Bean
  MyService myService() {
    return new DefaultMyService(camelContext);
  }

}

6.6. Spring Boot アプリケーションでの Camel ルートの自動検出

Camel auto-configuration は、Spring コンテキストからすべての RouteBuilder インスタンスを収集し、自動的に CamelContext にインジェクトします。これにより、Spring Boot スターターで新しい Camel ルートを作成する処理が簡単になります。以下のようにルートを作成できます。

@Component アノテーションが付けられたクラスをクラスパスに追加します。

@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("jms:invoices").to("file:/invoices");
  }

}

または、@Configuration クラスに新しいルート RouteBuilder Bean を作成します。

@Configuration
public class MyRouterConfiguration {

  @Bean
  RoutesBuilder myRouter() {
    return new RouteBuilder() {

      @Override
      public void configure() throws Exception {
        from("jms:invoices").to("file:/invoices");
      }

    };
  }
 
}

6.7. Camel Spring Boot auto configuration の Camel プロパティーの設定

Spring Boot auto-configuration は、プロパティーのプレースホルダー、OS 環境変数、Camel プロパティーがサポートされるシステムプロパティーなどの Spring Boot 外部設定に接続します。

手順

  1. application.properties ファイルにプロパティーを定義します。 

    route.from = jms:invoices

    または、以下の例のように Camel プロパティーをシステムプロパティーとして設定します。

    java -Droute.to=jms:processed.invoices -jar mySpringApp.jar
  2. 次のように、設定されたプロパティーを Camel ルートのプレースホルダーとして使用します。

    @Component
    public class MyRouter extends RouteBuilder {
    
      @Override
      public void configure() throws Exception {
        from("{{route.from}}").to("{{route.to}}");
      }
    
    }

6.8. カスタム Camel コンテキストの設定

Camel Spring Boot auto-configuration によって作成された CamelContext Bean でオペレーションを実行するには、Spring コンテキストで CamelContextConfiguration インスタンスを登録します。

手順

  • 以下のように、Spring コンテキストで CamelContextConfiguration のインスタンスを登録します。

    @Configuration
    public class MyAppConfig {
    
      ...
    
      @Bean
      CamelContextConfiguration contextConfiguration() {
        return new CamelContextConfiguration() {
          @Override
          void beforeApplicationStart(CamelContext context) {
            // your custom configuration goes here
          }
        };
      }
    
    }

Spring コンテキストの開始前に CamelContextConfiguration および beforeApplicationStart(CamelContext) メソッドが呼び出され、このコールバックに渡された CamelContext インスタンスは完全に自動設定されます。複数のインスタンスの CamelContextConfiguration を Spring コンテキストに追加でき、すべてが実行されます。

6.9. 自動設定された CamelContext での JMX の無効化

自動設定された CamelContext で JMX を無効にするには、camel.springboot.jmxEnabled プロパティーを使用できます。JMX はデフォルトで有効になっています。

手順

  • 以下のプロパティーを application.properties ファイルに追加し、false に設定します。

    camel.springboot.jmxEnabled = false

6.10. 自動設定されたコンシューマーおよびプロデューサーテンプレートの Spring 管理 Bean へのインジェクト

Camel auto configuration によって、事前設定された ConsumerTemplate および ProducerTemplate インスタンスが提供されます。これらを Spring 管理の Bean にインジェクトすることができます。

@Component
public class InvoiceProcessor {

  @Autowired
  private ProducerTemplate producerTemplate;

  @Autowired
  private ConsumerTemplate consumerTemplate;
  public void processNextInvoice() {
    Invoice invoice = consumerTemplate.receiveBody("jms:invoices", Invoice.class);
    ...
    producerTemplate.sendBody("netty-http:http://invoicing.com/received/" + invoice.id());
  }

}

デフォルトでは、コンシューマーテンプレートとプロデューサーテンプレートのエンドポイントキャッシュサイズは 1000 に設定されています。これらの値を変更するには、以下の Spring プロパティーを希望するキャッシュサイズに設定します。例を以下に示します。

camel.springboot.consumerTemplateCacheSize = 100
camel.springboot.producerTemplateCacheSize = 200

6.11. Spring コンテキストの自動設定された TypeConverter

Camel auto configuration では、Spring コンテキストの typeConverter という名前の TypeConverter インスタンスが登録されます。

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public long parseInvoiceValue(Invoice invoice) {
    String invoiceValue = invoice.grossValue();
    return typeConverter.convertTo(Long.class, invoiceValue);
  }

}

6.12. Spring タイプコンバージョン API ブリッジ

Spring は、強力な タイプコンバージョン API で構成されます。Spring API は Camel の タイプコンバーター API と似ています。これらの API は似ているため、Camel Spring Boot は Spring コンバージョン API に委譲するブリッジコンバーター (SpringTypeConverter) を自動的に登録します。つまり、追加設定のない Camel は Spring コンバーターを Camel と同様に扱います。

これにより、以下のように Camel TypeConverter API を使用して、Camel および Spring コンバーターの両方にアクセスできます。

@Component
public class InvoiceProcessor {

  @Autowired
  private TypeConverter typeConverter;

  public UUID parseInvoiceId(Invoice invoice) {
    // Using Spring's StringToUUIDConverter
    UUID id = invoice.typeConverter.convertTo(UUID.class, invoice.getId());
  }

}

ここでは、Spring Boot はアプリケーションコンテキストで使用できる Spring の ConversionService インスタンスに変換を委譲します。ConversionService インスタンスがない場合は、Camel Spring Boot の自動設定が ConversionService のインスタンスを作成します。

6.13. タイプ変換機能の無効化

Camel Spring Boot のタイプ変換機能を無効にするには、camel.springboot.typeConversion プロパティーを false に設定します。このプロパティーが false に設定されると、auto-configuration によってタイプコンバーターインスタンスが登録されず、Spring Boot タイプコンバージョン API へのタイプ変換の委譲が有効になりません。

手順

  • Camel Spring Boot コンポーネントのタイプ変換機能を無効にするには、以下のように camel.springboot.typeConversion プロパティーを false に設定します。

    camel.springboot.typeConversion = false

6.14. 自動設定の XML ルートのクラスパスへの追加

デフォルトでは、camel ディレクトリーのクラスパスにある Camel XML ルートは Camel Spring Boot コンポーネントによって自動検出され、含まれます。設定オプションを使用すると、ディレクトリー名を設定でき、設定オプションを使用してこの機能を無効化できます。

手順

  • 以下のようにクラスパスの Camel Spring Boot XML ルートを設定します。

    // turn off
    camel.springboot.xmlRoutes = false
    // scan in the com/foo/routes classpath
    camel.springboot.xmlRoutes = classpath:com/foo/routes/*.xml
    注記

    XML ファイルによって Camel XML ルート要素が定義され、CamelContext 要素は定義されないはずです。例を以下に示します。

       <routes xmlns="http://camel.apache.org/schema/spring">
            <route id="test">
                <from uri="timer://trigger"/>
                <transform>
                    <simple>ref:myBean</simple>
                </transform>
                <to uri="log:out"/>
            </route>
        </routes>

Spring XML ファイルの使用

<camelContext> で Spring XML ファイルを使用するには、Spring XML ファイルまたは application.properties ファイルの Camel コンテキストを設定します。Camel コンテキストの名前を設定し、ストリームキャッシングを有効にするには、以下を application.properties ファイルに追加します。

camel.springboot.name = MyCamel
camel.springboot.stream-caching-enabled=true

6.15. 自動設定の XML Rext-DSL ルートの追加

Camel Spring Boot コンポーネントによって、camel-rest ディレクトリー以下のクラスパスに追加される Camel Rest-DSL XML ルートが自動検出され、組み込まれます。設定オプションを使用すると、ディレクトリー名を設定でき、設定オプションを使用してこの機能を無効化できます。

手順

  • 以下のように、クラスパスの Camel Spring Boot Rest-DSL XML ルートを設定します。

    // turn off
    camel.springboot.xmlRests = false
    // scan in the com/foo/routes classpath
    camel.springboot.xmlRests = classpath:com/foo/rests/*.xml
    注記

    Rest-DSL ファイルによって、Camel XML REST 要素が定義され、CamelContext 要素は定義されないはずです。例を以下に示します。

       <rests xmlns="http://camel.apache.org/schema/spring">
          <rest>
             <post uri="/persons">
                <to uri="direct:postPersons"/>
             </post>
             <get uri="/persons">
                <to uri="direct:getPersons"/>
             </get>
             <get uri="/persons/{personId}">
                 <to uri="direct:getPersionId"/>
             </get>
             <put uri="/persons/{personId}">
                 <to uri="direct:putPersionId"/>
             </put>
             <delete uri="/persons/{personId}">
                 <to uri="direct:deletePersionId"/>
             </delete>
          </rest>
        </rests>

6.16. Camel Spring Boot でのテスト

Camel を Spring Boot で実行すると、Spring Boot は自動的に Camel と @Component アノテーションが付けられたそのルートを組み込みします。Spring Boot でテストする場合、@ContextConfiguration ではなく @SpringBootTest を使用して、使用する設定クラスを指定します。

異なる RouteBuilder クラスに複数の Camel ルートがある場合、アプリケーションの実行時に Camel Spring Boot コンポーネントによってこれらのルートがすべて自動的に組み込まれます。1 つの RouteBuilder クラスのみからルートをテストする場合は、以下のパターンを使用して、有効にする RouteBuilder を include (含める) または exclude (除外) することができます。

  • java-routes-include-pattern: パターンに一致する RouteBuilder クラスを include (含める)ために使用されます。
  • java-routes-exclude-pattern: パターンに一致する RouteBuilder クラスを exclude (除外) するために使用されます。exclude は include よりも優先されます。

手順

  1. 以下のように、ユニットテストクラスの include または exclude パターンを @SpringBootTest アノテーションへのプロパティーとして指定します。

    @RunWith(CamelSpringBootRunner.class)
    @SpringBootTest(classes = {MyApplication.class);
       properties = {"camel.springboot.java-routes-include-pattern=**/Foo*"})
    public class FooTest {

    FooTest クラスの include パターンは Ant スタイルパターンを表す **/Foo* です。このパターンは、すべてのパッケージ名と一致する 2 つのアスタリスクで始まります。/Foo* は、FooRoute のようにクラス名が Foo で始まる必要があることを意味します。

  2. 以下の maven コマンドを使用してテストを実行します。

    mvn test -Dtest=FooTest

第7章 XA トランザクションを使用した Spring Boot での Camel サービスの実行

Spring Boot Camel XA トランザクションクイックスタートは、2 つの外部トランザクションリソースである JMS リソース (AーMQ) およびデータベース (PostgreSQL) にて XA トランザクションをサポートする Spring Boot で Camel サービスを実行する方法を実証します。これらの外部リソースは OpenShift によって提供され、このクイックスタートを実行する前に起動する必要があります。

7.1. StatefulSet リソース

このクイックスタートは OpenShift StatefulSet リソースを使用してトランザクションマネージャーの一意性を保証します。トランザクションログの保存には PersistentVolume が必要になります。アプリケーションは、StatefulSet リソースのスケーリングをサポートします。各インスタンスには独自の in-process リカバリーマネージャーがあります。特別なコントローラーは、アプリケーションがスケールダウンした場合に、終了されたすべてのインスタンスが作業をすべて適切に完了するようにし、保留中のトランザクションが残されないようにします。リカバリーマネージャーが保留中の作業を終了前にすべてフラッシュできない場合、スケールダウン操作はコントローラーによってロールバックされます。このクイックスタートは Spring Boot Narayana リカバリーコントローラーを使用します。

7.2. Spring Boot Narayana リカバリーコントローラー

Spring Boot Narayana リカバリーコントローラーは、終了前に保留中のトランザクションをクリーンアップして、StatefulSet のスケールダウンフェーズを正常に処理できるようにします。スケールダウン操作が実行されても、終了後に Pod がクリーンアップされない場合は、以前のレプリカが復元されるため、スケールダウン操作が効果的にキャンセルされます。

StatefulSet のすべての Pod は、StetefulSet に属する各 Pod の終了状態を保存するために使用される共有ボリュームにアクセスできる必要があります。StatefulSet の pod-0 は状態を定期的にチェックし、StatefulSet のサイズが合わない場合に適切なサイズにスケーリングします。

リカバリーコントローラーが動作するには、現在の namespace のパーミッションを編集する必要があります (ロールバインディングは OpenShift に公開されたリソースセットに含まれています)。リカバリーコントローラーを無効にするには、CLUSTER_RECOVERY_ENABLED 環境変数を使用します。この場合、サービスアカウントに特別なパーミッションは必要ありませんが、スケールダウン操作によって、保留中のトランザクションが通知のないまま終了された Pod に残される可能性があります。

7.3. Spring Boot Narayana リカバリーコントローラーの設定

以下の例は、リカバリーコントローラーを使用して OpenShift で Narayana が動作するよう設定する方法を示しています。

手順

  1. これは、application.properties ファイルの例です。Kubernetes yaml 記述子の以下のオプションを置き換えます。

    # Cluster
    cluster.nodename=1
    cluster.base-dir=./target/tx
    
    # Transaction Data
    spring.jta.transaction-manager-id=${cluster.nodename}
    spring.jta.log-dir=${cluster.base-dir}/store/${cluster.nodename}
    
    # Narayana recovery settings
    snowdrop.narayana.openshift.recovery.enabled=true
    snowdrop.narayana.openshift.recovery.current-pod-name=${cluster.nodename}
    # You must enable resource filtering in order to inject the Maven artifactId
    snowdrop.narayana.openshift.recovery.statefulset=${project.artifactId}
    snowdrop.narayana.openshift.recovery.status-dir=${cluster.base-dir}/status
  2. 共有ボリュームに、終了に関連するトランザクションと情報の両方を格納する必要があります。以下のように StatefulSet yaml 記述子にマウントすることができます。

    apiVersion: apps/v1beta1
    kind: StatefulSet
    #...
    spec:
    #...
      template:
    #...
        spec:
          containers:
          - env:
            - name: CLUSTER_BASE_DIR
              value: /var/transaction/data
              # Override CLUSTER_NODENAME with Kubernetes Downward API (to use `pod-0`, `pod-1` etc. as tx manager id)
            - name: CLUSTER_NODENAME
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: metadata.name
    #...
            volumeMounts:
            - mountPath: /var/transaction/data
              name: the-name-of-the-shared-volume
    #...

Spring Boot Narayana リカバリーコントローラーの Camel エクステンション

Spring Boot アプリケーションコンテキストで Camel が見つかった場合、保留中のトランザクションをすべてフラッシュする前に Camel コンテキストは自動的に停止されます。

7.4. OpenShift での Camel Spring Boot XA クイックスタートの実行

この手順では、実行中の単一ノードの OpenShift クラスターでクイックスタートを実行する方法を説明します。

手順

  1. Camel Spring Boot XA プロジェクトをダウンロードします。

    git clone --branch spring-boot-camel-xa-1.0.0.fuse-760022-redhat-00001 https://github.com/jboss-fuse/spring-boot-camel-xa
  2. spring-boot-camel-xa ディレクトリーに移動し、以下のコマンドを実行します。

    mvn clean install
  3. OpenShift サーバーにログインします。

    oc login -u developer -p developer
  4. test という名前のプロジェクト namespace を作成します (存在しない場合)。

    oc new-project test

    test プロジェクト namespace がすでに存在する場合は、それに切り替えます。

    oc project test
  5. 依存関係をインストールします。

    • ユーザー名 theuser とパスワード Thepassword1! を使用して、postgresql をインストールします。

      oc new-app --param=POSTGRESQL_USER=theuser --param=POSTGRESQL_PASSWORD='Thepassword1!' --env=POSTGRESQL_MAX_PREPARED_TRANSACTIONS=100 --template=postgresql-persistent
    • ユーザー名 theuser とパスワード Thepassword1! を使用して、A-MQ ブローカーをインストールします。

      oc new-app --param=MQ_USERNAME=theuser --param=MQ_PASSWORD='Thepassword1!' --template=amq63-persistent
  6. トランザクションログの永続ボリュームクレームを作成します。

    oc create -f persistent-volume-claim.yml
  7. クイックスタートをビルドおよびでデプロイします。

    mvn fabric8:deploy -P openshift
  8. レプリカの数を必要に合わせてスケールアップします。

    oc scale statefulset spring-boot-camel-xa --replicas 3

    注記: Pod 名はトランザクションマネージャー ID として使用されます (spring.jta.transaction-manager-id プロパティー)。また、現在の実装によってトランザクションマネージャー ID の長さも制限されます。よって、以下の点に注意してください。

    • StatefulSet の名前はトランザクションシステムの識別子であるため、変更しないでください。
    • Pod の名前が 23 文字以下になるように StatefulSet の名前を付ける必要があります。Pod 名は、<statefulset-name>-0, <statefulset-name>-1 のような慣例を使用して、OpenShift によって作成されます。Narayana はできる限り、同じ ID を持つリカバリーマネージャーが複数存在しないようにするため、Pod 名が制限よりも長い場合は、最後の 23 バイトがトランザクション ID として適用されます (「ー」などの一部の文字の削除後)。
  9. クイックスタートが実行されたら、以下のコマンドを使用してベースサービス URL を取得します。

    NARAYANA_HOST=$(oc get route spring-boot-camel-xa -o jsonpath={.spec.host})

7.5. 成功した XA トランザクションのテスト

以下のワークフローは、成功した XA トランザクションのテスト方法を示しています。

手順

  1. audit_log テーブルのメッセージのリストを取得します。

    curl -w "\n" http://$NARAYANA_HOST/api/
  2. 当初、このリストは空の状態です。最初の要素を追加します。

    curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=hello

    しばらく待ってから、新しいリストを取得します。

    curl -w "\n" http://$NARAYANA_HOST/api/
  3. 新しいリストには、hellohello-ok の 2 つのメッセージが含まれます。hello-ok は、メッセージが送信キューに送られ、ログに記録されたことを確認します。複数のメッセージを追加してログを確認することができます。

7.6. 失敗した XA トランザクションのテスト

以下のワークフローは、失敗した XA トランザクションのテスト方法を示しています。

手順

  1. fail という名前のメッセージを送信します。

    curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=fail
  2. しばらく待ってから、新しいリストを取得します。

    curl -w "\n" http://$NARAYANA_HOST/api/
  3. このメッセージは、ルートの最後で例外を発生するため、トランザクションは常にロールバックされます。audit_log テーブルにはメッセージのトレースが記録されないはずです。

第8章 Camel アプリケーションの A-MQ ブローカーとの統合

このチュートリアルでは、A-MQ イメージを使用してクイックスタートをデプロイする方法を説明します。

8.1. Spring Boot Camel A-MQ クイックスタートのビルドおよびデプロイ

このクイックスタートでは、Spring Boot アプリケーションを AMQ Online に接続する方法と、Fuse on OpenShift を使用して 2 つの Camel ルートの間で JMS メッセージングを使用する方法を実証します。

前提条件

  • AMQ Online がデプロイされ、稼働しているようにしてください。AMQ Online を OpenShift にインストールするには、「Installing and configuring AMQ Online on OpenShift」を参照してください。
  • OpenShift が適切に稼働し、Fuse イメージストリームがすでに OpenShift にインストールされているようにしてください。「管理者向けの基本情報」を参照してください。
  • Maven リポジトリーが Fuse に対して設定されているようにしてください。詳細は「Maven リポジトリーの設定」を参照してください。

手順

  1. 開発者として OpenShift サーバーにログインします。

    oc login -u developer -p developer
  2. openshift プロジェクトにログインします。

    oc project openshift
  3. Maven ワークフローを使用して、クイックスタートプロジェクトを作成します。

    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
    -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \
    -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
    -DarchetypeArtifactId=spring-boot-camel-amq-archetype \
    -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
  4. archetype プラグインが対話モードに切り替わり、残りのフィールドの入力を要求されます。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse76-spring-boot-camel-amq
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse76-spring-boot-camel-amq
    version: 1.0-SNAPSHOT
    package: org.example.fis
    Y: :Y

    プロンプトが表示されたら、groupId の値には org.example.fisartifactId の値には fuse76-spring-boot-camel-amq を入力します。残りのフィールドではデフォルト値を使用します。

  5. クイックスタートディレクトリー fuse76-spring-boot-camel-amq に移動します。

    cd fuse76-spring-boot-camel-amq
  6. 以下のコマンドを実行し、設定ファイルを AMQ Online に適用します。これらの設定ファイルによって、管理者権限を持つ AMQ Online ユーザーおよびキューが作成されます。

    oc login -u system:admin
    oc apply -f src/main/resources/k8s
  7. mvn コマンドを実行し、クイックスタートを OpenShift サーバーにデプロイします。

    mvn fabric8:deploy -Popenshift
  8. クイックスタートが正常に実行されていることを確認するには、以下を行います。

    1. ブラウザーで https://OPENSHIFT_IP_ADDR の OpenShift Web コンソールに移動します。OPENSHIFT_IP_ADDR はクラスターの IP アドレスに置き換えます。クレデンシャル (例: ユーザー名 developer、パスワード developer) を使用して、コンソールにログインします。
    2. 左側のパネルで Home を展開し、Status をクリックして openshift プロジェクトの Project Status ページを表示します。
    3. fuse76-spring-boot-camel-amq をクリックし、クイックスタートの Overview 情報ページを表示します。
    4. 左側のパネルで Workloads を展開します。
    5. Pods をクリックした後、fuse76-spring-boot-camel-amq-xxxxx をクリックします。クイックスタートの Pod の詳細が表示されます。
    6. Logs をクリックし、アプリケーションのログを確認します。

      出力にはメッセージが正常に送信されたことが表示されます。

      10:17:59.825 [Camel (camel) thread #10 - timer://order] INFO  generate-order-route - Generating order order1379.xml
      10:17:59.829 [Camel (camel) thread #8 - JmsConsumer[incomingOrders]] INFO  jms-cbr-route - Sending order order1379.xml to the UK
      10:17:59.829 [Camel (camel) thread #8 - JmsConsumer[incomingOrders]] INFO  jms-cbr-route - Done processing order1379.xml
      10:18:02.825 [Camel (camel) thread #10 - timer://order] INFO  generate-order-route - Generating order order1380.xml
      10:18:02.829 [Camel (camel) thread #7 - JmsConsumer[incomingOrders]] INFO  jms-cbr-route - Sending order order1380.xml to another country
      10:18:02.829 [Camel (camel) thread #7 - JmsConsumer[incomingOrders]] INFO jms-cbr-route - Done processing order1380.xml
  9. Web インターフェースでルートを表示するには、Open Java Console をクリックし、AMQ キューのメッセージをチェックします。

第9章 Spring Boot と Kubernetes の統合

現在、Spring Cloud Kubernetes プラグインは Spring Boot と Kubernetes の以下の機能を統合できます。

9.1. Spring Boot の外部化設定

Spring Boot の 外部化設定 (externalized configuration) は、外部ソースの設定値を Java コードにインジェクトできるメカニズムです。Java コードでインジェクションを有効にするには、通常 @Value アノテーション (単一のフィールドにインジェクトする場合) または @ConfigurationProperties アノテーション(Java Bean クラスの複数のプロパティーにインジェクトする場合) をつけます。

設定データはさまざまなソース (プロパティーソース) から取得できます。特に、設定プロパティーは多くの場合でプロジェクトの application.properties ファイル (または application.yaml ファイル) で設定されます。

9.1.1. Kubernetes の ConfigMap

Kubernetes の ConfigMap は、設定データをデプロイされたアプリケーションに提供できるメカニズムです。ConfigMap オブジェクトは、通常 YAML ファイルに定義され、Kubernetes クラスターにアップロードされるため、デプロイされたアプリケーションで設定データを利用できるようになります。

9.1.2. Kubernetes の Secret

Kubernetes の Secretは、機密データ (パスワード、証明書など) をデプロイされたアプリケーションに提供するメカニズムです。

9.1.3. Spring Cloud Kubernetes プラグイン

Spring Cloud Kubernetes プラグインは、Kubernetes と Spring Boot 間のインテグレーションを実装します。原則では、Kubernetes API を使用して ConfigMap から設定データにアクセスできます。しかし、Kubernetes の ConfigMap が Spring Boot 設定の代替プロパティーソースとして動作するように Kubernetes の ConfigMap を直接 Spring Boot の外部化設定メカニズムで統合した方がはるかに便利です。Spring Cloud Kubernetes プラグインは基本的にこの機能を提供します。

9.1.4. Kubernetes インテグレーションでの Spring Boot の有効化

Kubernetes インテグレーションを有効にするには、そのインテグレーションを Maven 依存関係として pom.xml ファイルに追加します。

手順

  1. 以下の Maven 依存関係を Spring Boot Maven プロジェクトの pom.xml ファイルに追加して、Kubernetes インテグレーションを有効にします。

    <project ...>
      ...
      <dependencies>
        ...
        <dependency>
          <groupId>io.fabric8</groupId>
          <artifactId>spring-cloud-kubernetes-core</artifactId>
        </dependency>
        ...
      </dependencies>
      ...
    </project>
  2. インテグレーションを完了するには以下を行います。

    • アノテーションを Java ソースコードに追加します。
    • Kubernetes ConfigMap オブジェクトを作成します。
    • アプリケーションが ConfigMap オブジェクトを読み取りできるようにするため、OpenShift サービスアカウントのパーミッションを編集します。

その他のリソース

9.2. ConfigMap プロパティーソースのチュートリアルの実行

以下のチュートリアルでは、Kubernetes の Secret および ConfigMap の設定を試すことができます。「Kubernetes インテグレーションでの Spring Boot の有効化」の説明どおりに、Spring Cloud Kubernetes プラグインを有効にして、Kubernetes 設定オブジェクトを Spring Boot 外部化設定と統合します。

9.2.1. Spring Boot Camel Config クイックスタートの実行

以下のチュートリアルは、Kubernetes の Secret と ConfigMap の設定を可能にする spring-boot-camel-config-archetype Maven archetype を基にしています。

手順

  1. 新しいシェルプロンプトを開き、以下の Maven コマンドを入力して簡単な Camel Spring Boot プロジェクトを作成します。

    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
      -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-config-archetype \
      -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001

    archetype プラグインは対話モードに切り替わり、残りのフィールドを追加するよう要求します。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse76-configmap
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse76-configmap
    version: 1.0-SNAPSHOT
    package: org.example.fis
    Y: : Y

    プロンプトが表示されたら、groupId の値には org.example.fisartifactId の値には fuse76-configmap を入力します。残りのフィールドではデフォルト値を使用します。

  2. OpenShift にログインし、アプリケーションをデプロイする OpenShift プロジェクトに切り替えます。たとえば、developer ユーザーとしてログインし、openshift プロジェクトにデプロイする場合は、以下のコマンドを入力します。

    oc login -u developer -p developer
    oc project openshift
  3. コマンドラインで、新しい fuse76-configmap プロジェクトのディレクトリーに移動し、このアプリケーションの Secret オブジェクトを作成します。

    cd fuse76-configmap
    oc create -f sample-secret.yml
    注記

    アプリケーションをデプロイする に Secret オブジェクトを作成する必要があります。そうでないと、Secret が利用できるようになるまでデプロイされたコンテナーが待機状態になります。続けて Secret を作成すると、コンテナーは待機状態ではなくなります。Secret オブジェクトの設定方法に関する詳細は「Secret の設定」を参照してください。

  4. クイックスタートアプリケーションをビルドおよびデプロイします。fuse76-configmap プロジェクトのトップレベルで以下を入力します。

    mvn fabric8:deploy -Popenshift
  5. 次のようにアプリケーションログを確認します。

    1. ブラウザーで https://OPENSHIFT_IP_ADDR の OpenShift Web コンソールに移動します (OPENSHIFT_IP_ADDR はクラスターの IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名 developer、パスワード developer) を使用して、コンソールにログインします。
    2. 左側のパネルで Home を展開します。Status をクリックして Project Status ページを表示します。選択された namespace (例: openshift) の既存のアプリケーションがすべて表示されます。
    3. fuse76-configmap をクリックし、クイックスタートの Overview 情報ページを表示します。
    4. 左側のパネルで Workloads を展開します。
    5. Pods をクリックした後、fuse76-configmap-xxxx をクリックします。アプリケーションの Pod の詳細が表示されます。
    6. Logs タブをクリックし、アプリケーションのログを表示します。
  6. src/main/resources/application.properties で設定されるデフォルトの受信者リストは、生成されたメッセージを 2 つのダミーエンドポイントである direct:async-queue および direct:file に送信します。これにより、以下のようなメッセージがアプリケーションログに書き込まれます。

    5:44:57.376 [Camel (camel) thread #0 - timer://order] INFO  generate-order-route - Generating message message-44, sending to the recipient list
    15:44:57.378 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> message-44 pushed to an async queue (simulation)
    15:44:57.379 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> Using username 'myuser' for the async queue
    15:44:57.380 [Camel (camel) thread #0 - timer://order] INFO  target-route--file - ----> message-44 written to a file
  7. ConfigMap オブジェクトを使用して fuse76-configmap アプリケーションの設定を更新する前に、OpenShift ApiServer からデータを確認するパーミッションを fuse76-configmap アプリケーションに付与する必要があります。以下のコマンドを入力し、fuse76-configmap アプリケーションのサービスアカウントに view パーミッションを付与します。

    oc policy add-role-to-user view system:serviceaccount:openshift:qs-camel-config
    注記

    構文 system:serviceaccount:PROJECT_NAME:SERVICE_ACCOUNT_NAME を使用してサービスアカウントが指定されます。fis-config デプロイメント記述子は、SERVICE_ACCOUNT_NAMEqs-camel-config に定義します。

  8. ライブリロード機能の動作を確認するには、以下のように ConfigMap オブジェクトを作成します。

    oc create -f sample-configmap.yml

    新しい ConfigMap は、実行中のアプリケーションにある Camel ルートの受信者リストをオーバーライドし、生成されたメッセージを 3 つ のダミーエンドポイントである direct:async-queuedirect:file、および direct:mail に送信するよう設定します。ConfigMap オブジェクトの詳細は、「ConfigMap の設定」を参照してください。これにより、以下のようなメッセージがアプリケーションログに書き込まれます。

    16:25:24.121 [Camel (camel) thread #0 - timer://order] INFO  generate-order-route - Generating message message-9, sending to the recipient list
    16:25:24.124 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> message-9 pushed to an async queue (simulation)
    16:25:24.125 [Camel (camel) thread #0 - timer://order] INFO  target-route-queue - ----> Using username 'myuser' for the async queue
    16:25:24.125 [Camel (camel) thread #0 - timer://order] INFO  target-route--file - ----> message-9 written to a file (simulation)
    16:25:24.126 [Camel (camel) thread #0 - timer://order] INFO  target-route--mail - ----> message-9 sent via mail

9.2.2. 設定プロパティー Bean

設定プロパティー Bean は、インジェクションによって設定を受け取ることができる標準の Java Bean です。Java コードと外部設定メカニズムの間の基本的なインターフェースを提供します。

外部化設定および Bean レジストリー

以下のイメージは、spring-boot-camel-config クイックスタートで Spring Boot の外部化設定がどのように動作するかを示しています。

kube spring boot 01

設定メカニズムには以下の 2 つの主要部分があります。

プロパティーソース
設定へのインジェクションのプロパティー設定を提供します。デフォルトのプロパティーソースはアプリケーションの application.properties ファイルで、任意で ConfigMap オブジェクトまたは Secret オブジェクトによるオーバーライドが可能です。
設定プロパティー Bean
プロパティーソースから設定の更新を受け取ります。設定プロパティー Bean は、@Configuration または @ConfigurationProperties アノテーションが付けられた Java Bean です。
Spring Bean レジストリー
必要なアノテーションが付けられた 設定プロパティー Bean は、Spring Bean レジストリーに登録されます。
Camel Bean レジストリー
Camel Bean レジストリーは、自動的に Spring Bean レジストリーと統合されるため、登録された Spring Bean を Camel ルートで参照できます。

QuickstartConfiguration クラス

fuse76-configmap プロジェクトの設定プロパティー Bean は、以下のように QuickstartConfiguration Java クラス (src/main/java/org/example/fis/ ディレクトリー下) として定義されます。

package org.example.fis;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration  1
@ConfigurationProperties(prefix = "quickstart")  2
public class QuickstartConfiguration {

    /**
     * A comma-separated list of routes to use as recipients for messages.
     */
    private String recipients;  3

    /**
     * The username to use when connecting to the async queue (simulation)
     */
    private String queueUsername;  4

    /**
     * The password to use when connecting to the async queue (simulation)
     */
    private String queuePassword;  5

    // Setters and Getters for Bean properties
    // NOT SHOWN
    ...
}
1
@Configuration アノテーションによって、QuickstartConfiguration クラスはインスタンス化され、quickstartConfiguration を ID として持つ Beanとして Spring に登録されます。これにより、Bean は自動的に Camel からアクセスできるようになります。たとえば、Camel 構文 ${bean:quickstartConfiguration?method=getQueueUsername} を使用すると、target-route-queue ルートは queueUserName プロパティーにアクセスできるようになります。
2
@ConfigurationProperties アノテーションは、プロパティーソースのプロパティー値を定義するときに使用する必要がある接頭辞 quickstart を定義します。たとえば、プロパティーファイルは recipients プロパティーを quickstart.recipients として参照します。
3
recipient プロパティーはプロパティーソースからインジェクトできます。
4
queueUsername プロパティーはプロパティーソースからインジェクトできます。
5
queuePassword プロパティーはプロパティーソースからインジェクトできます。

9.2.3. Secret の設定

このクイックスタートの Kubernetes Secret は、必要な 1 つの追加ステップ以外は標準の方法でセットアップされています。追加ステップとして、Spring Cloud Kubernetes プラグインを Secret のマウントパスで設定し、起動時に Secret が読み取れるようにする必要があります。Secret を設定するには、以下を行います。

  1. サンプル Secret オブジェクトの作成
  2. Secret のボリュームマウントの設定
  3. Secret プロパティーを読み取るため spring-cloud-kubernetes を設定

サンプル Secret オブジェクト

クイックスタートプロジェクトによって、以下のようなサンプル Secret sample-secret.yml が提供されます。Secret オブジェクトのプロパティー値は常に base64 でエンコードされます (base64 コマンドラインユーティリティーを使用)。Secret が Pod のファイルシステムにマウントされると、値は自動的に元のプレーンテキストにデコードされます。

sample-secret.yml ファイル

apiVersion: v1
kind: Secret
metadata: 1
  name: camel-config
type: Opaque
data:
  # The username is 'myuser'
  quickstart.queue-username: bXl1c2VyCg== 2
  quickstart.queue-password: MWYyZDFlMmU2N2Rm 3

1
metadata.name: Secret を識別します。OpenShift システムの他の部分はこの識別子を使用して Secret を参照します。
2
quickstart.queue-username: quickstartConfiguration Bean の queueUsername プロパティーにインジェクトすることを目的とします。値は base64 でエンコードする 必要 があります。
3
quickstart.queue-password: quickstartConfiguration Bean の queuePassword プロパティーにインジェクトすることを目的とします。値は base64 でエンコードする 必要 があります。
注記

Kubernetes では、プロパティー名を CamelCase で定義できません (プロパティー名をすべて小文字にする必要があります)。この制限を回避するには、ハイフンを使用した形式 queue-username を使用します。Spring はこれを queueUsername と一致します。これは、外部化設定に対して Spring Boot の リラックスバインディングルールを利用します。

Secret のボリュームマウントの設定

Secret をボリュームマウントとして設定し、起動時に Secret がロードされるようにアプリケーションを設定する必要があります。アプリケーションの起動後、Secret プロパティーはファイルシステムの指定の場所で利用可能になります。アプリケーションの deployment.yml ファイルは、Secret のボリュームマウントを定義する src/main/fabric8/ ディレクトリー下にあります。

deployment.yml ファイル

spec:
  template:
    spec:
      serviceAccountName: "qs-camel-config"
      volumes: 1
        - name: "camel-config"
          secret:
            # The secret must be created before deploying this application
            secretName: "camel-config"
      containers:
        -
          volumeMounts: 2
            - name: "camel-config"
              readOnly: true
              # Mount the secret where spring-cloud-kubernetes is configured to read it
              # see src/main/resources/bootstrap.yml
              mountPath: "/etc/secrets/camel-config"
          resources:
#            requests:
#              cpu: "0.2"
#              memory: 256Mi
#            limits:
#              cpu: "1.0"
#              memory: 256Mi
             env:
              - name: SPRING_APPLICATION_JSON
               value: '{"server":{"undertow":{"io-threads":1, "worker-threads":2 }}}'

1
デプロイメントは volumes セクションで、camel-config という名前の Secret を参照する camel-config という名前の新しいボリュームを宣言します。
2
デプロイメントは volumeMounts セクションで、新しいボリュームマウントを宣言します。これは、camel-config ボリュームを参照し、Secret ボリュームが Pod のファイルシステムの /etc/secrets/camel-config パスにマウントする必要があることを指定します。

Secret プロパティーを読み取るため spring-cloud-kubernetes を設定

Secret を Spring Boot の外部化設定と統合するには、Spring Cloud Kubernetes プラグインを Secret のマウントパスで設定する必要があります。Spring Cloud Kubernetes は指定の場所から Secret を読み取り、Spring Boot はそれをプロパティーソースとして利用できるようになります。Spring Cloud Kubernetes プラグインを設定するには、クイックスタートプロジェクトの src/main/resources 下にある bootstrap.yml ファイルを設定します。

bootstrap.yml ファイル

# Startup configuration of Spring-cloud-kubernetes
spring:
  application:
    name: camel-config
  cloud:
    kubernetes:
      reload:
        # Enable live reload on ConfigMap change (disabled for Secrets by default)
        enabled: true
      secrets:
        paths: /etc/secrets/camel-config

spring.cloud.kubernetes.secrets.paths プロパティーは、Pod の Secret ボリュームマウントのパスリストを指定します。

注記

bootstrap.properties ファイル (または bootstrap.yml ファイル) は、application.properties ファイルと同様に動作しますが、アプリケーションの起動時により前の段階でロードされます。bootstrap.properties ファイルの Spring Cloud Kubernetes プラグインに関連するプロパティーを設定した方が信頼性が高くなります。

9.2.4. ConfigMap の設定

Spring Cloud Kubernetes との統合には、ConfigMap オブジェクトの作成と適切な view パーミッションの設定の他に、ConfigMap の metadata.name がプロジェクトの bootstrap.yml ファイルに設定された spring.application.name プロパティーの値と一致するようにする必要があります。ConfigMap を設定するには、以下を行います。

  • サンプル ConfigMap オブジェクトの作成
  • view パーミッションの設定
  • Spring Cloud Kubernetes プラグインの設定

サンプル ConfigMap オブジェクト

クイックスタートオブジェクトは、サンプル ConfigMap sample-configmap.yml を提供します。

kind: ConfigMap
apiVersion: v1
metadata: 1
  # Must match the 'spring.application.name' property of the application
  name: camel-config
data:
  application.properties: | 2
    # Override the configuration properties here
    quickstart.recipients=direct:async-queue,direct:file,direct:mail 3
1
metadata.name: ConfigMap を識別します。OpenShift システムの他の部分はこの識別子を使用して ConfigMap を参照します。
2
data.application.properties: このセクションは、アプリケーションとデプロイされた application.properties ファイルの設定をオーバーライドできるプロパティー設定をリストします。
3
quickstart.recipients: quickstartConfiguration Bean の recipients プロパティーにインジェクトすることを目的とします。

view パーミッションの設定

Secret の deployment.yml ファイルで説明したとおり、serviceAccountName はプロジェクトの deployment.ymlファイルで qs-camel-config に設定されます。そのため、以下のコマンドを実行して、クイックスタートアプリケーションで view パーミッションを有効にします (test プロジェクト namespace にデプロイされることを仮定します)。

oc policy add-role-to-user view system:serviceaccount:test:qs-camel-config

Spring Cloud Kubernetes プラグインの設定

Spring Cloud Kubernetes プラグインは、bootstrap.yml ファイルの以下の設定によって指定されます。

spring.application.name
この値は、ConfigMap オブジェクトの metadata.name と一致する必要があります (たとえば、クイックスタートの sample-configmap.yml で定義された値)。デフォルトは application です。
spring.cloud.kubernetes.reload.enabled
これを true に設定すると、ConfigMap オブジェクトの動的リロードが有効になります。

サポートされるプロパティーに関する詳細は「PropertySource リロード設定プロパティー」を参照してください。

9.3. ConfigMap PropertySource の使用

Kubernetes には、設定をアプリケーションに渡すための ConfigMap という概念があります。Spring Cloud Kubernetes プラグインは、ConfigMap とのインテグレーションを提供し、Spring Boot が ConfigMap にアクセスできるようにします。

有効な場合、ConfigMap PropertySource はアプリケーションの名前が付いた ConfigMap を Kubernetes で検索します (spring.application.name を参照)。その ConfigMap が見つかった場合は、そのデータを読み取り、以下を行います。

9.3.1. 個々のプロパティーの適用

プロパティーを使用してそのスレッドプール設定を読み取る demo という名前の Spring Boot アプリケーションがあるとします。

  • pool.size.core
  • pool.size.max

これを YAML 形式で ConfigMap に外部化することができます。

kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  pool.size.core: 1
  pool.size.max: 16

9.3.2. application.yaml ConfigMap プロパティーの適用

ほとんどの場合で個々のプロパティーは適切に動作しますが、YAML を使用した方が便利であることがあります。ここでは、application.yaml という名前の単一のプロパティーを使用し、YAML を内部に組み込みします。

kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.yaml: |-
    pool:
      size:
        core: 1
        max:16

9.3.3. application.properties ConfigMap プロパティーの適用

Spring Boot の application.properties ファイルのスタイルで ConfigMap プロパティーを定義することもできます。ここでは、application.properties という名前の単一のプロパティーを使用し、内部にプロパティー設定をリストします。

kind: ConfigMap
apiVersion: v1
metadata:
  name: demo
data:
  application.properties: |-
    pool.size.core: 1
    pool.size.max: 16

9.3.4. ConfigMap のデプロイ

ConfigMap をデプロイし、Spring Boot アプリケーションにアクセスできるようにするには、以下の手順を実行します。

手順

  1. Spring Boot アプリケーションで 外部化設定 メカニズムを使用し、ConfigMap プロパティーソースへアクセスします。たとえば、Java Bean に @Configuration アノテーションを付けると、ConfigMap による Bean のプロパティー値のインジェクションが可能になります。
  2. プロジェクトの bootstrap.properties ファイル (または bootstrap.yaml ファイル) で、spring.application.name プロパティーが ConfigMap の名前と一致するよう設定します。
  3. アプリケーションに関連するサービスアカウントの view パーミッションを有効にします (デフォルトでは、default というサービスアカウントになります)。たとえば、view パーミッションを default サービスアカウントに追加するには、以下を実行します。

    oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)

9.4. Secrets PropertySource の使用

Kubernetes には、パスワードや OAuth トークンなどの機密データを格納するための Secret という概念があります。Spring Cloud Kubernetes プラグインは Secrets とのインテグレーションを提供し、Spring Boot が Secret へアクセスできるようにします。

有効になっている Secrets プロパティーソースは、以下のソースから Kubernetes の Secrets を検索します。Secret が見つかった場合、アプリケーションはそのデータを利用できます。

  1. Secret マウントからの再帰的な読み取り
  2. アプリケーションにちなんだ名前の付与 (spring.application.name を参照)
  3. 一部のラベルとの一致

デフォルトでは、API 経由の Secret の消費 (上記の 2 および 3) は 有効になっていない ことに注意してください。

9.4.1. Secret の設定例

プロパティーを使用して ActiveMQ および PostreSQL 設定を読み取る demo という名前の Spring Boot アプリケーションがあるとします。

amq.username
amq.password
pg.username
pg.password

これらの Secret は YAML 形式で Secrets に対して外部化できます。

ActiveMQ の Secret
apiVersion: v1
kind: Secret
metadata:
  name: activemq-secrets
  labels:
    broker: activemq
type: Opaque
data:
  amq.username: bXl1c2VyCg==
  amq.password: MWYyZDFlMmU2N2Rm
PostreSQL の Secret
apiVersion: v1
kind: Secret
metadata:
  name: postgres-secrets
  labels:
    db: postgres
type: Opaque
data:
  pg.username: dXNlcgo=
  pg.password: cGdhZG1pbgo=

9.4.2. Secret の消費

消費する Secret を選択する方法は複数あります。

  • Secret がマップされたディレクトリーをリストする方法

    -Dspring.cloud.kubernetes.secrets.paths=/etc/secrets/activemq,etc/secrets/postgres

    すべての Secret が共通のルートにマップされている場合は、以下のように設定できます。

    -Dspring.cloud.kubernetes.secrets.paths=/etc/secrets
  • 名前付きの Secret を設定する方法

    -Dspring.cloud.kubernetes.secrets.name=postgres-secrets
  • ラベルのリストを定義する方法

    -Dspring.cloud.kubernetes.secrets.labels.broker=activemq
    -Dspring.cloud.kubernetes.secrets.labels.db=postgres

9.4.3. Secrets PropertySource の設定プロパティー

以下のプロパティーを使用して、Secrets プロパティーソースを設定できます。

spring.cloud.kubernetes.secrets.enabled
Secrets プロパティーソースを有効にします。タイプは Boolean で、デフォルトは true です。
spring.cloud.kubernetes.secrets.name
検索する Secret の名前を設定します。タイプは String で、デフォルトは ${spring.application.name} です。
spring.cloud.kubernetes.secrets.labels
Secret の検索に使用されるラベルを設定します。このプロパティーは マップベースのバインディング による定義どおりに動作します。タイプは java.util.Map で、デフォルトは null です。
spring.cloud.kubernetes.secrets.paths
Secret がマウントされるパスを設定します。このプロパティーは コレクションベースのバインディング による定義どおりに動作します。タイプは java.util.List で、デフォルトは null です。
spring.cloud.kubernetes.secrets.enableApi
API 経由で Secret の消費を有効または無効にします。タイプは Boolean で、デフォルトは false です。
注記

API 経由でシークレットにアクセスすることは、セキュリティー上の理由で制限されることがあります。シークレットを POD にマウントする方法が推奨されます。

9.5. PropertySource reload の使用

アプリケーションによっては、外部プロパティーソースで変更を検出し、内部の状況を更新して、新しい設定を反映する必要があります。Spring Cloud Kubernetes のリロード機能は、関連する ConfigMap または Secret の変更時にアプリケーションのリロードをトリガーできます。

9.5.1. PropertySource reload の有効化

Spring Cloud Kubernetes の PropertySource reload 機能は、デフォルトで無効になっています。

手順

  1. クイックスタートの src/main/resources ディレクトリーに移動し、bootstrap.yml ファイルを開きます。
  2. 設定プロパティー spring.cloud.kubernetes.reload.enabled=true を変更します。

9.5.2. PropertySource reload のレベル

spring.cloud.kubernetes.reload.strategy プロパティーでは以下のリロードレベルがサポートされます。

refresh

(デフォルト): @ConfigurationProperties または @RefreshScope アノテーションが付けられた設定 Bean のみがリロードされます。このリロードレベルは、Spring Cloud コンテキストの更新機能を利用します。

注記

PropertySource reload 機能は、リロードストラテジーが refresh に設定されている場合に シンプルな プロパティー (コレクションではない) のみに使用できます。コレクションによって対応されるプロパティーは起動時に変更しないでください。

restart_context
Spring の ApplicationContext 全体が正常に再起動されます。Bean は新しい設定で再作成されます。
shutdown
Spring の ApplicationContext がシャットダウンされ、コンテナーの再起動がアクティベートされます。このレベルを使用する場合は、デーモンでないすべてのスレッドが ApplicationContext にバインドされ、レプリケーションコントローラーまたはレプリカのセットが Pod を再起動するよう設定されているようにしてください。

9.5.3. PropertySource reload の例

以下の例では、リロード機能が有効になっている場合の動作について説明します。

手順

  1. リロード機能がデフォルト設定 (refresh モード) で有効になっていることを仮定します。ConfigMap の変更時に以下の Beanが更新されます。

    @Configuration
    @ConfigurationProperties(prefix = "bean")
    public class MyConfig {
    
        private String message = "a message that can be changed live";
    
        // getter and setters
    
    }
  2. 変更の詳細を確認するには、以下のようにメッセージを定期的に出力する別の Bean を作成します。

    @Component
    public class MyBean {
    
        @Autowired
        private MyConfig config;
    
        @Scheduled(fixedDelay = 5000)
        public void hello() {
            System.out.println("The message is: " + config.getMessage());
        }
    }
  3. 以下のように ConfigMap を使用すると、アプリケーションによって出力されるメッセージを変更できます。

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: reload-example
    data:
      application.properties: |-
        bean.message=Hello World!

    Pod に関連する ConfigMap の bean.message という名前のプロパティーに変更を加えると、プログラムの出力に反映されます。

9.5.4. PropertySource reload の操作モード

リロード機能は 2 つの操作モードをサポートします。

event
(デフォルト): Kubernetes API (Web ソケット) を使用して ConfigMap または Secret の変更を監視します。イベントによって設定の再チェックが実行され、変更があった場合はリロードが実行されます。ConfigMap の変更をリッスンするには、サービスアカウントに view ロールが必要です。Secret にはより高いレベルのロール ( など) が必要になります (Secret はデフォルトでは監視されません)。
polling
ConfigMap と Secret から定期的に設定を再作成し、設定の変更を確認します。ポーリングの期間は spring.cloud.kubernetes.reload.period プロパティーを使用して設定でき、デフォルトは 15 秒 です。監視対象のプロパティーソースと同じロールが必要です。たとえば、ファイルにマウントされた Secret ソースにポーリングを使用する場合は特定の権限は必要ありません。

9.5.5. PropertySource reload 設定プロパティー

リロード機能の設定には、以下のプロパティーを使用できます。

spring.cloud.kubernetes.reload.enabled
プロパティーソースおよび設定リロードの監視を有効にします。タイプは Boolean で、デフォルトは false です。
spring.cloud.kubernetes.reload.monitoring-config-maps
ConfigMap の変更の監視を許可します。タイプは Boolean で、デフォルトは true です。
spring.cloud.kubernetes.reload.monitoring-secrets
Secret の変更の監視を許可します。タイプは Boolean で、デフォルトは false です。
spring.cloud.kubernetes.reload.strategy
リロードの実行時に使用するストラテジー (refreshrestart_context、または shutdown)。タイプは Enum で、デフォルトは refresh です。
spring.cloud.kubernetes.reload.mode
プロパティーソースの変更をリッスンする方法を指定します (event または polling)。タイプは Enum で、デフォルトは event です。
spring.cloud.kubernetes.reload.period
polling ストラテジーの使用時に変更の検証を行う期間をミリ秒単位で指定します。タイプは Long で、デフォルトは 15000 です。

以下の点に注意してください。

  • spring.cloud.kubernetes.reload.* プロパティーは ConfigMap または Secret で使用しないでください。起動時にこのようなプロパティーを変更すると、予期せぬ結果が発生する可能性があります。
  • refresh レベルの使用時に、プロパティーまたは ConfigMap 全体を削除しても、Bean は元の状態に復元されません。

第10章 Karaf イメージのアプリケーションの開発

このチュートリアルでは、Karaf イメージのアプリケーションを作成およびデプロイする方法を説明します。

10.1. Maven archetype を使用した Karaf プロジェクトの作成

Maven archetype を使用して Karaf プロジェクトを作成するには、以下の手順にしたがいます。

手順

  1. システムの適切なディレクトリーに移動します。
  2. Maven コマンドを起動して、Karaf プロジェクトを作成します。

    mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate \
      -DarchetypeCatalog=https://maven.repository.redhat.com/ga/io/fabric8/archetypes/archetypes-catalog/2.2.0.fuse-760024-redhat-00001/archetypes-catalog-2.2.0.fuse-760024-redhat-00001-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=karaf-camel-log-archetype \
      -DarchetypeVersion=2.2.0.fuse-760024-redhat-00001
  3. archetype プラグインは対話モードに切り替わり、残りのフィールドを追加するよう要求します。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse76-karaf-camel-log
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse76-karaf-camel-log
    version: 1.0-SNAPSHOT
    package: org.example.fis
     Y: : Y

    プロンプトが表示されたら、groupId の値には org.example.fisartifactId の値には fuse76-karaf-camel-log を入力します。残りのフィールドではデフォルト値を使用します。

  4. 上記のコマンドが BUILD SUCCESS 状態で終了した場合、fuse76-karaf-camel-log サブディレクトリー内に新しい Fuse on OpenShift プロジェクトが作成されているはずです。
  5. これで、fuse76-karaf-camel-log プロジェクトをビルドおよびデプロイできるようになりました。OpenShift にログインしている状態で、fuse76-karaf-camel-log プロジェクトのディレクトリーに移動し、以下のようにプロジェクトをビルドおよびデプロイします。

    cd fuse76-karaf-camel-log
    mvn fabric8:deploy -Popenshift
注記

使用できる Karaf archetype の完全リストは「Karaf archetype カタログ」を参照してください。

10.2. Camel Karaf アプリケーションの構造

Camel Karaf アプリケーションのディレクトリー構造は以下のようになります。

  ├── pom.xml 1
  ├── README.md
  ├── configuration
  │   └── settings.xml
  └── src
      ├── main
      │   ├── fabric8
      │   │   └── deployment.yml 2
      │   ├── java
      │   │   └── org
      │   │       └── example
      │   │           └── fis
      │   └── resources
      │       ├── assembly
      │       │   └── etc
      │       │       └── org.ops4j.pax.logging.cfg 3
      │       └── OSGI-INF
      │           └── blueprint
      │               └── camel-log.xml 4
      └── test
          └── java
              └── org
                  └── example
                      └── fis

このうち、Karaf アプリケーションの開発に重要なファイルは次のとおりです。

1
pom.xml: 追加の依存関係が含まれます。依存関係を pom.xml ファイルに追加できます。たとえば、ロギングの場合は SLF4J を使用できます。
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
2
src/main/fabric8/deployment.yml: fabric8-maven-plugin によって生成されるデフォルトの OpenShift 設定ファイルにマージされる追加設定を提供します。
注記

このファイルは Karaf アプリケーションの一部として使用されませんが、CPU やメモリー使用量などのリソースを制限するためにすべてのクイックスタートで使用されます。

3
org.ops4j.pax.logging.cfg: ログレベルのカスタマイズ方法を示し、デフォルトのログレベルである INFO ではなく、DEBUG を設定します。
4
camel-log.xml: アプリケーションのソースコードが含まれます。

10.3. Karaf archetype カタログ

Karaf archetype カタログには以下の例が含まれます。

表10.1 Karaf Maven archetype

名前説明

karaf-camel-amq-archetype

Camel amq コンポーネントを使用して、Apache ActiveMQ メッセージブローカーとメッセージを送受信する方法を実証します。

karaf-camel-log-archetype

メッセージを 5 秒おきにサーバーに記録する、簡単な Apache Camel アプリケーションを実証します。

karaf-camel-rest-sql-archetype

Camel の REST DSL とともに JDBC を介して SQL を使用し、RESTful API を公開する方法を実証します。

karaf-cxf-rest-archetype

CXF を使用して RESTful(JAX-RS) Web サービスを作成し、OSGi HTTP サービス経由で公開する方法を実証します。

10.4. Fabric8 Karaf 機能の使用

Fabric8 は Apache Karaf のサポートを提供し、Kubernetes の OSGi アプリケーションの開発を容易にします。

Fabric8 の重要な機能を以下に示します。

  • Blueprint XML ファイルでプレースホルダーを解決するさまざまなストラテジー。
  • 環境変数
  • システムプロパティー
  • サービス
  • Kubernetes の ConfigMap
  • Kubernetes の Secret
  • Kubernetes の設定マップを使用して、OSGi 設定管理を動的に更新します。
  • OSGi サービスの Kubernetes ヘルスチェックを提供します。

10.4.1. Fabric8 Karaf 機能の追加

この機能を追加するには、fabric8-karaf-features 依存関係をプロジェクトの POM フィルに追加します。

手順

  1. プロジェクトの pom.xml ファイルを開き、fabric8-karaf-features 依存関係を追加します。
<dependency>
  <groupId>io.fabric8</groupId>
  <artifactId>fabric8-karaf-features</artifactId>
  <version>${fabric8.version}</version>
  <classifier>features</classifier>
  <type>xml</type>
</dependency>

Fabric8 Karaf 機能が Karaf サーバーにインストールされます。

10.4.2. Fabric8 Karaf Core バンドル機能の追加

fabric8-karaf-core バンドルは、Blueprint および ConfigAdmin エクステンションによって使用される機能を提供します。

手順

  1. プロジェクトの pom.xml を開き、fabric8-karaf-corestartupFeatures セクションに追加します。

    <startupFeatures>
      ...
      <feature>fabric8-karaf-core</feature>
      ...
    </startupFeatures>

    これにより、fabric8-karaf-core 機能がカスタム Karaf ディストリビューションに追加されます。

10.4.3. プロパティープレースホルダーサービスのオプション設定

fabric8-karaf-core バンドルは、以下のインターフェースで PlaceholderResolver サービスをエクスポートします。

public interface PlaceholderResolver {
    /**
     * Resolve a placeholder using the strategy indicated by the prefix
     *
     * @param value the placeholder to resolve
     * @return the resolved value or null if not resolved
     */
    String resolve(String value);

    /**
     * Replaces all the occurrences of variables with their matching values from the resolver using the given source string as a template.
     *
     * @param source the string to replace in
     * @return the result of the replace operation
     */
    String replace(String value);

    /**
     * Replaces all the occurrences of variables within the given source builder with their matching values from the resolver.
     *
     * @param value the builder to replace in
     * @rerurn true if altered
     */
    boolean replaceIn(StringBuilder value);

    /**
     * Replaces all the occurrences of variables within the given dictionary
     *
     * @param dictionary the dictionary to replace in
     * @rerurn true if altered
     */
    boolean replaceAll(Dictionary<String, Object> dictionary);

    /**
     * Replaces all the occurrences of variables within the given dictionary
     *
     * @param dictionary the dictionary to replace in
     * @rerurn true if altered
     */
    boolean replaceAll(Map<String, Object> dictionary);
}

PlaceholderResolver サービスは、異なるプロパティープレースホルダー解決ストラテジーのコレクターとして動作します。デフォルトで提供される解決ストラテジーの一覧は「解決ストラテジー」を参照してください。プロパティープレースホルダーサービスのオプションを設定するには、システムプロパティーと環境変数のどちらかか両方を使用します。

手順

  1. OpenShift で ConfigMap にアクセスするには、サービスアカウントに view パーミッションが必要になります。view パーミッションをサービスアカウントに追加します。

    oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
  2. API 経由での Secret へのアクセスは制限されている可能性があるため、Secret を Pod にマウントします。
  3. Secret は Pod ではボリュームマウントとして使用でき、以下のように secret という名前のディレクトリーにマップされます。

    containers:
      -
       env:
       - name: FABRIC8_K8S_SECRETS_PATH
         value: /etc/secrets
         volumeMounts:
       - name: activemq-secret-volume
         mountPath: /etc/secrets/activemq
         readOnly: true
       - name: postgres-secret-volume
         mountPath: /etc/secrets/postgres
         readOnly: true
    
    volumes:
      - name: activemq-secret-volume
      secret:
      secretName: activemq
      - name: postgres-secret-volume
       secret:
      secretName: postgres

10.4.4. カスタムのプロパティープレースホルダーリゾルバーの追加

カスタムのプレースホルダーリゾルバーを追加して、カスタムの暗号化などの特定の必要項目をサポートできます。また、PlaceholderResolver サービスを使用して、Blueprint および ConfigAdmin がリゾルバーを使用できるようにすることもできます。

手順

  1. 以下の mvn 依存関係をプロジェクトの pom.xml に追加します。

    pom.xml

    ---
    <dependency>
      <groupId>io.fabric8</groupId>
      <artifactId>fabric8-karaf-core</artifactId>
    </dependency>
    ---

  2. PropertiesFunction インターフェースを実装し、CSR を使用して OSGi サービスとして登録します。

    import io.fabric8.karaf.core.properties.function.PropertiesFunction;
    import org.apache.felix.scr.annotations.Component;
    import org.apache.felix.scr.annotations.ConfigurationPolicy;
    import org.apache.felix.scr.annotations.Service;
    
    @Component(
        immediate = true,
        policy = ConfigurationPolicy.IGNORE,
        createPid = false
    )
    @Service(PropertiesFunction.class)
    public class MyPropertiesFunction implements PropertiesFunction {
        @Override
        public String getName() {
            return "myResolver";
        }
    
        @Override
        public String apply(String remainder) {
            // Parse and resolve remainder
            return remainder;
        }
    }
  3. 以下のように、設定管理でリゾルバーを参照することができます。

    properties

    my.property = $[myResolver:value-to-resolve]

10.4.5. 解決ストラテジーの一覧

PlaceholderResolver サービスは、異なるプロパティープレースホルダー解決ストラテジーのコレクターとして動作します。デフォルトで提供される解決ストラテジーを以下の表に示します。

  1. 解決ストラテジーの一覧

接頭辞

説明

env

env:JAVA_HOME

OS 環境変数からプロパティーを検索します。

`sys

sys:java.version

Java JVM システムプロパティーからプロパティーを検索します。

`service

service:amq

サービス命名規則を使用して、OS 環境変数からプロパティーを検索します。

service.host

service.host:amq

ホスト名の部分のみを返すサービス命名規則を使用して、OS 環境変数からプロパティーを検索します。

service.port

service.port:amq

ポートの部分のみを返すサービス命名規則を使用して、OS 環境変数からプロパティーを検索します。

k8s:map

k8s:map:myMap/myKey

Kubernetes ConfigMap (API 経由) からプロパティーを検索します。

k8s:secret

k8s:secret:amq/password

Kubernetes の Secret (API またはボリュームマウント経由) からプロパティーを検索します。

10.4.6. プロパティープレースホルダーサービスのオプション一覧

プロパティープレースホルダーサービスは以下のオプションをサポートします。

  1. プロパティープレースホルダーサービスのオプション一覧
名前デフォルト説明

fabric8.placeholder.prefix

$[

プレースホルダーの接頭辞。

fabric8.placeholder.suffix

]

プレースホルダーの接尾辞。

fabric8.k8s.secrets.path

null

Secret がマップされたパスのコンマ区切りリスト。

fabric8.k8s.secrets.api.enabled

false

API 経由で Secret の消費を有効または無効にする。

10.5. Fabric8 Karaf Config 管理サポートの追加

10.5.1. Fabric8 Karaf Config 管理サポートの追加

カスタムの Karaf ディストリビューションに Fabric8 Karaf Config 管理サポートを追加できます。

手順

  • プロジェクトの pom.xml を開き、fabric8-karaf-cmstartupFeatures セクションに追加します。

    pom.xml

    <startupFeatures>
      ...
      <feature>fabric8-karaf-cm</feature>
      ...
    </startupFeatures>

10.5.2. ConfigMap インジェクションの追加

fabric8-karaf-cm は、Karaf の ConfigAdminConfigMap の値をインジェクトする ConfigAdmin ブリッジを提供します。

手順

  1. ConfigMap が ConfigAdmin ブリッジによって追加されるようにするには、ConfigMap に karaf.pid をラベル付けする必要があります。karaf.pid の値はコンポーネントの pid に対応します。例を以下に示します。

    kind: ConfigMap
    apiVersion: v1
    metadata:
      name: myconfig
      labels:
        karaf.pid: com.mycompany.bundle
    data:
      example.property.1: my property one
      example.property.2: my property two
  2. 設定を定義するには、単一のプロパティー名を使用できます。ほとんどの場合で個別のプロパティーは動作します。これは karaf/etc の pid ファイルと同じです。例を以下に示します。

    kind: ConfigMap
    apiVersion: v1
    metadata:
      name: myconfig
      labels:
        karaf.pid: com.mycompany.bundle
    data:
      com.mycompany.bundle.cfg: |
        example.property.1: my property one
        example.property.2: my property two

10.5.3. 設定プラグイン

fabric8-karaf-cm は、設定プロパティープレースホルダーを解決する ConfigurationPlugin を提供します。

fabric8-karaf-cm プラグインでプロパティーの置き換えを有効にするには Java プロパティー fabric8.config.plugin.enabledtrue に設定する必要があります。たとえば、以下のように Karaf イメージで JAVA_OPTIONS 環境変数を使用して、このプロパティーを設定することができます。

JAVA_OPTIONS=-Dfabric8.config.plugin.enabled=true

10.5.4. 設定プロパティープレースホルダー

以下に設定プロパティープレースホルダーの例を示します。

my.service.cfg

    amq.usr = $[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/username]
    amq.pwd = $[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/password]
    amq.url = tcp://$[env+service:ACTIVEMQ_SERVICE_NAME]

my-service.xml

    <?xml version="1.0" encoding="UTF-8"?>

    <blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:cm="http://aries.apache.org/blueprint/xmlns/blueprint-cm/v1.1.0"
               xsi:schemaLocation="
                 http://www.osgi.org/xmlns/blueprint/v1.0.0
                 https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
                 http://camel.apache.org/schema/blueprint
                 http://camel.apache.org/schema/blueprint/camel-blueprint.xsd">

      <cm:property-placeholder persistent-id="my.service" id="my.service" update-strategy="reload"/>

      <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent">
         <property name="userName"  value="${amq.usr}"/>
         <property name="password"  value="${amq.pwd}"/>
         <property name="brokerURL" value="${amq.url}"/>
      </bean>
    </blueprint>

10.5.5. Fabric8 Karaf 設定管理オプション

Fabric8 Karaf 設定管理は以下のオプションをサポートします。

名前デフォルト説明

fabric8.config.plugin.enabled

false

ConfigurationPlugin を有効にします。

fabric8.cm.bridge.enabled

true

ConfigAdmin ブリッジを有効にします。

fabric8.config.watch

true

ConfigMap の変更の監視を有効にします。

fabric8.config.merge

false

ConfigAdmin での ConfigMap 値のマージを有効にします。

fabric8.config.meta

true

ConfigAdmin ブリッジでの ConfigMap のインジェクトを有効にします。

fabric8.pid.label

karaf.pid

ConfigAdmin ブリッジが検索するラベルを定義します (よって、選択する必要のある ConfigMap にそのラベルが存在する必要があり、その値で PID の関連付けが判断されます)。

fabric8.pid.filters

empty

ConfigAdmin ブリッジの追加の条件を定義し、ConfigMap を選択します。サポートされる構文は以下のとおりです。

  • 異なるラベルの条件はコンマ (,) で区切られ、ラベルの間の AND として解釈されます。
  • ラベル内のセミコロン (;) は OR として解釈され、ラベル値で条件の区切り文字として使用できます。

たとえば、-Dfabric8.pid.filters=appName=A;B,database.name=my.oracle.datasource のようなフィルターの場合、A または B の値を持つラベル appName と、my.oracle.datasource と同等のラベル database.name の両方を持つすべての ConfigMap を提供します。

重要

ConfigurationPlugin には Aries Blueprint CM 1.0.9 以上が必要です。

10.6. Fabric8 Karaf Blueprint サポートの追加

fabric8-karaf-blueprintAries PropertyEvaluator と、fabric8-karaf-core からのプロパティープレースホルダーリゾルバーを使用して、Blueprint XML ファイルのプレースホルダーを解決します。

手順

  • カスタム Karaf ディストリビューションに Blueprint サポートの機能を含めるには、プロジェクトの pom.xml ファイルの startupFeatures セクションに fabric8-karaf-blueprint を追加します。

    <startupFeatures>
      ...
      <feature>fabric8-karaf-blueprint</feature>
      ...
    </startupFeatures>

Fabric8 エバリュエーターは、${env+service:MY_ENV_VAR} のようなチェーンされたエバリュエーターをサポートします。MY_ENV_VAR 変数を環境変数に対して解決する必要があります。結果はサービス関数を使用して解決されます。例を以下に示します。

<?xml version="1.0" encoding="UTF-8"?>

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:ext="http://aries.apache.org/blueprint/xmlns/blueprint-ext/v1.2.0"
           xsi:schemaLocation="
             http://www.osgi.org/xmlns/blueprint/v1.0.0
             https://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
             http://camel.apache.org/schema/blueprint
             http://camel.apache.org/schema/blueprint/camel-blueprint.xsd
             http://aries.apache.org/blueprint/xmlns/blueprint-ext/v1.3.0
             http://aries.apache.org/schemas/blueprint-ext/blueprint-ext-1.3.xsd">

  <ext:property-placeholder evaluator="fabric8" placeholder-prefix="$[" placeholder-suffix="]"/>

  <bean id="activemq" class="org.apache.activemq.camel.component.ActiveMQComponent">
     <property name="userName"  value="$[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/username]"/>
     <property name="password"  value="$[k8s:secret:$[env:ACTIVEMQ_SERVICE_NAME]/password]"/>
     <property name="brokerURL" value="tcp://$[env+service:ACTIVEMQ_SERVICE_NAME]"/>
  </bean>
</blueprint>
重要

入れ子のプロパティープレースホルダーの置換には Aries Blueprint Core 1.7.0 以上が必要です。

10.7. Fabric8 Karaf ヘルスチェックの有効化

fabric8-karaf-checks をスタートアップ機能としてインストールすることが推奨されます。有効にすると、Karaf サーバーは http://0.0.0.0:8181/readiness-check および http://0.0.0.0:8181/health-check URL を公開できます。これらの URL は、Kubernetes が readiness probe および liveness probe のために使用できます。

注記

これらの URL は、以下が true の場合に HTTP 200 ステータスコードのみで応答します。

  • OSGi Framework が開始している。
  • すべての OSGi バンドルが開始している。
  • すべてのブート機能がインストールされている。
  • デプロイされた BluePrint バンドルがすべて作成済み状態である。
  • デプロイされた SCR バンドルはすべてアクティブ、登録済み、またはファクトリー状態である。
  • すべての Web バンドルが Web サーバーにデプロイされている。
  • 作成された Camel コンテキストがすべて開始済み状態である。

手順

  1. プロジェクトの pom.xml を開き、fabric8-karaf-checks 機能を startupFeatures セクションに追加します。

    pom.xml

    <startupFeatures>
      ...
      <feature>fabric8-karaf-checks</feature>
      ...
    </startupFeatures>

    fabric8-maven-plugin:resources ゴールは fabric8-karaf-checks 機能が使用されているかを検出し、readiness および liveness probe について Kubernetes をコンテナーの設定に追加します。

10.8. カスタムヘルスチェックの追加

追加のカスタムヘルスチェックを提供して、リクエストを処理する準備が整う前に Karaf サーバーがユーザートラフィックを受信しないようにすることができます。カスタムヘルスチェックを有効にするには、io.fabric8.karaf.checks.HealthChecker または io.fabric8.karaf.checks.ReadinessChecker インターフェースを実装し、これらのオブジェクトを OSGi レジストリーに登録する必要があります。

手順

  • 以下の mvn 依存関係をプロジェクトの pom.xml に追加します。

    pom.xml

    <dependency>
      <groupId>io.fabric8</groupId>
      <artifactId>fabric8-karaf-checks</artifactId>
    </dependency>

    注記

    SCR を使用すると、最も簡単に OSGi レジストリーでオブジェクトを作成および登録できます。

以下は、ヘルスチェックを実行して空きのディスク領域が確保されるようにする例になります。

import io.fabric8.karaf.checks.*;
import org.apache.felix.scr.annotations.*;
import org.apache.commons.io.FileSystemUtils;
import java.util.Collections;
import java.util.List;

@Component(
    name = "example.DiskChecker",
    immediate = true,
    enabled = true,
    policy = ConfigurationPolicy.IGNORE,
    createPid = false
)
@Service({HealthChecker.class, ReadinessChecker.class})
public class DiskChecker implements HealthChecker, ReadinessChecker {

    public List<Check> getFailingReadinessChecks() {
        // lets just use the same checks for both readiness and health
        return getFailingHeathChecks();
    }

    public List<Check> getFailingHealthChecks() {
        long free = FileSystemUtils.freeSpaceKb("/");
        if (free < 1024 * 500) {
            return Collections.singletonList(new Check("disk-space-low", "Only " + free + "kb of disk space left."));
        }
        return Collections.emptyList();
    }
}

第11章 JBoss EAP イメージのアプリケーションの開発

JBoss EAP で Fuse アプリケーションを開発するために、S2I ソースワークフローを使用して、EAP で Red Hat Camel CDI の OpenShift プロジェクトを作成することもできます。

前提条件

  • OpenShift が適切に稼働し、Fuse イメージストリームがすでに OpenShift にインストールされているようにしてください。「管理者向けの基本情報」を参照してください。
  • Maven リポジトリーが Fuse に対して設定されているようにしてください。詳細は「Maven リポジトリーの設定」を参照してください。

11.1. S2I ソースワークフローを使用した JBoss EAP プロジェクトの作成

JBoss EAP で Fuse アプリケーションを開発するために、S2I ソースワークフローを使用して、EAP で Red Hat Camel CDI の OpenShift プロジェクトを作成することもできます。

手順

  1. view ロールをデフォルトのサービスアカウントに追加して、クラスタリングを有効にします。これにより、view サービスアカウントへの default アクセス権限がユーザーに付与されます。サービスアカウントは、ビルド、デプロイメント、およびその他の Pod を実行するために各プロジェクトで必要になります。シェルプロンプトに以下の oc クライアントコマンドを入力します。

    oc login -u developer -p developer
    oc policy add-role-to-user view -z default
  2. インストールされた Fuse on OpenShift テンプレートを表示します。

    oc get template -n openshift
  3. 以下のコマンドを入力し、Red Hat Fuse 7.6 Camel CDI with EAP クイックスタートの実行に必要なリソースを作成します。これにより、クイックスタートのデプロイメント設定およびビルド設定が作成されます。ターミナルにクイックスタートや作成されたリソースに関する情報が表示されます。

    oc new-app s2i-fuse76-eap-camel-cdi
    
    --> Creating resources ...
        service "s2i-fuse76-eap-camel-cdi" created
        service "s2i-fuse76-eap-camel-cdi-ping" created
        route.route.openshift.io "s2i-fuse76-eap-camel-cdi" created
        imagestream.image.openshift.io "s2i-fuse76-eap-camel-cdi" created
        buildconfig.build.openshift.io "s2i-fuse76-eap-camel-cdi" created
        deploymentconfig.apps.openshift.io "s2i-fuse76-eap-camel-cdi" created
    --> Success
        Access your application via route 's2i-fuse76-eap-camel-cdi-OPENSHIFT_IP_ADDR'
        Build scheduled, use 'oc logs -f bc/s2i-fuse76-eap-camel-cdi' to track its progress.
        Run 'oc status' to view your app.
  4. ブラウザーで https://OPENSHIFT_IP_ADDR の OpenShift Web コンソールに移動します (OPENSHIFT_IP_ADDR はクラスターの IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名 developer、パスワード developer) を使用して、コンソールにログインします。
  5. 左側のパネルで Home を展開します。Projects をクリックしてから、プロジェクトダッシュボードに表示する openshift プロジェクトを選択します。
  6. Workloads タブをクリックします。選択された namespace (例: openshift) の既存のアプリケーションがすべて表示されます。
  7. s2i-fuse76-eap-camel-cdi をクリックし、クイックスタートの Overview 情報ページを表示します。

    eap image s2i source 08

  8. Resources タブをクリックした後に Routes セクションに表示されたリンクをクリックし、アプリケーションにアクセスします。

    eap image s2i source 07

    リンクの形式は http://s2i-fuse76-eap-camel-cdi-OPENSHIFT_IP_ADDR になります。これにより、ブラウザーで以下のようなメッセージが表示されます。

    Hello world from 172.17.0.3
  9. URL の name パラメーターを使用して名前を指定することもできます。たとえば、ブラウザーに URL http://s2i-fuse76-eap-camel-cdi-openshift.apps.cluster-name.openshift.com/?name=jdoe を入力すると、以下のような応答が表示されます。

    Hello jdoe from 172.17.0.3
  10. View Logs をクリックし、アプリケーションのログを表示します。
  11. 稼働中の Pod を終了するには以下を行います。

    1. Overview タブをクリックし、アプリケーションの Overview 情報ページに戻ります。
    2. Pod アイコンの隣りにある 下矢印 get started s2i binary 05 をクリックして、値をゼロにして Pod を停止します。

11.2. JBoss EAP アプリケーションの構造

Red Hat Fuse 7.6 Camel CDI with EAP サンプルのソースコードは、以下の場所にあります。

https://github.com/wildfly-extras/wildfly-camel-examples/tree/wildfly-camel-examples-5.2.0.fuse-720021/camel-cdi

Camel on EAP アプリケーションのディレクトリー構造は以下のようになります。

  ├── pom.xml
  ├── README.md
  ├── configuration
  │   └── settings.xml
  └── src
      └── main
          ├── java
          │   └── org
          │       └── wildfly
          │           └── camel
          │               └── examples
          │                   └── cdi
          │                       └── camel
          │                           ├── MyRouteBuilder.java
          │                           ├── SimpleServlet.java
          │                           └── SomeBean.java
          └── webapp
              └── WEB-INF
                  └── beans.xml

このうち、JBoss EAP アプリケーションの開発に重要なファイルは次のとおりです。

pom.xml
追加の依存関係が含まれます。

11.3. JBoss EAP クイックスタートテンプレート

Fuse on JBoss EAP には以下の S2I テンプレートが提供されます。

表11.1 JBoss EAP S2I テンプレート

名前説明

JBoss Fuse 7.6 Camel A-MQ with EAP (eap-camel-amq-template)

camel-activemq コンポーネントを使用して、OpenShift 上で実行している AMQ メッセージブローカーに接続します。ブローカーがすでにデプロイされていることを前提とします。

Red Hat Fuse 7.6 Camel CDI with EAP (eap-camel-cdi-template)

camel-cdi コンポーネントを使用して、CDI Bean を Camel ルートに統合します。

Red Hat Fuse 7.6 CXF JAX-RS with EAP (eap-camel-cxf-jaxrs-template)

camel-cxf コンポーネントを使用して JAX-RS REST サービスを作成および消費します。

Red Hat Fuse 7.6 CXF JAX-WS with EAP (eap-camel-cxf-jaxws-template)

camel-cxf コンポーネントを使用して JAX-WS Web サービスを作成および消費します。

Red Hat Fuse 7.6 Camel JPA + MySQL (Ephemeral) with EAP eap-camel-jpa-template

Red Hat Fuse on EAP の Camel アプリケーションを MySQL データベースに接続し、REST API を公開する方法を実証します。この例は、MySQL サーバーとして実行するコンテナー 1 つと、クライアントへのデータベースとして動作する Camel アプリケーションを実行するコンテナー 1 つの、合計 2 つのコンテナーを作成します。

第12章 Fuse on OpenShift での永続ストレージの使用

Fuse on OpenShift アプリケーションは、永続ファイルシステムがない OpenShift コンテナーをベースとしています。アプリケーションを起動するたびに、イミュータブルな Docker 形式のイメージで新しいコンテナーに起動されます。そのため、コンテナーが停止するとファイルシステムの永続データが失われます。しかし、アプリケーションは一部の状態を永続ストアのデータとして保存する必要があり、アプリケーションは共通のデータストアへのアクセスを共有することがあります。OpenShift プラットフォームは、外部のストアを永続ストレージとして提供することをサポートします。

12.1. ボリュームおよびボリュームタイプ

OpenShift では、Pod およびコンテナーは ボリューム を、複数のローカルまたはネットワーク接続ストレージエンドポイントが対応するファイルシステムとしてマウントすることができます。

ボリュームタイプには以下が含まれます。

  • emptydir (空のディレクトリー): デフォルトのボリュームタイプです。これは、Pod がローカルホストに作成されると割り当てられるディレクトリーです。サーバー全体でコピーされず、Pod を削除するとディレクトリーも削除されます。
  • configmap: 名前付きの configmap からキーと値のペアで内容が追加されるディレクトリーです。
  • hostPath (ホストディレクトリー): 任意のホスト上の特定のパスを持つディレクトリーで、昇格された権限が必要です。
  • secret (マウントされたシークレット): シークレットボリュームは名前付きのシークレットを提供されるディレクトリーにマウントします。
  • persistentvolumeclaim または pvc (永続ボリュームクレーム): コンテナーのボリュームディレクトリーを、名前で割り当てた永続ボリュームクレームにリンクします。永続ボリュームクレームは、ストレージ割り当てのリクエストです。クレームがバインドされていないと、Pod が開始しないことに注意してください。

ボリュームは Pod レベルで設定され、hostPath を使用して外部ストレージへの直接アクセスのみが可能です。そのため、複数の Pod の共有リソースへのアクセスを hostPath ボリュームとして管理することは困難です。

12.2. PersistentVolumes

PersistentVolumes は、NFS、Ceph RBD、AWS Elastic Block Store (EBS) などのさまざまな種類のネットワークストレージが対応するクラスター全体のストレージをクラスター管理者がプロビジョニングできるようにします。また、PersistentVolumes は容量、アクセスモード、およびリサイクルポリシーも指定します。これにより、基盤のリソースに関係なく、複数のプロジェクトの Pod が永続ストレージにアクセスできます。

さまざまな種類の PersistentVolumes の作成に関しては、「永続ストレージの設定」を参照してください。

12.3. 永続ボリュームの設定

永続ボリュームをプロビジョニングするには、設定ファイルを作成します。その後、PersistentVolume クレームを作成すると、このストレージにアクセスできます。

手順

  1. 以下の設定例を使用して pv.yaml という名前の設定ファイルを作成します。これは、ホストマシン上のパスを pv001 という名前の PersistentVolume としてプロビジョニングします。

    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: pv0001
    spec:
      accessModes:
        - ReadWriteOnce
      capacity:
        storage: 2Mi
      hostPath:
        path: /data/pv0001/

    この例では、ホストパスは /data/pv0001 で、ストレージの容量が 2MB に制限されます。たとえば、OpenShift CDK を使用する場合は、OpenShift クラスターをホストする仮想マシンから /data/pv0001 ディレクトリーをプロビジョニングします。

  2. PersistentVolume を作成します。

    oc create -f pv.yaml
  3. PersistentVolume の作成を検証します。これは、OpenShift クラスターに設定されたすべての PersistentVolumes をリストします。

    oc get pv

12.4. PersistentVolumeClaims の作成

PersistentVolume はストレージエンドポイントを OpenShift クラスターの名前付きのエンティティーとして公開します。プロジェクトからこのストレージにアクセスするには、PersistentVolume にアクセスできる PersistentVolumeClaims を作成する必要があります。PersistentVolumeClaims は、特定のストレージ容量およびアクセスモードのカスタマイズされたクレームで各プロジェクトに作成されます。

手順

  • 以下の設定例は、pv0001 という名前の PersistentVolume に対して 1 度だけ読み書きアクセスする 1MB のストレージの pvc0001 という名前のクレームを作成します。

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: pvc0001
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 1Mi

12.5. Pod での永続ボリュームの使用

Pod はボリュームマウントを使用してファイルマウントの場所を定義し、ボリュームを使用して PersistentVolumeClaims 参照を定義します。

手順

  1. 以下のように、ファイルシステムで PersistentVolumeClaim pvc0001 を /usr/share/data にマウントするコンテナー設定の例を作成します。

    spec:
      template:
        spec:
          containers:
            - volumeMounts:
              - name: vol0001
                mountPath: /usr/share/data
          volumes:
            - name: vol0001
              persistentVolumeClaim:
                claimName: pvc0001

    アプリケーションによって /usr/share/data ディレクトリーに書き込まれたすべてのデータがコンテナーの再起動後も保持されるようになりました。

  2. この設定を Fuse on OpenShift アプリケーションの src/main/fabric8/deployment.yml ファイルに追加し、以下のコマンドを使用して OpenShift リソースを作成します。

    mvn fabric8:resource-apply
  3. 作成した DeploymentConfiguration にボリュームマウントとボリュームがあることを確認します。

    oc describe deploymentconfig <application-dc-name>

    Fuse on OpenShift クイックスタートでは、<application-dc-name> を Maven プロジェクト名 (例: spring-boot-camel) に置き換えます。

第13章 Fuse on OpenShift のパッチ適用

以下のタスクを 1 つ以上実行して、Fuse on OpenShift 製品を最新のパッチレベルにする必要がある場合があります。

Fuse on OpenShift イメージのパッチ適用
OpenShift サーバーの Fuse on OpenShift イメージを更新し、新しいアプリケーションのビルドが Fuse ベースイメージのパッチが適用されたバージョンをベースにするようにします。
BOM を使用したアプリケーション依存関係のパッチ適用
プロジェクト POM ファイルの依存関係を更新し、アプリケーションがパッチが適用されたバージョンの Maven アーティファクトを使用するようにします。
Fuse on OpenShift テンプレートのパッチ適用
OpenShift サーバーの Fuse on OpenShift テンプレートを更新し、Fuse on OpenShift テンプレートで作成された新しいプロジェクトがパッチが適用されたバージョンの Maven アーティファクトを使用するようにします。

13.1. BOM および Maven 依存関係に関する重要事項

Fuse on OpenShift のコンテキストでは、アプリケーションはすべて Red Hat Maven リポジトリーからダウンロードした Maven アーティファクトを使用してビルドされます。そのため、アプリケーションコードにパッチを適用するには、プロジェクトの POM ファイルを編集し、Maven 依存関係を変更して適切な Fuse on OpenShift パッチバージョンを使用することのみが必要となります。

Fuse on OpenShift の Maven 依存関係をすべて一緒にアップグレードし、すべて同じパッチバージョンの依存関係をプロジェクトが使用することが重要になります。Fuse on OpenShift は、一緒にビルドおよびテストされた、Maven アーティファクトのセットで構成されます。Fuse on OpenShift の異なるパッチレベルの Maven アーティファクトを一緒に使用すると、Red Hat がテストおよびサポートしていない信頼できない設定になる可能性があります。このような状況を回避する最も簡単な方法は、Fuse on OpenShift でサポートされる Maven アーティファクトのバージョンをすべて定義する BOM (Bill of Materials) ファイルを Maven で使用することです。BOM ファイルのバージョンを更新すると、プロジェクトの POM にあるすべての Fuse on OpenShift Maven アーティファクトのバージョンが自動的に更新されます。

Fuse on OpenShift Maven archetype または Fuse on OpenShift テンプレートによって生成された POM ファイルには、BOM ファイルを使用する標準レイアウトがあり、必要な特定のプラグインのバージョンを定義します。標準レイアウトはアプリケーションの依存関係のパッチ適用やアップグレードを大変容易にするため、独自のアプリケーションでこの標準レイアウトを使用することが推奨されます。

13.2. Fuse on OpenShift イメージのパッチ適用

Fuse on OpenShift イメージは、メインの Fuse 製品から独立して更新されます。Fuse on OpenShift イメージにパッチが必要な場合、更新されたイメージは標準の Fuse on OpenShift イメージストリームで利用可能になり、更新されたイメージは Red Hat イメージレジストリー registry.redhat.io からダウンロードできます。Fuse on OpenShift は以下のイメージストリームを提供します (OpenShift イメージストリーム名 によって識別されます)。

  • fuse7-java-openshift
  • fuse7-karaf-openshift
  • fuse7-eap-openshift
  • fuse7-console
  • apicurito-ui
  • fuse-apicurito-generator

手順

  1. 通常、Fuse on OpenShift イメージストリームは、OpenShift サーバーの openshift プロジェクトにインストールされます。OpenShift の Fuse on OpenShift イメージの状態をチェックするには、管理者として OpenShift にログインし、以下のコマンドを入力します。

    $ oc get is -n openshift
    NAME                            DOCKER REPO                                           TAGS                            UPDATED
    fuse7-console                   172.30.1.1:5000/openshift/fuse7-console               1.0,1.1,1.2,1.3,1.4,1.5,1.6     About an hour ago
    fuse7-eap-openshift             172.30.1.1:5000/openshift/fuse7-eap-openshift         1.0,1.1,1.2,,1.3,1.4,1.5,1.6    About an hour ago
    fuse7-java-openshift            172.30.1.1:5000/openshift/fuse7-java-openshift        1.0,1.1,1.2,1.3,1.4,1.5,1.6     About an hour ago
    fuse7-karaf-openshift           172.30.1.1:5000/openshift/fuse7-karaf-openshift       1.0,1.1,1.2,1.3,1.4,1.5,1.6     About an hour ago...
    fuse-apicurito-generator        172.30.1.1:5000/openshift/fuse-apicurito-generator    1.2,1.3,1.4,1.5,1.6             About an hour ago...
    apicurito-ui                    172.30.1.1:5000/openshift/apicurito-ui                1.2,1.3,1.4,1.5,1.6             About an hour ago...
  2. 各イメージストリームを 1 つずつ更新できるようになりました。

    oc import-image -n openshift fuse7-java-openshift:1.6
    oc import-image -n openshift fuse7-karaf-openshift:1.6
    oc import-image -n openshift fuse7-eap-openshift:1.6
    oc import-image -n openshift fuse7-console:1.6
    oc import-image -n openshift apicurito-ui:1.6
    oc import-image -n openshift fuse-apicurito-generator:1.6
注記

イメージストリームのバージョンタグの形式は 1.6-<BUILDNUMBER> です。タグを 1.6 として指定すると、1.6 ストリームの最新ビルドが取得されます。

注記

新しい Fuse on OpenShift イメージが利用できるようになったときに毎回再ビルドを自動的にトリガーするよう、Fuse アプリケーションを設定することもできます。詳細は、『OpenShift Container Platform 3.11 開発者ガイド』の「デプロイメントトリガーの設定」を参照してください。

13.3. Fuse on OpenShift テンプレートのパッチ適用

適切なパッチが適応された依存関係を使用して新しいテンプレートベースのプロジェクトがビルドされるようにするため、Fuse on OpenShift テンプレートを最新のパッチレベルに更新する必要があります。

手順

  1. Fuse on OpenShift テンプレートの更新には管理者権限が必要です。以下のように、OpenShift サーバーに管理者としてログインします。

    oc login URL -u ADMIN_USER -p ADMIN_PASS

    ここで、URL は OpenShift サーバーの URL に置き換え、ADMIN_USER および ADMIN_PASS には OpenShift サーバーの管理者アカウントのクレデンシャルを使用します。

  2. パッチが適用された Fuse on OpenShift テンプレートをインストールします。コマンドプロンプトに以下のコマンドを入力します。

    BASEURL=https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.0.fuse-760043-redhat-00003
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-amq-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cdi-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cxf-jaxrs-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-cxf-jaxws-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/eap-camel-jpa-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-amq-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-log-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-camel-rest-sql-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/karaf-cxf-rest-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-amq-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-config-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-drools-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-infinispan-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-camel-xml-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-cxf-jaxrs-template.json
    oc replace --force -n openshift -f ${BASEURL}/quickstarts/spring-boot-cxf-jaxws-template.json
    注記

    BASEURL は、クイックスタートテンプレートを格納する Git リポジトリーの GA ブランチを示し、常に最新のテンプレートが HEAD にあります。そのため、これらのコマンドを実行するたびに最新バージョンのテンプレートが取得されます。

13.4. BOM を使用したアプリケーション依存関係のパッチ適用

新しいスタイルの BOM を使用するよう、アプリケーションの pom.xml ファイルが設定されている場合は、本セクションの手順にしたがって Maven 依存関係をアップグレードします。

13.4.1. Spring Boot アプリケーションでの依存関係の更新

以下のコードは、Fuse on OpenShift における Spring Boot アプリケーションの POM ファイルの標準的なレイアウトを表しています。重要なプロパティー設定がいくつか含まれています。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

    <fuse.version>7.6.0.fuse-760027-redhat-00001</fuse.version>
    ...
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-springboot-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
  <build>
    ...
    <plugins>
      <!-- Core plugins -->
      ...
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        ...
        <version>${fuse.version}</version>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>openshift</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.jboss.redhat-fuse</groupId>
            <artifactId>fabric8-maven-plugin</artifactId>
            ...
            <version>${fuse.version}</version>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>

アプリケーションのパッチ適用やアップグレードでは、以下のバージョン設定が重要になります。

fuse.version
新しいスタイルの fuse-springboot-bom BOM のバージョンや、fabric8-maven-plugin および spring-boot-maven-plugin プラグインのバージョンを定義します。

13.4.2. Karaf アプリケーションのでの依存関係の更新

以下のコードは、Fuse on OpenShift における Karaf アプリケーションの POM ファイルの標準的なレイアウトを表しています。重要なプロパティー設定がいくつか含まれています。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <fuse.version>7.6.0.fuse-760027-redhat-00001</fuse.version>
    ...
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-karaf-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
  <build>
    ...
    <plugins>
      ...
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${fuse.version}</version>
        ...
      </plugin>
      ...
      <plugin>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fabric8-maven-plugin</artifactId>
        <version>${fuse.version}</version>
        ...
      </plugin>
    </plugins>
  </build>

</project>

アプリケーションのパッチ適用やアップグレードでは、以下のバージョン設定が重要になります。

fuse.version
新しいスタイルの fuse-karaf-bom BOM のバージョンや、fabric8-maven-plugin および karaf-maven-plugin プラグインのバージョンを定義します。

13.4.3. JBoss EAP アプリケーションでの依存関係の更新

以下のコードは、Fuse on OpenShift における JBoss EAP アプリケーションの POM ファイルの標準的なレイアウトを表しています。重要なプロパティー設定がいくつか含まれています。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project ...>
  ...
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <fuse.version>7.6.0.fuse-760027-redhat-00001</fuse.version>
    ...
  </properties>

  <!-- Dependency Management -->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.jboss.redhat-fuse</groupId>
        <artifactId>fuse-eap-bom</artifactId>
        <version>${fuse.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  ...
</project>

アプリケーションのパッチ適用やアップグレードでは、以下のバージョン設定が重要になります。

fuse.version
fuse-eap-bom BOM ファイル (旧式の wildfly-camel-bom BOM ファイルの代わりとなる) のバージョンを定義します。BOM のバージョンを特定のパッチバージョンに更新すると、Fuse on JBoss EAP の Maven 依存関係がすべて更新されます。

13.5. 利用可能な BOM バージョン

以下の表は、異なるパッチリリースの Red Hat Fuse に対応する新しいスタイルの BOM バージョンを表しています。

表13.1 Red Hat Fuse リリースおよび対応する新しいスタイルの BOM バージョン

Red Hat Fuse リリースorg.jboss.redhat-fuse BOM バージョン

Red Hat Fuse 7.0.0 GA

7.6.0.fuse-760027-redhat-00001

Red Hat Fuse 7.0.1 patch

7.0.1.fuse-000008-redhat-4

アプリケーション POM を特定の Red Hat Fuse パッチリリースにアップグレードするには、fuse.version プロパティーを対応する BOM バージョンに設定します。

付録A Spring Boot Maven プラグイン

Spring Boot Maven プラグインによって Maven で Spring Boot のサポートが提供され、実行可能な jar または war アーカイブをパッケージ化や、アプリケーション in-place の実行を可能にします。

A.1. Spring Boot Maven プラグインのゴール

Spring Boot Maven プラグインには以下のゴールが含まれます。

  • spring-boot:run は Spring Boot アプリケーションを実行します。
  • spring-boot:repackage は、.jar および .war ファイルを再パッケージして実行可能にします。
  • spring-boot:start および spring-boot:stop の両方は、Spring Boot アプリケーションのライフサイクルを管理するために使用されます。
  • spring-boot:build-info は、Actuator が使用できるビルド情報を生成します。

A.2. Spring Boot Maven プラグインの使用

Spring Boot プラグインの使用方法に関する一般的な手順は、「http://docs.spring.io/spring-boot/docs/current/maven-plugin/usage.html」を参照してください。以下の例は Spring Boot の spring-boot-maven-plugin の使用方法を示しています。

注記

Spring Boot Maven プラグインの詳細は「http://docs.spring.io/spring-boot/docs/current/maven-plugin」を参照してください。

A.2.1. Spring Boot 2 の Spring Boot Maven プラグインの使用

以下の例は Spring Boot 2 の spring-boot-maven-plugin の使用方法を示しています。

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.redhat.fuse</groupId>
  <artifactId>spring-boot-camel</artifactId>
  <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- configure the Fuse version you want to use here -->
        <fuse.bom.version>7.6.0.fuse-sb2-760028-redhat-00001</fuse.bom.version>

        <!-- maven plugin versions -->
        <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>
        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
    </properties>


    <build>
        <defaultGoal>spring-boot:run</defaultGoal>

        <plugins>
            <plugin>
                <groupId>org.jboss.redhat-fuse</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${fuse.bom.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>redhat-ea-repository</id>
            <url>https://maven.repository.redhat.com/earlyaccess/all</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>redhat-ea-repository</id>
            <url>https://maven.repository.redhat.com/earlyaccess/all</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

A.2.2. Spring Boot 1 の Spring Boot Maven プラグインの使用

以下の例は Spring Boot 1 の spring-boot-maven-plugin の使用方法を示しています。

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.redhat.fuse</groupId>
  <artifactId>spring-boot-camel</artifactId>
  <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- configure the Fuse version you want to use here -->
        <fuse.bom.version>7.6.0.fuse-760027-redhat-00001</fuse.bom.version>

        <!-- maven plugin versions -->
        <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>
        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
    </properties>


    <build>
        <defaultGoal>spring-boot:run</defaultGoal>

        <plugins>
            <plugin>
                <groupId>org.jboss.redhat-fuse</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${fuse.bom.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>redhat-ea-repository</id>
            <url>https://maven.repository.redhat.com/earlyaccess/all</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>redhat-ga-repository</id>
            <url>https://maven.repository.redhat.com/ga</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>redhat-ea-repository</id>
            <url>https://maven.repository.redhat.com/earlyaccess/all</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

付録B Karaf Maven プラグインの使用

karaf-maven-plugin は、Karaf コンテナーのマイクロサービススタイルパッケージである Karaf サーバーアセンブリーの作成を可能にします。終了したアセンブリーには、Karaf インストールに必要なすべてのコンポーネント (etc/、data/、lib、およびシステムディレクトリーの内容を含む) が含まれますが、アプリケーションの実行に最低限必要なコンポーネントのみに限定されます。

B.1. Maven 依存関係

karaf-assembly プロジェクトの Maven 依存関係は feature リポジトリー (features 分類子) または kar アーカイブになります。

  • feature リポジトリーは Maven 構造の ystem/internal リポジトリーにインストールされます。
  • kar アーカイブのコンテンツはサーバーの上で展開され、含まれた feature リポジトリーはインストールされています。

Maven 依存関係の範囲

依存関係の Maven スコープは、features サービス設定ファイル etc/org.apache.karaf.features.cfg (featuresRepositories プロパティー以下) にその feature リポジトリーがリストされているかどうかを判断します。これらのスコープは次のとおりです。

  • compile (デフォルト): リポジトリー (または kar アーカイブ) のすべての機能が startup.properties にインストールされます。feature リポジトリーは features サービス設定ファイルにリストされません。
  • runtime: karaf-maven-plugin のブートステージ。
  • Provided: karaf-maven-plugin のインストールステージ。

B.2. Karaf Maven プラグインの設定

karaf-maven-plugin は、Maven スコープに関連する 3 つのステージを定義します。プラグイン設定は、インストールされた feature リポジトリーから機能を参照して、これらの要素を使用して機能をインストールする方法を制御します。

  • スタートアップステージ: etc/startup.properties

    このステージでは、etc/startup.properties に含まれるバンドルのリストを準備するためにスタートアップ機能、スタートアッププロファイル、およびスタートアップバンドルが使用されます。この結果、機能バンドルは適切な開始レベルで etc/startup.properties にリストされ、バンドルは system 内部リポジトリーにコピーされます。たとえば、<startupFeature>foo</startupFeature> のように feature_name または feature_name/feature_version 形式を使用できます。

  • ブートステージ: etc/org.apache.karaf.features.cfg

    このステージは、featuresBoot プロパティーで使用できる機能と、featuresRepositories プロパティーのリポジトリーを管理します。この結果、機能名が features サービス設定の boot-features に追加され、機能のすべてのバンドルが system 内部リポジトリーにコピーされます。たとえば、<bootFeature>bar</bootFeature> のように feature_name または feature_name/feature_version 形式を使用できます。

  • インストールステージ:

    このステージは、アーティファクトを ${karaf.home}/${karaf.default.repository} にインストールします。この結果、機能のバンドルすべてが system 内部リポジトリーにインストールされます。そのため、機能は起動時に外部リポジトリーにアクセスしなくてもインストールされることがあります。たとえば、<installedFeature>baz</installedFeature> のように feature_name または feature_name/feature_version 形式を使用できます。

  • ライブラリー

    プラグインは、ライブラリー URL を指定する 1 つ以上の library 子要素を持つ、libraries 要素を受け入れます。

    <libraries>
        <library>mvn:org.postgresql/postgresql/9.3-1102-jdbc41;type:=endorsed</library>
    </libraries>

B.3. カスタマイズされた Karaf アセンブリー

karaf-maven-plugin によって提供された karaf:assembly ゴールを使用するのが、推奨される Karaf サーバーアセンブリーの作成方法です。この方法では、プロジェクトの pom.xml ファイルの Maven 依存関係からサーバーをアセンブルします。karaf-maven-plugin 設定に指定されたバンドル (または機能) と、pom.xml<dependencies> セクションに指定された依存関係の両方をカスタマイズされた Karaf アセンブリーに追加できます。

  • kar

    kar タイプの依存関係は、スタートアップ (scope=compile)、ブート (scope=runtime)、またはインストール (scope=provided) kars として karaf-maven-plugin に追加されます。kar は作業ディレクトリー (target/assembly) に展開され、機能 XML が検索され、追加の feature リポジトリーとして使用されます (ステージは指定の kar のステージと同じです)。

  • features.xml

    features 分類子の依存関係は、karaf-maven-plugin でスタートアップ (scope=compile)、ブート (scope=runtime) またはインストール (scope=provided) リポジトリーとして使用されます。kar で見つかった feature リポジトリーを明示的に追加する必要はありません。

  • jar および bundle

    bundle または jar タイプの依存関係は、karaf-maven-plugin でスタートアップ (scope=compile)、ブート (scope=runtime)、またはインストール (scope=provided) バンドルとして使用されます。

B.3.1. karaf:assembly goal

karaf-maven-pluginによって提供される karaf:assembly ゴールを使用して Karaf サーバーアセンブリーを作成できます。このゴールは、プロジェクト POM の Maven 依存関係からマイクロサービススタイルサーバーアセンブリーをアセンブルします。Fuse on OpenShift プロジェクトでは、karaf:assembly ゴールを Maven インストールフェーズにバインドすることが推奨されます。プロジェクトはバンドルパッケージを使用し、bootBundles 要素内部にリストすることでプロジェクト自体が Karaf コンテナーにインストールされます。

注記

Karaf フレームワーク機能などの必要な要素のみをスタートアップステージに含めるようにしてください。これは etc/startup.properties に追加され、このステージでは Karaf features サービスは完全に開始していないためです。他の要素はブートステージに移します。

以下の例は、クイックスタートの典型的な Maven 設定を表しています。

<plugin>
  <groupId>org.jboss.redhat-fuse</groupId>
  <artifactId>karaf-maven-plugin</artifactId>
  <version>${fuse.version}</version>
  <extensions>true</extensions>
  <executions>
    <execution>
      <id>karaf-assembly</id>
      <goals>
        <goal>assembly</goal>
      </goals>
      <phase>install</phase>
    </execution>
  </executions>
  <configuration>

    <karafVersion>{karafMavenPluginVersion}</karafVersion>
    <useReferenceUrls>true</useReferenceUrls>
    <archiveTarGz>false</archiveTarGz>
    <includeBuildOutputDirectory>false</includeBuildOutputDirectory>
    <startupFeatures>
      <feature>karaf-framework</feature>
            </startupFeatures>
            <bootFeatures>
      <feature>shell</feature>
      <feature>jaas</feature>
      <feature>aries-blueprint</feature>
      <feature>camel-blueprint</feature>
      <feature>fabric8-karaf-blueprint</feature>
      <feature>fabric8-karaf-checks</feature>
    </bootFeatures>
    <bootBundles>
      <bundle>mvn:${project.groupId}/${project.artifactId}/${project.version}</bundle>
    </bootBundles>
  </configuration>
</plugin>

付録C Fabric8 Maven プラグイン

fabric8-maven-plugin を利用すると、Java アプリケーションを OpenShift にデプロイできます。これは Maven との緊密なインテグレーションを提供し、すでに提供されているビルド設定の利点を活用できます。このプラグインは以下のタスクを中心に行います。

  • Docker 形式イメージのビルド
  • OpenShift リソース記述子の作成

大変柔軟に設定でき、以下を作成するために複数の設定モデルをサポートします。

  • Zero-Config の設定: opinionated default (推奨されるデフォルト) で迅速な立ち上げが可能になります。または、より高度な要件を可能にします。
  • XML 設定: pom.xml ファイルに追加できるその他の設定オプションを提供します。

C.1. イメージのビルド

fabric8:build ゴールは、アプリケーションが含まれる Docker 形式イメージの作成に使用されます。ビルドアーティファクトやイメージの依存関係を簡単に含めることができます。このプラグインは maven-assembly-plugin のアセンブリー記述子を使用し、イメージに追加されるコンテンツを指定します。

重要

Fuse on OpenShift では、OpenShift s2i ビルドストラテジーのみがサポートされます。docker ビルドストラテジーはサポートされません

C.2. Kubernetes および OpenShift リソース

Kubernetes および OpenShift リソース記述子は、fabric8:resource で作成できます。これらのファイルは Maven アーティファクト内にパッケージされ、fabric8:apply を使用して稼働中のオーケストレーションプラットフォームにデプロイできます。

設定

4 つのレベルの設定があります。

  • Zero-Config モードは、pom.xml ファイルにあるデータを基にして、使用するベースイメージや公開するポートなど、非常に的確な決定を行えるようにします。これは開始点として使用され、クイックスタートアプリケーションを小さくきれいに維持するために使用されます。
  • XML プラグイン設定モードは docker-maven-plugin が提供するモードと似ています。IDE サポートでタイプセーフな設定が可能ですが、可能なリソース記述子機能のサブセットのみが提供されます。
  • Kubernetes and OpenShift リソースフラグメントは、プラグインで強化できるユーザー提供の YAML ファイルです。これにより、上級ユーザーはすべての機能が含まれるプレーンな設定ファイルを使用できますが、プロジェクト固有のビルド情報を追加したり、定型コードの使用を回避することができます。OpenShift クラスターで docker compose デプロイメントを立ち上げるために Docker Compose が使用されます。これには、OpenShift のデプロイメントプロセスに関する知識はほとんど必要ありません。Cluster Operator 設定についての詳細は、https://maven.fabric8.io/#configuration を参照してください。

C.3. プラグインのインストール

Fabric8 Maven プラグインは Maven の中央リポジトリーで使用でき、以下のようにインテグレーション前後のフェーズに接続することができます。

手順

  • Fabric8 Maven プラグインをインテグレーション前およびインテグレーション後のフェーズに接続するには、以下の settings.xml ファイルを追加します。
<plugin>
  <groupId>org.jboss.redhat-fuse</groupId>
  <artifactId>fabric8-maven-plugin</artifactId>
  <version>${fuse.version}</version>

  <configuration>
     ....
     <images>
        <!-- A single's image configuration -->
        <image>
          ...
          <build>
           ....
          </build>
        </image>
        ....
     </images>
  </configuration>

  <!-- Connect fabric8:resource and fabric8:build to lifecycle phases -->
  <executions>
    <execution>
       <id>fabric8</id>
       <goals>
         <goal>resource</goal>
         <goal>build</goal>
       </goals>
    </execution>
  </executions>
</plugin>

C.4. Fabric8 Maven プラグインのゴールの理解

Fabric8 Maven プラグインは、スムーズな Java 開発環境を提供するゴールのセットをサポートします。ゴールは以下のように分類できます。

  • ビルドゴール は、Docker 形式イメージや S2I ビルドなどの Kubernetes および OpenShift ビルドアーティファクトを作成および管理するために使用されます。
  • 開発ゴール は、リソース記述子を開発クラスターにデプロイするために使用されます。また、開発クラスターのライフサイクルを管理するのにも便利です。

C.4.1. ビルドおよび開発ゴールの理解

Red Hat Fabric Integration Services 製品の Fabric8 Maven プラグインによってサポートされるゴールは次のとおりです。

表C.1 ビルドゴール

ゴール説明

fabric8:build

ビルドイメージ。Fuse on OpenShift では、OpenShift s2i ビルドストラテジーのみがサポートされることに注意してください。docker ビルドストラテジーはサポートされません。

fabric8:resource

Kubernetes または OpenShift リソース記述子を作成します。

fabric8:apply

リソースを実行中のクラスターに適用します。

fabric8:resource-apply

fabric8:resourcefabric8:apply を実行します。

表C.2 開発ゴール

ゴール説明

fabric8:run

フォアグラウンドで完全な開発ワークフローサイクル fabric8:resourcefabric8:buildfabric8:apply を実行します。

fabric8:deploy

リソース記述子の作成後にクラスターへデプロイし、アプリケーションをビルドします。バックグラウンドで実行すること以外は fabric8:run と同じです。

fabric8:undeploy

クラスターからリソース記述子をアンデプロイおよび削除します。

fabric8:start

以前デプロイされたアプリケーションを開始します。

fabric8:stop

以前デプロイされたアプリケーションを停止します。

fabric8:log

実行中のアプリケーションのログを表示します。

fabric8:debug

リモートのデバッグを有効にします。

fabric8:watch

プロジェクトワークスペースで変更を監視し、アプリケーションの再デプロイメントを自動的にトリガーします。

C.4.2. 環境変数の設定

以下のように XML 設定に env パラメーターを追加して、1 つ以上の環境変数を設定できます。例を以下に示します。

<configuration>
  <resources>
    <env>
        <JAVA_OPTIONS>-Dmy.custom=option</JAVA_OPTIONS>
        <MY_VAR>value</MY_VAR>
    </env>
  </resources>
</configuration>

C.4.3. リソース検証設定

fabric8:resource ゴールは、Kubernetes および OpenShift の API 仕様を使用して、生成されたリソース記述子を検証します。

表C.3 リソース検証設定

設定説明デフォルト

fabric8.skipResourceValidation

値が true に設定されている場合、リソース検証はスキップされます。これは、何らかの理由でリソース検証に失敗してもデプロイメントを継続したい場合に便利です。

false

fabric8.failOnValidationError

値が true に設定されている場合、検証エラーによってプラグインの実行がブロックされます。true に設定されていない場合は警告が表示されます。

false

fabric8.build.switchToDeployment

値が true に設定され、OpenShift で ImageStreams を使用していない場合、fabric8-maven-plugin は DeploymentConfig ではなく Deployments に切り替わります。

false

fabric8.openshift.trimImageInContainerSpec

値が true に設定されている場合、コンテナーイメージ参照が "" に設定されます。これは、後続のロールアウトによって ImagePullErr が発生する OpenShift 3.7 での不適切な動作を処理するためのものです。

false

Fabric8 Maven プラグインゴールの詳細は「https://maven.fabric8.io/#goals」を参照してください。

C.5. ジェネレーター

Fabric8 Maven プラグインは、特定の種類のアプリケーションに対して自動的にイメージをビルドする機能がある、generator コンポーネントを提供します。Fuse on OpenShift では、以下のジェネレータータイプがサポートされます。

ジェネレーターフレームワークは、アプリケーションプロジェクトの特性に応じて、必要なビルドタイプを自動検出し、適切なジェネレーターコンポーネントを呼び出します。

注記

Fabric8 Maven プラグインのオープンソースコミュニティーバージョンは、追加のジェネレータータイプを提供しますが、これらのタイプは Fuse on OpenShift 製品ではサポートされません。

C.5.1. ゼロ設定

ジェネレーターには設定が必要ありません。ジェネレーターはデフォルトで有効になり、Fabric8 Maven プラグインが呼び出されると自動的にデフォルト設定で実行されます。しかし、必要な場合はジェネレーターの設定を簡単にカスタマイズできます。

C.5.2. ベースイメージを指定するモード

Fuse on OpenShift では、アプリケーションビルドのベースイメージは Java イメージ (Spring Boot アプリケーションの場合) または Karaf イメージ (Karaf アプリケーションの場合) のいずれかになります。Fabric8 Maven プラグインは、ベースイメージの指定に以下のモードをサポートします。

istag

(デフォルト): image stream は、OpenShift イメージストリームからタグ付けされたイメージを選択して動作します。この場合、ベースイメージは以下の形式で指定されます。

<namespace>/<image-stream-name>:<tag>

<namespace> は、イメージストリームが定義される OpenShift プロジェクトの名前に置き換えます (通常は openshift)。<image-stream-name> はイメージストリームの名前に置き換えます。<tag> はストリームの特定のイメージを識別します (またはストリームの最新イメージを追跡します)。

docker

docker モードは、イメージレジストリーから特定の Docker 形式イメージを選択して動作します。ベースイメージは直接リモートレジストリーから取得されるため、イメージストリームは必要ありません。この場合、ベースイメージは以下の形式で指定されます。

[<registry-location-url>/]<image-namespace>/<image-name>:<tag>

イメージ指定子は 任意で リモートイメージレジストリーの URL である <registry-location-url> で始まり、イメージ namespace <image-namespace>、イメージ名 <image-name>、およびタグ <tag> が続きます。

注記

オープンソースコミュニティーバージョンの fabric8-maven-plugin のデフォルト操作は Red Hat の製品化バージョンとは異なります。たとえば、コミュニティーバージョンのデフォルトモードは docker です。

C.5.2.1. istag モードのデフォルト値

デフォルトである istag モードが選択されている場合、Fabric8 Maven プラグインは以下のデフォルトイメージ指定子を使用して Fuse イメージを選択します (形式は <namespace>/<image-stream-name>:<tag> です)。

fuse7/fuse-eap-openshift:1.6
fuse7/fuse-java-openshift:1.6
fuse7/fuse-karaf-openshift:1.6
注記

Fuse イメージストリームでは、個別のイメージに 1.0-11.0-2 などのビルド番号がタグ付けされます。常に最新のイメージを追跡するよう、1.0 タグが設定されます。

C.5.2.2. docker モードのデフォルト値

docker モードが選択され、registry.redhat.io にアクセスするよう OpenShift 環境が設定されていることを仮定する場合、Fabric8 Maven プラグインは以下のデフォルトイメージ指定子を使用して Fuse イメージを選択します (形式は <image-namespace>/<image-name>:<tag> です)。

fuse7/fuse-eap-openshift:1.6
fuse7/fuse-java-openshift:1.6
fuse7/fuse-karaf-openshift:1.6

C.5.2.3. Spring Boot アプリケーションのモード設定

Spring Boot アプリケーションのビルドに使用されるモード設定とベースイメージの場所をカスタマイズするには、以下の形式で configuration 要素をアプリケーションの pom.xml ファイルにある fabric8-maven-plugin 設定に追加します。

<configuration>
  <generator>
    <config>
      <spring-boot>
        <fromMode>{istag|docker}</fromMode>
        <from>{image locations}</from>
      </spring-boot>
    </config>
  </generator>
</configuration>

C.5.2.4. Karaf アプリケーションのモード設定

Karaf アプリケーションのビルドに使用されるモード設定とベースイメージの場所をカスタマイズするには、以下の形式で configuration 要素をアプリケーションの pom.xml ファイルにある fabric8-maven-plugin 設定に追加します。

<configuration>
  <generator>
    <config>
      <karaf>
        <fromMode>{istag|docker}</fromMode>
        <from>{image locations}</from>
      </karaf>
    </config>
  </generator>
</configuration>

C.5.2.5. コマンドラインを使用したジェネレーターモードの指定

pom.xml ファイルで直接モードの設定をカスタマイズする代わりに、以下のプロパティー設定をコマンドライン呼び出しに追加し、モードの設定を直接 mvn コマンドに渡すことができます。

//build from Docker-formatted image directly, registry location, image name or tag are subject to change if desirable
-Dfabric8.generator.fromMode=docker
-Dfabric8.generator.from=<custom-registry-location-url>/<image-namespace>/<image-name>:<tag>

//to use ImageStream from different namespace
-Dfabric8.generator.fromMode=istag //istag is default
-Dfabric8.generator.from=<namespace>/<image-stream-name>:<tag>

C.5.3. Spring Boot

Spring Boot ジェネレーターは、pom.xml ファイルで spring-boot-maven-plugin を見つけるとアクティベートされます。生成されたコンテナーポートは application.properties ファイルの server.port プロパティーのから読み取られ、見つからない場合はデフォルトで 8080 になります。

このジェネレーターは一般的なジェネレーターオプションの他に、以下のオプションで設定することができます。

表C.4 Spring Boot 設定オプション

要素説明デフォルト

assemblyRef

アセンブリーへの参照が指定されている場合は、含めるアーティファクトの検出を行わずに使用されます。

 

targetDir

検出されたアーティファクトが配置される生成されたイメージ内のディレクトリー。ベースイメージも変更された場合のみ変更します。

/deployments

jolokiaPort

ベースイメージによって公開される Jolokia エージェントのポート。Jolokia ポートを公開したくない場合はこれを 0 に設定します。

8778

mainClass

呼び出すメインクラス。指定のない場合は次のようにジェネレーターがメインクラスを検索します。最初に、fat-jar を検出するためにチェックが実行されます。次に、main メソッドを持つ単一のクラスを探すために target/classes ディレクトリーがスキャンされます。何も見つからなかった場合や複数のクラスが見つかった場合は、ジェネレーターは何もしません。

 

webPort

サービスとして公開するポート。Web アプリケーションのポートであるはずです。ポートを公開しない場合はこれを 0 に設定します。

8080

color

設定されている場合、Spring Boot のコンソール出力で色を強制的に使用します。

 

ジェネレーターは、application.properties から読み取られた管理またはサーバーポートのいずれかを示す Kubernetes の liveness および readiness probe を追加します。server.ssl.key-store プロパティーが application.properties に設定されている場合、probe は https を使用するよう自動的に設定されます。

C.5.4. Karaf

Karaf ジェネレーターは、pom.xml ファイルで karaf-maven-plugin を見つけるとアクティベートされます。このジェネレーターは、一般的なジェネレーターオプションに加え、以下のオプションで設定が可能です。

表C.5 Karaf 設定オプション

要素説明デフォルト

baseDir

検出されたアーティファクトが配置される生成されたイメージ内のディレクトリー。ベースイメージも変更された場合のみ変更します。

/deployments

jolokiaPort

ベースイメージによって公開される Jolokia エージェントのポート。Jolokia ポートを公開したくない場合はこれを 0 に設定します。

8778

mainClass

呼び出すメインクラス。指定のない場合は次のようにジェネレーターがメインクラスを検索します。最初に、fat-jar を検出するためにチェックが実行されます。次に、main メソッドを持つ単一のクラスを探すために target/classes ディレクトリーがスキャンされます。何も見つからなかった場合や複数のクラスが見つかった場合は、ジェネレーターは何もしません。

 

user

ファイルを追加するユーザーやグループ。ベースイメージにユーザーがすでに存在している必要があります。通常の形式は <user>[:<group>[:<run-user>]]` です。ユーザーおよびグループは数値のユーザー id およびグループ id、または名前として指定することができます。グループ id は任意です。

jboss:jboss:jboss

webPort

サービスとして公開するポート。Web アプリケーションのポートであるはずです。ポートを公開しない場合はこれを 0 に設定します。

8080

付録D Fabric8 Camel Maven プラグイン

fabric8-camel-maven プラグインを使用して、ソースコードからすべての Camel エンドポイントを検証できます。これにより、Camel アプリケーションまたはユニットテストを実行する前にエンドポイントが有効であることを確認できます。

D.1. Fabric8 Camel Maven プラグインのゴール

ソースコードで Camel エンドポイントを検証するには、以下を使用します。

  • fabric8-camel:validate: このゴールは、Maven プロジェクトのソースコードを検証し、無効な Camel エンドポイント URI を到底します。

D.2. fabric8-camel-maven プラグインのプロジェクトへの追加

fabric8-camel-maven プラグインをプロジェクトに追加するには、fabric8-camel-maven プラグインをプロジェクトの pom.xml ファイルに追加します。

手順

  1. プラグインを有効にするには、以下を pom.xml ファイルに追加します。

    <plugin>
      <groupId>io.fabric8.forge</groupId>
      <artifactId>fabric8-camel-maven-plugin</artifactId>
      <version>2.3.90</version>
    </plugin>

    Note: fabric8-forge リリースの現在のバージョン番号を確認してください。最新のリリースは https://github.com/fabric8io/fabric8-forge/releases にあります。

  2. その後、ゴールの検証はコマンドラインまたは IDEA や Eclipse などの Java エディターから実行できます。

    mvn fabric8-camel:validate

プラグインの自動実行

プラグインを有効にしてビルドの一部として自動的に実行し、エラーを検出することも可能です。以下の例では、プラグインが実行されるタイミングがフェーズによって決定されます。この例では、メインのソースコードの完了後に実行される process-classes がフェーズです。

<plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.80</version>
  <executions>
    <execution>
      <phase>process-classes</phase>
    <goals>
      <goal>validate</goal>
    </goals>
    </execution>
  </executions>
</plugin>

テストソースコードの検証

Maven プラグインを設定して、テストソースコードを検証することもできます。以下のように process-test-classes のとおりにフェーズを変更します。

<plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.80</version>
  <executions>
    <execution>
      <configuration>
        <includeTest>true</includeTest>
      </configuration>
      <phase>process-test-classes</phase>
      <goals>
        <goal>validate</goal>
      </goals>
    </execution>
  </executions>
</plugin>

D.3. Maven プロジェクトでのゴールの実行

プラグインを pom.xml ファイルに追加せずに Maven プロジェクトでゴールの検証を実行することもできます。完全修飾名を使用してプラグインを指定する必要があります。

手順

  • Apache Camel から camel-example-cdi プラグインでゴールを実行する場合は、以下のコマンドを実行します。

        $cd camel-example-cdi
        $mvn io.fabric8.forge:fabric8-camel-maven-plugin:2.3.80:validate

    これにより、以下の出力が表示されます。

    [INFO] ------------------------------------------------------------------------
    [INFO] Building Camel :: Example :: CDI 2.16.2
    [INFO] ------------------------------------------------------------------------
    [INFO]
    [INFO] --- fabric8-camel-maven-plugin:2.3.80:validate (default-cli) @ camel-example-cdi ---
    [INFO] Endpoint validation success: (4 = passed, 0 = invalid, 0 = incapable, 0 = unknown components)
    [INFO] Simple validation success: (0 = passed, 0 = invalid)
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------

検証に成功した後、4 つのエンドポイントを検証できます。次の例は、Camel エンドポイントを検証し、必要な場合は修正する方法を表しています。

たとえば、ソースコードに以下のような Camel エンドポイント URI があるとします。

  1. Camel エンドポイント URI を以下のように修正します。

      @Uri("timer:foo?period=5000")
  2. period オプションに誤りが含まれるように、以下のような変更を加えます。

      @Uri("timer:foo?perid=5000")
  3. 再度、検証ゴールを実行します。

    [INFO] ------------------------------------------------------------------------
    [INFO] Building Camel :: Example :: CDI 2.16.2
    [INFO] ------------------------------------------------------------------------
    [INFO]
    [INFO] --- fabric8-camel-maven-plugin:2.3.80:validate (default-cli) @ camel-example-cdi ---
    [WARNING] Endpoint validation error at: org.apache.camel.example.cdi.MyRoutes(MyRoutes.java:32)
    
    	timer:foo?perid=5000
    
    	                   perid    Unknown option. Did you mean: [period]
    
    
    [WARNING] Endpoint validation error: (3 = passed, 1 = invalid, 0 = incapable, 0 = unknown components)
    [INFO] Simple validation success: (0 = passed, 0 = invalid)
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------

    上記のように、Camel エンドポイント URI のエラーが表示されます。

D.4. オプション

Maven プラグインは以下のオプションをサポートします。これらのオプションはコマンドラインから設定するか (-D 構文を使用)、<configuration> タグの pom.xml ファイルで定義します。

表D.1 Fabric8 Camel Maven プラグインのオプション

パラメーターデフォルト値説明

downloadVersion

true

インターネットからの Camel カタログバージョンのダウンロードを許可するかどうか。プロジェクトが使用する Camel バージョンがこのプラグインがデフォルトで使用する Camel バージョンと異なる場合に必要です。

failOnError

false

無効な Camel バージョンが見つかった場合に失敗するかどうか。デフォルトでは、WARN レベルでエラーがログに記録されます。

logUnparseable

false

解析不可能なため検証できないエンドポイント URI をログに記録するかどうか。

includeJava

true

無効な Camel エンドポイントについて検証される Java ファイルを含めるかどうか。

includeXML

true

無効な Camel エンドポイントについて検証される XML ファイルを含めるかどうか。

includeTest

false

テストソースコードを含めるかどうか。

includes

-

Java および xml ファイルの名前を絞り込み、指定されたパターンのリスト (ワイルドカードおよび正規表現) と一致するファイルのみが含まれるようにします。複数の値はコンマで区切ることができます。

excludes

-

Java および xml ファイルの名前を絞り込み、指定されたパターンのリスト (ワイルドカードおよび正規表現) と一致するファイルが除外されるようにします。複数の値はコンマで区切ることができます。

ignoreUnknownComponent

true

不明のなコンポーネントを無視するかどうか。

ignoreIncapable

true

エンドポイント URI の解析が不可能なことを無視するかどうか。

ignoreLenientProperties

true

lenient プロパティーを使用するコンポーネントを無視するかどうか。true の場合、URI の検証はより厳密になりますが、lenient プロパティーを使用するため、URI にあってもコンポーネントの一部でないプロパティーでは失敗することがあります。HTTP コンポーネントを使用してエイドポイント URI でクエリーパラメーターを提供する場合がこの例になります。

showAll

false

エンドポイントと簡単な式 (無効と有効の両方) をすべて表示するかどうか。

D.5. インクルードテストの検証

Maven プロジェクトがある場合、プラグインを実行して単体テストのソースコードでエンドポイントを検証することもできます。

手順

  • 以下のように -D スタイルを使用してオプションを渡すことができます。
    $cd myproject
    $mvn io.fabric8.forge:fabric8-camel-maven-plugin:2.3.80:validate -DincludeTest=true

付録E JVM 環境変数のカスタマイズ

JVM 環境変数を使用して、Fuse on OpenShift イメージのオプションをすべて設定できます。

E.1. OpenJDK 8 でのS2I Java ビルダーイメージの使用

S2I Java ビルダーイメージを使用すると、他のアプリケーションサーバーを使用せずに直接結果を実行できます。この S2I イメージは、フラットなクラスパス (fat jars を含む) を持つマイクロサービスに適しています。

Fuse on OpenShift イメージの使用時に Java オプションを設定できます。JVM オプションでは、JAVA_OPTIONS 環境変数を使用できます。また、アプリケーションに渡される引数には JAVA_ARGS を提供します。

E.2. OpenJDK 8 でのS2I Karaf ビルダーイメージの使用

Karaf4 カスタムアセンブリーベースの Maven プロジェクトをビルドするには、S2I Karaf ビルダーイメージを OpenShift の Source To Image ワークフローと使用します。

手順

  • 以下のコマンドを使用して、S2I ワークフローを使用します。
s2i build <git repo url> registry.redhat.io/fuse7/fuse-karaf-openshift:1.6 <target image name>
docker run <target image name>

E.2.1. Karaf4 アセンブリーの設定

Maven プロジェクトによってビルドされた Karaf4 アセンブリーの場所を提供する方法は複数あります。

  • 出力ディレクトリーのデフォルトのアセンブリーファイル *.tar.gz
  • sti または oc コマンドで -e flag を使用。
  • プロジェクトソース下の .sti/environment にある FUSE_ASSEMBLY プロパティーを設定。

E.2.2. Maven ビルドのカスタマイズ

Maven のビルドをカスタマイズすることが可能です。MAVEN_ARGS 環境変数を設定して、動作を変更できます。デフォルトでは、MAVEN_ARGS は以下のように設定されます。

`Karaf4: install karaf:assembly karaf:archive -DskipTests -e`

E.3. ビルド時の環境変数

ビルド中に、S2I Java および Karaf ビルダーイメージの動作に影響を与える環境変数を以下に示します。

  • MAVEN_ARGS: Maven の呼び出し時に使用する引数で、デフォルトのパッケージを置き換えます。
  • MAVEN_ARGS_APPEND: 追加の Maven引数で、-X-am-pl などの一時的な引数の追加に便利です。
  • ARTIFACT_DIR: マルチモジュールのビルドのために Jar ファイルが作成された target/ へのパス。これらは ${MAVEN_ARGS} に追加されます。
  • ARTIFACT_COPY_ARGS: アーティファクトを出力ディレクトリーからアプリケーションディレクトリーにコピーするときに使用する引数。イメージの一部になるアーティファクトを指定するのに便利です。
  • MAVEN_CLEAR_REPO: 設定すると、アーティファクトのビルド後に Maven リポジトリーが削除されます。これはアプリケーションイメージを小さく維持するのに便利ですが、インクリメンタルビルドを使用できません。デフォルト値は false です。

E.4. ランタイムの環境変数

以下の環境変数を使用して、実行スクリプトに影響を与えることができます。

  • JAVA_APP_DIR: アプリケーションがあるディレクトリー。アプリケーションのすべてのパスはこのディレクトリーを基準にした相対パスになります。
  • JAVA_LIB_DIR: このディレクトリーには、Java jar ファイルと、クラスパスが保持されるオプションのクラスパスファイルが含まれます。単一行のクラスパス (コロン区切り) または行ごとにリストされた jar ファイルのいずれかになります。設定のない場合は JAVA_LIB_DIRJAVA_APP_DIR ディレクトリーと同じになります。
  • JAVA_OPTIONS: Java の呼び出し時に追加するオプション。
  • JAVA_MAX_MEM_RATIO: JAVA_OPTIONS に -Xmx オプションがない場合に使用されます。これは、コンテナーの制限をベースにしてデフォルトの最大ヒープメモリーを算出するために使用されます。このオプションをコンテナーのメモリー制限がない Docker コンテナーで使用しても、何も影響はありません。
  • JAVA_MAX_CORE: ガベッジコレクタースレッドの数など、特定のデフォルトを算出するために使用される利用可能なコアの数を手動で制限します。0 に設定すると、コアの数を基にしてベース JVM のチューニングを行うことができません。
  • JAVA_DIAGNOSTICS: これを設定して、一部の診断情報を取得し、標準出力に送ります。
  • JAVA_MAIN_CLASS: Java の引数として使用するメインクラス。この環境変数を使用すると $JAVA_APP_DIR ディレクトリーのすべての jar ファイルがクラスパスと $JAVA_LIB_DIR ディレクトリーに追加されます。
  • JAVA_APP_JAR: java -jar で開始できるようにするための適切なマニフェストを持つ jar ファイル。ただし、指定がない場合は $JAVA_MAIN_CLASS が設定されます。すべての場合で jar ファイルはクラスパスに追加されます。
  • JAVA_APP_NAME: プロセスに使用する名前。
  • JAVA_CLASSPATH: 使用するクラスパス。指定の無い場合は起動スクリプトが ${JAVA_APP_DIR}/classpath ファイルを確認し、その内容をクラスパスとして使用します。このファイルが存在しない場合は、アプリケーションディレクトリーのすべての jar が (classes:${JAVA_APP_DIR}/*) 以下に追加されます。
  • JAVA_DEBUG: 設定するとリモートでのデバッグが有効になります。
  • JAVA_DEBUG_PORT: リモートでのデバッグに使用されるポート。デフォルト値は 5005 です。

E.5. Jolokia の設定

以下の環境を Jolokiaで使用できます。

  • AB_JOLOKIA_OFF: 設定した場合、Jolokia のアクティベートを無効にします (空の値をエコーします)。Jolokia はデフォルトで有効になっています。
  • AB_JOLOKIA_CONFIG: 設定した場合、ファイル (パスを含む) を Jolokia JVM エージェントプロパティーとして使用します。設定のない場合は、設定を使用して /opt/jolokia/etc/jolokia.properties が作成されます。
  • AB_JOLOKIA_HOST: バインドするホストアドレス (デフォルト値は 0.0.0.0)。
  • AB_JOLOKIA_PORT: 使用するポート (デフォルト値は 8778)。
  • AB_JOLOKIA_USER: Basic 認証に使用されます。デフォルトでは、jolokia になります。
  • AB_JOLOKIA_PASSWORD: Basic 認証のパスワード。デフォルトでは認証は無効になっています。
  • AB_JOLOKIA_PASSWORD_RANDOM: 値を生成し、/opt/jolokia/etc/jolokia.pw ファイルに書き込みます。
  • AB_JOLOKIA_HTTPS: HTTPS でセキュアな通信を有効にします。デフォルトでは、serverCert 設定が AB_JOLOKIA_OPTS に指定されていないと、自己署名サーバー証明書が生成されます。
  • AB_JOLOKIA_ID: 使用するエージェント ID。
  • AB_JOLOKIA_DISCOVERY_ENABLED: Jolokia の検出を有効にします。デフォルト値は false です。
  • AB_JOLOKIA_OPTS: エージェント設定に追加される追加のオプション。オプションは key=value の形式で指定されます。

以下は、さまざまな環境とのインテグレーションにおけるオプションになります。以下は、さまざまな環境とのインテグレーションにおけるオプションになります。

  • AB_JOLOKIA_AUTH_OPENSHIFT: OpenShift TSL 通信のクライアント認証を有効にします。このパラメーターの値がクライアント証明書に存在するようにしてください。このパラメーターを有効にすると、Jolokia が自動的に HTTPS 通信モードになります。デフォルトの CA 証明書は、/var/run/secrets/kubernetes.io/serviceaccount/ca.crt に設定されます。

JAVA_ARGS 変数を対応する値に設定すると、アプリケーションの引数を指定できます。

付録F JVM のチューニングによる Linux コンテナー内での実行

JVM エルゴノミクス による、ガベッジコレクター、ヒープサイズ、およびランタイムコンパイラーのデフォルト値の設定を許可すると、Linux コンテナー内部で実行している Java プロセスは想定どおりに動作しません。java -jar mypplication-fat.jar などのチューニングパラメーターを使用せずに Java アプリケーションを実行すると、JVM はコンテナーの制限ではなく、ホストの制限を基にして複数のパラメーターを自動的に設定します。

本セクションでは、コンテナーの制限を考慮してデフォルト値が算出されるよう、Linux コンテナー内部で Java アプリケーションをパッケージ化するための情報を提供します。

F.1. JVM のチューニング

現在の Java JVM はコンテナー対応でないため、コンテナーのサイズではなく、物理ホストのサイズを基にしてリソースを割り当てます。たとえば、通常 JVM は最大ヒープサイズを、ホスト上の物理メモリーの 1/4 に設定します。大型のホストマシンでは、この値はコンテナーに定義されたメモリー制限を簡単に越えてしまいます。実行時にコンテナー制限を越えてしまうと、OpenShift はアプリケーションを強制終了します。

この問題に対応するには、Java JVM が制限されたコンテナー内で実行されることを認識でき、かつ最大ヒープサイズが手動で調整されない場合は自動的に調整されることを認識できる、Fuse on OpenShift ベースのイメージを使用します。これにより、アプリケーションを実行する JVM の最大メモリー制限とコア制限を設定できます。Fuse on OpenShift イメージは以下を行うことができます。

  • コンテナーのコアを基にした CICompilerCount の設定。
  • コンテナーメモリー制限が 300MB 未満の場合に C2 JIT コンパイラーを無効にする。
  • コンテナーメモリー制限が 300MB 未満の場合に、コンテナーメモリー制限の 1/4 をデフォルトのヒープサイズに使用する。

F.2. Fuse on OpenShift イメージ のデフォルト動作

Fuse on OpenShift では、アプリケーションビルドのベースイメージは Java イメージ (Spring Boot アプリケーションの場合) または Karaf イメージ (Karaf アプリケーションの場合) のいずれかになります。Fuse on OpenShift イメージはコンテナー制限を読み取るスクリプトを実行し、その制限をリソース割り当てのベースとして使用します。デフォルトでは、スクリプトは以下のリソースを JVM に割り当てます。

  • コンテナーメモリー制限の 50%
  • コンテナーコア制限の 50%

これには一部の例外があります。Karaf と Java イメージでは、物理メモリーが 300MB のしきい値未満になると、ヒープサイズはデフォルトの半分ではなく、1/4 に回復されます。

F.3. Fuse on OpenShift イメージのカスタムチューニング

スクリプトは、内部リソースをチューニングするためにカスタムアプリケーションによって読み取られる CONTAINER_MAX_MEMORY および CONTAINER_CORE_LIMIT 環境変数を設定します。さらに、アプリケーションを実行する JVM の設定をカスタマイズ可能にする以下のランタイム環境変数を指定できます。

  • JAVA_OPTIONS
  • JAVA_MAX_MEM_RATIO

制限を明示的にカスタマイズするには、Maven プロジェクトで JAVA_MAX_MEM_RATIO ファイルを編集し、deployment.yml 環境変数を設定します。

spec:
  template:
    spec:
      containers:
        -
          resources:
            requests:
              cpu: "0.2"
               memory: 256Mi
            limits:
              cpu: "1.0"
               memory: 256Mi
          env:
          - name: JAVA_MAX_MEM_RATIO
            value: 60

F.4. サードパーティーライブラリーのチューニング

Red Hat は、Jetty などのサードパーティー Java ライブラリーの制限をカスタマイズすることを推奨します。このようなライブラリーは、制限を手作業でカスタマイズしないと、指定のデフォルト制限を使用します。起動スクリプトは、アプリケーションが使用できるコンテナー制限を記述する一部の環境変数を公開します。

CONTAINER_CORE_LIMIT
算出されたコア制限
CONTAINER_MAX_MEMORY
コンテナーに指定されたメモリー制限

法律上の通知

Copyright © 2021 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.