

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# RabbitMQ 자습서
<a name="rabbitmq-on-amazon-mq"></a>

다음 자습서는 Amazon MQ에서 RabbitMQ를 구성하고 사용하는 방법을 보여줍니다. Node.js, Python, .NET 등과 같은 다양한 프로그래밍 언어로 지원되는 클라이언트 라이브러리를 사용하는 방법에 대한 자세한 내용은 *RabbitMQ 시작 안내서*에서 [RabbitMQ 자습서](https://www.rabbitmq.com/getstarted.html)를 참조하세요.

**Topics**
+ [브로커 기본 설정 편집](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ [RabbitMQ용 Amazon MQ와 함께 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)
+ [RabbitMQ용 Amazon MQ에 OAuth 2.0 인증 및 권한 부여 사용](oauth-tutorial.md)
+ [RabbitMQ용 Amazon MQ에 대한 IAM 인증 및 권한 부여 사용](rabbitmq-iam-tutorial.md)
+ [RabbitMQ용 Amazon MQ에 LDAP 인증 및 권한 부여 사용](rabbitmq-ldap-tutorial.md)
+ [RabbitMQ용 Amazon MQ에 HTTP 인증 및 권한 부여 사용](rabbitmq-http-tutorial.md)
+ [RabbitMQ용 Amazon MQ에 SSL 인증서 인증 사용](rabbitmq-ssl-tutorial.md)
+ [AMQP 및 관리 엔드포인트에 mTLS 사용](rabbitmq-mtls-tutorial.md)
+ [JMS 애플리케이션 연결](rabbitmq-tutorial-jms.md)

# 브로커 기본 설정 편집
<a name="amazon-mq-rabbitmq-editing-broker-preferences"></a>

를 사용하여 CloudWatch 로그 활성화 또는 비활성화와 같은 브로커 기본 설정을 편집할 수 있습니다 AWS Management Console.

## RabbitMQ 브로커 옵션 편집
<a name="rabbitmq-edit-current-configuration-console"></a>

1. [Amazon MQ 콘솔](https://console.aws.amazon.com/amazon-mq/)에 로그인합니다.

1. 브로커 목록에서 브로커(예: **MyBroker**)를 선택한 다음 **Edit(편집)**을 선택합니다.

1. **Edit *MyBroker*(MyBroker 편집)** 페이지의 **Specifications(사양)** 섹션에서 **Broker engine version(브로커 엔진 버전)** 또는 **Broker Instance type(브로커 인스턴스 유형)**을 선택합니다.

   

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(수정 예약)**를 선택합니다.
**참고**  
**Enable automatic minor version upgrades(마이너 버전 자동 업그레이드 활성화)**만 선택하는 경우 브로커 재부팅이 필요하지 않기 때문에 버튼이 **Save(저장)**로 바뀝니다.

   지정된 시간에 기본 설정이 브로커에 적용됩니다.

# RabbitMQ용 Amazon MQ와 함께 Python Pika 사용
<a name="amazon-mq-rabbitmq-pika"></a>

 다음 자습서에서는 RabbitMQ용 Amazon MQ 브로커에 연결하도록 구성된 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)

## 사전 조건
<a name="amazon-mq-rabbitmq-pika-prerequisites"></a>

 이 자습서를 완료하려면 다음과 같은 사전 조건이 필요합니다.
+ RabbitMQ용 Amazon MQ 브로커 자세한 내용은 [RabbitMQ용 Amazon MQ 브로커 생성](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
  ```

## 권한
<a name="amazon-mq-rabbitmq-pika-permissions"></a>

이 자습서를 진행하려면 vhost에 대한 쓰기 및 읽기 권한이 있는 RabbitMQ용 Amazon MQ 브로커 사용자가 한 명 이상 필요합니다. 다음 표에서는 필요한 최소 권한을 정규식(regexp) 패턴으로 설명합니다.


| Tags | regexp 구성 | regexp 쓰기 | regexp 읽기 | 
| --- | --- | --- | --- | 
| none |  | .\$1 | .\$1 | 

 나열된 사용자 권한은 사용자에게 읽기 및 쓰기 권한만 제공합니다. 브로커에 대한 관리 작업을 수행할 수 있는 관리 플러그 인에 대한 액세스 권한은 부여되지 않습니다. 사용자의 액세스를 지정된 대기열로 제한하는 정규 표현식 패턴을 사용하여 권한을 추가적으로 제한할 수 있습니다. 예를 들어 읽기 정규 표현식 패턴을 `^[hello world].*`로 변경하면 해당 사용자에게는 `hello world`로 시작하는 대기열에서 읽을 수 있는 권한만 부여됩니다.

RabbitMQ 사용자를 생성하고 사용자 태그 및 권한을 관리하는 방법에 대한 자세한 내용은 [RabbitMQ용 Amazon MQ 브로커 사용자](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user) 단원을 참조하세요.

## 1단계: 기본 Python Pika 클라이언트 생성
<a name="amazon-mq-rabbitmq-pika-basic-client"></a>

RabbitMQ용 Amazon MQ 브로커와 상호 작용할 때 생성자를 정의하고 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단계: 게시자 생성 및 메시지 전송
<a name="amazon-mq-rabbitmq-pika-publisher-basic-publish"></a>

 대기열을 선언하는 게시자를 생성하고 단일 메시지를 전송하려면 다음을 수행합니다.

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(
           "<broker-id>",
           "<username>",
           "<password>",
           "<region>"
       )
   
       # 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` 생성자 문으로 전달되는 파라미터를 교체합니다.
   +  **`<broker-id>`** - Amazon MQ가 브로커에 대해 생성하는 고유한 ID입니다. 브로커 ARN에서 ID를 구문 분석할 수 있습니다. 예를 들어 ARN이 `arn:aws:mq:us-east-2:123456789012:broker:MyBroker:b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`인 경우 브로커 ID는 `b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`입니다.
   +  **`<username>`** - 브로커에 메시지를 쓸 수 있는 충분한 권한이 있는 브로커 사용자의 사용자 이름입니다.
   +  **`<password>`** - 브로커에 메시지를 쓸 수 있는 충분한 권한이 있는 브로커 사용자의 암호입니다.
   +  **`<region>`** - RabbitMQ용 Amazon MQ 브로커를 생성한 AWS 리전입니다. RabbitMQ 예를 들어 `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단계: 소비자 생성 및 메시지 수신
<a name="amazon-mq-rabbitmq-pika-consumer-basic-get"></a>

 대기열에서 단일 메시지를 수신하는 소비자를 생성하려면 다음을 수행합니다.

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(
           "<broker-id>",
           "<username>",
           "<password>",
           "<region>"
       )
   
       # 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
   ```

   코드가 성공적으로 실행되면 메시지 본문과 라우팅 키를 포함한 헤더가 터미널 창에 표시됩니다.

   ```
   <Basic.GetOk(['delivery_tag=1', 'exchange=', 'message_count=0', 'redelivered=False', 'routing_key=hello world queue'])> <BasicProperties> b'Hello World!'
   ```

## 4단계: (선택 사항) 이벤트 루프 설정 및 메시지 소비
<a name="amazon-mq-rabbitmq-pika-consumer-basic-consume"></a>

 대기열에서 여러 메시지를 소비하려면 다음과 같이 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(
           "<broker-id>",
           "<username>",
           "<password>",
           "<region>"
       )
   
       # 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!'
   ...
   ```

## 다음 단계
<a name="amazon-mq-rabbitmq-pika-whats-next"></a>
+  지원되는 기타 RabbitMQ 클라이언트 라이브러리에 대한 자세한 내용은 RabbitMQ 웹 사이트에서 [RabbitMQ 클라이언트 설명서](https://www.rabbitmq.com/clients.html)를 참조하세요.

# RabbitMQ 일시 중지된 대기열 동기화 문제 해결
<a name="rabbitmq-queue-sync"></a>

RabbitMQ용 Amazon MQ [클러스터 배포](rabbitmq-broker-architecture.md#rabbitmq-broker-architecture-cluster)에서 각 대기열에 게시된 메시지는 세 개의 브로커 노드 간에 복제됩니다. *미러링*이라고 하는 이 복제는 RabbitMQ 브로커에 고가용성(HA)을 제공합니다. 클러스터 배포의 대기열은 한 노드의 *기본* 복제본과 하나 이상의 *미러*로 구성됩니다. 미러링된 대기열에 적용되는 메시지 대기열에 넣기를 비롯한 모든 작업은 먼저 기본 대기열에 적용된 다음 해당 미러 전체에 복제됩니다.

예를 들어 미러링된 대기열이 기본 노드(`main`)와 두 개 미러(`mirror-1` 및 `mirror-2`)의 세 개 노드에서 복제된다고 가정합니다. 이 미러링된 대기열의 모든 메시지가 모든 미러에 전파되면 대기열이 동기화됩니다. 노드(`mirror-1`)가 일정 시간 사용할 수 없게 되더라도 대기열은 작동하고 계속 메시지를 대기열에 넣을 수 있습니다. 그러나 대기열을 동기화하려면 `mirror-1`을 사용할 수 없는 동안 `main`에 게시된 메시지를 `mirror-1`에 복제해야 합니다.

미러링에 대한 자세한 내용은 RabbitMQ 웹 사이트에서 [클래식 미러링된 대기열](https://www.rabbitmq.com/ha.html)을 참조하세요.

**유지 관리 및 대기열 동기화**

[유지 관리 기간](amazon-mq-rabbitmq-editing-broker-preferences.md#rabbitmq-edit-current-configuration-console) 중 Amazon MQ는 모든 유지 관리 작업을 한 번에 한 노드에서 수행하여 브로커가 계속 작동하도록 합니다. 따라서 각 노드의 작동이 다시 시작할 때 대기열을 동기화해야 할 수 있습니다. 동기화하는 동안 미러에 복제되어야 하는 메시지는 해당하는 Amazon Elastic Block Store(Amazon EBS) 볼륨에서 메모리로 로드되어 배치로 처리됩니다. 메시지를 배치로 처리하면 대기열을 더 빠르게 동기화할 수 있습니다.

대기열이 짧게 유지되고 메시지가 작으면 대기열이 성공적으로 동기화되고 예상대로 작업이 재개됩니다. 그러나 배치의 데이터 양이 노드의 메모리 한도에 가까워지면 노드에서 고용량 메모리 경보가 발생하여 대기열 동기화가 일시 중지됩니다. 메모리 사용량은 [CloudWatch의 브로커 노드 지표](amazon-mq-accessing-metrics.md) `RabbitMemUsed`와 `RabbitMqMemLimit`를 비교하여 확인할 수 있습니다. 메시지가 사용 또는 삭제되거나 배치의 메시지 수가 줄지 않으면 동기화가 완료될 수 없습니다.

**참고**  
대기열 동기화 배치 크기를 줄이면 복제 트랜잭션 수가 더 많아질 수 있습니다.

일시 중지된 대기열 동기화 문제를 해결하려면 `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)

## 사전 조건
<a name="rabbitmq-queue-sync-prerequisites"></a>

이 자습서를 사용하려면 관리자 권한이 있는 RabbitMQ용 Amazon MQ 브로커 사용자가 있어야 합니다. 브로커를 처음 생성할 때 만든 관리자 사용자를 사용하거나 나중에 만들었을 수 있는 다른 사용자를 사용할 수 있습니다. 다음 표에는 필요한 관리자 사용자 태그 및 권한이 정규식(regexp) 패턴으로 나와 있습니다.


| Tags | regexp 읽기 | regexp 구성 | regexp 쓰기 | 
| --- | --- | --- | --- | 
| administrator | .\$1 | .\$1 | .\$1 | 

RabbitMQ 사용자를 생성하고 사용자 태그 및 권한을 관리하는 방법에 대한 자세한 내용은 [RabbitMQ용 Amazon MQ 브로커 사용자](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user) 단원을 참조하세요.

## 1단계: `ha-sync-batch-size` 정책 적용
<a name="rabbitmq-queue-sync-step-1"></a>

다음 절차에서는 브로커에서 생성되는 모든 대기열에 적용되는 정책을 추가하는 방법을 보여줍니다. RabbitMQ 웹 콘솔이나 RabbitMQ 관리 API를 사용할 수 있습니다. 자세한 내용은 RabbitMQ 웹 사이트에서 [관리 플러그 인](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(정책 추가/업데이트)**를 확장합니다.
**참고**  
기본적으로 RabbitMQ용 Amazon MQ 클러스터는 `ha-all-AWS-OWNED-DO-NOT-DELETE`라는 초기 브로커 정책과 함께 생성됩니다. Amazon MQ는 브로커의 모든 대기열이 세 노드 모두에 복제되고 대기열이 자동으로 동기화되도록 이 정책을 관리합니다.

1. 새 브로커 정책을 생성하려면 **Add / update a policy(정책 추가/업데이트)**에서 다음을 수행합니다.

   1. **Name(이름)**에 정책의 이름을 입력합니다(예: **batch-size-policy**).

   1. **Pattern(패턴)**에 regexp 패턴 **.\$1**를 입력합니다. 이 경우 정책이 브로커의 모든 대기열과 일치합니다.

   1. **Apply to(적용 대상)**의 드롭다운 목록에서 **Exchanges and queues(교환 및 대기열)**를 선택합니다.

   1. **Priority(우선 순위)**에 vhost에 적용된 다른 모든 정책보다 큰 정수를 입력합니다. 지정된 시간에 RabbitMQ 대기열 및 교환에 정확히 하나의 정책 정의 집합을 적용할 수 있습니다. RabbitMQ는 가장 높은 우선 순위 값과 일치하는 정책을 선택합니다. 정책 우선 순위 및 정책을 결합하는 방법에 대한 자세한 내용은 RabbitMQ Server 설명서에서 [정책](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 관리 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단계: 대기열 동기화 다시 시작
<a name="rabbitmq-queue-sync-step-2"></a>

브로커에 새 `ha-sync-batch-size` 정책을 적용한 후 대기열 동기화를 다시 시작합니다.

**RabbitMQ 웹 콘솔을 사용하여 대기열 동기화를 다시 시작하려면**
**참고**  
RabbitMQ 웹 콘솔을 열려면 이 자습서 1단계의 이전 지침을 참조하세요.

1. RabbitMQ 웹 콘솔의 페이지 상단에서 **Queues(대기열)**를 선택합니다.

1. **Queues(대기열)** 페이지의 **All queues(모든 대기열)**에서 일시 중지된 대기열을 찾습니다. **정책** 열에서 생성한 새 정책의 이름(예: `batch-size-policy`)이 대기열에 표시되어야 합니다.

1. 줄어든 배치 크기로 동기화 프로세스를 다시 시작하려면 먼저 대기열 동기화를 취소합니다. 그런 다음 대기열 동기화를 다시 시작합니다.

**참고**  
동기화가 일시 중지되고 성공적으로 완료되지 않으면 `ha-sync-batch-size` 값을 줄이고 대기열 동기화를 다시 시작해 보세요.

## 다음 단계
<a name="rabbitmq-queue-sync-next-steps"></a>
+ 대기열이 동기화되면 Amazon CloudWatch 지표 `RabbitMQMemUsed`를 확인하여 RabbitMQ 노드에서 사용하는 메모리 양을 모니터링할 수 있습니다. 또한 `RabbitMQMemLimit` 지표를 확인하여 노드의 메모리 제한을 모니터링할 수 있습니다. 자세한 내용은 [Amazon MQ의 CloudWatch 지표 액세스](amazon-mq-accessing-metrics.md) 및 [RabbitMQ용 Amazon MQ 브로커에 사용 가능한 CloudWatch 지표](rabbitmq-logging-monitoring.md) 단원을 참조하세요.
+ 대기열 동기화 일시 중지를 방지하려면 대기열을 짧게 유지하고 메시지를 처리하는 것이 좋습니다. 메시지 크기가 더 큰 워크로드의 경우 브로커 인스턴스 유형을 메모리가 더 많은 더 큰 인스턴스 크기로 업그레이드하는 것이 좋습니다. 브로커 인스턴스 유형 및 브로커 기본 설정 편집에 대한 자세한 내용은 [브로커 기본 설정 편집](amazon-mq-rabbitmq-editing-broker-preferences.md) 섹션을 참조하세요.
+  새 RabbitMQ용 Amazon MQ 브로커를 생성할 때 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) 단원을 참조하세요.

## 관련 리소스
<a name="rabbitmq-queue-sync-related-resources"></a>
+  [UpdateBrokerInput](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-model-updatebrokerinput) - Amazon MQ API를 사용하여 브로커 인스턴스 유형을 업데이트하려면 이 브로커 속성을 사용합니다.
+ [파라미터 및 정책](https://www.rabbitmq.com/parameters.html)(RabbitMQ Server 설명서) - RabbitMQ 웹 사이트에서 RabbitMQ 파라미터 및 정책에 대해 자세히 알아봅니다.
+ [RabbitMQ 관리 HTTP API](https://pulse.mozilla.org/api/) - RabbitMQ 관리 API에 대해 자세히 알아봅니다.

# 연결 및 채널 수 축소
<a name="reducing-connections-and-channels"></a>

Amazon MQ 브로커용 RabbitMQ와의 연결은 클라이언트 애플리케이션에서 닫거나 RabbitMQ 웹 콘솔을 사용하여 수동으로 닫을 수 있습니다. RabbitMQ 웹 콘솔을 사용하여 연결을 닫으려면 다음을 수행하세요.

1. 에 로그인 AWS Management Console 하고 브로커의 RabbitMQ 웹 콘솔을 엽니다.

1.  RabbitMQ 콘솔에서 **연결(Connections)** 탭을 선택합니다.

1. **연결** 페이지의 **모든 연결(All connections)** 목록에서 닫을 연결의 이름을 선택합니다.

1.  연결 세부 정보 페이지에서 **이 연결 닫기(Close this connection)**를 선택하여 섹션을 확장한 다음 **강제 닫기(Force Close)**를 선택합니다. 필요에 따라 직접 입력한 설명을 추가하여 **이유(Reason)**의 기본 텍스트를 변경할 수 있습니다. RabbitMQ용 Amazon MQ는 연결을 닫을 때 사용자가 지정한 이유를 클라이언트에 반환합니다.

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 기반 애플리케이션 연결
<a name="rabbitmq-connect-jvm-application"></a>

 RabbitMQ 브로커를 생성한 후 애플리케이션을 브로커에 연결할 수 있습니다. 다음 예제에서는 [RabbitMQ Java 클라이언트 라이브러리](https://www.rabbitmq.com/java-client.html)를 사용하여 브로커에 대한 연결을 생성하고, 대기열을 생성하고, 메시지를 전송하는 방법을 보여줍니다. 다양한 언어로 지원되는 RabbitMQ 클라이언트 라이브러리를 사용하여 RabbitMQ 브로커에 연결할 수 있습니다. 지원되는 RabbitMQ 클라이언트 라이브러리에 대한 자세한 내용은 [RabbitMQ 클라이언트 라이브러리 및 개발자 도구](https://www.rabbitmq.com/devtools.html)를 참조하세요.

### 사전 조건
<a name="rabbitmq-connect-application-prerequisites-getting-started"></a>

**참고**  
다음의 사전 필수 단계는 퍼블릭 액세스 가능성 없이 생성된 RabbitMQ 브로커에만 적용됩니다. 퍼블릭 액세스 가능성이 있는 브로커를 생성하는 경우에는 건너뛸 수 있습니다.

#### VPC 속성 활성화
<a name="rabbitmq-connect-application-enable-vpc-attributes-getting-started"></a>

VPC 내에서 브로커에 액세스할 수 있도록 하려면 `enableDnsHostnames` 및 `enableDnsSupport` VPC 속성을 활성화해야 합니다. 자세한 내용은 *Amazon VPC 사용 설명서*의 [VPC에서 DNS 지원](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support)을 참조하세요.

#### 인바운드 연결 활성화
<a name="rabbitmq-connect-application-allow-inbound-connections-getting-started"></a>

1. [Amazon MQ 콘솔](https://console.aws.amazon.com/amazon-mq/)에 로그인합니다.

1. 브로커 목록에서 브로커 이름(예: **MyBroker**)을 선택합니다.

1. ***MyBroker*** 페이지의 **Connections(연결)** 섹션에서 브로커의 웹 콘솔 URL 및 와이어 레벨 프로토콜의 주소 및 포트를 적어둡니다.

1. **세부 정보** 섹션의 **보안 및 네트워크**에서 보안 그룹의 이름 또는 ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/ko_kr/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png)을 선택합니다.

   EC2 Dashboard의 **보안 그룹** 페이지가 표시됩니다.

1. 보안 그룹 목록에서 보안 그룹을 선택합니다.

1. 페이지 하단에서 **인바운드**를 선택한 후 **편집**을 선택합니다.

1. **Edit inbound rules(인바운드 규칙 편집)** 대화 상자에서 공개적으로 액세스하고자 하는 모든 URL 또는 엔드포인트에 대한 규칙을 추가합니다. 다음 예제에서는 브로커 웹 콘솔에 대해 이 작업을 수행하는 방법을 보여줍니다.

   1. **규칙 추가(Add Rule)**를 선택합니다.

   1. **유형**에서 **Custom TCP(사용자 지정 TCP)**를 선택합니다.

   1. **Source(소스)**에서 **Custom(사용자 지정)**을 선택한 상태에서 웹 콘솔에 액세스하는 데 사용할 시스템의 IP 주소(예: `192.0.2.1`)를 입력합니다.

   1. **저장**을 선택합니다.

      이제 브로커가 인바운드 연결을 허용할 수 있습니다.

#### Java 종속성 추가
<a name="rabbitmq-connect-application-java-dependencies-getting-started"></a>

빌드 자동화를 위해 Apache Maven을 사용하는 경우 `pom.xml` 파일에 다음 종속성을 추가합니다. Apache Maven의 Project Object Model 파일에 대한 자세한 내용은 [POM 소개](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html)를 참조하세요.

```
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.9.0</version>
</dependency>
```

빌드 자동화에 [Gradle](https://docs.gradle.org/current/userguide/userguide.html)을 사용하는 경우 다음 종속성을 선언합니다.

```
dependencies {
    compile 'com.rabbitmq:amqp-client:5.9.0'
}
```

#### `Connection` 및 `Channel` 클래스 가져오기
<a name="rabbitmq-import-connections-and-channels"></a>

 RabbitMQ Java 클라이언트는 각각 AMQP 0-9-1 연결 및 채널을 나타내는 `Connection` 및 `Channel` API 클래스가 포함된 `com.rabbitmq.client`를 최상위 패키지로 사용합니다. `Connection` 및 `Channel` 클래스를 사용하려면 다음 예제와 같이 먼저 가져옵니다.

```
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
```

#### `ConnectionFactory` 생성 및 브로커에 연결
<a name="rabbitmq-create-connection-factory-and-connect"></a>

다음 예제에 따라 지정된 파라미터를 사용하여 `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();
```

#### 교환에 메시지 게시
<a name="rabbitmq-publish-message"></a>

 `Channel.basicPublish`를 사용하여 메시지를 교환에 게시할 수 있습니다. 다음 예제에서는 AMQP `Builder` 클래스를 사용하여 콘텐츠 유형이 `plain/text`인 메시지 속성 객체를 빌드합니다.

```
byte[] messageBodyBytes = "Hello, world!".getBytes();
channel.basicPublish(exchangeName, routingKey,
             new AMQP.BasicProperties.Builder()
               .contentType("text/plain")
               .userId("userId")
               .build(),
               messageBodyBytes);
```

**참고**  
`BasicProperties`는 자동 생성된 소유자 클래스의 내부 클래스인 `AMQP`입니다.

#### 대기열 구독 및 메시지 수신
<a name="rabbitmq-subscribe-receive-message"></a>

`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` 메서드에서 수행하면 가장 간편합니다.

#### 연결 닫기 및 브로커와 연결 끊기
<a name="rabbitmq-disconnect"></a>

RabbitMQ 브로커와 연결을 끊으려면 다음과 같이 채널과 연결을 모두 닫습니다.

```
channel.close();
conn.close();
```

**참고**  
RabbitMQ Java 클라이언트 라이브러리를 사용하는 방법에 대한 자세한 내용은 [RabbitMQ Java 클라이언트 API 가이드](https://www.rabbitmq.com/api-guide.html)를 참조하세요.

## 3단계: (선택 사항) AWS Lambda 함수에 연결
<a name="rabbitmq-connect-to-lambda"></a>

 AWS Lambda 는 Amazon MQ 브로커의 메시지에 연결하고 사용할 수 있습니다. 브로커를 Lambda에 연결할 때는 대기열에서 메시지를 읽고 함수를 [동기식으로](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 함수 [실행 역할](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가 브로커에 연결하도록 허용해야 합니다.
   +  퍼블릭 서브넷당 하나의 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 Management Console을 사용하여 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 페이로드는 브로커의 엔진 유형에 따라 다릅니다. 다음은 RabbitMQ용 Amazon MQ 대기열의 Lambda 페이로드 예제입니다.
**참고**  
 예제에서 `test`는 RabbitMQ 대기열의 이름이고 `/`는 기본 가상 호스트의 이름입니다. 메시지를 받을 때 이벤트 소스는 `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)을 참조하세요.

# RabbitMQ용 Amazon MQ에 OAuth 2.0 인증 및 권한 부여 사용
<a name="oauth-tutorial"></a>

이 자습서에서는 Amazon Cognito를 OAuth 2.0 공급자로 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 [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 인증을 구성하기 위한 사전 조건
<a name="oauth-tutorial-prerequisites"></a>

AWS CDK 스택, [RabbitMQ용 Amazon Cognito OAuth 2 플러그인](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample)을 배포하여 이 자습서에 필요한 Amazon Cognito 리소스를 설정할 수 있습니다. Amazon Cognito를 수동으로 설정하는 경우 RabbitMQ용 Amazon MQ 브로커에서 OAuth 2.0을 구성하기 전에 다음 사전 조건을 충족해야 합니다.

**Amazon Cognito를 설정하기 위한 사전 조건**
+ 사용자 풀을 생성하여 Amazon Cognito 엔드포인트를 설정합니다. 이렇게 하려면 [Amazon Cognito에서 OAuth 2.0을 사용하는 방법: 다양한 OAuth 2.0 권한 부여에 대해 알아보기](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/)라는 제목의 블로그를 참조하세요.
+ 범위가 정의된 사용자 풀 `read:all`, `write:all`, `configure:all` 및 `tag:administrator`에서 `rabbitmq`라는 리소스 서버를 생성합니다. 이러한 범위는 RabbitMQ 권한과 연결됩니다.

  리소스 서버 생성에 대한 자세한 내용은 *Amazon Cognito 개발자 안내서*의 [사용자 풀(AWS Management Console)에 대한 리소스 서버 정의](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 관리 콘솔에 사용자를 로그인하는 데 사용되는 퍼블릭 클라이언트입니다. 다음 절차에서 생성할 RabbitMQ용 Amazon MQ 브로커의 엔드포인트를 허용된 콜백 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 버전 >= `2.28.23` - 브로커 생성 중에 사용자 이름과 암호를 선택적으로 추가할 수 있습니다.

## AWS CLI를 사용하여 Amazon Cognito로 OAuth 2.0 인증 구성
<a name="oauth-tutorial-config-cognito-using-cli"></a>

다음 절차에서는 Amazon Cognito를 IdP로 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 OAuth 2.0 인증을 설정하는 방법을 보여줍니다. 이 절차에서는 AWS CLI를 사용하여 필요한 리소스를 생성하고 구성합니다.

다음 절차에서는 configurationID 및 Revision, *<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>* 및 *<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 "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>" \
     --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": "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>","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 "<b-2a1b5133-a10c-49d2-879b-8c176c34cf73>"
   ```

   이 명령은 다음 예제와 유사한 응답을 반환합니다. 다음 응답은 `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 스크립트를 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 연결을 테스트합니다. 이 스크립트는 Amazon Cognito에서 토큰을 가져와 연결이 제대로 구성되었는지 확인합니다. 성공적으로 구성되면 브로커가 메시지를 게시하고 소비하는 것을 볼 수 있습니다.

   `ACCESS_REFUSED` 오류가 발생하면 브로커에 대한 CloudWatch 로그를 사용하여 구성 설정 문제를 해결할 수 있습니다. Amazon MQ 콘솔에서 브로커의 CloudWatch 로그 그룹에 대한 링크를 찾을 수 있습니다.

   이 스크립트에서는 다음 값을 제공해야 합니다.
   + `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=<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 및 단순 인증 구성
<a name="oauth-tutorial-config-both-auth-methods-using-cli"></a>

OAuth 2.0 인증을 사용하여 브로커를 생성할 때 다음 인증 방법 중 하나를 지정할 수 있습니다.
+ **OAuth 2.0 전용**: 이 방법을 사용하려면 브로커를 생성하는 동안 사용자 이름과 암호를 제공하지 마십시오. [이전 절차](#oauth-tutorial-config-cognito-using-cli)에서는 OAuth 2.0 인증 방법만 사용하는 방법을 보여줍니다.
+ **OAuth 2.0 및 단순 인증**: 이 방법을 사용하려면 브로커를 생성하는 동안 사용자 이름과 암호를 제공합니다. 또한 다음 절차와 같이 `auth_backends.2 = internal`을 브로커 구성에 추가합니다.

다음 절차에서는 *<ConfigurationId>* 및 *<Revision>*과 같은 자리 표시자 값을 실제 값으로 바꿔야 합니다.

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": "<ConfigurationId>","Revision": <Revision>}' \
    --users '[{"Username":"<myUser>","Password":"<myPassword11>"}]'
   ```

1. [Amazon Cognito를 사용하여 OAuth 2.0 인증 구성](#oauth-tutorial-config-cognito-using-cli) 절차의 5단계와 6단계에 설명된 대로 브로커 상태와 인증 방법 설정 구성이 성공했는지 확인합니다.

# RabbitMQ용 Amazon MQ에 대한 IAM 인증 및 권한 부여 사용
<a name="rabbitmq-iam-tutorial"></a>

다음 절차에서는 RabbitMQ용 Amazon MQ 브로커에 대해 AWS IAM 인증 및 권한 부여를 활성화하는 방법을 보여줍니다. IAM을 활성화한 후 사용자는 AWS IAM 자격 증명을 사용하여 RabbitMQ 관리 API에 액세스하고 AMQP를 통해 연결할 수 있습니다. IAM 인증이 RabbitMQ용 Amazon MQ에서 작동하는 방식에 대한 자세한 내용은 섹션을 참조하세요[RabbitMQ용 Amazon MQ에 대한 IAM 인증 및 권한 부여](iam-for-amq-for-rabbitmq.md).

## 사전 조건
<a name="iam-tutorial-prerequisites"></a>
+ AWS RabbitMQ용 Amazon MQ 브로커를 소유한 AWS 계정의 관리자 자격 증명
+ 이러한 관리자 자격 증명으로 구성된 셸 환경( AWS CLI 프로필 또는 환경 변수 사용)
+ AWS CLI 설치 및 구성
+ `jq` 명령줄 JSON 프로세서 설치됨
+ `curl` 명령줄 도구 설치됨

## 를 사용하여 IAM 인증 및 권한 부여 구성 AWS CLI
<a name="iam-tutorial-procedure"></a>

1. **환경 변수 설정**

   브로커에 필요한 환경 변수를 설정합니다.

   ```
   export AWS_DEFAULT_REGION=<region>
   export BROKER_ID=<broker-id>
   ```

1. **아웃바운드 JWT 토큰 활성화**

    AWS 계정에 대해 아웃바운드 웹 자격 증명 페더레이션을 활성화합니다.

   ```
   ISSUER_IDENTIFIER=$(aws iam enable-outbound-web-identity-federation --query 'IssuerIdentifier' --output text)
   echo $ISSUER_IDENTIFIER
   ```

   출력에는 계정의 고유한 발급자 식별자 URL이 형식으로 표시됩니다`https://<id>.tokens.sts.global.api.aws`.

1. **IAM 정책 문서 생성**

   웹 자격 증명 토큰을 가져올 수 있는 권한을 부여하는 정책 문서를 생성합니다.

   ```
   cat > policy.json << 'EOF'
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor0",
               "Effect": "Allow",
               "Action": [
                   "sts:GetWebIdentityToken",
                   "sts:TagGetWebIdentityToken"
               ],
               "Resource": "*"
           }
       ]
   }
   EOF
   ```

1. **신뢰 정책 생성**

   호출자 자격 증명을 검색하고 신뢰 정책 문서를 생성합니다.

   ```
   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 역할을 수임하고 웹 자격 증명 토큰을 얻습니다.

   ```
   # 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 관리 API에 액세스합니다.

   ```
   BROKER_URL=<broker-id>.mq.<region>.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=<broker-endpoint>
   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 로그를 사용하여 구성 설정 문제를 해결할 수 있습니다. Amazon MQ 콘솔에서 브로커의 CloudWatch Logs 로그 그룹에 대한 링크를 찾을 수 있습니다.

# RabbitMQ용 Amazon MQ에 LDAP 인증 및 권한 부여 사용
<a name="rabbitmq-ldap-tutorial"></a>

이 자습서에서는를 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 LDAP 인증 및 권한 부여를 구성하는 방법을 설명합니다 AWS Managed Microsoft AD.

**Topics**
+ [LDAP 인증 및 권한 부여를 구성하기 위한 사전 조건](#rabbitmq-ldap-tutorial-prerequisites)
+ [AWS CLI를 사용하여 RabbitMQ에서 LDAP 구성](#rabbitmq-ldap-tutorial-configure-cli)

## LDAP 인증 및 권한 부여를 구성하기 위한 사전 조건
<a name="rabbitmq-ldap-tutorial-prerequisites"></a>

RabbitMQ LDAP 통합용 Amazon MQ용 CDK 스택을 배포하여이 자습서에 필요한 AWS 리소스를 설정할 수 있습니다. [AWS Amazon MQ RabbitMQ 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 스택을 사용하는 대신 리소스를 수동으로 설정하는 경우 RabbitMQ용 Amazon MQ 브로커에 LDAP를 구성하기 전에 동등한 인프라가 있는지 확인합니다.

### Amazon MQ를 설정하기 위한 사전 조건
<a name="rabbitmq-ldap-tutorial-prerequisite-cli"></a>

AWS CLI 버전 >= 2.28.23: 브로커 생성 중에 사용자 이름과 암호를 선택적으로 추가할 수 있습니다.

## AWS CLI를 사용하여 RabbitMQ에서 LDAP 구성
<a name="rabbitmq-ldap-tutorial-configure-cli"></a>

이 절차에서는 AWS CLI를 사용하여 필요한 리소스를 생성하고 구성합니다. 다음 절차에서는 configurationID 및 개정, `<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>`와 같은 자리 표시자 값을 실제 값으로 바꿔야 `<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. 다음 예제와 같이 라는 구성 파일을 생성`rabbitmq.conf`하여 LDAP를 인증 및 권한 부여 방법으로 사용합니다. 템플릿의 모든 자리 표시자 값(로 표시됨`${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 "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>" \
     --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": "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>","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 "<b-2a1b5133-a10c-49d2-879b-8c176c34cf73>"
   ```

   이 명령은 다음 예제와 유사한 응답을 반환합니다. 다음 응답은 `describe-broker` 명령이 반환하는 전체 출력의 약식 버전입니다. 이 응답은 브로커 상태와 브로커를 보호하는 데 사용되는 인증 전략을 보여줍니다. 이 경우 `config_managed` 인증 전략은 브로커가 LDAP 인증 방법을 사용함을 나타냅니다.

   ```
   {
   "AuthenticationStrategy": "config_managed",
       ...,
       "BrokerState": "RUNNING",
       ...
   }
   ```

1. 필수 CDK 스택에서 생성한 테스트 사용자 중 하나를 사용하여 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"}'
   ```

# RabbitMQ용 Amazon MQ에 HTTP 인증 및 권한 부여 사용
<a name="rabbitmq-http-tutorial"></a>

이 자습서에서는 외부 HTTP 서버를 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 HTTP 인증 및 권한 부여를 구성하는 방법을 설명합니다.

**참고**  
HTTP 인증 플러그인은 RabbitMQ용 Amazon MQ 버전 4 이상에서만 사용할 수 있습니다. RabbitMQ 

**Topics**
+ [HTTP 인증 및 권한 부여를 구성하기 위한 사전 조건](#rabbitmq-http-tutorial-prerequisites)
+ [AWS CLI를 사용하여 RabbitMQ에서 HTTP 인증 구성](#rabbitmq-http-tutorial-configure-cli)

## HTTP 인증 및 권한 부여를 구성하기 위한 사전 조건
<a name="rabbitmq-http-tutorial-prerequisites"></a>

[AWS RabbitMQ용 Amazon MQ HTTP 인증 통합을 위한 CDK 스택](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-http-sample/)을 배포하여이 자습서에 필요한 AWS 리소스를 설정할 수 있습니다.

이 CDK 스택은 HTTP 인증 서버, 인증서 및 IAM 역할을 포함하여 필요한 모든 AWS 리소스를 자동으로 생성합니다. 스택에서 생성한 리소스의 전체 목록은 패키지 README를 참조하세요.

CDK 스택을 사용하는 대신 리소스를 수동으로 설정하는 경우 RabbitMQ용 Amazon MQ 브로커에 HTTP 인증을 구성하기 전에 동등한 인프라가 있는지 확인합니다.

### Amazon MQ를 설정하기 위한 사전 조건
<a name="rabbitmq-http-tutorial-prerequisite-cli"></a>

AWS CLI 버전 >= 2.28.23: 브로커 생성 중에 사용자 이름과 암호를 선택적으로 추가할 수 있습니다.

## AWS CLI를 사용하여 RabbitMQ에서 HTTP 인증 구성
<a name="rabbitmq-http-tutorial-configure-cli"></a>

이 절차에서는 AWS CLI를 사용하여 필요한 리소스를 생성하고 구성합니다. 다음 절차에서는 자리 표시자 값을 실제 값으로 바꿔야 합니다.

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 "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>" \
     --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": "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>","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 "<b-2a1b5133-a10c-49d2-879b-8c176c34cf73>"
   ```

   이 명령은 다음 예제와 유사한 응답을 반환합니다. `config_managed` 인증 전략은 브로커가 HTTP 인증 방법을 사용함을 나타냅니다.

   ```
   {
       "AuthenticationStrategy": "config_managed",
       ...,
       "BrokerState": "RUNNING",
       ...
   }
   ```

1. 필수 CDK 스택에서 생성한 테스트 사용자 중 하나를 사용하여 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 '{}'
   ```

# RabbitMQ용 Amazon MQ에 SSL 인증서 인증 사용
<a name="rabbitmq-ssl-tutorial"></a>

이 자습서에서는 프라이빗 인증 기관을 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 SSL 인증서 인증을 구성하는 방법을 설명합니다.

**참고**  
SSL 인증서 인증 플러그인은 RabbitMQ용 Amazon MQ 버전 4 이상에서만 사용할 수 있습니다. RabbitMQ 

**Topics**
+ [SSL 인증서 인증을 구성하기 위한 사전 조건](#rabbitmq-ssl-tutorial-prerequisites)
+ [AWS CLI를 사용하여 RabbitMQ에서 SSL 인증서 인증 구성](#rabbitmq-ssl-tutorial-configure-cli)

## SSL 인증서 인증을 구성하기 위한 사전 조건
<a name="rabbitmq-ssl-tutorial-prerequisites"></a>

SSL 인증서 인증은 상호 TLS(mTLS)를 사용하여 X.509 인증서를 사용하여 클라이언트를 인증합니다. [AWS RabbitMQ용 Amazon MQ mTLS 통합을 위한 CDK 스택을](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/) 배포하여이 자습서에 필요한 AWS 리소스를 설정할 수 있습니다.

이 CDK 스택은 인증 기관, 클라이언트 인증서 및 IAM 역할을 포함하여 필요한 모든 AWS 리소스를 자동으로 생성합니다. 스택에서 생성한 리소스의 전체 목록은 패키지 README를 참조하세요.

**참고**  
CDK 스택을 배포하기 전에 `RABBITMQ_TEST_USER_NAME` 환경 변수를 설정합니다. 이 값은 클라이언트 인증서의 일반 이름(CN)으로 사용되며 자습서 단계에서 사용하는 사용자 이름과 일치해야 합니다. 예: `export RABBITMQ_TEST_USER_NAME="myuser"`

CDK 스택을 사용하는 대신 리소스를 수동으로 설정하는 경우 RabbitMQ용 Amazon MQ 브로커에서 SSL 인증서 인증을 구성하기 전에 동등한 인프라가 있는지 확인합니다.

### Amazon MQ를 설정하기 위한 사전 조건
<a name="rabbitmq-ssl-tutorial-prerequisite-cli"></a>

AWS CLI 버전 >= 2.28.23: 브로커 생성 중에 사용자 이름과 암호를 선택적으로 추가할 수 있습니다.

## AWS CLI를 사용하여 RabbitMQ에서 SSL 인증서 인증 구성
<a name="rabbitmq-ssl-tutorial-configure-cli"></a>

이 절차에서는 AWS CLI를 사용하여 필요한 리소스를 생성하고 구성합니다. 다음 절차에서는 configurationID, Revision 및 `<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>`와 같은 자리 표시자 값을 실제 값으로 바꿔야 `<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. 다음 예제와 같이 라는 구성 파일을 생성`rabbitmq.conf`하여 SSL 인증서 인증을 사용합니다. 템플릿의 모든 자리 표시자 값(로 표시됨`${...}`)을 배포된 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 "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>" \
     --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": "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>","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 "<b-2a1b5133-a10c-49d2-879b-8c176c34cf73>"
   ```

   이 명령은 다음 예제와 유사한 응답을 반환합니다. 다음 응답은 `describe-broker` 명령이 반환하는 전체 출력의 약식 버전입니다. 이 응답은 브로커 상태와 브로커를 보호하는 데 사용되는 인증 전략을 보여줍니다. 이 경우 `config_managed` 인증 전략은 브로커가 SSL 인증서 인증 방법을 사용함을 나타냅니다.

   ```
   {
       "AuthenticationStrategy": "config_managed",
       ...,
       "BrokerState": "RUNNING",
       ...
   }
   ```

1. 다음 `ssl.sh` 스크립트를 사용하여 SSL 인증서 인증을 확인합니다.

   이 bash 스크립트를 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 연결을 테스트합니다. 이 스크립트는 클라이언트 인증서를 인증에 사용하고 연결이 제대로 구성되었는지 확인합니다. 성공적으로 구성되면 브로커가 메시지를 게시하고 소비하는 것을 볼 수 있습니다.

   `ACCESS_REFUSED` 오류가 발생하면 브로커에 대한 CloudWatch 로그를 사용하여 구성 설정 문제를 해결할 수 있습니다. Amazon MQ 콘솔에서 브로커의 CloudWatch 로그 그룹에 대한 링크를 찾을 수 있습니다.

   이 스크립트에서는 다음 값을 제공해야 합니다.
   + `USERNAME`: 클라이언트 인증서의 일반 이름(CN)입니다.
   + `CLIENT_KEYSTORE`: 클라이언트 키 스토어 파일(PKCS12 형식)의 경로입니다. 필수 CDK 스택을 사용한 경우 기본 경로는 입니다`$(pwd)/certs/client-keystore.p12`.
   + `KEYSTORE_PASSWORD`: 클라이언트 키 스토어의 암호입니다. 필수 CDK 스택을 사용한 경우 기본 암호는 입니다`changeit`.
   + `BROKER_DNS`: Amazon MQ 콘솔의 브로커 세부 정보 페이지에 있는 **연결**에서이 값을 찾을 수 있습니다.

   ```
   #! /bin/bash
   set -e
   
   # Client information
   ## FIXME: Update this value with the client ID and secret of your confidential application client
   USERNAME=<client_cert_common_name>
   CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
   KEYSTORE_PASSWORD=changeit
   
   BROKER_DNS=<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 사용
<a name="rabbitmq-mtls-tutorial"></a>

이 자습서에서는 프라이빗 인증 기관을 사용하여 AMQP 클라이언트 연결 및 RabbitMQ 관리 인터페이스에 대해 상호 TLS(mTLS)를 구성하는 방법을 설명합니다.

**참고**  
mTLS에 대한 프라이빗 인증 기관 사용은 RabbitMQ용 Amazon MQ 버전 4 이상에서만 사용할 수 있습니다. RabbitMQ 

**Topics**
+ [mTLS를 구성하기 위한 사전 조건](#rabbitmq-mtls-tutorial-prerequisites)
+ [AWS CLI를 사용하여 RabbitMQ에서 mTLS 구성](#rabbitmq-mtls-tutorial-configure-cli)

## mTLS를 구성하기 위한 사전 조건
<a name="rabbitmq-mtls-tutorial-prerequisites"></a>

와의 RabbitMQ mTLS 통합을 위한 Amazon MQ용 CDK 스택을 배포하여이 자습서에 필요한 AWS 리소스를 설정할 수 있습니다. [AWS Amazon MQ RabbitMQ ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/)

이 CDK 스택은 인증 기관, 클라이언트 인증서 및 IAM 역할을 포함하여 필요한 모든 AWS 리소스를 자동으로 생성합니다. 스택에서 생성한 리소스의 전체 목록은 패키지 README를 참조하세요.

CDK 스택을 사용하는 대신 리소스를 수동으로 설정하는 경우 RabbitMQ용 Amazon MQ 브로커에서 mTLS를 구성하기 전에 동등한 인프라가 있는지 확인합니다.

### Amazon MQ를 설정하기 위한 사전 조건
<a name="rabbitmq-mtls-tutorial-prerequisite-cli"></a>

AWS CLI 버전 >= 2.28.23: 브로커 생성 중에 사용자 이름과 암호를 선택적으로 추가할 수 있습니다.

## AWS CLI를 사용하여 RabbitMQ에서 mTLS 구성
<a name="rabbitmq-mtls-tutorial-configure-cli"></a>

이 절차에서는 AWS CLI를 사용하여 필요한 리소스를 생성하고 구성합니다. 다음 절차에서는 configurationID 및 개정, `<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>`와 같은 자리 표시자 값을 실제 값으로 바꿔야 `<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. 다음 예제와 같이 라는 구성 파일을 생성`rabbitmq.conf`하여 AMQP 및 관리 엔드포인트에 대한 mTLS를 구성합니다. 템플릿의 모든 자리 표시자 값(로 표시됨`${...}`)을 배포된 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 "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>" \
     --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": "<c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca>","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 "<b-2a1b5133-a10c-49d2-879b-8c176c34cf73>"
   ```

   이 명령은 다음 예제와 유사한 응답을 반환합니다. 다음 응답은 `describe-broker` 명령이 반환하는 전체 출력의 약식 버전입니다.

   ```
   {
       "AuthenticationStrategy": "simple",
       ...,
       "BrokerState": "RUNNING",
       ...
   }
   ```

1. 다음 스크립트를 사용하여 `mtls.sh` mTLS 인증을 확인합니다.

   이 bash 스크립트를 사용하여 RabbitMQ용 Amazon MQ 브로커에 대한 연결을 테스트합니다. 이 스크립트는 클라이언트 인증서를 사용하여 연결을 인증하고 연결이 제대로 구성되었는지 확인합니다. 성공적으로 구성되면 브로커가 메시지를 게시하고 소비하는 것을 볼 수 있습니다.

   `ACCESS_REFUSED` 오류가 발생하면 브로커에 대한 CloudWatch 로그를 사용하여 구성 설정 문제를 해결할 수 있습니다. Amazon MQ 콘솔에서 브로커의 CloudWatch 로그 그룹에 대한 링크를 찾을 수 있습니다.

   이 스크립트에서는 다음 값을 제공해야 합니다.
   + `USERNAME` 및 `PASSWORD`: 브로커로 생성한 RabbitMQ 사용자 자격 증명입니다.
   + `CLIENT_KEYSTORE`: 클라이언트 키 스토어 파일(PKCS12 형식)의 경로입니다. 필수 CDK 스택을 사용한 경우 기본 경로는 입니다`$(pwd)/certs/client-keystore.p12`.
   + `KEYSTORE_PASSWORD`: 클라이언트 키 스토어의 암호입니다. 필수 CDK 스택을 사용한 경우 기본 암호는 입니다`changeit`.
   + `BROKER_DNS`: Amazon MQ 콘솔의 브로커 세부 정보 페이지에 있는 **연결**에서이 값을 찾을 수 있습니다.

   ```
   #! /bin/bash
   set -e
   
   # Client information
   ## FIXME: Update this value with the client ID and secret of your confidential application client
   USERNAME=<testuser>
   PASSWORD=<testpassword>
   CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
   KEYSTORE_PASSWORD=changeit
   
   BROKER_DNS=<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 애플리케이션 연결
<a name="rabbitmq-tutorial-jms"></a>

 이 자습서에서는 RabbitMQ Amazon MQ RabbitMQ 브로커에 연결하는 방법을 보여줍니다. 메시지를 보낼 생산자와 RabbitMQ 대기열에서 메시지를 받을 소비자를 생성하는 방법을 알아봅니다.

 시작하기 전에 Maven 프로젝트에 적절한 RabbitMQ JMS 종속성을 추가합니다.

 JMS 1.1 및 2.0의 경우: 

```
<dependencies>

  <dependency>
    <groupId>com.rabbitmq.jms</groupId>
    <artifactId>rabbitmq-jms</artifactId>
    <version>2.12.0</version>
  </dependency>

</dependencies>
```

 JMS 3.1의 경우: 

```
<dependencies>

  <dependency>
    <groupId>com.rabbitmq.jms</groupId>
    <artifactId>rabbitmq-jms</artifactId>
    <version>3.5.0</version>
  </dependency>

</dependencies>
```

## 생산자 생성
<a name="rabbitmq-tutorial-jms-producer"></a>

 다음 코드 예제에서는 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);
```

## 소비자 생성
<a name="rabbitmq-tutorial-jms-consumer"></a>

 다음 코드 예제에서는 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();
```