GBase Database Commercial Installation: A Step-by-Step Guide to License Loading

Summary: Installing GBase Database(GBase 8a) commercial edition requires more than extracting a package and starting services. This guide covers package compatibility checks, license preparation, cluster installation, license validation, and post-installation verification to help prevent avoidable deployment delays.

A commercial installation of GBase Database(GBase 8a) is not necessarily difficult. The real challenge is coordinating the installation package, target environment, node information, and License authorization before deployment begins.

For clusters with three or more nodes, a clear installation sequence can prevent a common problem: the software is installed, but the cluster is not ready for production because the License has not been loaded or validated correctly.

The recommended approach is to confirm compatibility first, prepare the License against the intended environment, install the cluster, and verify the final state before handover.

Step 1: Request the Commercial License Before Installation

Start with the License application process.

For the relevant GBase Database(GBase 8a) releases, commercial License authorization may be associated with the ESN and SSH private key of the GCware node. Confirm the exact requirements for your target release and provide the correct node information when requesting the License.

Applying too late can delay the project. If a relevant node or key changes during deployment, the existing License may need to be reissued.

Store the License file in an appropriate location, such as /opt, and ensure that the installation user can access it without exposing it to unauthorized users.

Before proceeding, record:

• Target GBase Database version
• Intended GCware node information
• Required License type
• License file location
• License validity period, where applicable

Step 2: Check CPU Architecture, Operating System, and Python

Before extracting the package, verify three compatibility dimensions: processor architecture, operating system, and Python runtime.

Run the following commands on the target host:

uname -m
grep -E '^(NAME|VERSION_ID)=' /etc/os-release
python -V

Interpret the results against the compatibility matrix for the exact GBase Database release.

CPU architecture

• Intel, Hygon, and Zhaoxin platforms generally use x86_64.
• Kunpeng and Phytium platforms generally use aarch64.
• Loongson and Sunway platforms may require separately confirmed packages.

Operating system

Package selection depends on the supported operating system release and kernel environment. For example, certain CentOS 8, openEuler, and Kylin V10 environments may use a redhat8 package family, while certain CentOS 7 environments use redhat7.

Do not assume that similarly named distributions are interchangeable. Confirm the exact supported combinations before installation.

Python runtime

The required Python interpreter depends on the installer and commercial package edition. The FREE edition and commercial builds may have different runtime requirements, and Python 3 builds may require separate licensing.

Verify the Python version on every node, not just the Coordinator. A runtime mismatch can cause deployment scripts to fail even when the binary package itself is correct.

Step 3: Extract the Installation Package

Copy the installation archive to /opt and extract it using the installation account and directory permissions required by your deployment procedure.

For example:

cp /tmp/GBase8a_MPP_Cluster-*.tar.bz2 /opt
cd /opt
tar -jxvf GBase8a_MPP_Cluster-*.tar.bz2
cd gcinstall

Confirm that the archive matches the target architecture, operating system, and release. If multiple package archives exist in the directory, identify the intended package explicitly rather than relying on a wildcard.

Step 4: Prepare the Installation Environment and Configuration

Use the environment preparation script supplied with the package when required by the release.

For example:

python SetSysEnv.py --dbaUser=gbase --installPrefix=/opt/gbase

Confirm the supported interpreter and script parameters in the package documentation before execution.

Next, prepare demo.options. The following is an illustrative configuration based on the fields in this deployment workflow:

installPrefix=/opt/gbase
dbaUser=gbase
dbaPwd=<DBA_PASSWORD>
sshPort=22
rootPwd=<ROOT_PASSWORD>

Replace the placeholders with the required credentials. Do not store real passwords in published documentation, shared scripts, or unrestricted configuration files.

The actual required fields and their names must match the demo.options format for your installed release. Configure the SSH port to match the target hosts; if the hosts use a non-default port, do not leave it set to 22.

Also verify SSH connectivity and authentication before starting a multi-node installation. Password parsing and special-character handling depend on the installer and configuration mechanism. Rather than weakening credentials, follow the supported escaping or credential-handling procedure for the target version.

Step 5: Load the License During Commercial Installation

For releases that support this syntax, specify the commercial License file with --license_file:

./gcinstall.py --license_file=/opt/gbase.lic --silent=demo.options

In this example:

• --license_file specifies the License file.
• --silent specifies the installation parameter file.

Check the exact command syntax and License loading behavior in the manual for your target GBase Database release.

The important principle is to plan License authorization as part of installation rather than assuming it can be added later without further checks. If the License was not loaded, determine the supported recovery procedure before considering a reinstall.

Step 6: Verify Services, License Status, and Cluster State

After installation, verify the environment in a controlled sequence.

If the relevant profile and service-management commands apply to your release, the workflow may resemble the following:

source ~/.gbase_profile
gcware_services all start
gcluster_services all start

Only start or restart services when required by the documented installation procedure and the current cluster state.

Next, check License status. For versions that support the following command syntax:

chkLicense -n 10.10.10.1,10.10.10.2 -u gbase -p '<DBA_PASSWORD>'

Use the actual node IP addresses and supported authentication options for your environment. Avoid placing real passwords directly in shell commands where they could be exposed through shell history or process inspection.

Review these fields in the output:

• is_exist — Whether the License file exists.
• version — The reported License category, such as business or trial.
• is_valid — Whether the License is valid.

For a commercial deployment, confirm that the reported License category and validity match the intended authorization.

Finally, inspect the cluster with:

gcadmin

Use the status definitions for your installed release to interpret the result. If the cluster remains close, do not immediately reinstall. Check whether the License was loaded, whether authorization is valid, and whether the services and node configuration are correct.

A License file's existence alone does not prove that authorization is working. Similarly, a cluster status should be evaluated alongside the relevant service and License checks.

For multi-node environments, verify all relevant nodes rather than assuming that a successful check against one machine proves the entire cluster is ready.

Step 7: Document the Installation for Handover

A deployment is not complete until the operations team can verify what was installed and maintain it afterward.

Record the following information in the handover document:

• GBase Database version and package filename
• CPU architecture, operating system, and Python version
• Node IP addresses and relevant ESN information
• GCware node and cluster role assignments
• License type, validation result, and expiry date where applicable
• Location of protected key backups and recovery documentation
• Final service and cluster-status verification results

Changes to relevant nodes or keys may affect License authorization. Assess these impacts before a node replacement, operating system reinstall, or other significant infrastructure change.

A complete handover record reduces uncertainty during maintenance, expansion, and future troubleshooting.

Important Version Note: GBase Database 9.5.3.27

The License system and related installation procedures differ around the 9.5.3.27 release boundary.

License formats, command parameters, loading behavior, and activation procedures may vary. Do not copy commands from another environment without confirming the target version and its documentation.

This is also why package selection, runtime verification, and License preparation should be completed before the installation window begins.

Conclusion

A successful GBase Database(GBase 8a) commercial installation starts before the first command is executed.

Confirm the package against the target CPU architecture and operating system. Verify the Python runtime across all nodes. Request and prepare the appropriate License. Load it using the supported installation procedure, then validate License status and cluster readiness before handover.

The key lesson is simple: installation completion, License validity, and production readiness are three separate checkpoints.

Treating them as one documented workflow helps reduce avoidable delays and makes future cluster maintenance more predictable.