337

I have 5 environments:

 - local (my development machine)
 - dev
 - qc
 - uat
 - live
 - staging

I want different application properties to be used for each environment, so I have the following properties files each which have a different URL for the datasource:

 - application.properties  (containing common properties)
 - application-local.properties
 - application-dev.properties
 - application-qc.properties
 - application-uat.properties
 - application-live.properties

I am using IntelliJ and running my app using bootRun in the Gradle plugin on my local machine. I will be using deploying the same application war file on all other environments which run Tomcat.

I have tried adding:

--spring.profiles.active=local

to the run configuration under script parameters.

I have tried adding

-Dspring.profiles.active=local

to the run configuration under VM options.

Neither work. I keep seeing the INFO message on startup say: No active profile set, falling back to default profiles: default

If I run my app from the windows command line using 

gradle bootRun

but I first set the environment variable 

set SPRING_PROFILES_ACTIVE=local

Then everything works.

So my question is, how do I activate my local spring boot profile when running bootRun from IntelliJ ?

Improve this question
6
  • 1
    Why are you running the application via gradle there? Wouldn't it be 10 times more convenient to use the run configuration? There's a field where you can set the profiles to enable... Commented Sep 28, 2016 at 6:40
  • 1
    I am using the run configuration in IntelliJ, as explained above. It's not working. Commented Sep 28, 2016 at 6:47
  • 2
    No you're not. What I am talking about is the "Spring Boot run configuration" Run -> Edit configuration > New > Spring Boot. Commented Sep 28, 2016 at 6:50
  • Aah yes, I moved away from Spring Boot run configuration as I needed to expand project.properties into application.properties in my build.gradle and if I used the Spring Boot run configuration, it didn't seem to work. I'll look into resolving that issue and then perhaps I can simply use the active profile field as you suggested Commented Sep 28, 2016 at 6:57
  • 1
    Using the Spring Boot configuration seems more trouble than its worth. The 'Make' simply copies across the resources and doesn't filter/alter them as per by build script. Then telling it to run the 'build' from gradle instead of 'make' simply causes the run to freeze. If I use bootRun instead, along with my environment entry as per below answer, all works fine. Commented Sep 28, 2016 at 7:08

20 Answers 20

Reset to default
493

I added -Dspring.profiles.active=test to VM Options and then re-ran that configuration. It worked perfectly.

This can be set by

  • Choosing Run | Edit Configurations...
  • Go to the Configuration tab
  • Expand the Environment section to reveal VM options
Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

It doesn't work for me too. I use gradle and two modules (api and ui)
Doesn't work for me either, also using gradle here.
HI, I have the same issue but this fix does not fix the issue. what is meant here by reran the configuration? is it as just as rerunning the task?
This works only for configurations of type "Application" (running the public static main method). It will not work if your configuration is of type maven or gradle (mvn spring-boot:run)
Usually, spring.profiles.include is preferrable, because spring.profiles.active also disables other profiles. Deactivating default profiles might be undesired.
|
136

If you actually make use of Spring Boot run configurations (currently only supported in the Ultimate Edition) it's easy to pre-configure the profiles in "Active Profiles" setting.

enter image description here

Improve this answer

5 Comments

Thanks, I'm sure this would work, however I am not using the Spring Boot run configuration, I am using the Gradle run configuration which doesn't have the "Active Profiles" field. My gradle build filters and modifies some of the properties files it copies to the build directory, so I am using the Grade run configuration for this.
As an above answer pointed out: if this isn't working for you, ensure that you're passing in the args in your Application.main() eg SpringApplication.run( Application.class, args );
This feature is supported in the Ultimate edition only.
Thanks @JulienMalige for pointing this out. I will edit my answer.
You can use a comma separate list of them as you would in the cli so for example default, staging. The far right takes highest precedence so for example foo=bar (default) and foo=baz (staging), will result in foo=baz
103

Tested with IntelliJ Community edition 2021.x

