検索

Fuse on OpenShift ガイド

download PDF
Red Hat Fuse 7.4

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

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 イメージストリームおよびテンプレートをそれぞれ Skipped Imagestreams および 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-fuse74-eap-camel-amq
      - s2i-fuse74-eap-camel-cdi
      - s2i-fuse74-eap-camel-cxf-jaxrs
      - s2i-fuse74-eap-camel-cxf-jaxws
      - s2i-fuse74-eap-camel-jpa
      - s2i-fuse74-karaf-camel-amq
      - s2i-fuse74-karaf-camel-log
      - s2i-fuse74-karaf-camel-rest-sql
      - s2i-fuse74-karaf-cxf-rest
      - s2i-fuse74-spring-boot-camel
      - s2i-fuse74-spring-boot-camel-amq
      - s2i-fuse74-spring-boot-camel-config
      - s2i-fuse74-spring-boot-camel-drools
      - s2i-fuse74-spring-boot-camel-infinispan
      - s2i-fuse74-spring-boot-camel-rest-sql
      - s2i-fuse74-spring-boot-camel-xa
      - s2i-fuse74-spring-boot-camel-xml
      - s2i-fuse74-spring-boot-cxf-jaxrs
  7. Fuse on OpenShift イメージストリームをインストールします。

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

    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-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.fuse-740025-redhat-00003/quickstarts/${template}
     done
  9. Fuse Console のテンプレートをインストールします。

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

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

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

    oc get template -n openshift

2.3. OpenShift 4.x サーバーでの Apicurito Operator のインストール

Red Hat Fuse on OpenShift は、REST API の設定に使用できる Web ベースの API デザイナーである Apicurito を提供します。新しい Apicurito Operator は、OpenShift Container Platform 4.1 でのインストールおよびアップグレードを簡単にします。Fuse 7.4 では、Apicurito Operator は OperatorHub で利用できます。以下の手順にしたがって、Operator をインストールします。

前提条件

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

手順

  1. OpenShift 4.x サーバーを起動します。
  2. ブラウザーで OpenShift コンソールに移動します。ご自分のクレデンシャルでコンソールにログインします。
  3. Catalog をクリックした後、OperatorHub をクリックします。
  4. 検索フィールドウインドウに Apicurito と入力し、Enter キーを押します。右側のパネルに Apicurito Operator が表示されます。
  5. Apicurito Operator をクリックします。Apicurito Operator インストールウインドウが表示されます。
  6. Install をクリックします。Create Operator Subscription フォームが表示されます。このフォームには以下のオプションがあります。

    • Installation mode (インストールモード)
    • Update Channel (更新チャネル)
    • Approval Strategy (承認ストラテジー)

      デフォルト値をそのまま使用するか、希望の値を選択します。

  7. Subscribe をクリックします。Apicurito Operator が選択した namespace にインストールされます。
  8. 確認するには、Catalog をクリックした後、Installed Operator をクリックします。リストに Apicurito Operator が表示されます。
  9. Name 列の Apicurito Operator をクリックします。Provided APIs 以下の Create New をクリックします。新しい CRD (Custom Resource Definition) がデフォルト値で作成されます。以下のフィールドは CR の一部としてサポートされます。

    • size: Apicurito Operator が持つ Pod の数。
    • image: Apicurito イメージ。既存のインストールでこのイメージを変更すると、Operator のアップグレードがトリガーされます。
  10. Create をクリックします。これにより新しい apicurito-service が作成されます。

2.4. 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.fuse-740025-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-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.fuse-740025-redhat-00003/quickstarts/${template}
     done
  6. Fuse Console のテンプレートをインストールします。

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

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

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

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

    oc get template -n openshift

第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.fuse-740025-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-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. 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 の設定」を参照してください。

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

    oc get template -n test
  7. ブラウザーで 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.4 がサポートするバージョンの Java がインストールされているようにしてください。サポートされる Java バージョンの詳細は「Red Hat Fuse でサポートされる構成 」を参照してください。

手順

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

  1. Fuse on OpenShift では、バージョン 3.9 の CDK をインストールすることが推奨されます。CDK 3.9 をインストールおよび使用するための詳細手順は『Red Hat CDK 3.9 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.9 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.9『Getting Started Guide』の「Using the OpenShift Client Binary」を参照してください。

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

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

    詳細は、CDK 3.9 『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 3.5 Developer Guide』の「Binary Source」を参照してください。
