This guide explains how to create a production version of the LuciadFusion Platform, and how to deploy it.
The LuciadFusion Platform is a server application that provides access to published data. The server application is accessed through a client application communicating over the network. The client application can be a desktop application or a browser-based application.
Client applications can communicate directly with the server application. However, it is
recommended to integrate the server application behind a web server, such as
Apache HTTP Server,
with a reverse proxy setup. Many organizations currently have such a setup in place.
It makes the configuration of secured connections to the server easier.
In a reverse proxy setup, direct access to the server by client applications is blocked. The client application uses HTTPS to connect to the reverse proxy server. The reverse proxy server forwards the requests to the LuciadFusion server using plain HTTP, on an internal network. The SSL certificates are managed by the reverse proxy server, the Apache HTTP Server.
The LuciadFusion distribution comes with a deployment build script. Before you can run it, you need to complete a few tasks as preparation.
The build environment prerequisites for deployment are ProGuard and Ant.
The obfuscation tool ProGuard is not included in the LuciadFusion distribution.
You must download it from https://www.guardsquare.com/en/products/proguard.
proguard.jar file in the folder
A sample configuration script for this tool, specific to the obfuscation of the LuciadFusion server, is available in
Refer to Obfuscating your application for more information.
The deployment build script itself is based on Ant. The Ant tool is available within the distribution. No extra steps are needed to set it up.
Due to a bug in ProGuard, the ProGuard 7.0.x versions do not include ant support. Either use a different version of ProGuard or download the ProGuard ant jar yourself.
If deployment size is an issue, you can reduce the deployment package size by approximately 200 MB by excluding the resource
jar containing geoid
metadata. See the commented out exclude attribute in the obfuscate target within
The LuciadFusion requires a deployment license. Copy your deployment license jar
deployment.jar to the
licenses folder. It is picked up by the build script and included in the generated artifact.
The LuciadFusion product stores its configuration in a database. PostgreSQL, Oracle, SQL Server and H2 are supported.
In a production environment, a PostgreSQL, Oracle or SQL Server database is strongly recommended.
For PostgreSQL, see https://www.postgresql.org/ for download and installation instructions. The PostgreSQL user that is initially configured to create the LuciadFusion tables requires the following privileges:
Make sure to enable the
For Oracle, see https://www.oracle.com/database/ for download and installation instructions. The Oracle user that is initially configured to create the LuciadFusion tables requires the following privileges:
CREATE ANY INDEX
DROP ANY TABLE
ALTER ANY INDEX
EXECUTE ANY PROCEDURE
CREATE ANY INDEXTYPE
EXECUTE ANY INDEXTYPE
ALTER ANY INDEXTYPE
DROP ANY INDEXTYPE
SELECT ANY SEQUENCE
CREATE TRIGGER(this is only for 11g)
For SQL Server, see https://www.microsoft.com/en-us/sql-server/default.aspx for download and installation instructions.
The SQL Server database created for LuciadFusion needs to turn the READ_COMMITTED_SNAPSHOT option to true.
The user that is initially configured to create the LuciadFusion tables in that database needs the
db_owner role for that database.
The LuciadFusion distribution comes with a sample setup that uses a
For deployment, you must prepare a
fusion.production profile by modifying the configuration files. They are located in the folder
Copy the file
Modify the properties to match your environment. The documentation for the properties is in the file itself.
You can also add more profile configurations to the
For guidelines regarding the configuration files, see Configuring LuciadFusion Studio.
This is an optional step. The LuciadFusion distribution is organized in such a way that you can make a deployment-ready version of the application without writing custom code.
The Platform customization documentation explains how you can plug custom code into the LuciadFusion server application.
The build script below picks up source code located in the directory
Copy your custom source files in this folder if you want to include them.
Additionally, if your custom code contains Spring annotations or code that requires Java reflection to discover,
make sure that you exclude your custom code from obfuscation (see
which contains a commented out example).
The LuciadFusion distribution offers the UI of the end user application LuciadFusion Studio in English. However, it is organized in such a way that you can easily add UI translations.
How to localize the LuciadFusion Studio UI explains how you can add Studio translations.
The build script picks up the translations located in
Go to the folder
build/fusionplatform and run the deployment build script
deploy_fusionplatform_service for your platform:
Linux and macOS:
The deployment build generates two artifacts in the directory
The build script in the distribution is an example Ant build script that shows how to generate a LuciadFusion server application with a production profile. The configuration for the production profile is explained in Configuring LuciadFusion Studio. In this section, it is assumed that the configuration has been prepared.
The build script provides targets to build LuciadFusion for deployment within a servlet container, Apache Tomcat or Jetty for example, and as a standalone deployment within an embedded servlet container.
You can run the deployment build script without arguments. The default target generates two artifacts, a WAR and a standalone zip archive for example. If you want to control what artifact type is generated, you must specify one of the following build targets as a command line argument.
package:zip: builds the application in such a way that you can start it up as a standalone application using a start script. The application is packaged in a ZIP archive.
package:war: builds the application in such a way that you can deploy it in a servlet container like Apache Tomcat or Jetty. The application is packaged as a WAR.
package: the main build target of the example build script. It generates both the WAR and the ZIP archive.
The deployment build script contains comments that help you create your own automated deployment build process. The build script generates output on the console for your convenience.
You need to choose the artifact depending on your deployment options.
To deploy in a servlet container, Apache Tomcat for example, use
LuciadFusionPlatform.war, a web archive ready for deployment. The requirement for the servlet container is that it must support the servlet 3.1 specification. If you deploy in a default configuration of Apache Tomcat, you can start using the LuciadFusion Studio web application for configuration of the server. You can find it at the location http://localhost:8080/LuciadFusionPlatform/studio. The web archive artifact will be needed in the majority of the cases.
To deploy the server application in a standalone version, use
LuciadFusionPlatform.zip. It offers a start-up script using an embedded Jetty servlet container. Extract the zip archive and start the LuciadFusion Platform server by running the script
StartFusionPlatformServer. The Studio web application to configure the server is available at the location http://localhost:8080/studio. This artifact is useful mainly for local deployment.
This option allows you to still fine-tune the configuration (
application-fusion.production.yml) in the
resourcesdirectory, if necessary. Changes come into effect when the application is restarted.