You can create Multiple configurations, one each for a specific profile, In my case below, I have created a dev config with dev profile environment variable.

  1. Goto Run > Edit Configuration
  2. Choose the configuration you want to edit, in the left under Application.
  3. On the right side > Under Environment Variable, update spring.profiles.active=<your profile name> example spring.profiles.active=dev (observer:- the variable should be without -D flag)
  4. Save the changes and Run the Spring boot app with the same configuration.

Note:- You can also create a new configuration or copy existing in step 2 above, using the option available in the same panel.

enter image description here

Improve this answer

2 Comments

This answer worked for me, I'm using the gradle bootRun configuration on Spring Boot 2.4.2 and the other answers would not change my active profile. Thanks!
Only this one works for non-springboot app
49

Spring Boot seems had changed the way of reading the VM options as it evolves. Here's some way to try when you launch an application in Intellij and want to active some profile:

1. Change VM options

Open "Edit configuration" in "Run", and in "VM options", add: -Dspring.profiles.active=local

It actually works with one project of mine with Spring Boot v2.0.3.RELEASE and Spring v5.0.7.RELEASE, but not with another project with Spring Boot v2.1.1.RELEASE and Spring v5.1.3.RELEASE.

Also, when running with Maven or JAR, people mentioned this:

mvn spring-boot:run -Drun.profiles=dev

or 

java -jar -Dspring.profiles.active=dev XXX.jar

(See here: how to use Spring Boot profiles)

2. Passing JVM args

It is mentioned somewhere, that Spring changes the way of launching the process of applications if you specify some JVM options; it forks another process and will not pass the arg it received so this does not work. The only way to pass args to it, is:

mvn spring-boot:run -Dspring-boot.run.jvmArguments="..."

Again, this is for Maven. https://docs.spring.io/spring-boot/docs/current/maven-plugin/examples/run-debug.html

3. Setting (application) env var

What works for me for the second project, was setting the environment variable, as mentioned in some answer above: "Edit configuration" - "Environment variable", and:

SPRING_PROFILES_ACTIVE=local
Improve this answer

5 Comments

The env var should actually be SPRING_PROFILES_ACTIVE.
I added it in "Run configuration" of IDEA "VM options" like "spring.profiles.active" and it works. Maybe another form like urs is used system-wide in system properties?
If you're adding it to ~/.profile or similar, you have to use SPRING_PROFILES_ACTIVE -- spring.profiles.active likely only works as an argument on the command line.
Ah.. so you mean the same as I suspected; real system env not just the application env. OK I make an edit.
This answer is very concise and complete
18

Try add this command in your build.gradle

enter image description here

So for running configure that shape:

enter image description here

Improve this answer

1 Comment

doesn't work for me
11

I ended up adding the following to my build.gradle:

bootRun {
  environment SPRING_PROFILES_ACTIVE: environment.SPRING_PROFILES_ACTIVE ?: "local"
}

test {
  environment SPRING_PROFILES_ACTIVE: environment.SPRING_PROFILES_ACTIVE ?: "test"
}

So now when running bootRun from IntelliJ, it defaults to the "local" profile.

On our other environments, we will simply set the 'SPRING_PROFILES_ACTIVE' environment variable in Tomcat.

I got this from a comment found here: https://github.com/spring-projects/spring-boot/pull/592

Improve this answer

Comments

11

For Spring Boot 2.1.0 and later you can use

mvn spring-boot:run -Dspring-boot.run.profiles=foo,bar

Improve this answer

2 Comments

In your commandline will be spring-boot:run -Dspring-boot.run.profiles=local
with spring-boot:run this is the answer
7

A probable cause could be that you do not pass the command line parameters into the applications main method. I made the same mistake some weeks ago.

public static final void main(String... args) {
    SpringApplication.run(Application.class, args);
}
Improve this answer

2 Comments

Thanks for the reply and suggestion, however I am passing the arguments in.
This actually fixed my problem. For some reason when I created the project using Gradle, it didn't auto-generate my Application class so did it by hand from memory. Missed the args step, and so the "Active Profiles" box in the run configuration didn't work -- I had to manually pass in -Dspring.profiles.active in the VM options box.
7

This is worked for me Intellij Ultimate version 2022.3.

===== Step 1 =====

go to Run > Edit Configurations enter image description here

===== Step 2 =====

