Set up Vertica on-premises

• 1: Installation overview and checklist
• 2: Before you install Vertica
• 2.1: Platform and hardware requirements and recommendations
• 2.2: Communal storage for on-premises Eon Mode databases
• 2.3: Configure the network
• 2.3.1: Reserved ports
• 2.3.2: Firewall considerations
• 2.4: Operating system configuration overview
• 2.5: Automatically configured operating system settings
• 2.5.1: Sysctl
• 2.5.2: Nice limits configuration
• 2.5.3: min_free_kbytes setting
• 2.5.4: User max open files limit
• 2.5.5: System max open files limit
• 2.5.6: Pam limits
• 2.5.7: pid_max setting
• 2.5.8: User address space limits
• 2.5.9: User file size limit
• 2.5.10: User process limit
• 2.5.11: Maximum memory maps configuration
• 2.6: Manually configured operating system settings
• 2.6.1: SUSE control groups configuration
• 2.6.2: Cron required for scheduled jobs
• 2.6.3: Disk readahead
• 2.6.4: I/O scheduling
• 2.6.5: Enabling or disabling transparent hugepages
• 2.6.6: Check for swappiness
• 2.6.7: Enabling network time protocol (NTP)
• 2.6.8: Enabling chrony or ntpd for Red Hat and CentOS systems
• 2.6.9: SELinux configuration
• 2.6.10: CPU frequency scaling
• 2.6.11: Enabling or disabling defrag
• 2.6.12: Support tools
• 2.7: System user configuration
• 2.7.1: System user requirements
• 2.7.2: TZ environment variable
• 2.7.3: LANG environment variable settings
• 2.7.4: Package dependencies
• 3: Install Vertica using the command line
• 3.1: Download and install the Vertica server package
• 3.2: Linux users created by Vertica
• 3.3: Validation scripts
• 3.3.1: Vcpuperf
• 3.3.2: Vioperf
• 3.3.3: Vnetperf
• 3.4: Install Vertica with the installation script
• 3.4.1: Install on a FIPS 140-2 enabled machine
• 3.4.2: Specifying disk storage location during installation
• 3.4.3: Perform a basic install
• 3.4.4: install_vertica options
• 3.5: Install Vertica silently
• 3.6: Enable secure shell (SSH) logins
• 4: After you install Vertica

1 - Installation overview and checklist

Carefully review and complete the installation tasks in all sections of this topic.

Important notes

• Vertica supports only one running database per cluster.

• Vertica supports installation on one, two, or multiple nodes. The steps for Installing Vertica are the same, no matter how many nodes are in the cluster.

• Prerequisites listed in Before You Install Vertica are required for all Vertica configurations.

• Only one instance of Vertica can be running on a host at any time.

• To run the install_vertica script, as well as adding, updating, or deleting nodes, you must be logged in as root, or sudo as a user with all privileges. You must run the script for all installations, including upgrades and single-node installations.

Installation scenarios

The three main scenarios for installing Vertica on hosts are:

• A single node install, where Vertica is installed on a single host as a localhost process. This form of install cannot be expanded to more hosts later on and is typically used for development or evaluation purposes.

• Installing to a cluster of physical host hardware. This is the most common scenario when deploying Vertica in a testing or production environment.

• Installing to a local cluster of virtual host hardware. This is similar to installing on physical hosts, but with network configuration differences.

Before you install

Before You Install Vertica describes how to construct a hardware platform and prepare Linux for Vertica installation.

These preliminary steps are broken into two categories:

• Configuring Hardware and Installing Linux

• Configuring the Network

Install or upgrade Vertica

Once you have completed the steps in the Before You Install Vertica section, you are ready to run the install script.

Installing Vertica describes how to:

• Back up any existing databases.

• Download and install the Vertica RPM package.

• Install a cluster using the install_vertica script.

• [Optional] Create a properties file that lets you install Vertica silently.

Post-installation tasks

After You Install Vertica describes subsequent steps to take after you've run the installation script. Some of the steps can be skipped based on your needs:

• Install the license key.

• Verify that kernel and user parameters are correctly set.

• Install the vsql client application on non-cluster hosts.

• Resolve any SLES 11.3 issues during spread configuration.

• Use the Vertica documentation online, or download and install Vertica documentation. Find the online documentation and documentation packages to download at https://docs.vertica.com/latest.

• Install client drivers.

• Extend your installation with Vertica packages.

• Install or upgrade the Management Console.

2 - Before you install Vertica

Complete all of the tasks in this section before you install Vertica. When you have completed this section, proceed to Install Vertica using the command line.

2.1 - Platform and hardware requirements and recommendations

Hardware recommendations

The Vertica Analytics Platform is based on a massively parallel processing (MPP), shared-nothing architecture, in which the query processing workload is divided among all nodes of the Vertica database. OpenText highly recommends using a homogeneous hardware configuration for your Vertica cluster; that is, each node of the cluster should be similar in CPU, clock speed, number of cores, memory, and operating system version.

Note that OpenText has not tested Vertica on clusters made up of nodes with disparate hardware specifications. While it is expected that a Vertica database would functionally work in a mixed hardware configuration, performance will be limited to that of the slowest node in the cluster.

Vertica performs best on processors with higher clock frequency. When possible, choose a faster processor with fewer cores as opposed to a slower processor with more cores.

Tests performed both internally and by customers have shown performance differences between processor architectures even when accounting for differences in core count and clock frequency. When possible, compare platforms by installing Vertica and running experiments using your data and workloads. Consider testing on cloud platforms that offer VMs running on different processor architectures, even if you intend to deploy your Vertica database on premises.

Detailed hardware recommendations are available in Recommendations for Sizing Vertica Nodes and Clusters.

Platform requirements and recommendations

You must verify that your servers meet the platform requirements described in Supported Platforms. The Supported Platforms topics detail supported versions for the following:

• OS for Server and Management Console (MC)

• Supported Browsers for MC

• Supported File Systems

Install the latest vendor-specific system software

Install the latest vendor drivers for your hardware.

Data storage recommendations

• All internal drives connect to a single RAID controller.

• The RAID array should form one hardware RAID device as a contiguous /data volume.

Install Perl

Before you perform the cluster installation, install Perl 5 on all the target hosts. Perl is available for download from www.perl.org.

Validation utilities

Vertica provides several validation utilities that validate the performance on prospective hosts. The utilities are installed when you install the Vertica RPM, but you can use them before you run the install_vertica script. See Validation scripts for more details on running the utilities and verifying that your hosts meet the recommended requirements.

Verify sudo

Vertica uses the sudo command during installation and some administrative tasks. Ensure that sudo is available on all hosts with the following command:

# which sudo
/usr/bin/sudo

If sudo is not installed, on all hosts, follow the instructions in How to Enable sudo on Red Hat Enterprise Linux.

When you use sudo to install Vertica, the user that performs the installation must have privileges on all nodes in the cluster.

Configuring sudo with privileges for the individual commands can be a tedious and error-prone process; thus, the Vertica documentation does not include every possible sudo command that you can include in the sudoers file. Instead, Vertica recommends that you temporarily elevate the sudo user to have all privileges for the duration of the install.

To allow root sudo access on all commands as any user on any machine, use visudo as root to edit the /etc/sudoers file and add this line:

## Allow root to run any commands anywhere
root   ALL=(ALL) ALL

After the installation completes, remove (or reset) sudo privileges to the pre-installation settings.

BASH shell requirements

All shell scripts included in Vertica must run under the BASH shell. If you are on a Debian system, then the default shell can be DASH. DASH is not supported. Change the shell for root and for the dbadmin user to BASH with the chsh command.

For example:

# getent passwd | grep root
root:x:0:0:root:/root:/bin/dash

# chsh
Changing shell for root.
New shell [/bin/dash]: /bin/bash
Shell changed.

Then, as root, change the symbolic link for /bin/sh from /bin/dash to /bin/bash:

# rm /bin/sh
# ln -s /bin/bash /bin/sh

Log out and back in for the change to take effect.

2.2 - Communal storage for on-premises Eon Mode databases

If you create an Eon Mode database, you must plan for your use of communal storage to store your database's data. Communal storage is based on a shared storage, such as AWS S3 or Pure Storage FlashBlade servers.

Whatever communal storage platform you use, you must ensure that it is durable (protected against data loss). The data in your Eon Mode database is only as safe as the communal storage that contains it. Most cloud provider's object stores come with a guaranteed redundancy to prevent data loss. When you install an Eon Mode database on-premises, you may have to take additional steps to prevent data loss.

Planning communal storage capacity for on-premises databases

Most cloud providers do not limit the amount of data you can store in their object stores. The only real limit is your budget; storing more data costs more money.

When you create an Eon Mode database on-premises, your storage is limited to the size of your communal storage. Unlike the cloud, you must plan ahead for the amount of storage you will need. For example, if you have a Pure Admin FlashBlade installation with three 8TB blades, then in theory, your database can grow up to 24TB. In practice, you need to account other uses of your object store, as well as factors such as data compression, and space consumed by unreaped ROS containers (storage containers no longer used by Vertica but not yet deleted by the object store).

The following calculator helps you determine the size for your communal storage needs, based on your estimated data size and additional uses of your communal storage. The values with white backgrounds in the Value column are editable. Change them to reflect your environment.

2.3 - Configure the network

This group of steps involve configuring the network. These steps differ depending on your installation scenario. A single node installation requires little network configuration, because the single instance of the Vertica server does not need to communication with other nodes in a cluster. For cluster install scenarios, you must make several decisions regarding your configuration.

Vertica supports server configuration with multiple network interfaces. For example, you might want to use one as a private network interface for internal communication among cluster hosts (the ones supplied via the --hosts option to install_vertica) and a separate one for client connections.

Important notes

• Network configuration is exactly the same for single nodes as for multi-node clusters, with one special exception. If you install Vertica on a single host machine that is to remain a permanent single-node configuration (such as for development or Proof of Concept), you can install Vertica using localhost or the loopback IP (typically 127.0.0.1) as the value for --hosts. Do not use the hostname localhost in a node definition if you are likely to add nodes to the configuration later.

• If you are using a host with multiple network interfaces, configure Vertica to use the address which is assigned to the NIC that is connected to the other cluster hosts.

• Use a dedicated gigabit switch. If you do not performance could be severely affected.

• Do not use DHCP dynamically-assigned IP addresses for the private network. Use only static addresses or permanently-leased DHCP addresses.

Choose IPv4 or IPv6 addresses for host identification and communications

Vertica supports using either IPv4 or IPv6 IP addresses for identifying the hosts in a database cluster. Vertica uses a single address to identify a host in the database cluster. All the IP addresses used to identify hosts in the cluster must use the same IP family.

The hosts in your database cluster can have both IPv4 and IPv6 network addresses assigned to them. Only one of these addresses is used to identify the node within the cluster. You can use the other addresses to handle client connections or connections to other systems.

You tell Vertica which address family to use when you install it. By default, Vertica uses IPv4 addresses for hosts. If you want the nodes in your database to use IPv6 addresses, add the --ipv6 option to the arguments you pass to the install_vertica script.

In most cases, the address family you select does not impact how your database functions. However, there are a few exceptions:

• Use IPv4 addresses to identify the nodes in your cluster if you want to use the Management Console to manage your database. Currently, the MC does not support databases that use IPv6 addresses.

• If you select IPv6 addressing for your cluster, it automatically uses point-to-point networking mode.

• Currently, AWS is the only cloud platform on which Vertica supports IPv6 addressing. To use IPv6 on AWS, you must identify cluster hosts using IP addresses instead of host names. The AWS DNS does not support resolving host names to IPv6.

• If you only assign IPv6 addresses to the hosts in your database cluster, you may have problems interfacing to other systems that do not support IPv6.

Part of the information you pass to the install script is the list of hosts it will use to form the Vertica cluster. If you use host names in this list instead of IP addresses, ensure that the host names resolve to the IP address family you want to use for your cluster. For example, if you want your cluster to use IPv6 addresses, ensure your DNS or /etc/hosts file resolves the host names to IPv6 addresses.

You can configure DNS to return both IPv4 and IPv6 addresses for a host name. In this case, the installer uses the IPv4 address unless you supply the --ipv6 argument. If you use /etc/hosts for host name resolution (which is the best practice), host names cannot resolve to both IPv4 and IPv6 addresses.

Optionally run spread on a separate control network

If your query workloads are network intensive, you can use the --control-network parameter with the install_vertica script (see Install Vertica with the installation script) to allow spread communications to be configured on a subnet that is different from other Vertica data communications.

The --control-network parameter accepts either the default value or a broadcast network IP address (for example, 192.168.10.255 ).

Configure SSH

• Verify that root can use Secure Shell (SSH) to log in (ssh) to all hosts that are included in the cluster. SSH (SSH client) is a program for logging into a remote machine and for running commands on a remote machine.

• If you do not already have SSH installed on all hosts, log in as root on each host and install it before installing Vertica. You can download a free version of the SSH connectivity tools from OpenSSH.

• Make sure that /dev/pts is mounted. Installing Vertica on a host that is missing the mount point /dev/pts could result in the following error when you create a database:

TIMEOUT ERROR: Could not login with SSH. Here is what SSH said:Last login: Sat Dec 15 18:05:35 2007 from v_vmart_node0001

