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 クラスターを準備できます。
- Red Hat コンテナーレジストリーへの認証の設定。
- Fuse on OpenShift イメージおよびテンプレートのインストール。
2.1. Red Hat コンテナーレジストリーの認証設定
Red Hat Fuse on OpenShift イメージストリームおよびテンプレートをインポートおよび使用する前に、Red Hat コンテナーレジストリーへの認証を設定する必要があります。
手順
管理者として OpenShift サーバーにログインします。
oc login -u system:admin
イメージストリームをインストールする OpenShift プロジェクトにログインします。Fuse on OpenShift イメージストリームの
openshift
プロジェクトを使用することが推奨されます。oc project openshift
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 シークレットを作成する必要があります。
Pod のイメージをプルするためにシークレットを使用するには、シークレットをサービスアカウントに追加します。サービスアカウントの名前は、Pod が使用するサービスアカウントの名前と一致する必要があります。以下は、デフォルトのサービスアカウントである
default
を使用する例になります。oc secrets link default <pull_secret_name> --for=pull
ビルドイメージをプッシュまたはプルするためにシークレットを使用するには、シークレットを 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) に記載されているように、サービスカタログとテンプレートサービスブローカーを先にインストールする必要があります。
手順
- OpenShift 4 サーバーを起動します。
OpenShift サーバーに管理者としてログインします。
oc login -u system:admin
docker-registry シークレットを作成したプロジェクトを使用することを確認します。
oc project openshift
Samples Operator の現在の設定を表示します。
oc get configs.samples.operator.openshift.io -n openshift-cluster-samples-operator -o yaml
Samples Operator が、追加された Fuse テンプレートおよびイメージストリームを無視するよう設定します。
oc edit configs.samples.operator.openshift.io -n openshift-cluster-samples-operator
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
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
クイックスタートテンプレートをインストールします。
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
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 の設定」を参照してください。
(任意手順): インストールされた 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 コンテナーレジストリーへの認証が設定されている必要があります。
手順
- OpenShift 4.x サーバーを起動します。
- ブラウザーで OpenShift コンソールに移動します。ご自分のクレデンシャルでコンソールにログインします。
- Catalog をクリックした後、OperatorHub をクリックします。
-
検索フィールドウインドウに Apicurito と入力し、
Enter
キーを押します。右側のパネルに Apicurito Operator が表示されます。 - Apicurito Operator をクリックします。Apicurito Operator インストールウインドウが表示されます。
Install をクリックします。Create Operator Subscription フォームが表示されます。このフォームには以下のオプションがあります。
- Installation mode (インストールモード)
- Update Channel (更新チャネル)
Approval Strategy (承認ストラテジー)
デフォルト値をそのまま使用するか、希望の値を選択します。
- Subscribe をクリックします。Apicurito Operator が選択した namespace にインストールされます。
- 確認するには、Catalog をクリックした後、Installed Operator をクリックします。リストに Apicurito Operator が表示されます。
Name 列の Apicurito Operator をクリックします。Provided APIs 以下の Create New をクリックします。新しい CRD (Custom Resource Definition) がデフォルト値で作成されます。以下のフィールドは CR の一部としてサポートされます。
- size: Apicurito Operator が持つ Pod の数。
- image: Apicurito イメージ。既存のインストールでこのイメージを変更すると、Operator のアップグレードがトリガーされます。
- Create をクリックします。これにより新しい apicurito-service が作成されます。
2.4. OpenShift 3.x サーバーでの Fuse イメージストリームおよびテンプレートのインストール
Red Hat コンテナーレジストリーへの認証を設定した後、Red Hat Fuse on OpenShift イメージストリームおよびテンプレートをインポートおよび使用します。
手順
- OpenShift サーバーを起動します。
OpenShift サーバーに管理者としてログインします。
oc login -u system:admin
docker-registry シークレットを作成したプロジェクトを使用することを確認します。
oc project openshift
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
クイックスタートテンプレートをインストールします。
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
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 の設定」を参照してください。
Apicurito テンプレートをインストールします。
oc create -n openshift -f ${BASEURL}/fuse-apicurito.yml
(任意手順): インストールされた 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 コンテナーレジストリーへの認証が設定されている必要があります。
詳細は以下を参照してください。
手順
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 とクレデンシャルを使用します。
test という名前のプロジェクト namespace を新規作成します。
oc new-project test
test プロジェクト namespace がすでに存在する場合は、以下のコマンドを使用して切り替えます。
oc project test
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 イメージストリームが表示されます。
クイックスタートテンプレートをインストールします。
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
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 の設定」を参照してください。
(任意手順): インストールされた Fuse on OpenShift イメージおよびテンプレートを表示します。
oc get template -n test
ブラウザーで OpenShift コンソールに移動します。
-
https://OPENSHIFT_IP_ADDR:8443 を使用します。
OPENSHIFT_IP_ADDR
は OpenShift サーバーの実際の IP アドレスに置き換えます。 - クレデンシャル (例: ユーザー名 developer とパスワード developer) を使用して OpenShift コンソールにログインします。
-
https://OPENSHIFT_IP_ADDR:8443 を使用します。
第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 をインストールするには、以下を行います。
- Fuse on OpenShift では、バージョン 3.9 の CDK をインストールすることが推奨されます。CDK 3.9 をインストールおよび使用するための詳細手順は『Red Hat CDK 3.9 Getting Started Guide』を参照してください。
- 「Red Hat コンテナーレジストリーの認証設定」の手順にしたがって、OpenShift クレデンシャルを設定し、Red Hat コンテナーレジストリーにアクセスできるようにします。
2章管理者向けの基本情報 の説明にしたがって、Fuse on OpenShift イメージおよびテンプレートを手作業でインストールします。
注記CDK のバージョンには Fuse on OpenShift イメージおよびテンプレートが事前にインストールされている可能性があります。ただし、OpenShift クレデンシャルの設定後に、Fuse on OpenShift イメージおよびテンプレートをインストール (または更新) する必要があります。
- 本章の例を参照する前に、『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 リポジトリーを設定します。
手順
-
Maven
settings.xml
ファイルを開きます。通常、このファイルは Linux または macOS の場合は~/.m2/settings.xml
、Windows の場合はDocuments and Settings\<USER_NAME>\.m2\settings.xml
に配置されます。 以下の Maven リポジトリーを追加します。
-
Maven central:
https://repo1.maven.org/maven2
-
Red Hat GA リポジトリー:
https://maven.repository.redhat.com/ga
Red Hat EA リポジトリー:
https://maven.repository.redhat.com/earlyaccess/all
上記のリポジトリーは、
settings.xml
ファイルの依存関係リポジトリーセクションと、プラグインリポジトリーセクションの両方に追加する必要があります。
-
Maven central:
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 プロジェクトを作成、ビルド、およびデプロイします。
手順
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.fis
、artifactId
の値にはfuse74-spring-boot
を入力します。残りのフィールドにはデフォルト値を使用します。-
前のコマンドが
BUILD SUCCESS
状態で終了した場合、fuse74-spring-boot
サブディレクトリー内に新しい Fuse on OpenShift プロジェクトが作成されているはずです。XML DSL コードはfuse74-spring-boot/src/main/resources/spring/camel-context.xml
ファイルで確認できます。デモンストレーションコードは、乱数が含まれるメッセージを継続的にログに送信する、シンプルな Camel ルートを定義します。 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 とクレデンシャルを使用します。以下のコマンドを実行し、Fuse on OpenShift イメージおよびテンプレートがすでにインストールされ、アクセス可能であることを確認します。
oc get template -n openshift
イメージおよびテンプレートが事前にインストールされていない場合や、提供されたバージョンが古い場合は、Fuse on OpenShift イメージおよびテンプレートを手作業でインストール (または更新) します。Fuse on OpenShift イメージのインストール方法に関する詳細は、2章管理者向けの基本情報 を参照してください。
以下のように、
test
という名前のプロジェクト namespace を作成します。oc new-project test
test
プロジェクト namespace がすでに存在する場合、以下のコマンドを使用して切り替えます。oc project test
これで、
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 回目からはビルドが速くなります。
-
ブラウザーで OpenShift コンソールに移動し、クレデンシャル (例: ユーザー名
developer
およびパスワードdeveloper
) を使用してコンソールにログインします。 - OpenShift コンソールで下方向にスクロールし、test プロジェクト namespace を見つけます。test プロジェクトをクリックして test プロジェクト namespace を開きます。test プロジェクトの Overview タブが開き、fuse74-spring-boot アプリケーションが表示されます。
fuse74-spring-boot デプロイメントの左にある矢印をクリックし、このデプロイメントの詳細を展開および表示します。
Pod アイコン (青い円) の中心をクリックし、fuse74-spring-boot の Pod のリストを表示します。
Pod の Name (この例では
fuse74-spring-boot-1-kxdjm
) をクリックし、稼働中の Pod の詳細を表示します。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
-
左側のナビゲーションバーにある Overview をクリックし、
test
namespace のアプリケーション概要に戻ります。実行中の Pod をシャットダウンするには、Pod アイコンの横にある下矢印 をクリックします。Scale down deployment fuse74-spring-boot-1? というダイアログが表示されたら、Scale Down をクリックします。 (任意): 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 を開きます。
OpenShift プロジェクトの Applications → Pods ビューで、Pod 名をクリックし、実行している Fuse Pod の詳細を表示します。このページの右側に、コンテナーテンプレートの概要が表示されます。
このビューの Open Java Console リンクをクリックし、Fuse Console を開きます。
注記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 をデプロイするには、以下の手順にしたがいます。
手順
- OpenShift コンソールで既存のプロジェクトを開くか、新しいプロジェクトを作成します。
Fuse Console を OpenShift プロジェクトに追加します。
Add to Project → Browse Catalog と選択します。
Select an item to add to the current project ページが開きます。
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 テンプレートを手作業でインストールすることができます。
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 アプリケーションを検出し、接続します。
Red Hat Fuse Console ウィザードで Next をクリックします。ウィザードの Configuration ページが開きます。
任意で、設定パラメーターのデフォルト値を変更できます。
Create をクリックします。
ウィザードの Results ページに Red Hat Fuse Console が作成されたことが表示されます。
- Continue to the project overview をクリックし、Fuse Console アプリケーションがプロジェクトに追加されたことを確認します。
Fuse Console を開き、提供された URL をクリックした後にログインします。
ブラウザーに Authorize Access ページが表示され、必要なパーミッションが表示されます。
Allow selected permissions をクリックします。
ブラウザーで Fuse Console が開かれ、プロジェクトで実行されている Fuse の Pod が表示されます。
表示するアプリケーションの Connect をクリックします。
新しいブラウザーウィンドウが開かれ、Fuse Console にアプリケーションが表示されます。
4.2.3.3. コマンドラインからの Fuse Console のデプロイ
表4.1「Fuse Console テンプレート」 は、Fuse アプリケーションのデプロイメントのタイプに応じて、コマンドラインから Fuse Console へのアクセスに使用できる 2 つの OpenShift テンプレートについて説明しています。
タイプ | 説明 |
---|---|
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 つを実行して、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 によって自動的に生成されるため、省略することが可能です。
以下のコマンドを実行して、Fuse Console デプロイメントの状態と URL を取得します。
oc status
- ブラウザーから Fuse Console にアクセスするには、提供される URL (例: https://fuse-console.192.168.64.12.nip.io) を使用します。
4.2.3.4. Fuse Console でデータが正しく表示されるよう確認
Fuse Console のキューおよびコネクションの表示で、不足しているキューやコネクションがあったり、一貫性のないアイコンが表示される場合、Jolokia が応答でマーシャルするアレイの要素の最大数を指定する、Jolokia コレクションサイズパラメーターを調節します。
手順
Fuse Console の右上隅にあるユーザーアイコンをクリックして、Preferences をクリックします。
- Maximum collection size オプションの値を大きくします (デフォルトは 50,000)。
- Close をクリックします。
4.2.4. S2I ソースワークフローを使用したプロジェクトの作成およびデプロイ
ここでは、OpenShift S2I ソースワークフローを使用して、テンプレートをベースとした Fuse on OpenShift プロジェクトをビルドおよびデプロイします。最初に、リモート Git リポジトリーに保存されたクイックスタートプロジェクトを使用します。OpenShift コンソールを使用すると、このクイックスタートプロジェクトを OpenShift サーバーでダウンロード、ビルド、およびデプロイできます。
手順
-
ブラウザーで https://OPENSHIFT_IP_ADDR:8443 の OpenShift コンソールに移動します (
OPENSHIFT_IP_ADDR
は CDK の場合で表示された IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名developer
、パスワードdeveloper
) を使用して、コンソールにログインします。 カタログ検索フィールドに
Red Hat Fuse 7.4 Camel XML
を検索文字列として入力し、Red Hat Fuse 7.4 Camel XML DSL with Spring Boot テンプレートを選択します。- テンプレートウィザードの Information ステップが開きます。Next をクリックします。
以下のように、テンプレートウィザードの Configuration ステップが開きます。Add to Project ドロップダウンメニューで My Project を選択します。
注記この例で新しいプロジェクトを作成したい場合は、上記の手順の代わりに Add to Project ドロップダウンメニューで Create Project を選択します。新規プロジェクトの名前を入力する Project Name フィールドが表示されます。
Configuration ステップの残りの設定では、デフォルトの値を使用します。Create をクリックします。
注記クイックスタートをそのまま実行せずに、アプリケーションコードを変更する場合は、元のクイックスタート Git リポジトリーをフォークし、Git Repository URL および Git Reference フィールドに適切な値を入力する必要があります。
- テンプレートウィザードの Results ステップが開きます。Close をクリックします。
- 右側の My Projects ペインで My Project をクリックします。My Project プロジェクトの Overview タブが開き、s2i-fuse74-spring-boot-camel-xml アプリケーションが表示されます。
s2i-fuse74-spring-boot-camel-xml デプロイメントの左にある矢印をクリックし、以下のようにこのデプロイメントの詳細を展開および表示します。
このビューにビルドログが表示されます。何らかの理由でビルドに失敗した場合は、ビルドログを参照して問題を診断します。
注記リモートの Maven リポジトリーから多くの依存関係をダウンロードする必要があるため、ビルドが完了するまで数分かかることがあります。ビルド時間を短縮するには、ローカルネットワークに Nexus サーバーをデプロイすることが推奨されます。
ビルドが正常に完了したら、Pod アイコンは 1 つの Pod が実行している青い円で表示されます。Pod アイコン (青い円) の中心をクリックし、s2i-fuse74-spring-boot-camel-xml の Pod のリストを表示します。
注記複数の Pod が実行されている場合、この時点では実行中の Pod のリストが表示されます。1 つの Pod のみが実行されている場合は、実行中の Pod の詳細ビューが表示されます。
Pod 詳細ビューが開きます。Logs タブをクリックしてアプリケーションログを表示し、ログを下方向にスクロールして、Camel アプリケーションによって生成されたログメッセージを見つけます。
-
左側のナビゲーションバーにある Overview をクリックし、
My Project
namespace のアプリケーション概要に戻ります。実行中の Pod をシャットダウンするには、Pod アイコンの横にある下矢印 をクリックします。Scale down deployment s2i-fuse74-spring-boot-camel-xml-1? というダイアログが表示されたら、Scale Down をクリックします。 (任意): CDK を使用している場合は、シェルプロンプトに戻り、以下のコマンドを入力すると、仮想 OpenShift サーバーを完全にシャットダウンすることができます。
minishift stop
第5章 Spring Boot イメージのアプリケーションの開発
本章では、Spring Boot イメージのアプリケーションを開発する方法を説明します。
5.1. Maven archetype を使用した Spring Boot プロジェクトの作成
Maven archetype を使用して Spring Boot プロジェクトを作成するには、以下の手順にしたがいます。
手順
- システムの適切なディレクトリーに移動します。
シェルプロンプトで以下の
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.fis
、artifactId
の値にはfuse74-spring-boot
を入力します。残りのフィールドにはデフォルト値を使用します。- サンプルのビルドおよびデプロイ方法については、クイックスタートの手順にしたがいます。
使用できる 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-starter
やcamel-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 カタログには以下の例が含まれます。
名前 | 説明 |
---|---|
| fabric8 Java ベースイメージを基にして Apache Camel を Spring Boot と使用する方法を実証します。 |
| Spring Boot アプリケーションを ActiveMQ ブローカーに接続する方法と、Kubernetes または OpenShift を使用して 2 つの Camel ルートの間で JMS メッセージングを使用する用法を実証します。 |
| Kubernetes ConfigMaps および Secret を使用して Spring Boot アプリケーションを設定する方法を実証します。 |
| Apache Camel を使用して、リモート Kie Server で Kubernetes または OpenShift で実行している Spring Boot アプリケーションを統合する方法を実証します。 |
| Hot Rod プロトコルを使用して Spring Boot アプリケーションを JBoss Data Grid または Infinispan サーバーに接続する方法を実証します。 |
| Camel の REST DSL とともに JDBC を介して SQL を使用し、RESTful API を公開する方法を実証します。 |
| Spring Boot、Camel、および XA トランザクション。この例は、2 つの外部トランザクションリソースである JMS リソース (A-MQ) とデータベース (PostgreSQL) の XA トランザクションをサポートする Spring Boot で Camel Service を実行する方法を実証します。このクイックスタートでは、PostgreSQL データベースと A-MQ ブローカーが最初にデプロイおよび実行されている必要があります。OpenShift サービスカタログに提供されるテンプレートを使用するのが、簡単な実行方法の 1 つです。 |
| Blueprint 設定ファイルより、Spring Boot の Camel ルートを設定する方法を実証します。 |
| fabric8 Java ベースイメージを基にして Spring Boot で Apache CXF を使用する方法を実証します。クイックスタートは Spring Boot を使用して、Swagger が有効な CXF JAXRS エンドポイントが含まれるアプリケーションを設定します。 |
| 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 が動作するよう設定する方法を示しています。
手順
これは、
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
共有ボリュームに、終了に関連するトランザクションと情報の両方を格納する必要があります。以下のように 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 クラスターでクイックスタートを実行する方法を説明します。
手順
Camel Spring Boot XA プロジェクトをダウンロードします。
git clone https://github.com/jboss-fuse/spring-boot-camel-xa
spring-boot-camel-xa
ディレクトリーに移動し、以下のコマンドを実行します。mvn clean install
OpenShift サーバーにログインします。
oc login -u developer -p developer
test
という名前のプロジェクト namespace を作成します (存在しない場合)。oc new-project test
test
プロジェクト namespace がすでに存在する場合は、それに切り替えます。oc project test
依存関係をインストールします。
-
ユーザー名
postgresql
とパスワードtheuser
を使用して、OpenShift カタログからThepassword1!
をインストールします。 -
ユーザー名
theuser
とパスワードThepassword1!
を使用して、OpenShift カタログからA-MQ
ブローカーをインストールします。
-
ユーザー名
準備済みステートメントを許可するよう、
Postgresql
データベースを変更します。oc env dc/postgresql POSTGRESQL_MAX_PREPARED_TRANSACTIONS=100
トランザクションログの永続ボリュームクレームを作成します。
oc create -f persistent-volume-claim.yml
クイックスタートをビルドおよびでデプロイします。
mvn fabric8:deploy -P openshift
レプリカの数を必要に合わせてスケールアップします。
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 として適用されます (「ー」などの一部の文字の削除後)。
クイックスタートが実行されたら、以下のコマンドを使用してベースサービス URL を取得します。
NARAYANA_HOST=$(oc get route spring-boot-camel-xa -o jsonpath={.spec.host})
7.5. 成功した XA トランザクションのテスト
以下のワークフローは、成功した XA トランザクションのテスト方法を示しています。
手順
audit_log テーブルのメッセージのリストを取得します。
curl -w "\n" http://$NARAYANA_HOST/api/
当初、このリストは空の状態です。最初の要素を追加します。
curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=hello
しばらく待ってから、新しいリストを取得します。
curl -w "\n" http://$NARAYANA_HOST/api/
-
新しいリストには、
hello
とhello-ok
の 2 つのメッセージが含まれます。hello-ok
は、メッセージが送信キューに送られ、ログに記録されたことを確認します。複数のメッセージを追加してログを確認することができます。
7.6. 失敗した XA トランザクションのテスト
以下のワークフローは、失敗した XA トランザクションのテスト方法を示しています。
手順
fail
という名前のメッセージを送信します。curl -w "\n" -X POST http://$NARAYANA_HOST/api/?entry=fail
しばらく待ってから、新しいリストを取得します。
curl -w "\n" http://$NARAYANA_HOST/api/
- このメッセージは、ルートの最後で例外を発生するため、トランザクションは常にロールバックされます。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 リポジトリーの設定」を参照してください。
手順
クイックスタートをビルドおよびデプロイするために準備します。
OpenShift に開発者としてログインします。
oc login -u developer -p developer
新しいプロジェクト amq-quickstart を作成します。
oc new-project amq-quickstart
インストールした AーMQ 6 イメージおよびテンプレートのバージョンを確認します。
$ oc get template -n openshift
amqXX-basic
という名前のテンプレートが見つかるはずです。XX
は、OpenShift にインストールされた AーMQ のバージョンになります。
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 がベース) で動作します。メッシュエンドポイントの検出に必要なユーザーロールを追加します (Kubernetes REST API 経由)。
$ oc policy add-role-to-user view system:serviceaccount:amq-quickstart:default
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
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.fis
、artifactId
の値にはfuse74-spring-boot-camel-amq
を入力します。残りのフィールドにはデフォルト値を使用します。クイックスタートディレクトリー
fuse74-spring-boot-camel-amq
に移動します。$ cd fuse74-spring-boot-camel-amq
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
mvn
コマンドを実行し、クイックスタートを OpenShift サーバーにデプロイします。mvn fabric8:deploy -Popenshift
クイックスタートが正常に実行されていることを確認するには、以下を行います。
- OpenShift コンソールに移動します。
- プロジェクト amq-quickstart を選択します。
- Applications をクリックします。
- Pods を選択します。
- fis-spring-boot-camel-am-1-xxxxx をクリックします。
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
- 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
ファイルに追加します。
手順
以下の Maven 依存関係を Spring Boot Maven プロジェクトの pom.xml ファイルに追加して、Kubernetes インテグレーションを有効にします。
<project ...> ... <dependencies> ... <dependency> <groupId>io.fabric8</groupId> <artifactId>spring-cloud-kubernetes-core</artifactId> </dependency> ... </dependencies> ... </project>
インテグレーションを完了するには以下を行います。
- アノテーションを Java ソースコードに追加します。
- Kubernetes ConfigMap オブジェクトを作成します。
- アプリケーションが ConfigMap オブジェクトを読み取りできるようにするため、OpenShift サービスアカウントのパーミッションを編集します。
その他のリソース
- 詳細は、「ConfigMap プロパティーソースのチュートリアルの実行」を参照してください。
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 を基にしています。
手順
新しいシェルプロンプトを開き、以下の 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.fis
、artifactId
の値にはfuse74-configmap
を入力します。残りのフィールドにはデフォルト値を使用します。OpenShift にログインし、アプリケーションをデプロイする OpenShift プロジェクトに切り替えます。たとえば、
developer
ユーザーとしてログインし、test
プロジェクトにデプロイする場合は、以下のコマンドを入力します。oc login -u developer -p developer oc project test
コマンドラインで、新しい
fuse74-configmap
プロジェクトのディレクトリーに移動し、このアプリケーションの Secret オブジェクトを作成します。oc create -f sample-secret.yml
注記アプリケーションをデプロイする 前 に Secret オブジェクトを作成する必要があります。そうでないと、Secret が利用できるようになるまでデプロイされたコンテナーが待機状態になります。続けて Secret を作成すると、コンテナーは待機状態ではなくなります。Secret オブジェクトの設定方法に関する詳細は「Secret の設定」を参照してください。
クイックスタートアプリケーションをビルドおよびデプロイします。
fuse74-configmap
プロジェクトのトップレベルで以下を入力します。mvn fabric8:deploy -Popenshift
次のようにアプリケーションログを確認します。
-
ブラウザーで OpenShift コンソールを開き、該当するプロジェクト namespace を選択します (例:
test
)。 -
fuse74-configmap
サービスの円形 Pod アイコンの中心をクリックします。 - Pods ビューで Name Pod をクリックし、実行中の Pod の詳細を表示します (1 つの Pod のみが実行中である場合は直接詳細ページが表示されます)。
- Logs タグをクリックしてアプリケーションログを表示し、下方向にスクロールして Camel アプリケーションによって生成されたログメッセージを見つけます。
-
ブラウザーで OpenShift コンソールを開き、該当するプロジェクト namespace を選択します (例:
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
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_NAME
をqs-camel-config
に定義します。ライブリロード機能の動作を確認するには、以下のように ConfigMap オブジェクトを作成します。
oc create -f sample-configmap.yml
新しい ConfigMap は、実行中のアプリケーションにある Camel ルートの受信者リストをオーバーライドし、生成されたメッセージを 3 つ のダミーエンドポイントである
direct:async-queue
、direct: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 の外部化設定がどのように動作するかを示しています。
設定メカニズムには以下の 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 を設定するには、以下を行います。
- サンプル Secret オブジェクトの作成
- Secret のボリュームマウントの設定
- 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 }}}'
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
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 アプリケーションにアクセスできるようにするには、以下の手順を実行します。
手順
-
Spring Boot アプリケーションで 外部化設定 メカニズムを使用し、ConfigMap プロパティーソースへアクセスします。たとえば、Java Bean に
@Configuration
アノテーションを付けると、ConfigMap による Bean のプロパティー値のインジェクションが可能になります。 -
プロジェクトの
bootstrap.properties
ファイル (またはbootstrap.yaml
ファイル) で、spring.application.name
プロパティーが ConfigMap の名前と一致するよう設定します。 アプリケーションに関連するサービスアカウントの
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 が見つかった場合、アプリケーションはそのデータを利用できます。
- Secret マウントからの再帰的な読み取り
-
アプリケーションにちなんだ名前の付与 (
spring.application.name
を参照) - 一部のラベルとの一致
デフォルトでは、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
機能は、デフォルトで無効になっています。
手順
-
クイックスタートの
src/main/resources
ディレクトリーに移動し、bootstrap.yml
ファイルを開きます。 -
設定プロパティー
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 の例
以下の例では、リロード機能が有効になっている場合の動作について説明します。
手順
リロード機能がデフォルト設定 (refresh モード) で有効になっていることを仮定します。ConfigMap の変更時に以下の Beanが更新されます。
@Configuration @ConfigurationProperties(prefix = "bean") public class MyConfig { private String message = "a message that can be changed live"; // getter and setters }
変更の詳細を確認するには、以下のようにメッセージを定期的に出力する別の Bean を作成します。
@Component public class MyBean { @Autowired private MyConfig config; @Scheduled(fixedDelay = 5000) public void hello() { System.out.println("The message is: " + config.getMessage()); } }
以下のように 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
-
リロードの実行時に使用するストラテジー (
refresh
、restart_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 プロジェクトを作成するには、以下の手順にしたがいます。
手順
- システムの適切なディレクトリーに移動します。
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
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.fis
、artifactId
の値にはfuse74-karaf-camel-log
を入力します。残りのフィールドにはデフォルト値を使用します。- サンプルのビルドおよびデプロイ方法については、クイックスタートの手順にしたがいます。
使用できる 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 カタログには以下の例が含まれます。
名前 | 説明 |
---|---|
| Camel amq コンポーネントを使用して、Apache ActiveMQ メッセージブローカーとメッセージを送受信する方法を実証します。 |
| メッセージを 5 秒おきにサーバーに記録する、簡単な Apache Camel アプリケーションを実証します。 |
| Camel の REST DSL とともに JDBC を介して SQL を使用し、RESTful API を公開する方法を実証します。 |
| 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 フィルに追加します。
手順
-
プロジェクトの
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 エクステンションによって使用される機能を提供します。
手順
プロジェクトの
pom.xml
を開き、fabric8-karaf-core
をstartupFeatures
セクションに追加します。<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
サービスは、異なるプロパティープレースホルダー解決ストラテジーのコレクターとして動作します。デフォルトで提供される解決ストラテジーの一覧は「解決ストラテジー」を参照してください。プロパティープレースホルダーサービスのオプションを設定するには、システムプロパティーと環境変数のどちらかか両方を使用します。
手順
OpenShift で ConfigMap にアクセスするには、サービスアカウントに view パーミッションが必要になります。view パーミッションをサービスアカウントに追加します。
oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
- API 経由での Secret へのアクセスは制限されている可能性があるため、Secret を Pod にマウントします。
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 がリゾルバーを使用できるようにすることもできます。
手順
以下の mvn 依存関係をプロジェクトの
pom.xml
に追加します。pom.xml
--- <dependency> <groupId>io.fabric8</groupId> <artifactId>fabric8-karaf-core</artifactId> </dependency> ---
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; } }
以下のように、設定管理でリゾルバーを参照することができます。
properties
my.property = $[myResolver:value-to-resolve]
10.4.5. 解決ストラテジーの一覧
PlaceholderResolver
サービスは、異なるプロパティープレースホルダー解決ストラテジーのコレクターとして動作します。デフォルトで提供される解決ストラテジーを以下の表に示します。
- 解決ストラテジーの一覧
接頭辞 | 例 | 説明 |
|
| OS 環境変数からプロパティーを検索します。 |
`sys |
| Java JVM システムプロパティーからプロパティーを検索します。 |
`service |
| サービス命名規則を使用して、OS 環境変数からプロパティーを検索します。 |
|
| ホスト名の部分のみを返すサービス命名規則を使用して、OS 環境変数からプロパティーを検索します。 |
|
| ポートの部分のみを返すサービス命名規則を使用して、OS 環境変数からプロパティーを検索します。 |
|
| Kubernetes ConfigMap (API 経由) からプロパティーを検索します。 |
|
| Kubernetes の Secret (API またはボリュームマウント経由) からプロパティーを検索します。 |
10.4.6. プロパティープレースホルダーサービスのオプション一覧
プロパティープレースホルダーサービスは以下のオプションをサポートします。
- プロパティープレースホルダーサービスのオプション一覧
名前 | デフォルト | 説明 |
---|---|---|
| $[ | プレースホルダーの接頭辞。 |
| ] | プレースホルダーの接尾辞。 |
| null | Secret がマップされたパスのコンマ区切りリスト。 |
| false | API 経由で Secret の消費を有効または無効にする。 |
10.5. Fabric8 Karaf の設定管理サポートの追加
10.5.1. Fabric8 Karaf の設定管理サポートの追加
カスタムの Karaf ディストリビューションに Fabric8 Karaf の設定管理サポートを追加できます。
手順
プロジェクトの
pom.xml
を開き、fabric8-karaf-cm
をstartupFeatures
セクションに追加します。pom.xml
<startupFeatures> ... <feature>fabric8-karaf-cm</feature> ... </startupFeatures>
10.5.2. ConfigMap インジェクションの追加
fabric8-karaf-cm
は、Karaf の ConfigAdmin
に ConfigMap
の値をインジェクトする ConfigAdmin
ブリッジを提供します。
手順
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
設定を定義するには、単一のプロパティー名を使用できます。ほとんどの場合で個別のプロパティーは動作します。これは
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.enabled
を true
に設定する必要があります。たとえば、以下のように 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 を選択します。サポートされる構文は以下のとおりです。
たとえば、-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-blueprint
は Aries 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 コンテキストがすべて開始済み状態である。
手順
プロジェクトの
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 プロジェクトを作成することもできます。
手順
view
ロールをデフォルトのサービスアカウントに追加して、クラスタリングを有効にします。これにより、view
サービスアカウントへのdefault
アクセス権限がユーザーに付与されます。サービスアカウントは、ビルド、デプロイメント、およびその他の Pod を実行するために各プロジェクトで必要になります。シェルプロンプトに以下のoc
クライアントコマンドを入力します。oc login -u developer -p developer oc policy add-role-to-user view -z default
-
ブラウザーで https://OPENSHIFT_IP_ADDR:8443 の OpenShift コンソールに移動します (
OPENSHIFT_IP_ADDR
は CDK の場合で表示された IP アドレスに置き換えます)。クレデンシャル (例: ユーザー名developer
、パスワードdeveloper
) を使用して、コンソールにログインします。 カタログ検索フィールドに検索文字列として
Red Hat Fuse 7.4 Camel CDI with EAP
を入力し、Red Hat Fuse 7.4 Camel CDI with EAP テンプレートを選択します。- テンプレートウィザードの Information ステップが開きます。Next をクリックします。
テンプレートウィザードの Configuration ステップが開きます。Add to Project ドロップダウンメニューで My Project を選択します。
注記この例で新しいプロジェクトを作成したい場合は、上記の手順の代わりに Add to Project ドロップダウンメニューで Create Project を選択します。新規プロジェクトの名前を入力する Project Name フィールドが表示されます。
Configuration ステップの残りの設定では、デフォルトの値を使用します。Create をクリックします。
注記クイックスタートをそのまま実行せずに、アプリケーションコードを変更する場合は、元のクイックスタート Git リポジトリーをフォークし、Git Repository URL および Git Reference フィールドに適切な値を入力する必要があります。
- テンプレートウィザードの Results ステップが開きます。Close をクリックします。
- 右側の My Projects ペインで My Project をクリックします。My Project プロジェクトの Overview タブが開き、s2i-fuse74-eap-camel-cdi アプリケーションが表示されます。
s2i-fuse74-eap-camel-cdi デプロイメントの左にある矢印をクリックし、このデプロイメントの詳細を展開および表示します。
このビューにビルドログが表示されます。何らかの理由でビルドに失敗した場合は、ビルドログを参照して問題を診断します。
注記リモートの Maven リポジトリーから多くの依存関係をダウンロードする必要があるため、ビルドが完了するまで数分かかることがあります。ビルド時間を短縮するには、ローカルネットワークに Nexus サーバーをデプロイすることが推奨されます。
ビルドが正常に完了したら、Pod アイコンは 1 つの Pod が実行している青い円で表示されます。
アプリケーションを開くには、アプリケーションの詳細の上に表示される、
http://s2i-fuse74-eap-camel-cdi-myproject.IP_ADDRESS.nip.io/
形式のリンクをクリックします。これにより、ブラウザーで以下のようなメッセージが表示されます。Hello world from 172.17.0.3
URL の
name
パラメーターを使用して名前を指定することもできます。たとえば、ブラウザーに URLhttp://s2i-fuse74-eap-camel-cdi-myproject.IP_ADDRESS.nip.io/?name=jdoe
を入力すると、以下のような応答が表示されます。Hello jdoe from 172.17.0.3
-
左側のナビゲーションバーにある Overview をクリックし、
My Project
namespace のアプリケーション概要に戻ります。実行中の Pod をシャットダウンするには、Pod アイコンの横にある下矢印 をクリックします。Scale down deployment s2i-fuse74-eap-camel-cdi-1? というダイアログが表示されたら、Scale Down をクリックします。 (任意): 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 テンプレートが提供されます。
名前 | 説明 |
---|---|
JBoss Fuse 7.4 Camel A-MQ with EAP ( | camel-activemq コンポーネントを使用して、OpenShift 上で実行している AMQ メッセージブローカーに接続します。ブローカーがすでにデプロイされていることを前提とします。 |
Red Hat Fuse 7.4 Camel CDI with EAP ( | camel-cdi コンポーネントを使用して、CDI Bean を Camel ルートに統合します。 |
Red Hat Fuse 7.4 CXF JAX-RS with EAP ( | camel-cxf コンポーネントを使用して JAX-RS REST サービスを作成および消費します。 |
Red Hat Fuse 7.4 CXF JAX-WS with EAP ( | camel-cxf コンポーネントを使用して JAX-WS Web サービスを作成および消費します。 |
Red Hat Fuse 7.4 Camel JPA + MySQL (Ephemeral) with EAP | 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 クレームを作成すると、このストレージにアクセスできます。
手順
以下の設定例を使用して
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
ディレクトリーをプロビジョニングします。PersistentVolume
を作成します。oc create -f pv.yaml
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
参照を定義します。
手順
以下のように、ファイルシステムで
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
ディレクトリーに書き込まれたすべてのデータがコンテナーの再起動後も保持されるようになりました。この設定を Fuse on OpenShift アプリケーションの
src/main/fabric8/deployment.yml
ファイルに追加し、以下のコマンドを使用して OpenShift リソースを作成します。mvn fabric8:resource-apply
作成した 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
手順
通常、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...
各イメージストリームを 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 テンプレートを最新のパッチレベルに更新する必要があります。
手順
Fuse on OpenShift テンプレートの更新には管理者権限が必要です。以下のように、OpenShift サーバーに管理者としてログインします。
oc login URL -u ADMIN_USER -p ADMIN_PASS
ここで、
URL
は OpenShift サーバーの URL に置き換え、ADMIN_USER
およびADMIN_PASS
には OpenShift サーバーの管理者アカウントのクレデンシャルを使用します。パッチが適用された 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 バージョンを表しています。
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 プラグインのゴールには以下が含まれます。
-
spring-boot:run
は Spring Boot アプリケーションを実行します。 -
spring-boot:repackage
は、.jar
および.war
ファイルを再パッケージして実行可能にします。 -
spring-boot:start
およびspring-boot:stop
の両方は、Spring Boot アプリケーションのライフサイクルを管理するために使用されます。 -
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 開発環境を提供するゴールのセットをサポートします。ゴールは以下のように分類できます。
C.3.1. ビルドおよび開発ゴールの理解
Red Hat Fabric Integration Services 製品の Fabric8 Maven プラグインによってサポートされるゴールは次のとおりです。
ゴール | 説明 |
---|---|
fabric8:build |
ビルドイメージ。Fuse on OpenShift では、OpenShift |
fabric8:resource | Kubernetes または OpenShift リソース記述子を作成します。 |
fabric8:apply | リソースを実行中のクラスターに適用します。 |
fabric8:resource-apply |
|
ゴール | 説明 |
---|---|
fabric8:run |
フォアグラウンドで完全な開発ワークフローサイクル |
fabric8:deploy |
リソース記述子の作成後にクラスターへデプロイし、アプリケーションをビルドします。バックグラウンドで実行すること以外は |
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 仕様を使用して、生成されたリソース記述子を検証します。
設定 | 説明 | デフォルト |
---|---|---|
| 値が true に設定されている場合、リソース検証はスキップされます。これは、何らかの理由でリソース検証に失敗してもデプロイメントを継続したい場合に便利です。 | false |
| 値が true に設定されている場合、検証エラーによってプラグインの実行がブロックされます。true に設定されていない場合は警告が表示されます。 | false |
| 値が true に設定され、OpenShift で ImageStreams を使用していない場合、fabric8-maven-plugin は DeploymentConfig ではなく Deployments に切り替わります。 | false |
|
値が true に設定されている場合、コンテナーイメージ参照が "" に設定されます。これは、後続のロールアウトによって | 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-1
や 1.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
になります。
このジェネレーターは一般的なジェネレーターオプションの他に、以下のオプションで設定することができます。
要素 | 説明 | デフォルト |
---|---|---|
assemblyRef | アセンブリーへの参照が指定されている場合は、含めるアーティファクトの検出を行わずに使用されます。 | |
targetDir | 検出されたアーティファクトが配置される生成されたイメージ内のディレクトリー。ベースイメージも変更された場合のみ変更します。 |
|
jolokiaPort | ベースイメージによって公開される Jolokia エージェントのポート。Jolokia ポートを公開したくない場合はこれを 0 に設定します。 | 8778 |
mainClass |
呼び出すメインクラス。指定のない場合は次のようにジェネレーターがメインクラスを検索します。最初に、fat-jar を検出するためにチェックが実行されます。次に、 | |
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
を見つけるとアクティベートされます。
このジェネレーターは一般的なジェネレーターオプションの他に、以下のオプションで設定することができます。
要素 | 説明 | デフォルト |
---|---|---|
baseDir | 検出されたアーティファクトが配置される生成されたイメージ内のディレクトリー。ベースイメージも変更された場合のみ変更します。 |
|
jolokiaPort | ベースイメージによって公開される Jolokia エージェントのポート。Jolokia ポートを公開したくない場合はこれを 0 に設定します。 | 8778 |
mainClass |
呼び出すメインクラス。指定のない場合は次のようにジェネレーターがメインクラスを検索します。最初に、fat-jar を検出するためにチェックが実行されます。次に、 | |
user |
ファイルを追加するユーザーやグループ。ベースイメージにユーザーがすでに存在している必要があります。通常の形式は |
|
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 バージョンが見つかった場合に失敗するかどうか。デフォルトでは、 |
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_DIR
はJAVA_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
- コンテナーに指定されたメモリー制限