Nuix SDK – Configuring Nuix RESTful Service

Getting Started: SSL Configuration

Thu, 29 Jul 2021 00:00:00 +0000

To ensure that all communications within Nuix RESTful Service are protected, Secure Sockets Layer (SSL) should be enabled before using the application in a production environment.

Before You Begin

It is recommended that SSL be implemented with a valid certificate obtained from a trusted Certificate Authority (CA).

To enable SSL, Nuix RESTful Service requires:

A PKCS12 (Recommended) or JKS keystore
A PEM or DER based certificate

Generating a Self-Signed Certificate

Certificates being used in a production environment should be obtained and signed by a trusted Certificate Authority (CA). In some circumstances, however, it may be necessary to generate a self-signed certificate for testing purposes.

Use the following procedure to generate a self-signed PKCS12 based keystore for use with Nuix RESTful Service.

From a command prompt, navigate to the Java installation directory used by Nuix RESTful Service:
- Windows: C:\Program Files\Common Files\i4j_jres\11.0.3\bin
- Linux: $JAVA_HOME/bin

Run the following command to generate the keystore.

keytool -genkeypair -alias nuixrest -keyalg RSA -keysize 4096 -storetype PKCS12 -keystore nuixrest.p12 -validity 3650 -storepass changeit -keypass changeit

Proceed to Enableing SSL to complete the configuration.

Importing a PEM Certificate to a PKCS12 Keystore

If using a certificate from a trusted CA, use the following procedure to import the PEM based key and certificate to the PKCS12 keystore:

Note

Ensure that an OpenSSL Binary has been download and installed before proceeding

From a command prompt with elevated privileges, enter the following command:

openssl pkcs12 -export -out nuixrest.p12 -inkey privkey.pem -in cert.pem -name nuixrest

Proceed to Enableing SSL to complete the configuration.

Enabling SSL

Use the following procedure to enable SSL for Nuix RESTful Service after importing your certificate to the keystore:

Navigate to the following location within the Nuix RESTful Service installation directory.
- Windows default: C:\Program Files\Nuix\Nuix RESTful Service\settings
- Linux default: /opt/nuix-restful-service/settings
Using a text editor, open application.properties.

Update the values of the following existing properties to provide the details of your keystore and enable SSL:

server.port=8443
server.ssl.key-store=/path/to/generated/keystore/nuixrest.p12
server.ssl.key-store-password=changeit
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=nuixrest
server.ssl.key-password=changeit
server.ssl.enabled-protocols=TLSv1.2

Save the file and exit.
Restart Nuix RESTful Service for the changes to take effect.

After restarting, Nuix RESTful Service will be accessible at the following URL: https://127.0.0.1:8443/nuix-restful-service/svc/docs

Note

If using a self-signed certificate, the Nuix RESTful Service reference documentation will not be accessible if using a Chrome based browser.

Getting Started: Licensing Configuration

Fri, 16 Jul 2021 00:00:00 +0000

During installation, Nuix RESTful Service can be configured to acquire licenses from either an available Nuix Management Server (NMS) or the Nuix Cloud License Server (CLS). After installation, you may need to eventually update the URL, server type, or credentials being used to acquire licenses. Use the details within this topic to update your license server connection information.

Nuix RESTful Service supports the following four license server types:

Nuix Management Server (NMS)

Acquire licenses directly from an NMS instance.
Relay server with NMS users

Connect to an NMS instance configured as a relay server to acquire licenses from CLS using NMS user authentication.
Relay server with CLS users

Connect to an NMS instance configured as a relay server to acquire licenses from CLS using CLS user authentication.
Cloud License Server (CLS)

Acquire licenses directly from CLS.

Note

For more information on CLS or how to configuring NMS as a relay server, see the Cloud License Server Getting Started Guide.

Updating License Server Configurations

Use the following procedure to update the license server configuration of your Nuix RESTful Service installation:

Prerequisites:

If configuring CLS for licensing, you must have a valid CLS user account and credentials to connect to the Nuix CLS portal (https://my.nuix.com).
Ensure that Nuix RESTful service is not running by closing the application or stopping the service before proceeding.

Configuration:

Navigate to the settings directory within the location where Nuix RESTful Service is installed.
- Windows: C:\Program Files\Nuix\Nuix RESTful Service\settings
- Debian/Ubuntu: /opt/nuix-restful-service/settings
Locate and open the application.properties file within a text editor.
Update the following properties with values based on the license server type being used.
nuix.license.source=
Specify the server type to use. Valid values include:
- server - Nuix Management Server (NMS)
- local-relay-server-local-users - Relay server with NMS users
- local-relay-server-cls-users - Relay server with CLS users
- cloud-server - Cloud License Server (CLS)
nuix.registry.servers=

The URL of the licensing server being used. To connect to CLS, specify licence-api.nuix.com.
Save and exit the file.
Restart Nuix RESTful Service for the changes to take effect.

If the credentials for accessing the license server have changed, proceeded to the next section.

Updating License Server Credentials

The stored credentials used to access your configured license server can be updated directly using the API. Use the following procedure to update the credentials associated with your specific NMS or CLS connection:

Submit a request to the /authenticatedUsers/login endpoint to log in and acquire a license using your updated credentials.

curl -L -X PUT 'http://127.0.0.1:8080/nuix-restful-service/svc/authenticatedUsers/login' \
-H 'Content-Type: application/json' \
--data-raw '{
    "username": "user1",
    "password": "newPassword",
    "licenseShortName": "enterprise-workstation",
    "workers": 2
}'

{
  "username": "user1",
  "authToken": "49e225d7-b88d-4d1b-9cbc-296e83706a60",
  "licenseShortName": "enterprise-workstation",
  "workersGranted": 1
}

Using the acquired authentication token, call the licenseServer/credentials endpoint, providing your updated license server credentials.

curl --location --request PUT 'localhost:8080/nuix-restful-service/svc/v1/licenseServer/credentials' \
--header 'Content-Type: application/json' \
--header 'nuix-auth-token: 49e225d7-b88d-4d1b-9cbc-296e83706a60' \
--data-raw '{
  "username": "user1",
  "password": "newPassword"
}'

{
    "message": "Success.",
    "status": "PERSISTENT"
}

If the call is made successfully, and the provided credentials are valid, the password will be encrypted and the following properties within the application.properties file will be automatically updated, replacing any previous values

nuix.license.server.username=

Username of the CLS or NMS account being used for license acquisition.
nuix.license.server.securePassword=

The encrypted password associated with the license server username.

Getting Started: Application Settings

Thu, 06 May 2021 00:00:00 +0000

Application Properties

Configurable properties for the Nuix RESTful Service application are located within the application.properties file. To access this file, navigate to the settings directory within the Nuix RESTful Service installation directory.

Windows default: C:\Program Files\Nuix\Nuix RESTful Service\settings
Linux default: /opt/nuix-restful-service/settings

After modifying the file, restart Nuix RESTful Service for the changes to take effect.

