---

Micronaut Configuration Interview Questions and Answers

Introduction

Configuration is a critical part of every enterprise application. Database URLs, API keys, Kafka brokers, JWT secrets, feature flags, and cloud settings should never be hardcoded in the source code.

Micronaut provides a flexible configuration system using YAML, properties files, environment variables, system properties, and external configuration sources. Configuration values can be injected directly into beans using annotations such as @Value and @ConfigurationProperties.

---

Micronaut Configuration Architecture

flowchart LR

application.yml --> Configuration

application-dev.yml --> Configuration

EnvironmentVariables --> Configuration

SystemProperties --> Configuration

ExternalSecrets --> Configuration

Configuration --> MicronautContainer

MicronautContainer --> Application

---

Q1. What is Configuration in Micronaut?

Answer

Configuration allows applications to externalize values instead of hardcoding them.

Examples include:

• Database URL
• Server Port
• JWT Secret
• Kafka Broker
• Redis Host
• API Keys
• Feature Flags

Example

micronaut:
  application:
    name: payment-service

server:
  port: 8080

Benefits

• Easy deployment
• Environment-specific values
• Better security
• Improved maintainability

---

Q2. What is application.yml?

application.yml is the primary configuration file used by Micronaut.

Example

micronaut:
  application:
    name: banking-service

datasources:
  default:
    url: jdbc:mysql://localhost:3306/bank
    username: root
    password: password

server:
  port: 8080

Configuration is automatically loaded during application startup.

---

Q3. How do you inject configuration values?

Use the @Value annotation.

Example

@Singleton
public class ServerInfo {

    @Value("${server.port}")
    private int port;

}

Another example

@Value("${micronaut.application.name}")
private String applicationName;

Configuration Flow

flowchart LR

application.yml --> Micronaut

Micronaut --> @Value

@Value --> Bean

---

Q4. What is @ConfigurationProperties?

Instead of injecting individual values, Micronaut can map an entire configuration section to a Java class.

Configuration

datasources:
  default:
    url: jdbc:mysql://localhost:3306/bank
    username: root
    password: secret

Bean

@ConfigurationProperties("datasources.default")
public class DatabaseConfiguration {

    private String url;

    private String username;

    private String password;

    // getters and setters

}

Benefits

• Cleaner code
• Type-safe
• Easier maintenance

---

Q5. How do environments work?

Micronaut supports multiple environments.

Examples

• dev
• test
• qa
• prod

Configuration files

application.yml

application-dev.yml

application-test.yml

application-prod.yml

Diagram

flowchart TD

application.yml --> Dev

application.yml --> Test

application.yml --> Production

Each environment overrides only the necessary properties.

---

Q6. How do Environment Variables work?

Micronaut automatically reads operating system environment variables.

Example

export DB_HOST=localhost

export DB_PORT=3306

Configuration

datasources:
  default:
    url: jdbc:mysql://${DB_HOST}:${DB_PORT}/bank

Benefits

• Docker friendly
• Kubernetes friendly
• Secure deployment
• No source code changes

---

Q7. What is Configuration Property Priority?

Micronaut resolves properties in order of precedence.

Priority	Source
1	Command-line arguments
2	System Properties
3	Environment Variables
4	application-{env}.yml
5	application.yml
6	Default Values

Highest priority overrides lower priority values.

---

Q8. How do you provide default values?

Default values prevent application failures when properties are missing.

Example

@Value("${server.port:8080}")
private int port;

If the property is unavailable,

8080

is automatically used.

---

Q9. How is configuration managed in production?

Production applications typically use external configuration.

Examples

• Kubernetes ConfigMaps
• Kubernetes Secrets
• Docker Environment Variables
• AWS Secrets Manager
• HashiCorp Vault
• Azure Key Vault

Architecture

flowchart LR

Vault --> Micronaut

AWSSecrets --> Micronaut

ConfigMap --> Micronaut

Micronaut --> Application

Hardcoding passwords inside Git repositories should always be avoided.

---

Q10. Configuration Best Practices

Never Hardcode Secrets

Bad

String password="admin123";

Good

datasources:
  default:
    password: ${DB_PASSWORD}

---

Use ConfigurationProperties

Avoid multiple @Value fields.

---

Separate Configurations by Environment

Maintain dedicated files for development, testing, and production.

---

Store Secrets Securely

Use Vault or cloud secret managers instead of property files.

---

Banking Example

flowchart TD

Developer --> Git

Git --> CI/CD

CI/CD --> Kubernetes

Kubernetes --> ConfigMap

Kubernetes --> Secret

ConfigMap --> Micronaut

Secret --> Micronaut

Micronaut --> BankingService

---

Common Interview Questions

• What is configuration in Micronaut?
• Explain application.yml.
• What is @Value?
• What is @ConfigurationProperties?
• How do environments work?
• How do environment variables work?
• What is configuration precedence?
• How do you provide default values?
• How do you manage secrets?
• What are configuration best practices?

---

Quick Revision

Topic	Summary
application.yml	Primary configuration file
@Value	Injects single property
@ConfigurationProperties	Maps property groups
Environment	Dev, Test, QA, Prod
Environment Variables	External configuration
ConfigMap	Kubernetes configuration
Secret Manager	Secure credentials
Default Value	Fallback property
Property Priority	Override order
External Configuration	Production deployment

---

Configuration Loading Flow

sequenceDiagram
Application->>Micronaut: Startup
Micronaut->>application.yml: Load Properties
Micronaut->>Environment Variables: Override Values
Micronaut->>Configuration Beans: Inject Properties
Configuration Beans-->>Application: Ready

---

Key Takeaways

• Micronaut supports externalized configuration using YAML files, properties files, environment variables, system properties, and external secret stores.
• application.yml is the default configuration file loaded during startup.
• Use @Value to inject individual configuration values into beans.
• Use @ConfigurationProperties to map related configuration properties into strongly typed classes.
• Environment-specific configuration files such as application-dev.yml and application-prod.yml simplify deployments across multiple environments.
• Environment variables make applications portable across Docker, Kubernetes, and cloud platforms.
• Configuration sources follow a priority order, allowing higher-precedence values to override defaults.
• Never store passwords, API keys, or secrets directly in source code or Git repositories.
• Use secure secret management solutions such as AWS Secrets Manager, HashiCorp Vault, or Kubernetes Secrets in production.
• Proper configuration management improves security, maintainability, and deployment flexibility in enterprise Micronaut applications.