Allow passwordless SSH access for the dbadmin user

The dbadmin user must be authorized for passwordless ssh. In typical installs, you won't need to change anything; however, if you set up your system to disallow passwordless login, you'll need to enable it for the dbadmin user. See Enable secure shell (SSH) logins.

2.3.1 - Reserved ports

The install_vertica script checks that required ports are open and available to Vertica. The installer reports any issues with identifier N0020.

You can also verify that ports required by Vertica are not in use by running the following command as the root user and comparing it with the ports required, as shown below:

$ ss -atupn

Firewall requirements

Vertica requires several ports to be open on the local network. Vertica does not recommend placing a firewall between nodes (all nodes should be behind a firewall), but if you must use a firewall between nodes, ensure the following ports are available:

2.3.2 - Firewall considerations

Vertica requires multiple ports be open between nodes. You may use a firewall (IP Tables) on Redhat/CentOS and Ubuntu/Debian based systems. Note that firewall use is not supported on SuSE systems and that SuSE systems must disable the firewall. The installer reports issues found with your IP tables configuration with the identifiers N0010 for (systems that use IP Tables) and N011 (for SuSE systems).

The installer checks the IP tables configuration and issues a warning if there are any configured rules or chains. The installer does not detect if the configuration may conflict with Vertica. It is your responsibility to verify that your firewall allows traffic for Vertica as described in Reserved ports.

You can modify your firewall to allow for Vertica network traffic, or you can disable the firewall if your network is secure. Note that firewalls are not supported for Vertica systems running on SuSE.

Red Hat and CentOS systems:

To disable the system firewall, run the following command as root or sudo:

# systemctl mask firewalld
# systemctl disable firewalld
# systemctl stop firewalld

Ubuntu and Debian systems

For details on how to configure iptables and allow specific ports to be open, see the platform-specific documentation for your platform:

• Debian: https://wiki.debian.org/iptables

• Ubuntu: https://help.ubuntu.com/12.04/serverguide/firewall.html.

To disable iptables on Debian, run the following command as root or sudo:

$ /etc/init.d/iptables stop

$ update-rc.d -f iptables remove

To disable iptables on Ubuntu, run the following command:

$ sudo ufw disable

SuSE systems

The firewall must be disabled on SUSE systems. To disable the firewall on SuSE systems, run the following command:

# /sbin/SuSEfirewall2 off

2.4 - Operating system configuration overview

This topic provides a high-level overview of the OS settings required for Vertica. Each item provides a link to additional details about the setting and detailed steps on making the configuration change. The installer tests for all of these settings and provides hints, warnings, and failures if the current configuration does not meet Vertica requirements.

Before you install the operating system

The below sections detail system settings that must be configured when you install the operating system. These settings cannot be easily changed after the operating system is installed.

Automatically configured operating system settings

These general OS settings are automatically made by the installer if they do not meet Vertica requirements. You can prevent the installer from automatically making these configuration changes by using the --no-system-configuration parameter for the install_vertica script.

For more information on each configuration setting, see Automatically configured operating system settings.

Manually configured operating system settings

For more information on each configuration setting, see Manually configured operating system settings.

System user requirements

The following tasks pertain to the configuration of the system user required by Vertica.

For more information on each configuration setting, see System user configuration.

2.5 - Automatically configured operating system settings

These general Operating System settings are automatically made by the installer. You can prevent the installer from automatically making these configuration changes by using the --no-system-configuration parameter for the install_vertica script.

2.5.1 - Sysctl

During installation, Vertica attempts to automatically change various OS level settings. The installer may not change values on your system if they exceed the threshold required by the installer. You can prevent the installer from automatically making these configuration changes by using the --no-system-configuration parameter for the install_vertica script.

To permanently edit certain settings and prevent them from reverting on reboot, use sysctl.

The sysctl settings relevant to the installation of Vertica include:

• min_free_kbytes

• fs.file_max

• vm.max_map_count

Permanently changing settings with sysctl:

1. As the root user, open the /etc/sysctl.conf file:

   # vi /etc/sysctl.conf
   

2. Enter a parameter and value:

   parameter = value
   

   For example, to set the parameter and value for fs.file-max to meet Vertica requirements, enter:

   fs.file-max = 65536
   

3. Save your changes, and close the /etc/sysctl.conf file.

4. As the root user, reload the config file:

   # sysctl -p
   

Identifying settings added by the installer

You can see whether the installer has added a setting by opening the /etc/sysctl.conf file:

# vi /etc/sysctl.conf

If the installer has added a setting, the following line appears:

# The following 1 line added by Vertica tools. 2015-02-23 13:20:29
parameter = value

2.5.2 - Nice limits configuration

The Vertica system user (dbadmin by default) must be able to raise and lower the priority of Vertica processes. To do this, the nice option in the /etc/security/limits.conf file must include an entry for the dbadmin user. The installer reports this issue with the identifier: S0010.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

All systems

To set the Nice Limit configuration for the dbadmin user, edit /etc/security/limits.conf and add the following line. Replace dbadmin with the name of your system user.

dbadmin -       nice    0

2.5.3 - min_free_kbytes setting

This topic details how to update the min_free_kbytes setting so that it is within the range supported by Vertica. The installer reports this issue with the identifier: S0050 if the setting is too low, or S0051 if the setting is too high.

The vm.min_free_kbytes setting configures the page reclaim thresholds. When this number is increased the system starts reclaiming memory earlier, when its lowered it starts reclaiming memory later. The default min_free_kbytes is calculated at boot time based on the number of pages of physical RAM available on the system.

The setting must be whichever value is the greatest from the following options:

• The default value configured by the system

• 4096

• The result of running the commands:

  $ memtot=`grep MemTotal /proc/meminfo | awk '{printf "%.0f",$2}'`
  $ echo "scale=0;sqrt ($memtot*16)" | bc
  

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

All systems

To manually set min_free_kbytes:

1. Determine the current/default setting with the following command:

   $ sysctl vm.min_free_kbytes
   

2. If the result of the previous command is No such file or directory or the default value is less than 4096, then run these commands to determine the correct value:

   $ memtot=`grep MemTotal /proc/meminfo | awk '{printf "%.0f",$2}'`
   $ echo "scale=0;sqrt ($memtot*16)" | bc
   

3. Edit or add the current value of vm.min_free_kbytes in /etc/sysctl.conf with the value from the output of the previous command.

   # The min_free_kbytes setting
   vm.min_free_kbytes=16132
   

4. Run sysctl -p to apply the changes in sysctl.conf immediately.

   Note

   These steps must be repeated for each node in the cluster.

2.5.4 - User max open files limit

This topic details how to change the user max open-files limit setting to meet Vertica requirements. The installer reports this issue with the identifier S0060.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

Vertica requires that the dbadmin user not be limited when opening files. The open file limit per user is calculated as follows:

user max open files = greater of { ≥ 65536 | ≤ RAM-MBs }

As a dbadmin user, you can determine the open file limit by running ulimit -n. For example:

$ ulimit -n
65536

To manually set the limit, edit /etc/security/limits.conf and edit/add the nofile setting for the user who is configured as the database administrator—by default, dbadmin. For example:

dbadmin -       nofile  65536

The setting must be no less than 65536 MB, but not greater than the system value of fs.nr_open. For example, the default value of fs.nr_open value on Red Hat Enterprise Linux 9 is 1048576 MB.

2.5.5 - System max open files limit

This topic details how to modify the limit for the number of open files on your system so that it meets Vertica requirements. The installer reports this issue with the identifier: S0120.

Vertica opens many files. Some platforms have global limits on the number of open files. The open file limit must be set sufficiently high so as not to interfere with database operations.

The recommended value is at least the amount of memory in MB, but not less than 65536.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

All systems

To manually set the open file limit:

1. Run /sbin/sysctl fs.file-max to determine the current limit.

2. If the limit is not 65536 or the amount of system memory in MB (whichever is higher), then edit or add fs.file-max=max number of files to /etc/sysctl.conf.

   # Controls the maximum number of open files
   fs.file-max=65536
   

3. Run sysctl -p to apply the changes in sysctl.conf immediately.

2.5.6 - Pam limits

This topic details how to enable the "su" pam_limits.so module required by Vertica. The installer reports issues with the setting with the identifier: S0070.

On some systems the pam module called pam_limits.so is not set in the file /etc/pam.d/su. When it is not set, it prevents the conveying of limits (such as open file descriptors) to any command started with su -.

In particular, the Vertica init script would fail to start Vertica because it calls the Administration Tools to start a database with the su - command. This problem was first noticed on Debian systems, but the configuration could be missing on other Linux distributions. See the pam_limits man page for more details.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

All systems

To manually configure this setting, append the following line to the /etc/pam.d/su file:

session required pam_limits.so

See the pam_limits man page for more details: man pam_limits.

2.5.7 - pid_max setting

This topic explains how to change pid_max to a supported value. The value of pid_max should be

pid_max = num-user-proc + 2**15 = num-user-proc + 32768

where num-user-proc is the size of memory in megabytes.

The minimum value for pid_max is 524288.

If your pid_max value is too low, the installer reports this problem and indicates the minimum value.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

All systems

To change the pid_max value:

# sysctl -w kernel.pid_max=524288

2.5.8 - User address space limits

This topic details how to modify the Linux address space limit for the dbadmin user so that it meets Vertica requirements. The address space setting controls the maximum number of threads and processes for each user. If this setting does not meet the requirements then the installer reports this issue with the identifier: S0090.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

The address space available to the dbadmin user must not be reduced via user limits and must be set to unlimited.

All systems

To manually set the address space limit:

1. Run ulimit -v as the dbadmin user to determine the current limit.

2. If the limit is not unlimited, then add the following line to /etc/security/limits.conf. Replace dbadmin with your database admin user

dbadmin -       as      unlimited

2.5.9 - User file size limit

This topic details how to modify the file size limit for files on your system so that it meets Vertica requirements. The installer reports this issue with the identifier: S0100.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

The file size limit for the dbadmin user must not be reduced via user limits and must be set to unlimited.

All systems

To manually set the file size limit:

1. Run ulimit -f as the dbadmin user to determine the current limit.

2. If the limit is not unlimited, then edit/add the following line to /etc/security/limits.conf. Replace dbadmin with your database admin user.

dbadmin -       fsize      unlimited

2.5.10 - User process limit

This topic details how to change the user process limit so that it meets Vertica requirements.The installer reports this issue with the identifier: S0110.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

The user process limit must be high enough to allow for the many threads opened by Vertica. The recommended limit is the amount of RAM in MB and must be at least 1024.

All systems

To manually set the user process limit:

1. Run ulimit -u as the dbadmin user to determine the current limit.

2. If the limit is not the amount of memory in MB on the server, then edit/add the following line to /etc/security/limits.conf. Replace 4096 with the amount of system memory, in MB, on the server.

dbadmin -       nproc     4096

2.5.11 - Maximum memory maps configuration

This topic details how to modify the limit for the number memory maps a process can have on your system so that it meets Vertica requirements. The installer reports this issue with the identifier: S0130.

The installer automatically configures the correct setting if the default value does not meet system requirements. If an issue occurs when setting this value, or you use the --no-system-configuration argument to the installer and the current setting is incorrect, then the installer reports this as an issue.

Vertica uses a lot of memory while processing and can approach the default limit for memory maps per process.

The recommended value is at least the amount of memory on the system in KB / 16, but not less than 65536.

All systems

To manually set the memory map limit:

1. Run /sbin/sysctl vm.max_map_count to determine the current limit.

2. If the limit is not 65536 or the amount of system memory in KB / 16 (whichever is higher), then edit/add the following line to /etc/sysctl.conf. Replace 65536 with the value for your system.

   
   # The following 1 line added by Vertica tools. 2014-03-07 13:20:31
   
   
   vm.max_map_count=65536
   

3. Run sysctl -p to apply the changes in sysctl.conf immediately.

2.6 - Manually configured operating system settings

The topics in this section detail general Operating System settings that must be set manually.

Persisting operating system settings

To prevent manually set Operating System settings from reverting on reboot, you should configure some of these settings in the /etc/rc.local script. This script contains commands and scripts that run each time the system is booted.

Vertica uses settings in /etc/rc.local to set the following functionality:

• Disk readahead
• I/O scheduling
• Enabling or disabling transparent hugepages

Editing /etc/rc.local

1. As the root user, open /etc/rc.local:

   # vi /etc/rc.local
   

2. Enter a script or command. For example, to configure transparent hugepages to meet Vertica requirements, enter the following:

   echo never > /sys/kernel/mm/redhat_transparent_hugepage/enabled
   

   Important

   On some Ubuntu/Debian systems, the last line in /etc/rc.local must be exit 0. All additions to /etc/rc.local must precede this line.

3. Save your changes, and close /etc/rc.local.

4. If you use Red Hat 7.0 or CentOS 7.0 or higher, run the following command as root or sudo:

   $ chmod +x /etc/rc.d/rc.local
   

On reboot, the command runs during startup. You can also run the command manually as the root user, if you want it to take effect immediately.

Disabling tuning system service

