> ## Documentation Index
> Fetch the complete documentation index at: https://docs.germainux.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Engine Configuration

> The GermainUX Engine Manager controls all Engine instances deployed on the same host.

Components
[`Engine`](https://docs.germainux.com/main/germain-ux-engine)

Availability
8.6.0 or later

> [card] [Manage the Engine Manager on Linux](#manage-the-engine-manager-on-linux)
>
> Control Engine Manager service

> [card] [Manage individual Engines](#manage-individual-engines)
>
> Enable or disable Engines

> [card] [Validate the configuration](#validate-the-configuration)
>
> Confirm settings took effect

> [card] [Troubleshooting](#troubleshooting)
>
> Resolve Engine config issues

**GermainUX Engine Configuration**

The GermainUX Engine Manager controls all Engine instances deployed on the same host. Administrators can manage the Engine Manager at the operating-system level and control individual Engines centrally through the GermainUX Workspace.

This page explains the day-to-day management of the Engine Manager and its Engines. Memory and proxy settings are covered in their dedicated guides.

## Engine Manager and Engine

| Component | Responsibility |
| - | - |
| Engine Manager | Connects the host to Germain Enterprise and starts, stops, or restarts its Engine instances |
| Engine | Runs the monitoring and automation components assigned to it |

A host normally runs one Engine Manager and one or more Engines. Stopping the Engine Manager also affects its managed Engines.

## Manage the Engine Manager on Windows

On Windows, the Engine Manager runs as a system service.

To manage it:

1. Open the Windows Services console: `services.msc `

   ![Engine Configuration: Manage the Engine Manager on Windows](https://mintcdn.com/germain-ux/8KX3c-GSSWR99tdN/images/main/engine-configuration/image-20201118-203841.png?fit=max\&auto=format\&n=8KX3c-GSSWR99tdN\&q=85\&s=e0f42f37f6659dd7083ff20033a6eb42)
2. Find the GermainUX Engine Manager service.
3. Use the available controls to start, stop, or restart it.
4. Confirm that its status changes to **Running** after startup.

You can also manage it from an administrative Command Prompt:

```text theme={null}
sc query "<engine-manager-service-name>"
sc start "<engine-manager-service-name>"
sc stop "<engine-manager-service-name>"
```

The exact service name depends on the Engine distribution and installation method.

## Manage the Engine Manager on Linux

### Start the Engine Manager manually

From `ENGINE_HOME`, run:

```text theme={null}
nohup bin/startEngineManager.sh &
```

This is suitable for initial validation or troubleshooting. For production, run the Engine Manager through `systemd` or another operating-system service manager.

### Find the Engine Manager process

```text theme={null}
ps -ef | grep apm-engine-manager.jar
```

Identify the Java process running:

```text theme={null}
apm-engine-manager.jar
```

### Stop the Engine Manager

Send a standard termination signal to the identified process:

```text theme={null}
kill <process-id>
```

Wait for the Engine Manager and its managed Engines to stop:

```text theme={null}
ps -ef | grep apm-engine
```

> [!NOTE]
>
> Do not use `kill -9` for a routine shutdown. A forced termination prevents the Engine Manager from stopping its managed Engines cleanly and may leave separate Engine processes running.

For production, prefer:

```text theme={null}
sudo systemctl start germain-engine-manager
sudo systemctl stop germain-engine-manager
sudo systemctl restart germain-engine-manager
sudo systemctl status germain-engine-manager
```

Use the actual service name configured on the host.

## Review the Engine Manager log

The primary Engine Manager log is:

```text theme={null}
ENGINE_HOME/logs/EngineManager.log
```

Some older distributions may use:

```text theme={null}
ENGINE_HOME/log/EngineManager.log
```

Use this log to verify:

* Connection to Germain Enterprise
* Node registration
* Authorization status
* Configuration retrieval
* Engine startup and shutdown
* Heartbeats

> [accordion] Show all 10
>
> * Proxy or network errors
> * Java and memory errors
> * Component startup failures
> * Local state-store errors

A successful startup includes a message similar to:

```text theme={null}
Started EngineManagerApplication in <duration> seconds
```

## Authorize an Engine Manager

A newly installed Engine Manager may appear in GermainUX but remain unable to retrieve its configuration until authorized.

In the GermainUX Workspace:

**1. Open Germain > State**

**2. Select Nodes**

**3. Find the Engine Manager**

**4. Select the lock in the Sessions column**

**5. Confirm the authorization**

After authorization, review `EngineManager.log` and confirm that the Manager retrieves its configuration and starts its Engines.

## Manage individual Engines

Individual Engines can be enabled or disabled without disabling every Engine managed by the same Engine Manager.

In the GermainUX Workspace:

1. Sign in as an administrator.
2. Open **Germain > State**.
3. Select the Engines view.
4. Search for the Engine by name or browse the list.
5. Select the Engine.
6. Change its status to enabled or disabled.

   ![Engine Configuration: Manage individual Engines](https://mintcdn.com/germain-ux/8KX3c-GSSWR99tdN/images/main/engine-configuration/image-20260826-214541.png?fit=max\&auto=format\&n=8KX3c-GSSWR99tdN\&q=85\&s=cd1c44c3943321bcbd40b85024a76a9d)
7. Confirm the requested state is reflected in the Workspace and logs.

### Disable an Engine when

* Performing maintenance on its host
* Investigating repeated component failures
* Moving components to another Engine
* Preventing monitoring during an approved change
* Retiring the Engine

### Enable an Engine when

* Initial configuration is complete
* Maintenance has ended
* Required dependencies are available
* Its assigned components are ready to run

Disabling an Engine does not necessarily stop the Engine Manager or other Engines on the same host.

## Restart an individual Engine

Restart an Engine after changing settings that are applied only at startup, including:

* JVM memory
* JVM system properties
* Proxy settings
* Engine-specific runtime options
* Certain component configurations

From **Germain > State**:

**1. Select the Engine**

**2. Save the updated configuration**

**3. Select Restart this Engine**

**4. Monitor its status**

**5. Review the Engine logs**

**6. Confirm that its monitoring components resume execution**

Avoid restarting multiple production Engines simultaneously unless the resulting interruption has been reviewed and approved.

## Configure Engine memory

Engine heap settings can be updated from **Germain > State**. After modifying the JVM options, save the configuration and restart the affected Engine.

Use the dedicated [Engine Memory Configuration](https://docs.germainux.com/main/engine-memory-configuration.md) guide for the complete procedure, default JVM parameters, and validation steps.

Increase memory only when the Engine host has sufficient free capacity. If the host is constrained, move components or Engines to another host instead.

## Configure proxy access

Proxy settings may need to be configured separately for:

* The Engine Manager
* Individual Engines

You can also configure the node to relay the Engine Manager’s proxy settings to its Engines.

Use [Engine Proxy Configuration](https://docs.germainux.com/main/engine-proxy-configuration.md) for the required JVM properties and configuration procedure.

## Validate the configuration

After changing the Engine configuration, confirm that:

* The Engine Manager is running.
* Its node is authorized.
* The heartbeat appears in **Germain > State**.
* All expected Engines are listed.
* Required Engines are enabled.
* Engine restarts complete successfully.

> [accordion] Show all 12
>
> * The effective JVM command line contains the expected settings.
> * Proxy connectivity works when required.
> * Monitoring components resume execution.
> * New telemetry appears in GermainUX.
> * No repeated errors appear in `EngineManager.log`.
> * CPU, memory, and disk utilization remain acceptable.

## Troubleshooting

### Engine Manager does not start

Check:

* Java version and `JAVA_HOME`
* Germain Enterprise connectivity
* Service-account permissions
* JVM memory settings
* Proxy configuration
* Port and firewall access
* `EngineManager.log`

### Engine appears but does not load

Confirm that:

* The node was authorized.
* The Engine is enabled.
* Germain Enterprise is reachable.
* The configuration account is valid.
* The Manager can retrieve the node configuration.
* The configured messaging transport is available.

### Configuration changes are not applied

Verify that:

* You updated the intended Engine.
* The configuration was saved successfully.
* The Engine was restarted when required.
* No invalid JVM option prevents startup.
* The effective command line contains the new setting.
* No node- or host-level configuration overrides it.

### Engine repeatedly restarts

Review the logs for:

* Out-of-memory errors
* Invalid JVM options
* Component initialization failures
* Local state-store problems
* Missing drivers
* Permission failures
* Unavailable dependencies

Do not repeatedly restart the Engine without identifying the first relevant error.

## Related guides

| Guide | Purpose |
| - | - |
| [Engine Memory Configuration](https://docs.germainux.com/main/engine-memory-configuration.md) | adjust JVM memory and restart the Engine |
| [Engine Proxy Configuration](https://docs.germainux.com/main/engine-proxy-configuration.md) | configure proxy access for the Engine Manager and Engines |
| Engine Troubleshooting | resolve startup, state-store, and capacity issues |

## Get Help

> [card] [Contact GermainUX Support](https://docs.germainux.com/main/support.md)
>
> The GermainUX team helps you get up and running faster, empower your team, turn data into actionable insights, and optimize performance to deliver measurable business outcomes.

> [card] Can't find what you need?
>
> Search all GermainUX docs with **Ctrl + K**, or use the feedback buttons at the bottom of this page to tell us what is missing.

The content of this document is proprietary to GERMAIN SOFTWARE.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.