S2I ソースワークフロー
ビルド入力が Git ソース からの S2I です。このワークフローの特徴は、ビルドがすべて OpenShift サーバー上でビルドされることです。詳細は『OpenShift 3.5 Developer Guide』の「Git Source」を参照してください。

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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003

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

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :

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

  2. 前のコマンドが BUILD SUCCESS 状態で終了した場合、fuse74-spring-boot サブディレクトリー内に新しい Fuse on OpenShift プロジェクトが作成されているはずです。XML DSL コードは fuse74-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. 以下のコマンドを実行し、Fuse on OpenShift イメージおよびテンプレートがすでにインストールされ、アクセス可能であることを確認します。

    oc get template -n openshift

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

  5. 以下のように、test という名前のプロジェクト namespace を作成します。

    oc new-project test

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

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

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

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

    ...
    [INFO] OpenShift platform detected
    [INFO] Using project: test
    [INFO] Creating a Service from openshift.yml namespace test name fuse74-spring-boot
    [INFO] Created Service: target/fabric8/applyJson/test/service-fuse74-spring-boot.json
    [INFO] Using project: test
    [INFO] Creating a DeploymentConfig from openshift.yml namespace test name fuse74-spring-boot
    [INFO] Created DeploymentConfig: target/fabric8/applyJson/test/deploymentconfig-fuse74-spring-boot.json
    [INFO] Creating Route test:fuse74-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-02-22T12:08:11+01:00
    [INFO] Final Memory: 63M/272M
    [INFO] ------------------------------------------------------------------------
    注記

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

  7. ブラウザーで OpenShift コンソールに移動し、クレデンシャル (例: ユーザー名 developer およびパスワード developer) を使用してコンソールにログインします。
  8. OpenShift コンソールで下方向にスクロールし、test プロジェクト namespace を見つけます。test プロジェクトをクリックして test プロジェクト namespace を開きます。test プロジェクトの Overview タブが開き、fuse74-spring-boot アプリケーションが表示されます。
  9. fuse74-spring-boot デプロイメントの左にある矢印をクリックし、このデプロイメントの詳細を展開および表示します。

    OpenShift console test namespace overview showing fuse74-spring-boot application and associated pods

  10. Pod アイコン (青い円) の中心をクリックし、fuse74-spring-boot の Pod のリストを表示します。

    List of pods associated with the fuse74-spring-boot service

  11. Pod の Name (この例では fuse74-spring-boot-1-kxdjm) をクリックし、稼働中の Pod の詳細を表示します。

    Detail view of the running pod for fuse74-spring-boot

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

    ...
    07:30:32.406 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 985
    07:30:34.405 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 741
    07:30:36.409 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 796
    07:30:38.409 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 211
    07:30:40.411 [Camel (camel) thread #0 - timer://foo] INFO  simple-route - >>> 511
    07:30:42.411 [Camel (camel) thread #0 - timer://foo] INFO simple-route - >>> 942
  13. 左側のナビゲーションバーにある Overview をクリックし、test namespace のアプリケーション概要に戻ります。実行中の Pod をシャットダウンするには、Pod アイコンの横にある下矢印 get started s2i binary 05 をクリックします。Scale down deployment fuse74-spring-boot-1? というダイアログが表示されたら、Scale Down をクリックします。
  14. (任意): CDK を使用している場合は、シェルプロンプトに戻り、以下のコマンドを入力すると、仮想 OpenShift サーバーを完全にシャットダウンすることができます。

    minishift stop

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

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

手順

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

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

    mvn fabric8:undeploy
    mvn fabric8:deploy -Popenshift

4.2.3. OpenShift での Fuse Console の設定

OpenShift では、Fuse Console にアクセスする方法は 2 つあります。

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

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

注記
  • OpenShift 4 で Fuse Console で Fuse 7.4 サービスを管理する場合、『7.4 リリースノート』の説明にしたがって、コミュニティーバージョン (Hawtio) をインストールする必要があります。
  • Fuse Console のセキュリティーおよびユーザー管理は、OpenShift によって処理されます。
  • Fuse Console のテンプレートは、デフォルトでエンドツーエンド暗号化を設定するため、Fuse Console のリクエストはブラウザーからクラスター内のサービスまでエンドツーエンドでセキュア化されます。
  • ロールベースアクセス制御 (デプロイ後に Fuse Console にアクセスするユーザーの場合) は現在 Fuse on OpenShift では使用できません。

前提条件

  • Fuse on OpenShift ガイド』の説明にしたがって、Fuse Console の Fuse on OpenShift イメージストリームおよびテンプレートをインストールする必要があります。
  • Fuse Console をクラスターモードで OpenShift Container Platform 環境にデプロイする場合、クラスター管理者ロールとクラスターモードテンプレートが必要です。以下のコマンドを実行します。
oc adm policy add-cluster-role-to-user cluster-admin system:serviceaccount:openshift-infra:template-instance-controller
注記

クラスターモードテンプレートは、デフォルトでは OpenShift Container Platform の最新バージョンでのみ利用できます。OpenShift Online のデフォルトカタログでは提供されません。

4.2.3.1. Fuse Console からの単一 Fuse Pod の監視

OpenShift で実行している 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"
              }
4.2.3.2. OpenShift Console からの Fuse Console のデプロイ

OpenShift 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 にアプリケーションが表示されます。

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

表4.1「Fuse Console テンプレート」 は、Fuse アプリケーションのデプロイメントのタイプに応じて、コマンドラインから Fuse Console へのアクセスに使用できる 2 つの OpenShift テンプレートについて説明しています。

表4.1 Fuse Console テンプレート
タイプ説明

cluster

クラスター管理者ロールの作成を必要とする OAuth クライアントを使用します。Fuse Console は、複数の namespace またはプロジェクトにまたがってデプロイされた Fuse アプリケーションを検出し、接続することができます。

namespace

プロジェクトでの管理者ロールの作成のみを必要とする、サービスアカウントを OAuth クライアントとして使用します。これにより、Fuse Console のこの単一プロジェクトへのアクセスが制限されるため、単一テナントのデプロイメントとして動作します。

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

oc process --parameters -f https://raw.githubusercontent.com/jboss-fuse/application-templates/application-templates-2.1.fuse-740025-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.fuse-740025-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.fuse-740025-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) を使用します。
4.2.3.4. Fuse Console でデータが正しく表示されるよう確認

Fuse Console のキューおよびコネクションの表示で、不足しているキューやコネクションがあったり、一貫性のないアイコンが表示される場合、Jolokia が応答でマーシャルするアレイの要素の最大数を指定する、Jolokia コレクションサイズパラメーターを調節します。

手順

  1. Fuse Console の右上隅にあるユーザーアイコンをクリックして、Preferences をクリックします。

    mf preferences

  2. Maximum collection size オプションの値を大きくします (デフォルトは 50,000)。
  3. Close をクリックします。

4.2.4. S2I ソースワークフローを使用したプロジェクトの作成およびデプロイ

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

手順

  1. ブラウザーで https://OPENSHIFT_IP_ADDR:8443 の OpenShift コンソールに移動します (OPENSHIFT_IP_ADDRは CDK の場合で表示された IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名 developer、パスワード developer) を使用して、コンソールにログインします。
  2. カタログ検索フィールドに Red Hat Fuse 7.4 Camel XML を検索文字列として入力し、Red Hat Fuse 7.4 Camel XML DSL with Spring Boot テンプレートを選択します。

    get started s2i source 01

  3. テンプレートウィザードの Information ステップが開きます。Next をクリックします。
  4. 以下のように、テンプレートウィザードの Configuration ステップが開きます。Add to Project ドロップダウンメニューで My Project を選択します。

    注記

    この例で新しいプロジェクトを作成したい場合は、上記の手順の代わりに Add to Project ドロップダウンメニューで Create Project を選択します。新規プロジェクトの名前を入力する Project Name フィールドが表示されます。

  5. Configuration ステップの残りの設定では、デフォルトの値を使用します。Create をクリックします。

    get started s2i source 02

    注記

    クイックスタートをそのまま実行せずに、アプリケーションコードを変更する場合は、元のクイックスタート Git リポジトリーをフォークし、Git Repository URL および Git Reference フィールドに適切な値を入力する必要があります。

  6. テンプレートウィザードの Results ステップが開きます。Close をクリックします。
  7. 右側の My Projects ペインで My Project をクリックします。My Project プロジェクトの Overview タブが開き、s2i-fuse74-spring-boot-camel-xml アプリケーションが表示されます。
  8. s2i-fuse74-spring-boot-camel-xml デプロイメントの左にある矢印をクリックし、以下のようにこのデプロイメントの詳細を展開および表示します。

    get started s2i source 03

  9. このビューにビルドログが表示されます。何らかの理由でビルドに失敗した場合は、ビルドログを参照して問題を診断します。

    注記

    リモートの Maven リポジトリーから多くの依存関係をダウンロードする必要があるため、ビルドが完了するまで数分かかることがあります。ビルド時間を短縮するには、ローカルネットワークに Nexus サーバーをデプロイすることが推奨されます。

  10. ビルドが正常に完了したら、Pod アイコンは 1 つの Pod が実行している青い円で表示されます。Pod アイコン (青い円) の中心をクリックし、s2i-fuse74-spring-boot-camel-xml の Pod のリストを表示します。

    注記

    複数の Pod が実行されている場合、この時点では実行中の Pod のリストが表示されます。1 つの Pod のみが実行されている場合は、実行中の Pod の詳細ビューが表示されます。

  11. Pod 詳細ビューが開きます。Logs タブをクリックしてアプリケーションログを表示し、ログを下方向にスクロールして、Camel アプリケーションによって生成されたログメッセージを見つけます。

    Details view of the running pod

  12. 左側のナビゲーションバーにある Overview をクリックし、My Project namespace のアプリケーション概要に戻ります。実行中の Pod をシャットダウンするには、Pod アイコンの横にある下矢印 get started s2i binary 05 をクリックします。Scale down deployment s2i-fuse74-spring-boot-camel-xml-1? というダイアログが表示されたら、Scale Down をクリックします。
  13. (任意): CDK を使用している場合は、シェルプロンプトに戻り、以下のコマンドを入力すると、仮想 OpenShift サーバーを完全にシャットダウンすることができます。

    minishift stop

第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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-xml-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003

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

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-spring-boot
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-spring-boot
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :

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

  3. サンプルのビルドおよびデプロイ方法については、クイックスタートの手順にしたがいます。
注記

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

5.2. 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.3. 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-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.4. 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.4.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.4.0.fuse-sb2-740019-redhat-00005</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.4.0.fuse-740036-redhat-00002</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.5. 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.4.0.fuse-740036-redhat-00002</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

6.1. Camel Spring Boot について

Camel Spring Boot コンポーネントは、Apache Camel の自動設定を提供します。Camel コンテキストの自動設定は、Spring コンテキストで使用できる Camel ルートを自動検出し、プロデューサーテンプレート、コンシューマーテンプレート、タイプコンバーターなどの主な Camel ユーティリティーを Bean として登録します。

Camel Spring Boot アプリケーションはすべて製品化バージョンで dependencyManagement を使用する必要があります。詳細はクイックスタートの pom を参照してください。BOM のバージョンをオーバーライドしないように、後でタグが付けられたバージョンを省略することができます。

<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 スターターについて

Apache Camel には、スターターを使用して Spring Boot アプリケーションを開発できる、Spring Boot スターターモジュールが含まれています。

注記

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

スターターを使用するには、以下のスニペットを Spring Boot の pom.xml ファイルに追加します。

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

スターターを使用すると、以下のスニペットのように、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");
    }
}