If you use Red Hat 7.0 or CentOS 7.0 or higher, make sure the tuning system service does not start on when Vertica reboots. Turning off tuning prevents monitoring of your OS and any tuning of your OS based on this monitoring. Tuning also enables THP silently, which can cause issues in other areas such as read ahead.

Run the following command as sudo or root:

$ chkconfig tuned off

2.6.1 - SUSE control groups configuration

On SuSE 12, the installer checks the control group (cgroup) setting for the cgroups that Vertica may run under:

• verticad

• vertica_agent

• sshd

The installer verifies that the pid.max resource is large enough for all the threads that Vertica creates. We check the contents of:

• /sys/fs/cgroup/pids/system.slice/verticad.service/pids.max

• /sys/fs/cgroup/pids/system.slice/vertica_agent.service/pids.max

• /sys/fs/cgroup/pids/system.slice/sshd.service/pids.max

If these files exist and they fail to include the value max, the installation stops and the installer returns a failure message (code S0340).

If these files do not exist, they are created automatically when the systemd runs the verticad and vertica_agent startup scripts. However, the site's cgroup configuration process managed their default values. Vertica does not change the defaults.

Pre-installation configuration

Before installing Vertica, configure your system as follows:

# Create the following directories:
sudo mkdir /sys/fs/cgroup/pids/system.slice/verticad.service/
sudo mkdir /sys/fs/cgroup/pids/system.slice/vertica_agent.service/
# sshd service dir should already exist, so don't need to create it

# Set pids.max values:
sudo sh -c 'echo "max" > /sys/fs/cgroup/pids/system.slice/verticad.service/pids.max'
sudo sh -c 'echo "max" > /sys/fs/cgroup/pids/system.slice/vertica_agent.service/pids.max'
sudo sh -c 'echo "max" > /sys/fs/cgroup/pids/system.slice/sshd.service/pids.max'

Persisting configuration for restart

After installation, you can configure control groups for subsequent reboots of the Vertica database. You do so by editing configuration file /etc/init.d/after.local and adding the commands shown earlier.

2.6.2 - Cron required for scheduled jobs

Admintools uses the Linux cron package to schedule jobs that regularly rotate the database logs. Without this package installed, the database logs will never be rotated. The lack of rotation can lead to a significant consumption of storage for logs. On busy clusters, Vertica can produce hundreds of gigabytes of logs per day.

cron is installed by default on most Linux distributions, but it may not be present on some SUSE 12 systems.

To install cron, run this command:

$ sudo zypper install cron

2.6.3 - Disk readahead

Vertica requires that Disk Readahead be set to at least 2048. The installer reports this issue with the identifier: S0020.

RedHat/CentOS and SuSE based systems

For each drive in the Vertica system, Vertica recommends that you set the readahead value to at least 2048 for most deployments. The command immediately changes the readahead value for the specified disk. The second line adds the command to /etc/rc.local so that the setting is applied each time the system is booted. Note that some deployments may require a higher value and the setting can be set as high as 8192, under guidance of support.

The following example sets the readahead value of the drive sda to 2048:

$ /sbin/blockdev --setra 2048 /dev/sda
$ echo '/sbin/blockdev --setra 2048 /dev/sda' >> /etc/rc.local

If you are using Red Hat 7.0 or CentOS 7.0 or higher, run the following command as root or sudo:

$ chmod +x /etc/rc.d/rc.local

Ubuntu and debian systems

For each drive in the Vertica system, set the readahead value to 2048. Run the command once in your shell, then add the command to /etc/rc.local so that the setting is applied each time the system is booted. Note that on Ubuntu systems, the last line in rc.local must be "exit 0". So you must manually add the following line to etc/rc.local before the last line with exit 0.

/sbin/blockdev --setra 2048 /dev/sda

2.6.4 - I/O scheduling

Vertica requires that I/O Scheduling be set to deadline or noop. The installer checks what scheduler the system is using, reporting an unsupported scheduler issue with identifier: S0150. If the installer cannot detect the type of scheduler in use (typically if your system is using a RAID array), it reports that issue with identifier: S0151.

If your system is not using a RAID array, then complete the following steps to change your system to a supported I/O Scheduler. If you are using a RAID array, then consult your RAID vendor documentation for the best performing scheduler for your hardware.

Configure the I/O scheduler

The Linux kernel can use several different I/O schedulers to prioritize disk input and output. Most Linux distributions use the Completely Fair Queuing (CFQ) scheme by default, which gives input and output requests equal priority. This scheduler is efficient on systems running multiple tasks that need equal access to I/O resources. However, it can create a bottleneck when used on Vertica drives containing the catalog and data directories, because it gives write requests equal priority to read requests, and its per-process I/O queues can penalize processes making more requests than other processes.

Instead of the CFQ scheduler, configure your hosts to use either the Deadline or NOOP I/O scheduler for the drives containing the catalog and data directories:

• The Deadline scheduler gives priority to read requests over write requests. It also imposes a deadline on all requests. After reaching the deadline, such requests gain priority over all other requests. This scheduling method helps prevent processes from becoming starved for I/O access. The Deadline scheduler is best used on physical media drives (disks using spinning platters), since it attempts to group requests for adjacent sectors on a disk, lowering the time the drive spends seeking.

• The NOOP scheduler uses a simple FIFO approach, placing all input and output requests into a single queue. This scheduler is best used on solid state drives (SSDs). Because SSDs do not have a physical read head, no performance penalty exists when accessing non-adjacent sectors.

Failure to use one of these schedulers for the Vertica drives containing the catalog and data directories can result in slower database performance. Other drives on the system (such as the drive containing swap space, log files, or the Linux system files) can still use the default CFQ scheduler (although you should always use the NOOP scheduler for SSDs).

You can set your disk device scheduler by writing the name of the scheduler to a file in the /sys directory or using a kernel boot parameter.

Changing the scheduler through the /sys directory

You can view and change the scheduler Linux uses for I/O requests to a single drive using a virtual file under the /sys directory. The name of the file that controls the scheduler a block device uses is:

/sys/block/deviceName/queue/scheduler

Where deviceName is the name of the disk device, such as sda or cciss\!c0d1 (the first disk on an OpenText RAID array). Viewing the contents of this file shows you all of the possible settings for the scheduler. The currently-selected scheduler is surrounded by square brackets:

# cat /sys/block/sda/queue/scheduler
noop deadline [cfq]

To change the scheduler, write the name of the scheduler you want the device to use to its scheduler file. You must have root privileges to write to this file. For example, to set the sda drive to use the deadline scheduler, run the following command as root:

# echo deadline > /sys/block/sda/queue/scheduler
# cat /sys/block/sda/queue/scheduler
noop [deadline] cfq

Changing the scheduler immediately affects the I/O requests for the device. The Linux kernel starts using the new scheduler for all of the drive's input and output requests.

Changes to the I/O scheduler made through the /sys directory only last until the system is rebooted, so you need to add the commands that change the I/O scheduler to a startup script (such as those stored in /etc/init.d, or though a command in /etc/rc.local). You also need to use a separate command for each drive on the system whose scheduler you want to change.

For example, to make the configuration take effect immediately and add it to rc.local so it is used on subsequent reboots.

echo deadline > /sys/block/sda/queue/scheduler
echo 'echo deadline > /sys/block/sda/queue/scheduler' >> /etc/rc.local

You may prefer to use this method of setting the I/O scheduler over using a boot parameter if your system has a mix of solid-state and physical media drives, or has many drives that do not store Vertica catalog and data directories.

If you are using Red Hat 7.0 or CentOS 7.0 or higher, run the following command as root or sudo:

$ chmod +x /etc/rc.d/rc.local

Changing the scheduler with a boot parameter

Use the elevator kernel boot parameter to change the default scheduler used by all disks on your system. This is the best method to use if most or all of the drives on your hosts are of the same type (physical media or SSD) and will contain catalog or data files. You can also use the boot parameter to change the default to the scheduler the majority of the drives on the system need, then use the /sys files to change individual drives to another I/O scheduler. The format of the elevator boot parameter is:

elevator=schedulerName

Where schedulerName is deadline, noop, or cfq. You set the boot parameter using your bootloader (grub or grub2 on most recent Linux distributions). See your distribution's documentation for details on how to add a kernel boot parameter.

2.6.5 - Enabling or disabling transparent hugepages

You can modify transparent hugepages to meet Vertica configuration requirements:

• For Red Hat/CentOS and SUSE 15.1, Vertica provides recommended settings to optimize your system performance by workload.

• For all other systems, you must disable transparent hugepages or set them to madvise. The installer reports this issue with the identifier: S0310.

Recommended settings by workload for Red Hat/CentOS and SUSE 15.1

Vertica recommends transparent hugepages settings to optimize performance by workload. The following table contains recommendations for systems that primarily run concurrent queries (such as short-running dashboard queries), or sequential SELECT or load (COPY) queries:

See Enabling or disabling defrag for additional settings that optimize your system performance by workload.

Enabling transparent hugepages on Red Hat/CentOS and SUSE 15.1

Determine if transparent hugepages is enabled. To do so, run the following command.

cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never

The setting returned in brackets is your current setting.

For systems that do not support /etc/rc.local, use the equivalent startup script that is run after the destination runlevel has been reached. For example SuSE uses /etc/init.d/after.local.

You can enable transparent hugepages by editing /etc/rc.local and adding the following script:

if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
    echo always > /sys/kernel/mm/transparent_hugepage/enabled
fi

You must reboot your system for the setting to take effect, or, as root, run the following echo line to proceed with the install without rebooting:

# echo always > /sys/kernel/mm/transparent_hugepage/enabled

If you are using Red Hat or CentOS or higher, run the following command as root or sudo:

$ chmod +x /etc/rc.d/rc.local

Disabling transparent hugepages on other systems

To determine if transparent hugepages is enabled, run the following command.

cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never

The setting returned in brackets is your current setting. Depending on your platform OS, the madvise setting may not be displayed.

You can disable transparent hugepages one of two ways:

• Edit your boot loader (for example /etc/grub.conf). Typically, you add the following to the end of the kernel line. However, consult the documentation for your system before editing your bootloader configuration.

  transparent_hugepage=never
  

• Edit /etc/rc.local (on systems that support rc.local) and add the following script.

  if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
     echo never > /sys/kernel/mm/transparent_hugepage/enabled
  fi
  

For systems that do not support /etc/rc.local, use the equivalent startup script that is run after the destination runlevel has been reached. For example SuSE uses /etc/init.d/after.local.

Regardless of which approach you choose, you must reboot your system for the setting to take effect, or run the following two echo lines to proceed with the install without rebooting:

echo never > /sys/kernel/mm/transparent_hugepage/enabled

2.6.6 - Check for swappiness

The swappiness kernel parameter defines the amount, and how often, the kernel copies RAM contents to a swap space. Vertica recommends a value of 0. The installer reports any swappiness issues with identifier S0112.

You can check the swappiness value by running the following command:

$ cat /proc/sys/vm/swappiness

To set the swappiness value add or update the following line in /etc/sysctl.conf:

vm.swappiness = 0

This also ensures that the value persists after a reboot.

If necessary, you change the swappiness value at runtime by logging in as root and running the following:

$ echo 0 > /proc/sys/vm/swappiness

2.6.7 - Enabling network time protocol (NTP)

The network time protocol (NTP) daemon must be running on all of the hosts in the cluster so that their clocks are synchronized. The spread daemon relies on all of the nodes to have their clocks synchronized for timing purposes. If your nodes do not have NTP running, the installation can fail with a spread configuration error or other errors.

Verify that NTP is running

To verify that your hosts are configured to run the NTP daemon on startup, enter the following command:

$ chkconfig --list ntpd

Debian and Ubuntu do not support chkconfig, but they do offer an optional package. You can install this package with the command sudo apt-get install sysv-rc-conf. To verify that your hosts are configured to run the NTP daemon on startup with the sysv-rc-conf utility, enter the following command:

$ sysv-rc-conf --list ntpd

The chkconfig command can produce an error similar to ntpd: unknown service. If you get this error, verify that your Linux distribution refers to the NTP daemon as ntpd rather than ntp. If it does not, you need to install the NTP daemon package before you can configure it. Consult your Linux documentation for instructions on how to locate and install packages.

If the NTP daemon is installed, your output should resemble the following:

ntp 0:off 1:off 2:on 3:on 4:off 5:on 6:off

The output indicates the runlevels where the daemon runs. Verify that the current runlevel of the system (usually 3 or 5) has the NTP daemon set to on. If you do not know the current runlevel, you can find it using the runlevel command:

$ runlevel
N 3

Configure NTP for red hat 6/CentOS 6 and SLES

If your system is based on Red Hat 6/CentOS 6 or SUSE Linux Enterprise Server, use the service and chkconfig utilities to start NTP and have it start at startup.

$ /sbin/service ntpd restart
$ /sbin/chkconfig ntpd on

• Red Hat 6/CentOS 6—NTP uses the default time servers at ntp.org. You can change the default NTP servers by editing /etc/ntpd.conf.

• SLES—By default, no time servers are configured. You must edit /etc/ntpd.conf after the install completes and add time servers.

Configure NTP for ubuntu and debian

By default, the NTP daemon is not installed on some Ubuntu and Debian systems. First, install NTP, and then start the NTP process. You can change the default NTP servers by editing /etc/ntpd.confas shown:

