Analytics-Admn-201 Questions and Answers

Tableau Server’s installer configures process instances based on hardware and deployment type (single-node vs. multi-node). For a single-node installation with 4 cores, we need to consider the default process topology. Let’s break this down exhaustively:

Key Processes:

Gateway: Handles incoming requests (1 instance).

Application Server (VizPortal): Manages UI and sessions (1 instance).

VizQL Server: Renders visualizations (2 instances).

Backgrounder: Runs extract refreshes, subscriptions (1 instance).

Data Server: Manages data connections (1 instance).

File Store: Stores extracts (1 instance).

Repository: Metadata database (1 instance, active).

Cluster Controller, Cache Server, etc.: Supporting processes (typically 1 each).

Default Configuration:

On a single-node install, Tableau sets 1 instance per process unless specified otherwise, except for VizQL, which defaults to 2.

The installer doesn’t scale instances linearly with cores (e.g., 4 cores ≠ 4 instances). Post-install, TSM can adjust this (e.g., tsm topology set-process), but the question asks for the installed default.

Minimum hardware (8 cores, 32 GB RAM) suggests higher defaults, but 4 cores still triggers a minimal setup.

Option B (1): Correct with Caveat.

Most processes (e.g., Backgrounder, Gateway, Data Server) default to 1 instance on install, regardless of 4 cores.

VizQL defaults to 2, but the question’s phrasing ("each process") implies a general rule. Historically (and per docs), 1 is the baseline for most, with VizQL as the exception.

Interpretation: Assuming "each" means the typical case, 1 fits most processes on a 4-core single-node setup.

Option A (2): Incorrect. Only VizQL defaults to 2; others don’t.

Option C (8): Incorrect. Far exceeds defaults—8 cores might justify more, but not 4.

Option D (4): Incorrect. Not tied to core count by default; manual config would be needed.

Why This Matters: Understanding defaults aids capacity planning—4 cores is below production minimum (8), so performance tuning may be needed post-install.

In Tableau Server, schedules manage tasks like extract refreshes and subscriptions. Each task within a schedule has a priority value (ranging from 1 to 100, where 1 is the highest priority and 100 is the lowest). Tasks with higher priority (lower numbers) are executed before tasks with lower priority (higher numbers) when queued by the Backgrounder process. If the Backgrounder is overloaded or delayed, lower-priority tasks may not complete on time, leading to inconsistent refreshes.

In this scenario:

The 7:00 AM Extract Refresh task is critical for the CEO’s workbook, but the data is only refreshed 70% of the time by 9:00 AM.

The server has a single node, meaning a single Backgrounder process handles all tasks. With five schedules (some overlapping in the early morning), contention or delays could prevent the 7:00 AM task from completing reliably before 9:00 AM.

Option C (Set the priority of this task to 1): Correct. Setting the task priority to 1 ensures it has the highest priority among all queued tasks. This increases the likelihood that the Backgrounder executes it promptly at 7:00 AM, completing the refresh before the CEO accesses the workbook at 9:00 AM. You can adjust task priority in the Tableau Server web interface under Schedules > Tasks > Edit Priority.

Option A (Set the default priority of this schedule to 50): Incorrect. The default priority for schedules is already 50, and this option refers to the schedule’s default, not the specific task. It wouldn’t address the contention issue.

Option B (Set the priority for all other tasks to 50): Incorrect. This keeps all tasks at the default priority (50), leaving the 7:00 AM task without a relative advantage. It doesn’t prioritize the CEO’s task.

Option D (Set the priority of this task to 100): Incorrect. Priority 100 is the lowest, which would deprioritize the task, making the refresh even less reliable.

Tableau Server provides multiple methods to create groups (collections of users) and projects (content containers), catering to UI, CLI, and programmatic needs. Let’s dissect each option with depth:

Option B (Tableau Server browser interface): Correct.

