How to run bootRun with spring profile via gradle task

Question

I'm trying to set up gradle to launch the bootRun process with various spring profiles enabled.

My current bootRun configuration looks like:

bootRun {
    // pass command line options from gradle to bootRun
    // usage: gradlew bootRun "-Dspring.profiles.active=local,protractor"
    if (System.properties.containsKey('spring.profiles.active')) {
        systemProperty "spring.profiles.active", System.properties['spring.profiles.active']
    }
}

I'd like to set system properties with a gradle task, and then execute bootRun.

My attempt looked like this:

task bootRunDev

bootRunDev  {
    System.setProperty("spring.profiles.active", "Dev")
}

A few questions:

is systemProperty a part of the spring boot bootRun configuration?
is it possible to set a system property in another task?
What should my next step be? I need to get bootRunDev configuration to happen before bootRun
Is there another approach I should look into

-Eric

score 163 · Answer 1 · edited Jun 20 '20 at 09:12

163

Spring Boot v2 Gradle plugin docs provide an answer:

6.1. Passing arguments to your application

Like all JavaExec tasks, arguments can be passed into bootRun from the command line using --args='<arguments>' when using Gradle 4.9 or later.

To run server with active profile set to dev:

$ ./gradlew bootRun --args='--spring.profiles.active=dev'

edited Jun 20 '20 at 09:12

Community

1
1

answered Sep 11 '19 at 13:21

Ivar

4,350
2
27
29

3

This definitely works, can you please tell me how can i pass these in bootJar task – Somnath Singh Oct 01 '20 at 06:57

score 80 · Answer 2 · edited Apr 24 '19 at 18:33

80

Environment variables can be used to set spring properties as described in the documentation. So, to set the active profiles (spring.profiles.active) you can use the following code on Unix systems:

SPRING_PROFILES_ACTIVE=test gradle clean bootRun

And on Windows you can use:

SET SPRING_PROFILES_ACTIVE=test
gradle clean bootRun

edited Apr 24 '19 at 18:33

Paulo Merson

13,270
8
79
72

answered Jun 21 '17 at 04:28

david

997
7
5

2