application.properties または application.yml ファイルの Camel アプリケーションをカスタマイズできます。 

Camel Spring Boot は、Camel スターターコンポーネントのいずれかを設定するときに、設定ファイル (application.properties または yaml ファイル)の ID 名による Bean の参照をサポートするようになりました。src/main/resources/application.properties (または yaml) ファイルで、Bean の ID 名を参照して他の Bean を参照する Camel のオプションを簡単に設定できるようになりました。たとえば、以下のように Bean ID を使用すると、xslt コンポーネントはカスタム Bean を参照できます。

以下のように、ID「myExtensionFactory」でカスタム Bean を参照します。

camel.component.xslt.saxon-extension-functions=myExtensionFactory

以下のように、Spring Boot @Bean アノテーションを使用して作成します。

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

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

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

6.3. 自動設定された Camel コンテキスト

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

たとえば、以下のように camelContext にアクセスできます。

@Configuration
public class MyAppConfig {

  @Autowired
  CamelContext camelContext;

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

}

6.4. Camel ルートの自動検出

Camel の自動設定は、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.5. Camel プロパティー

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

これらのプロパティーは application.properties ファイルで定義されます。 

route.from = jms:invoices

システムプロパティーとしての使用

java -Droute.to=jms:processed.invoices -jar mySpringApp.jar