$ sudo apt-get install ntp
$ sudo /etc/init.d/ntp reload

Verify that NTP is operating correctly

To verify that the Network Time Protocol Daemon (NTPD) is operating correctly, issue the following command on all nodes in the cluster.

For Red Hat 6/CentOS 6 and SLES:

$ /usr/sbin/ntpq -c rv | grep stratum

For Ubuntu and Debian:

$ ntpq -c rv | grep stratum

A stratum level of 16 indicates that NTP is not synchronizing correctly.

If a stratum level of 16 is detected, wait 15 minutes and issue the command again. It may take this long for the NTP server to stabilize.

If NTP continues to detect a stratum level of 16, verify that the NTP port (UDP Port 123) is open on all firewalls between the cluster and the remote machine to which you are attempting to synchronize.

Red hat documentation related to NTP

The preceding links were current as of the last publication of the Vertica documentation and could change between releases.

• http://kbase.redhat.com/faq/docs/DOC-6731

• http://kbase.redhat.com/faq/docs/DOC-6902

• http://kbase.redhat.com/faq/docs/DOC-6991

2.6.8 - Enabling chrony or ntpd for Red Hat and CentOS systems

Before you can install Vertica, you must enable one of the following on your system for clock synchronization:

• chrony

• NTPD

You must enable and activate the Network Time Protocol (NTP) before installation. Otherwise, the installer reports this issue with the identifier S0030.

For information on installing and using chrony, see the information below. For information on NTPD see Enabling network time protocol (NTP). For more information about chrony, see Using chrony in the Red Hat documentation.

Install chrony

The chrony suite consists of:

• chronyd - the daemon for clock synchronization.

• chronyc - the command-line utility for configuring chronyd .

chrony is installed by default on some versions of Red Hat/CentOS 7. However, if chrony is not installed on your system, you must download it. To download chrony, run the following command as sudo or root:

# dnf install chrony

Verify that chrony is running

To view the status of the chronyd daemon, run the following command:

$ systemctl status chronyd

If chrony is running, an output similar to the following appears:

chronyd.service - NTP client/server
    Loaded: loaded (/usr/lib/systemd/system/chronyd.service; enabled)
    Active: active (running) since Mon 2015-07-06 16:29:54 EDT; 15s ago
Main PID: 2530 (chronyd)
    CGroup: /system.slice/chronyd.service
            ââ2530 /usr/sbin/chronyd -u chrony

If chrony is not running, execute the following command as sudo or root. This command also causes chrony to run at boot time:

# systemctl enable chronyd

Verify that chrony is operating correctly

To verify that the chrony daemon is operating correctly, issue the following command on all nodes in the cluster:

$ chronyc tracking

An output similar to the following appears:

Reference ID    : 198.247.63.98 (time01.website.org)
Stratum         : 3
Ref time (UTC)  : Thu Jul  9 14:58:01 2015
System time     : 0.000035685 seconds slow of NTP time
Last offset     : -0.000151098 seconds
RMS offset      : 0.000279871 seconds
Frequency       : 2.085 ppm slow
Residual freq   : -0.013 ppm
Skew            : 0.185 ppm
Root delay      : 0.042370 seconds
Root dispersion : 0.022658 seconds
Update interval : 1031.0 seconds
Leap status     : Normal

A stratum level of 16 indicates that chrony is not synchronizing correctly. If chrony continues to detect a stratum level of 16, verify that the UDP port 323 is open. This port must be open on all firewalls between the cluster and the remote machine to which you are attempting to synchronize.

2.6.9 - SELinux configuration

Vertica does not support SELinux except when SELinux is running in permissive mode. If it detects that SELinux is installed and the mode cannot be determined the installer reports this issue with the identifier: S0080. If the mode can be determined, and the mode is not permissive, then the issue is reported with the identifier: S0081.

Red hat and SUSE systems

You can either disable SELinux or change it to use permissive mode.

To disable SELinux:

1. Edit /etc/selinux/config and change setting for SELinux to disabled (SELINUX=disabled). This disables SELinux at boot time.

2. As root/sudo, type setenforce 0 to disable SELinux immediately.

To change SELinux to use permissive mode:

1. Edit /etc/selinux/config and change setting for SELINUX to permissive (SELINUX=Permissive).

2. As root/sudo, type setenforce Permissive to switch to permissive mode immediately.

Ubuntu and debian systems

You can either disable SELinux or change it to use permissive mode.

To disable SELinux:

1. Edit /selinux/config and change setting for SELinux to disabled (SELINUX=disabled). This disables SELinux at boot time.

2. As root/sudo, type setenforce 0 to disable SELinux immediately.

To change SELinux to use permissive mode:

1. Edit /selinux/config and change setting for SELinux to permissive (SELINUX=Permissive).

2. As root/sudo, type setenforce Permissive to switch to permissive mode immediately.

2.6.10 - CPU frequency scaling

This topic details the various CPU frequency scaling methods supported by Vertica. In general, if you do not require CPU frequency scaling, then disable it so as not to impact system performance.

The installer allows CPU frequency scaling to be enabled when the cpufreq scaling governor is set to performance. If the cpu scaling governor is set to ondemand, and ignore_nice_load is 1 (true), then the installer fails with the error S0140. If the cpu scaling governor is set to ondemand and ignore_nice_load is 0 (false), then the installer warns with the identifier S0141.

CPU frequency scaling is a hardware and software feature that helps computers conserve energy by slowing the processor when the system load is low, and speeding it up again when the system load increases. This feature can impact system performance, since raising the CPU frequency in response to higher system load does not occur instantly. Always disable this feature on the Vertica database hosts to prevent it from interfering with performance.

You disable CPU scaling in your host's system BIOS. There may be multiple settings in your host's BIOS that you need to adjust in order to completely disable CPU frequency scaling. Consult your host hardware's documentation for details on entering the system BIOS and disabling CPU frequency scaling.

If you cannot disable CPU scaling through the system BIOS, you can limit the impact of CPU scaling by disabling the scaling through the Linux kernel or setting the CPU frequency governor to always run the CPU at full speed.

The method you use to disable frequency depends on the CPU scaling method being used in the Linux kernel. See your Linux distribution's documentation for instructions on disabling scaling in the kernel or changing the CPU governor.

2.6.11 - Enabling or disabling defrag

You can modify the defrag utility to meet Vertica configuration requirements, or to optimize your system performance by workload.

On all Red Hat/CentOS systems, you must disable the defrag utility to meet Vertica configuration requirements.

For SUSE 15.1, Vertica recommends that you enable defrag for optimized performance.

Recommended settings by workload for Red Hat/CentOS and SUSE 15.1

Vertica recommends defrag settings to optimize performance by workload. The following table contains recommendations for systems that primarily run concurrent queries (such as short-running dashboard queries), or sequential SELECT or load (COPY) queries:

See Enabling or disabling transparent hugepages for additional settings that optimize your system performance by workload.

Disabling defrag on Red Hat/CentOS and SUSE 15.1

1. Determine if defrag is enabled by running the following command:

   cat /sys/kernel/mm/transparent_hugepage/defrag
   [always] madvise never
   

   The setting returned in brackets is your current setting. If you are not using madvise or never as your defrag setting, then you must disable defrag.

2. Edit /etc/rc.local, and add the following script:

   if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
       echo never > /sys/kernel/mm/transparent_hugepage/defrag
   fi
   

   You must reboot your system for the setting to take effect, or run the following echo line to proceed with the install without rebooting:

   # echo never > /sys/kernel/mm/transparent_hugepage/defrag
   

3. If you are using Red Hat or CentOS, run the following command as root or sudo:

   $ chmod +x /etc/rc.d/rc.local
   

Enabling defrag on Red Hat/CentOS and SUSE 15.1

1. Determine if defrag is enabled by running the following command:

   cat /sys/kernel/mm/transparent_hugepage/defrag
   [never] madvise never
   

   The setting returned in brackets is your current setting. If you are not using madvise or always as your defrag setting, then you must enable defrag.

2. Edit /etc/rc.local, and add the following script:

   if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
       echo always > /sys/kernel/mm/transparent_hugepage/defrag
   fi
   

   You must reboot your system for the setting to take effect, or run the following echo line to proceed with the install without rebooting:

   # echo always > /sys/kernel/mm/transparent_hugepage/defrag
   

3. If you are using Red Hat or CentOS, run the following command as root or sudo:

   $ chmod +x /etc/rc.d/rc.local
   

2.6.12 - Support tools

Vertica suggests that the following tools are installed so support can assist in troubleshooting your system if any issues arise:

• pstack (or gstack) package. Identified by issue S0040 when not installed.

• mcelog package. Identified by issue S0041 when not installed.

• sysstat package. Identified by issue S0045 when not installed.

Red Hat and CentOS systems

To install the required tools on Red Hat and CentOS systems, run the following commands as sudo or root:

# dnf install gdb
# dnf install mcelog
# dnf install sysstat

Ubuntu and Debian systems

To install the required tools on Ubuntu and Debian systems, run the following commands as sudo or root:

$ apt-get install pstack
$ apt-get install mcelog
$ apt-get install sysstat

SuSE systems

To install the required tools on SuSE systems, run the following commands as sudo or root.

# zypper install sysstat
# zypper install mcelog

There is no individual SuSE package for pstack/gstack. However, the gdb package contains gstack, so you could optionally install gdb instead, or build pstack/gstack from source. To install the gdb package:

# zypper install gdb

2.7 - System user configuration

The following tasks pertain to the configuration of the system user required by Vertica.

2.7.1 - System user requirements

Vertica has specific requirements for the system user that runs and manages Vertica. If you specify a user during install, but the user does not exist, then the installer reports this issue with the identifier: S0200.

System user requirement details

Vertica requires a system user to own database files and run database processes and administration scripts. By default, the install script automatically configures and creates this user for you with the username dbadmin. See Linux users created by Vertica for details on the default user created by the install script. If you decide to manually create your own system user, then you must create the user before you run the install script. If you manually create the user:

• the user must have the same username and password on all nodes

• the user must use the BASH shell as the user's default shell. If not, then the installer reports this issue with identifier [S0240].

• the user must be in the verticadba group (for example: usermod -a -G verticadba userNameHere). If not, the installer reports this issue with identifier [S0220].

  Note

  You must create a verticadba group on all nodes. If you do not, then the installer reports the issue with identifier [S0210].

• the user's login group must be either verticadba or a group with the same name as the user (for example, the home group for dbadmin is dbadmin). You can check the groups for a user with the id command. For example: id dbadmin. The "gid" group is the user's primary group. If this is not configured correctly then the installer reports this issue with the identifier [S0230]. Vertica recommends that you use verticadba as the user's primary login group. For example: usermod -g verticadba userNameHere. If the user's primary group is not verticadba as suggested, then the installer reports this with HINT [S0231].

• the user must have a home directory. If not, then the installer reports this issue with identifier [S0260].

• the user's home directory must be owned by the user. If not, then the installer reports the issue with identifier [S0270].

• the system must be aware of the user's home directory (you can set it with the usermod command: usermod -m -d /path/to/new/home/dir userNameHere). If this is not configured correctly then the installer reports the issue with [S0250].

• the user's home directory must be owned by the dbadmin's primary group (use the chown and chgrp commands if necessary). If this is not configured correctly, then the installer reports the issue with identifier [S0280].

• the user's home directory should have secure permissions. Specifically, it should not be writable by anyone or by the group. Ideally the permissions should be, when viewing with ls, "---" (nothing), or "r-x" (read and execute). If this is not configured as suggested then the installer reports this with HINT [S0290].

2.7.2 - TZ environment variable

This topic details how to set or change the TZ environment variable and update your tzdata package. If this variable is not set, then the installer reports this issue with the identifier: S0305.

Before installing Vertica, update the tzdata package for your system and set the default time zone for your database administrator account by specifying the TZ environmental variable. If your database administrator is being created by the install_vertica script, then set the TZ variable after you have installed Vertica.

Update tzdata package

The tzdata package is a public-domain time zone database that is pre-installed on most Linux systems. The tzdata package is updated periodically for time-zone changes across the world. You should update to the latest tzdata package before installing or updating Vertica.

Update your tzdata package with the following command:

• RedHat based systems: yum update tzdata

• Debian and Ubuntu systems: apt-get install tzdata

Setting the default time zone

When a client receives the result set of a SQL query, all rows contain data adjusted, if necessary, to the same time zone. That time zone is the default time zone of the initiator node unless the client explicitly overrides it using the SQL SET TIME ZONE command described in the SQL Reference Manual. The default time zone of any node is controlled by the TZ environment variable. If TZ is undefined, the operating system time zone.

If your operating system timezone is not set to the desired timezone of the database then make sure that the Linux environment variable TZ is set to the desired value on all cluster hosts.

The installer returns a warning if the TZ variable is not set. If your operating system timezone is appropriate for your database, then the operating system timezone is used and the warning can be safely ignored.

Setting the time zone on a host

You can set the time zone several different ways, depending on the Linux distribution or the system administrator’s preferences.

• To set the system time zone on Red Hat and SUSE Linux systems, edit:

  /etc/sysconfig/clock
  