Setting	Description	Example
autoMigrateCases	When set to `true`, cases will be automatically migrated to the current installed version of the Nuix Engine when opened.	false
asyncFunctionResultRetention	The length of time in milliseconds to retain the results of asynchronous functions.	300000
cluster.enabled	Set to `true` to enable clustering on an instance of Nuix RESTful Service.	false
cluster.license	License to acquire when operating in a cluster for non-worker based operations. (Optional)
cluster.roles	A list of cluster roles. Set to `producer`, `consumer`, or `producer,consumer` to configure the node role in a cluster. Only valid when `cluster.enabled=true`.
configurationFolder	The location where REST application configuration files are stored.	/settings
cors.allow.origin	A comma-separated list of permitted cross origin hosts. A value of `*` allows all domains.	*
closeCasesIfIdleInMinutes	The length of time a case can remain idle before being automatically closed. If set to `0`, idle cases will never close automatically.	10
function.queue.pause.timeout	The length of time in minutes that the asynchronous function queue will pause when paused.	5
hazelcastTcpIpMembers	A comma-separated list of IP addresses that identifies all nodes included in a cluster. Only valid when `cluster.enabled=true`.	192.168.111.60,192.168.111.61
ignoreDerbyCases	Disallows the creation of Derby cases.	false
inventoryLocations	A comma-separated list of directory paths where cases are stored.	/cases
inventoryRefresh	The length of time in milliseconds to wait before checking the case inventory for updates.	60000
exportsFolder	The location where exports are saved.	/exports
logging.config	The location of the Logback configuration file.	settings/logback.xml
logging.json.enabled	Set to `true` to enable the generation of REST logs in JSON format. This format is easier to process in applications like Filebeat.	false
logging.file.name	The name of the file where logs are output.	nuix-rest.log
maxItemTextLength	The maximum number of characters to return for each item. If no value is set, all item text is returned.
nuix.engine.path	The location where the Nuix Engine is installed.	/nuix-engine
nuix.engine.userDataDirs	A comma-separated list of paths to the Nuix Engine user-data directories.	user-data,shared-user-data
nuix.logdir	The location where Nuix worker logs are stored.	/logs
nuix.registry.servers	The URL of a Nuix Management Server (NMS) or Nuix Cloud License Server (CLS).	licence-api.nuix.com (CLS)
nuix.license.source	The method being used for license acquisition. See Licensing Configuration for additional information on configuring different license sources.	`server` = NMS `cloud-server` = CLS
nuix.license.server.username	The username of an NMS or CLS account, determined by `nuix.license.source`, that will be used to perform license checks.
nuix.license.server.password	The plaintext password of the licensing user. Use this property when changing the password of your licensing user. Note: After restarting the application, the password is encrypted and saved to `nuix.license.server.securePassword` and the plaintext value is cleared.
nuix.license.server.securePassword	The encrypted password of the licensing user. Note: If a new password is entered for `nuix.license.server.password`, the value of this property will be automatically updated for the new password once the application is restarted.
pathToResources	The location of the resources directory. The specified directory path should include the queryValidationCase, which is included during installation.	/resources
publicURL	The domain URL of the Nuix RESTful Service application.	http://localhost:nuix-restful-service/svc:8080
returnNuixLicenseIfIdleInMinutes	The length of time a user can remain idle before being logged out and the license is reclaimed. Setting a value of `0` will cause sessions not to expire when idle.	30
searchThumbnailsExportDirectory	The location where thumbnails are stored.	/thumbnails
serverId	A unique identifier for the Nuix RESTful Service instance.	rest-1
server.name	A name for the Nuix RESTful Service instance.	worker-1
server.port	The port the application listens on.	8080
server.tags	A comma separated list of tags to identify a node within a clustered environment. See Clustering server tags for additional information.	coordinator,worker
server.servlet.context-path	The `context path` is the name of the URL at which the Nuix RESTful Service application is accessed.	/nuix-restful-service/svc
server.tomcat.basedir	The base directory where Apache Tomcat® is located.	INSTALLATION_DIRECTORY
server.tomcat.accesslog.buffered	Whether to buffer output such that it is flushed only periodically.	false
server.tomcat.accesslog.directory	The location where access logs are written.	/logs
server.tomcat.accesslog.enabled	Enable or Disable the creation of access logs.	false
server.tomcat.accesslog.prefix	Access log prefix.	nuix_rest_access_log
spring.http.multipart.max-file-size	The maximum upload size for multipart/form-data.	1000MB
spring.http.multipart.max-request-size	The maximum request size for multipart/form-data.	1000MB
threadpool.asyncfunction	Control the number of threads available for asynchronous functions.	4
threadpool.nativesearch	Control the number of threads available to marshal search items.	10
threadpool.searchUnsortedManager	Control the number of threads available for unsorted search functions.	4
threadpool.searchUnsorted	Control the number of threads available to marshal unsorted search items.	4
userScriptsLocation	The location where user scripts are read from for execution.	/user-scripts

JVM Arguments

The following Java Virtual Machine (JVM) settings are included in the default configuration of Nuix RESTful Service. To access these settings, locate the following file within the Nuix RESTful Service installation directory.

Windows default: C:\Program Files\Nuix\Nuix RESTful Service\Nuix-REST.vmoptions
Linux default: /opt/nuix-restful-service/Nuix-REST.vmoptions

After modifying the file, restart Nuix RESTful Service for the changes to take effect.