Camel ルートのプレースホルダーとしての使用

@Component
public class MyRouter extends RouteBuilder {

  @Override
  public void configure() throws Exception {
    from("{{route.from}}").to("{{route.to}}");
  }

}

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

Camel 自動設定によって作成された CamelContext Bean で操作を実行するには、以下のように 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.7. JMX の無効化

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

たとえば、以下のプロパティーを application.properties ファイルに追加します。

camel.springboot.jmxEnabled = false

6.8. 自動設定されたコンシューマーおよびプロデューサーのテンプレート

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.9. 自動設定された 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.10. 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.11. タイプ変換機能の無効化

TypeConverter インスタンスや Spring ブリッジなど、Camel Spring Boot のタイプ変換機能の登録を無効にするには、以下のように camel.springboot.typeConversion プロパティーを false に設定します。

camel.springboot.typeConversion = false

6.12. XML ルートの追加

デフォルトでは、camel-spring-boot によって自動検出され、含まれる camel ディレクトリー下のクラスパスに Camel XML ルートを配置することができます。Camel バージョン 2.17 以降では、以下のように設定オプションを使用して、ディレクトリー名を設定したり、この機能を無効にすることができます。

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

XML ファイルは、以下のような CamelContext ではなく Camel XML ルートである必要があります。

   <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>

<camelContext> と Spring XML ファイルを使用する場合、Camel を Spring XML ファイルおよび application.properties ファイルで設定できます。たとえば、Camel に名前を設定し、ストリームキャッシュを有効にするには、以下を追加します。

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

6.13. XML RestーDSL の追加

デフォルトでは、camel-spring-boot によって自動検出され、含まれる camel-rest ディレクトリー下のクラスパスに Camel 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 XML ファイルは、以下のように CamelContext ではなく Camel XML rest である必要があります。

   <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.14. Camel Spring Boot でのテスト

Spring Boot で実行している Camel の場合、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 よりも優先されます。

以下のように、@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 で始まる必要があることを意味します。以下の Maven コマンドを使用してテストを実行できます。

mvn test -Dtest=FooTest

6.15. その他の参考資料

第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 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. 依存関係をインストールします。

    • ユーザー名 postgresql とパスワード theuser を使用して、OpenShift カタログから Thepassword1! をインストールします。
    • ユーザー名 theuser とパスワード Thepassword1! を使用して、OpenShift カタログから A-MQ ブローカーをインストールします。
  6. 準備済みステートメントを許可するよう、Postgresql データベースを変更します。

    oc env dc/postgresql POSTGRESQL_MAX_PREPARED_TRANSACTIONS=100
  7. トランザクションログの永続ボリュームクレームを作成します。

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

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

    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 として適用されます (「ー」などの一部の文字の削除後)。
  10. クイックスタートが実行されたら、以下のコマンドを使用してベースサービス 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 クイックスタートのビルドおよびデプロイ

この例では、JBoss A-MQ 6 イメージとデプロイメントテンプレートが必要になります。CDK 3.1.1+ を使用する場合、JBoss AM-Q 6 イメージおよびテンプレートはすでにデフォルトで openshift namespace にインストールされているはずです。

前提条件

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

手順

  1. クイックスタートをビルドおよびデプロイするために準備します。

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

      oc login -u developer -p developer
    2. 新しいプロジェクト amq-quickstart を作成します。

      oc new-project amq-quickstart
    3. インストールした AーMQ 6 イメージおよびテンプレートのバージョンを確認します。

      $ oc get template -n openshift

      amqXX-basic という名前のテンプレートが見つかるはずです。XX は、OpenShift にインストールされた AーMQ のバージョンになります。

  2. A-MQ 6 イメージを amq-quickstart namespace にデプロイします。XX は、前のステップで確認した AーMQ の実際のバージョンに置き換えます。

    $ oc process openshift//amqXX-basic -p APPLICATION_NAME=broker -p MQ_USERNAME=admin -p MQ_PASSWORD=admin -p MQ_QUEUES=test -p MQ_PROTOCOL=amqp -n amq-quickstart | oc create -f -
    注記

    古いバージョンの oc を使用すると、oc コマンドが失敗することがあります。この構文は、oc のバージョン 3.5.x (Kubernetes 1.5.x がベース) で動作します。

  3. メッシュエンドポイントの検出に必要なユーザーロールを追加します (Kubernetes REST API 経由)。

    $ oc policy add-role-to-user view system:serviceaccount:amq-quickstart:default
  4. 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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
    -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
    -DarchetypeArtifactId=spring-boot-camel-amq-archetype \
    -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
  5. archetype プラグインが対話モードに切り替わり、残りのフィールドの入力を要求されます。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-spring-boot-camel-amq
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-spring-boot-camel-amq
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :

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

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

    $ cd fuse74-spring-boot-camel-amq
  7. ACTIVEMQ_BROKER_USERNAME および ACTIVEMQ_BROKER_PASSWORD 環境変数を設定して、ブローカーにログインするためのクライアントクレデンシャルをカスタマイズします。fuse74-spring-boot-camel-amq プロジェクトで、以下のように src/main/fabric8/deployment.yml ファイルを編集します。

    spec:
      template:
        spec:
          containers:
            -
              resources:
                requests:
                  cpu: "0.2"
    #              memory: 256Mi
                limits:
                  cpu: "1.0"
    #              memory: 256Mi
              env:
              - name: AMQP_HOST
                value: broker-amq-amqp
              - name: SPRING_APPLICATION_JSON
                value: '{"server":{"undertow":{"io-threads":1, "worker-threads":2 }}}'
              - name: AMQP_USERNAME
                value: admin
              - name: AMQP_PASSWORD
                value: admin
  8. mvn コマンドを実行し、クイックスタートを OpenShift サーバーにデプロイします。

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

    1. OpenShift コンソールに移動します。
    2. プロジェクト amq-quickstart を選択します。
    3. Applications をクリックします。
    4. Pods を選択します。
    5. fis-spring-boot-camel-am-1-xxxxx をクリックします。
    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
  10. Web インターフェースでルートを表示するには、Open Java Console をクリックし、A-MQ キューのメッセージをチェックします。

