You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by GitBox <gi...@apache.org> on 2021/01/29 19:08:39 UTC
[GitHub] [camel-website] zregvart commented on a change in pull request #534: Blog: Camel Quarkus Configuration Tips
zregvart commented on a change in pull request #534:
URL: https://github.com/apache/camel-website/pull/534#discussion_r567031414
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
Review comment:
```suggestion
From the Camel side, the `{{...}}` notation could be issued, for instance, in a simple expression:
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
Review comment:
```suggestion
Notice how the property from the second line embeds the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
Review comment:
```suggestion
But there is more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
+
+## Environment variables
+
+Another topic of interest is environment variable expansion. Look at the following property definition where the USERNAME environment variable is used:
+```properties
+environment-variable = a-value-with-environment-variable-${USERNAME}
+```
+
+So, it is possible to include environment variables in the mix. In case Camel Quarkus runs in an environment where the variable is not defined,
+it is even possible to define a default value after the `:` character like this:
+```properties
+environment-variable-or-default = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:by-a-default-value}
+```
+
+Last but not least, it's also possible to mix property expressions with environment variables as in the following lines:
+```properties
+default-value = with-a-default-value-resolved-via-a-property-expression
+environment-variable-or-default-via-property-expression = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:${default-value}}
+```
+The more meaningful part is `${UNEXISTING_ENV_VAR:${default-value}}`. If the environment variable `UNEXISTING_ENV_VAR` is not defined, we end up embedding the `default-value` configured one line above.
+
+## A tricky situation
+
+The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it remind us some part of the [Camel simple Language](/components/latest/languages/simple-language.html).
+For instance, some developers could end up defining a property like below:
+```properties
+date-expression = ${date:now}
+```
+And then using it in a Camel simple expression like that:
+```properties
+from(...).setBody(simple("{{escape-dollar-to-avoid-property-resolution}}")
+```
+But when the `setBody` statement is executed, the resulting body is... `null`
+
+It could sounds a bit strange at first, but let's review this situation with what we have learned so far.
+On first pass, the `application.properties` file is parsed with respect to the [Properties file format](https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html). No special characters are used, so the parsing outcome would be `${date:now}` as expected.
+
+But in the second pass, it turns out that this property value is interpreted as the expansion of an environment variable named `date` with a default value `now`. As such, Camel is provided with the default value `now`. The expansion algorithm is detailed in [io.smallrye.common.expression.Expression.parseString(...)](https://github.com/smallrye/smallrye-common/blob/0b59733491ff936808cd26a4b300f11fe3f2a5f0/expression/src/main/java/io/smallrye/common/expression/Expression.java#L245).
+Paying a close attention, it appears that the environment value expansion could be avoided using `$$`:
+```properties
+date-expression = $${date:now}
+```
+Exactly what we needed, Camel is now provided with the simple expression `${date:now}` and set the body to a value like `Fri Jan 29 17:07:44 CET 2021` on execution.
+
+## Summary
+
+At the end of the day, we had a refresher about `application.properties`, property expressions and environment variables with default value.
+We have seen how to deal with a tricky situation and there must be even more corner cases out there.
+
+The source code for this example could be found [here](https://github.com/aldettinger/camel-quarkus-properties). Also, the Quarkus configuration reference guide is located [here](https://quarkus.io/guides/config-reference).
+
+We hope that this article brought some useful tips when dealing with configuration in Camel Quarkus.
Review comment:
```suggestion
We hope that this article brought some useful tips when dealing with the configuration in Camel Quarkus.
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
+
+## Environment variables
+
+Another topic of interest is environment variable expansion. Look at the following property definition where the USERNAME environment variable is used:
+```properties
+environment-variable = a-value-with-environment-variable-${USERNAME}
+```
+
+So, it is possible to include environment variables in the mix. In case Camel Quarkus runs in an environment where the variable is not defined,
+it is even possible to define a default value after the `:` character like this:
+```properties
+environment-variable-or-default = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:by-a-default-value}
+```
+
+Last but not least, it's also possible to mix property expressions with environment variables as in the following lines:
+```properties
+default-value = with-a-default-value-resolved-via-a-property-expression
+environment-variable-or-default-via-property-expression = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:${default-value}}
+```
+The more meaningful part is `${UNEXISTING_ENV_VAR:${default-value}}`. If the environment variable `UNEXISTING_ENV_VAR` is not defined, we end up embedding the `default-value` configured one line above.
+
+## A tricky situation
+
+The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it remind us some part of the [Camel simple Language](/components/latest/languages/simple-language.html).
+For instance, some developers could end up defining a property like below:
+```properties
+date-expression = ${date:now}
+```
+And then using it in a Camel simple expression like that:
+```properties
+from(...).setBody(simple("{{escape-dollar-to-avoid-property-resolution}}")
+```
+But when the `setBody` statement is executed, the resulting body is... `null`
+
+It could sounds a bit strange at first, but let's review this situation with what we have learned so far.
Review comment:
```suggestion
It could sound a bit strange at first, but let's review this situation with what we have learned so far.
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
+
+## Environment variables
+
+Another topic of interest is environment variable expansion. Look at the following property definition where the USERNAME environment variable is used:
+```properties
+environment-variable = a-value-with-environment-variable-${USERNAME}
+```
+
+So, it is possible to include environment variables in the mix. In case Camel Quarkus runs in an environment where the variable is not defined,
+it is even possible to define a default value after the `:` character like this:
+```properties
+environment-variable-or-default = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:by-a-default-value}
+```
+
+Last but not least, it's also possible to mix property expressions with environment variables as in the following lines:
+```properties
+default-value = with-a-default-value-resolved-via-a-property-expression
+environment-variable-or-default-via-property-expression = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:${default-value}}
+```
+The more meaningful part is `${UNEXISTING_ENV_VAR:${default-value}}`. If the environment variable `UNEXISTING_ENV_VAR` is not defined, we end up embedding the `default-value` configured one line above.
+
+## A tricky situation
+
+The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it remind us some part of the [Camel simple Language](/components/latest/languages/simple-language.html).
Review comment:
```suggestion
The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it reminds us of some parts of the [Camel simple Language](/components/latest/languages/simple-language.html).
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
+
+## Environment variables
+
+Another topic of interest is environment variable expansion. Look at the following property definition where the USERNAME environment variable is used:
+```properties
+environment-variable = a-value-with-environment-variable-${USERNAME}
+```
+
+So, it is possible to include environment variables in the mix. In case Camel Quarkus runs in an environment where the variable is not defined,
+it is even possible to define a default value after the `:` character like this:
+```properties
+environment-variable-or-default = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:by-a-default-value}
+```
+
+Last but not least, it's also possible to mix property expressions with environment variables as in the following lines:
+```properties
+default-value = with-a-default-value-resolved-via-a-property-expression
+environment-variable-or-default-via-property-expression = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:${default-value}}
+```
+The more meaningful part is `${UNEXISTING_ENV_VAR:${default-value}}`. If the environment variable `UNEXISTING_ENV_VAR` is not defined, we end up embedding the `default-value` configured one line above.
+
+## A tricky situation
+
+The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it remind us some part of the [Camel simple Language](/components/latest/languages/simple-language.html).
+For instance, some developers could end up defining a property like below:
+```properties
+date-expression = ${date:now}
+```
+And then using it in a Camel simple expression like that:
+```properties
+from(...).setBody(simple("{{escape-dollar-to-avoid-property-resolution}}")
+```
+But when the `setBody` statement is executed, the resulting body is... `null`
+
+It could sounds a bit strange at first, but let's review this situation with what we have learned so far.
+On first pass, the `application.properties` file is parsed with respect to the [Properties file format](https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html). No special characters are used, so the parsing outcome would be `${date:now}` as expected.
Review comment:
```suggestion
On the first pass, the `application.properties` file is parsed with respect to the [Properties file format](https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html). No special characters are used, so the parsing outcome would be `${date:now}` as expected.
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
+
+## Environment variables
+
+Another topic of interest is environment variable expansion. Look at the following property definition where the USERNAME environment variable is used:
+```properties
+environment-variable = a-value-with-environment-variable-${USERNAME}
+```
+
+So, it is possible to include environment variables in the mix. In case Camel Quarkus runs in an environment where the variable is not defined,
+it is even possible to define a default value after the `:` character like this:
+```properties
+environment-variable-or-default = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:by-a-default-value}
+```
+
+Last but not least, it's also possible to mix property expressions with environment variables as in the following lines:
+```properties
+default-value = with-a-default-value-resolved-via-a-property-expression
+environment-variable-or-default-via-property-expression = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:${default-value}}
+```
+The more meaningful part is `${UNEXISTING_ENV_VAR:${default-value}}`. If the environment variable `UNEXISTING_ENV_VAR` is not defined, we end up embedding the `default-value` configured one line above.
+
+## A tricky situation
+
+The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it remind us some part of the [Camel simple Language](/components/latest/languages/simple-language.html).
+For instance, some developers could end up defining a property like below:
+```properties
+date-expression = ${date:now}
+```
+And then using it in a Camel simple expression like that:
+```properties
+from(...).setBody(simple("{{escape-dollar-to-avoid-property-resolution}}")
+```
+But when the `setBody` statement is executed, the resulting body is... `null`
+
+It could sounds a bit strange at first, but let's review this situation with what we have learned so far.
+On first pass, the `application.properties` file is parsed with respect to the [Properties file format](https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html). No special characters are used, so the parsing outcome would be `${date:now}` as expected.
+
+But in the second pass, it turns out that this property value is interpreted as the expansion of an environment variable named `date` with a default value `now`. As such, Camel is provided with the default value `now`. The expansion algorithm is detailed in [io.smallrye.common.expression.Expression.parseString(...)](https://github.com/smallrye/smallrye-common/blob/0b59733491ff936808cd26a4b300f11fe3f2a5f0/expression/src/main/java/io/smallrye/common/expression/Expression.java#L245).
+Paying a close attention, it appears that the environment value expansion could be avoided using `$$`:
Review comment:
```suggestion
Paying close attention, it appears that the environment value expansion could be avoided using `$$`:
```
##########
File path: content/blog/2021/01/camel-quarkus-configuration-tips/index.md
##########
@@ -0,0 +1,106 @@
+---
+title: "Camel Quarkus Configuration Tips"
+date: 2021-01-29
+authors: ["aldettinger"]
+categories: ["Camel Quarkus"]
+preview: "Camel Quarkus Configuration Tips"
+summary: "Some tips related to configuration in Camel Quarkus"
+---
+
+Lately, I have exchanged with a member of the Camel community around configuration properties in Camel Quarkus.
+It's really interesting to hear about situations people are facing out there, so please keep reaching out to the community.
+Thinking back about the case at hand, I think there is room for a refresher about some configuration tips.
+
+## Configuration via application.properties file
+
+There are multiple ways to define configurations in Camel Quarkus.
+The more common way to define configurations must be the `application.properties` file, as illustrated below:
+```properties
+basic=a-basic-value
+```
+
+There are few possibilities for a developer to use the defined configurations.
+One could use the `@ConfigProperty` annotation as beneath:
+```java
+@ConfigProperty(name = "basic")
+String basicPropertyFromAnnotation;
+```
+
+It's also possible to access the configuration values programmatically via the following code:
+```java
+String basicPropertyFromConfigProvider = ConfigProvider.getConfig().getValue("basic", String.class);
+```
+
+From the Camel side, the `{{...}}` notation could be issued, for instance in a simple expression:
+```java
+from(...).setBody(simple("{{basic}}"))
+```
+
+It's worth noting that in a first pass the `application.properties` file is parsed thanks to `java.util.Properties`.
+And as such, the corresponding character escaping rules applies, for instance one could define a configuration using the mathematical square root sign `\u221A` as beneath:
+```properties
+unicode = a-value-with-unicode-character-(\u221A9=3)
+```
+
+## Property expressions
+
+But there are more processing happening in a second pass thanks to [smallrye-common](https://github.com/smallrye/smallrye-common) and it leads to more features.
+For instance, with property expressions one could define a configuration as below:
+```properties
+embedded = resolved-via-a
+property-expression = a-value-${embedded}-property-expression
+```
+
+Notice how the property from the second line embed the value from the first line. The resulting value at the end would be `a-value-resolved-via-a-property-expression`.
+
+## Environment variables
+
+Another topic of interest is environment variable expansion. Look at the following property definition where the USERNAME environment variable is used:
+```properties
+environment-variable = a-value-with-environment-variable-${USERNAME}
+```
+
+So, it is possible to include environment variables in the mix. In case Camel Quarkus runs in an environment where the variable is not defined,
+it is even possible to define a default value after the `:` character like this:
+```properties
+environment-variable-or-default = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:by-a-default-value}
+```
+
+Last but not least, it's also possible to mix property expressions with environment variables as in the following lines:
+```properties
+default-value = with-a-default-value-resolved-via-a-property-expression
+environment-variable-or-default-via-property-expression = a-value-where-non-existing-environment-variable-is-replaced-${UNEXISTING_ENV_VAR:${default-value}}
+```
+The more meaningful part is `${UNEXISTING_ENV_VAR:${default-value}}`. If the environment variable `UNEXISTING_ENV_VAR` is not defined, we end up embedding the `default-value` configured one line above.
+
+## A tricky situation
+
+The previous syntax `${VAR:default}` may sound familiar for some Camel users. Indeed, it remind us some part of the [Camel simple Language](/components/latest/languages/simple-language.html).
+For instance, some developers could end up defining a property like below:
+```properties
+date-expression = ${date:now}
+```
+And then using it in a Camel simple expression like that:
+```properties
+from(...).setBody(simple("{{escape-dollar-to-avoid-property-resolution}}")
+```
+But when the `setBody` statement is executed, the resulting body is... `null`
+
+It could sounds a bit strange at first, but let's review this situation with what we have learned so far.
+On first pass, the `application.properties` file is parsed with respect to the [Properties file format](https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html). No special characters are used, so the parsing outcome would be `${date:now}` as expected.
+
+But in the second pass, it turns out that this property value is interpreted as the expansion of an environment variable named `date` with a default value `now`. As such, Camel is provided with the default value `now`. The expansion algorithm is detailed in [io.smallrye.common.expression.Expression.parseString(...)](https://github.com/smallrye/smallrye-common/blob/0b59733491ff936808cd26a4b300f11fe3f2a5f0/expression/src/main/java/io/smallrye/common/expression/Expression.java#L245).
+Paying a close attention, it appears that the environment value expansion could be avoided using `$$`:
+```properties
+date-expression = $${date:now}
+```
+Exactly what we needed, Camel is now provided with the simple expression `${date:now}` and set the body to a value like `Fri Jan 29 17:07:44 CET 2021` on execution.
+
+## Summary
+
+At the end of the day, we had a refresher about `application.properties`, property expressions and environment variables with default value.
Review comment:
```suggestion
At the end of the day, we had a refresher about `application.properties`, property expressions, and environment variables with the default value.
```
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org