Previous | Next | See Also

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

Prerequisite

The plugin is not bundled with IntelliJ IDEA, but it can be installed from the JetBrains plugin repository as described in Installing, Updating and Uninstalling Repository Plugins and Enabling and Disabling Plugins.

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-specific features in the Application Servers tool window. You can create, start, inspect, stop and delete your Docker containers, deploy your application artifacts, delete unnecessary Docker images, view logs and more.

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 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. Create an artifact configuration for your application.
  5. Build the artifact. You can do that separately (Build | Build Artifacts), or when executing the corresponding run configuration.
  6. Create a Docker Deployment run configuration.
  7. Execute the run configuration.
  8. Use the Application Servers 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.

    01_DockerNewProject

  2. When the project is created, add text (e.g. Hello World!) to index.jsp, see e.g. Developing source code.

    02_DockerIndexJsp

  3. Create a Docker configuration and specify Docker API settings:
    1. Open the Clouds page of the Settings dialog: File | Settings | Build, Execution, Deployment | Clouds.
    2. Click add and select Docker.

      The default settings provided by IntelliJ IDEA should be OK (https://192.168.99.100:2376 for API URL and <your_home_directory>\.docker\machine\certs for the certificates folder).

      03_DockerSettings

    3. Click OK in the Settings 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>.

    04_DockerDockerFile

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

      05_DockerArtifact

    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.

      06_DockerRunConfig

    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.

      06_DockerRunConfig_Container

      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": "0.0.0.0", "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.

    07_DockerRun

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

    08_DockerAppServers

  11. When the artifact is finally deployed, open a web browser and go to http://192.168.99.100:18080/<artifact-name>/ to see the application output.

    09_DockerAppInBrowser

  12. To get an impression of what other functionality is available, look at context menu commands for various items in the Application Servers tool window.

    10_DockerAppServersContextMenu

    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.