第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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=spring-boot-camel-config-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003

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

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-configmap
    Define value for property 'version':  1.0-SNAPSHOT: :
    Define value for property 'package':  org.example.fis: :
    [INFO] Using property: spring-boot-version = 1.5.17.RELEASE
    Confirm properties configuration:
    groupId: org.example.fis
    artifactId: fuse74-configmap
    version: 1.0-SNAPSHOT
    package: org.example.fis
    spring-boot-version: 1.5.17.RELEASE
     Y: :

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

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

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

    oc create -f sample-secret.yml
    注記

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

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

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

    1. ブラウザーで OpenShift コンソールを開き、該当するプロジェクト namespace を選択します (例: test)。
    2. fuse74-configmap サービスの円形 Pod アイコンの中心をクリックします。
    3. Pods ビューで Name Pod をクリックし、実行中の Pod の詳細を表示します (1 つの Pod のみが実行中である場合は直接詳細ページが表示されます)。
    4. Logs タグをクリックしてアプリケーションログを表示し、下方向にスクロールして Camel アプリケーションによって生成されたログメッセージを見つけます。
  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 オブジェクトを使用して fuse74-configmap アプリケーションの設定を更新する前に、OpenShift ApiServer からデータを確認するパーミッションを fuse74-configmap アプリケーションに付与する必要があります。以下のコマンドを入力し、fuse74-configmap アプリケーションのサービスアカウントに view パーミッションを付与します。

    oc policy add-role-to-user view system:serviceaccount:test: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 クラス

fuse74-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 というプロパティーの適用

ほとんどの場合で個々のプロパティーは適切に動作しますが、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 というプロパティーの適用

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 リロード設定プロパティー

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

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-740017-redhat-00003/archetypes-catalog-2.2.0.fuse-740017-redhat-00003-archetype-catalog.xml \
      -DarchetypeGroupId=org.jboss.fuse.fis.archetypes \
      -DarchetypeArtifactId=karaf-camel-log-archetype \
      -DarchetypeVersion=2.2.0.fuse-740017-redhat-00003
  3. archetype プラグインは対話モードに切り替わり、残りのフィールドを追加するよう要求します。

    Define value for property 'groupId': : org.example.fis
    Define value for property 'artifactId': : fuse74-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: fuse74-karaf-camel-log
    version: 1.0-SNAPSHOT
    package: org.example.fis
     Y: :

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

  4. サンプルのビルドおよびデプロイ方法については、クイックスタートの手順にしたがいます。
注記

使用できる 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 の設定管理サポートの追加

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

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

手順

  • プロジェクトの 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. ブラウザーで https://OPENSHIFT_IP_ADDR:8443 の OpenShift コンソールに移動します (OPENSHIFT_IP_ADDRは CDK の場合で表示された IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名 developer、パスワード developer) を使用して、コンソールにログインします。
  3. カタログ検索フィールドに検索文字列として Red Hat Fuse 7.4 Camel CDI with EAP を入力し、Red Hat Fuse 7.4 Camel CDI with EAP テンプレートを選択します。

    eap image s2i source 01
  4. テンプレートウィザードの Information ステップが開きます。Next をクリックします。
  5. テンプレートウィザードの Configuration ステップが開きます。Add to Project ドロップダウンメニューで My Project を選択します。

    注記

    この例で新しいプロジェクトを作成したい場合は、上記の手順の代わりに Add to Project ドロップダウンメニューで Create Project を選択します。新規プロジェクトの名前を入力する Project Name フィールドが表示されます。

  6. Configuration ステップの残りの設定では、デフォルトの値を使用します。Create をクリックします。

    注記

    クイックスタートをそのまま実行せずに、アプリケーションコードを変更する場合は、元のクイックスタート Git リポジトリーをフォークし、Git Repository URL および Git Reference フィールドに適切な値を入力する必要があります。

  7. テンプレートウィザードの Results ステップが開きます。Close をクリックします。
  8. 右側の My Projects ペインで My Project をクリックします。My Project プロジェクトの Overview タブが開き、s2i-fuse74-eap-camel-cdi アプリケーションが表示されます。
  9. s2i-fuse74-eap-camel-cdi デプロイメントの左にある矢印をクリックし、このデプロイメントの詳細を展開および表示します。

    eap image s2i source 02

  10. このビューにビルドログが表示されます。何らかの理由でビルドに失敗した場合は、ビルドログを参照して問題を診断します。

    eap image s2i source 03

    注記

    リモートの Maven リポジトリーから多くの依存関係をダウンロードする必要があるため、ビルドが完了するまで数分かかることがあります。ビルド時間を短縮するには、ローカルネットワークに Nexus サーバーをデプロイすることが推奨されます。

  11. ビルドが正常に完了したら、Pod アイコンは 1 つの Pod が実行している青い円で表示されます。

    Link to the running application

  12. アプリケーションを開くには、アプリケーションの詳細の上に表示される、http://s2i-fuse74-eap-camel-cdi-myproject.IP_ADDRESS.nip.io/ 形式のリンクをクリックします。これにより、ブラウザーで以下のようなメッセージが表示されます。

    Hello world from 172.17.0.3

    URL の name パラメーターを使用して名前を指定することもできます。たとえば、ブラウザーに URL http://s2i-fuse74-eap-camel-cdi-myproject.IP_ADDRESS.nip.io/?name=jdoe を入力すると、以下のような応答が表示されます。

    Hello jdoe from 172.17.0.3
  13. 左側のナビゲーションバーにある Overview をクリックし、My Project namespace のアプリケーション概要に戻ります。実行中の Pod をシャットダウンするには、Pod アイコンの横にある下矢印 get started s2i binary 05 をクリックします。Scale down deployment s2i-fuse74-eap-camel-cdi-1? というダイアログが表示されたら、Scale Down をクリックします。
  14. (任意): CDK を使用している場合は、シェルプロンプトに戻り、以下のコマンドを入力すると、仮想 OpenShift サーバーを完全にシャットダウンすることができます。

    minishift stop