Setting	Description	Default
-Xmx	Sets the maximum Java heap size.	6G
-XX:+UseParallelGC	Enable parallel garbage collection. This setting is recommended for improved performance.
-Djna.nosys	Require Java Native Access (JNA) to only load native libraries and ignore system libraries.	true
-Djava.io.tmpdir	The temporary directory used by the Java Virtual Machine (JVM) to create and store temporary files.	$INSTALLATION_DIRECTORY/temp
-Dnuix.investigator.bulkProcessingTemp	The temporary directory used for bulk processing operations (populating stores, OCR, etc).	$INSTALLATION_DIRECTORY/temp/bulk
-Dnuix.worker.tmpdir	The default temporary directory used by workers.	$INSTALLATION_DIRECTORY/temp/worker
-Dspring.config.location	The location where the application.properties file is stored.	$INSTALLATION_DIRECTORY/settings
-Dnuix.worker.jvm.arguments	JVM arguments that are applied specifically to Nuix workers.	-Dlog4j.configuration= file:$INSTALLATION_DIRECTORY/nuix-engine/config/log4j.properties

Getting Started: Clustering

Thu, 22 Apr 2021 00:00:00 +0000

Important

Pilot Program Only - Not GA until Nuix 10.0. Please direct all inquires regarding the Pilot Program to rest-pilot@nuix.com.

Nuix RESTful Service supports clustered installations to enable distributed workloads across multiple nodes within a cluster. When configured as a cluster, requests submitted to REST are managed and distributed across the cluster with no further action from the user.

Clustering Concepts

A clustered environment consists of two or more Nuix RESTful Service instances that have been configured to communicate and share data with each other over a network. Each instance represents a node within the cluster. Nodes are further classified by roles, which are defined during setup and determine what function the node can perform within the cluster. The following two roles are available.

Producer role: Nodes that are assigned the producer role function as the primary server (base URL) for all calls submitted to the API. Producer nodes are responsible for receiving incoming calls, queuing requests, processing non-cluster-enabled functions, and relaying results from across the cluster back to the user.
Consumer role: Nodes that are assigned the consumer role are responsible for performing the cluster-enabled requests in the job queue based on the node’s capacity and availability.

As requests are submitted to the cluster, they are picked up and processed immediately. If the cluster is at capacity, the requests will instead be added to a queue and processed by the first consumer node that becomes available or gains additional capacity.

Consumer nodes can accept new requests if the following criteria are met:

The request is for a cluster-enabled function.
The request can be performed immediately.
The case associated with a request is available to the node.
The node has capacity, which is defined by the following restrictions:
- Worker-based tasks: Limited to one request per node simultaneously.
- Non-worker-based tasks: Can perform multiple requests simultaneously.
- Based on the resources available to the node, it may be capable of performing both types of requests simultaneously.

If any of the criteria cannot be met by a consumer node, the request will remain in the queue until another node within the cluster becomes available.

Note

Communication between nodes is not encrypted by default.

Server Tags

To optimize and steer the distribution of requests throughout a cluster, server tags can be implemented to control the type of requests that are performed by specific nodes. Server tags are simple user-defined labels, such as OCR or Worker-Based, that are applied to consumer nodes during clustering setup.

Once configured, requests that are submitted with a specific server tag will be routed to and processed by a node that has a matching tag. Requests submitted without a tag will continue to be processed by the first available consumer node.

Warning

Requests that are submitted with a server tag that does not exist within the cluster will never be processed.

To identify server tags that exist within the cluster before submitting a request, see Viewing the Cluster.

The practice of server tagging can be beneficial if trying to prioritize calls that are submitted to the API. For instance, separating worker-based requests from non-worker-based requests. Functions that require workers, such as ingestion, OCR, and exports can often be long running resource intensive processes. By using server tags, these types of requests can be steered towards dedicated nodes within the cluster that are better provisioned to handle these types of jobs.

Tip

Nodes that have been configured with server tags are not restricted from processing untagged requests. If a request is submitted to the cluster and a tagged node is the first available node to meet all criteria required to accept a request, it will do so.

Prerequisites for Creating a Cluster

To set up a Nuix RESTful Service clustered environment, the following prerequisites must be addressed.

Two or more installed instances of Nuix RESTful Service.
- The IP addresses of all nodes included in the cluster must be known to complete the following configurations.
Access to Nuix Licensing using any of the following options:
- Nuix Management Server (NMS)
- Nuix Cloud License Server (CLS)
Networked file storage for shared resources.
Elasticsearch v7.8.1

