> For the complete documentation index, see [llms.txt](https://docs.eximee.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/konsumenci-rabbitmq/konfiguracja.md).

# Konfiguracja

Ta strona opisuje konfigurację, którą przygotowują administratorzy, żeby [konsument RabbitMQ](https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/konsumenci-rabbitmq.md) odbierał wiadomości. Wiadomości z kolejek odbiera aplikacja `lowcode-queue-consumer`. Dla każdej kolejki z jej konfiguracji rejestruje listenera, a każdą odebraną z tej kolejki wiadomość przekazuje do przypisanego do niej konsumenta.

Do konfiguracji potrzebujesz danych, które projektant procesu ustalił z administratorami i przesłał w zgłoszeniu ([przykład zgłoszenia](https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/konsumenci-rabbitmq.md#przyklad-zgloszenia)): nazwy kolejki, nazwy konsumenta, nazwy kolejki DLQ i nazwy połączenia.

## Przykład konfiguracji

Wszystkie zmienne ustawiasz w pliku `env.yaml` (ConfigMap) aplikacji `lowcode-queue-consumer`. Pełny przykład konfiguracji z jednym połączeniem i jedną kolejką:

```yaml
# Repozytorium artefaktów: z niego aplikacja pobiera skrypty konsumentów
EXIMEE_REPOSITORY_USER: '<uzytkownik>'
EXIMEE_REPOSITORY_PASSWORD: '<haslo>'

# Eximee BPMS: do niego skrypty wysyłają wiadomości wznawiające procesy
EXIMEE_ROUTER_ENGINE_USER: '<uzytkownik>'
EXIMEE_ROUTER_ENGINE_PASSWORD: '<haslo>'

# Dane brokera RabbitMQ, wspólne dla wszystkich połączeń
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_HOST: 'rabbitmq.bank.local'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_PORT: '5671'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_SSL_ENABLED: 'true'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_SSL_VALIDATE_SERVER_CERTIFICATE: 'true'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_SSL_VERIFY_HOSTNAME: 'true'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_VIRTUAL_HOST: 'eximee'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_USERNAME: '<uzytkownik>'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_PASSWORD: '<haslo>'

# Połączenie "integration": kolejka -> konsument oraz kolejka -> DLQ
SCRIPT_QUEUE_INTEGRATION_QUEUE_MAPPING: 'eximee_demo_integration=message_consumer_demo'
SCRIPT_QUEUE_INTEGRATION_QUEUE_DLQ_MAPPING: 'eximee_demo_integration=eximee_demo_integration.dlq'
```

Kolejne sekcje opisują, skąd wziąć wartości do tego przykładu, jak przygotować broker, a potem połączenia, segment `COMMON` i każdą zmienną.

## Dane ze zgłoszenia

| Dane ze zgłoszenia                          | Co z nimi zrobić                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Nazwa połączenia, na przykład `integration` | Projektant procesu może zaproponować nazwę. Potwierdź ją albo wskaż istniejące połączenie, do którego dopiszesz mapowanie kolejki. Użyj jej wielkimi literami w nazwach zmiennych, na przykład `SCRIPT_QUEUE_INTEGRATION_QUEUE_MAPPING`. Nazwa nie może zawierać znaku `_` (sekcja [Nazwa połączenia](#nazwa-polaczenia)). |
| Kolejka                                     | Załóż kolejkę na brokerze (sekcja [Przygotowanie brokera](#przygotowanie-brokera)) i wpisz ją po lewej stronie `QUEUE_MAPPING`.                                                                                                                                                                                            |
| Nazwa konsumenta                            | Wpisz ją po prawej stronie `QUEUE_MAPPING`, na przykład `eximee_demo_integration=message_consumer_demo`. Nazwa musi być identyczna z nazwą konsumenta w Eximee Designer.                                                                                                                                                   |
| Kolejka DLQ                                 | Załóż kolejkę na brokerze i wpisz ją w `QUEUE_DLQ_MAPPING`, na przykład `eximee_demo_integration=eximee_demo_integration.dlq` (sekcja [Obsługa błędów: DLX i DLQ](#obsluga-bledow-dlx-i-dlq)).                                                                                                                             |

## Przygotowanie brokera

Platforma nie tworzy kolejek, exchange'y ani bindingów na brokerze. Przed zmianą konfiguracji Eximee administrator RabbitMQ zakłada na brokerze kolejkę, z której konsument ma czytać, oraz kolejkę DLQ. Sposób przygotowania DLQ opisuje sekcja [Obsługa błędów: DLX i DLQ](#obsluga-bledow-dlx-i-dlq).

{% hint style="danger" %}
Kolejka wskazana w mapowaniu musi istnieć na brokerze przed uruchomieniem aplikacji. To samo dotyczy kolejki wskazanej w mapowaniu DLQ. Jeżeli którejś brakuje, aplikacja `lowcode-queue-consumer` nie wystartuje.
{% endhint %}

## Połączenia i segment `COMMON`

Konfiguracja składa się z nazwanych połączeń. Połączenie to dane brokera (adres, virtual host, użytkownik, TLS) oraz mapowanie kolejek na konsumentów. Dla każdego połączenia aplikacja otwiera osobne połączenie z brokerem.

`COMMON` nie jest połączeniem. To zestaw wartości domyślnych, które aplikacja dołącza do każdego połączenia. Połączenie może nadpisać dowolną z nich własną wartością. Konfiguracja, która zawiera tylko zmienne `COMMON`, nie tworzy żadnego połączenia i nie odbiera wiadomości.

### Typowa konfiguracja: jeden broker

Jeśli wszystkie kolejki leżą na jednym brokerze, w jednym virtual hoście. Wtedy:

* dane brokera ustaw raz, w zmiennych `SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_*`,
* utwórz jedno połączenie, na przykład `INTEGRATION`, i ustaw w nim tylko mapowanie kolejek,
* każdą kolejną kolejkę dopisz do mapowania tego samego połączenia, po przecinku.

Tak wygląda [przykład konfiguracji](#przyklad-konfiguracji) na początku strony. Z dwiema kolejkami mapowanie połączenia `INTEGRATION` ma postać:

```yaml
SCRIPT_QUEUE_INTEGRATION_QUEUE_MAPPING: 'eximee_demo_integration=message_consumer_demo,inna_kolejka=inny_konsument'
SCRIPT_QUEUE_INTEGRATION_QUEUE_DLQ_MAPPING: 'eximee_demo_integration=eximee_demo_integration.dlq,inna_kolejka=inna_kolejka.dlq'
```

Jeden konsument może być przypisany do kilku kolejek. Jedna instancja aplikacji przetwarza wiadomości z danej kolejki pojedynczo, jedną po drugiej.

### Kilka połączeń: inny broker, virtual host albo użytkownik

Dodaj kolejne połączenie, gdy część kolejek leży na innym brokerze, w innym virtual hoście albo wymaga innego użytkownika. W nowym połączeniu ustaw tylko te dane, które różnią się od `COMMON`, oraz jego własne mapowanie.

Przykład: kolejki partnera leżą na tym samym brokerze, ale w virtual hoście `partner`. Połączenie `PARTNER` nadpisuje virtual host, a adres, port, TLS i dane logowania bierze z `COMMON`:

```yaml
SCRIPT_QUEUE_PARTNER_CONSUMER_CLIENT_VIRTUAL_HOST: 'partner'
SCRIPT_QUEUE_PARTNER_QUEUE_MAPPING: 'kolejka_partnera=konsument_partnera'
```

{% hint style="warning" %}
Nie ustawiaj `QUEUE_MAPPING` ani `QUEUE_DLQ_MAPPING` w segmencie `COMMON`. Mapowanie z `COMMON` obowiązuje w każdym połączeniu, więc każde połączenie szukałoby tych samych kolejek na swoim brokerze.
{% endhint %}

### Nazwa połączenia

Nazwa połączenia to fragment nazwy zmiennej pomiędzy `SCRIPT_QUEUE_` a `_QUEUE_MAPPING`. W przykładzie `SCRIPT_QUEUE_INTEGRATION_QUEUE_MAPPING` połączenie nazywa się `INTEGRATION`, a w logach aplikacji występuje jako `integration`.

* Nazwa połączenia to jedno słowo, bez znaku `_`. Aplikacja traktuje znak `_` w nazwie zmiennej jako separator. Ze zmiennej `SCRIPT_QUEUE_BANK_CENTRALNY_QUEUE_MAPPING` nie powstanie połączenie `BANK_CENTRALNY`, a listener nie zostanie zarejestrowany. Użyj na przykład `BANKCENTRALNY`.
* Nazwa `COMMON` jest zarezerwowana dla wartości domyślnych i nie tworzy połączenia.

## Zmienne aplikacji `lowcode-queue-consumer`

### Repozytorium artefaktów i Eximee BPMS

| Zmienna                         | Opis                                       | Wartość domyślna                               |
| ------------------------------- | ------------------------------------------ | ---------------------------------------------- |
| `EXIMEE_REPOSITORY_URL`         | Adres repozytorium artefaktów.             | `http://eximee-repository:8080`                |
| `EXIMEE_REPOSITORY_USER`        | Użytkownik repozytorium artefaktów.        | Brak (wymagane)                                |
| `EXIMEE_REPOSITORY_PASSWORD`    | Hasło użytkownika repozytorium artefaktów. | Brak (wymagane)                                |
| `EXIMEE_ROUTER_ENGINE_URL`      | Adres API Eximee BPMS.                     | `http://eximee-router-engine:8080/engine-rest` |
| `EXIMEE_ROUTER_ENGINE_USER`     | Użytkownik Eximee BPMS.                    | Brak (wymagane)                                |
| `EXIMEE_ROUTER_ENGINE_PASSWORD` | Hasło użytkownika Eximee BPMS.             | Brak (wymagane)                                |

### Połączenie z brokerem

Zamiast `<POLACZENIE>` wpisz `COMMON` (wartość dla wszystkich połączeń) albo nazwę połączenia (wartość tylko dla niego). Wartość domyślna obowiązuje, gdy zmiennej nie ustawiono ani dla połączenia, ani w `COMMON`.

| Zmienna                                                                     | Opis                                                                                                                    | Wartość domyślna                                     |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_HOST`                            | Adres brokera.                                                                                                          | `localhost`                                          |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_PORT`                            | Port brokera.                                                                                                           | `5671` przy włączonym TLS, w przeciwnym razie `5672` |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_VIRTUAL_HOST`                    | Virtual host RabbitMQ.                                                                                                  | `/`                                                  |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_USERNAME`                        | Użytkownik brokera.                                                                                                     | `guest`                                              |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_PASSWORD`                        | Hasło użytkownika brokera.                                                                                              | `guest`                                              |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_SSL_ENABLED`                     | `true` włącza szyfrowanie połączenia (TLS).                                                                             | `false`                                              |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_SSL_VALIDATE_SERVER_CERTIFICATE` | `true` włącza weryfikację certyfikatu brokera. Opis w sekcji [Połączenie szyfrowane (TLS)](#polaczenie-szyfrowane-tls). | `false`                                              |
| `SCRIPT_QUEUE_<POLACZENIE>_CONSUMER_CLIENT_SSL_VERIFY_HOSTNAME`             | `true` włącza sprawdzanie, czy certyfikat brokera został wystawiony dla jego adresu.                                    | `false`                                              |

{% hint style="info" %}
Zmienne odbioru mają w nazwie `CONSUMER`. Zmienne wysyłki ze skryptów, z `PRODUCER` w nazwie, ustawia się osobno w aplikacjach, które wykonują skrypty (strona [Konfiguracja wysyłki do RabbitMQ](https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/lowcode-do-rabbitmq/konfiguracja.md)).
{% endhint %}

### Mapowanie kolejek

Zamiast `<POLACZENIE>` wpisz nazwę połączenia. Nie ustawiaj tych zmiennych w `COMMON`.

| Zmienna                                       | Opis                                                                                                                                                                                                                                                               | Wartość domyślna                                          |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------- |
| `SCRIPT_QUEUE_<POLACZENIE>_QUEUE_MAPPING`     | Mapowanie kolejki na konsumenta w postaci `<nazwa-kolejki>=<nazwa-konsumenta>`. Kilka par rozdziel przecinkami.                                                                                                                                                    | Brak: połączenie bez mapowania nie odbiera wiadomości     |
| `SCRIPT_QUEUE_<POLACZENIE>_QUEUE_DLQ_MAPPING` | Mapowanie kolejki na kolejkę DLQ w postaci `<nazwa-kolejki>=<nazwa-kolejki-dlq>`. Kilka par rozdziel przecinkami. Po lewej stronie może stać tylko kolejka, która występuje w `QUEUE_MAPPING` tego samego połączenia. W przeciwnym razie aplikacja nie wystartuje. | Brak: o losie odrzuconych wiadomości decyduje DLX kolejki |

### Cache konsumentów

| Zmienna                                    | Opis                                                                                    | Wartość domyślna |
| ------------------------------------------ | --------------------------------------------------------------------------------------- | ---------------- |
| `LOWCODE_QUEUE_CONSUMER_FETCH_CACHE_TTL`   | Jak długo aplikacja przechowuje konsumenta pobranego z repozytorium, na przykład `30s`. | `1s`             |
| `LOWCODE_QUEUE_CONSUMER_COMPILE_CACHE_TTL` | Jak długo aplikacja przechowuje skompilowany skrypt konsumenta, na przykład `30s`.      | `1s`             |

Zmiana konsumenta zapisana w Eximee Designer zaczyna obowiązywać po upływie tych TTL. Cache możesz też wyczyścić od razu:

```bash
curl -X POST https://DOCKER_HOST:PORT/lowcode-queue-consumer/cache/invalidate
```

{% hint style="warning" %}
Aplikacja ignoruje bez ostrzeżenia zmienną z literówką w nazwie, na przykład `SSL_ENABLE` zamiast `SSL_ENABLED`. Po każdej zmianie konfiguracji sprawdź w logach, czy aplikacja zarejestrowała listenery na właściwych kolejkach (opis w sekcji [Sprawdzenie działania](#sprawdzenie-dzialania)).
{% endhint %}

## Połączenie szyfrowane (TLS)

Do połączenia szyfrowanego z weryfikacją certyfikatu brokera ustaw wszystkie trzy zmienne:

```yaml
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_SSL_ENABLED: 'true'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_SSL_VALIDATE_SERVER_CERTIFICATE: 'true'
SCRIPT_QUEUE_COMMON_CONSUMER_CLIENT_SSL_VERIFY_HOSTNAME: 'true'
```

Certyfikat brokera jest wtedy sprawdzany domyślnym truststore Javy w obrazie aplikacji. Certyfikat samopodpisany albo wystawiony przez wewnętrzne CA zostanie odrzucony, jeżeli tego CA nie ma w truststore.

{% hint style="danger" %}
Samo `SSL_ENABLED: 'true'` szyfruje połączenie, ale nie weryfikuje certyfikatu brokera: aplikacja zaakceptuje dowolny certyfikat. Na środowiskach produkcyjnych zawsze ustawiaj także `SSL_VALIDATE_SERVER_CERTIFICATE` i `SSL_VERIFY_HOSTNAME`.
{% endhint %}

## Obsługa błędów: DLX i DLQ

Wiadomość, której konsument nie przetworzył (skrypt zgłosił wyjątek), jest odrzucana i nie wraca na kolejkę. Dalszą drogę takiej wiadomości wyznacza jeden z dwóch wariantów opisanych niżej. Wybierz jeden wariant dla każdej kolejki.

* **DLQ** (Dead Letter Queue) to kolejka, w której odrzucone wiadomości czekają na analizę.
* **DLX** (Dead Letter Exchange) to exchange, do którego broker przekazuje wiadomości odrzucone z kolejki.

{% hint style="danger" %}
Jeżeli dla kolejki nie skonfigurowano żadnego z wariantów, odrzucone wiadomości są tracone. Platforma nie zapisuje ich w żadnym innym miejscu, więc nie będzie można ich odtworzyć ani przeanalizować.
{% endhint %}

### Wariant A: DLQ wskazana w konfiguracji Eximee (zalecany)

Administrator RabbitMQ zakłada zwykłą kolejkę DLQ, na przykład `eximee_demo_integration.dlq`. Administrator Eximee wskazuje ją w zmiennej `QUEUE_DLQ_MAPPING`:

```yaml
SCRIPT_QUEUE_INTEGRATION_QUEUE_DLQ_MAPPING: 'eximee_demo_integration=eximee_demo_integration.dlq'
```

Aplikacja publikuje nieprzetworzoną wiadomość na tę kolejkę z niezmienioną treścią i nagłówkami. Dodaje trzy nagłówki pomocne w analizie:

| Nagłówek                | Zawartość                                                                                                                                                                                                                                              |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `x-original-exchange`   | Exchange, z którego wiadomość trafiła na kolejkę. Pusty przy exchange domyślnym.                                                                                                                                                                       |
| `x-original-routingKey` | Routing key, z którym wiadomość trafiła na kolejkę.                                                                                                                                                                                                    |
| `x-exception-class`     | Rodzaj błędu, na przykład `com.consdata.eximee.script.runtime.api.ScriptRuntimeException`, gdy skrypt zgłosił wyjątek, albo `com.consdata.eximee.lowcode.core.exception.ScriptCodeNotFoundException`, gdy nie istnieje konsument o nazwie z mapowania. |

Treść błędu nie trafia do wiadomości. Szczegóły błędu znajdziesz w logach aplikacji `lowcode-queue-consumer`.

Wariant A ma pierwszeństwo: dla kolejki z wpisem w `QUEUE_DLQ_MAPPING` aplikacja nie korzysta z DLX ustawionego na kolejce.

### Wariant B: DLX ustawiony na kolejce przez administratora RabbitMQ

Administrator RabbitMQ ustawia na kolejce argumenty, które wskazują DLX, oraz wiąże z tym exchange'em kolejkę DLQ. Przykład dla kolejki `eximee_demo_integration`:

```
Kolejka eximee_demo_integration, argumenty:
  x-dead-letter-exchange:    eximee_demo_integration.dlx
  x-dead-letter-routing-key: eximee_demo_integration.dlq

Exchange eximee_demo_integration.dlx, typ direct

Kolejka eximee_demo_integration.dlq,
  binding z exchange eximee_demo_integration.dlx
  z routing key eximee_demo_integration.dlq
```

W tym wariancie w konfiguracji Eximee nie ustawiasz `QUEUE_DLQ_MAPPING`. Broker dodaje do odrzuconej wiadomości nagłówek `x-death` z nazwą kolejki źródłowej i przyczyną `rejected`.

### Wiadomości w DLQ

Wiadomość z DLQ nie jest automatycznie przetwarzana ponownie. Administrator powinien przeanalizować przyczynę błędu i zdecydować o dalszych działaniach, na przykład po poprawieniu skryptu przenieść wiadomość z powrotem na kolejkę źródłową narzędziami RabbitMQ.

## Wdrożenie zmian w konfiguracji

Aplikacja czyta konfigurację przy starcie. Po zmianie `env.yaml`, na przykład po dodaniu nowej kolejki, uruchom aplikację `lowcode-queue-consumer` ponownie.

## Sprawdzenie działania

1. Po starcie aplikacji `lowcode-queue-consumer` znajdź w jej logach wpis dla każdej zmapowanej kolejki:

   ```
   Registering queue listener. [connectionId=integration, queue=eximee_demo_integration, script=message_consumer_demo, deadLetterQueue=eximee_demo_integration.dlq]
   ```

   Wartość `deadLetterQueue=dead-letter exchange of the queue` oznacza, że dla kolejki nie ustawiono `QUEUE_DLQ_MAPPING` i o losie odrzuconych wiadomości decyduje DLX kolejki (wariant B).
2. Sprawdź stan połączeń z brokerem w monitoringu (np. Grafana).
3. W panelu RabbitMQ Management otwórz kolejkę, rozwiń sekcję **Publish message** i opublikuj wiadomość testową w uzgodnionym formacie, z identyfikatorem instancji procesu, który czeka na kroku oczekiwania. Format wiadomości projektant procesu uzgadnia z zespołem systemu zewnętrznego.
4. W logach aplikacji znajdź wpis o odebraniu wiadomości:

   ```
   Message received [connectionId=integration, stream=eximee_demo_integration, script=message_consumer_demo, ...]
   ```

   a po nim wpisy z `Logger` w skrypcie konsumenta.
5. Sprawdź, czy proces przeszedł dalej i czy kolejka DLQ jest pusta.

## Rozwiązywanie problemów

| Objaw                                                                                                       | Możliwa przyczyna                                                                                                                                                                                                                                       | Rozwiązanie                                                                                                                    |
| ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Aplikacja `lowcode-queue-consumer` nie startuje, w logu `Queue <nazwa> does not exist on the broker`        | Kolejka z `QUEUE_MAPPING` albo `QUEUE_DLQ_MAPPING` nie istnieje na brokerze. Log wskazuje kolejkę i zmienną, w której ją wpisano.                                                                                                                       | Załóż kolejkę na brokerze albo popraw nazwę w mapowaniu.                                                                       |
| Aplikacja nie startuje, w logu `is not mapped to a script`                                                  | `QUEUE_DLQ_MAPPING` zawiera kolejkę, której nie ma w `QUEUE_MAPPING` tego samego połączenia.                                                                                                                                                            | Dodaj kolejkę do `QUEUE_MAPPING` albo usuń ją z `QUEUE_DLQ_MAPPING`.                                                           |
| Wiadomości zostają na kolejce, w logu brak `Registering queue listener` dla tej kolejki                     | Brak mapowania, literówka w nazwie zmiennej albo znak `_` w nazwie połączenia.                                                                                                                                                                          | Popraw nazwę zmiennej zgodnie z sekcją [Nazwa połączenia](#nazwa-polaczenia) i uruchom aplikację ponownie.                     |
| Aplikacja nie startuje, w logu `AmqpConnectException`, `AmqpAuthenticationException` albo `AmqpIOException` | Aplikacja łączy się z brokerem przy starcie. `AmqpConnectException`: broker jest niedostępny albo adres lub port są błędne. `AmqpAuthenticationException`: błędne dane logowania. `AmqpIOException` z `vhost ... not found`: virtual host nie istnieje. | Sprawdź zmienne `CONSUMER_CLIENT_*` i dostępność brokera z aplikacji. Przy porcie `5671` sprawdź, czy ustawiono `SSL_ENABLED`. |
| Każda wiadomość trafia do DLQ z `x-exception-class` = `...ScriptCodeNotFoundException`                      | Nazwa konsumenta w `QUEUE_MAPPING` różni się od nazwy w Eximee Designer.                                                                                                                                                                                | Popraw nazwę w mapowaniu.                                                                                                      |
| Wiadomość z błędem znika i nie ma jej w żadnej kolejce                                                      | Dla kolejki nie skonfigurowano DLQ ani DLX.                                                                                                                                                                                                             | Skonfiguruj DLQ według sekcji [Obsługa błędów: DLX i DLQ](#obsluga-bledow-dlx-i-dlq).                                          |

## Powiązane strony

* [Konsumenci RabbitMQ](https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/konsumenci-rabbitmq.md) — przygotowanie procesu i pisanie konsumenta.
* [Lowcode do RabbitMQ](https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/lowcode-do-rabbitmq.md) — wysyłka wiadomości na kolejkę ze skryptów i zadań skryptowych.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.eximee.com/eksploatacja-aplikacji/obsluga-zdarzen/konsumenci-rabbitmq/konfiguracja.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