11.2. JBoss EAP アプリケーションの構造

Red Hat Fuse 7.4 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.4 Camel A-MQ with EAP (eap-camel-amq-template)

camel-activemq コンポーネントを使用して、OpenShift 上で実行している AMQ メッセージブローカーに接続します。ブローカーがすでにデプロイされていることを前提とします。

Red Hat Fuse 7.4 Camel CDI with EAP (eap-camel-cdi-template)

camel-cdi コンポーネントを使用して、CDI Bean を Camel ルートに統合します。

Red Hat Fuse 7.4 CXF JAX-RS with EAP (eap-camel-cxf-jaxrs-template)

camel-cxf コンポーネントを使用して JAX-RS REST サービスを作成および消費します。

Red Hat Fuse 7.4 CXF JAX-WS with EAP (eap-camel-cxf-jaxws-template)

camel-cxf コンポーネントを使用して JAX-WS Web サービスを作成および消費します。

Red Hat Fuse 7.4 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            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           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            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            About an hour ago...
    fuse-apicurito-generator         172.30.1.1:5000/openshift/fuse-apicurito-generator       1.2,1.3,1.4                    About an hour ago...
    apicurito-ui                     172.30.1.1:5000/openshift/apicurito-ui                   1.2,1.3,1.4                    About an hour ago...
  2. 各イメージストリームを 1 つずつ更新できるようになりました。

    oc import-image -n openshift fuse7-java-openshift:1.4
    oc import-image -n openshift fuse7-karaf-openshift:1.4
    oc import-image -n openshift fuse7-eap-openshift:1.4
    oc import-image -n openshift fuse7-console:1.4
    oc import-image -n openshift apicurito-ui:1.4
    oc import-image -n openshift fuse-apicurito-generator:1.4
注記

イメージストリームのバージョンタグの形式は 1.4-<BUILDNUMBER> です。タグを 1.4 として指定すると、1.4 ストリームの最新ビルドが取得されます。

注記

新しい 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.fuse-740025-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.4.0.fuse-740036-redhat-00002</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.4.0.fuse-740036-redhat-00002</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.4.0.fuse-740036-redhat-00002</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.4.0.fuse-740036-redhat-00002

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 プラグイン

A.1. Spring Boot Maven プラグインの概要

この付録では、Spring Boot Maven プラグインについて説明します。Maven での Spring Boot サポートを提供し、実行可能 jar または war アーカイブのパッケージ化や、アプリケーション in-place の実行を可能にします。

A.2. ゴール

Spring Boot プラグインのゴールには以下が含まれます。

  1. spring-boot:run は Spring Boot アプリケーションを実行します。
  2. spring-boot:repackage は、.jar および .war ファイルを再パッケージして実行可能にします。
  3. spring-boot:start および spring-boot:stop の両方は、Spring Boot アプリケーションのライフサイクルを管理するために使用されます。
  4. spring-boot:build-info は、Actuator が使用できるビルド情報を生成します。

A.3. 使用法

Spring Boot プラグインの使用方法に関する一般的な手順は、「http://docs.spring.io/spring-boot/docs/current/maven-plugin/usage.html」を参照してください。以下の例は Spring Boot 1 の spring-boot-maven-plugin の使用方法を示しています。

注記

Spring Boot Maven プラグインの詳細は「http://docs.spring.io/spring-boot/docs/current/maven-plugin」を参照してください。

A.3.1. Spring Boot 2 の Spring Boot Maven プラグイン

<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.4.0.fuse-sb2-740019-redhat-00005</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.3.2. Spring Boot 1 の Spring Boot Maven プラグイン

<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.4.0.fuse-740036-redhat-00002</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 リポジトリーはインストールされています。

B.1.1. 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 プラグイン

C.1. 概要

fabric8-maven-plugin を利用すると、Java アプリケーションを OpenShift にデプロイできます。これは Maven との緊密なインテグレーションを提供し、すでに提供されているビルド設定の利点を活用できます。このプラグインは以下のタスクを中心に行います。

  • Docker 形式イメージのビルド
  • OpenShift リソース記述子の作成

