Deploying Bitnami/WildFly in Docker with Volume and Port Forwarding

Introduction

Linkedin post

As the technology landscape continues to evolve, containerization has become a crucial aspect of modern software development and deployment. Docker, a leading platform in this space, allows developers to package applications and their dependencies into containers, ensuring consistency across different environments. Bitnami provides ready-to-use application and development stacks, including WildFly, a popular Java application server. This article will guide you through deploying Bitnami/WildFly in Docker using volume and port forwarding, focusing on practical steps and best practices.

Understanding Docker and Bitnami

What is Docker?

Docker is an open-source platform that enables developers to automate the deployment of applications inside lightweight, portable containers. Containers include everything needed to run an application, including the code, runtime, libraries, and system tools. This ensures that applications run consistently across different environments, from development to production.

What is Bitnami?

Bitnami is a library of popular server applications and development environments that can be easily deployed on various platforms, including Docker. Bitnami provides pre-configured application images optimized for ease of use, performance, and security.

What is WildFly?

WildFly is an open-source application server developed by Red Hat, used for running Java applications. It is known for its high performance, reliability, and support for the latest Java Enterprise Edition (EE) specifications.

Setting Up the Environment

Before deploying Bitnami/WildFly in Docker, ensure that you have Docker installed on your system. Follow the instructions on the Docker website to install Docker for your operating system.

Pulling the Bitnami/WildFly Docker Image

Bitnami provides a pre-configured WildFly Docker image that you can use to quickly set up a WildFly server. To pull the Bitnami/WildFly Docker image, use the following command:

docker pull bitnami/wildfly

This command downloads the latest Bitnami/WildFly image from the Docker Hub repository.

Running Bitnami/WildFly with Port Forwarding

Port forwarding is essential when running Docker containers, as it allows you to access services running inside the container from your host machine. WildFly typically runs on port 8080 for web access and port 9990 for management.

To run the Bitnami/WildFly container with port forwarding, use the following command:

docker volume create wildfly_data

• -d: Runs the container in detached mode.

• --name wildfly: Names the container "wildfly".

• -p 8080:8080: Maps port 8080 on the host to port 8080 in the container.

• -p 9990:9990: Maps port 9990 on the host to port 9990 in the container.

Accessing the WildFly Server

After running the container, you can access the WildFly server's web interface by navigating to http://localhost:8080 in your web browser. For management access, go to http://localhost:9990.

Using Volumes for Data Persistence

Docker containers are ephemeral by nature, meaning that any data stored inside a container will be lost if the container is removed. To persist data, you can use Docker volumes, which store data on the host machine.

Creating a Volume

First, create a Docker volume using the following command:

docker run -d --name wildfly -p 8080:8080 -p 9990:9990 -v wildfly_data:/bitnami/wildfly bitnami/wildfly

This command creates a new volume named wildfly_data.

Running WildFly with a Volume

Next, run the Bitnami/WildFly container with the volume attached:

docker run -d --name wildfly -p 8080:8080 -p 9990:9990 -v wildfly_data:/bitnami/wildfly bitnami/wildfly

-v wildfly_data:/bitnami/wildfly: Mounts the wildfly_data volume to the /bitnami/wildfly directory inside the container.

Deploying Applications to WildFly

Once the WildFly server is running, you can deploy Java applications (WAR files) to it. There are several ways to deploy applications to WildFly, including the management console, the command-line interface (CLI), and the deployment directory.

Deploying via the Management Console

1. Access the WildFly management console at http://localhost:9990.

2. Navigate to the "Deployments" section.

3. Click "Add" to upload and deploy your WAR file.

Deploying via the Command-Line Interface (CLI)

Open a terminal and start the WildFly CLI:

docker exec -it wildfly /opt/bitnami/wildfly/bin/jboss-cli.sh --connect

Use the following CLI command to deploy your application:

deploy /path/to/your/application.war

Deploying via the Deployment Directory

You can also deploy applications by placing them in the deployment directory. Copy your WAR file to the /bitnami/wildfly/standalone/deployments directory:

docker cp /path/to/your/application.war wildfly:/bitnami/wildfly/standalone/deployments

WildFly automatically detects and deploys applications placed in this directory.

Managing WildFly Configuration

WildFly's configuration is managed through XML files located in the /bitnami/wildfly/standalone/configuration directory. The main configuration file is standalone.xml.

Editing Configuration Files

To edit configuration files, you can either copy them to your host, make changes, and copy them back, or use a text editor inside the container.

Copying Files to the Host

1. Copy the configuration file to your host machine:

    docker cp wildfly:/bitnami/wildfly/standalone/configuration/standalone.xml /path/to/host/standalone.xml
   

   • Edit the file using your preferred text editor.

   • Copy the modified file back to the container:

       docker cp /path/to/host/standalone.xml wildfly:/bitnami/wildfly/standalone/configuration/standalone.xml
     

     Restart the WildFly container to apply the changes:

       docker restart wildfly
     

     Editing Files Inside the Container

     Alternatively, you can use a text editor inside the container:

     1. Access the container's shell:

         docker exec -it wildfly /bin/bash
        

        Edit the configuration file using a text editor such as vi or nano:

         vi /bitnami/wildfly/standalone/configuration/standalone.xml
        

        Save your changes and restart the container to apply them.

Best Practices for Running WildFly in Docker

1. Use Environment Variables for Configuration

Bitnami/WildFly supports environment variables for configuration. This allows you to configure the container without modifying configuration files directly. For example, you can set the WildFly admin username and password using the following command:

docker run -d --name wildfly -p 8080:8080 -p 9990:9990 -e WILDFLY_USER=admin -e WILDFLY_PASSWORD=adminpassword bitnami/wildfly

2. Monitor Resource Usage

Monitoring the resource usage of your WildFly container is essential for ensuring optimal performance. You can use Docker's built-in monitoring tools to track CPU, memory, and network usage:

docker stats wildfly

3. Backup and Restore Data

Regularly backup your WildFly data to prevent data loss. You can create a backup of your Docker volume using the following command:

docker run --rm -v wildfly_data:/data -v /path/to/backup:/backup busybox tar cvf /backup/wildfly_backup.tar /data

To restore the backup, use the following command:

docker run --rm -v wildfly_data:/data -v /path/to/backup:/backup busybox tar xvf /backup/wildfly_backup.tar -C /

4. Use Docker Compose for Multi-Container Applications

For more complex applications that require multiple containers (e.g., a database and a web server), use Docker Compose to define and manage your multi-container environment. Create a docker-compose.yml file with the following content:

version: '3'
services:
  wildfly:
    image: bitnami/wildfly
    ports:
      - "8080:8080"
      - "9990:9990"
    volumes:
      - wildfly_data:/bitnami/wildfly
    environment:
      - WILDFLY_USER=admin
      - WILDFLY_PASSWORD=adminpassword

volumes:
  wildfly_data:

Start your multi-container application with the following command:

docker-compose up -d

Conclusion

Deploying Bitnami/WildFly in Docker with volume and port forwarding is a powerful way to ensure consistent and efficient application deployment. By following the steps outlined in this guide, you can set up a WildFly server, deploy applications, and manage configurations with ease. Additionally, adhering to best practices will help you maintain a reliable and performant deployment environment. With Docker and Bitnami's pre-configured images, you can streamline your development and deployment processes.