Groups: Go to Users > Groups > Add Group, name it, and optionally sync with Active Directory.

Projects: Go to Content > Projects > New Project, set name, description, and permissions.

Details: The web UI is intuitive, requiring server/site administrator rights. It’s ideal for manual, ad-hoc creation with immediate visibility.

Permissions: For projects, you can set default permissions or lock them here.

Option C (tabcmd): Correct.

Groups: tabcmd creategroup "GroupName" creates a local group. Add users with tabcmd addusers "GroupName" --users "user1,user2".

Projects: tabcmd createproject -n "ProjectName" -d "Description" creates a project.

Details: tabcmd is a command-line tool for batch operations or scripting (e.g., automating group/project setup). It requires a server admin login (tabcmd login).

Limitation: No AD sync via tabcmd—that’s UI or REST API territory.

Option D (REST API): Correct.

Groups: Use the POST /api/api-version/sites/site-id/groups endpoint with a payload (e.g., {"group": {"name": "GroupName"}}). Supports AD import too.

Projects: Use POST /api/api-version/sites/site-id/projects (e.g., {"project": {"name": "ProjectName", "description": "Desc"}}).

Details: The REST API is programmatic, ideal for integration with external systems or bulk automation. Requires authentication via a token and server/site admin rights.

Power: Offers full control, including nested projects and custom permissions.

Option A (tsm customize): Incorrect.

Purpose: tsm customize modifies TSM UI branding (e.g., logos, colors) via commands like tsm customize --logo "path/to/logo.png".

Why Wrong: It’s unrelated to creating groups or projects—it’s for cosmetic server configuration, not content/user management.

Why This Matters: Offering UI, CLI, and API options ensures flexibility—manual for small tasks, automation for scale—critical in enterprise deployments.

In Tableau Server, projects organize content (workbooks, data sources) and use permissions to control access. "Locking permissions" restricts how permissions are managed within a project—let’s explore this exhaustively:

Permission Management Modes:

Managed by Owner: Default mode. Content owners (e.g., workbook publishers) can set permissions on their items, inheriting project defaults as a starting point.

Locked to the Project: Project-level permissions are enforced, and content owners cannot modify them. This ensures consistency across all items in the project.

How to Lock:

In the Tableau Server web UI:

Go to Content > Projects.

Select a project, click Actions > Permissions.

In the Permissions dialog, change Permissions Management from "Customizable" (Managed by Owner) to "Locked."

Set the desired permissions (e.g., Viewer, Editor) for users/groups, which then apply uniformly to all content.

Via REST API: Use the updateProject endpoint with "permissionsLocked": true.

Option B (You can lock permissions to a project by changing Customizable to Locked): Correct.

Details: This is the precise action in the UI—switching from "Customizable" to "Locked" locks permissions at the project level.

Impact: Owners lose the ability to override permissions on individual workbooks/data sources, enforcing governance.

Example: Set "All Users" to Viewer (Locked)—all content in the project is view-only, regardless of owner intent.

Option A (Locking permissions must be enabled on the Server Settings page): Incorrect.

Why: Locking is a per-project setting, not a server-wide toggle. The Server Settings page (via TSM) controls global configs (e.g., authentication), not project permissions.

Option C (Content permissions are locked by default): Incorrect.

Default: New projects are "Managed by Owner" (Customizable), allowing flexibility unless explicitly locked by an admin.

Option D (By setting the appropriate Project permission role): Incorrect.

Confusion: "Project permission role" isn’t a term—permissions are set via rules (e.g., Viewer, Editor), but locking is a separate action (Customizable → Locked).

Why This Matters: Locking permissions ensures uniform access control, critical for regulated environments or large teams where consistency trumps flexibility.

In Tableau, data sources can be embedded (stored within a workbook) or published (stored separately on Tableau Server). Let’s define these and analyze the advantages:

Embedded Data Source: The connection details and any extract are bundled in the .twb or .twbx file. Each workbook manages its own copy.

