翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# RabbitMQ のチュートリアル
以下のチュートリアルでは、Amazon MQ で RabbitMQ を設定して使用する方法を説明します。サポートされているクライアントライブラリを Node.js、Python、.NET などのさまざまなプログラミング言語で使用する方法の詳細については、「*RabbitMQ Getting Started Guide*」の「[RabbitMQ Tutorials](https://www.rabbitmq.com/getstarted.html)」を参照してください。
**Topics**
+ [ブローカー設定の編集](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ [Amazon MQ for RabbitMQ でPython Pika を使う](amazon-mq-rabbitmq-pika.md)
+ [RabbitMQ の一時停止されたキュー同期の解決](rabbitmq-queue-sync.md)
+ [接続およびチャネルの数の削減](reducing-connections-and-channels.md)
+ [ステップ 2: ブローカーに JVM ベースのアプリケーションを接続する](#rabbitmq-connect-jvm-application)
+ [Connect your Amazon MQ for RabbitMQ broker to Lambda](#rabbitmq-connect-to-lambda)
+ [Amazon MQ for RabbitMQ での OAuth 2.0 認証と認可の使用](oauth-tutorial.md)
+ [Amazon MQ for RabbitMQ での IAM 認証と認可の使用](rabbitmq-iam-tutorial.md)
+ [Amazon MQ for RabbitMQ での LDAP 認証と認可の使用](rabbitmq-ldap-tutorial.md)
+ [Amazon MQ for RabbitMQ での HTTP 認証と認可の使用](rabbitmq-http-tutorial.md)
+ [Amazon MQ for RabbitMQ での SSL 証明書認証の使用](rabbitmq-ssl-tutorial.md)
+ [AMQP および管理エンドポイントに mTLS を使用する](rabbitmq-mtls-tutorial.md)
+ [JMS アプリケーションを接続する](rabbitmq-tutorial-jms.md)
# ブローカー設定の編集
を使用して CloudWatch ログの有効化や無効化など、ブローカーの設定を編集できます AWS マネジメントコンソール。
## RabbitMQ ブローカーオプションを編集する
1. [Amazon MQ コンソール](https://console.aws.amazon.com/amazon-mq/)にサインインします。
1. ブローカーリストからブローカーを選択して (**MyBroker** など)、[**Edit**] (編集) をクリックします。
1. [***MyBroker* の編集**] ページの [**仕様**] セクションで、[**ブローカーエンジンのバージョン**] または [**ブローカーインスタンスタイプ**] を選択します。
1. [**CloudWatch Logs**] セクションのトグルボタンをクリックして、一般ログを有効化または無効化します。これ以上のステップは必要ありません。
**注記**
RabbitMQ ブローカーの場合、Amazon MQ は自動的にサービスリンクロール (SLR) を使用して、CloudWatch に一般ログを発行します。詳細については、「[Amazon MQ のサービスリンクロールの使用](using-service-linked-roles.md)」を参照してください。
Amazon MQ は、RabbitMQ ブローカーに対する監査ロギングをサポートしません。
1. [**Maintenance (メンテナンス)**] セクションで、ブローカーのメンテナンススケジュールを設定します。
ブローカーを AWS リリース時に新しいバージョンにアップグレードするには、「自動**マイナーバージョンアップグレードを有効にする**」を選択します。自動アップグレードは、曜日、時刻 (24 時間形式)、およびタイムゾーン (デフォルトは UTC) で定義された*メンテナンスウィンドウ*中に行われます。
1. [**Schedule modifications (スケジュールの変更)**] を選択します。
**注記**
[**自動マイナーバージョンのアップグレードを有効にする**] のみを選択した場合、ブローカーの再起動が必要ないため、ボタンは [**保存**] に変わります。
設定が指定された時刻にブローカーに適用されます。
# Amazon MQ for RabbitMQ でPython Pika を使う
次のチュートリアルでは、Amazon MQ for RabbitMQ ブローカーに接続するように構成された TLS を使用して [Python Pika](https://github.com/pika/pika) クライアントをセットアップする方法を示しています。Pika は RabbitMQ のための AMQP 0-9-1 プロトコルの Python 実装です。このチュートリアルでは、Pika のインストール、キューの宣言、ブローカーのデフォルトエクスチェンジにメッセージを送信するパブリッシャーの設定、キューからメッセージを受信するコンシューマーの設定について説明します。
**Topics**
+ [前提条件](#amazon-mq-rabbitmq-pika-prerequisites)
+ [権限](#amazon-mq-rabbitmq-pika-permissions)
+ [ステップ 1: 基本的な Python Pika クライアントを作成する](#amazon-mq-rabbitmq-pika-basic-client)
+ [ステップ 2: パブリッシャーを作成してメッセージを送信する](#amazon-mq-rabbitmq-pika-publisher-basic-publish)
+ [ステップ 3: コンシューマーを作成してメッセージを受信する](#amazon-mq-rabbitmq-pika-consumer-basic-get)
+ [ステップ 4: (オプション) イベントループを設定し、メッセージを消費する](#amazon-mq-rabbitmq-pika-consumer-basic-consume)
+ [次のステップ](#amazon-mq-rabbitmq-pika-whats-next)
## 前提条件
このチュートリアルの最初のステップを完了するには、以下のものが必要です。
+ Amazon MQ for RabbitMQ ブローカー。詳細については、「[Amazon MQ for RabbitMQ ブローカーを作成する](getting-started-rabbitmq.md#create-rabbitmq-broker)」を参照してください。
+ オペレーティングシステム用に [Python 3](https://www.python.org/downloads/) がインストールされています。
+ Python `pip` を使用して、[Pika](https://pika.readthedocs.io/en/stable/) がインストールされました。Pika をインストールするには、新しいターミナルウィンドウを開き、以下を実行します。
```
$ python3 -m pip install pika
```
## 権限
このチュートリアルでは、vhost への書き込みおよび読み取りの許可を持つ Amazon MQ for RabbitMQ ブローカーユーザーが少なくとも 1 人必要です。次の表は、正規表現 (regexp) パターンに必要な最小アクセス許可を示しています。
| タグ | 設定 regexp | 書き込み regexp | 読み込み regexp |
| --- | --- | --- | --- |
| none | | .\$1 | .\$1 |
リストされているユーザー許可は、ブローカで管理オペレーションを実行するための管理プラグインへのアクセスを付与することなく、ユーザーに読み取りおよび書き込み許可のみを提供します。特定のキューへのユーザーのアクセスを制限する正規表現パターンを提供することで、許可をさらに制限できます。例えば、読み取り regexp パターンを `^[hello world].*` に変更する場合、ユーザーには `hello world` で始まるキューからの読み取り許可のみが付与されます。
RabbitMQ ユーザーの作成、およびユーザータグと許可の管理の詳細については、「[Amazon MQ for RabbitMQ ブローカーのユーザー](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user)」を参照してください。
## ステップ 1: 基本的な Python Pika クライアントを作成する
Amazon MQ for RabbitMQ ブローカーと対話するときに、コンストラクタを定義し、TLS 設定に必要な SSL コンテキストを提供する Python Pika クライアント基本クラスを作成するには、次の手順を実行します。
1. 新しいターミナルウィンドウを開き、プロジェクトの新しいディレクトリを作成し、そのディレクトリに移動します。
```
$ mkdir pika-tutorial
$ cd pika-tutorial
```
1. 以下の Python コードを含む `basicClient.py` というファイルを作成します。
```
import ssl
import pika
class BasicPikaClient:
def __init__(self, rabbitmq_broker_id, rabbitmq_user, rabbitmq_password, region):
# SSL Context for TLS configuration of Amazon MQ for RabbitMQ
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.set_ciphers('ECDHE+AESGCM:!ECDSA')
url = f"amqps://{rabbitmq_user}:{rabbitmq_password}@{rabbitmq_broker_id}.mq.{region}.amazonaws.com:5671"
parameters = pika.URLParameters(url)
parameters.ssl_options = pika.SSLOptions(context=ssl_context)
self.connection = pika.BlockingConnection(parameters)
self.channel = self.connection.channel()
```
パブリッシャーとコンシューマに対して、`BasicPikaClient` から継承する追加のクラスを定義できるようになりました。
## ステップ 2: パブリッシャーを作成してメッセージを送信する
キューを宣言し、1 つのメッセージを送信するパブリッシャを作成するには、次の手順を実行します。
1. 次のコードサンプルの内容をコピーし、前のステップで作成した同じディレクトリで、`publisher.py` と名前を付けてローカルに保存します。
```
from basicClient import BasicPikaClient
class BasicMessageSender(BasicPikaClient):
def declare_queue(self, queue_name):
print(f"Trying to declare queue({queue_name})...")
self.channel.queue_declare(queue=queue_name)
def send_message(self, exchange, routing_key, body):
channel = self.connection.channel()
channel.basic_publish(exchange=exchange,
routing_key=routing_key,
body=body)
print(f"Sent message. Exchange: {exchange}, Routing Key: {routing_key}, Body: {body}")
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Initialize Basic Message Sender which creates a connection
# and channel for sending messages.
basic_message_sender = BasicMessageSender(
"",
"",
"",
""
)
# Declare a queue
basic_message_sender.declare_queue("hello world queue")
# Send a message to the queue.
basic_message_sender.send_message(exchange="", routing_key="hello world queue", body=b'Hello World!')
# Close connections.
basic_message_sender.close()
```
`BasicMessageSender` クラスは `BasicPikaClient` から継承され、キューの宣言、キューへのメッセージの送信、および接続を閉じるための追加のメソッドを実装します。コードサンプルでは、キューの名前と等しいルーティングキーを使用して、メッセージをデフォルトの交換にルーティングします。
1. [`if __name__ == "__main__":`] で、渡されたパラメータを次の情報を含む `BasicMessageSender` コンストラクターステートメントで置換します。
+ **``** – Amazon MQ がブローカー用に生成する一意の ID です。ID は、ブローカー ARN から解析できます。例えば、`arn:aws:mq:us-east-2:123456789012:broker:MyBroker:b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9` という ARN の場合、ブローカー ID は `b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9` になります。
+ **``** - ブローカにメッセージを書き込むのに十分な許可を持つブローカユーザーのユーザー名。
+ **``** - ブローカにメッセージを書き込むのに十分な許可を持つブローカユーザーのパスワード。
+ **``** – Amazon MQ for RabbitMQ ブローカーを作成した AWS リージョン。例えば、`us-west-2`。
1. `publisher.py` を作成した同じディレクトリで次のコマンドを実行します。
```
$ python3 publisher.py
```
コードが正常に実行された場合、ターミナルウィンドウに次の出力が表示されます。
```
Trying to declare queue(hello world queue)...
Sent message. Exchange: , Routing Key: hello world queue, Body: b'Hello World!'
```
## ステップ 3: コンシューマーを作成してメッセージを受信する
キューから単一のメッセージを受信するコンシューマーを作成するには、次の手順を実行します。
1. 次のコードサンプルの内容をコピーし、同じディレクトリで、`consumer.py` と名前を付けてローカルに保存します。
```
from basicClient import BasicPikaClient
class BasicMessageReceiver(BasicPikaClient):
def get_message(self, queue):
method_frame, header_frame, body = self.channel.basic_get(queue)
if method_frame:
print(method_frame, header_frame, body)
self.channel.basic_ack(method_frame.delivery_tag)
return method_frame, header_frame, body
else:
print('No message returned')
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection
# and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
basic_message_receiver.get_message("hello world queue")
# Close connections.
basic_message_receiver.close()
```
前のステップで作成したパブリッシャーと同様に、 は から`BasicMessageReceiver`継承`BasicPikaClient`し、単一のメッセージを受信して接続を閉じるための追加のメソッドを実装します。
1. `if __name__ == "__main__":` ステートメントで、渡されたパラメータを次の情報を含む `BasicMessageReceiver` コンストラクターに置換します。
1. プロジェクトディレクトリで次のコマンドを実行します。
```
$ python3 consumer.py
```
コードが正常に実行されると、メッセージ本文とルーティングキーを含むヘッダーがターミナルウィンドウに表示されます。
```
b'Hello World!'
```
## ステップ 4: (オプション) イベントループを設定し、メッセージを消費する
キューから複数のメッセージを消費するには、Pika の [https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume](https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume) メソッドと、次に示すコールバック関数を使用します
1. `consumer.py` で、`BasicMessageReceiver` クラスに以下のメソッド定義を追加します。
```
def consume_messages(self, queue):
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
self.channel.basic_consume(queue=queue, on_message_callback=callback, auto_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
self.channel.start_consuming()
```
1. `consumer.py` の `if __name__ == "__main__":` の下で、前のステップで定義した `consume_messages` メソッドを呼び出します。
```
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
# basic_message_receiver.get_message("hello world queue")
# Consume multiple messages in an event loop.
basic_message_receiver.consume_messages("hello world queue")
# Close connections.
basic_message_receiver.close()
```
1. `consumer.py` をもう一度実行し、成功すると、キューに入れられたメッセージがターミナルウィンドウに表示されます。
```
[*] Waiting for messages. To exit press CTRL+C
[x] Received b'Hello World!'
[x] Received b'Hello World!'
...
```
## 次のステップ
+ サポートされている他の RabbitMQ クライアントライブラリの詳細については、RabbitMQ のウェブサイトの「[RabbitMQ クライアントドキュメント](https://www.rabbitmq.com/clients.html)」を参照してください。
# RabbitMQ の一時停止されたキュー同期の解決
Amazon MQ for RabbitMQ [クラスターデプロイ](rabbitmq-broker-architecture.md#rabbitmq-broker-architecture-cluster)では、各キューに発行されたメッセージが 3 つのブローカーノード全体にレプリケートされます。*ミラーリング*と呼ばれるこのレプリケーションは、RabbitMQ ブローカーに高可用性 (HA) を提供します。クラスターデプロイ内のキューは、1 つのノード上にある*メイン*レプリカと、1 つ、または複数の*ミラー*で構成されています。ミラーキューに適用されるすべての操作 (メッセージのキュー登録など) は、まずメインキューに適用され、その後ミラー全体にレプリケートされます。
例えば、メインノード (`main`) と 2 つのミラー (`mirror-1` および `mirror-2`) の 3 つのノード全体にレプリケートされたミラーキューについて考えてみましょう。このミラーキュー内のすべてのメッセージがすべてのミラーに正常に伝播されると、キューが同期されたことになります。ノード (`mirror-1`) が一定期間使用できなくなった場合でも、キューは引き続き動作可能で、メッセージのキュー登録を継続できますが、キューを同期するには、`mirror-1` が使用不可である間に `main` に発行されたメッセージが `mirror-1` にレプリケートされる必要があります。
ミラーリングの詳細については、RabbitMQ ウェブサイトで「[Classic Mirrored Queues](https://www.rabbitmq.com/ha.html)」を参照してください。
**メンテナンスとキューの同期**
[メンテナンスウィンドウ](amazon-mq-rabbitmq-editing-broker-preferences.md#rabbitmq-edit-current-configuration-console)中、Amazon MQ はすべてのメンテナンス作業を一度に 1 ノードずつ実行して、ブローカーが動作可能な状態を維持することを確実にします。その結果、各ノードが操作を再開するときに、キューが同期する必要が生じる場合があります。同期中、ミラーにレプリケートする必要があるメッセージは、バッチで処理されるように、対応する Amazon Elastic Block Store (Amazon EBS) ボリュームからメモリにロードされます。メッセージをバッチで処理することにより、キューの同期が速くなります。
キューを短くし、メッセージを小さくしておくと、キューが正常に同期し、期待通りに操作を再開します。ただし、バッチ内のデータ量がノードのメモリ制限に近づいた場合は、ノードが高メモリアラームを発し、キューの同期を一時停止します。メモリ使用量は、[CloudWatch で `RabbitMemUsed` および `RabbitMqMemLimit` のブローカーノードメトリクス](amazon-mq-accessing-metrics.md)を比較することで確認できます。同期は、メッセージが消費もしくは削除される、またはバッチ内のメッセージの数が減るまで完了できません。
**注記**
キューの同期のバッチサイズを小さくすると、レプリケーショントランザクション数の増加につながる可能性があります。
一時停止されたキューの同期を解決するには、`ha-sync-batch-size` ポリシーの適用とキューの同期の再開について説明する、このチュートリアルのステップに従ってください。
**Topics**
+ [前提条件](#rabbitmq-queue-sync-prerequisites)
+ [ステップ 1: `ha-sync-batch-size` ポリシーを適用する](#rabbitmq-queue-sync-step-1)
+ [ステップ 2: キューの同期を再開する](#rabbitmq-queue-sync-step-2)
+ [次の手順](#rabbitmq-queue-sync-next-steps)
+ [関連リソース](#rabbitmq-queue-sync-related-resources)
## 前提条件
このチュートリアルには、管理者権限を持つ Amazon MQ for RabbitMQ ブローカーユーザーが必要です。ブローカーを初めて作成したときに作成された管理者ユーザー、またはその後で作成した別のユーザーを使用できます。以下の表は、正規表現 (regexp) パターンとしての必要な管理者ユーザータグと許可です。
| タグ | 読み込み regexp | 設定 regexp | 書き込み regexp |
| --- | --- | --- | --- |
| administrator | .\$1 | .\$1 | .\$1 |
RabbitMQ ユーザーの作成、およびユーザータグと許可の管理の詳細については、「[Amazon MQ for RabbitMQ ブローカーのユーザー](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user)」を参照してください。
## ステップ 1: `ha-sync-batch-size` ポリシーを適用する
以下の手順では、ブローカーで作成されたすべてのキューに適用されるポリシーの追加について説明します。RabbitMQ ウェブコンソールまたは RabbitMQ Management API を使用できます。詳細については、RabbitMQ ウェブサイトの「[Management Plugin](https://www.rabbitmq.com/management.html)」を参照してください。
**RabbitMQ ウェブコンソールを使用して `ha-sync-batch-size` ポリシーを適用する**
1. [Amazon MQ コンソール](https://console.aws.amazon.com/amazon-mq/)にサインインします。
1. 左側のナビゲーションペインで [**Brokers**] (ブローカー) をクリックします。
1. ブローカーのリストから、新しいポリシーを適用するブローカーの名前を選択します。
1. ブローカーのページの [**Connections**] (接続) セクションで、**RabbitMQ ウェブコンソール** URL をメモします。新しいブラウザタブまたはウィンドウに RabbitMQ ウェブコンソールが開きます。
1. ブローカー管理者のサインイン認証情報を使用して RabbitMQ ウェブコンソールにログインします。
1. RabbitMQ ウェブコンソールのページ上部で、[**Admin**] (管理) をクリックします。
1. [**Admin**] (管理) ページの右側にあるナビゲーションペインで [**Policies**] (ポリシー) をクリックします。
1. [**Policies**] (ポリシー) ページに、ブローカーの現在の [**User policies**] (ユーザーポリシー) が表示されます。[**User policies**] (ユーザーポリシー) の下で、[**Add / update a policy] (ポリシーの追加/更新**) を展開します。
**注記**
デフォルトで、Amazon MQ for RabbitMQ クラスターは、`ha-all-AWS-OWNED-DO-NOT-DELETE` という名前の初期ブローカーポリシーを使用して作成されます。Amazon MQ はこのポリシーを管理して、ブローカー上のすべてのキューが 3 つのノードすべてにレプリケートされ、キューが自動的に同期化されることを確実にします。
1. 新しいブローカーポリシーを作成するには、[**Add / update a policy**] (ポリシーの追加/更新) で以下を実行します。
1. [**Name**] (名前) には、ポリシーの名前 (**batch-size-policy** など) を入力します。
1. [**Pattern**] (パターン) には regexp パターン **.\$1** を入力して、ポリシーがブローカー上のすべてのキューと一致するようにします。
1. [**Apply to**] (適用先) には、ドロップダウンリストから [**Exchanges and queues**] (エクスチェンジとキュー) を選択します。
1. [**Priority**] (優先順位) には、vhost に適用されたその他すべてのポリシーよりも大きい整数を入力します。RabbitMQ のキューとエクスチェンジに適用できるのは、常に 1 つのポリシー定義セットのみです。RabbitMQ は、一致するポリシーで、最高の優先順位値を持つものを選択します。ポリシーの優先順位とポリシーの結合方法の詳細については、RabbitMQ サーバードキュメントの「[Policies](https://www.rabbitmq.com/parameters.html#policies)」を参照してください。
1. [**Definition**] (定義) には、以下のキーバリューペアを追加します。
+ **ha-sync-batch-size**=*100*。ドロップダウンリストから [**Number**] (数値) を選択します。
**注記**
`ha-sync-batch-size` の値は、キュー内の同期されていないメッセージの数とサイズに基づいて調整と較正を行う必要がある場合があります。
+ **ha-mode**=**all**。ドロップダウンリストから [**String**] (文字列) を選択します。
**重要**
`ha-mode` 定義は、すべての HA 関連ポリシーに必須です。省略すると、検証が失敗します。
+ **ha-sync-mode**=**automatic**。ドロップダウンリストから [**String**] (文字列) を選択します。
**注記**
`ha-sync-mode` 定義は、すべてのカスタムポリシーに必須です。省略すると、Amazon MQ が定義を自動的に付加します。
1. [**Add / update policy**] (ポリシーを追加/更新) をクリックします。
1. [**User policies**] (ユーザーポリシー) リストに新しいポリシーが表示されることを確認します。
**RabbitMQ Management API を使用して `ha-sync-batch-size` ポリシーを適用する**
1. [Amazon MQ コンソール](https://console.aws.amazon.com/amazon-mq/)にサインインします。
1. 左側のナビゲーションペインで [**Brokers**] (ブローカー) をクリックします。
1. ブローカーのリストから、新しいポリシーを適用するブローカーの名前を選択します。
1. ブローカーのページの [**Connections**] (接続) セクションで、**RabbitMQ ウェブコンソール** URL をメモします。これは、HTTP リクエストで使用するブローカーエンドポイントです。
1. 任意の新しいターミナルまたはコマンドラインウィンドウを開きます。
1. 新しいブローカーポリシーを作成するには、以下の `curl` コマンドを入力します。このコマンドでは、`%2F` としてエンコードされているデフォルト `/` vhost 上のキューを前提としています。
**注記**
*ユーザー名*と*パスワード*を、ブローカー管理者のサインイン認証情報に置き換えます。`ha-sync-batch-size` の値 (*100*) は、キュー内の同期されていないメッセージの数とサイズに基づいて調整と較正を行う必要がある場合があります。ブローカーエンドポイントを先ほどメモした URL に置き換えます。
```
curl -i -u username:password -H "content-type:application/json" -XPUT \
-d '{"pattern":".*", "priority":1, "definition":{"ha-sync-batch-size":100, "ha-mode":"all", "ha-sync-mode":"automatic"}}' \
https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies/%2F/batch-size-policy
```
1. 新しいポリシーがブローカーのユーザーポリシーに追加されていることを確認するには、以下の `curl` コマンドを入力して、すべてのブローカーポリシーをリストします。
```
curl -i -u username:password https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies
```
## ステップ 2: キューの同期を再開する
ブローカーに新しい `ha-sync-batch-size` ポリシーを適用したら、キューの同期を再開します。
**RabbitMQ ウェブコンソールを使用してキューの同期を再開する**
**注記**
RabbitMQ ウェブコンソールを開くには、このチュートリアルのステップ 1 にある前述の手順を参照してください。
1. RabbitMQ ウェブコンソールのページ上部で、[**Queues**] (キュー) をクリックします。
1. [**Queues**] (キュー) ページの [**All queues**] (すべてのキュー) で、一時停止されたキューを見つけます。**[ポリシー]** 行に、キューが作成された新しいポリシーの名前をリストします (`batch-size-policy` など)。
1. 縮小されたバッチサイズで同期プロセスを再開するには、まずキュー同期をキャンセルします。次に、キュー同期を再起動します。
**注記**
同期が一時停止して正常に終了しない場合は、`ha-sync-batch-size` の値を低くして、もう一度キューの同期を再開してみてください。
## 次の手順
+ キューが正常に同期化されたら、Amazon CloudWatch メトリクス `RabbitMQMemUsed` を表示することで、RabbitMQ ノードが使用するメモリの量をモニタリングできます。`RabbitMQMemLimit` メトリクスを表示して、ノードのメモリ制限をモニタリングすることもできます。詳細については、「[Amazon MQ 向けの CloudWatch メトリクスへのアクセス](amazon-mq-accessing-metrics.md)」および「[Amazon MQ for RabbitMQ ブローカーで利用可能な CloudWatch メトリクス](rabbitmq-logging-monitoring.md)」を参照してください。
+ キューの同期が一時停止しないようにするため、キューを短くしておき、メッセージを処理することをお勧めします。メッセージサイズが大きいワークロードの場合は、より多くのメモリを備えたより大きなインスタンスサイズにブローカーインスタンスタイプをアップグレードすることもお勧めします。ブローカーインスタンスタイプとブローカー設定の編集に関する詳細については、「[ブローカー設定の編集](amazon-mq-rabbitmq-editing-broker-preferences.md)」を参照してください。
+ 新しい Amazon MQ for RabbitMQ ブローカーを作成するときは、ブローカーのパフォーマンスを最適化するために、Amazon MQ が一連のデフォルトブローカーポリシーと仮想ホスト制限を適用します。お使いのブローカーに推奨されるデフォルトのポリシーと制限がない場合は、独自のポリシーと制限を作成することをお勧めします。デフォルトのポリシーと vhost 制限の作成に関する詳細については、「[https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html](https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html)」を参照してください。
## 関連リソース
+ [UpdateBrokerInput](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-model-updatebrokerinput) – Amazon MQ API を使用してブローカーインスタンスタイプを更新するには、このブローカープロパティを使用します。
+ [Parameters and Policies](https://www.rabbitmq.com/parameters.html) (RabbitMQ サーバードキュメント) – RabbitMQ のウェブサイトで、RabbitMQ のパラメータとポリシーの詳細について学びます。
+ [RabbitMQ Management HTTP API](https://pulse.mozilla.org/api/) – RabbitMQ Management API の詳細について学びます。
# 接続およびチャネルの数の削減
Amazon MQ 上の RabbitMQ への接続は、クライアントアプリケーションで終了できます。また、RabbitMQ ウェブコンソールを使用して手動で終了することもできます。RabbitMQ ウェブコンソールを使用して接続を終了するには、次の手順を実行します。
1. にサインイン AWS マネジメントコンソール し、ブローカーの RabbitMQ ウェブコンソールを開きます。
1. RabbitMQ コンソールで、**[Connections]** (接続) タブを選択します。
1. **[Connections]** (接続) ページの **[All connections]** (すべての接続) から、終了する接続の名前をリストから選択します。
1. 接続の詳細ページで、**[Close this connection]** (この接続を終了する) を選択してセクションを展開し、**[Force Close]** (強制終了) を選択します。オプションで、**理由**のデフォルトのテキストをお客様自身の説明に置き換えることもできます。接続を終了すると、Amazon MQ 上の RabbitMQ により、指定した理由がクライアントに返されます。
1. ダイアログボックスで **[OK]** を選択し、確認して接続を終了します。
接続を終了すると、終了した接続に関連付けられているすべてのチャネルも終了します。
**注記**
クライアントアプリケーションは、終了後にブローカーが自動的に接続を再確立するように設定されている場合があります。この場合、接続またはチャネルの数を減らすには、ブローカーのウェブコンソールからの接続を終了するだけでは不十分です。
パブリックアクセスがないブローカーの場合、適切なメッセージプロトコルのポート (例えば AMQP 接続の場合、ポート `5671`) でインバウンドトラフィックを拒否することで、一時的に接続をブロックできます。ブローカーの作成時に Amazon MQ に指定したセキュリティグループのポートをブロックできます。セキュリティグループの変更方法の詳細については、*Amazon VPC ユーザーガイド*の「[セキュリティグループへのルールの追加](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#adding-security-group-rules)」を参照してください。
## ステップ 2: ブローカーに JVM ベースのアプリケーションを接続する
RabbitMQ ブローカーを作成したら、ブローカーにアプリケーションを接続できます。以下の例では、[RabbitMQ Java クライアントライブラリ](https://www.rabbitmq.com/java-client.html)を使用してブローカーへの接続を作成し、キューを作成して、メッセージを送信する方法を説明します。RabbitMQ ブローカーには、サポートされているさまざまな言語の RabbitMQ クライアントライブラリを使用して接続することができます。サポートされている RabbitMQ クライアントライブラリの詳細については、「[RabbitMQ client libraries and developer tools](https://www.rabbitmq.com/devtools.html)」を参照してください。
### 前提条件
**注記**
以下の前提条件ステップは、パブリックアクセシビリティなしで作成された RabbitMQ ブローカーのみに適用されます。パブリックアクセシビリティがあるブローカーを作成している場合は、スキップすることができます。
#### VPC 属性 を有効にする
VPC 内でブローカーにアクセスできることを確実にするには、`enableDnsHostnames` および `enableDnsSupport` VPC 属性を有効にする必要があります。詳細については、*Amazon VPC ユーザーガイド*の「[VPC の DNS サポート](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support)」を参照してください。
#### インバウンド接続を有効にする
1. [Amazon MQ コンソール](https://console.aws.amazon.com/amazon-mq/)にサインインします。
1. ブローカーのリストからブローカーの名前 (**MyBroker** など) を選択します。
1. [***MyBroker***] ページの [**Connections**] (接続) セクションで、ブローカーのウェブコンソール URL とワイヤレベルプロトコルのアドレスとポートをメモします。
1. [**Details**] (詳細) セクションの [**Security and network**] (セキュリティとネットワーク) で、セキュリティグループの名前または ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/ja_jp/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png) をクリックします。
EC2 ダッシュボードの [**セキュリティグループ**] ページが表示されます。
1. セキュリティグループのリストから、セキュリティグループを選択します。
1. ページ下部で、[**インバウンド**] を選択し、次に [**編集**] を選択します。
1. [**Edit inbound rules**] (インバウンドルールの編集) ダイアログボックスで、パブリックアクセスを許可する URL またはエンドポイントごとにルールを追加します (以下の例は、これをブローカーのウェブコンソールに対して行う方法を説明しています)。
1. **[ルールの追加]** を選択します。
1. [**タイプ**] で、[**カスタム TCP**] を選択します。
1. [**Source**] (ソース) では、[**Custom**] (カスタム) が選択された状態のままにしておき、ウェブコンソールにアクセスできるようにするシステムの IP アドレスを入力します (`192.0.2.1` など)。
1. [**Save**] (保存) をクリックします。
これで、ブローカーはインバウンド接続を受け入れることができます。
#### Java の依存関係を追加する
ビルドの自動化のために Apache Maven を使用している場合は、以下の依存関係を `pom.xml` ファイルに追加します。Apache Maven のプロジェクトオブジェクトモデルファイルの詳細については、「[Introduction to the POM](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html)」を参照してください。
```
com.rabbitmq
amqp-client
5.9.0
```
ビルドの自動化のために [Gradle](https://docs.gradle.org/current/userguide/userguide.html) を使用している場合は、以下の依存関係を宣言します。
```
dependencies {
compile 'com.rabbitmq:amqp-client:5.9.0'
}
```
#### `Connection` と `Channel` クラスをインポートする
RabbitMQ Java クライアントは、そのトップレベルパッケージとして `com.rabbitmq.client` を使用し、それぞれが AMQP 0-9-1 接続とチャネルを表す `Connection` および `Channel` API クラスがあります。以下の例にあるように、使用する前に `Connection` と `Channel` クラスをインポートします。
```
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
```
#### `ConnectionFactory` を作成してブローカーに接続する
以下の例を使用して、所定のパラメータで `ConnectionFactory` クラスのインスタンスを作成します。`setHost` メソッドを使用して、先ほどメモしておいたブローカーエンドポイントを設定します。`AMQPS` のワイヤレベル接続には、ポート `5671` を使用します。
```
ConnectionFactory factory = new ConnectionFactory();
factory.setUsername(username);
factory.setPassword(password);
//Replace the URL with your information
factory.setHost("b-c8352341-ec91-4a78-ad9c-a43f23d325bb.mq.us-west-2.amazonaws.com");
factory.setPort(5671);
// Allows client to establish a connection over TLS
factory.useSslProtocol();
// Create a connection
Connection conn = factory.newConnection();
// Create a channel
Channel channel = conn.createChannel();
```
#### エクスチェンジにメッセージを発行する
エクスチェンジにメッセージを発行するには、`Channel.basicPublish` を使用できます。以下の例では、AMQP `Builder` クラスを使用して、content-type が `plain/text` のメッセージプロパティオブジェクトを構築します。
```
byte[] messageBodyBytes = "Hello, world!".getBytes();
channel.basicPublish(exchangeName, routingKey,
new AMQP.BasicProperties.Builder()
.contentType("text/plain")
.userId("userId")
.build(),
messageBodyBytes);
```
**注記**
`BasicProperties` は自動生成されたホルダークラス `AMQP` の内部クラスであることに注意してください。
#### キューにサブスクライブしてメッセージを受信する
メッセージは、`Consumer` インターフェイスを使用してキューにサブスクライブすることによって受信できます。サブスクライブすると、メッセージが到着すると同時に自動配信されます。
`Consumer` を実装する最も簡単な方法は、サブクラス `DefaultConsumer` の使用です。以下の例にあるように、`DefaultConsumer` オブジェクトは、サブスクリプションをセットアップするための `basicConsume` コールの一部として渡すことがきます。
```
boolean autoAck = false;
channel.basicConsume(queueName, autoAck, "myConsumerTag",
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException
{
String routingKey = envelope.getRoutingKey();
String contentType = properties.getContentType();
long deliveryTag = envelope.getDeliveryTag();
// (process the message components here ...)
channel.basicAck(deliveryTag, false);
}
});
```
**注記**
`autoAck = false` を指定したので、`Consumer` に配信されたメッセージを承認する必要があります。これは、上記の例にあるように、`handleDelivery` で実行することが最も便利です。
#### 接続を閉じてブローカーへの接続を切断する
RabbitMQ ブローカーへの接続を切断するには、以下に示すように、チャネルと接続の両方を閉じます。
```
channel.close();
conn.close();
```
**注記**
RabbitMQ Java クライアントライブラリの使用に関する詳細については、[RabbitMQ Java Client API Guide](https://www.rabbitmq.com/api-guide.html) を参照してください。
## ステップ 3: (オプション) AWS Lambda 関数に接続する
AWS Lambda は Amazon MQ ブローカーに接続して、Amazon MQ ブローカーからのメッセージを消費できます。ブローカーを Lambda に接続するときは、キューからメッセージを読み取り、関数 [synchronously](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html) を呼び出す[イベントソースマッピング](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html)を作成します。作成するイベントソースマッピングは、ブローカーからメッセージをバッチで読み取り、それらを JSON オブジェクト形式の Lambda ペイロードに変換します。
**ブローカーを Lambda 関数に接続する**
1. Lambda 関数 [execution role](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) に以下の IAM ロール許可を追加します。
+ [ mq:DescribeBroker ](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-http-methods)
+ [ec2:CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html)
+ [ec2:DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html)
+ [ec2:DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html)
+ [ec2:DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)
+ [ec2:DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html)
+ [ec2:DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html)
+ [logs:CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
+ [logs:CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
+ [logs:PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)
+ [secretsmanager:GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
**注記**
必要な IAM 許可がない場合、関数は Amazon MQ リソースからレコードを正常に読み取ることができません。
1. (オプション) パブリックアクセシビリティがないブローカーを作成した場合は、次のいずれかを実行して、Lambda のブローカーへの接続を許可する必要があります。
+ パブリックサブネットごとに 1 つの NAT ゲートウェイを設定します。詳細については、*AWS Lambda デベロッパーガイド*の「[VPC に接続した関数のインターネットアクセスとサービスアクセス](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet)」を参照してください。
+ VPC エンドポイントを使用して、Amazon Virtual Private Cloud (Amazon VPC) と Lambda 間の接続を作成します。Amazon VPC は、 AWS Security Token Service (AWS STS) および Secrets Manager エンドポイントにも接続する必要があります。詳細については、*AWS Lambda デベロッパーガイド*の「[Lambda のインターフェイス VPC エンドポイントの設定](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html)」を参照してください。
1. AWS マネジメントコンソールを使用して、Lambda 関数の[イベントソースとしてブローカーを設定](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping)します。[https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html) AWS Command Line Interface コマンドを使用することもできます。
1. ブローカーから取り込まれたメッセージを処理するための Lambda 関数のコードをいくつか記述します。イベントソースマッピングによって取得される Lambda ペイロードは、ブローカーのエンジンタイプに依存します。以下は、Amazon MQ for RabbitMQ キューの Lambda ペイロードの例です。
**注記**
この例では、`test` がキューの名前で、`/` がデフォルト仮想ホストの名前です。メッセージを受信すると、イベントソースは `test::/` の下にメッセージを一覧表示します。
```
{
"eventSource": "aws:rmq",
"eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
"rmqMessagesByQueue": {
"test::/": [
{
"basicProperties": {
"contentType": "text/plain",
"contentEncoding": null,
"headers": {
"header1": {
"bytes": [
118,
97,
108,
117,
101,
49
]
},
"header2": {
"bytes": [
118,
97,
108,
117,
101,
50
]
},
"numberInHeader": 10
}
"deliveryMode": 1,
"priority": 34,
"correlationId": null,
"replyTo": null,
"expiration": "60000",
"messageId": null,
"timestamp": "Jan 1, 1970, 12:33:41 AM",
"type": null,
"userId": "AIDACKCEVSQ6C2EXAMPLE",
"appId": null,
"clusterId": null,
"bodySize": 80
},
"redelivered": false,
"data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ=="
}
]
}
}
```
Amazon MQ の Lambda への接続、Amazon MQ イベントソースに対して Lambda がサポートするオプション、およびイベントソースマッピングエラーに関する詳細については、「*AWS Lambda デベロッパーガイド*」の「[Amazon MQ で Lambda を使用する](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html)」を参照してください。
# Amazon MQ for RabbitMQ での OAuth 2.0 認証と認可の使用
このチュートリアルでは、Amazon Cognito を OAuth 2.0 プロバイダーとして使用して、Amazon MQ for RabbitMQ ブローカーの [OAuth 2.0 認証](oauth-for-amq-for-rabbitmq.md)を設定する方法について説明します。
**注記**
Amazon Cognito は、中国 (北京) および中国 (寧夏) では使用できません。
**重要**
このチュートリアルは Amazon Cognito に固有のものですが、他の ID プロバイダー (IdP) を使用できます。詳細については、「[OAuth 2.0 認証の例](https://www.rabbitmq.com/docs/oauth2-examples)」を参照してください。
**Topics**
+ [OAuth 2.0 認証を設定するための前提条件](#oauth-tutorial-prerequisites)
+ [AWS CLI を使用した Amazon Cognito による OAuth 2.0 認証の設定](#oauth-tutorial-config-cognito-using-cli)
+ [Amazon Cognito による OAuth 2.0 とシンプルな認証の設定](#oauth-tutorial-config-both-auth-methods-using-cli)
## OAuth 2.0 認証を設定するための前提条件
このチュートリアルで必要な Amazon Cognito リソースを設定するには、AWS CDK スタックである [RabbitMQ OAuth 2 プラグイン用 Amazon Cognito スタック](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample)をデプロイします。Amazon Cognito を手動で設定する場合は、Amazon MQ for RabbitMQ ブローカーで OAuth 2.0 を設定する前に、次の前提条件を満たしていることを確認してください。
**Amazon Cognito をセットアップするための前提条件**
+ ユーザープールを作成して Amazon Cognito エンドポイントをセットアップします。これを行うには、「[How to use OAuth 2.0 in Amazon Cognito: Learn about the different OAuth 2.0 grants](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/)」というタイトルのブログを参照してください。
+ ユーザープールに `rabbitmq` という名前のリソースサーバーを作成し、`read:all`、`write:all`、`configure:all`、`tag:administrator` のスコープを定義します。これらのスコープは RabbitMQ アクセス許可に関連付けられます。
リソースサーバーの作成の詳細については、「*Amazon Cognito デベロッパーガイド*」の「[ユーザープール (AWS マネジメントコンソール) のリソースサーバーの定義](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html#cognito-user-pools-define-resource-servers-console)」を参照してください。
+ 以下のアプリケーションクライアントを作成します。
+ タイプ `Machine-to-Machine application` のユーザープールのアプリケーションクライアント。これは、RabbitMQ AMQP クライアントに使用されるクライアントシークレットを持つ機密クライアントです。アプリケーションクライアントとその作成の詳細については、「[アプリクライアントの種類](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#user-pool-settings-client-app-client-types)」および「[アプリクライアントの作成](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#cognito-user-pools-app-idp-settings-console-create)」を参照してください。
+ タイプ `Single-page application` のユーザープールのアプリケーションクライアント。これは、RabbitMQ マネジメントコンソールへのユーザーのログインに使用されるパブリッククライアントです。このアプリケーションクライアントを更新して、次の手順で作成する Amazon MQ for RabbitMQ ブローカーのエンドポイントを許可されたコールバック URL として含める必要があります。詳細については、「[Amazon Cognito コンソールでのマネージドログインのセットアップ](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-managed-login.html#set-up-managed-login)」を参照してください。
**Amazon MQ をセットアップするための前提条件**
+ OAuth 2.0 のセットアップが成功したかどうかを確認する bash スクリプトを実行するための作業中の [Docker](https://docs.docker.com/engine/install/) インストール。
+ ブローカーの作成中にユーザー名とパスワードの追加をオプションにする AWS CLI version >= `2.28.23`。
## AWS CLI を使用した Amazon Cognito による OAuth 2.0 認証の設定
次の手順は、Amazon Cognito を IdP として使用して Amazon MQ for RabbitMQ ブローカーの OAuth 2.0 認証を設定する方法を示しています。この手順では、AWS CLI を使用して必要なリソースを作成および設定します。
次の手順では、configurationID や Revision、**、*<2>* などのプレースホルダー値を実際の値に置き換えてください。
1. 次の例に示すように、[create-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/create-configuration.html) AWS CLI コマンドを使用して新しい設定を作成します。
```
aws mq create-configuration \
--name "rabbitmq-oauth2-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-oauth2-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-oauth2-config"
}
```
1. 次の例に示すように、OAuth 2.0 を認証および認可方法として使用する **rabbitmq.conf** と呼ばれる設定ファイルを作成します。
```
auth_backends.1 = oauth2
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool.
# If you used the AWS CDK stack to deploy Amazon Cognito, this is one of the stack outputs.
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
# Amazon Cognito does not include an audience field in access tokens
auth_oauth2.verify_aud = false
# Amazon Cognito does not allow * in its custom scopes. Use aliases to translate between Amazon Cognito and RabbitMQ.
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
# Allow OAuth 2.0 login for RabbitMQ management console
management.oauth_enabled = true
# FIXME: Update this value with the client ID of your public application client
management.oauth_client_id = ${RabbitMqOAuth2TestStack.ManagementConsoleAppClientId}
# FIXME: Update this value with the base JWKS URI (without /.well-known/jwks.json)
auth_oauth2.issuer = ${RabbitMqOAuth2TestStack.Issuer}
management.oauth_scopes = rabbitmq/tag:administrator
```
この設定では、[スコープエイリアス](https://www.rabbitmq.com/docs/oauth2#scope-translation)を使用して、Amazon Cognito で定義されたスコープを RabbitMQ 互換スコープにマッピングします。
1. 次の例に示すように、[update-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/update-configuration.html) AWS CLI コマンドを使用して設定を更新します。このコマンドでは、この手順のステップ 1 のレスポンスで受け取った設定 ID を追加します。例えば、**c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca**。
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-oauth2-config",
"Warnings": []
}
```
1. この手順のステップ 2 で作成した OAuth 2.0 設定でブローカーを作成します。そのためには、以下の例に示すように [create-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/create-broker.html) AWS CLI コマンドを使用します。このコマンドでは、ステップ 1 と 2 のレスポンスで取得した設定 ID とリビジョン番号をそれぞれ指定します。例えば、**c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca** と **2** です。
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-oauth2-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. 次の例に示すように、[describe-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/describe-broker.html) AWS CLI コマンドを使用して、ブローカーのステータスが `CREATION_IN_PROGRESS` から `RUNNING` に移行していることを確認します。このコマンドでは、前のステップの結果で取得したブローカー ID を指定します。例: **b-2a1b5133-a10c-49d2-879b-8c176c34cf73**。
```
aws mq describe-broker \
--broker-id ""
```
このコマンドでは、次の例のようなレスポンスが返されます。次のレスポンスは、`describe-broker` コマンドが返す完全な出力の省略バージョンです。このレスポンスは、ブローカーのステータスと、ブローカーの保護に使用される認証戦略を示します。この場合、`config_managed` 認証戦略はブローカーが OAuth 2 認証方法を使用していることを示します。
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
OAuth2 を使用して RabbitMQ マネジメントコンソールにログインするには、ブローカーエンドポイントを、対応する Amazon Cognito アプリクライアントの有効なコールバック URL として追加する必要があります。詳細については、サンプル [ Amazon Cognito CDK スタック](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample#step-5-update-callback-urls-if-using-placeholder-urls)のセットアップのステップ 5 を参照してください。
1. 次の `perf-test.sh` スクリプトを使用して、OAuth 2.0 の認証と認可を検証します。
この bash スクリプトを使用して、Amazon MQ for RabbitMQ ブローカーへの接続をテストします。このスクリプトは Amazon Cognito からトークンを取得し、接続が正しく設定されているかどうかを確認します。正常に設定されると、ブローカーがメッセージを発行して消費します。
`ACCESS_REFUSED` エラーが発生した場合は、ブローカーの CloudWatch ログを使用して設定をトラブルシューティングできます。ブローカーの CloudWatch ロググループのリンクは、Amazon MQ コンソールにあります。
このスクリプトでは、次の値を指定する必要があります。
+ `CLIENT_ID` および `CLIENT_SECRET`: これらの値は、Amazon Cognito コンソールの **[アプリクライアント]** ページで確認できます。
+ Cognito ドメイン: これは Amazon Cognito コンソールで確認できます。**[ブランディング]** で、**[ドメイン]** を選択します。**[ドメイン]** ページで、この値は **[リソースサーバー]** セクションにあります。
+ Amazon MQ ブローカーエンドポイント: この値は、Amazon MQ コンソールのブローカーの詳細ページの **[接続]** にあります。
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
CLIENT_ID=${RabbitMqOAuth2TestStack.AmqpAppClientId}
CLIENT_SECRET=${RabbitMqOAuth2TestStack.AmqpAppClientSecret}
# FIXME: Update this value with the domain of your Amazon Cognito user pool
RESPONSE=$(curl -X POST ${RabbitMqOAuth2TestStack.TokenEndpoint} \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}&scope=rabbitmq/configure:all rabbitmq/read:all rabbitmq/tag:administrator rabbitmq/write:all")
# Extract the access_token from the response.
# This token will be passed in the password field when connecting to the broker.
# Note that the username is left blank, the field is ignored by the plugin.
BROKER_PASSWORD=$(echo ${RESPONSE} | jq -r '.access_token')
# FIXME: Update this value with the endpoint of your broker. For example, b-89424106-7e0e-4abe-8e98-8de0dada7630.mq.us-east-1.on.aws.
BROKER_DNS=
CONNECTION_STRING=amqps://:${BROKER_PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--flag persistent --rate $PRODUCER_RATE
```
## Amazon Cognito による OAuth 2.0 とシンプルな認証の設定
OAuth 2.0 認証を使用してブローカーを作成する場合、次のいずれかの認証方法を指定できます。
+ **OAuth 2.0 のみ**: この方法を使用するには、ブローカーの作成時にユーザー名とパスワードを指定しないでください。[前の手順](#oauth-tutorial-config-cognito-using-cli)は、OAuth 2.0 認証方法のみを使用する方法を示しています。
+ **OAuth 2.0 とシンプルな認証の両方**: この方法を使用するには、ブローカーの作成時にユーザー名とパスワードを指定します。また、次の手順に示すように、`auth_backends.2 = internal` をブローカー設定に追加します。
次の手順では、** や ** などのプレースホルダー値を実際の値に置き換えてください。
1. 両方の認証方法を使用するには、次の例に示すように、ブローカー設定を作成します。
```
auth_backends.1 = oauth2
auth_backends.2 = internal
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.verify_aud = false
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
```
この設定では、[スコープエイリアス](https://www.rabbitmq.com/docs/oauth2#scope-translation)を使用して、Amazon Cognito で定義されたスコープを RabbitMQ 互換スコープにマッピングします。
1. 次の例に示すように、両方の認証方法を使用するブローカーを作成します。
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker-with-internal-user" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": }' \
--users '[{"Username":"","Password":""}]'
```
1. [Amazon Cognito による OAuth 2.0 認証の設定](#oauth-tutorial-config-cognito-using-cli) 手順のステップ 5 と 6 で説明されているように、ブローカーのステータスと認証方法の設定が成功したことを確認します。
# Amazon MQ for RabbitMQ での IAM 認証と認可の使用
次の手順は、Amazon MQ for RabbitMQ AWS ブローカーの IAM 認証と認可を有効にする方法を示しています。IAM を有効にすると、ユーザーは IAM AWS 認証情報を使用して RabbitMQ Management API にアクセスし、AMQP 経由で接続するための認証を行うことができます。Amazon MQ for RabbitMQ での IAM 認証の仕組みの詳細については、「」を参照してください[Amazon MQ for RabbitMQ の IAM 認証と認可](iam-for-amq-for-rabbitmq.md)。
## 前提条件
+ AWS Amazon MQ for RabbitMQ ブローカーを所有する AWS アカウントの管理者認証情報
+ これらの管理者認証情報で設定されたシェル環境 (CLI AWS プロファイルまたは環境変数を使用)
+ AWS CLI のインストールと設定
+ `jq` コマンドライン JSON プロセッサがインストールされている
+ `curl` コマンドラインツールのインストール
## を使用した IAM 認証と認可の設定 AWS CLI
1. **環境変数を設定する**
ブローカーに必要な環境変数を設定します。
```
export AWS_DEFAULT_REGION=
export BROKER_ID=
```
1. **アウトバウンド JWT トークンを有効にする**
AWS アカウントのアウトバウンドウェブ ID フェデレーションを有効にします。
```
ISSUER_IDENTIFIER=$(aws iam enable-outbound-web-identity-federation --query 'IssuerIdentifier' --output text)
echo $ISSUER_IDENTIFIER
```
出力には、アカウントの一意の発行者識別子 URL が 形式で表示されます`https://.tokens.sts.global.api.aws`。
1. **IAM ポリシードキュメントを作成する**
ウェブ ID トークンを取得するアクセス許可を付与するポリシードキュメントを作成します。
```
cat > policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sts:GetWebIdentityToken",
"sts:TagGetWebIdentityToken"
],
"Resource": "*"
}
]
}
EOF
```
1. **信頼ポリシーを作成する**
発信者 ID を取得し、信頼ポリシードキュメントを作成します。
```
CALLER_ARN=$(aws sts get-caller-identity --query Arn --output text)
cat > trust-policy.json << EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "$CALLER_ARN"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
```
1. **IAM ロールを作成する**
IAM ロールを作成し、ポリシーをアタッチします。
```
aws iam create-role --role-name RabbitMqAdminRole --assume-role-policy-document file://trust-policy.json
aws iam put-role-policy --role-name RabbitMqAdminRole --policy-name RabbitMqAdminRolePolicy --policy-document file://policy.json
```
1. **RabbitMQ OAuth2 設定を構成する**
OAuth2 認証および認可設定を使用して RabbitMQ 設定ファイルを作成します。
```
cat > rabbitmq.conf << EOF
auth_backends.1 = oauth2
auth_backends.2 = internal
auth_oauth2.jwks_url = ${ISSUER_IDENTIFIER}/.well-known/jwks.json
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.additional_scopes_key = sub
auth_oauth2.scope_aliases.1.alias = arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/RabbitMqAdminRole
auth_oauth2.scope_aliases.1.scope = rabbitmq/tag:administrator rabbitmq/read:*/* rabbitmq/write:*/* rabbitmq/configure:*/*
auth_oauth2.https.hostname_verification = wildcard
management.oauth_enabled = true
EOF
```
1. **ブローカー設定を更新する**
新しい設定をブローカーに適用します。
```
# Retrieve the configuration ID
CONFIG_ID=$(aws mq describe-broker --broker-id $BROKER_ID --query 'Configurations[0].Id' --output text)
# Create a new configuration revision
REVISION=$(aws mq update-configuration --configuration-id $CONFIG_ID --data "$(cat rabbitmq.conf | base64 --wrap=0)" --query 'LatestRevision.Revision' --output text)
# Apply the configuration to the broker
aws mq update-broker --broker-id $BROKER_ID --configuration Id=$CONFIG_ID,Revision=$REVISION
# Reboot the broker to apply changes
aws mq reboot-broker --broker-id $BROKER_ID
```
ブローカーのステータスが に戻るのを待って`RUNNING`から、次のステップに進みます。
1. **JWT トークンを取得する**
IAM ロールを引き受け、ウェブ ID トークンを取得します。
```
# Assume the RabbitMqAdminRole
ROLE_CREDS=$(aws sts assume-role --role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/RabbitMqAdminRole --role-session-name rabbitmq-session)
# Configure the session with temporary credentials
export AWS_ACCESS_KEY_ID=$(echo "$ROLE_CREDS" | jq -r '.Credentials.AccessKeyId')
export AWS_SECRET_ACCESS_KEY=$(echo "$ROLE_CREDS" | jq -r '.Credentials.SecretAccessKey')
export AWS_SESSION_TOKEN=$(echo "$ROLE_CREDS" | jq -r '.Credentials.SessionToken')
# Obtain the web identity token
TOKEN_RESPONSE=$(aws sts get-web-identity-token \
--audience "rabbitmq" \
--signing-algorithm ES384 \
--duration-seconds 300 \
--tags Key=scope,Value="rabbitmq/tag:administrator")
# Extract the token
TOKEN=$(echo "$TOKEN_RESPONSE" | jq -r '.WebIdentityToken')
```
1. **RabbitMQ 管理 API にアクセスする**
JWT トークンを使用して RabbitMQ Management API にアクセスします。
```
BROKER_URL=.mq..on.aws
curl -u ":$TOKEN" \
-X GET https://${BROKER_URL}/api/overview \
-H "Content-Type: application/json"
```
応答が成功すると、IAM 認証が正しく動作していることが確認されます。レスポンスには、JSON 形式のブローカーの概要情報が含まれています。
1. **JWT トークンを使用して AMQP 経由で接続する**
パフォーマンステストツールで JWT トークンを使用して AMQP 接続をテストします。
```
BROKER_DNS=
CONNECTION_STRING=amqps://:${TOKEN}@${BROKER_DNS}:5671
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to 1 \
--producers 1 --consumers 1 \
--uri ${CONNECTION_STRING} \
--flag persistent --rate 1
```
`ACCESS_REFUSED` エラーが発生した場合は、ブローカーの CloudWatch ログを使用して設定をトラブルシューティングできます。ブローカーの CloudWatch Logs ロググループのリンクは、Amazon MQ コンソールにあります。
# Amazon MQ for RabbitMQ での LDAP 認証と認可の使用
このチュートリアルでは、 を使用して Amazon MQ for RabbitMQ ブローカーの LDAP 認証と認可を設定する方法について説明します AWS Managed Microsoft AD。
**Topics**
+ [LDAP 認証と認可を設定するための前提条件](#rabbitmq-ldap-tutorial-prerequisites)
+ [CLI を使用した RabbitMQ での LDAP AWS の設定](#rabbitmq-ldap-tutorial-configure-cli)
## LDAP 認証と認可を設定するための前提条件
このチュートリアルで必要な AWS リソースを設定するには、[AWS Amazon MQ for RabbitMQ LDAP 統合用の CDK スタックを と AWS Managed Microsoft AD](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-ldap-activedirectory-sample/)デプロイします。
この CDK スタックは、LDAP ユーザーとグループ AWS Managed Microsoft AD、Network Load Balancer、証明書、IAM ロールなど、必要なすべての AWS リソースを自動的に作成します。スタックによって作成されたリソースの完全なリストについては、パッケージ README を参照してください。
CDK スタックを使用する代わりにリソースを手動で設定する場合は、Amazon MQ for RabbitMQ ブローカーで LDAP を設定する前に、同等のインフラストラクチャが整っていることを確認してください。
### Amazon MQ をセットアップするための前提条件
AWS CLI バージョン >= 2.28.23。ブローカーの作成時にユーザー名とパスワードをオプションで追加します。
## CLI を使用した RabbitMQ での LDAP AWS の設定
この手順では、 CLI AWS を使用して必要なリソースを作成および設定します。次の手順では、configurationID や Revision、 `` などのプレースホルダー値を実際の値に置き換え`<2>`てください。
1. 次の例に示すように、`create-configuration` AWS CLI コマンドを使用して新しい設定を作成します。
```
aws mq create-configuration \
--name "rabbitmq-ldap-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-ldap-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-ldap-config"
}
```
1. 次の例に示すように、LDAP `rabbitmq.conf`を認証および認可方法として使用する という設定ファイルを作成します。テンプレート内のすべてのプレースホルダー値 ( でマーク) を`${RabbitMqLdapTestStack.*}`、デプロイされた AWS CDK 前提条件スタック出力または同等のインフラストラクチャの実際の値に置き換えます。
```
auth_backends.1 = ldap
# LDAP authentication settings - For more information,
# see https://www.rabbitmq.com/docs/ldap#basic
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_ldap.servers.1 = ${RabbitMqLdapTestStack.NlbDnsName}
auth_ldap.dn_lookup_bind.user_dn = ${RabbitMqLdapTestStack.DnLookupUserDn}
auth_ldap.dn_lookup_base = ${RabbitMqLdapTestStack.DnLookupBase}
auth_ldap.dn_lookup_attribute = ${RabbitMqLdapTestStack.DnLookupAttribute}
auth_ldap.port = 636
auth_ldap.use_ssl = true
auth_ldap.ssl_options.verify = verify_peer
auth_ldap.log = network
# AWS integration for secure credential retrieval
# - see: https://github.com/amazon-mq/rabbitmq-aws
# The aws plugin allows RabbitMQ to securely retrieve credentials and certificates
# from AWS services.
# Replace the ${RabbitMqLdapTestStack.*} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.auth_ldap.ssl_options.cacertfile = ${RabbitMqLdapTestStack.CaCertArn}
aws.arns.auth_ldap.dn_lookup_bind.password = ${RabbitMqLdapTestStack.DnLookupUserPasswordArn}
aws.arns.assume_role_arn = ${RabbitMqLdapTestStack.AmazonMqAssumeRoleArn}
# LDAP authorization queries - For more information,
# see: https://www.rabbitmq.com/docs/ldap#authorisation
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual group DN
# values from your deployed prerequisite CDK stack outputs
# Uses Active Directory groups created by the prerequisite CDK stack
auth_ldap.queries.tags = '''
[{administrator, {in_group, "${RabbitMqLdapTestStack.RabbitMqAdministratorsGroupDn}"}},
{management, {in_group, "${RabbitMqLdapTestStack.RabbitMqMonitoringUsersGroupDn}"}}]
'''
# FIXME: This provides all authenticated users access to all vhosts
# - update to restrict access as required
auth_ldap.queries.vhost_access = '''
{constant, true}
'''
# FIXME: This provides all authenticated users full access to all
# queues and exchanges - update to restrict access as required
auth_ldap.queries.resource_access = '''
{for, [ {permission, configure, {constant, true}},
{permission, write,
{for, [{resource, queue, {constant, true}},
{resource, exchange, {constant, true}}]}},
{permission, read,
{for, [{resource, exchange, {constant, true}},
{resource, queue, {constant, true}}]}}
]
}
'''
# FIXME: This provides all authenticated users access to all topics
# - update to restrict access as required
auth_ldap.queries.topic_access = '''
{for, [{permission, write, {constant, true}},
{permission, read, {constant, true}}
]
}
'''
```
1. 次の例に示すように、`update-configuration` AWS CLI コマンドを使用して設定を更新します。このコマンドでは、この手順のステップ 1 のレスポンスで受け取った設定 ID を追加します。例えば、`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`。
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ldap-config",
"Warnings": []
}
```
1. この手順のステップ 2 で作成した LDAP 設定を使用してブローカーを作成します。これを行うには、次の例に示すように `create-broker` AWS CLI コマンドを使用します。このコマンドでは、ステップ 1 と 2 のレスポンスで取得した設定 ID とリビジョン番号をそれぞれ指定します。例えば、`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` と `2` です。
```
aws mq create-broker \
--broker-name "rabbitmq-ldap-test-1" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ldap-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
**ブローカーの命名制限**
前提条件の CDK スタックによって作成された IAM ロールは、ブローカー名を で始まるように制限します`rabbitmq-ldap-test`。ブローカー名がこのパターンに従っているか、IAM ロールに ARN 解決のためにロールを引き受けるアクセス許可がないことを確認します。
1. 次の例に示すように `describe-broker` AWS CLI コマンドを使用して`RUNNING`、ブローカーのステータスが から `CREATION_IN_PROGRESS`に移行していることを確認します。このコマンドでは、前のステップの結果で取得したブローカー ID を指定します (例: `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`)。
```
aws mq describe-broker \
--broker-id ""
```
このコマンドでは、次の例のようなレスポンスが返されます。次のレスポンスは、`describe-broker` コマンドが返す完全な出力の省略バージョンです。このレスポンスは、ブローカーのステータスと、ブローカーの保護に使用される認証戦略を示します。この場合、`config_managed`認証戦略はブローカーが LDAP 認証方法を使用していることを示します。
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. 前提条件の CDK スタックによって作成されたテストユーザーの 1 人を使用して RabbitMQ アクセスを検証する
```
# FIXME: Replace ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a user (should fail - console user only has monitoring permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/users/testuser \
-H "Content-Type: application/json" \
-d '{"password":"testpass","tags":"management"}'
```
# Amazon MQ for RabbitMQ での HTTP 認証と認可の使用
このチュートリアルでは、外部 HTTP サーバーを使用して Amazon MQ for RabbitMQ ブローカーの HTTP 認証と認可を設定する方法について説明します。
**注記**
HTTP 認証プラグインは、Amazon MQ for RabbitMQ バージョン 4 以降でのみ使用できます。
**Topics**
+ [HTTP 認証と認可を設定するための前提条件](#rabbitmq-http-tutorial-prerequisites)
+ [CLI を使用した RabbitMQ での HTTP AWS 認証の設定](#rabbitmq-http-tutorial-configure-cli)
## HTTP 認証と認可を設定するための前提条件
このチュートリアルで必要な AWS リソースを設定するには、[AWS Amazon MQ for RabbitMQ HTTP 認証統合用の CDK スタック](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-http-sample/)をデプロイします。
この CDK スタックは、HTTP 認証サーバー、証明書、IAM ロールなど、必要なすべての AWS リソースを自動的に作成します。スタックによって作成されたリソースの完全なリストについては、パッケージ README を参照してください。
CDK スタックを使用する代わりにリソースを手動で設定する場合は、Amazon MQ for RabbitMQ ブローカーで HTTP 認証を設定する前に、同等のインフラストラクチャが整っていることを確認してください。
### Amazon MQ をセットアップするための前提条件
AWS CLI バージョン >= 2.28.23。ブローカーの作成時にユーザー名とパスワードをオプションで追加します。
## CLI を使用した RabbitMQ での HTTP AWS 認証の設定
この手順では、 CLI AWS を使用して必要なリソースを作成および設定します。次の手順では、プレースホルダー値を実際の値に置き換えてください。
1. 次の例に示すように、`create-configuration` AWS CLI コマンドを使用して新しい設定を作成します。
```
aws mq create-configuration \
--name "rabbitmq-http-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-http-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-http-config"
}
```
1. 次の例に示すように、HTTP `rabbitmq.conf`を認証および認可方法として使用する という設定ファイルを作成します。テンプレート内のすべてのプレースホルダー値 ( でマーク) を`${...}`、デプロイされた AWS CDK 前提条件スタック出力または同等のインフラストラクチャの実際の値に置き換えます。
```
auth_backends.1 = cache
auth_backends.2 = http
auth_cache.cached_backend = http
# HTTP authentication settings
# For more information, see https://github.com/rabbitmq/rabbitmq-auth-backend-http
# FIXME: Replace the ${...} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_http.http_method = post
auth_http.user_path = ${HttpServerUserPath}
auth_http.vhost_path = ${HttpServerVhostPath}
auth_http.resource_path = ${HttpServerResourcePath}
auth_http.topic_path = ${HttpServerTopicPath}
# TLS/HTTPS configuration
auth_http.ssl_options.verify = verify_peer
auth_http.ssl_options.sni = test.amazonaws.com
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.auth_http.ssl_options.cacertfile = ${CaCertArn}
```
1. `update-configuration` AWS CLI コマンドを使用して設定を更新します。ステップ 3 の設定 ID を使用します。
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-http-config",
"Warnings": []
}
```
1. HTTP 設定でブローカーを作成します。前のステップの設定 ID とリビジョン番号を使用します。
```
aws mq create-broker \
--broker-name "rabbitmq-http-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-http-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. `describe-broker` AWS CLI コマンドを使用して`RUNNING`、ブローカーのステータスが から `CREATION_IN_PROGRESS`に移行していることを確認します。
```
aws mq describe-broker \
--broker-id ""
```
このコマンドでは、次の例のようなレスポンスが返されます。`config_managed` 認証戦略は、ブローカーが HTTP 認証方法を使用していることを示します。
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. 前提条件の CDK スタックによって作成されたテストユーザーの 1 人を使用して RabbitMQ アクセスを検証する
```
# FIXME: Replace ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a vhost (should fail - console user only has management permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/vhosts/test-vhost \
-H "Content-Type: application/json" \
-d '{}'
```
# Amazon MQ for RabbitMQ での SSL 証明書認証の使用
このチュートリアルでは、プライベート認証機関を使用して Amazon MQ for RabbitMQ ブローカーの SSL 証明書認証を設定する方法について説明します。
**注記**
SSL 証明書認証プラグインは、Amazon MQ for RabbitMQ バージョン 4 以降でのみ使用できます。
**Topics**
+ [SSL 証明書認証を設定するための前提条件](#rabbitmq-ssl-tutorial-prerequisites)
+ [CLI を使用した RabbitMQ での SSL AWS 証明書認証の設定](#rabbitmq-ssl-tutorial-configure-cli)
## SSL 証明書認証を設定するための前提条件
SSL 証明書認証は、相互 TLS (mTLS) を使用して X.509 証明書を使用してクライアントを認証します。このチュートリアルで必要な AWS リソースを設定するには、[AWS Amazon MQ for RabbitMQ mTLS 統合用の CDK スタック](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/)をデプロイします。
この CDK スタックは、認証機関、クライアント証明書、IAM ロールなど、必要なすべての AWS リソースを自動的に作成します。スタックによって作成されたリソースの完全なリストについては、パッケージ README を参照してください。
**注記**
CDK スタックをデプロイする前に、 `RABBITMQ_TEST_USER_NAME`環境変数を設定します。この値はクライアント証明書の共通名 (CN) として使用され、チュートリアルのステップで使用するユーザー名と一致する必要があります。例: `export RABBITMQ_TEST_USER_NAME="myuser"`
CDK スタックを使用する代わりにリソースを手動で設定する場合は、Amazon MQ for RabbitMQ ブローカーで SSL 証明書認証を設定する前に、同等のインフラストラクチャが整っていることを確認してください。
### Amazon MQ をセットアップするための前提条件
AWS CLI バージョン >= 2.28.23。ブローカーの作成時にユーザー名とパスワードをオプションで追加します。
## CLI を使用した RabbitMQ での SSL AWS 証明書認証の設定
この手順では、 CLI AWS を使用して必要なリソースを作成および設定します。次の手順では、configurationID や Revision、 `` などのプレースホルダー値を実際の値に置き換え`<2>`てください。
1. 次の例に示すように、`create-configuration` AWS CLI コマンドを使用して新しい設定を作成します。
```
aws mq create-configuration \
--name "rabbitmq-ssl-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-ssl-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-ssl-config"
}
```
1. 次の例に示すように、SSL 証明書認証を使用する`rabbitmq.conf`ように という設定ファイルを作成します。テンプレート内のすべてのプレースホルダー値 ( でマーク) を`${...}`、デプロイされた AWS CDK 前提条件スタック出力または同等のインフラストラクチャの実際の値に置き換えます。
```
auth_mechanisms.1 = EXTERNAL
ssl_cert_login_from = common_name
auth_backends.1 = internal
# Reject if no client cert
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# FIXME: Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.ssl_options.cacertfile = ${CaCertArn}
```
1. 次の例に示すように、`update-configuration` AWS CLI コマンドを使用して設定を更新します。このコマンドでは、この手順のステップ 1 のレスポンスで受け取った設定 ID を追加します。例えば、`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`。
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ssl-config",
"Warnings": []
}
```
1. この手順のステップ 2 で作成した SSL 証明書認証設定を使用してブローカーを作成します。これを行うには、次の例に示すように `create-broker` AWS CLI コマンドを使用します。このコマンドでは、ステップ 1 と 2 のレスポンスで取得した設定 ID とリビジョン番号をそれぞれ指定します。例えば、`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` と `2` です。
```
aws mq create-broker \
--broker-name "rabbitmq-ssl-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ssl-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. 次の例に示すように `describe-broker` AWS CLI コマンドを使用して`RUNNING`、ブローカーのステータスが から `CREATION_IN_PROGRESS`に移行していることを確認します。このコマンドでは、前のステップの結果で取得したブローカー ID を指定します。例えば、`b-2a1b5133-a10c-49d2-879b-8c176c34cf73`。
```
aws mq describe-broker \
--broker-id ""
```
このコマンドでは、次の例のようなレスポンスが返されます。次のレスポンスは、`describe-broker` コマンドが返す完全な出力の省略バージョンです。このレスポンスは、ブローカーのステータスと、ブローカーの保護に使用される認証戦略を示します。この場合、`config_managed`認証戦略はブローカーが SSL 証明書認証方法を使用していることを示します。
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. 次の`ssl.sh`スクリプトを使用して SSL 証明書認証を検証します。
この bash スクリプトを使用して、Amazon MQ for RabbitMQ ブローカーへの接続をテストします。このスクリプトは、認証にクライアント証明書を使用し、接続が正しく設定されているかどうかを確認します。正常に設定されると、ブローカーがメッセージを発行して消費します。
`ACCESS_REFUSED` エラーが発生した場合は、ブローカーの CloudWatch ログを使用して設定をトラブルシューティングできます。ブローカーの CloudWatch ロググループのリンクは、Amazon MQ コンソールにあります。
このスクリプトでは、次の値を指定する必要があります。
+ `USERNAME`: クライアント証明書の共通名 (CN)。
+ `CLIENT_KEYSTORE`: クライアントキーストアファイルへのパス (PKCS12 形式）。前提条件の CDK スタックを使用した場合、デフォルトのパスは です`$(pwd)/certs/client-keystore.p12`。
+ `KEYSTORE_PASSWORD`: クライアントキーストアのパスワード。前提条件の CDK スタックを使用した場合、デフォルトのパスワードは です`changeit`。
+ `BROKER_DNS`: この値は、Amazon MQ コンソールのブローカーの詳細ページの **Connections** にあります。
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
USERNAME=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
finch run --rm --ulimit nofile=40960:40960 \
-v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
-e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--sasl-external \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# AMQP および管理エンドポイントに mTLS を使用する
このチュートリアルでは、プライベート認証機関を使用して AMQP クライアント接続と RabbitMQ 管理インターフェイスの相互 TLS (mTLS) を設定する方法について説明します。
**注記**
mTLS のプライベート認証機関の使用は、Amazon MQ for RabbitMQ バージョン 4 以降でのみ使用できます。
**Topics**
+ [mTLS を設定するための前提条件](#rabbitmq-mtls-tutorial-prerequisites)
+ [CLI を使用した RabbitMQ での mTLS AWS の設定](#rabbitmq-mtls-tutorial-configure-cli)
## mTLS を設定するための前提条件
このチュートリアルで必要な AWS リソースを設定するには、[AWS Amazon MQ for RabbitMQ mTLS 統合用の CDK スタックを に](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/)デプロイします。
この CDK スタックは、認証機関、クライアント証明書、IAM ロールなど、必要なすべての AWS リソースを自動的に作成します。スタックによって作成されたリソースの完全なリストについては、パッケージ README を参照してください。
CDK スタックを使用する代わりにリソースを手動で設定する場合は、Amazon MQ for RabbitMQ ブローカーで mTLS を設定する前に、同等のインフラストラクチャが整っていることを確認してください。
### Amazon MQ をセットアップするための前提条件
AWS CLI バージョン >= 2.28.23。ブローカーの作成時にユーザー名とパスワードをオプションで追加します。
## CLI を使用した RabbitMQ での mTLS AWS の設定
この手順では、 CLI AWS を使用して必要なリソースを作成および設定します。次の手順では、configurationID や Revision、 `` などのプレースホルダー値を実際の値に置き換え`<2>`てください。
1. 次の例に示すように、`create-configuration` AWS CLI コマンドを使用して新しい設定を作成します。
```
aws mq create-configuration \
--name "rabbitmq-mtls-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-mtls-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-mtls-config"
}
```
1. 次の例に示すように、 という設定ファイルを作成して、AMQP および管理エンドポイントの mTLS `rabbitmq.conf`を設定します。テンプレート内のすべてのプレースホルダー値 ( でマーク) を`${...}`、デプロイされた AWS CDK 前提条件スタック出力または同等のインフラストラクチャの実際の値に置き換えます。
```
auth_backends.1 = internal
# TLS configuration
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
management.ssl.verify = verify_peer
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# FIXME: Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.ssl_options.cacertfile = ${CaCertArn}
aws.arns.management.ssl.cacertfile = ${CaCertArn}
```
1. 次の例に示すように、`update-configuration` AWS CLI コマンドを使用して設定を更新します。このコマンドでは、この手順のステップ 1 のレスポンスで受け取った設定 ID を追加します。例えば、`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`。
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-mtls-config",
"Warnings": []
}
```
1. この手順のステップ 2 で作成した mTLS 設定を使用してブローカーを作成します。これを行うには、次の例に示すように `create-broker` AWS CLI コマンドを使用します。このコマンドでは、ステップ 1 と 2 のレスポンスで取得した設定 ID とリビジョン番号をそれぞれ指定します。例えば、`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` と `2` です。
```
aws mq create-broker \
--broker-name "rabbitmq-mtls-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
このコマンドでは、次の例のようなレスポンスが返されます。
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-mtls-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. 次の例に示すように `describe-broker` AWS CLI コマンドを使用して`RUNNING`、ブローカーのステータスが から `CREATION_IN_PROGRESS`に移行していることを確認します。このコマンドでは、前のステップの結果で取得したブローカー ID を指定します。例えば、`b-2a1b5133-a10c-49d2-879b-8c176c34cf73`。
```
aws mq describe-broker \
--broker-id ""
```
このコマンドでは、次の例のようなレスポンスが返されます。次のレスポンスは、`describe-broker` コマンドが返す完全な出力の省略バージョンです。
```
{
"AuthenticationStrategy": "simple",
...,
"BrokerState": "RUNNING",
...
}
```
1. 次の`mtls.sh`スクリプトを使用して mTLS 認証を検証します。
この bash スクリプトを使用して、Amazon MQ for RabbitMQ ブローカーへの接続をテストします。このスクリプトは、クライアント証明書を使用して認証し、接続が正しく設定されているかどうかを確認します。正常に設定されると、ブローカーがメッセージを発行して消費します。
`ACCESS_REFUSED` エラーが発生した場合は、ブローカーの CloudWatch ログを使用して設定をトラブルシューティングできます。ブローカーの CloudWatch ロググループのリンクは、Amazon MQ コンソールにあります。
このスクリプトでは、次の値を指定する必要があります。
+ `USERNAME` および `PASSWORD`: ブローカーで作成した RabbitMQ ユーザー認証情報。
+ `CLIENT_KEYSTORE`: クライアントキーストアファイルへのパス (PKCS12 形式）。前提条件の CDK スタックを使用した場合、デフォルトのパスは です`$(pwd)/certs/client-keystore.p12`。
+ `KEYSTORE_PASSWORD`: クライアントキーストアのパスワード。前提条件の CDK スタックを使用した場合、デフォルトのパスワードは です`changeit`。
+ `BROKER_DNS`: この値は、Amazon MQ コンソールのブローカーの詳細ページの **Connections** にあります。
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
USERNAME=
PASSWORD=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${USERNAME}:${PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
finch run --rm --ulimit nofile=40960:40960 \
-v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
-e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# JMS アプリケーションを接続する
このチュートリアルでは、RabbitMQ JMS クライアントを使用して JMS アプリケーションを Amazon MQ for RabbitMQ ブローカーに接続する方法を示します。 RabbitMQ プロデューサーを作成してメッセージを送信し、コンシューマーを作成して RabbitMQ キューからメッセージを受信する方法について説明します。
開始する前に、適切な RabbitMQ JMS 依存関係を Maven プロジェクトに追加します。
JMS 1.1 および 2.0 の場合:
```
com.rabbitmq.jms
rabbitmq-jms
2.12.0
```
JMS 3.1 の場合:
```
com.rabbitmq.jms
rabbitmq-jms
3.5.0
```
## プロデューサーを作成する
次のコード例は、JMS を使用して RabbitMQ キューに書き込む方法を示しています。
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
connection = factory.createConnection();
connection.start();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination(queueName, true, false);
// Send the message to the queue
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
String msg_content = "Hello World!!";
TextMessage textMessage = session.createTextMessage(msg_content);
producer.send(textMessage);
System.out.printf("Published to AMQP queue '%s': %s", queueName, msg_content);
```
## コンシューマーを作成する
次のコード例は、JMS を使用して RabbitMQ キューから読み取る方法を示しています。
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
// Establish the connection and session
jakarta.jms.Connection connection = factory.createConnection();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination();
destination.setDestinationName(queueName);
destination.setAmqp(true);
destination.setAmqpQueueName(queueName);
// Initialize consumer
MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(message -> {
try {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
System.out.printf("Message: %s%n", textMessage.getText());
} else if (message instanceof BytesMessage) {
BytesMessage bytesMessage = (BytesMessage) message;
byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
bytesMessage.readBytes(bytes);
String content = new String(bytes);
System.out.printf("Message: %s%n", content);
} else {
System.out.printf("Message: [%s]%n", message.getClass().getSimpleName());
}
} catch (JMSException e) {
System.err.printf("Error processing message: %s%n", e.getMessage());
}
});
connection.start();
```