Installation¶
Trino Gateway is distributed as an executable JAR file. The release notes contain links to download specific versions.
Every Trino Gateway release includes a Docker container and a Helm chart as alternative deployment methods.
Follow the development instructions to
build the JAR file and the Docker image instructions or use the
TrinoGatewayRunner class for local testing.
The quickstart guide contains instructions for running the
application locally.
Following are instructions for installing Trino Gateway for production environments.
Requirements¶
Consider the following requirements for your Trino Gateway installation.
Java¶
Trino Gateway requires a Java 25 runtime. Lower versions of Java can not be used. Higher versions are verified in our CI pipelines, but you may run into unexpected issues.
We recommend using the Amazon Corretto OpenJDK distribution, as Trino Gateway is tested against that distribution. Amazon Corretto is also the JDK used by the Trino Gateway Docker image.
Verify the Java version on your system with java -version.
Operating system¶
No specific operating system is required. All testing and development is performed with Linux and MacOS.
Processor architecture¶
No specific processor architecture is required, as long as a suitable Java distribution is installed.
Backend database¶
Trino Gateway requires a MySQL, PostgreSQL, or Oracle database. Database
initialization is performed automatically when the Trino Gateway process
starts. Migrations are performed using Flyway.
The migration files can be viewed in the gateway-ha/src/main/resources/ folder.
Each database type supported has its own sub-folder.
The files are also included in the JAR file.
If you do not want migrations to be performed automatically on startup, then
you can set runMigrationsEnabled to false in the data store configuration.
Migrations are activated by default, and deactivating them is rarely necessary.
With migrations deactivated, you must apply any new migration files to the
database manually before each upgrade of Trino Gateway.
You can also disable query history recording to the database by setting
queryHistoryEnabled to false. This can be useful in scenarios where you
want to reduce database load or don't need query history tracking.
To limit the size of each query history record, set
queryHistoryMaxQueryTextLength to the maximum number of characters of query
text to store. Longer query text is truncated and a
-- [truncated by trino-gateway: N of M chars] comment is appended, so the
stored value can be slightly longer than the configured limit. By default, the
full query text is stored.
If maxPoolSize is configured and greater than 0, Trino Gateway uses a
connection pool for data store connections, including Trino Gateway metadata,
query history, and the pins for
OAuth2 token-exchange routing.
If maxPoolSize is not configured, Trino Gateway creates a new JDBC connection
per request.
A value of 10 is a reasonable starting point for many deployments, but the
optimal value depends on the database capacity and expected concurrency.
The optional keepaliveTime and maxLifetime settings control how frequently
idle pooled connections are checked and how long a pooled connection can be
reused. Both accept Airlift-style durations such as 2m or 30m. If they are
not configured, the connection pool defaults are used. A non-zero value below
30s, or a keepaliveTime that is not less than maxLifetime, is not applied:
the setting is reset to its default or disabled and a warning is logged.
For example:
dataStore:
jdbcUrl: jdbc:postgresql://postgres:5432/trino_gateway_db
user: USER
password: PASSWORD
driver: org.postgresql.Driver
queryHistoryHoursRetention: 24
queryHistoryEnabled: true # Set to false to disable query history recording
queryHistoryMaxQueryTextLength: 10000 # Optional: truncate stored query text
maxPoolSize: 10 # Optional: enables JDBC connection pooling for the data store
keepaliveTime: 2m # Optional: interval for checking idle pooled connections
maxLifetime: 30m # Optional: maximum lifetime of a pooled connection
Keep the pool small. Trino Gateway uses the data store for backend metadata,
query history, and periodic cleanup. Each query submitted through Trino Gateway
inserts a query history record while the request is proxied, so the pool must
keep up with the query submission rate. Each insert is short, so a large pool is
rarely beneficial. HikariCP recommends a fixed-size pool sized roughly as
(cpu_cores * 2) + effective_spindles for the Trino Gateway host, and the
default of 10 suits most deployments. Never set maxPoolSize higher
than what the database allows across all Trino Gateway instances, such as
PostgreSQL or MySQL max_connections, or the Oracle sessions and processes
limits. At high scale, an external pooler such as PgBouncer is often a better
fit than a large pool.
Set maxLifetime a few seconds shorter than the shortest connection lifetime
enforced by the database or infrastructure, such as a load balancer idle timeout
or the MySQL wait_timeout. Keep keepaliveTime shorter than maxLifetime.
For the rationale and the full set of pool tuning options, see the HikariCP documentation on pool sizing and configuration.
Flyway uses a transactional lock in databases that support it such as
PostgreSQL.
In the scenario where multiple Trino Gateway instances are running and sharing
the same backend database, the first Trino Gateway instance to start will get
the lock and run the database migrations with Flyway. Other Trino Gateway
instances might fail during startup while migrations are running but once migrations
are completed they will start as expected.
Query history write buffer¶
By default, Trino Gateway writes a query history record to the database as part
of routing each query, and the write fails when the database is unavailable.
Configure the write buffer to keep routing queries during a temporary database
outage. A query history record that fails to write because of a connection
problem is buffered in memory. A background task retries writing all buffered
records at every flushInterval, so they are persisted shortly after the
database is reachable again.
The buffer is deactivated by default. It holds at most maxCapacity records,
with a default of 10000, so memory use is bounded even during a prolonged
outage. This limits the memory overhead to a few megabytes of query history
records, while covering a multi-minute outage at typical query rates. Use
queryHistoryMaxQueryTextLength to bound the size of each record when large
query text values are common, since records are truncated before they are
buffered. When the buffer is full, the oldest record is dropped to make room for
a new one, and an error is logged.
The first query that fails to write its record waits for the database connection timeout before the record is buffered. While the buffer holds records, Trino Gateway buffers new records directly without connecting to the database, so later queries are not delayed. Writes go to the database again once the background task has flushed the buffer.
The flush of all buffered records is attempted at the configured
flushInterval, with a default of 2s, so buffered history becomes visible
shortly after the database recovers, without adding significant load. The value
accepts Airlift-style durations such as 500ms or 10s. A buffered record that
fails to write for a reason other than a connection problem, such as a duplicate
query ID, is dropped and an error is logged.
Trino Gateway attempts a final flush of the buffered records on shutdown. If the database is still unavailable, the remaining records are lost, and an error with their number is logged.
Trino clusters¶
The proxied Trino clusters behind the Trino Gateway must support the Trino JDBC driver and the Trino REST API for cluster and node health information. Typically, this means that Trino versions 354 and higher should work, however newer Trino versions are strongly recommended.
Trino-derived projects and platforms may work if the Trino JDBC driver and the REST API are supported. For example, Starburst Galaxy and Starburst Enterprise are known to work. Trino deployments with the Helm chart and other means on various cloud platforms, such as Amazon EKS also work. However Amazon Athena does not work since it uses alternative, custom protocols and lacks the concept of individual clusters.
Trino configuration¶
From a users perspective Trino Gateway acts as a transparent proxy for one or more Trino clusters. The following Trino configuration tips should be taken into account for all clusters behind the Trino Gateway.
If all client and server communication is routed through Trino Gateway, then process forwarded HTTP headers must be enabled:
Without this setting, first requests go from the user to Trino Gateway and then to Trino correctly. However, the URL for subsequent next URIs for more results in a query provided by Trino is then using the local URL of the Trino cluster, and not the URL of the Trino Gateway. This circumvents the Trino Gateway for all these requests. In scenarios, where the local URL of the Trino cluster is private to the Trino cluster on the network level, these following calls do not work at all for users.
This setting is also required for Trino to authenticate in the case TLS is
terminated at the Trino Gateway. Normally it refuses to authenticate plain HTTP
requests, but if http-server.process-forwarded=true it authenticates over
HTTP if the request includes a forwarded HTTPS protocol header, such as X-Forwarded-Proto: HTTPS.
To prevent Trino Gateway from sending X-Forwarded-* and Forwarded headers, add the following configuration:
Find more information in the related Trino documentation.
Configuration¶
After downloading or building the JAR, rename it to gateway-ha.jar,
and place it in a directory with read and write access such as /opt/trinogateway.
Copy the example config file config.yaml from the gateway-ha/
directory into the same directory, and update the configuration as needed.
Each component of the Trino Gateway has a corresponding node in the configuration YAML file.
Secrets in configuration file¶
Environment variables can be used as values in the configuration file. You can manually set an environment variable on the command line.
To use this variable in the configuration file, you reference it with the
syntax ${ENV:VARIABLE}. For example:
dataStore:
jdbcUrl: jdbc:postgresql://localhost:5432/gateway
user: postgres
password: ${ENV:DB_PASSWORD}
Configure routing rules¶
Find more information in the routing rules documentation.
Configure OAuth2 token-exchange routing¶
Trino's OAuth2 token-exchange handshake spans two HTTP clients that share only
an authId: the driver/CLI poll loop (GET /oauth2/token/{authId}) and the
browser (GET /oauth2/token/initiate/{authIdHash}, returning from the identity
provider to GET /oauth2/callback). Only the coordinator that issued the
original 401 challenge holds the in-memory exchange state for that authId,
so in a multi-coordinator deployment normal routing can send these requests to
a different backend and stall the login. This is separate from the existing
cookie-based browser routing (see
Routing logic), which cannot help
on its own since the driver and browser are different HTTP clients.
Enable pinning of OAuth2 token-exchange requests to the coordinator that
minted the authId with:
Pins are recorded in the oauth2_routing table so they are shared across
gateway instances. Each pin is keyed by pin_key, a hash of the handshake id.
The table is created by the database migrations. If
migrations are deactivated with runMigrationsEnabled set to false and the
table does not exist, pins cannot be persisted and OAuth2 routing silently falls
back to normal routing.
A pin is dropped, and the client is forced to re-authenticate, only when its
coordinator is deactivated or removed. Otherwise the request goes to the pinned
coordinator whatever its health status, since no other coordinator can finish
the handshake. If that coordinator is down, the request fails with 502 and the
pin is removed after the retention period. The Trino CLI and JDBC driver retry a
502 while they poll for the token, so they wait until their external
authentication timeout, 2 minutes by default. A new login gets a new handshake
id and is not affected.
Pins are written on 401 responses to unauthenticated requests, so writes are
rate-limited per gateway instance. Over the limit, the pin is not written, the
rest of that handshake is routed normally and may fail, and the
PinWriteRateLimited counter of the
io.trino.gateway.ha.router:name=OAuth2RoutingStats JMX bean is incremented.
The limit is shared by all clients of the instance, so a flood of
unauthenticated requests above it also stops real logins from being pinned. To
avoid that, raise the limit or rate-limit anonymous traffic in front of the
gateway. Adjust the limit with:
The limit is an average, so an instance that was idle can briefly write up to about twice as many pins in one second.
Stored pins are retained for 20 minutes by default and are removed by a sweep
that runs every 5 minutes. Keep the retention above the coordinators'
http-server.authentication.oauth2.challenge-timeout (15 minutes by default),
so a pin is not removed while its handshake can still complete. Trino Gateway
logs a warning if the retention is 15 minutes or less:
The sweep only runs while oauth2RoutingEnabled is set. If you turn OAuth2
routing off, remove the remaining pins with DELETE FROM oauth2_routing.
Trino Gateway keeps the handshake ids out of its own log lines, but the
HTTP request log
(http-server.log.enabled, on by default) records the raw path and query of
every request, including the authId, the authIdHash, and the callback's
code and state. Anyone who can read that log while a login is in progress
can take it over, so restrict access to the log or disable it when OAuth2
routing is enabled.
Configure logging ¶
To configure the logging level for various classes, specify the path to the
log.properties file by setting log.levels-file in serverConfig.
For additional configurations, use the log.* properties from the
Trino logging properties documentation and specify
the properties in serverConfig.
Proxying additional paths¶
By default, Trino Gateway only proxies requests to paths starting with
/v1/statement, /v1/query, /ui, /v1/info, /v1/node, /ui/api/stats and
/oauth.
If you want to proxy additional paths, you can add them by adding the
extraWhitelistPaths node to your configuration YAML file.
Trino Gateway takes regexes from extraWhitelistPaths and forwards only
those requests with a URI that exactly match. Be sure
to use single-quoted strings so that escaping is not required.
extraWhitelistPaths:
- '/ui/insights'
- '/api/v1/biac'
- '/api/v1/dataProduct'
- '/api/v1/dataproduct'
- '/api/v2/.*'
- '/ext/faster'
Configure additional v1/statement-like paths¶
The Trino client protocol specifies that queries are initiated by a POST to v1/statement.
The Trino Gateway incorporates this into its routing logic by extracting and recording the
query id from responses to such requests. If you use an experimental or commercial build of
Trino that supports additional endpoints, you can cause Trino Gateway to treat them
equivalently to /v1/statement by adding them under the additionalStatementPaths
configuration node. They must be absolute, and no path can be a prefix to any other path.
The standard /v1/statement path is always included and does not need to be configured.
For example:
Deactivate UI pages¶
You can set the disablePages configuration to deactivate UI pages.
The following pages are available:
dashboardclusterresource-groupselectorhistoryrouting-rules
Link queries to the Trino Web UI¶
The query history page links each query to the Web UI of its backend. Trino 483
replaced the Web UI, and the page the default link points to returns 404 there,
even with web-ui.legacy.enabled. Set queryLinkType to match the Trino
version of your clusters:
QUERY_HTMLlinks to/ui/query.html?<queryId>, the query page of Trino 482 and earlier. This is the default.HASH_ROUTElinks to/ui/#/queries/<queryId>, the query page of the default Web UI in Trino 483 and later.
The setting applies to all backends. If your clusters run Trino releases on both sides of 483, links to one of the groups do not open the query.
Configure behind a load balancer¶
A possible deployment of Trino Gateway is to run multiple instances of Trino
Gateway behind another generic load balancer, such as a load balancer from
your cloud hosting provider. In this deployment you must configure the
serverConfig to include enabling process forwarded HTTP headers:
Configure larger proxy response size¶
Trino Gateway reads the response from Trino in bytes (up to 32MB by default).
Responses larger than this limit fail with a 502 Bad Gateway error instead
of being forwarded truncated. The proxy HTTP client also limits the response
size with proxy.http-client.max-response-content-length in serverConfig,
16MB by default, so increase both to allow larger responses. responseSize
can be configured by setting:
Configure HTTP compression¶
Trino Gateway requests gzip compressed responses from the Trino clusters and
decompresses them before they are returned to the client. Trino Gateway
compresses the responses for clients that send an Accept-Encoding header,
with gzip, brotli, or zstd.
The response size limits apply to the decompressed response, so compression
does not raise them. Responses larger than
proxy.http-client.max-response-content-length in serverConfig, 16MB by
default, fail with a Buffering capacity exceeded error. Increase it together
with responseSize in proxyResponseConfiguration to allow larger responses.
Configure the compression between Trino Gateway and the Trino clusters with the
proxy.http-client properties in serverConfig, and the compression between
the clients and Trino Gateway with the http-server properties:
serverConfig:
proxy.http-client.gzip-compression.enabled: true
proxy.http-client.brotli-compression.enabled: false
proxy.http-client.zstd-compression.enabled: false
http-server.gzip-compression.enabled: true
http-server.brotli-compression.enabled: true
http-server.zstd-compression.enabled: true
The values in the preceding example are the defaults. Set the three
http-server properties to false to disable all compression of the responses
to the clients.
Running Trino Gateway¶
Start Trino Gateway with the following java command in the directory of the JAR and YAML files:
Helm ¶
Helm manages the deployment of Kubernetes applications by templating Kubernetes resources with a set of Helm charts. The Trino Gateway Helm chart is available in the Trino Helm chart project.
Configure the charts repository as a Helm chart repository with the following command:
The Trino Gateway chart consists of the following components:- A
confignode for general configuration dataStoreSecret,backendStateSecretandauthenticationSecretfor providing sensitive configurations through Kubernetes secrets,- Standard Helm options such as
replicaCount,resourcesandingress.
The default values.yaml found in the helm/trino-gateway folder includes
basic configuration options as an example. For a simple deployment, proceed with
the following steps:
Create a yaml file containing the configuration for your datastore:
cat << EOF > datastore.yaml
dataStore:
jdbcUrl: jdbc:postgresql://yourdatabasehost:5432/gateway
user: postgres
password: secretpassword
driver: org.postgresql.Driver
EOF
kubectl create secret generic datastore-yaml --from-file datastore.yaml --dry-run=client -o yaml | kubectl apply -f -
Create a values override with a name such as values-override.yaml and
reference this secret in the backendStateSecret node:
When a Secret is created with the --from-file option, the filename is used as
the key. Finally, you can deploy Trino Gateway with the chart from the root
of this repository:
Secrets for authenticationSecret and backendState can be provisioned
similarly. Alternatively, you can directly define the config.backEndState
node in values-override.yaml and leave backendStateSecret undefined.
However, a Secret
is recommended to protect the database credentials required for this
configuration.
By default, the Trino Gateway process is started with the following command:
java -XX:MinRAMPercentage=80.0 -XX:MaxRAMPercentage=80.0 -jar /usr/lib/trino-gateway/gateway-ha-jar-with-dependencies.jar /etc/trino-gateway/config.yaml
You can customize details with the command node. It accepts a list, that must
begin with an executable such as java or bash that is available on the PATH.
The following list elements are provided as arguments to the executable. It is
not typically necessary to modify this node. You can use it to change of JVM
startup parameters to control memory settings and other aspects, or to use other
configuration file names.
Additional options¶
To implement routing rules, create a ConfigMap from your routing rules yaml definition:
Then mount it to your container:
volumes:
- name: routing-rules
configMap:
name: routing-rules
items:
name: your-routing-rules.yaml
path: your-routing-rules.yaml
volumeMounts:
- name: routing-rules
mountPath: "/etc/routing-rules/your-routing-rules.yaml"
subPath: your-routing-rules.yaml
Ensure that the mountPath matches the rulesConfigPath specified in your
configuration. Note that the subPath is not strictly necessary, and if it
is not specified the file is mounted at mountPath/<configMap key>.
Kubernetes updates the mounted file when the ConfigMap is updated.
Standard Helm options such as replicaCount, image, imagePullSecrets,
service, ingress and resources are supported. These are defined in
helm/values.yaml.
More detail about the chart are available in the values reference documentation
Health checks on Trino clusters¶
The Trino Gateway periodically performs health checks and maintains an in-memory TrinoStatus for each backend. If a backend fails a health check, it is marked as UNHEALTHY, and the Trino Gateway stops routing requests to it.
It is important to distinguish TrinoStatus from the active/inactive state of a backend. The active/inactive state indicates whether a backend is manually turned on or off, whereas TrinoStatus is programmatically determined by the health check process.
See TrinoStatus for more details on what each Trino status means.
Username and password for the health check can be configured by adding
backendState to your configuration. The username and password must be valid
across all backends.
SSL and xForwardProtoHeader can be configured based on whether the connection between the Trino Gateway and the backend is secure. By default, both are set to false. Find more information in the related Trino documentation.
backendState:
username: "user"
password: "password"
ssl: <false/true>
xForwardedProtoHeader: <false/true>
The type of health check is configured by setting
to one of the following values.
INFO_API (default)¶
By default Trino Gateway uses the v1/info REST endpoint. A successful check is
defined as a 200 response with starting: false. The check uses the monitor
HTTP client, so its timeouts are set with the monitor.http-client properties
in serverConfig. The METRICS and JMX monitors use the same HTTP client,
so these properties apply to them too. How often the checks run is set with
taskDelay in the monitor node, 1 minute by default. For example
serverConfig:
monitor.http-client.connect-timeout: 5s
monitor.http-client.request-timeout: 10s
monitor.http-client.idle-timeout: 10s
monitor:
taskDelay: 30s
retries: 1
All parameters are optional. The defaults are connect-timeout 5s,
request-timeout 5m and idle-timeout 1m, so without them a backend that
stops responding is only marked UNHEALTHY after 1 minute. A backend whose
check times out is marked UNHEALTHY. Each round of checks waits for every
backend before it updates their status, so a backend that stops responding
delays the status of all backends until its check times out. retries only
applies to 502, 503, and 504 responses.
METRICS¶
This pulls statistics from Trino's OpenMetrics endpoint.
It retrieves the number of running and queued queries for use with
the QueryCountBasedRouter (either METRICS or JDBC must be enabled if
QueryCountBasedRouter is used).
By default, it uses the trino_execution_name_QueryManager_RunningQueries and
trino_execution_name_QueryManager_QueuedQueries to track the number of running
and queued queries respectively, however these metrics can be configured as follows:
monitor:
runningQueriesMetricName: io_starburst_galaxy_name_GalaxyMetrics_RunningQueries
queuedQueriesMetricName: io_starburst_galaxy_name_GalaxyMetrics_QueuedQueries
Similarly, by default the monitor pulls the metrics using the /metrics endpoint, but it
can be updated to use another one:
This monitor allows customizing health definitions by comparing metrics to fixed
values. This is configured through two maps: metricMinimumValues and
metricMaximumValues. The keys of these maps are the metric names, and the values
are the minimum or maximum values (inclusive) that are considered healthy. By default,
the only metric populated is:
This requires the cluster to have at least one active worker node in order to be considered healthy. The map is overwritten if configured explicitly. For example, to increase the minimum worker count to 10 and disqualify clusters that have been experiencing frequent major Garbage Collections, set
monitor:
metricMinimumValues:
trino_node_name_CoordinatorNodeManager_ActiveNodeCount: 10
metricMaximumValues:
io_airlift_stats_name_GcMonitor_MajorGc_FiveMinutes_count: 2
Trino 477 renamed the active node count metric from
trino_metadata_name_DiscoveryNodeManager_ActiveNodeCount to
trino_node_name_CoordinatorNodeManager_ActiveNodeCount. The monitor accepts
either name for this metric, whichever one you configure, so one configuration
monitors clusters on both sides of Trino 477. See
Trino version compatibility for the full
picture.
JDBC¶
This uses a JDBC connection to query system.runtime tables for cluster
information. It is required for the query count based routing strategy. This is
recommended over UI_API since it does not restrict the Web UI authentication
method of backend clusters.
Trino Gateway uses explicitPrepare=false by default. This property was introduced
in Trino 431, and uses a single query for prepared statements, instead of a
PREPARE/EXECUTE pair. If you are using the JDBC health check option with older
versions of Trino, set
The query timeout can be set through
Other timeout parameters are not applicable to the JDBC connection.
JMX¶
The monitor type JMX can be used as an alternative to collect cluster information,
which is required for the QueryCountBasedRouterProvider. This uses the v1/jmx/mbean
endpoint on Trino clusters.
This monitor does not work with Trino 477 and later. Trino 477 renamed the
DiscoveryNodeManagerMBean it reads, and Trino 480 removed thev1/jmx/mbeanendpoint it depends on. That endpoint is not part of the documented Trino JMX interface, which covers RMI access only. Use theMETRICSmonitor, which reads the OpenMetrics endpoint of each cluster, instead. To check other MBean values, export them on that endpoint with theopenmetrics.jmx-object-namesproperty of each Trino cluster, and set limits for them withmetricMinimumValuesandmetricMaximumValues. See Trino version compatibility.
To enable this:
JMX monitoring must be activated on all Trino clusters with:
Allow JMX endpoint access by adding rules to your file-based access control
configuration. Example for user:
{
"catalogs": [
{
"user": "user",
"catalog": "system",
"allow": "read-only"
}
],
"system_information": [
{
"user": "user",
"allow": ["read"]
}
]
}
Ensure that a username and password are configured by adding the backendState
section to your configuration. The credentials must be consistent across all
backend clusters and have read rights on the system_information.
The JMX monitor will use these credentials to authenticate against the JMX endpoint of each Trino cluster and collect metrics like running queries, queued queries, and worker nodes information.
UI_API¶
This pulls cluster information from the ui/api/stats REST endpoint. It is only
supported for backend clusters with web-ui.authentication.type=FORM. Set
a username and password using backendState as with the JDBC option.
The monitor requires a session cookie from the login, so a cluster with another
Web UI authentication type, such as fixed, is reported as UNKNOWN. Use
INFO_API or JDBC for such clusters.
The monitor detects the Web UI login resource of each backend cluster. It first
posts a JSON request body to /ui/auth/login, the login resource of the Web UI
in Trino 483 and later. When that returns no session cookie, it posts a form
encoded request body to /ui/login, the login resource in Trino 482 and
earlier. The monitor remembers the login resource that works for each cluster,
so one configuration monitors clusters on different Trino versions, for example
during an upgrade of one cluster at a time.
The monitor does not use /ui/legacy/login, which belongs to the previous Web
UI in Trino 483 and later.
NOOP¶
This option disables health checks.
Trino version compatibility¶
The monitor types depend on different Trino interfaces, and some of those interfaces changed in recent Trino releases. The following table summarizes which monitor types work against which Trino versions.
| Monitor type | Trino 476 and earlier | 477 to 479 | 480 to 482 | 483 and later |
|---|---|---|---|---|
INFO_API |
Yes | Yes | Yes | Yes |
JDBC |
Yes | Yes | Yes | Yes |
METRICS |
Yes | Yes | Yes | Yes |
JMX |
Yes | No | No | No |
UI_API |
Yes | Yes | Yes | Yes |
NOOP |
Not applicable | Not applicable | Not applicable | Not applicable |
The causes are:
- Trino 477 renamed the active node count metric used by the
METRICSmonitor. The monitor accepts either name. - Trino 477 renamed the
DiscoveryNodeManagerMBean that theJMXmonitor reads, and Trino 480 removed thev1/jmx/mbeanendpoint it depends on. That endpoint was never part of the documented Trino JMX interface. - Trino 483 replaced the previous Web UI with the preview Web UI, which changed
the login resource that the
UI_APImonitor uses. The monitor detects the login resource of each cluster.
INFO_API, JDBC, METRICS, and UI_API work with clusters on any of these
Trino versions in the same deployment. INFO_API and JDBC use stable, documented
Trino interfaces. Note that the QueryCountBasedRouter requires either
METRICS or JDBC.
Monitor configuration applies to all backends, so a deployment with clusters on
Trino 477 or later cannot use JMX.