HEAVY.AI Docs
v8.1.0
v8.1.0
  • Welcome to HEAVY.AI Documentation
  • Overview
    • Overview
    • Release Notes
  • Installation and Configuration
    • System Requirements
      • Hardware Reference
      • Software Requirements
      • Licensing
    • Installation
      • Free Version
      • Installing on Docker
        • HEAVY.AI Installation using Docker on Ubuntu
      • Installing on Ubuntu
        • HEAVY.AI Installation on Ubuntu
        • Install NVIDIA Drivers and Vulkan on Ubuntu
      • Installing on Rocky Linux / RHEL
        • HEAVY.AI Installation on RHEL
        • Install NVIDIA Drivers and Vulkan on Rocky Linux and RHEL
      • Getting Started on AWS
      • Getting Started on GCP
      • Getting Started on Azure
      • Getting Started on Kubernetes (BETA)
      • Upgrading
        • Upgrading HEAVY.AI
        • Upgrading from Omnisci to HEAVY.AI 6.0
        • CUDA Compatibility Drivers
      • Uninstalling
      • Ports
    • Services and Utilities
      • Using Services
      • Using Utilities
    • Executor Resource Manager
    • Configuration Parameters
      • Overview
      • Configuration Parameters for HeavyDB
      • Configuration Parameters for HEAVY.AI Web Server
      • Configuration Parameters for HeavyIQ
    • Security
      • Roles and Privileges
        • Column-Level Security
      • Connecting Using SAML
      • Implementing a Secure Binary Interface
      • Encrypted Credentials in Custom Applications
      • LDAP Integration
    • Distributed Configuration
  • Loading and Exporting Data
    • Supported Data Sources
      • Kafka
      • Using HeavyImmerse Data Manager
      • Importing Geospatial Data
    • Command Line
      • Loading Data with SQL
      • Exporting Data
  • SQL
    • Data Definition (DDL)
      • Datatypes
      • Users and Databases
      • Tables
      • System Tables
      • Views
      • Policies
      • Comment
    • Data Manipulation (DML)
      • SQL Capabilities
        • ALTER SESSION SET
        • ALTER SYSTEM CLEAR
        • DELETE
        • EXPLAIN
        • INSERT
        • KILL QUERY
        • LIKELY/UNLIKELY
        • SELECT
        • SHOW
        • UPDATE
        • Arrays
        • Logical Operators and Conditional and Subquery Expressions
        • Table Expression and Join Support
        • Type Casts
      • Geospatial Capabilities
        • Uber H3 Hexagonal Modeling
      • Functions and Operators
      • System Table Functions
        • generate_random_strings
        • generate_series
        • tf_compute_dwell_times
        • tf_feature_self_similarity
        • tf_feature_similarity
        • tf_geo_rasterize
        • tf_geo_rasterize_slope
        • tf_graph_shortest_path
        • tf_graph_shortest_paths_distances
        • tf_load_point_cloud
        • tf_mandelbrot*
        • tf_point_cloud_metadata
        • tf_raster_contour_lines; tf_raster_contour_polygons
        • tf_raster_graph_shortest_slope_weighted_path
        • tf_rf_prop_max_signal (Directional Antennas)
        • ts_rf_prop_max_signal (Isotropic Antennas)
        • tf_rf_prop
      • Window Functions
      • Reserved Words
      • SQL Extensions
      • HeavyIQ LLM_TRANSFORM
  • HeavyImmerse
    • Introduction to HeavyImmerse
    • Admin Portal
    • Control Panel
    • Working with Dashboards
      • Dashboard List
      • Creating a Dashboard
      • Configuring a Dashboard
      • Duplicating and Sharing Dashboards
    • Measures and Dimensions
    • Using Parameters
    • Using Filters
    • Using Cross-link
    • Chart Animation
    • Multilayer Charts
    • SQL Editor
    • Customization
    • Joins (Beta)
    • Chart Types
      • Overview
      • Bubble
      • Choropleth
      • Combo
      • Contour
      • Cross-Section
      • Gauge
      • Geo Heatmap
      • Heatmap
      • Linemap
      • Number
      • Pie
      • Pointmap
      • Scatter Plot
      • Skew-T
      • Table
      • Text Widget
      • Wind Barb
    • Deprecated Charts
      • Bar
      • Combo - Original
      • Histogram
      • Line
      • Stacked Bar
    • HeavyIQ SQL Notebook
  • HEAVYIQ Conversational Analytics
    • HeavyIQ Overview
      • HeavyIQ Guidance
  • HeavyRF
    • Introduction to HeavyRF
    • Getting Started
    • HeavyRF Table Functions
  • HeavyConnect
    • HeavyConnect Release Overview
    • Getting Started
    • Best Practices
    • Examples
    • Command Reference
    • Parquet Data Wrapper Reference
    • ODBC Data Wrapper Reference
    • Raster Data Wrapper Reference
  • HeavyML (BETA)
    • HeavyML Overview
    • Clustering Algorithms
    • Regression Algorithms
      • Linear Regression
      • Random Forest Regression
      • Decision Tree Regression
      • Gradient Boosting Tree Regression
    • Principal Components Analysis
  • Python / Data Science
    • Data Science Foundation
    • JupyterLab Installation and Configuration
    • Using HEAVY.AI with JupyterLab
    • Python User-Defined Functions (UDFs) with the Remote Backend Compiler (RBC)
      • Installation
      • Registering and Using a Function
      • User-Defined Table Functions
      • RBC UDF/UDTF Example Notebooks
      • General UDF/UDTF Tutorial Notebooks
      • RBC API Reference
    • Ibis
    • Interactive Data Exploration with Altair
    • Additional Examples
      • Forecasting with HEAVY.AI and Prophet
  • APIs and Interfaces
    • Overview
    • heavysql
    • Thrift
    • JDBC
    • ODBC
    • Vega
      • Vega Tutorials
        • Vega at a Glance
        • Getting Started with Vega
        • Getting More from Your Data
        • Creating More Advanced Charts
        • Using Polys Marks Type
        • Vega Accumulator
        • Using Transform Aggregation
        • Improving Rendering with SQL Extensions
      • Vega Reference Overview
        • data Property
        • projections Property
        • scales Property
        • marks Property
      • Migration
        • Migrating Vega Code to Dynamic Poly Rendering
      • Try Vega
    • RJDBC
    • SQuirreL SQL
    • heavyai-connector
  • Tutorials and Demos
    • Loading Data
    • Using Heavy Immerse
    • Hello World
    • Creating a Kafka Streaming Application
    • Getting Started with Open Source
    • Try Vega
  • Troubleshooting and Special Topics
    • FAQs
    • Troubleshooting
    • Vulkan Renderer
    • Optimizing
    • Known Issues and Limitations
    • Logs and Monitoring
    • Archived Release Notes
      • Release 6.x
      • Release 5.x
      • Release 4.x
      • Release 3.x
