# Run targets For certain [run/debug configurations](run-debug-configuration.html), you can run your code in another environment such as cloud or a [Docker](docker.html) container directly from IntelliJ IDEA. This feature allows you to instantly test the changes against the real environment the app is intended for. This ensures that there will be no incompatibilities when moving to production, which is especially important when working on code that depends on the environment. This feature also spares you the extra actions normally required to deploy and run the app every time something changes. ## Prerequisites The environment used for running the app is referred to as target. For IntelliJ IDEA to run code on a target, the target has to define a language runtime, which represents something on the target that can be used by a run/debug configuration to run code. For example, the Application and Maven run/debug configurations would need a JDK and Maven respectively. In order to run your code on a target, all you need is to define the target execution environment in the [run/debug configuration](run-debug-configuration.html) that you would normally use for local run. After you have done that, launching the app on a target is no different than launching it locally. ## Supported run/debug configuration types The following [run/debug configurations](run-debug-configuration.html) can run on a remote target: * [Application](run-debug-configuration-java-application.html) * [JAR Application](compiling-applications.html#package_into_jar) * [JUnit](junit.html) * [Maven](maven-support.html) (debugging, profiling, and coverage not supported) * [Gradle](gradle.html) (debugging, profiling, and coverage not supported) * [Spring Boot](run-debug-configuration-spring-boot.html) * [Quarkus](quarkus.html) * [Micronaut](micronaut.html) ## Create a run/debug configuration Procedure: 1. Go to `Run | Edit Configurations`. Alternatively, press `Alt+Shift+F10` (Windows), `⌃ ⌥ R` (macOS), `⌥ ⇧ F10` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ R` (macOS System Shortcuts), `Alt+Shift+F10` (XWin), `Alt+Shift+F10` (GNOME), `Alt+Shift+F10` (KDE), `Alt+Shift+F10` (Emacs), `Alt+Shift+F10` (Sublime Text), `⌃ ⌥ R` (Sublime Text (macOS)), `Alt+Shift+F10` (NetBeans), `Ctrl+Alt+Shift+R` (Visual Studio), `⌘ ⌥ ⇧ R` (Visual Studio (macOS)), `Alt+Shift+F10` (Eclipse), `⌃ ⌥ R` (Eclipse (macOS)), then `0` (Windows), `0` (macOS), `0` (IntelliJ IDEA Classic (macOS)), `0` (macOS System Shortcuts), `0` (XWin), `0` (GNOME), `0` (KDE), `0` (Emacs), `0` (Sublime Text), `0` (Sublime Text (macOS)), `0` (NetBeans), `0` (Visual Studio), `0` (Visual Studio (macOS)), `0` (Eclipse), `0` (Eclipse (macOS)). 2. In the [Run/Debug Configuration](run-debug-configuration.html) dialog, click the Add button ![the Add button](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.expui.general.add.svg) on the toolbar or press `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Ctrl+N` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `Alt+Insert` (NetBeans), `Ctrl+N` (Visual Studio), `⌘ N` (Visual Studio (macOS)), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)). The list shows the run/debug configuration [templates](run-debug-configuration.html#templates). 3. Select one of the [supported](#supported-rcs) run/debug configuration types. 4. If you have already defined the target, select it from the Run on menu. Otherwise, click Manage targets… to add a new target. For more information on configuring a particular target type, refer to the following procedures: * [SSH](#ssh) * [Docker](#docker) * [WSL](how-to-use-wsl-development-environment-in-product.html#wsl_run_target) You can also configure a run target in a run/debug configuration template, so the next time you create a new configuration of that type, its parameters already have the desired values. For more information, refer to [Configure the default values for a template](run-debug-configuration.html#change-template). ## Run Procedure: Procedure for running the app on a remote target is the same as for running it locally: 1. Select the run/debug configuration on the main toolbar. ![Selecting run configuration from the list](https://resources.jetbrains.com.cn/help/img/idea/2026.2/run_rc_1.png) 2. Click ![The Run button](https://resources.jetbrains.com.cn/help/img/idea/2026.2/app.actions.execute.svg) or press `Shift+F10` (Windows), `⌃ R` (macOS), `⇧ F10` (IntelliJ IDEA Classic (macOS)), `⌥ ⇧ R` (macOS System Shortcuts), `Shift+F10` (XWin), `Shift+F10` (GNOME), `Shift+F10` (KDE), `Shift+F10` (Emacs), `Shift+F10` (Sublime Text), `Shift+F10` (Sublime Text (macOS)), `F6` (NetBeans), `Ctrl+F5` (Visual Studio), `⌃ F5` (Visual Studio (macOS)), `Alt+Shift+X` (Eclipse), `⌘ ⇧ F11` (Eclipse (macOS)). IntelliJ IDEA builds the artifacts and then copies them to the target. After that, it runs the app on the target using the specified runtime. ## Debug, profile, and analyze coverage You can [debug](debugging-code.html), [profile](cpu-and-allocation-profiling-basic-concepts.html), and [measure coverage](code-coverage.html) for Java applications that run on a target in the exact same way as when they run locally. > **Note:** > When you use [Async profiler](profiler-intro.html), the [settings on the Java Profiler page](custom-profiler-configurations.html#async-options) apply to the remote environment. If the target uses a different platform, the settings must be configured accordingly. ## Target types A target describes the configuration of the environment in which the application will run. When you create a remote target, IntelliJ IDEA automatically detects the runtimes available in the remote environment. If required, you can manually configure additional runtimes. ### SSH > **Note:** > FTP/SFTP/WebDAV connectivity plugin is required. Procedure: 1. Select if you want to use an existing SSH configuration or create a new one: Existing: Select an existing SSH configuration from the SSH list, then click Next. For more information about configuring SSH, refer to [Create SSH configurations](create-ssh-configurations.html). New: 1. Enter the IP of the SSH server, the port listening for SSH connections, and the name of the user on the server machine, on whose behalf you are going to run your application. Click Next. 2. Wait for the connection to be established. If there is an agent that has the credentials, no additional configuration will be required. Otherwise, select the authentication method and provide the required values: * Password: enter the password. * Key pair (OpenSSH or PuTTY): To apply this authentication method, you must have a private key on the client machine and a public key on the remote server. IntelliJ IDEA supports private keys that are generated with the [OpenSSH](https://www.openssh.com/) utility. Specify the path to the file where your private key is stored and type the passphrase (if any) in the corresponding fields. To have IntelliJ IDEA remember the passphrase, select the Save passphrase checkbox. Click Next. > **Tip:** > For more information about working with SSH keys, refer to the [Generating a new SSH key and adding it to the ssh-agent](https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/) tutorial. 2. Wait for the SSH server introspection to complete. During this step, IntelliJ IDEA tries to identify the language runtimes available in the environment. Click Next. 3. Configure the following properties: * Use rsync: toggle this option to use [rsync](https://rsync.samba.org) for file transfer. This is recommended as it will generally speed up copying files. * Project path on target: the path on the server that will be used for storing the project files. 4. Add language runtimes . For each runtime, specify its version and path on the server. The configured settings then appear in the Build and run section of the run/debug configuration when you select this environment as the target. The following runtimes are available: * Java: a JDK on the server suitable for running your application. When this runtime type is selected, the application is built locally and then copied to the destination * Maven: Maven installed on the server. When this runtime type is selected, the sources and libraries are copied to the server, and then built and run there. ### Docker > **Note:** > Docker plugin is required. For more information, refer to [Docker run targets](docker-run-targets.html). Procedure: 1. Select or configure a Docker server as described in [Enable Docker support.](docker.html#connect_to_docker) 2. For Windows and macOS – make sure Docker has access to all the folders used in the workflow, for example, the project folder, `.maven`, and so on. For more information, refer to [official Docker documentation](https://docs.docker.com/desktop/). 3. Select if you want to build an image locally or pull it from Docker registry. Build: * Dockerfile: the Dockerfile that will be used for building the image. * Context folder: a folder whose contents will be accessible by the Docker daemon during the build to be later used in the image filesystem. * Rebuild image automatically every time before running code: when this option is set, the image will be rebuilt every time the code is run. Otherwise, IntelliJ IDEA will use the already existing image (if any). Additionally, you can specify the following: * Image tag: specify the name and tag for the built image. Similar to using the `-t` option with `docker build`. * Build options: specify arbitrary options for the `docker build` command. * Build args: [override the default build-time variables](https://docs.docker.com/engine/reference/commandline/build/#set-build-time-variables-build-arg). Similar to using the `--build-arg` option with `docker build`. * Run options: specify arbitrary options for the `docker run` command. > **Note:** > Not all `docker run` options are supported. If you would like to request support for some option, leave a comment in [IDEA-181088](https://youtrack.jetbrains.com/issue/IDEA-181088). Pull: * Image tag: specify the full coordinates for the image to be pulled from a registry. The default `:latest` tag will be used if only repository is specified. * Run options: specify arbitrary options for the `docker run` command. > **Note:** > Not all `docker run` options are supported. If you would like to request support for some option, leave a comment in [IDEA-181088](https://youtrack.jetbrains.com/issue/IDEA-181088). 4. Wait for the container introspection to complete. During this step, IntelliJ IDEA tries to identify the language runtimes available in the environment. Click Next. 5. If required, configure language runtimes. You may need it in when: * you have a complex image (for example with several JDK). The primary runtime will be identified automatically. However, any additional runtimes require manual configuration. * the introspection fails. In most cases, IntelliJ IDEA will correctly identify the primary runtime based on the context from step 1. If this does not happen, manually modify the primary runtime. For each runtime, specify its version and path in the container. The configured runtimes then appear in the Build and run section of the run/debug configuration when you select this environment as the target. The following runtimes are available: * Java: a JDK suitable for running your application. When this runtime type is selected, the application is built locally and then copied to the destination * Maven: Maven in the container. When this runtime type is selected, the sources and libraries are copied to the container, and then built and run there. ### Docker Compose You can use a single Docker Compose service as a run target. > **Note:** > Docker plugin is required. Procedure: 1. Select or configure a Docker server as described in [Enable Docker support.](docker.html#connect_to_docker) 2. For Windows and macOS – make sure Docker has access to all the folders used in the workflow, for example, the project folder, `.maven`, and so on. For more information, refer to [official Docker documentation](https://docs.docker.com/desktop/). 3. Specify the Docker Compose configuration files, select the necessary service, and provide any additional environment variables. Click Next. 4. Wait for the Docker Compose service introspection to complete. During this step, IntelliJ IDEA tries to identify the language runtimes available in the environment. Click Next. 5. If necessary, configure language runtimes. This may be necessary in the following cases: * If you have a complex service with several runtimes, IntelliJ IDEA will identify the primary one automatically. However, any additional runtimes require manual configuration. * If the introspection fails, modify the primary runtime manually. For each runtime, specify its version and path in the container. The configured runtimes then appear in the Build and run section of the run/debug configuration when you select this environment as the target. The following runtimes are available: * Java: If there is a Java runtime available in the container, the application is built locally and then copied to the target. * Maven and Gradle: If there is Maven or Gradle in the container, the sources and libraries are copied to the container, and then built and run there. ## See also ### Related [Create SSH configurations](create-ssh-configurations.html) [Docker run targets](docker-run-targets.html)