IntelliJ IDEA 2016.1 Help


You can add Docker support to IntelliJ IDEA by installing the Docker integration plugin.


Make sure that the following prerequisites are met:

Overview of Docker support

The Docker integration plugin adds the following to IntelliJ IDEA:

  • Docker configurations. These are named sets of settings for accessing the Docker Remote API.
  • Docker Deployment run/debug configurations. They let you download and build Docker images, create and start Docker containers, and deploy your application artifacts into the containers. Application debugging is supported only for Java.
  • Docker tool window that lets you manage your Docker images and containers.
  • Docker Registry configurations that represent your Docker image repository user accounts.

Working with Docker: Process overview

  1. Install Docker and start the Docker daemon (on Windows and OS X - along with the Docker VM in which it runs). For corresponding instructions, see Get Started with Docker.
  2. Install the Docker integration plugin. For instructions, see Installing, Updating and Uninstalling Repository Plugins.

    Note: For the plugin to work properly, IntelliJ IDEA should be started using Java 7 or a later version.

  3. Create a Docker configuration. You can do that:
    • Separately, in the Settings / Preferences dialog: Ctrl+Alt+S | Build, Execution, Deployment | Clouds | add | Docker.
    • When creating a Docker Deployment run configuration: Run | Edit Configurations | add | Docker Deployment, etc.

    See the settings for a Docker configuration.

  4. If you are going to deploy your application into a container, create an artifact configuration for your application and build the artifact (e.g. Build | Build Artifacts).
  5. Create a Docker Deployment run configuration.
  6. Execute the run configuration.
  7. Use the Docker Tool Window to manage your Docker images, containers and deployed applications.

Example: Deploying a web app into the Wildfly Docker container

Once you have installed Docker and the Docker integration plugin, you can try out some of the Docker integration features.

In this example, we'll use the Wildfly app server Docker image to create a container and deploy a one-page JSP application into that container.

  1. Create a project for developing a Java web application (File | New | Project | Java | Web Application, etc.), see e.g Enabling Web app development support when creating a project or module.
  2. When the project is created, add text (e.g. Hello World!) to index.jsp, see e.g. Developing source code.
  3. Create a Docker configuration and specify Docker API settings:
    1. Open the Clouds page of the Settings / Preferences dialog: File | Settings | Build, Execution, Deployment | Clouds on Windows and Linux, or IntelliJ IDEA | Preferences | Build, Execution, Deployment | Clouds on OS X.
    2. Click add and select Docker.

      The default settings provided by IntelliJ IDEA should be OK:

      • API URL:
      • Certificates folder: <your_home_directory>\.docker\machine\machines\default

      The rest of the settings, at the moment, don't matter.

    3. Click OK in the Settings / Preferences dialog.
  4. In the project root directory, create a new directory (e.g. docker-dir): File | New | Directory, etc.

    We'll use this directory to store our Dockerfile, a .war application artifact and a container settings file.

  5. Create a file Dockerfile in the docker-dir directory.
  6. Add the following to your Dockerfile (this is what the file should contain according to the Wildfly image description):
    FROM jboss/wildfly ADD <artifact-name>.war /opt/jboss/wildfly/standalone/deployments/

    Use the actual artifact name in place of <artifact-name>. (On the following picture, the name of the artifact is HelloDocker.)

  7. Create an artifact configuration for your <artifact-name>.war:
    1. Open the Project Structure dialog (e.g. Ctrl+Shift+Alt+S) and select Artifacts.
    2. Click add, select Web Application: Archive and select For '<project-name>:war exploded'.
    3. Change the artifact name (in the Name field). The name should be the same as in your Dockerfile (<artifact-name>) but without .war at the end.
    4. Select the docker-dir directory as the artifact output directory (the Output directory field.) (According to the Wildfly image description, the application .war artifact should be in the same directory as the Dockerfile.)
    5. Click OK in the Project Structure dialog.
  8. Create a Docker Deployment run/debug configuration and specify its settings:
    1. Run | Edit Configurations | add | Docker Deployment.
    2. Server. Select your Docker configuration.
    3. Deployment. Select docker-dir/Dockerfile. This means that the application deployment will be controlled by the corresponding Dockerfile.
    4. Before launch. Click add, select Build Artifacts, and select your <artifact-name> artifact.
    5. Select the Container tab.
    6. JSON file. Generate a sample container settings .json file and save it in docker-dir: click import_icon, select docker-dir and click OK.

      The rest of the settings are optional.

    7. Click OK in the Run/Debug Configurations dialog.
  9. Open container-settings.json in the editor. Note this fragment:
    "HostConfig": { "PortBindings":{ "8080/tcp": [{ "HostIp": "", "HostPort": "18080" }] } }

    This means that the TCP port 8080 inside the container will be available to the outside world as the port 18080.

  10. Execute the run/debug configuration, e.g. by clicking run to the right of the run configuration selector.

    Wait while IntelliJ IDEA downloads and builds the Wildfly image, creates and starts the container, and deploys the artifact into the container. (The Docker tool window opens and corresponding info is output there.)

  11. When the artifact is finally deployed, open a web browser and go to<artifact-name>/ to see the application output.
  12. To get an impression of what other functionality is available, look at context menu commands for various items in the Docker tool window.

    Note that you can also run Bash docker commands. On OS X and Linux you can use the IntelliJ IDEA Terminal tool window for that. On Windows you should use the Bash command-line interpreter available in the Docker Toolbox.

See Also

Last modified: 13 July 2016