Powered by GitBook
On this page
  • Node Locked Licenses
  • Floating Licenses
  • Upgrade Scenarios
Export as PDF
  1. Installation and Configuration
  2. System Requirements

Licensing

PreviousSoftware RequirementsNextInstallation

Last updated 1 year ago

The Enterprise Edition of HEAVY.AI contains a rich set of analytical and location intelligence features at various capacity levels. A license provides the ability to use these features at specific capacities (e.g. specific number of GPUs) for a specified period of time, typically based on an end user license agreement.

A new license version and mechanism was implement in the 8.0 HEAVY.AI release. This is a breaking change that would require all enterprise customers to request a new license before upgrading to the 8.0 release. This document provides details about the new licensing options and provides guidance on how to decide on the best licensing option for your organization and how to request and apply an appropriate license.

Starting at the 8.0 release, HEAVY.AI supports two types of licenses: Node Locked Licenses and Floating Licenses.

Node Locked Licenses

Node locked licenses restrict the use of the platform to a single machine. A node locked license is generated for a specific machine that an organization has set up to run their instance and is appropriate for organizations with single instance deployment agreements with dedicated machines for use.

In order to get started with a node locked license, a unique machine identifier called a “Host ID“ has to be derived from the machine on which will be running. The Host ID can be displayed using the heavysql “\status” command. For example:

$ echo "\status" | ./bin/heavysql -p HyperInteractive
License invalid
Not connected to any database. See \h for help.
Server Version                      : 7.2.4 Enterprise Edition
Host ID                             : 1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqr
--------------------------------------------------
Server Name                         : example.com
Server Start Time                   : 2024-03-01 : 00:00:00

