Connecting Docker with IntelliJ for Grails Framework Development

Learn how to seamlessly connect Docker with IntelliJ IDEA for Grails framework development. This comprehensive guide covers setup, configurations, Dockerfile creation, debugging, and best practices with detailed code examples. Perfect for Grails developers!

Docker is an essential tool for modern development, providing a containerized environment that simplifies dependency management and enhances portability. If you’re working with the Grails framework and using IntelliJ IDEA, connecting Docker can streamline your development workflow. This blog walks you through the entire process of setting up Docker with IntelliJ for a Grails project, including configurations and best practices.

Prerequisites

Before starting, ensure you have the following installed and set up:

1. Docker
   Download Docker Desktop from Docker’s official site, install it, and ensure it’s running. Verify the installation by running: docker --version
2. IntelliJ IDEA Ultimate
   Docker support is only available in IntelliJ IDEA Ultimate. Install the Docker plugin via the plugin marketplace in IntelliJ.
3. Grails Framework
   Ensure that Grails is installed in your project. You can set it up using SDKMAN or by downloading it from grails.org.
4. Java Development Kit (JDK)
   Grails requires Java. Install the latest version of the JDK and configure the JAVA_HOME environment variable.

Step 1: Setting Up Docker in IntelliJ

To begin, enable Docker support in IntelliJ:

Navigate to File → Settings → Build, Execution, Deployment → Docker.
Click the + icon to add a new Docker configuration.
Choose Docker for Windows/Mac/Linux based on your system.
Test the connection to ensure IntelliJ can communicate with Docker.

Step 2: Configuring Docker for Your Grails Project

Writing a Dockerfile
The Dockerfile defines the environment for running your Grails application. Create a Dockerfile in the root of your Grails project with the following content:

FROM openjdk:17-jdk-alpine
WORKDIR /app
COPY . .
RUN ./gradlew assemble
EXPOSE 8080
CMD ["./gradlew", "bootRun"]

Configuring Docker-Compose
If your Grails application requires a database or additional services, create a docker-compose.yml file in the project root:

version: '3.8'
services:
  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: grails_db
    ports:
      - "3306:3306"

  app:
    build:
      context: .
    ports:
      - "8080:8080"
    environment:
      DB_HOST: db
      DB_PORT: 3306

Step 3: Configuring the Grails Application

Update your Grails configuration to use environment variables for database connectivity. Modify application.yml as follows:

dataSource:
  url: jdbc:mysql://${DB_HOST:localhost}:${DB_PORT:3306}/grails_db
  username: ${DB_USER:root}
  password: ${DB_PASSWORD:root}

Step 4: Building and Running Docker Containers

Build the Docker image for your Grails application using the following command:

docker build -t grails-app .

Run the containerized application:

docker run -p 8080:8080 -e DB_HOST=db -e DB_PORT=3306 grails-app

If you’re using docker-compose, start all services with:

docker-compose up

Step 5: Integrating Docker with IntelliJ

To run Docker containers directly from IntelliJ:

Open Run/Debug Configurations via Run → Edit Configurations.
Add a new Docker Deployment configuration.
Specify the Dockerfile or docker-compose.yml file.
Add required environment variables, such as DB_HOST and DB_PORT.
Save the configuration and run it from IntelliJ.

Step 6: Debugging Grails in Docker

Debugging a Dockerized Grails application requires additional setup.

Modify the Dockerfile to expose the debug port:

EXPOSE 5005
CMD ["./gradlew", "bootRun", "--debug-jvm"]

In IntelliJ, create a Remote JVM Debug configuration:
Set the host to localhost and port to 5005.

Run the container with debugging enabled:

docker run -p 8080:8080 -p 5005:5005 grails-app

Attach the IntelliJ debugger to the running container.

Step 7: Best Practices

Use Multi-Stage Builds
Optimize your Dockerfile for smaller image sizes:

FROM openjdk:17-jdk-alpine as builder
WORKDIR /app
COPY . .
RUN ./gradlew assemble

FROM openjdk:17-jre-alpine
WORKDIR /app
COPY --from=builder /app/build/libs/*.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

Profiles for Docker
Use separate profiles in application.yml for local and Docker environments.

Volume Mounts
Use volume mounts in docker-compose.yml to sync code changes without rebuilding the image:

volumes:
  - ./src:/app/src

Conclusion

Integrating Docker with IntelliJ for Grails framework development simplifies managing dependencies, improves debugging, and ensures a consistent development environment. By following this guide, you can fully leverage Docker’s capabilities while developing and debugging your Grails applications in IntelliJ.

Happy coding!

If you’re interested in exploring more grails framework resources and diving deeper into its features, click on this link to access additional tutorials, guides, and examples that will help you master grails framework!