Tableau Server on Linux Help

Limitations for Tableau Server in a Container

• Tableau Server in a Container only supports licence activation using Server ATR. Offline activation using Server ATR is supported in 2023.1 and later. This functionality is available in Containers but requires extra steps and approval. If you need to run Tableau Server in a Container in an air-gapped or offline environment, contact your Account representative for more information.
• Tableau Server in a Container does not currently support the Resource Monitoring Tool (RMT) agent.
• Kerberos is not supported in Tableau Server in a Container.

Tableau Server in a Container Setup Tool

The Tableau Server in a Container Setup Tool, build-image, builds a custom Tableau Server in a Container image from a Tableau .rpm Installer and the provided configuration files.

The Setup tool takes a Tableau Server installer and your drivers and other artifacts as input and creates a Docker image. When the build-image tool is used properly, the newly generated image will have installed the desired artefacts.

Supported distributions for building

Installation

The Tableau Server in a Container Setup Tool is provided as a tarball. You will need to extract the contents of the compressed file. Here is an example which assumes the Tableau Server in a Container setup tool archive is in your current directory:

tar -xzf tableau-server-container-setup-tool-<VERSION>.tar.gz

This creates a new directory, tableau-server-container-setup-tool-<VERSION> with the build-image script you use to run the tool.

{
"zip" : "<value>",
"country" : "<value>",
"city" : "<value>",
"last_name" : "<value>",
"industry" : "<value>",
"eula" : "accept",
"title" : "<value>",
"phone" : "<value>",
"company" : "<value>",
"state" : "<value>",
"department" : "<value>",
"first_name" : "<value>",
"email" : "<value>"
}

How to use the tool

There is an executable script in the setup tool called build-image. Running this with the -h option displays the help:

./src/build-image -h
Usage: build-image --accepteula -i [INPUT_IMAGE_NAME] -o [OUTPUT_IMAGE_NAME] [optional arguments]
Creates new Tableau Server image with pre-installed database drivers, configuration, and instructions.
REQUIRED

--accepteula              Indicate that you have accepted the End User License Agreement (EULA).

The EULA is available in the EULA directory of this tool.

-i installer              Path to the Tableau Server installer.

OPTIONAL

-o output name            Tag of target generated Tableau Server image.

-e environment file       Optional environment file to configuration overrides to docker image at build time.

-v setup tool version     Prints the Setup tool version.


-b base image version     Prints the default base image URL.

Basic example usage:

./build-image --accepteula -i tableau-server-image.rpm

Running the command without providing artefacts or a setup script will work, but doesn't really do anything because it would not be copying or installing any additional resources into the original Tableau Server in a Container image.

Orchestration

Tableau only provides documentation and support for Tableau Server containers running on Linux. Tableau does not provide documentation or support for container orchestration systems like Kubernetes or Docker Swarm. Kubernetes can, however, be used to deploy Tableau Server in a Container. For resources and guidance on deploying Tableau containers in Kubernetes, refer to our community-supported GitHub project: https://github.com/tableau/tableau-server-in-kubernetes(Link opens in a new window).

Customising the image

Setting Environment Variables at Build Time

A subset of environment variables that can customise your image can only be set when the image is built. This includes user, group and other properties that require root privilege inside the container. Root actions are not available by default at run-time. Additionally it can be useful to bake certain environment variables into the image at build time so they do not have to be set every time the image is run. All of these environment variables can be set by passing in an environment file to the build-image script.

Environment File

The environment file can be passed to the build-image script using the -e argument. The file must conform to this format:

<KEY>=<VALUE>
<KEY>=<VALUE>

Example Usage:

Create an environment file with the correct format:

UNPRIVILEGED_TABLEAU_UID=1012
UNPRIVILEGED_TABLEAU_GID=1020
TABLEAU_USERNAME=myuser
TABLEAU_PASSWORD=pw

Pass the file to the image builder

./build-image --accepteula -i tableau-server-2020-3.x86_64.rpm -e <path-to-env-file>

Environment Variables

Any environment variable can be set in the environment file. Take a look at the Environment Variables section to see the complete list.

Build-time environment variables can only be set when this script is run to build the image:

Drivers, Certificates and other files