The instance that the heavysql client connects to has to be launched on the machine in question and with privileged access (e.g. using “sudo“) in order to view the Host ID and use a Node Locked License. See the “Using systemd to Launch HeavyDB with Privileged Access” section for more details about how to launch HeavyDB with privileged access using systemd. For docker deployments, no additional deployment steps are required.

Note that changing fundamental hardware components of the machine can result in a change in the Host ID. If this happens, please reach out to the Customer Success team for assistance.

The Host ID is only meaningful within the context of and cannot be used to derive any information about the machine on which is running.

If you intend on getting a Node Locked License, create a new Node Locked License Request support ticket and provide the Host ID in the ticket description.

Floating Licenses

Similar to the process for Node Locked License deployments, a Host ID has to be derived for the machine on which the License Server will run (i.e. the license server is node locked). The steps for getting the Host ID is the same as those mentioned in the “Node Locked Licenses“ section above. If you intend on getting a floating license, create a new Floating License Request support ticket and provide the following information in the ticket description:

  1. Host ID of machine on which the License Server will be running.

  2. Hostname of License Server (as seen by the HeavyDB instances).

  3. License Server port number (as seen by the HeavyDB instances).

License Server Deployment

The License Server can be deployed using the heavyai/heavyai-license-server docker image. A directory containing an initially empty storage directory and license_server.conf file should be bound to the /var/lib/heavyai path. Example deployment:

$ mkdir -p ~/heavyai-license-server/storage
$ echo "port = 6278" > ~/heavyai-license-server/license_server.conf

$ docker run --rm -p 6280:6280 \
  -v ~/heavyai-license-server:/var/lib/heavyai \
  heavyai/heavyai-license-server

Upgrade Scenarios

Using systemd to Launch HeavyDB with Privileged Access

[Unit] 
Description=HEAVY.AI database server 
After=network.target remote-fs.target

[Service] 
Environment=LD_LIBRARY_PATH=/usr/local/cuda-11.0/compat:$LD_LIBRARY_PATH
WorkingDirectory=/opt/heavyai
ExecStart=/opt/heavyai/bin/heavydb --config /var/lib/heavyai/heavy.conf 
KillMode=control-group 
SuccessExitStatus=143 
LimitNOFILE=65536 
Restart=always

[Install] 
WantedBy=multi-user.target

After updating the service file, force reload of the systemd configuration by executing the following command:

sudo systemctl daemon-reload

Floating licenses allow for the deployment of the platform on multiple machines on the same network. Floating licenses require the deployment of another type of server called a “License Server”. The License Server monitors the use of licenses and resources across deployments and determines whether a deployment should proceed based on license restrictions related to the number of allowed deployments and total resources consumed across all deployments. When all license specified resources are used to the limit, no additional deployments will be allowed. A floating license is appropriate for organizations who have multiple instance deployment agreements or single instance deployment agreements but cannot rely on a dedicated machines for HEAVY.AI use (e.g. cloud deployments on non-dedicated hosts).

Organizations that have multiple teams, each using a different HEAVY.AI floating license, can use the same license server for all deployments across all teams. The license server is a lightweight application that can be deployed on a small CPU only machine.

No Existing Deployments

Customers with no existing deployments can follow the above steps for getting either a Node Locked or Floating License using the latest release.

Existing License on a 7.x.x Deployment

Customers with existing 7.x.x deployments should follow the above steps for getting either a Node Locked or Floating License using their existing deployment. An upgrade to the latest (or any 8.0 and later releases) should occur only after getting a new license from the Customer Success team. The old heavy.license file should be deleted or renamed before attempting to upgrade.

Existing license on a 6.x.x deployment

Customers with existing 6.x.x deployments should first upgrade to a 7.0.x release and follow the steps specified in the above “Existing license on a HEAVY.AI 7.x.x deployment“ section.

In order to launch HeavyDB with privileged access using systemd, the [Service] User and [Service] Group fields in the /lib/systemd/system/heavydb.service file (see for more details) should be removed. The updated file should look like:

HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
HEAVY.AI
CUDA Compatibility Drivers | v7.2.4 (latest) | HEAVY.AI Docs