• To set the TZ variable, edit, /etc/profile, or /home/dbadmin/.bashrc or /home/dbadmin/.bash_profile and add the following line (for example, for the US Eastern Time Zone):

  export TZ="America/New_York"
  

  For details on which timezone names are recognized by Vertica, see the appendix: Using time zones with Vertica.

2.7.3 - LANG environment variable settings

This topic details how to set or change the LANG environment variable. The LANG environment variable controls the locale of the host. If this variable is not set, then the installer reports this issue with the identifier: S0300. If this variable is not set to a valid value, then the installer reports this issue with the identifier: S0301.

Set the host locale

Each host has a system setting for the Linux environment variable LANG. LANG determines the locale category for native language, local customs, and coded character set in the absence of the LC_ALL and other LC_ environment variables. LANG can be used by applications to determine which language to use for error messages and instructions, collating sequences, date formats, and so forth.

To change the LANG setting for the database administrator, edit, /etc/profile, or /dbadmin/.bashrc or /home/dbadmin/.bash_profile on all cluster hosts and set the environment variable; for example:

export LANG=en_US.UTF-8

The LANG setting controls the following in Vertica:

• OS-level errors and warnings, for example, "file not found" during COPY operations.

• Some formatting functions, such as TO_CHAR and TO_NUMBER. See also Template patterns for numeric formatting.

The LANG setting does not control the following:

• Vertica specific error and warning messages. These are always in English at this time.

• Collation of results returned by SQL issued to Vertica. This must be done using a database parameter instead. See Implement locales for international data sets section for details.

2.7.4 - Package dependencies

For successful Vertica installation, you must first install three packages on all nodes in your cluster before installing the database platform.

The required packages are:

• openssh—Required for Administration tools connectivity between nodes.

• which—Required for Vertica operating system integration and for validating installations.

• dialog—Required for interactivity with Administration Tools.

Installing the required packages

The procedure you follow to install the required packages depends on the operating system on which your node or cluster is running. See your operating system's documentation for detailed information on installing packages.

• For CentOS/Red Hat Systems—Typically, you manage packages on Red Hat and CentOS systems using the yum utility.

  Run the following yum commands to install each of the package dependencies. The yum utility guides you through the installation:

  # yum install openssh
  # yum install which
  # yum install dialog
  

• For Debian/Ubuntu Systems—Typically, you use the apt-get utility to manage packages on Debian and Ubuntu systems.

  Run the following apt-get commands to install each of the package dependencies. The apt-get utility guides you through the installation:

  
  # apt-get install openssh
  # apt-get install which
  # apt-get install dialog
  

3 - Install Vertica using the command line

This section describes how to install the Vertica software on a cluster of nodes. It assumes that you have already performed the tasks in Before You Install Vertica, and that you have a Vertica license key.

To install Vertica, complete the following tasks:

1. Download and install the Vertica server package

2. Install Vertica with the installation script

Special notes

• Downgrade installations are not supported.

• Be sure that you download the RPM for the correct operating system and architecture.

• Vertica supports two-node clusters with zero fault tolerance (K=0 safety). This means that you can add a node to a single-node cluster, as long as the installation node (the node upon which you build) is not the loopback node (localhost/127.0.0.1).

• The installer performs platform verification tests that prevent the install from continuing if the platform requirements are not met. These tests ensure that your platform meets the hardware and software requirements for Vertica. You can simply run the installer and view a list of the failures and warnings to determine which configuration changes you must make.

3.1 - Download and install the Vertica server package

To download and install the Vertica server package:

1. Use a Web browser to go to the Vertica website.

2. Click the Support tab and select Customer Downloads.

3. Log into the portal to download the install package.
   Be sure the package you download matches the operating system and the machine architecture on which you intend to install it.

4. Transfer the installation package to the Administration host.

5. If you installed a previous version of Vertica on any of the hosts in the cluster, use the Administration tools to shut down any running database.

   The database must stop normally; you cannot upgrade a database that requires recovery.

6. If you are using sudo, skip to the next step. If you are root, log in to the Administration Host as root (or log in as another user and switch to root).

   $ su - root
   password: root-password
   #
   

   Caution

   When installing Vertica using an existing user as the dba, you must exit all UNIX terminal sessions for that user after setup completes and log in again to ensure that group privileges are applied correctly.

   After Vertica is installed, you no longer need root privileges. To verify sudo, see Platform and hardware requirements and recommendations.

7. Use one of the following commands to run the RPM package installer:

   • If you are root and installing an RPM:

     # rpm -Uvh pathname
     

     Note

     When installing a Vertica RPM, you might see an unexpected warning about a SHA256 signature. This warning indicates that you need to import a GPG key. Only necessary for versions after 10.0, keys can be downloaded under the Security section of your chosen release from the Vertica Client Drivers page. After downloading the key, you can import it with the following command:

     # rpm --import RPM-GPG-KEY-VERTICA

   • If you are using sudo and installing an RPM:

     $ sudo rpm -Uvh pathname
     

   • If you are using Debian:

     $ sudo dpkg -i pathname
     

   where pathname is the Vertica package file you downloaded.

   Note

   If the package installer reports multiple dependency problems, or you receive the error "ERROR: You're attempting to install the wrong RPM for this operating system", then you are trying to install the wrong Vertica server package.

After you install the Vertica RPM, you can use several Validation scripts to help determine if your hosts and network can properly handle the processing and network traffic required by Vertica.

3.2 - Linux users created by Vertica

This topic describes the Linux accounts that the installer creates and configures so Vertica can run. When you install Vertica, the installation script optionally creates the following Linux user and group:

• dbadmin—Administrative user

• verticadba—Group for DBA users

dbadmin and verticadba are the default names. If you want to change what these Linux accounts are called, you can do so using the installation script. See Install Vertica with the installation script for details.

Dbadmin privileges

The Linux dbadmin user owns the database catalog and data storage on disk. When you run the install script, Vertica creates this user on each node in the database cluster. It also adds dbadmin to the Linux dbadmin and verticadba groups, and configures the account as follows:

• Configures and authorizes dbadmin for passwordless SSH between all cluster nodes. SSH must be installed and configured to allow passwordless logins. See Enable secure shell (SSH) logins.

• Sets the dbadmin user's BASH shell to /bin/bash, required to run scripts, such as install_vertica and the Administration tools.

