Super Simple Guide to Multi-Environment Configurations in Micronaut

Ever tried to tweak settings in an app and wished there was a cleaner way to switch between development, testing, and production environments? That’s where the magic of multi-environment configuration comes in, especially if you’re using Micronaut. This trick doesn’t just save time—it saves a lot of headaches. So, here’s a stroll through how you can up your game by managing all those different settings without chopping and changing the core codebase.

The Basic Gist of Micronaut’s Config System

Micronaut is like a Swiss Army knife for configurations, supporting formats like properties files, JSON, and YAML. Don’t like application.properties? No worries. Want YAML? Easy peasy. Just add the dependencies, and you’re good to go.

Environment-Specific Setup

Imagine having separate tweakable files for each environment: development, testing, staging, and production. Create files like application-dev.yml, application-test.yml, and so on. Each of these files will be the rulebook for the respective environment.

For example:

application-dev.yml

micronaut:
  server:
    port: 8080
  datasource:
    url: jdbc:mysql://localhost:3306/devdb
    username: devuser
    password: devpassword

application-prod.yml

micronaut:
  server:
    port: 8080
  datasource:
    url: jdbc:mysql://prod-db-host:3306/proddb
    username: produser
    password: prodpassword

Switching Between Environments

Switching to a specific environment is a breeze. Just use system properties or set environment variables. For instance, to get your app to use the production setup, run this:

java -Dmicronaut.environments=prod -jar myapp.jar

Even easier? Set an environment variable MICRONAUT_ENVIRONMENTS to prod before hitting start.

Organizing Your Config Files

Micronaut is like the Marie Kondo of configuration files. You can organize them as neatly as you like:

config/
├── application.yml
├── application-dev.yml
├── application-test.yml
├── application-stg.yml
└── application-prod.yml

Have application.yml for common settings, and let the environment-specific ones do the overrides.

Using @ConfigurationProperties

Want to merge your config files with your Java beans? The @ConfigurationProperties annotation is your best buddy. Here’s a quick snippet:

import io.micronaut.context.annotation.ConfigurationProperties;

@ConfigurationProperties("micronaut.datasource")
public class DataSourceConfig {
    private String url;
    private String username;
    private String password;

    // Getters and setters
}

Example Application Configuration

To get the hang of it, here’s what a full example looks like. Say you have a ConfigController:

import io.micronaut.context.annotation.ConfigurationProperties;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;

@Controller("/config")
public class ConfigController {

    private final DataSourceConfig dataSourceConfig;

    public ConfigController(DataSourceConfig dataSourceConfig) {
        this.dataSourceConfig = dataSourceConfig;
    }

    @Get
    public String getConfig() {
        return "URL: " + dataSourceConfig.getUrl() +
               ", Username: " + dataSourceConfig.getUsername() +
               ", Password: " + dataSourceConfig.getPassword();
    }
}

And the corresponding YAML files:

application.yml

micronaut:
  server:
    port: 8080

application-dev.yml

micronaut:
  datasource:
    url: jdbc:mysql://localhost:3306/devdb
    username: devuser
    password: devpassword

application-prod.yml

micronaut:
  datasource:
    url: jdbc:mysql://prod-db-host:3306/proddb
    username: produser
    password: prodpassword

Deploying to the Cloud

When pushing your app to the cloud, tools like Platform.sh make life simpler. Here’s how you can rig it up:

.platform.app.yaml

name: app
type: "java:11"
disk: 1024
hooks:
  build: mvn clean package
web:
  commands:
    start: java -Xmx$(jq .info.limits.memory /run/config.json)m -XX:+ExitOnOutOfMemoryError -jar target/micronaut-1.0-SNAPSHOT.jar

.platform/routes.yaml

routes:
  http: /{path}
    upstream: app:http

The setup makes sure everything is wired up the right way, no matter the environment.

Wrapping Up

Whether you’re tinkering in the dev phase, testing, or going full production, having a solid multi-environment configuration is gold. With Micronaut, it’s as straightforward as creating environment-specific files and flipping a switch to change settings. This makes your app flexible, maintainable, and just plain smarter. Ready to give it a go? Your future self will thank you for it.