application.yml Reference: Every Top-Level Configuration Key

application.yml is the central configuration file for a Winter Boot application. It must live in the config directory referenced by #[WinterBootApplication(configDirectory: [...])]. This page indexes every top-level key the framework and its official libraries recognise, with one-line descriptions and links to the concept page that documents each in full.

For prose walkthroughs of properties, #[Value] injection, and additional property sources see Configuration.

Framework top-level keys

server

HTTP server configuration used by WinterWebSwooleApplication.

server:
    port: 8080
    address: 0.0.0.0
    context-path: /

Documented in Configuration.

winter

Framework-wide runtime settings.

winter:
    application:
        name: "My Winter App"
        id: MyApp
        version: 1.0.0
    namespaces:
        cacheTime: 10
    route:
        cacheTime: 10

• application.name, application.id, application.version: identity used in logs and actuator.
• namespaces.cacheTime: how long reflection scan results are cached.
• route.cacheTime: how long route mappings are cached.

datasource

List of relational datasources. Each entry produces a named PdbcTemplate bean and a transaction manager bean.

datasource:
    -   name: defaultdb
        isPrimary: true
        url: "sqlite::memory:"
        username: myuser
        password: mypassword
        driverClass: dev\winterframework\pdbc\pdo\PdoDataSource
        validationQuery: SELECT 1
        connection:
            persistent: true
            errorMode: ERRMODE_EXCEPTION
            columnsCase: CASE_NATURAL
            idleTimeout: 300
            autoCommit: true

Documented in Datasources & PdbcTemplate.

An optional migrations.enabled: true on a datasource entry opts the connection into SQL migrations.

modules

List of Winter modules (libraries) to load at startup.

modules:
    - module: 'dev\winterframework\kafka\KafkaModule'
      enabled: true
      configFile: 'config/kafka-config.yml'

Modules are loaded in order. Documented in The Module System.

logger

Monolog-cascade configuration for logging channels, handlers, and formatters.

Documented in Logging.

propertySources

List of additional property sources to load on top of application.yml.

Documented in Configuration.

Custom application keys

Any additional top-level key you define is exposed to #[Value("myApp.value1")] and can be read via PropertyContext. Convention is to nest your application config under a single namespace (for example myApp:).

Library-specific keys

Each Winter library reads its own top-level keys. The keys can live directly in application.yml or in a module-specific file referenced by the configFile entry under modules:.

opensearch

Used by OpenSearch and the framework’s OpenSearch migration runner.

opensearch:
    -   name: opensearch
        hosts:
            - https://localhost:9200
        username: admin
        password: secret
        ssl_verification: false
        migrations:
            enabled: true

kafka

Used by the Kafka library for consumer and producer definitions.

sqs

Used by the SQS library for connection and consumer definitions.

s3

Used by the S3 library for connection credentials.

doctrine

Used by the Doctrine library for ORM/DBAL datasources and multi-tenant configuration.

memdb

Used by the Memdb library for embedded server engine selection.

dtce

Used by the DTCE library for queue, store, and worker configuration.

eureka, consul

Used by the Service Discovery library.

redis, memcache

Used by the Redis and Memcache client libraries respectively.

security

Reserved for the planned Security module. Not yet implemented.

Module-config file convention

For libraries with substantial config, keep it in a dedicated file and reference it from modules::

application.yml

modules:
    - module: 'dev\winterframework\kafka\KafkaModule'
      enabled: true
      configFile: 'config/kafka-config.yml'

config/kafka-config.yml

kafka:
    consumers:
        - name: my-consumer
          # ...

The framework loads the referenced file and merges its keys into the property context so #[Value] and library beans can read them uniformly.