大変柔軟に設定でき、以下を作成するために複数の設定モデルをサポートします。

  • Zero-Config の設定: opinionated default (推奨されるデフォルト) で迅速な立ち上げが可能になります。または、より高度な要件を可能にします。
  • XML 設定: pom.xml ファイルに追加できるその他の設定オプションを提供します。

C.1.1. イメージのビルド

fabric8:build ゴールは、アプリケーションが含まれる Docker 形式イメージの作成に使用されます。ビルドアーティファクトやイメージの依存関係を簡単に含めることができます。このプラグインは maven-assembly-plugin のアセンブリー記述子を使用し、イメージに追加されるコンテンツを指定します。

重要

Fuse on OpenShift では、OpenShift s2i ビルドストラテジーのみがサポートされます。docker ビルドストラテジーはサポートされません

C.1.2. Kubernetes および OpenShift リソース

Kubernetes および OpenShift リソース記述子は、fabric8:resource で作成できます。これらのファイルは Maven アーティファクト内にパッケージされ、fabric8:apply を使用して稼働中のオーケストレーションプラットフォームにデプロイできます。

C.1.3. 設定

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.2. プラグインのインストール

Fabric8 Maven プラグインは Maven の中央リポジトリーで使用でき、以下のようにインテグレーション前後のフェーズに接続することができます。

<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.3. ゴールの理解

Fabric8 Maven プラグインは、スムーズな Java 開発環境を提供するゴールのセットをサポートします。ゴールは以下のように分類できます。

  • ビルドゴール は、Docker 形式イメージや S2I ビルドなどの Kubernetes および OpenShift ビルドアーティファクトを作成および管理するために使用されます。
  • 開発ゴール は、リソース記述子を開発クラスターにデプロイするために使用されます。また、開発クラスターのライフサイクルを管理するのにも便利です。

C.3.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.3.2. 環境変数の設定

以下のように XML 設定に env パラメーターを追加して、1 つ以上の環境変数を設定できます。例を以下に示します。

<configuration>
  <resources>
    <env>
        <JAVA_OPTIONS>-Dmy.custom=option</JAVA_OPTIONS>
        <MY_VAR>value</MY_VAR>
    </env>
  </resources>
</configuration>

C.3.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.4. ジェネレーター

Fabric8 Maven プラグインは、特定の種類のアプリケーションに対して自動的にイメージをビルドする機能がある、generator コンポーネントを提供します。Fuse on OpenShift の場合、以下のジェネレータータイプがサポートされます。

ジェネレーターフレームワークは、アプリケーションプロジェクトの特性に応じて、必要なビルドタイプを自動検出し、適切なジェネレーターコンポーネントを呼び出します。

注記

Fabric8 Maven プラグインのオープンソースコミュニティーバージョンは、追加のジェネレータータイプを提供しますが、これらのタイプは Fuse on OpenShift 製品ではサポートされません。

C.4.1. Zero-Configuration

ジェネレーターには設定が必要ありません。ジェネレーターはデフォルトで有効になり、Fabric8 Maven プラグインが呼び出されると自動的にデフォルト設定で実行されます。しかし、必要な場合はジェネレーターの設定を簡単にカスタマイズできます。

C.4.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.4.2.1. istag モードのデフォルト値

デフォルトである istag モードが選択されている場合、Fabric8 Maven プラグインは以下のデフォルトイメージ指定子を使用して Fuse イメージを選択します (形式は <namespace>/<image-stream-name>:<tag> です)。

fuse7/fuse-eap-openshift:1.3
fuse7/fuse-java-openshift:1.3
fuse7/fuse-karaf-openshift:1.3
注記

Fuse イメージストリームでは、個別のイメージに 1.0-11.0-2 などのビルド番号がタグ付けされます。常に最新のイメージを追跡するよう、1.0 タグが設定されます。

C.4.2.2. docker モードのデフォルト値

docker モードが選択され、registry.redhat.io にアクセスするよう OpenShift 環境が設定されていることを仮定する場合、Fabric8 Maven プラグインは以下のデフォルトイメージ指定子を使用して Fuse イメージを選択します (形式は <image-namespace>/<image-name>:<tag> です)。

fuse7/fuse-eap-openshift:1.3
fuse7/fuse-java-openshift:1.3
fuse7/fuse-karaf-openshift:1.3
C.4.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.4.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.4.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.4.3. Spring Boot

Spring Boot ジェネレーターは、pom.xml ファイルで spring-boot-maven-plugin を見つけるとアクティベートされます。生成されたコンテナーポートは server.port プロパティーの application.properties から読み取られ、見つからない場合はデフォルトで 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.4.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 プラグイン

D.1. ゴール

ソースコードの Camel エンドポイントを検証するには以下を使用します。

  • fabric8-camel:validate: Maven プロジェクトのソースコードを検証し、無効な Camel エンドポイント URI を到底します。

D.2. プラグインのプロジェクトへの追加

プラグインを有効にするには、以下を pom.xml ファイルに追加します。

<plugin>
  <groupId>io.fabric8.forge</groupId>
  <artifactId>fabric8-camel-maven-plugin</artifactId>
  <version>2.3.90</version>
</plugin>

注意: fabric8-forge リリースの現在のバージョン番号を確認してください。最新のリリースは https://github.com/fabric8io/fabric8-forge/releases にあります。

ただし、ゴールの検証はコマンドラインまたは IDEA や Eclipse などの Java エディターから実行できます。

mvn fabric8-camel:validate

プラグインを有効にしてビルドの一部として自動的に実行し、エラーを検出することも可能です。

<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>

フェーズはプラグインが実行されるタイミングを決定します。上記の例では、メインのソースコードの完了後に実行される process-classes がフェーズです。

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 エンドポイント URI があるとします。

  @Uri("timer:foo?period=5000")

