IntelliJ IDEA 2021.2 Help

Run targets

You can run your code in another environment such as cloud or a Docker 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 heavily depends on the environment.

Running the app directly in such environment also spares you the extra actions normally required to deploy and run the app every time something changes.

The environment that is 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 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 can run on a remote target:

Create a run/debug configuration

  1. From the main menu, select Run | Edit Configurations. Alternatively, press Alt+Shift+F10, then 0.

    Edit rcs

  2. In the Run/Debug Configuration dialog, click the Add button the Add button on the toolbar or press Alt+Insert. The list shows the run/debug configuration templates.

  3. Select one of the supported 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 instructions on configuring a particular target type, refer to the following procedures:

Run

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.

    Run rc 1

  2. Click The Run button or press Shift+F10.

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, profile, and measure coverage for Java applications that run on a target in the exact same way as when they run locally.

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

  1. Select if you want to use an existing SSH configuration or create a new one:

    Select an existing SSH configuration from the SSH list, then click Next. For instructions on how to configure an SSH configuration, refer to Create SSH configurations.

    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 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.

  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.

    Run targets ssh introspection

  3. Configure the following properties:

    • Use rsync: toggle this option to use rsync 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 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 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.

    Run targets ssh runtime

Docker

  1. Select or configure a Docker server as described in Enable Docker support.

  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 details, refer to official Docker documentation.

  3. Select if you want to build an image locally or pull it from Docker registry.

    • 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. Similar to using the --build-arg option with docker build.

    • Run options: specify arbitrary options for the docker run command.

    • 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.

  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, for some reason, 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.

Last modified: 02 August 2022
List of run/debug configuration templates Debug code