IntelliJ IDEA 2023.2 Help

Run targets

You can run your code in another environment such as cloud or a Docker container directly from IntelliJ IDEA.

For certain run/debug configurations, 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. Go to Run | Edit Configurations. Alternatively, press Alt+Shift+F10, then 0.

  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 more information on configuring a particular target type, refer to the following procedures:

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

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

  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 more information about configuring SSH, 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 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.

    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 more information, 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 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.

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

  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.

Last modified: 08 September 2023
Run shebang scripts Services tool window