While this code snippet may solve the question, [including an explanation](http://meta.stackexchange.com/questions/114762/explaining-entirely-code-based-answers) really helps to improve the quality of your post. Remember that you are answering the question for readers in the future, and those people might not know the reasons for your code suggestion. – DimaSan Jun 21 '17 at 07:17
On *nix, you will probably need to export the variable for it to be visible to gradle: `export SPRING_PROFILES_ACTIVE=dev; gradle bootRun` – Steve Tarver Apr 03 '18 at 14:59
5

No, on a per-call basis setting environment variables works as shown by david. – Patrick Bergner Jul 27 '18 at 13:10
It does work on Windows! In my case, I was not even running bootRun, but executing `SpringBootTest` tests that require the active profiles for retrieving properties via spring-cloud-config. – Paulo Merson Apr 24 '19 at 18:35

score 67 · Accepted Answer · edited Jul 07 '23 at 18:35

67

Simplest way would be to define default and allow it to be overridden. I am not sure what is the use of systemProperty in this case. Simple arguments will do the job.

def profiles = 'prod'

bootRun {
  args = ["--spring.profiles.active=" + profiles]
}

To run dev:

./gradlew bootRun -Pdev

To add dependencies on your task you can do something like this:

task setDevProperties(dependsOn: bootRun) << {
  doFirst {
    System.setProperty('spring.profiles.active', profiles)
  }
}

There are lots of ways achieving this in Gradle.

Edit:

Configure separate configuration files per environment.

if (project.hasProperty('prod')) {
  apply from: 'gradle/profile_prod.gradle'
} else {
  apply from: 'gradle/profile_dev.gradle'
}

Each configuration can override tasks for example:

def profiles = 'prod'
bootRun {
  systemProperty "spring.profiles.active", profiles
}

Run by providing prod flag in this case just like that:

./gradlew <task> -Pprod

edited Jul 07 '23 at 18:35

GreenGiant

4,930
1
46
76

answered Apr 28 '16 at 21:27

Vaelyr

2,841
2
21
34

I get `Could not find method dev() for arguments [org.springframework.boot:spring-boot-devtools] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.` when I try this approach. http://stackoverflow.com/a/31328621/1134197 works fine – aycanadal Nov 18 '16 at 12:21
3

While first code snippet shows how to configure `bootRun` task, other examples simply do not work. – Ivar Feb 26 '18 at 17:34
6

Can you update how `-Pdev` will set `profiles` to `dev`? It seems it does not work at all. – lowatt Nov 08 '18 at 21:49
1

You obviously need to have 'org.springframework.boot' plugin applied to your project as well. – Vaelyr Jan 20 '19 at 17:04
For anyone confused about `-P` see [Passing System properties to your application](https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/htmlsingle/#running-your-application-passing-system-properties) on the Spring website. It allows properties to be passed to the JVM. – Zach Jan 15 '21 at 15:29

Rafael · Answer 4 · 2019-01-16T17:33:17.597

16

Using this shell command it will work:

SPRING_PROFILES_ACTIVE=test gradle clean bootRun

Sadly this is the simplest way I have found. It sets environment property for that call and then runs the app.

edited Jan 16 '19 at 17:33

answered Sep 28 '18 at 09:51

Rafael

2,521
2
33
59

Just x but where do I put that ? sorry but i down vote your question – Jan 16 '19 at 12:24
1

Directly in the shell. The first part defines an env variable, then Gradle command. No need to downvote man. – Rafael Jan 16 '19 at 17:32
I also think this is the simplest way. thanks for sharing. – Ali Abazari Apr 22 '20 at 07:08

score 15 · Answer 5 · edited Jun 08 '18 at 17:01

15

For those folks using Spring Boot 2.0+, you can use the following to setup a task that will run the app with a given set of profiles.

task bootRunDev(type: org.springframework.boot.gradle.tasks.run.BootRun, dependsOn: 'build') {
    group = 'Application'

    doFirst() {
        main = bootJar.mainClassName
        classpath = sourceSets.main.runtimeClasspath
        systemProperty 'spring.profiles.active', 'dev'
    }
}

Then you can simply run ./gradlew bootRunDev or similar from your IDE.

edited Jun 08 '18 at 17:01

Mikezx6r

16,829
7
33
31

answered Aug 03 '17 at 17:23

Yona Appletree

8,801
6
35
52

how we can customize webapp folder for this task..? – rijin Feb 02 '18 at 19:13

score 8 · Answer 6 · answered Jul 15 '20 at 16:49

Kotlin edition: Define the following task in you build.gradle.kts file:

tasks.named<BootRun>("bootRun") {
  args("--spring.profiles.active=dev")
}

This will pass the parameter --spring.profiles.active=dev to bootRun, where the profile name is dev in this case.

Every time you run gradle bootRun the profile dev is used.

score 7 · Answer 7 · answered Feb 19 '20 at 09:38

7

In your build.gradle file simply use the following snippet

bootRun {
  args = ["--spring.profiles.active=${project.properties['profile'] ?: 'prod'}"]
}

And then run following command to use dev profile:

./gradlew bootRun -Pprofile=dev

answered Feb 19 '20 at 09:38

Akter Hossain

81
1
2

score 7 · Answer 8 · answered Oct 18 '22 at 15:21

7

For the command line as of Gradle 7.5 and Spring Boot 2.7.3, I do this (if it helps anyone):

gradle bootRun --args=--spring.profiles.active=myprofile

answered Oct 18 '22 at 15:21

Patrice Gagnon

1,276
14
14

score 6 · Answer 9 · answered Mar 19 '19 at 07:56

I wanted it simple just to be able to call gradle bootRunDev like you without having to do any extra typing..

This worked for me - by first configuring it the bootRun in my task and then right after it running bootRun which worked fine for me :)

task bootRunDev {
    bootRun.configure {
        systemProperty "spring.profiles.active", 'Dev'
    }
}

bootRunDev.finalizedBy bootRun

score 6 · Answer 10 · answered Dec 30 '19 at 12:05

For anyone looking how to do this in Kotlin DSL, here's a working example for build.gradle.kts:

tasks.register("bootRunDev") {
    group = "application"
    description = "Runs this project as a Spring Boot application with the dev profile"
    doFirst {
        tasks.bootRun.configure {
            systemProperty("spring.profiles.active", "dev")
        }
    }
    finalizedBy("bootRun")
}

score 3 · Answer 11 · answered Feb 26 '18 at 18:12

For someone from internet, there was a similar question https://stackoverflow.com/a/35848666/906265 I do provide the modified answer from it here as well:

// build.gradle
<...>

bootRun {}

// make sure bootRun is executed when this task runs
task runDev(dependsOn:bootRun) {
    // TaskExecutionGraph is populated only after 
    // all the projects in the build have been evaulated https://docs.gradle.org/current/javadoc/org/gradle/api/execution/TaskExecutionGraph.html#whenReady-groovy.lang.Closure-
    gradle.taskGraph.whenReady { graph ->
        logger.lifecycle('>>> Setting spring.profiles.active to dev')
        if (graph.hasTask(runDev)) {
            // configure task before it is executed
            bootRun {
                args = ["--spring.profiles.active=dev"]
            }
        }
    }
}

<...>

then in terminal:

gradle runDev

Have used gradle 3.4.1 and spring boot 1.5.10.RELEASE

score 3 · Answer 12 · answered Aug 23 '18 at 15:05

Configuration for 4 different task with different profiles and gradle tasks dependencies:

bootRunLocal and bootRunDev - run with specific profile
bootPostgresRunLocal and bootPostgresRunDev same as prev, but executing custom task runPostgresDocker and killPostgresDocker before/after bootRun

build.gradle:

final LOCAL='local'
final DEV='dev'

void configBootTask(Task bootTask, String profile) {
    bootTask.main = bootJar.mainClassName
    bootTask.classpath = sourceSets.main.runtimeClasspath

    bootTask.args = [ "--spring.profiles.active=$profile" ]
//    systemProperty 'spring.profiles.active', profile // this approach also may be used
    bootTask.environment = postgresLocalEnvironment
}

bootRun {
    description "Run Spring boot application with \"$LOCAL\" profile"
    doFirst() {
        configBootTask(it, LOCAL)
    }
}

task bootRunLocal(type: BootRun, dependsOn: 'classes') {
    description "Alias to \":${bootRun.name}\" task: ${bootRun.description}"
    doFirst() {
        configBootTask(it, LOCAL)
    }
}

task bootRunDev(type: BootRun, dependsOn: 'classes') {
    description "Run Spring boot application with \"$DEV\" profile"
    doFirst() {
        configBootTask(it, DEV)
    }
}

task bootPostgresRunLocal(type: BootRun) {
    description "Run Spring boot application with \"$LOCAL\" profile and re-creating DB Postgres container"
    dependsOn runPostgresDocker
    finalizedBy killPostgresDocker
    doFirst() {
        configBootTask(it, LOCAL)
    }
}

task bootPostgresRunDev(type: BootRun) {
    description "Run Spring boot application with \"$DEV\" profile and re-creating DB Postgres container"
    dependsOn runPostgresDocker
    finalizedBy killPostgresDocker
    doFirst() {
        configBootTask(it, DEV)
    }
}

meiskalt7 · Answer 13 · 2020-09-29T05:52:41.947

1

Add to VM options: -Dspring.profiles.active=dev

Or you can add it to the build.gradle file to make it work: bootRun.systemProperties = System.properties.

edited Sep 29 '20 at 05:52

answered Dec 03 '18 at 07:59

meiskalt7

606
7
13

6

This needs to be added to the `build.gradle` file to make it work: `bootRun.systemProperties = System.properties`. See https://github.com/spring-projects/spring-boot/issues/832#issuecomment-272780482 – Janux Jan 19 '19 at 15:58

score 1 · Answer 14 · answered Nov 03 '20 at 12:52

1

my way:

in gradle.properties:

profile=profile-dev

in build.gradle add VM options -Dspring.profiles.active:

bootRun {
   jvmArgs = ["-Dspring.output.ansi.enabled=ALWAYS","-Dspring.profiles.active="+profile]
}

this will override application spring.profiles.active option

answered Nov 03 '20 at 12:52

Dmitriy

234
2
7

FYI, this doesn't work with Kotlin Gradle DSL. `bootRun` shows on red. – acarlstein Feb 20 '23 at 20:26

score 1 · Answer 15 · answered Aug 24 '21 at 17:35

1

Working solution for Spring Boot 2.5+

tasks.register('runDev') {
   dependsOn 'bootRun'
   bootRun.systemProperty('spring.profiles.active', 'dev')
}

and to run:

./gradlew runDev

answered Aug 24 '21 at 17:35

DevTomek

501
4
6

score 1 · Answer 16 · answered May 14 '23 at 13:18

1

For Gragle Kotlin, following works for me

tasks.bootRun {
    args("--spring.profiles.active=dev")
}

answered May 14 '23 at 13:18

maruf571

1,836
2
21
18

score 0 · Answer 17 · answered May 02 '23 at 04:12

0

If you are using jib for containerisation then, Add these two line of codes in your build.gradle and application.properties files respectively.

jib.container.jvmFlags = ['-Dspring.profiles.active=test']
spring.profiles.active=test

that's it.

answered May 02 '23 at 04:12

Shubham K.

93
1
2
13

How to run bootRun with spring profile via gradle task

17 Answers17

Linked

Related