Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

feat(backend): spawn the notifications service + basic test (#9464)

Nicholas Tindle15275e2ce105
diff --git a/.github/workflows/platform-backend-ci.yml b/.github/workflows/platform-backend-ci.yml
index cdab6ed300..938cb7b6f9 100644
--- a/.github/workflows/platform-backend-ci.yml
+++ b/.github/workflows/platform-backend-ci.yml
@@ -42,6 +42,14 @@ jobs:
REDIS_PASSWORD: testpassword
ports:
- 6379:6379
+ rabbitmq:
+ image: rabbitmq:3.12-management
+ ports:
+ - 5672:5672
+ - 15672:15672
+ env:
+ RABBITMQ_DEFAULT_USER: ${{ env.RABBITMQ_DEFAULT_USER }}
+ RABBITMQ_DEFAULT_PASS: ${{ env.RABBITMQ_DEFAULT_PASS }}
steps:
- name: Checkout repository
@@ -139,6 +147,13 @@ jobs:
RUN_ENV: local
PORT: 8080
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+ # We know these are here, don't report this as a security vulnerability
+ # This is used as the default credential for the entire system's RabbitMQ instance
+ # If you want to replace this, you can do so by making our entire system generate
+ # new credentials for each local user and update the environment variables in
+ # the backend service, docker composes, and examples
+ RABBITMQ_DEFAULT_USER: 'rabbitmq_user_default'
+ RABBITMQ_DEFAULT_PASS: 'k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7'
# - name: Upload coverage reports to Codecov
# uses: codecov/codecov-action@v4
diff --git a/.github/workflows/platform-frontend-ci.yml b/.github/workflows/platform-frontend-ci.yml
index 8fc27fde56..f134687525 100644
--- a/.github/workflows/platform-frontend-ci.yml
+++ b/.github/workflows/platform-frontend-ci.yml
@@ -77,8 +77,8 @@ jobs:
- name: Free Disk Space (Ubuntu)
uses: jlumbroso/free-disk-space@main
with:
- large-packages: false # slow
- docker-images: false # limited benefit
+ large-packages: false # slow
+ docker-images: false # limited benefit
- name: Copy default supabase .env
run: |
@@ -104,11 +104,12 @@ jobs:
run: yarn playwright install --with-deps ${{ matrix.browser }}
- name: Run tests
+ timeout-minutes: 20
run: |
yarn test --project=${{ matrix.browser }}
- - name: Print Docker Compose logs in debug mode
- if: runner.debug
+ - name: Print Final Docker Compose logs
+ if: always()
run: |
docker compose -f ../docker-compose.yml logs
diff --git a/autogpt_platform/backend/backend/app.py b/autogpt_platform/backend/backend/app.py
index 5d77ea9632..eb0c6370c6 100644
--- a/autogpt_platform/backend/backend/app.py
+++ b/autogpt_platform/backend/backend/app.py
@@ -25,6 +25,7 @@ def main(**kwargs):
"""
from backend.executor import DatabaseManager, ExecutionManager, ExecutionScheduler
+ from backend.notifications import NotificationManager
from backend.server.rest_api import AgentServer
from backend.server.ws_api import WebsocketServer
@@ -32,6 +33,7 @@ def main(**kwargs):
DatabaseManager(),
ExecutionManager(),
ExecutionScheduler(),
+ NotificationManager(),
WebsocketServer(),
AgentServer(),
**kwargs,
diff --git a/autogpt_platform/backend/backend/data/graph.py b/autogpt_platform/backend/backend/data/graph.py
index 31bd1dee4b..6078d21762 100644
--- a/autogpt_platform/backend/backend/data/graph.py
+++ b/autogpt_platform/backend/backend/data/graph.py
@@ -70,11 +70,9 @@ class NodeModel(Node):
@staticmethod
def from_db(node: AgentNode):
- if not node.AgentBlock:
- raise ValueError(f"Invalid node {node.id}, invalid AgentBlock.")
obj = NodeModel(
id=node.id,
- block_id=node.AgentBlock.id,
+ block_id=node.agentBlockId,
input_default=type.convert(node.constantInput, dict[str, Any]),
metadata=type.convert(node.metadata, dict[str, Any]),
graph_id=node.agentGraphId,
diff --git a/autogpt_platform/backend/backend/executor/manager.py b/autogpt_platform/backend/backend/executor/manager.py
index 5f1b8e62c0..513e384b08 100644
--- a/autogpt_platform/backend/backend/executor/manager.py
+++ b/autogpt_platform/backend/backend/executor/manager.py
@@ -12,8 +12,15 @@ from typing import TYPE_CHECKING, Any, Generator, Optional, TypeVar, cast
from redis.lock import Lock as RedisLock
+from backend.data.notifications import (
+ AgentRunData,
+ NotificationEventDTO,
+ NotificationType,
+)
+
if TYPE_CHECKING:
from backend.executor import DatabaseManager
+ from backend.notifications.notifications import NotificationManager
from autogpt_libs.utils.cache import thread_cached
@@ -108,6 +115,7 @@ ExecutionStream = Generator[NodeExecutionEntry, None, None]
def execute_node(
db_client: "DatabaseManager",
creds_manager: IntegrationCredentialsManager,
+ notification_service: "NotificationManager",
data: NodeExecutionEntry,
execution_stats: dict[str, Any] | None = None,
) -> ExecutionStream:
@@ -196,7 +204,7 @@ def execute_node(
# Charge the user for the execution before running the block.
# TODO: We assume the block is executed within 0 seconds.
# This is fine because for now, there is no block that is charged by time.
- db_client.spend_credits(data, input_size + output_size, 0)
+ cost = db_client.spend_credits(data, input_size + output_size, 0)
for output_name, output_data in node_block.execute(
input_data, **extra_exec_kwargs
@@ -216,7 +224,22 @@ def execute_node(
):
yield execution
+ # Update execution status and spend credits
update_execution(ExecutionStatus.COMPLETED)
+ event = NotificationEventDTO(
+ user_id=user_id,
+ type=NotificationType.AGENT_RUN,
+ data=AgentRunData(
+ agent_name=node_block.name,
+ credits_used=cost,
+ execution_time=0,
+ graph_id=graph_id,
+ node_count=1,
+ ).model_dump(),
+ )
+
+ logger.info(f"Sending notification for {event}")
+ notification_service.queue_notification(event)
except Exception as e:
error_msg = str(e)
@@ -480,6 +503,7 @@ class Executor:
cls.pid = os.getpid()
cls.db_client = get_db_client()
cls.creds_manager = IntegrationCredentialsManager()
+ cls.notification_service = get_notification_service()
# Set up shutdown handlers
cls.shutdown_lock = threading.Lock()
@@ -554,7 +578,11 @@ class Executor:
try:
log_metadata.info(f"Start node execution {node_exec.node_exec_id}")
for execution in execute_node(
- cls.db_client, cls.creds_manager, node_exec, stats
+ db_client=cls.db_client,
+ creds_manager=cls.creds_manager,
+ notification_service=cls.notification_service,
+ data=node_exec,
+ execution_stats=stats,
):
q.add(execution)
log_metadata.info(f"Finished node execution {node_exec.node_exec_id}")
@@ -968,6 +996,13 @@ def get_db_client() -> "DatabaseManager":
return get_service_client(DatabaseManager)
+@thread_cached
+def get_notification_service() -> "NotificationManager":
+ from backend.notifications import NotificationManager
+
+ return get_service_client(NotificationManager)
+
+
@contextmanager
def synchronized(key: str, timeout: int = 60):
lock: RedisLock = redis.get_redis().lock(f"lock:{key}", timeout=timeout)
diff --git a/autogpt_platform/backend/backend/notifications/__init__.py b/autogpt_platform/backend/backend/notifications/__init__.py
new file mode 100644
index 0000000000..e791d49b3c
--- /dev/null
+++ b/autogpt_platform/backend/backend/notifications/__init__.py
@@ -0,0 +1,5 @@
+from .notifications import NotificationManager
+
+__all__ = [
+ "NotificationManager",
+]
diff --git a/autogpt_platform/backend/backend/notifications/notifications.py b/autogpt_platform/backend/backend/notifications/notifications.py
new file mode 100644
index 0000000000..d4e591ac8b
--- /dev/null
+++ b/autogpt_platform/backend/backend/notifications/notifications.py
@@ -0,0 +1,213 @@
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from aio_pika.exceptions import QueueEmpty
+from autogpt_libs.utils.cache import thread_cached
+
+from backend.data.notifications import (
+ BatchingStrategy,
+ NotificationEventDTO,
+ NotificationEventModel,
+ NotificationResult,
+ get_data_type,
+)
+from backend.data.rabbitmq import Exchange, ExchangeType, Queue, RabbitMQConfig
+from backend.executor.database import DatabaseManager
+from backend.util.service import AppService, expose, get_service_client
+from backend.util.settings import Settings
+
+if TYPE_CHECKING:
+ from backend.executor import DatabaseManager
+
+logger = logging.getLogger(__name__)
+settings = Settings()
+
+
+def create_notification_config() -> RabbitMQConfig:
+ """Create RabbitMQ configuration for notifications"""
+ notification_exchange = Exchange(name="notifications", type=ExchangeType.TOPIC)
+
+ summary_exchange = Exchange(name="summaries", type=ExchangeType.TOPIC)
+
+ dead_letter_exchange = Exchange(name="dead_letter", type=ExchangeType.DIRECT)
+ delay_exchange = Exchange(name="delay", type=ExchangeType.DIRECT)
+
+ queues = [
+ # Main notification queues
+ Queue(
+ name="immediate_notifications",
+ exchange=notification_exchange,
+ routing_key="notification.immediate.#",
+ arguments={
+ "x-dead-letter-exchange": dead_letter_exchange.name,
+ "x-dead-letter-routing-key": "failed.immediate",
+ },
+ ),
+ Queue(
+ name="backoff_notifications",
+ exchange=notification_exchange,
+ routing_key="notification.backoff.#",
+ arguments={
+ "x-dead-letter-exchange": dead_letter_exchange.name,
+ "x-dead-letter-routing-key": "failed.backoff",
+ },
+ ),
+ # Summary queues
+ Queue(
+ name="daily_summary_trigger",
+ exchange=summary_exchange,
+ routing_key="summary.daily",
+ arguments={"x-message-ttl": 86400000}, # 24 hours
+ ),
+ Queue(
+ name="weekly_summary_trigger",
+ exchange=summary_exchange,
+ routing_key="summary.weekly",
+ arguments={"x-message-ttl": 604800000}, # 7 days
+ ),
+ Queue(
+ name="monthly_summary_trigger",
+ exchange=summary_exchange,
+ routing_key="summary.monthly",
+ arguments={"x-message-ttl": 2592000000}, # 30 days
+ ),
+ # Failed notifications queue
+ Queue(
+ name="failed_notifications",
+ exchange=dead_letter_exchange,
+ routing_key="failed.#",
+ ),
+ ]
+
+ return RabbitMQConfig(
+ exchanges=[
+ notification_exchange,
+ # batch_exchange,
+ summary_exchange,
+ dead_letter_exchange,
+ delay_exchange,
+ ],
+ queues=queues,
+ )
+
+
+class NotificationManager(AppService):
+ """Service for handling notifications with batching support"""
+
+ def __init__(self):
+ super().__init__()
+ self.use_db = True
+ self.rabbitmq_config = create_notification_config()
+ self.running = True
+
+ @classmethod
+ def get_port(cls) -> int:
+ return settings.config.notification_service_port
+
+ def get_routing_key(self, event: NotificationEventModel) -> str:
+ """Get the appropriate routing key for an event"""
+ if event.strategy == BatchingStrategy.IMMEDIATE:
+ return f"notification.immediate.{event.type.value}"
+ elif event.strategy == BatchingStrategy.BACKOFF:
+ return f"notification.backoff.{event.type.value}"
+ return f"notification.{event.type.value}"
+
+ @expose
+ def queue_notification(self, event: NotificationEventDTO) -> NotificationResult:
+ """Queue a notification - exposed method for other services to call"""
+ try:
+ logger.info(f"Recieved Request to queue {event=}")
+ # Workaround for not being able to seralize generics over the expose bus
+ parsed_event = NotificationEventModel[
+ get_data_type(event.type)
+ ].model_validate(event.model_dump())
+ routing_key = self.get_routing_key(parsed_event)
+ message = parsed_event.model_dump_json()
+
+ logger.info(f"Recieved Request to queue {message=}")
+
+ exchange = "notifications"
+
+ # Publish to RabbitMQ
+ self.run_and_wait(
+ self.rabbit.publish_message(
+ routing_key=routing_key,
+ message=message,
+ exchange=next(
+ ex for ex in self.rabbit_config.exchanges if ex.name == exchange
+ ),
+ )
+ )
+
+ return NotificationResult(
+ success=True,
+ message=(f"Notification queued with routing key: {routing_key}"),
+ )
+
+ except Exception as e:
+ logger.error(f"Error queueing notification: {e}")
+ return NotificationResult(success=False, message=str(e))
+
+ async def _process_immediate(self, message: str) -> bool:
+ """Process a single notification immediately"""
+ try:
+ event = NotificationEventDTO.model_validate_json(message)
+ parsed_event = NotificationEventModel[
+ get_data_type(event.type)
+ ].model_validate_json(message)
+ # Implementation of actual notification sending would go here
+ # self.email_sender.send_templated(event.type, event.user_id, parsed_event)
+ logger.info(f"Processing notification: {parsed_event}")
+ return True
+ except Exception as e:
+ logger.error(f"Error processing notification: {e}")
+ return False
+
+ def run_service(self):
+ logger.info(f"[{self.service_name}] Started notification service")
+
+ # Set up queue consumers
+ channel = self.run_and_wait(self.rabbit.get_channel())
+
+ immediate_queue = self.run_and_wait(
+ channel.get_queue("immediate_notifications")
+ )
+
+ while self.running:
+ try:
+ # Process immediate notifications
+ try:
+ message = self.run_and_wait(immediate_queue.get())
+
+ if message:
+ success = self.run_and_wait(
+ self._process_immediate(message.body.decode())
+ )
+ if success:
+ self.run_and_wait(message.ack())
+ else:
+ self.run_and_wait(message.reject(requeue=True))
+ except QueueEmpty:
+ logger.debug("Immediate queue empty")
+
+ time.sleep(0.1)
+
+ except QueueEmpty as e:
+ logger.debug(f"Queue empty: {e}")
+ except Exception as e:
+ logger.error(f"Error in notification service loop: {e}")
+
+ def cleanup(self):
+ """Cleanup service resources"""
+ self.running = False
+ super().cleanup()
+
+ # ------- UTILITIES ------- #
+
+
+@thread_cached
+def get_db_client() -> "DatabaseManager":
+ from backend.executor import DatabaseManager
+
+ return get_service_client(DatabaseManager)
diff --git a/autogpt_platform/backend/backend/rest.py b/autogpt_platform/backend/backend/rest.py
index e0da452ca2..ecff860bc5 100644
--- a/autogpt_platform/backend/backend/rest.py
+++ b/autogpt_platform/backend/backend/rest.py
@@ -1,5 +1,6 @@
from backend.app import run_processes
from backend.executor import DatabaseManager, ExecutionScheduler
+from backend.notifications.notifications import NotificationManager
from backend.server.rest_api import AgentServer
@@ -8,6 +9,7 @@ def main():
Run all the processes required for the AutoGPT-server REST API.
"""
run_processes(
+ NotificationManager(),
DatabaseManager(),
ExecutionScheduler(),
AgentServer(),
diff --git a/autogpt_platform/backend/backend/util/service.py b/autogpt_platform/backend/backend/util/service.py
index ac7f437fff..96bdc74bc3 100644
--- a/autogpt_platform/backend/backend/util/service.py
+++ b/autogpt_platform/backend/backend/util/service.py
@@ -117,9 +117,8 @@ class AppService(AppProcess, ABC):
shared_event_loop: asyncio.AbstractEventLoop
use_db: bool = False
use_redis: bool = False
- use_async: bool = False
- use_rabbitmq: Optional[rabbitmq.RabbitMQConfig] = None
- rabbitmq_service: Optional[rabbitmq.SyncRabbitMQ | rabbitmq.AsyncRabbitMQ] = None
+ rabbitmq_config: Optional[rabbitmq.RabbitMQConfig] = None
+ rabbitmq_service: Optional[rabbitmq.AsyncRabbitMQ] = None
use_supabase: bool = False
def __init__(self):
@@ -135,7 +134,7 @@ class AppService(AppProcess, ABC):
return os.environ.get(f"{cls.service_name.upper()}_HOST", config.pyro_host)
@property
- def rabbit(self) -> rabbitmq.SyncRabbitMQ | rabbitmq.AsyncRabbitMQ:
+ def rabbit(self) -> rabbitmq.AsyncRabbitMQ:
"""Access the RabbitMQ service. Will raise if not configured."""
if not self.rabbitmq_service:
raise RuntimeError("RabbitMQ not configured for this service")
@@ -144,9 +143,9 @@ class AppService(AppProcess, ABC):
@property
def rabbit_config(self) -> rabbitmq.RabbitMQConfig:
"""Access the RabbitMQ config. Will raise if not configured."""
- if not self.use_rabbitmq:
+ if not self.rabbitmq_config:
raise RuntimeError("RabbitMQ not configured for this service")
- return self.use_rabbitmq
+ return self.rabbitmq_config
def run_service(self) -> None:
while True:
@@ -165,16 +164,14 @@ class AppService(AppProcess, ABC):
self.shared_event_loop.run_until_complete(db.connect())
if self.use_redis:
redis.connect()
- if self.use_rabbitmq:
+ if self.rabbitmq_config:
logger.info(f"[{self.__class__.__name__}] ⏳ Configuring RabbitMQ...")
- if self.use_async:
- self.rabbitmq_service = rabbitmq.AsyncRabbitMQ(self.use_rabbitmq)
- self.shared_event_loop.run_until_complete(
- self.rabbitmq_service.connect()
- )
- else:
- self.rabbitmq_service = rabbitmq.SyncRabbitMQ(self.use_rabbitmq)
- self.rabbitmq_service.connect()
+ # if self.use_async:
+ self.rabbitmq_service = rabbitmq.AsyncRabbitMQ(self.rabbitmq_config)
+ self.shared_event_loop.run_until_complete(self.rabbitmq_service.connect())
+ # else:
+ # self.rabbitmq_service = rabbitmq.SyncRabbitMQ(self.rabbitmq_config)
+ # self.rabbitmq_service.connect()
if self.use_supabase:
from supabase import create_client
@@ -203,7 +200,7 @@ class AppService(AppProcess, ABC):
if self.use_redis:
logger.info(f"[{self.__class__.__name__}] ⏳ Disconnecting Redis...")
redis.disconnect()
- if self.use_rabbitmq:
+ if self.rabbitmq_config:
logger.info(f"[{self.__class__.__name__}] ⏳ Disconnecting RabbitMQ...")
@conn_retry("Pyro", "Starting Pyro Service")
diff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.py
index c965572631..7eead6f735 100644
--- a/autogpt_platform/backend/backend/util/settings.py
+++ b/autogpt_platform/backend/backend/util/settings.py
@@ -140,6 +140,11 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
description="The port for agent server API to run on",
)
+ notification_service_port: int = Field(
+ default=8007,
+ description="The port for notification service daemon to run on",
+ )
+
platform_base_url: str = Field(
default="",
description="Must be set so the application knows where it's hosted at. "
diff --git a/autogpt_platform/backend/backend/util/test.py b/autogpt_platform/backend/backend/util/test.py
index ed4a343ab3..29b2cfdbc5 100644
--- a/autogpt_platform/backend/backend/util/test.py
+++ b/autogpt_platform/backend/backend/util/test.py
@@ -9,6 +9,7 @@ from backend.data.execution import ExecutionResult, ExecutionStatus
from backend.data.model import _BaseCredentials
from backend.data.user import create_default_user
from backend.executor import DatabaseManager, ExecutionManager, ExecutionScheduler
+from backend.notifications.notifications import NotificationManager
from backend.server.rest_api import AgentServer
from backend.server.utils import get_user_id
@@ -21,6 +22,7 @@ class SpinTestServer:
self.exec_manager = ExecutionManager()
self.agent_server = AgentServer()
self.scheduler = ExecutionScheduler()
+ self.notif_manager = NotificationManager()
@staticmethod
def test_get_user_id():
@@ -32,6 +34,7 @@ class SpinTestServer:
self.agent_server.__enter__()
self.exec_manager.__enter__()
self.scheduler.__enter__()
+ self.notif_manager.__enter__()
await db.connect()
await initialize_blocks()
@@ -46,6 +49,7 @@ class SpinTestServer:
self.exec_manager.__exit__(exc_type, exc_val, exc_tb)
self.agent_server.__exit__(exc_type, exc_val, exc_tb)
self.db_api.__exit__(exc_type, exc_val, exc_tb)
+ self.notif_manager.__exit__(exc_type, exc_val, exc_tb)
def setup_dependency_overrides(self):
# Override get_user_id for testing
diff --git a/autogpt_platform/docker-compose.platform.yml b/autogpt_platform/docker-compose.platform.yml
index 2ba1987612..948ade616e 100644
--- a/autogpt_platform/docker-compose.platform.yml
+++ b/autogpt_platform/docker-compose.platform.yml
@@ -81,18 +81,20 @@ services:
- REDIS_PORT=6379
- RABBITMQ_HOST=rabbitmq
- RABBITMQ_PORT=5672
- - RABBITMQ_USER=rabbitmq_user_default
- - RABBITMQ_PASSWORD=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
+ - RABBITMQ_DEFAULT_USER=rabbitmq_user_default
+ - RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
- REDIS_PASSWORD=password
- ENABLE_AUTH=true
- PYRO_HOST=0.0.0.0
- EXECUTIONSCHEDULER_HOST=rest_server
- EXECUTIONMANAGER_HOST=executor
+ - NOTIFICATIONMANAGER_HOST=rest_server
- FRONTEND_BASE_URL=http://localhost:3000
- BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]
- ENCRYPTION_KEY=dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw= # DO NOT USE IN PRODUCTION!!
ports:
- "8006:8006"
+ - "8007:8007"
- "8003:8003" # execution scheduler
networks:
- app-network
@@ -127,11 +129,12 @@ services:
- REDIS_PASSWORD=password
- RABBITMQ_HOST=rabbitmq
- RABBITMQ_PORT=5672
- - RABBITMQ_USER=rabbitmq_user_default
- - RABBITMQ_PASSWORD=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
+ - RABBITMQ_DEFAULT_USER=rabbitmq_user_default
+ - RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
- ENABLE_AUTH=true
- PYRO_HOST=0.0.0.0
- AGENTSERVER_HOST=rest_server
+ - NOTIFICATIONMANAGER_HOST=rest_server
- ENCRYPTION_KEY=dvziYgz0KSK8FENhju0ZYi8-fRTfAdlz6YLhdB_jhNw= # DO NOT USE IN PRODUCTION!!
ports:
- "8002:8000"
@@ -157,17 +160,17 @@ services:
# rabbitmq:
# condition: service_healthy
migrate:
- condition: service_completed_successfully
+ condition: service_completed_successfully
environment:
- SUPABASE_JWT_SECRET=your-super-secret-jwt-token-with-at-least-32-characters-long
- DATABASE_URL=postgresql://postgres:your-super-secret-and-long-postgres-password@db:5432/postgres?connect_timeout=60&schema=platform
- REDIS_HOST=redis
- REDIS_PORT=6379
- REDIS_PASSWORD=password
- # - RABBITMQ_HOST=rabbitmq # TODO: Uncomment this when we have a need for it in websocket (like nofifying when stuff went down)
+ # - RABBITMQ_HOST=rabbitmq
# - RABBITMQ_PORT=5672
- # - RABBITMQ_USER=rabbitmq_user_default
- # - RABBITMQ_PASSWORD=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
+ # - RABBITMQ_DEFAULT_USER=rabbitmq_user_default
+ # - RABBITMQ_DEFAULT_PASS=k0VMxyIJF9S35f3x2uaw5IWAl6Y536O7
- ENABLE_AUTH=true
- PYRO_HOST=0.0.0.0
- BACKEND_CORS_ALLOW_ORIGINS=["http://localhost:3000"]