• Provides read-write-execute permissions on the following directories:

  • /opt/vertica/*

  • /home/dbadmin—the default directory for database data and catalog files (configurable through the install script)

After you install Vertica

Root or sudo privileges are not required to start or run Vertica after the installation process completes.

The dbadmin user can log in and perform Vertica tasks, such as creating a database, installing/changing the license key, or installing drivers. If dbadmin wants database directories in a location that differs from the default, the root user (or a user with sudo privileges) must create the requested directories and change ownership to the dbadmin user.

Vertica prevents administration from users other than the dbadmin user (or the user name you specified during the installation process if not dbadmin). Only this user can run Administration Tools.

See also

• Installation overview and checklist
• Before you install Vertica
• Platform and hardware requirements and recommendations
• Enable secure shell (SSH) logins

3.3 - Validation scripts

Vertica provides several validation utilities that can be used prior to deploying Vertica to help determine if your hosts and network can properly handle the processing and network traffic required by Vertica. These utilities can also be used if you are encountering performance issues and need to troubleshoot the issue.

After you install the Vertica RPM, you have access to the following scripts in /opt/vertica/bin:

• Vcpuperf - a CPU performance test used to verify your CPU performance.

• Vioperf - an Input/Output test used to verify the speed and consistency of your hard drives.

• Vnetperf - a Network test used to test the latency and throughput of your network between hosts.

These utilities can be run at any time, but are well suited to use before running the install_vertica script.

3.3.1 - Vcpuperf

The vcpuperf utility measures your server's CPU processing speed and compares it against benchmarks for common server CPUs. The utility performs a CPU test and measures the time it takes to complete the test. The lower the number scored on the test, the better the performance of the CPU.

The vcpuperf utility also checks the high and low load times to determine if CPU throttling is enabled. If a server's low-load computation time is significantly longer than the high-load computation time, CPU throttling may be enabled. CPU throttling is a power-saving feature. However, CPU throttling can reduce the performance of your server. Vertica recommends disabling CPU throttling to enhance server performance.

Syntax

vcpuperf [-q]

Options

-q

Run in quiet mode. Quiet mode displays only the CPU Time, Real Time, and high and low load times.

Returns

• CPU Time: the amount of time it took the CPU to run the test.

• Real Time: the total time for the test to execute.

• High load time: The amount of time to run the load test while simulating a high CPU load.

• Low load time: The amount of time to run the load test while simulating a low CPU load.

Example

The following example shows a CPU that is running slightly slower than the expected time on a Xeon 5670 CPU that has CPU throttling enabled.

[root@node1 bin]# /opt/vertica/bin/vcpuperf
Compiled with: 4.1.2 20080704 (Red Hat 4.1.2-52) Expected time on Core 2, 2.53GHz: ~9.5s
Expected time on Nehalem, 2.67GHz: ~9.0s
Expected time on Xeon 5670, 2.93GHz: ~8.0s

This machine's time:
  CPU Time: 8.540000s
  Real Time:8.710000s

Some machines automatically throttle the CPU to save power.
  This test can be done in <100 microseconds (60-70 on Xeon 5670, 2.93GHz).
  Low load times much larger than 100-200us or much larger than the corresponding high load time
    indicate low-load throttling, which can adversely affect small query / concurrent performance.

This machine's high load time: 67 microseconds.
This machine's low load time: 208 microseconds.

3.3.2 - Vioperf

The vioperf utility quickly tests the performance of your host's input and output subsystem. The utility performs the following tests:

• sequential write

• sequential rewrite

• sequential read

• skip read (read non-contiguous data blocks)

The utility verifies that the host reads the same bytes that it wrote and prints its output to STDOUT. The utility also logs the output to a JSON formatted file.

For data in HDFS, the utility tests reads but not writes.

Syntax

vioperf [--help] [--duration=<INTERVAL>] [--log-interval=<INTERVAL>]
  [--log-file=<FILE>] [--condense-log] [--thread-count=<N>] [--max-buffer-size=<SIZE>]
  [--preserve-files] [--disable-crc] [--disable-direct-io] [--debug]
  [<DIR>*]

Minimum and recommended I/O performance

• The minimum required I/O is 20 MB/s read/write per physical processor core on each node, in full duplex (reading and writing) simultaneously, concurrently on all nodes of the cluster.

  Note

  Vertica supports some AWS instance types that do not meet these minimum I/O requirements. However, all supported AWS instances types, regardless of vioperf performance, can be used as Vertica cluster hosts. See Supported AWS instance types for a list of all supported AWS instance types.

• The recommended I/O is 40 MB/s per physical core on each node.

• The minimum required I/O rate for a node with 2 hyper-threaded six-core CPUs (12 physical cores) is 240 MB/s. Vertica recommends 480 MB/s.

For example, the I/O rate for a node with 2 hyper-threaded six-core CPUs (12 physical cores) is 240 MB/s required minimum, 480 MB/s recommended.

Disk space vioperf needs

vioperf requires about 4.5 GB to run.

Options

--help

Prints a help message and exits.

--duration

The length of time vioprobe runs performance tests. The default is 5 minutes. Specify the interval in seconds, minutes, or hours with any of these suffixes:

• Seconds: s, sec, secs, second, seconds. Example: --duration=60sec

• Minutes: m, min, mins, minute, minutes. Example: --duration=10min

• Hours: h, hr, hrs, hour, hours. Example: --duration=1hrs

--log-interval

The interval at which the log file reports summary information. The default interval is 10 seconds. This option uses the same interval notation as --duration.

--log-file

The path and name where log file contents are written, in JSON. If not specified, then vioperf creates a file named resultsdate-time.JSON in the current directory.

--condense-log

Directs vioperf to write the log file contents in condensed format, one JSON entry per line, rather than as indented JSON syntax.

--thread-count=<N>

The number of execution threads to use. By default, vioperf uses all threads available on the host machine.

--max-buffer-size=<SIZE>

The maximum size of the in-memory buffer to use for reads or writes. Specify the units with any of these suffixes:

• Bytes: b, byte, bytes.

• Kilobytes: k, kb, kilobyte, kilobytes.

• Megabytes: m, mb, megabyte, megabytes.

• Gigabytes: g, gb, gigabyte, gigabytes.

--preserve-files

Directs vioperf to keep the files it writes. This parameter is ignored for HDFS tests, which are read-only. Inspecting the files can help diagnose write-related failures.

--disable-crc

Directs vioperf to ignore CRC checksums when validating writes. Verifying checksums can add overhead, particularly when running vioperf on slower processors. This parameter is ignored for HDFS tests.

--disable-direct-io

When reading from or writing to a local file system, vioperf goes directly to disk by default, bypassing the operating system's page cache. Using direct I/O allows vioperf to measure performance quickly without having to fill the cache.

Disabling this behavior can produce more realistic performance results but slows down the operation of vioperf.

--debug

Directs vioperf to report verbose error messages.

<DIR>

Zero or more directories to test. If you do not specify a directory, vioperf tests the current directory. To test the performance of each disk, specify different directories mounted on different disks.

To test reads from a directory on HDFS:

• Use a URL in the hdfs scheme that points to a single directory (not a path) containing files at least 10MB in size. For best results, use 10GB files and verify that there is at least one file per vioperf thread.

• If you do not specify a host and port, set the HADOOP_CONF_DIR environment variable to a path including the Hadoop configuration files. This value is the same value that you use for the HadoopConfDir configuration parameter in Vertica. For more information see Configuring HDFS access.

• If the HDFS cluster uses Kerberos, set the HADOOP_USER_NAME environment variable to a Kerberos principal.

Returns

The utility returns the following information:

test

The test being run (Write, ReWrite, Read, or Skip Read)

directory

The directory in which the test is being run.

counter name

The counter type of the test being run. Can be either MB/s or Seeks per second.

counter value

The value of the counter in MB/s or Seeks per second across all threads. This measurement represents the bandwidth at the exact time of measurement. Contrast with counter value (avg).

counter value (10 sec avg)

The average amount of data in MB/s, or the average number of Seeks per second, for the test being run in the duration specified with --log-interval. The default interval is 10 seconds. The counter value (avg) is the average bandwidth since the last log message, across all threads.

counter value/core

The counter value divided by the number of cores.

counter value/core (10 sec avg)

The counter value (10 sec avg) divided by the number of cores.

thread count

The number of threads used to run the test.

%CPU

The available CPU percentage used during this test.

%IO Wait

The CPU percentage in I/O Wait state during this test. I/O wait state is the time working processes are blocked while waiting for I/O operations to complete.

elapsed time

The amount of time taken for a particular test. If you run the test multiple times, elapsed time increases the next time the test is run.

remaining time

The time remaining until the next test. Based on the --duration option, each of the tests is run at least once. If the test set is run multiple times, then remaining time is how much longer the test will run. The remaining time value is cumulative. Its total is added to elapsed time each time the same test is run again.

Example

Invoking vioperf from a terminal outputs the following message and sample results:

[dbadmin@v_vmart_node0001 ~]$ /opt/vertica/bin/vioperf --duration=60s
The minimum required I/O is 20 MB/s read and write per physical processor core on each node, in full duplex
i.e. reading and writing at this rate simultaneously, concurrently on all nodes of the cluster.
The recommended I/O is 40 MB/s per physical core on each node.
For example, the I/O rate for a server node with 2 hyper-threaded six-core CPUs is 240 MB/s required minimum, 480 MB/s recommended.

Using direct io (buffer size=1048576, alignment=512) for directory "/home/dbadmin"

test     | directory     | counter name         | counter value | counter value (10 sec avg) | counter value/core  | counter value/core (10 sec avg) | thread count  | %CPU  | %IO Wait  | elapsed time (s)| remaining time (s)
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Write    | /home/dbadmin | MB/s                 | 420           | 420                             | 210                | 210                        | 2             | 89    | 10        | 10              | 5
Write    | /home/dbadmin | MB/s                 | 412           | 396                             | 206                 | 198                        | 2             | 89    | 9         | 15              | 0
ReWrite  | /home/dbadmin | (MB-read+MB-write)/s | 150+150       | 150+150                         | 75+75               | 75+75                      | 2             | 58    | 40        | 10              | 5
ReWrite  | /home/dbadmin | (MB-read+MB-write)/s | 158+158       | 172+172                         | 79+79              | 86+86                      | 2             | 64    | 33        | 15              | 0
Read     | /home/dbadmin | MB/s                 | 194           | 194                             | 97                 | 97                         | 2             | 69    | 26        | 10              | 5
Read     | /home/dbadmin | MB/s                 | 192           | 190                             | 96                 | 95                         | 2             | 71    | 27        | 15              | 0
SkipRead | /home/dbadmin | seeks/s              | 659           | 659                             | 329.5              | 329.5                      | 2             | 2     | 85        | 10              | 5
SkipRead | /home/dbadmin | seeks/s              | 677           | 714                             | 338.5              | 357                        | 2             | 2     | 59        | 15              | 0

3.3.3 - Vnetperf

The vnetperf utility measures network performance of database hosts, as well as network latency and throughput for TCP and UDP protocols.

This utility helps identify the following issues:

• Low throughput for all hosts or one

• High latency for all hosts or one

• Bottlenecks between one or more hosts or subnets

• Too-low limit on the number of TCP connections that can be established simultaneously

• High rates of network packet loss

Syntax

vnetperf [[options](#Options)] [[tests](#Tests)]

Options

--condense

Condenses the log into one JSON entry per line, instead of indented JSON syntax.

--collect-logs

Collects test log files from each host.

--datarate rate

Limits throughput to this rate in MB/s. A rate of 0 loops the tests through several different rates.

Default: 0

--duration seconds

Time limit for each test to run in seconds.

Default: 1

--hosts host-name[,...]

Comma-separated list of host names or IP addresses on which to run the tests. The list must not contain embedded spaces.

--hosts file

File that specifies the hosts on which to run the tests. If you omit this option, then the vnetperf tries to access admintools to identify cluster hosts.

--identity-file file

If using passwordless SSH/SCP access between hosts, then specify the key file used to gain access to the hosts.

--ignore-bad-hosts

If set, runs tests on reachable hosts even if some hosts are not reachable. If you omit this option and a host is unreachable, then no tests are run on any hosts.

--log-dir directory

If --collect-logs is set, specifies the directory in which to place the collected logs.

Default: logs.netperf.<timestamp>

--log-level level

Log level to use, one of the following:

• INFO

• ERROR

• DEBUG

• WARN

Default: WARN

--list-tests

Lists the tests that vnetperf can run.

--output-file file

The file to which JSON results are written.

Default: results.<timestamp>.json

--ports port#[,...]

Comma-delimited list of port numbers to use. If only one port number is specified, then the next two numbers in sequence are also used.

Default: 14159,14160,14161

--scp-options 'scp-args'

Specifies one or more standard SCP command line arguments. SCP is used to copy test binaries over to the target hosts.

--ssh-options 'ssh-args'

Specifies one or more standard SSH command line arguments. SSH is used to issue test commands on the target hosts.

--tmp-dir directory

Specifies the temporary directory for vnetperf, where directory must have execute permission on all hosts, and does not include the unsupported characters ", ```, or '.

Default: /tmp (execute permission required)

--vertica-install directory

Indicates that Vertica is installed on each of the hosts, so vnetperf uses test binaries on the target system rather than copying them over with SCP.

Tests

vnetperf can specify one or more of the following tests. If no test is specified, vnetperf runs all tests. Test results are printed for each host.

Recommended network performance

• Maximum recommended RTT (round-trip time) latency is 1000 microseconds. Ideal RTT latency is 200 microseconds or less. Vertica recommends that clock skew be less than 1 second.

• Minimum recommended throughput is 100 MB/s. Ideal throughput is 800 MB/s or more.

  Note

  UDP throughput can be lower; multiple network switches can adversely affect performance.

Example

$ vnetperf latency tcp-throughput

The maximum recommended rtt latency is 2 milliseconds. The ideal rtt latency is 200 microseconds or less. It is recommended that clock skew be kept to under 1 second.
test              | date                    | node             | index | rtt latency (us)  | clock skew (us)
-------------------------------------------------------------------------------------------------------------------------
latency           | 2022-03-29_10:23:55,739 | 10.20.100.247    | 0     | 49                | 3
latency           | 2022-03-29_10:23:55,739 | 10.20.100.248    | 1     | 272               | -702
latency           | 2022-03-29_10:23:55,739 | 10.20.100.249    | 2     | 245               | 1037

The minimum recommended throughput is 100 MB/s. Ideal throughput is 800 MB/s or more. Note: UDP numbers may be lower, multiple network switches may reduce performance results.
date                    | test              | rate limit (MB/s) | node             | MB/s (sent) | MB/s (rec)  | bytes (sent)        | bytes (rec)         | duration (s)
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2022-03-29_10:23:55,742 | tcp-throughput    | 32                | 10.20.100.247    | 30.579      | 30.579      | 32112640            | 32112640            | 1.00151
2022-03-29_10:23:55,742 | tcp-throughput    | 32                | 10.20.100.248    | 30.5791     | 30.5791     | 32112640            | 32112640            | 1.0015
2022-03-29_10:23:55,742 | tcp-throughput    | 32                | 10.20.100.249    | 30.5791     | 30.5791     | 32112640            | 32112640            | 1.0015
2022-03-29_10:23:55,742 | tcp-throughput    | 32                | average          | 30.579      | 30.579      | 32112640            | 32112640            | 1.0015
2022-03-29_10:23:57,749 | tcp-throughput    | 64                | 10.20.100.247    | 61.0952     | 61.0952     | 64094208            | 64094208            | 1.00049
2022-03-29_10:23:57,749 | tcp-throughput    | 64                | 10.20.100.248    | 61.096      | 61.096      | 64094208            | 64094208            | 1.00048
2022-03-29_10:23:57,749 | tcp-throughput    | 64                | 10.20.100.249    | 61.0952     | 61.0952     | 64094208            | 64094208            | 1.00049
2022-03-29_10:23:57,749 | tcp-throughput    | 64                | average          | 61.0955     | 61.0955     | 64094208            | 64094208            | 1.00048
2022-03-29_10:23:59,753 | tcp-throughput    | 128               | 10.20.100.247    | 122.131     | 122.131     | 128122880           | 128122880           | 1.00046
2022-03-29_10:23:59,753 | tcp-throughput    | 128               | 10.20.100.248    | 122.132     | 122.132     | 128122880           | 128122880           | 1.00046
2022-03-29_10:23:59,753 | tcp-throughput    | 128               | 10.20.100.249    | 122.132     | 122.132     | 128122880           | 128122880           | 1.00046
2022-03-29_10:23:59,753 | tcp-throughput    | 128               | average          | 122.132     | 122.132     | 128122880           | 128122880           | 1.00046
2022-03-29_10:24:01,757 | tcp-throughput    | 256               | 10.20.100.247    | 243.819     | 244.132     | 255754240           | 256081920           | 1.00036
2022-03-29_10:24:01,757 | tcp-throughput    | 256               | 10.20.100.248    | 244.125     | 243.282     | 256049152           | 255164416           | 1.00025
2022-03-29_10:24:01,757 | tcp-throughput    | 256               | 10.20.100.249    | 244.172     | 243.391     | 256114688           | 255295488           | 1.00032
2022-03-29_10:24:01,757 | tcp-throughput    | 256               | average          | 244.039     | 243.601     | 255972693           | 255513941           | 1.00031
2022-03-29_10:24:03,761 | tcp-throughput    | 512               | 10.20.100.247    | 337.232     | 485.247     | 355893248           | 512098304           | 1.00645
2022-03-29_10:24:03,761 | tcp-throughput    | 512               | 10.20.100.248    | 446.16      | 231.001     | 467894272           | 242253824           | 1.00013
2022-03-29_10:24:03,761 | tcp-throughput    | 512               | 10.20.100.249    | 349.667     | 409.961     | 368476160           | 432013312           | 1.00497
2022-03-29_10:24:03,761 | tcp-throughput    | 512               | average          | 377.686     | 375.403     | 397421226           | 395455146           | 1.00385
2022-03-29_10:24:05,772 | tcp-throughput    | 640               | 10.20.100.247    | 328.279     | 509.256     | 383975424           | 595656704           | 1.11548
2022-03-29_10:24:05,772 | tcp-throughput    | 640               | 10.20.100.248    | 505.626     | 217.217     | 532250624           | 228655104           | 1.00389
2022-03-29_10:24:05,772 | tcp-throughput    | 640               | 10.20.100.249    | 390.355     | 474.89      | 410812416           | 499777536           | 1.00365
2022-03-29_10:24:05,772 | tcp-throughput    | 640               | average          | 408.087     | 400.454     | 442346154           | 441363114           | 1.04101
2022-03-29_10:24:07,892 | tcp-throughput    | 768               | 10.20.100.247    | 300.5       | 426.762     | 318734336           | 452657152           | 1.01154
2022-03-29_10:24:07,892 | tcp-throughput    | 768               | 10.20.100.248    | 268.252     | 402.891     | 283017216           | 425066496           | 1.00616
2022-03-29_10:24:07,892 | tcp-throughput    | 768               | 10.20.100.249    | 510.569     | 243.649     | 535592960           | 255590400           | 1.00042
2022-03-29_10:24:07,892 | tcp-throughput    | 768               | average          | 359.774     | 357.767     | 379114837           | 377771349           | 1.00604
2022-03-29_10:24:09,911 | tcp-throughput    | 1024              | 10.20.100.247    | 304.545     | 444.261     | 334987264           | 488669184           | 1.049
2022-03-29_10:24:09,911 | tcp-throughput    | 1024              | 10.20.100.248    | 422.246     | 192.773     | 474284032           | 216530944           | 1.07121
2022-03-29_10:24:09,911 | tcp-throughput    | 1024              | 10.20.100.249    | 353.206     | 446.809     | 378732544           | 479100928           | 1.0226
2022-03-29_10:24:09,911 | tcp-throughput    | 1024              | average          | 359.999     | 361.281     | 396001280           | 394767018           | 1.0476
2022-03-29_10:24:11,988 | tcp-throughput    | 2048              | 10.20.100.247    | 343.324     | 414.559     | 387710976           | 468156416           | 1.07697
2022-03-29_10:24:11,988 | tcp-throughput    | 2048              | 10.20.100.248    | 292.44      | 246.254     | 308314112           | 259620864           | 1.00544
2022-03-29_10:24:11,988 | tcp-throughput    | 2048              | 10.20.100.249    | 437.559     | 405.02      | 459145216           | 425000960           | 1.00072
2022-03-29_10:24:11,988 | tcp-throughput    | 2048              | average          | 357.774     | 355.278     | 385056768           | 384259413           | 1.02771

JSON results available at: ./results.2022-03-29_10:23:51,548.json

3.4 - Install Vertica with the installation script

You can run the installation script after you install the Vertica package. The installation script runs on a single node, using a Bash shell. The script copies the Vertica package to all other hosts (identified by the --hosts argument) in your planned cluster.

The installation script runs several tests on each of the target hosts to verify that the hosts meet system and performance requirements for a Vertica node. The installation script modifies some operating system configuration settings to meet these requirements. Other settings cannot be modified by the installation script and must be manually reconfigured. For details on operating system configuration settings, see Manually configured operating system settings and Automatically configured operating system settings.

3.4.1 - Install on a FIPS 140-2 enabled machine

Vertica supports the implementation of the Federal Information Processing Standard 140-2 (FIPS). You enable FIPS mode in the operating system.

During installation, the install_vertica script detects whether the host is operating in FIPS mode. The installer searches for the file /proc/sys/crypto/fips_enabled and examines its content. If the file exists and contains a '1' in the filename, the host is operating in FIPS mode and the following message appears:

/proc/sys/crypto/fips_enabled exists and contains '1', this is a FIPS system

To implement FIPS 140-2 on your Vertica Analytic Database, you need to configure both the server and the client you are using. To see the detailed configuration steps, go to Implementing FIPS 140-2.

Symbolic links for OpenSSL

On some non-FIPS systems, versioning anomalies can occur when you install a new version of OpenSSL. Sometimes, the default OpenSSL build procedure produces libraries with versions named 1.0.0. For Vertica to recognize that a library has a higher version number, the library name with a higher version number must be provided. As part of the Vertica installation, symbolic links are created to the appropriate OpenSSL files. The steps are as follows:

1. The RPM installer places two OpenSSL library files in /opt/vertica/lib:

   • libssl.so.1.1

   • libcrypto.so.1.1

2. The install_vertica script creates two symbolic links in /opt/vertica/lib:

   • libssl.so

   • libcrypto.so

3. The symbolic links point to libssl.so.1.1 and libcrypto.so.1.1, which the RPM installer placed in /opt/vertica/lib.

3.4.2 - Specifying disk storage location during installation

You can specify the disk storage location when you:

• Install Vertica (see below).

• Create a database using the Administration Tools.

• Installing Management Console

Specifying disk storage location when you install

When you install Vertica, the --data-dir parameter in the install_vertica script lets you specify a directory to contain database data and catalog files. The script defaults to the database administrator's default home directory /home/dbadmin.

Requirements

• The data and catalog directory must exist on each node in the cluster.

• The directory on each node must be owned by the database administrator

• Catalog and data path names must contain only alphanumeric characters and cannot have leading space characters. Failure to comply with these restrictions will result in database creation failure.

• Vertica refuses to overwrite a directory if it appears to be in use by another database. Therefore, if you created a database for evaluation purposes, dropped the database, and want to reuse the database name, make sure that the disk storage location previously used has been completely cleaned up. See Managing storage locations for details.

3.4.3 - Perform a basic install

For all installation options, see install_vertica options.

1. As root (or sudo) run the install script. The script must be run by a BASH shell as root or as a user with sudo privileges. You can configure many options when running the install script. See Basic Installation Parameters for the required options.

   If the installer fails due to any requirements not being met, you can correct the issue and then rerun the installer with the same command line options.

   To perform a basic installation:

   • As root:

     # /opt/vertica/sbin/install_vertica --hosts host_list --rpm package_name\
           --dba-user dba_username --parallel-no-prompts
     

   • Using sudo:

     $ sudo /opt/vertica/sbin/install_vertica --hosts host_list --rpm package_name \
           --dba-user dba_username --parallel-no-prompts
     

   Important

   If you place install_vertica in a location other than /opt/vertica, create a symlink from that location to /opt/vertica. Create this symlink on all cluster nodes, otherwise the database will not start.

2. When prompted for a password to log into the other nodes, provide the requested password. Doing so allows the installation of the package and system configuration on the other cluster nodes.

   • If you are root, this is the root password.

   • If you are using sudo, this is the sudo user password.

   The password does not echo on the command line. For example:

   Vertica Database 24.2.x Installation Tool
   Please enter password for root@host01:password
   

3. If the dbadmin user, or the user specified in the argument --dba-user, does not exist, then the install script prompts for the password for the user. Provide the password. For example:

   Enter password for new UNIX user dbadmin:password
   Retype new UNIX password for user dbadmin:password
   

4. Carefully examine any warnings or failures returned by install_vertica and correct the problems.

   For example, insufficient RAM, insufficient network throughput, and too high readahead settings on the file system could cause performance problems later on. Additionally, LANG warnings, if not resolved, can cause database startup to fail and issues with VSQL. The system LANG attributes must be UTF-8 compatible. After you fix the problems, rerun the install script.

5. When installation is successful, disconnect from the Administration host, as instructed by the script. Then, complete the required post-installation steps.

   At this point, root privileges are no longer needed and the database administrator can perform any remaining steps.

3.4.4 - install_vertica options

The following tables describe install_vertica script options. Most options have long and short forms—for example, --hosts and -s.

Required

install_vertica requires the following options:

• --hosts / -s

• --rpm / -r | --deb | --no-rpm-copy

• --dba-user username | -u username

  Required only if installing using root or upgrading versions.

For example:

 # /opt/vertica/sbin/install_vertica --hosts node0001,node0002,node0003 --rpm /tmp/vertica-version.RHEL8.x86_64.rpm

--hosts hostlist -s hostlist

Comma-separated list of host names or IP addresses to include in the cluster. The list must not include embedded spaces. For example:

• --hosts node01,node02,node03

• --hosts 192.168.233.101,192.168.233.102,192.168.233.103

• --hosts fd95:ff5d:5549:bdb0::1,fd95:ff5d:5549:bdb0::2,fd95:ff5d:5549:bdb0::3

The following requirements apply:

• If upgrading an existing installation of Vertica, use the same host names used previously.

• IP addresses or hostnames must be for unique hosts. Do not list the same host using multiple IP addresses/hostnames.

Note

Vertica stores only IP addresses in its configuration files. If you provide host names, they are converted to IP addresses when the script runs.

--rpm package-name -r package-name -deb package-name

Path and name of the Vertica RPM or Debian package. For example:

--rpm /tmp/vertica-version.RHEL8.x86_64.rpm

For Debian and Ubuntu installs, provide the name of the Debian package:

--deb /tmp/vertica_10.1_amd64.deb

The install package must be provided if you install or upgrade the Vertica server package on multiple nodes where the nodes do not have the latest server package installed, or if you are adding a new node. You do not need to provide the server package if you have a local copy of the RPM on each node and call the install script with the no-rpm-copy option. Unless you provide the --no-rpm-copy option, the install_vertica and update_vertica scripts serially copy the server package to the other nodes and install the package.

Tip

If installing or upgrading a large number of nodes, consider manually installing the package on all nodes before running the install/upgrade script. The script runs faster if it does not need to serially upload and install the package on each node.

--no-rpm-copy

Installer does not copy the RPM to the nodes in the cluster. The RPM must be present on each node specified by --hosts, and you must provide the path to the local RPM files with the --rpm-path option (defaults to /tmp/dbRPM.rpm). If you specify this option, you do not need to provide the --rpm option.

--dba-user username -u username

Name of the database superuser account to create. Only this account can run the Administration Tools. If you omit this parameter, then the default administrator account name is dbadmin.

This parameter is optional for new installations done as root; they must be specified when upgrading or when installing using sudo. If upgrading, use this parameter to specify the same account name that you used previously. If installing using sudo, username must already exist.

If you manually create the user, modify the user's .bashrc file to include the line: PATH=/opt/vertica/bin:$PATH so Vertica tools such as vsql and admintools can be easily started by this user.

For details on a minimal installation procedure, see Perform a basic install.

Optional

The following install_vertica options are not required. Many of them enable greater control over the installation process.

--help

Display help for this script.

--accept-eula -Y

Silently accepts the EULA agreement. On multi-node installations, this option is propagated across the cluster at the end of the installation, at the same time as the Administration Tools metadata.

Combine this option with --license (-L) to activate your license.

--add-hosts hostlist -A hostlist

Comma-separated list of hosts to add to an existing Vertica cluster.

--add-hosts modifies an existing installation of Vertica by adding a host to the database cluster and then reconfiguring spread. This is useful for improving system performance, or making the database K-safe.

If spread is configured in your installation to use point-to-point communication within the existing cluster, you must also use it when you add a new host; otherwise, the new host automatically uses UDP broadcast traffic, resulting in cluster communication problems that prevent Vertica from running properly. For example:

--add-hosts host01
--add-hosts 192.168.233.101

You can also use this option with the update_vertica script. For details, see Adding nodes.

--broadcast -U

Configures spread to use UDP broadcast traffic between nodes on the subnet. This is the default setting. Up to 80 spread daemons are supported by broadcast traffic. You can exceed the 80-node limit by using large cluster mode, which does not install a spread daemon on each node.

Do not combine this option with --point-to-point.

Important

When changing the configuration from --point-to-point to --broadcast, you must also specify --control-network.

--clean

Forcibly cleans previously stored configuration files. Use this option if you need to change the hosts that are included in your cluster. Only use this option when no database is defined.

This option is not supported by the update_vertica script.

--config-file file -z file

Use the properties file created earlier with [‑‑record-config](#record-config). This properties file contains key/value settings that map to install_vertica option.

--control-network { IPaddress | default } -S { IPadress | default }

Set to one of the following arguments:

• IPaddress: A broadcast network IP address that enables configuration of spread communications on a subnet different from other Vertica data communications.
• default

  Important

  IPaddress must match the subnet for at least some database nodes. If the address does not match the subnet of any database node, then the installer displays an error and stops. If the provided address matches some, but not all of the node's subnets, the installer displays a warning, but installation continues.

  Optimally, the value for --control-network matches all node subnets.

You can also use this option to force a cluster-wide spread reconfiguration when changing spread-related options.

--data-dir directory -d directory

Directory for database data and catalog files. For details, see Specifying disk storage location during installation and Managing storage locations.

Caution

Do not use a shared directory over more than one host for this setting. Data and catalog directories must be distinct for each node. Multiple nodes must not be allowed to write to the same data or catalog directory.

Default: /home/dbadmin

--dba-group group -g group

UNIX group for DBA users.

Default: verticadba

--dba-user-home directory -l directory

Home directory for the database administrator.

Default: /home/dbadmin

--dba-user-password password -p password

Password for the database administrator account. If omitted, the script prompts for a password and does not echo the input.

--dba-use-password-disabled

Disables the password for --dba-user. This argument stops the installer from prompting for a password for --dba-user. You can assign a password later using standard user management tools such as passwd.

--failure-threshold [threshold-arg]

Stops the installation when the specified failure threshold is encountered, where threshold-arg is one of the following:

• HINT: Stop the install if a HINT or greater issue is encountered during the installation tests. HINT configurations are settings you should make, but the database runs with no significant negative consequences if you omit the setting.
• WARN: Stop the installation if a WARN or greater issue is encountered. WARN issues might affect database performance. However, for environments where high-level performance is not a priority—for example, testing—WARN issues can be ignored.
• FAIL: Stop the installation if a FAIL or greater issue is encountered. FAIL issues can have severely negative performance consequences and possible later processing issues if not addressed. However, Vertica can start even if FAIL issues are ignored.
• HALT: Stop the installation if a HALT or greater issue is encountered. The database might be unable to start if you choose his option. This option is not supported in production environments.
• NONE: Do not stop the installation. The database might be unable to start if you choose this option. This option is not supported in production environments.

Default: WARN

--ipv4

Hosts in the cluster are identified by IPv4 network addresses. This is the default behavior.

--ipv6

Hosts in the cluster are identified by IPv6 network addresses, required if the --hosts list specifies Pv6 addresses. This option automatically enables the --point-to-point option.

--large-cluster [ num-control-nodes | default ]

Enables the large cluster feature, where a subset of nodes called control nodes connect to spread to send and receive broadcast messages. Consider using this option for a cluster with more than 50 nodes in Enterprise Mode. Vertica automatically enables this feature if you install onto 120 or more nodes in Enterprise Mode, or 16 or more nodes in Eon Mode.

Supply this option with one of the following arguments:

• num-control-nodes: Sets the number of control nodes in the new database to the smaller of this value or the value of --hosts. This value is applied differently in Enterprise Mode and Eon Mode:

  • Enterprise Mode: Sets the number of control nodes in the entire cluster.
  • Eon Mode: Sets the number of control nodes in the initial default subcluster. This value must be between 1 to 120, inclusive.

• default: Vertica sets the number of control nodes to the square root of the total number of cluster nodes listed in --hosts (-s).

For details, see Enable Large Cluster When Installing Vertica.

Default: default

--license { license-file | CE } -L { hostlist | CE }

Silently and automatically deploys the license key to /opt/vertica/config/share. On multi-node installations, the –-license option also applies the license to all nodes declared by --hosts. To activate your license, combined this option with ‑‑accept-eula option. If you do not use the ‑‑accept-eula option, you are asked to accept the EULA when you connect to your database. After you accept the EULA, your license is activated.

If specified with CE, this option automatically deploys the Community Edition license key, which is included in your download.

---no-system-configuration

Installer makes no changes to system properties. By default, the installer makes system configuration changes that meet server requirements.

If you use this option, the installer posts warnings or failures for configuration settings that do not meet requirements that it otherwise configures automatically.

This option has no effect on creating or updating user accounts.

--parallel-no-prompts

Installs the server binary package (.rpm or .deb) on the hosts in parallel without prompting for confirmation. This option reduces the installation time, especially on large clusters. If omitted, the install script installs the package on one host at a time. .

This option requires that the installer use passwordless ssh to connect to the hosts. It has no effect if the installer is not using passwordless ssh.

--point-to-point -T

Configures spread to use direct point-to-point communication between all Vertica nodes. Use this option if nodes are not located on the same subnet. Also use this option for all virtual environment installations, whether or not virtual servers are on the same subnet.

Up to 80 spread daemons are supported by point-to-point communication. You can exceed the 80-node limit by using large cluster mode, which does not install a spread daemon on each node.

Do not combine this option with --broadcast.

This option is automatically enabled by the --ipv6 option.

Important

When changing the configuration from --broadcast to --point-to-point, you must also specify --control-network.

--record-config filename -B filename

File name used with command line options to create a properties file that can be used with [‑‑config-file](#record-config). This option creates the properties file and exits; it does not affect installation.

--remove-hosts hostlist -R hostlist

Comma-separated list of hosts to remove from an existing Vertica cluster. After removing the specified hosts, spread is reconfigured on the cluster.

This option is useful for removing an obsolete or over-provisioned system.

If you use --point-to-point (-T) to configure spread to use direct point-to-point communication within the existing cluster, you must also use it when you remove a host; otherwise, the hosts automatically use UDP broadcast traffic, resulting in cluster communication problems that prevents Vertica from running properly.

The update_vertica script (see Removing hosts from a cluster) calls install_vertica to update the installation. You can use either script with this option.

--rpm-path rpm-filepath

Only used in conjunction with --no-rpm-copy, identifies the path to the local copy of the RPM on all nodes specified by --hosts.

Default: /tmp/dbRPM.rpm

--spread-logging -w

Configures spread to output logging to /opt/vertica/log/spread_hostname.log. This option does not apply to upgrades.

Note

Enable spread logging only if requested by Vertica technical support.

--ssh-identity file -i file

The root private-key file to use if passwordless ssh was already configured between the hosts. Before using this option, verify that normal SSH works without a password . The file can be private key file—for example, id_rsa—or PEM file. Do not use with the --ssh-password (-P) option.

Vertica accepts the following:

• By providing an SSH private key which is not password protected. You cannot run the install_vertica script with the sudo command when using this method.

• By providing a password-protected private key and using an SSH-Agent. Note that sudo typically resets environment variables when it is invoked. Specifically, the SSH_AUTHSOCK variable required by the SSH-Agent may be reset. Therefore, configure your system to maintain SSH_AUTHSOCK or invoke install_vertica using a method similar to the following:

  sudo SSH_AUTHSOCK=$SSH_AUTHSOCK /opt/vertica/sbin/install_vertica ...
  

--ssh-password password -P password

The password to use by default for each cluster host. If you omit this option and also omit ‑‑ssh‑identity (-i), then the script prompts for the password as necessary and does not echo input.

Do not use this option together with --ssh-identity (-i).

Important

If you run the install_vertica script as root, specify the root password:

# /opt/vertica/sbin/install_vertica -P root-passwd

If you run the install_vertica script with the sudo command, specify the password of the user who runs install_vertica, not the root password. For example if the dbadmin user runs install_vertica with sudo and has the password dbapasswd, then specify the password as dbapasswd:

$ sudo /opt/vertica/sbin/install_vertica -P dbapasswd

--temp-dir directory

Temporary directory used for administrative purposes. If it is a directory within /opt/vertica, then it is created by the installer. Otherwise, the directory should already exist on all nodes in the cluster. The location should allow dbadmin write privileges.

Note

This is not a temporary data location for the database.

Default: /tmp

3.5 - Install Vertica silently

This section describes how to create a properties file that lets you install and deploy Vertica-based applications quickly and without much manual intervention.

Install the properties file:

1. Download and install the Vertica install package, as described in Download and install the Vertica server package.

2. Create the properties file that enables non-interactive setup by supplying the parameters you want Vertica to use. For example:

   The following command assumes a multi-node setup:

   # /opt/vertica/sbin/install_vertica --record-config file_name --license /tmp/license.txt --accept-eula \
   # --dba-user-password password --ssh-password password --hosts host_list --rpm package_name
   

   The following command assumes a single-node setup:

   # /opt/vertica/sbin/install_vertica --record-config file_name --license /tmp/license.txt --accept-eula \
   # --dba-user-password password
   

   Option	Description
   --record-file file_name	[Required] Accepts a file name, which when used in conjunction with command line options, creates a properties file that can be used with the --config-file option during setup. This flag creates the properties file and exits; it has no impact on installation.
   --license { license_file | CE }	Silently and automatically deploys the license key to /opt/vertica/config/share. On multi-node installations, the –-license option also applies the license to all nodes declared in the --hosts host_list. If specified with CE, automatically deploys the Community Edition license key, which is included in your download. You do not need to specify a license file.
   --accept-eula	Silently accepts the EULA agreement during setup.
   --dba-user-password password	The password for the Database Superuser account; if not supplied, the script prompts for the password and does not echo the input.
   --ssh-password password	The root password to use by default for each cluster host; if not supplied, the script prompts for the password if and when necessary and does not echo the input.
   --hosts host_list	A comma-separated list of hostnames or IP addresses to include in the cluster; do not include space characters in the list. Examples: --hosts host01,host02,host03 --hosts 192.168.233.101,192.168.233.102,192.168.233.103
   --rpm package_name --deb package_name	The name of the RPM or Debian package that contained this script. For example: --rpm vertica-<span class="code-variable">version</span>.RHEL8.x86_64.rpm This parameter is required on multi-node installations if the RPM or DEB package is not already installed on the other hosts.

   See install_vertica options for the complete set of installation parameters.

   Tip

   Supply the parameters to the properties file once only. You can then install Vertica using just the --config-file parameter, as described below.

3. Use one of the following commands to run the installation script.

   • If you are root:

   /opt/vertica/sbin/install_vertica --config-file file_name
   

   • If you are using sudo:

   $ sudo /opt/vertica/sbin/install_vertica --config-file file_name
   

   --config-file file_name accepts an existing properties file created by --record-config file_name. This properties file contains key/value parameters that map to values in the install_vertica script, many with boolean arguments that default to false

   The command for a single-node install might look like this:

   # /opt/vertica/sbin/install_vertica --config-file /tmp/vertica-inst.prp
   

4. If you did not supply a --ssh-password password parameter to the properties file, you are prompted to provide the requested password to allow installation of the RPM/DEB and system configuration of the other cluster nodes. If you are root, this is the root password. If you are using sudo, this is the sudo user password. The password does not echo on the command line.

   Note

   If you are root on a single-node installation, you are not prompted for a password.

5. If you did not supply a --dba-user-password password parameter to the properties file, you are prompted to provide the database administrator account password.

   The installation script creates a new Linux user account (dbadmin by default) with the password that you provide.

6. Carefully examine any warnings produced by install_vertica and correct the problems if possible. For example, insufficient RAM, insufficient Network throughput and too high readahead settings on file system could cause performance problems later on.

   Note

   You can redirect any warning outputs to a separate file, instead of having them display on the system. Use your platforms standard redirected mechanisms. For example: install_vertica [options] > /tmp/file 1>&2.

7. Optionally perform the following steps:

   • Install the ODBC and JDBC driver.

   • Install vsql Client Application on Non-Cluster Hosts.

8. Disconnect from the Administration Host as instructed by the script. This is required to:

   • Set certain system parameters correctly.

   • Function as the Vertica database administrator.

At this point, Linux root privileges are no longer needed. The database administrator can perform the remaining steps.

If you supplied the --license and --accept-eula parameters to the properties file, then proceed to Getting started and then see Configuring the database.

Otherwise:

1. Log in to the Database Superuser account on the administration host.

2. Accept the End User License Agreement and install the license key you downloaded previously as described in Install the License Key.

3. Proceed to Getting started and then see Configuring the database.

Notes

• Downgrade installations are not supported.

• The following is an example of the contents of the configuration properties file:

accept_eula = True
license_file = /tmp/license.txt
record_to = file_name
root_password = password
vertica_dba_group = verticadba
vertica_dba_user = dbadmin
vertica_dba_user_password = password

3.6 - Enable secure shell (SSH) logins

The administrative account must be able to use Secure Shell (SSH) to log in (ssh) to all hosts without specifying a password. The shell script install_vertica does this automatically. This section describes how to do it manually if necessary.

1. If you do not already have SSH installed on all hosts, log in as root on each host and install it now. You can download a free version of the SSH connectivity tools from OpenSSH.

2. Log in to the Vertica administrator account (dbadmin in this example).

3. Make your home directory (~) writable only by yourself. Choose one of:

   $ chmod 700 ~
   

   or

   $ chmod 755 ~
   

   where:

   700 includes	755 includes
   400 read by owner 200 write by owner 100 execute by owner	400 read by owner 200 write by owner 100 execute by owner 040 read by group 010 execute by group 004 read by anybody (other) 001 execute by anybody

4. Change to your home directory:

   $ cd ~
   

5. Generate a private key/ public key pair:

   $ ssh-keygen -t rsa
   Generating public/private rsa key pair.
   Enter file in which to save the key (/home/dbadmin/.ssh/id_rsa):
   Created directory '/home/dbadmin/.ssh'.
   Enter passphrase (empty for no passphrase):
   Enter same passphrase again:
   Your identification has been saved in /home/dbadmin/.ssh/id_rsa.
   Your public key has been saved in /home/dbadmin/.ssh/id_rsa.pub.
   

6. Make your .ssh directory readable and writable only by yourself:

   $ chmod 700 ~/.ssh
   

7. Change to the .ssh directory:

   $ cd ~/.ssh
   

8. Copy the file id_rsa.pub onto the file authorized_keys2.

   $ cp id_rsa.pub authorized_keys2
   

9. Make the files in your .ssh directory readable and writable only by yourself:

   $ chmod 600 ~/.ssh/*
   

10. For each cluster host:

    $ scp -r ~/.ssh <host>:.
    

11. Connect to each cluster host. The first time you ssh to a new remote machine, you could get a message similar to the following:

    $ ssh dev0 Warning: Permanently added 'dev0,192.168.1.92' (RSA) to the list of known hosts.
    

    This message appears only the first time you ssh to a particular remote host.

See also

• OpenSSH

4 - After you install Vertica

The tasks described in this section are optional and are provided for your convenience. When you have completed this section, proceed to one of the following:

• Getting started
• Configuring the database

Install client drivers

After you install Vertica, install drivers on the client systems from which you plan to access your databases. Vertica supplies drivers for ADO.NET, JDBC, ODBC, OLE DB, Perl, and Python. For instructions on installing these drivers, see Client drivers.

Install the license key

If you did not supply the -L parameter during setup, or if you did not bypass the -L parameter for a silent install, the first time you log in as the Database Superuser and run the VerticaAdministration tools or Management Console, Vertica requires you to install a license key.

Follow the instructions in Managing licenses in the Administrator's Guide.

Create a database

To get started using Vertica immediately after installation, create a database. You can use either the Administration Tools or the Management Console. To create a database using MC, refer to Creating a database using MC. For instructions on creating a database with admintools, see Creating a database.

Install vsql client application on non-cluster hosts

You can use the Vertica vsql executable image on a non-cluster Linux host to connect to a Vertica database.

• On Red Hat, CentOS, and SUSE systems, you can install the client driver RPM, which includes the vsql executable. See Installing the vsql client for details.

• If the non-cluster host is running the same version of Linux as the cluster, copy the image file to the remote system. For example:

  $ scp host01:/opt/vertica/bin/vsql .$ ./vsql
  

• If the non-cluster host is running a different distribution or version of Linux than your cluster hosts, you must install the Vertica server RPM in order to get vsql:

  1. Download the appropriate RPM package by browsing to Vertica website. On the Support tab, select Customer Downloads.

  2. If the system you used to download the RPM is not the non-cluster host, transfer the file to the non-cluster host.

  3. Log into the non-cluster host as root and install the RPM package using the command:

     # rpm -Uvh filename
     

     Where filename is the package you downloaded. Note that you do not have to run the install_vertica script on the non-cluster host to use vsql.

Notes

• Use the same Command-line options that you would on a cluster host.

• You cannot run vsql on a Cygwin bash shell (Windows). Use ssh to connect to a cluster host, then run vsql.

vsql is also available for additional platforms. See Installing the vsql client.