Published Data Source: The connection or extract is hosted on Tableau Server, reusable across multiple workbooks.

Now, let’s evaluate the options:

Option C (Centralized data management is easier): Correct. Published data sources allow:

Single source of truth: One data source can serve multiple workbooks, ensuring consistency.

Unified updates: Refresh schedules, permissions, and metadata (e.g., calculated fields) are managed in one place via the Server UI.

Governance: Administrators can control access and monitor usage centrally.In contrast, embedded data sources require individual updates per workbook, leading to duplication and management overhead.

Option D (Storage space is conserved and resource usage during data refreshes is optimized): Correct. With published data sources:

Storage: A single extract on the Server (e.g., a .hyper file) is shared across workbooks, avoiding redundant copies stored in each embedded workbook.

Refreshes: One refresh job updates the shared extract, reducing CPU and memory usage compared to multiple refreshes for duplicate embedded extracts.Embedded data sources replicate extracts, increasing disk space and refresh load.

Option A (Data is protected so that it is only available in one workbook): Incorrect. This describes embedded data sources, not published ones. Published data sources are shared, not restricted to one workbook—permissions control access, not exclusivity.

Option B (Drivers are automatically installed on each client's machine): Incorrect. Drivers (e.g., for SQL Server, PostgreSQL) must be installed on the Server hosting the published data source, not client machines. This is unrelated to the published vs. embedded distinction.

Why This Matters: Published data sources enhance scalability and efficiency in enterprise deployments, making them a cornerstone of Tableau Server’s data strategy.

Tableau Server’s performance and stability depend on dedicated resources and proper configuration. Running additional software on the same server is the most likely to cause problems because:

Resource contention: Tableau Server requires significant CPU, RAM, and disk I/O. Other software (e.g., databases, web servers) can compete for these resources, leading to slowdowns, crashes, or failed tasks.

Port conflicts: Tableau uses specific ports (e.g., 80, 443, 8850), and other applications might interfere.

Security risks: Additional software increases the attack surface, potentially compromising Tableau Server.

Tableau recommends running the server on dedicated hardware without unrelated applications.

Option A (Running additional software on the server): Correct. This is a common cause of performance issues and is explicitly discouraged in Tableau’s best practices.

Option B (Separating the Backgrounder and VizQL processes to different machines): Incorrect. This is a supported multi-node configuration that can improve performance, not cause problems, if properly set up via TSM.

Option C (Configuring the server to use a static IP address): Incorrect. A static IP is recommended for Tableau Server to ensure consistent network access, so it’s unlikely to cause issues.

Option D (Using a non-default installation path): Incorrect. While not default, a custom path is supported (via TSM or installer options) and unlikely to cause problems if permissions and disk space are adequate.

The tsm maintenance backup command creates a backup file (with a .tsbak extension) that captures critical data needed to restore Tableau Server in case of failure or migration. This backup primarily includes:

Repository data: This encompasses the PostgreSQL database, which stores metadata such as workbooks, data sources, user information, permissions, schedules, and subscriptions.

Configuration data: This includes server settings like authentication methods, port configurations, and service layouts, but it does not include topology data as a separate entity (topology is part of the configuration).

The command does not back up the following:

Extract files (stored in the File Store), which must be backed up separately if needed.

Log files, which are archived using tsm maintenance ziplogs.

Option A (Notification settings) is incorrect because while notification settings are part of the configuration data stored in the repository, they are not the primary focus of the backup. The broader category is "repository data."

Option B (SMTP server settings) is also incorrect for the same reason—SMTP settings are configuration data within the repository, but the backup is not limited to just these settings.

Option D (Topology data) is incorrect because topology data (e.g., how services are distributed across nodes) is part of the configuration included in the backup, but it’s not stored as a standalone item. The .tsbak file is centered on the repository database.

Editing permissions on a workbook in Tableau Server depends on the user’s role and the project’s permission settings. Since permissions are not locked (i.e., "Managed by Owner"), let’s dissect who can edit them:

Permission Model:

Not Locked: Owners of content (workbooks, data sources) can set permissions, and Project Leaders can override at the project level.

Site Roles: Define maximum capabilities (e.g., Viewer, Explorer, Creator).

Capabilities: "Set Permissions" is explicit—only certain users get it.

Option C (The workbook’s owner): Correct.

Details: The owner (typically the publisher) has full control over their workbook when permissions are Managed by Owner:

How: In the UI, go to Content > Workbooks > Actions > Permissions—owners can edit rules (e.g., grant Editor to a group).

Site Role: Minimum of Explorer (can publish) or Creator to publish, ensuring "Set Permissions" capability.

Why: Ownership inherently includes permission management unless locked.

Option D (Users set to Project Leader for the workbook’s project): Correct.

Details: Project Leaders are assigned via Content > Projects > Actions > Permissions > Set Project Leader:

Power: Can edit permissions for all content in the project, even if not the owner.

Site Role: Requires Site Administrator or Server Administrator (Creator/Explorer variants suffice).

Why: Overrides ownership in Managed by Owner mode—ensures project-level governance.

Option A (Users with project and workbook Viewer role): Incorrect.

Why: Viewer role (site-level) limits users to viewing—lacks "Set Permissions" capability, regardless of project/workbook rules.

Option B (Users with workbook Interactor role): Incorrect.

Why: "Interactor" isn’t a standard role—likely a misnomer for Explorer or Viewer with interaction permissions (e.g., Filter). No permission-editing rights exist here.

Why This Matters: Knowing who can edit permissions prevents access control gaps—crucial for collaborative or regulated environments.

The Backgrounder process in Tableau Server handles tasks like extract refreshes and subscriptions—let’s explore its concurrency:

Backgrounder Behavior:

Each instance is single-threaded for task execution—one task at a time per Backgrounder.

Multiple Backgrounders (e.g., in multi-node setups) increase parallelism, but a single Backgrounder is limited to 1 concurrent task.

Queue: Additional tasks wait in the queue, prioritized by their priority (1–100).

Option A (One): Correct.

Details: A single Backgrounder executes one task (e.g., an extract refresh) until completion before starting the next.

Config: Add more Backgrounders via TSM (tsm topology set-process -n node1 -pr backgrounder -c 2) for more concurrency.

Option B (Two): Incorrect.

Why: Not natively supported—a single Backgrounder doesn’t multi-thread tasks.

Option C (Three): Incorrect.

Why: Exceeds the single-threaded design.

Option D (Unlimited): Incorrect.

Why: Concurrency is fixed at 1 per instance—resources affect queue processing speed, not simultaneous tasks.

Why This Matters: Understanding Backgrounder limits guides scaling—more instances mean more parallel tasks, critical for heavy workloads.

In Tableau Server, projects are containers for organizing and securing content. They help manage permissions and structure content hierarchically. Let’s define what can be contained:

Workbooks: Visualizations and dashboards published to the Server.

Data Sources: Published connections or extracts reusable across workbooks.

Nested Projects: Sub-projects within a parent project, introduced in later versions (e.g., 2018.2) for deeper organization.

Option B (Workbooks): Correct. Workbooks are the primary content type in projects, containing views and dashboards.

Option C (Nested Projects): Correct. Nested projects allow hierarchical structuring (e.g., a "Sales" project with "Q1" and "Q2" sub-projects), with inherited or custom permissions.

Option D (Data Sources): Correct. Published data sources reside in projects, providing reusable data connections.

Option A (Groups): Incorrect. Groups are collections of users managed at the site or server level, not stored within projects. Projects contain content, not user entities.

Why This Matters: Projects are key to content governance—knowing what they hold helps administrators organize and secure assets effectively.