The Tableau Server image does not come with pre-installed data connectors or drivers. You will need to create a bash setup-script that will instruct the build-image script to install the data connectors Tableau Server will need. These are the steps you would take:

1. Make sure the Tableau Server in a Container setup tool is installed properly

2. Download the driver from the Tableau driver page: https://www.tableau.com/en-gb/support/drivers(Link opens in a new window)

3. Copy the downloaded driver file into the customer-files directory in the Tableau Server in a Container setup tool.

   The customer-files directory will be copied into the docker image. It will be located in the following path inside the container: /docker/customer-files

4. Edit the file in the Tableau Server in a Container setup tool customer-files/setup-script to tell Docker how to install the driver.

   The script is just an executable bash file that is executed when the Docker image is built. (Technically it can be used to perform any arbitrary actions in the image including environment setup, configuration, etc.)

   The script will be run inside the container, so be mindful that the commands must work when executed inside the Tableau Server in a Container image.

   For example, if you want to install a driver named mydriver.rpm you would write this in setup-script:

   yum install -y /docker/customer-files/mydriver.rpm

Tableau Administrative Views

Tableau Administrative views require the PostgreSQL driver to be installed. If you plan on using these views you will need to follow the steps above and install the PostgreSQL driver. For more information about Administrative views, see Administrative Views

Deployment Configuration Examples

Docker

Tableau Server in a Container Basic Usage

docker run \
-e LICENSE_KEY=<key>
-p 8080:8080
-d <Tableau Server in a Container image ID or tag>

Tableau Server in a Container Basic Usage with Automated Initial Admin User

docker run \
-e LICENSE_KEY=<key> \
-e TABLEAU_USERNAME=<myadmin> \
-e TABLEAU_PASSWORD_FILE=/etc/tableau-admin-secret \
-v <full-path-to-pw-file>:/etc/tableau-admin-secret \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

TSM only mode

docker run \
-e TSM_ONLY=1 \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Multi-Node Basic Usage

Initial Node

Option 1: Use this if the server configuration (CONFIG_FILE) specifies a multi-node topology:

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-v <full-path-to-config-file>:/docker/config/config.json:ro \
-e LICENSE_KEY=<key> \
-p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \
--hostname=<name-of-host-machine> \
-d <Tableau Server in a Container image ID or tag>

Option 2: Use this if you want a multi-node deployment even if server configuration does not specify multi-node topology:

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-e LICENSE_KEY=<key> -e ALWAYS_WRITE_BOOTSTRAP_FILE=1 \
-p 8080:8080 -p 8800-9000:8800-9000 -p 27000-27010:27000-27010 \
--hostname=<name-of-host-machine> \
-d <Tableau Server in a Container image ID or tag>

Additional node

docker run \
-v <network-shared-directory>:/docker/config/bootstrap \
-e BOOTSTRAP_INSTALL=1 \
-p 8080:8080 -p 8800-9000:8800-9000 \
--hostname=<name-of-host-machine> \
-d <Tableau Server in a Container image ID or tag>

Externalise Data Usage

docker run \
-v <empty-data-dir>:/var/opt/tableau \
-e LICENSE_KEY=<key> \
--hostname=localhost \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Init-Container Basic Usage

Init Container

docker run \
-v <empty-data-dir>:/var/opt/tableau \
-e LICENSE_KEY=<key> \
-e INIT_CONTAINER=1 \
--hostname=localhost \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Run Container

docker run \
-v <empty-data-dir>:/var/opt/tableau \
--hostname=localhost \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Basic Restore from Backup Single-Node

docker run \
-v <full-path-to-backup-file>:/docker/config/backup/backup-file.tsbak \
-v <full-path-to-config-only-file>:/docker/config/config.json:ro \
-e LICENSE_KEY=<key> \
-p 8080:8080 -d <Tableau Server in a Container image ID or tag>

Docker-Compose

version: '3.2'
services:
    tableau-server:
         hostname: localhost
         volumes:
              - <your-tsm-command-file>:/docker/config/tsm-commands:ro
              - <your-config-file >:/docker/config/config.json:ro
         ports:
              - "8080:8080"
         image: ${IMAGE_NAME}
         environment:
              - LICENSE_KEY=<license-key>