period オプションに誤りが含まれるように、以下のような変更を加えます。

  @Uri("timer:foo?perid=5000")

再度、ゴールの検証を実行すると、以下が報告されます。

[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] ------------------------------------------------------------------------

D.4. オプション

Maven プラグインは以下のオプションをサポートします。これらのオプションはコマンドラインから設定するか (-D 構文を使用)、<configuration> タグの pom.xml ファイルで定義します。

D.4.1. 表

パラメーターデフォルト値説明

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 環境変数

E.1. OpenJDK 8 でのS2I Java ビルダーイメージ

Java ビルドのこの S2I ビルダーイメージでは、他のアプリケーションサーバーを使用せずに直接結果を実行できます。これは、フラットなクラスパス (fat jars を含む) を持つマイクロサービスに適しています。

Fuse on OpenShift イメージの使用時に Java オプションを設定できます。Fuse on OpenShift イメージのすべてのオプションは、以下のように環境変数を使用して設定されます。JVM オプションでは、JAVA_OPTIONS 環境変数を使用できます。また、アプリケーションに渡される引数には JAVA_ARGS を提供します。

E.2. OpenJDK 8 でのS2I Karaf ビルダーイメージ

Karaf4 カスタムアセンブリーベースの Maven プロジェクトをビルドするには、このイメージを OpenShift の Source To Image と使用します。

S2I を使用するコマンドは次のとおりです。

s2i build <git repo url> registry.redhat.io/fuse7/fuse-karaf-openshift:1.3 <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_ARGS 環境変数を設定して、動作を変更できます。

デフォルトでは、MAVEN_ARGS は以下のように設定されます。

Karaf4: install karaf:assembly karaf:archive -DskipTests -e

E.3. 環境変数

S2I Java および Karaf ビルダーイメージの動作に影響を与える環境変数を以下に示します。

E.3.1. ビルド時

ビルド時には以下の環境変数を使用できます。

  • 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.3.2. 実行時

以下の環境変数を使用して、実行スクリプトに影響を与えることができます。

  • 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.3.3. 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 コンテナー内での実行

F.1. 概要

JVM エルゴノミクス による、ガベッジコレクター、ヒープサイズ、およびランタイムコンパイラーのデフォルト値の設定を許可すると、Linux コンテナー内部で実行している Java プロセスは想定どおりに動作しません。java -jar mypplication-fat.jar などのチューニングパラメーターを使用せずに Java アプリケーションを実行すると、JVM はコンテナーの制限ではなく、ホストの制限を基にして複数のパラメーターを自動的に設定します。

本セクションでは、コンテナーの制限を考慮してデフォルト値が算出されるよう、Linux コンテナー内部で Java アプリケーションをパッケージ化するための情報を提供します。

F.2. JVM のチューニング

現在の Java JVM はコンテナー対応でないため、コンテナーのサイズではなく、物理ホストのサイズを基にしてリソースを割り当てます。たとえば、通常 JVM は最大ヒープサイズを、ホスト上の物理メモリーの 1/4 に設定します。大型のホストマシンでは、この値はコンテナーに定義されたメモリー制限を簡単に越えてしまいます。実行時にコンテナー制限を越えてしまうと、OpenShift はアプリケーションを強制終了します。

この問題に対応するには、Java JVM が制限されたコンテナー内で実行されることを認識でき、かつ最大ヒープサイズが手動で調整されない場合は自動的に調整されることを認識できる、Fuse on OpenShift ベースのイメージを使用します。これにより、アプリケーションを実行する JVM の最大メモリー制限とコア制限を設定できます。Fuse on OpenShift イメージは以下を行うことができます。

  • コンテナーのコアを基にした CICompilerCount の設定。
  • コンテナーメモリー制限が 300MB 未満の場合に C2 JIT コンパイラーを無効にする。
  • コンテナーメモリー制限が 300MB 未満の場合に、コンテナーメモリー制限の 1/4 をデフォルトのヒープサイズに使用する。

F.3. Fuse on OpenShift イメージ のデフォルト動作

Fuse on OpenShift では、アプリケーションビルドのベースイメージは Java イメージ (Spring Boot アプリケーションの場合) または Karaf イメージ (Karaf アプリケーションの場合) のいずれかになります。Fuse on OpenShift イメージはコンテナー制限を読み取るスクリプトを実行し、その制限をリソース割り当てのベースとして使用します。デフォルトでは、スクリプトは以下のリソースを JVM に割り当てます。

  • コンテナーメモリー制限の 50%
  • コンテナーコア制限の 50%

これには一部の例外があります。Karaf と Java イメージでは、物理メモリーが 300MB のしきい値未満になると、ヒープサイズはデフォルトの半分ではなく、1/4 に回復されます。

F.4. 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.5. サードパーティーライブラリーのチューニング

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.
Red Hat logoGithubRedditYoutubeTwitter

詳細情報

試用、購入および販売

コミュニティー

Red Hat ドキュメントについて

Red Hat をお使いのお客様が、信頼できるコンテンツが含まれている製品やサービスを活用することで、イノベーションを行い、目標を達成できるようにします。

多様性を受け入れるオープンソースの強化

Red Hat では、コード、ドキュメント、Web プロパティーにおける配慮に欠ける用語の置き換えに取り組んでいます。このような変更は、段階的に実施される予定です。詳細情報: Red Hat ブログ.

会社概要

Red Hat は、企業がコアとなるデータセンターからネットワークエッジに至るまで、各種プラットフォームや環境全体で作業を簡素化できるように、強化されたソリューションを提供しています。

© 2024 Red Hat, Inc.