Important

Only Elasticsearch based cases are supported within clustered environments.

Clustering requires the use of networked file storage to ensure all nodes within the cluster have access to the same data. Before you begin, ensure that a network file share is available and accessible from all nodes included in the Nuix RESTful Service cluster.

Note

The location of all network shares must be accessible using UNC paths.

The following directories must be created and configured as individual network shares:

Share Name	Description
`source data/`	Location to store raw evidence that has not yet been processed into a case.
`cases/`	An Elasticsearch based inventory location where cases are created and stored.
`user-data/`	Location to store artifacts and profiles that are used when processing evidence. The `user-data` directory is comprised of the following sub-directories that each store a different type of artifact. Tip: Create only the subdirectories that will be used in your workflows. `
`exports/`	Location to store exports generated by Nuix RESTful Service.
`thumbnails/`	Location to store thumbnails that are generated within a case.
`scripts/`	Location to store user-generated scripts for use with Nuix RESTful Service.

Configuring REST Instances

After all prerequisites have been addressed, use the following procedure to set up a clustered Nuix RESTful Service environment.

Note

This procedure must be performed on each node within the cluster.

Ensure that the instance of Nuix RESTful Service being modified has been stopped.
Navigate to the settings directory within the Nuix RESTful Service installation.
- Windows: <InstalDir>/Nuix/Nuix RESTful Service/settings
- Linux: /opt/nuix-restful-service/settings
Open the application.properties file within a text editor.
Modify the file by configuring the following properties to enable clustering and identify the role of the node within the cluster.
1. Enable the node to participate in the cluster by adding the following property:
```
cluster.enabled=true
```
2. Add one of the following properties to specify the node’s role within the cluster:
  - Producer role: The primary server for all calls submitted to the API. Producer nodes are responsible for receiving incoming calls, queuing requests, and relaying results from across the cluster back to the user.
  - Consumer role: Consumer nodes are responsible for performing the queued requests based on the node’s availability.
```
cluster.roles=producer
```
  Note: The cluster must contain at least one producer and consumer node.
3. Optionally, define a server tag that can be used to steer requests to this specific node.
```
server.tags=Worker-based
```
  If the node is expected to receive multiple types of requests, a comma separated list of tags can also be defined:
```
server.tags=Worker-based,OCR,Export
```
4. Update the values of the following existing properties to reflect the UNC paths of the network share locations that were previously created .
```
exportsFolder=\\10.130.138.177\exports
inventoryLocations=\\10.130.138.177\cases
searchThumbnailsExportDirectory=\\10.130.138.177\thumbnails
userScriptsLocation=\\10.130.138.177\scripts\
nuix.engine.userDataDirs=\\10.130.138.177\user-data\
```
5. Add the following property to identify nodes within the cluster. Provide a comma-separated list of IP addresses that represent all nodes included within the cluster.
```
hazelcastTcpIpMembers=<IPofNode1>,<IPofNode2>,<IPofNode3>
```
6. Verify that the publicURL property is set to an address that is accessible from all other nodes within the cluster.
Save and exit the file.
Restart Nuix RESTful Service.
Repeat this procedure until all nodes within the cluster have been configured.

Viewing the Cluster

After all nodes within your environment have been configured for clustering, you can check your cluster by submitting a GET request to the /cluster endpoint. This request should be submitted to a node within the cluster that has been configured with the producer role.

curl -L -X GET 'http://10.30.100.58:8080/nuix-restful-service/svc/v1/cluster' \
-H 'nuix-auth-token: 49e225d7-b88d-4d1b-9cbc-296e83706a60'

{
    "nodes": [
        {
            "hostAddress": "192.168.7.32",
            "hostName": "node01.nuix.com",
            "port": 5601,
            "details": {
                "serverId": "637edbff-3e1c-4f63-921e-da022a763fbf",
                "publicURL": "http://10.30.100.58:8080",
                "name": "REST-Node-1",
                "tags": [OCR,Export],
                "guid": "210ee909-3cdf-3f3a-b973-2cf4d7c7aea2"
            }
        },
                {
            "hostAddress": "192.168.7.12",
            "hostName": "node02.nuix.com",
            "port": 5602,
            "details": {
                "serverId": "432iunff-5h1a-8j67-738b-ic9344f643unf",
                "publicURL": "http://10.30.100.83:8080",
                "name": "REST-Node-2",
                "tags": [Worker-based],
                "guid": "468uj828-7uct-6h1s-m878-5hg5d9v6ema1"
            }
        }
    ]
}

After submitting the request, details about each available node are returned, including:

The name and location of the node.
The port where the node is operating.
Any server tags associated with the node.
A unique server GUID, useful for identifying a specific node.

Submitting Requests to the Cluster

When operating within a clustered Nuix RESTful Service environment, the process of submitting requests is no different from interacting with a single instance of Nuix REST.

To get started, you need to know the location of a node within the cluster that has been designated as a Producer. If multiple producers are available, any one can be used. Once identified, all calls to the cluster should be made to that node.

After a request is received, if the call is for a cluster-enabled function, the request will be added to the queue for the first available consumer node to pick up. If the call is for a non-cluster-enabled function, the producer node will simply perform the request itself.

Cluster-enabled functions are those that can be run asynchronously by any consumer node within the cluster. These functions are identified within the embedded API reference documentation (localhost:8080/nuix-restful-service/svc/docs) using the Cluster Enabled Operation label.

Submitting Requests with Server Tags

If server tags have been implemented within your cluster, you can use them in your calls by defining the following RAW data in the body of your requests.

--data-raw 
'{
  "restClusterSettings": {
      "nodeTags": {
          "defaultTags": ["Worker-based"]
      }
  },
}'

Getting Started: Unified Logging with Elasticsearch

Mon, 11 Jan 2021 00:00:00 +0000

Use the following topic to enable unified logging using the Elasticsearch ELK stack.

Prerequisites

Elasticsearch v7.8.1
Filebeat v7.8.1
Kibana v7.8.1
Nuix REST v9.0

This topic assumes that you already have a running instance of Nuix RESTful Service version 9.0 installed at the following location:

Windows: C:\Program Files\Nuix\Nuix RESTful Service
Linux: /opt/nuix-restful-service

The installation and configuration of Elasticsearch and Kibana are outside the scope of this topic.

Note

Before proceeding, ensure that the installed Nuix-REST service is not running.

Windows Filebeat Installation and Configuration

Use the following procedure to install Filebeat on Windows:

Download Filebeat (https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.8.1-windows-x86_64.zip)
Unzip the Filebeat installer to C:\Program Files\Filebeat.
Navigate to the C:\Program Files\Filebeat installation directory.
Rename filebeat.yml to filebeat.yml.backup.

Create a new filebeat.yml file in C:\Program Files\Filebeat and include the following configuration.

Click to View Windows Filebeat Configuration

filebeat.yaml

filebeat.inputs:
  -
  type: log
  enabled: true
  paths:
    - 'C:\Program Files\Nuix\Nuix RESTful Service\logs\**\*.json'
      json.message_key: message
      json.keys_under_root: true
      json.overwrite_keys: true
      json.add_error_key: true
     
  processors:
    - rename:
      fields:
      - from: "file"
      to: "file.source"
      ignore_missing: true
     
  output.elasticsearch:
  hosts: 'masterdata-node-0.elasticsearch.aws.chdev.nuix.com'

Open a command prompt with elevated administrative priviledges and navigate to C:\Program Files\Filebeat.
Enter the following command to install Filebeat in UnRestricted mode. Choose [R] to Run Once.

PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-filebeat.ps1

Filebeat is now installed and configured as a service but is not yet running.

Linux Filebeat Installation and Configuration

Use the following procedure to install Filebeat on Linux:

Download Filebeat using the following command:

curl -L -O https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.10.1-amd64.deb

Install Filebeat using the following command:
```
sudo dpkg -i filebeat-7.8.1-amd64.deb
```
Navigate to the installation directory and create a backup of the Filebeat configuration file:
```
cd /etc/filebeat
sudo mv filebeat.yml filebeat.yml.backup
```

Within the same directory, create a new filebeat.yml file and include the following configuration.

Click to View Linux Filebeat Configuration

filebeat.yaml

filebeat.inputs:
  -
  type: log
  enabled: true
  paths:
    - '/opt/nuix-restful-service/logs/**/*.json'
      json.message_key: message
      json.keys_under_root: true
      json.overwrite_keys: true
      json.add_error_key: true
     
  processors:
    - rename:
      fields:
      - from: "file"
      to: "file.source"
      ignore_missing: true
     
  output.elasticsearch:
  hosts: 'masterdata-node-0.elasticsearch.aws.chdev.nuix.com'

Filebeat is now installed and configured as a service but is not yet running.

Nuix RESTful Service Configuration Changes

Use the following procedures to configure the logging settings within your instance of Nuix RESTful Service.

Application Log Configuration

Navigate to the settings directory within your Nuix RESTful Service installation and locate application.properties.

Windows: C:\Program Files\Nuix\Nuix RESTful Service\settings\application.properties
Linux: /opt/nuix-restful-service/settings/application.properties

Using a text editor with elevated administrative priviledges, open application.properties.
Add the following property to the file to configure Nuix RESTful Service to generate JSON formatted log files.
```
logging.json.enabled=true
```

After adding this property and saving the file, the new defaut log becomes ${logging.path}\nuix-rest.log.json.

Worker Log Configuration

Navigate to the Nuix RESTful Service installation directory and locate the Nuix-REST.vmoptions file.

Windows: C:\Program Files\Nuix\Nuix RESTful Service\Nuix-REST.vmoptions
Linux: /opt/nuix-restful-service/nuix-rest.vmoptions

Using a text editor with elevated administrative priviledges, open Nuix-REST.vmoptions.
Locate the -Dnuix.worker.jvm.arguments property and make the following modification to change its value from log4j.properties to the log4j-logstash.xml configuration that ships with the application. This change configures workers to generate JSON formatted log files.

Windows:

-Dnuix.worker.jvm.arguments=-Dlog4j.configuration=file:/C:/Program%20Files/Nuix/Nuix%20RESTful%20Service/nuix-engine/config/log4j-logstash.xml

Linux:

-Dnuix.worker.jvm.arguments=-Dlog4j.configuration=file:/opt/nuix-restful-service/nuix-engine/config/log4j-logstash.xml

After modifying this property and saving the file, the new default worker log becomes ${logging.path}\job-${UUID}\${UUID2}.

Services

Start up all installed services once Filebeat and Nuix RESTful Service have been installed and configured.

Start the Nuix REST service
- On Linux: sudo service nuix-rest start
Start the Filebeat service
- On Linux: sudo service filebeat start

Log Viewing

Logs can now be viewed using Kibana. The installation and configuration of Kibana is outside the scope of this article, however, you can quickly look at logs if you have Docker installed using the following Docker command:

docker run -it \
    -e ELASTICSEARCH_HOSTS=http://your.elasticsearch.node.com:9200 \
    -p 5601:5601 \
    -e XPACK_SECURITY_ENABLED=false \
    -e MONITORING_ENABLED=false \
    -e XPACK_ML_ENABLED=false \
    -e XPACK_GRAPH_ENABLED=false \
    -e XPACK_REPORTING_ENABLED=false \
    docker.elastic.co/kibana/kibana:7.8.1

In a browser, navigate to http://localhost:5601

Nuix SDK – Configuring Nuix RESTful Service

Getting Started: SSL Configuration

Before You Begin

Generating a Self-Signed Certificate

Importing a PEM Certificate to a PKCS12 Keystore

Note

Enabling SSL

Note

Getting Started: Licensing Configuration

Note

Updating License Server Configurations

Updating License Server Credentials

Getting Started: Application Settings

Application Properties

JVM Arguments

Getting Started: Clustering

Important

Clustering Concepts

Note

Server Tags

Warning

Tip

Prerequisites for Creating a Cluster

Important

Network Share Requirements

Note

Configuring REST Instances

Note

Viewing the Cluster

Submitting Requests to the Cluster

Submitting Requests with Server Tags

Getting Started: Unified Logging with Elasticsearch

Prerequisites

Note

Windows Filebeat Installation and Configuration

filebeat.yaml

Linux Filebeat Installation and Configuration

filebeat.yaml

Nuix RESTful Service Configuration Changes

Application Log Configuration

Worker Log Configuration

Services

Log Viewing