first I created a dev profile using application-dev.properties file in resources directory. you can see below popup window. enter image description here

===== Step 3 =====

Now click click Modify Option section under Build and run section to enable Environmental variables.

OR

simple you can use ALT + E shortcut for that. enter image description here

===== Step 4 =====

Now you can see like below and you can enable spring profiles(in this dev profile) using SPRING_PROFILES_ACTIVE=dev. enter image description here

Click on apply and ok and run the application.

Improve this answer

Comments

6

You can pass it in 2 ways

One from environment variable

spring.profiles.active=local

Edit configurations -> Under your environment variable section add this. property

And, as VM or Program argument

-Dspring-boot.run.profiles=local

Edit configurations -> Under your VM Arguments section add this property.

Refer the sample Sample Intellij Run Configuration

Improve this answer

Comments

3

I use the Intellij Community Edition. Go to the "Run/Debug Configurations" > Runner tab > Environment variables > click button "...". Add: SPRING_PROFILES_ACTIVE = local

spring.profiles.active

Improve this answer

Comments

3

In my case I used below configuration at VM options in IntelliJ , it was not picking the local configurations but after a restart of IntelliJ it picked configuration details from IntelliJ and service started running.

-Dspring.profiles.active=local
Improve this answer

Comments

3

So for resuming...

If you have the IntelliJ Ultimate the correct answer is the one provided by Daniel Bubenheim

But if you don't, create in Run->Edit Configurations and in Configuration tab add the next Environment variable:

SPRING_PROFILES_ACTIVE=profilename

And to execute the jar do:

java -jar -Dspring.profiles.active=profilename XXX.jar
Improve this answer

Comments

1

Replace your profile name with BE

You can try the above way to activate a profile

Improve this answer

Comments

1

VM option is hidden by default. Here is the right way to do it

Run->Edit Configurations->Select the application on the left menu->Add VM Options enter image description here

and then add

-Dspring.profiles.active=<profile_name>

Replace the <profile_name> with the profile, say local

Click Apply & OK.

Improve this answer

Comments

0

Try this. Edit your build.gradle file as followed.

ext { profile = project.hasProperty('profile') ? project['profile'] : 'local' }
Improve this answer

Comments

0

Here are 2 ways

  1. Using gradle project property

In build.gradle, add

bootRun{
//https://github.com/spring-projects/spring-boot/pull/592#issuecomment-880263914
    if (project.hasProperty('profiles')) {
        environment SPRING_PROFILES_ACTIVE: profiles
    } else {
        def profiles = 'dev'
        environment SPRING_PROFILES_ACTIVE: profiles
    }
}

In intellij gradle configuration, change the value "test" in "-Pprofiles" as appropriate to environment you want to run

enter image description here

  1. Using environment property

Follow answer by @Hubert https://stackoverflow.com/a/39749545/3333878

And configure the run configuration as

enter image description here

Improve this answer

Comments

0

Create files properties like these

application.properties
application-dev.properties
application-prod.properties

then run

enter image description here

Improve this answer

3 Comments

How can I enable this 'Active profiles' option as I can't see it by default.
When you put application / compiled source code to environment A, profile default is A. When you put application / compiled source code to environment B, profile default is B.
Functionality with 'active profiles' is enabled only on IDEA Ultimate version. On community version there is not possible to set like that.
0

If you have base classes for integration and unit tests, which you should be doing for different reasons, you can add code to automatically set the profile if it's not specified. For example:

public class BaseIT {

    static {
        setProfileToTestIfEmpty();
    }

    private static void setProfileToTestIfEmpty() {
        if (System.getProperty("spring.profiles.active") == null) {
            System.setProperty("spring.profiles.active", "test");
        }
    }
}
Improve this answer

Comments

-5

Set -Dspring.profiles.active=local under program arguments.

Improve this answer

4 Comments

I have removed the quotes from my question above. I am not actually using quotes, I was just trying to show exactly what I was putting into the run configuration fields
you mean VM options!
This answer is very misleading as program arguments won't be recognized by the application!
This answer will not work, as mentioned by other folks, it should be under VM Options in IntelliJ Idea and not in the program arguments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.