信頼できるSalesforce Administrator Analytics-Admn-201問題集PDF 2026年03月23日最近更新された問題 [Q22-Q43]

Tableau Server uses caching to speed up workbook loading by storing query results. After a scheduled extract refresh updates the data, the cache may need recomputing-let’s dive into the mechanics:
* Caching Basics:
* VizQL Cache: Stores rendered views and query results for faster access.
* Refresh Trigger: A scheduled refresh updates the underlying extract (.hyper), but the cache isn’t automatically invalidated-it’s demand-driven.
* Recompute Conditions: Tableau recomputes the cache when the workbook is accessed (viewed) and its data has changed (e.g., via refresh).
* Evaluation:
* Option B (The workbook has upcoming scheduled refresh tasks): Correct.
* Why: An upcoming refresh task indicates the workbook relies on an extract with a schedule. After the refresh runs, the data changes, priming the cache for recomputation on next view. Without a schedule, no refresh occurs, so this is a prerequisite.
* Detail: Schedules are set in Schedules > Tasks-e.g., “Daily at 2 AM.”
* Option D (The workbook has been viewed recently): Correct.
* Why: Viewing triggers cache recomputation if the data has changed (e.g., post-refresh).
Tableau uses a “lazy caching” model-cache updates only when a user loads the workbook, ensuring fresh results.
* Detail: “Recently” isn’t strictly defined but implies post-refresh access.
* Option A (Published in the last month): Incorrect.
* Why: Publish date is irrelevant-cache recomputation ties to data changes and access, not publication timing.
* Option C (All Users group has permission rule allowing access): Incorrect.
* Why: Permissions enable viewing, but recomputation requires actual access (viewing) and a refresh event, not just potential access.
Why This Matters: Caching balances performance and freshness-understanding triggers prevents stale data surprises.
Reference: Tableau Server Documentation – “Caching and Performance” (https://help.tableau.com/current
/server/en-us/perf_cache.htm).

In an HA Tableau Server cluster, the Coordination Service (ZooKeeper ensemble) maintains cluster state- let’s find the best way to check it:
* Coordination Service:
* Runs on multiple nodes (3 or 5 in HA) to ensure quorum and failover.
* Status indicates if it’s running and synced-critical for cluster health.
* Option C (Run tsm status -v): Correct.
* Details: tsm status –verbose lists all processes across nodes, including Coordination Service (e.
g., “Coordination Service: RUNNING”).
* Why Best: Provides detailed, node-specific status in the CLI-e.g., “Node 1: RUNNING, Node
2: RUNNING.”
* Use: Run on the initial node; -v ensures full output.
* Option A (TSM web client Status page): Incorrect.
* Why: The TSM UI (Server > Status) shows process counts (e.g., “Coordination Service: 3 instances”), but not detailed per-node status-less granular than CLI.
* Option B (tsm maintenance ziplogs): Incorrect.
* Why: Generates log archives for troubleshooting, not a real-time status check.
* Option D (Tableau Server Status page): Incorrect.
* Why: The Server Status page (Server > Status in the web UI) monitors application processes (e.
g., VizQL), not TSM’s Coordination Service.
Why This Matters: Coordination Service health ensures HA stability-tsm status -v is the admin’s go-to for precision.
Reference: Tableau Server Documentation – “Check Server Status” (https://help.tableau.com/current/server/en- us/tsm_status.htm).

Table recommendations in Tableau Server suggest popular tables and data sources to users when they create new content in the web authoring environment. This feature is enabled by default but can be disabled at the site level.
Option A (Disable the option using the site Settings page): Correct. A site administrator can disable table recommendations by navigating to the site’s Settings > General page in the Tableau Server web interface and unchecking the option “Enable table recommendations.” This prevents users on that site from seeing these suggestions, offering a straightforward UI-based solution.
Option B (Use the command: tsm configuration set -k recommendations.enabled -v false): Incorrect. There is no recommendations.enabled key in the TSM configuration settings. This feature is managed per site, not server-wide via TSM.
Option C (Publish data sources only to projects with permissions locked): Incorrect. Locking permissions restricts access but doesn’t disable the recommendation feature itself. Users with access would still see recommendations.
Option D (Disable the option using the server Settings page): Incorrect. Table recommendations are a site- specific setting, not a server-wide setting. The server Settings page (via TSM) controls global configurations, not this feature.
Reference: Tableau Server Documentation – “Manage Site Settings” (https://help.tableau.com/current/server
/en-us/site_settings.htm).

When a user reports slow performance for a newly-published workbook on Tableau Server, troubleshooting requires isolating the cause-e.g., data source issues, server load, workbook design, or caching. The first question should establish a baseline to narrow the scope. Let’s analyze this step-by-step with depth:
* Performance Context:
* A workbook’s speed depends on:
* Data Source: Query complexity, size, network latency (e.g., database vs. extract).
* Workbook Design: Filters, calculations, dashboard complexity.
* Server Resources: VizQL rendering, Backgrounder load, caching.
* “Newly-published” implies it’s not yet optimized or cached on the server.
* Option A (Does it run any faster in Tableau Desktop?): Correct.
* Why First: Comparing Desktop vs. Server performance is the most foundational diagnostic step:
* Desktop Baseline: If it’s slow in Desktop (local machine), the issue likely lies in the workbook (e.g., complex queries, large data) or data source (e.g., slow database)-not Server-specific.
* Server Difference: If it’s fast in Desktop but slow on Server, the problem could be server- side (e.g., resource contention, network latency to the data source from Server).
* Practical Next Steps:
* Slow in Desktop: Optimize workbook (e.g., simplify calcs, use extracts).
* Fast in Desktop: Check Server (e.g., caching, VizQL load).
* Why Critical: Establishes whether the issue is inherent to the workbook/data or introduced by Server-guides all further investigation.
* Option B (Does the workbook always run slowly or does performance vary?): Useful but secondary.
* Why Not First: Variability (e.g., slow at peak times) points to server load, but without a Desktop baseline, you can’t rule out workbook design. It’s a follow-up question after A.
* Detail: Variability might suggest caching or concurrent user impact, but it assumes Server-side causation prematurely.
* Option C (How many times have you opened the workbook in Tableau Server?): Less relevant initially.
* Why Not First: Frequency of access might affect caching (first load is slower, subsequent loads faster), but it’s too specific and doesn’t isolate Desktop vs. Server. It’s a niche follow-up.
* Option D (Did you enable caching on the workbook?): Misleading and incorrect.
* Why Not First: Caching is server-managed (e.g., VizQL cache settings via tsm data-access caching set), not a user-toggle per workbook. Users don’t “enable” it-admins do. Plus, it’s premature without a baseline.
Why This Matters: Starting with Desktop performance cuts through assumptions, pinpointing whether the root cause is client-side (workbook/data) or server-side-essential for efficient resolution in production.
Reference: Tableau Server Documentation – “Troubleshoot Performance” (https://help.tableau.com/current
/server/en-us/troubleshoot_performance.htm).

Importing an AD group into Tableau Server syncs user management-let’s analyze the process and options:
* AD Group Import Process:
* How: In the UI (Users > Groups > Add Group > Active Directory), enter the AD group name, set a site role, and sync.
* Behavior:
* Existing Users: If a user is already in Tableau Server, their site role remains unchanged unless manually adjusted-sync applies the minimum role only if it upgrades access.
* New Users: Added to Tableau with the site role specified during import.
* Config: Requires AD authentication enabled in TSM.
* Option D (New users created are assigned the site role specified during import): Correct.
* Details: When importing (e.g., “SalesTeam” group, site role: Explorer):
* New users get Explorer.
* Existing users keep their role unless it’s below Explorer (e.g., Unlicensed # Explorer).
* Why: Ensures consistent onboarding-new users align with the group’s intended access.
* Option A (Existing users’ roles change to match import): Incorrect.
* Why: Existing roles persist unless lower than the minimum-e.g., Viewer stays Viewer if import sets Explorer, but Unlicensed upgrades. Not a full overwrite.
* Option B (Requires a .csv file): Incorrect.
* Why: AD import uses live sync via LDAP-no .csv needed (that’s for local auth imports).
* Option C (Change group name during import): Incorrect.
* Why: The AD group name is fixed-you can’t rename it in Tableau during sync (it mirrors AD).
Post-import renaming is possible but not part of the process.
Why This Matters: Accurate AD sync ensures seamless user management-missteps can disrupt access or licensing.
Reference: Tableau Server Documentation – “Synchronize Active Directory Groups” (https://help.tableau.com
/current/server/en-us/groups_sync.htm).

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.
Reference: Tableau Server Documentation – “Server Process Settings” (https://help.tableau.com/current/server
/en-us/processes.htm).

Abandoned workbooks-those no longer actively used-can clutter Tableau Server and consume resources (e.
g., disk space for extracts). Identifying them efficiently requires leveraging built-in administrative tools rather than manual or destructive methods. Let’s explore this in depth:
* Tableau Server Admin Views: Tableau provides pre-built administrative views to monitor server health, usage, and content. The Stale Content view, accessible under Server > Status > Administrative Views, is specifically designed to identify content (workbooks, data sources) that hasn’ t been viewed or modified recently. It shows:
* Content name, owner, and project.
* Last viewed date and last modified date.
* View count over a period.This view uses Repository data to track usage metrics, making it ideal for spotting abandoned workbooks.
* Option A (Use the Stale Content administrative view): Correct. This is the most efficient and non- invasive method. You can filter by last viewed date (e.g., >30 days ago) to identify workbooks with large extracts that users have stopped accessing. From there, you can contact owners or delete the content if policy allows. It’s a server administrator’s go-to tool for content management.
* Option B (Examine extract files in ProgramData/…/extract): Incorrect and impractical. The ProgramData/Tableau/Tableau Server/data/tabsvc/dataengine/extract directory stores .hyper extract files, but:
* File names are cryptic (e.g., GUIDs), not tied directly to workbook names.
* It doesn’t indicate usage or abandonment-only file presence and size.
* Manual inspection is time-consuming and error-prone compared to the Stale Content view.
* Option C (Delete all extracts and allow them to be re-generated): Incorrect and risky. Deleting extracts (e.g., via tsm maintenance cleanup) removes them without identifying usage. Regeneration only occurs if a schedule or user triggers it, potentially disrupting active users and losing historical data unnecessarily.
* Option D (View all workbooks, and sort by the Modified date): Partially effective but inefficient. In the Tableau Server UI (e.g., under Content > Workbooks), you can sort by “Last Modified,” but:
* It doesn’t show viewership (a workbook might be modified recently but unused).
* It’s manual and doesn’t scale for large deployments compared to the Stale Content view.
Why This Matters: The Stale Content view leverages Tableau’s metadata to provide actionable insights, saving time and reducing risk compared to manual or destructive alternatives. It’s part of Tableau’s governance toolkit.
Reference: Tableau Server Documentation – “Administrative Views” (https://help.tableau.com/current/server
/en-us/adminview_stale_content.htm).

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.
Reference: Tableau Server Documentation – “Permissions” (https://help.tableau.com/current/server/en-us
/permissions.htm), “Project Leader Permissions” (https://help.tableau.com/current/server/en-us
/permissions_project_leader.htm).

Tableau Server is designed for production environments and is supported only on server-class operating systems, not desktop operating systems. As of the latest documentation (aligned with knowledge up to March
21, 2025), the supported operating systems for Tableau Server on Windows are:
Windows Server 2016
Windows Server 2019
Windows Server 2022 (added in later versions, but relevant as of 2025).
Desktop operating systems like Windows 7 or Windows 10 are not supported for production installations due to stability, security, and performance requirements.
Option A (Windows 7): Incorrect. Windows 7 is a desktop OS and is not supported for Tableau Server. It’s also end-of-life as of January 2020.
Option B (Windows 10): Incorrect. Windows 10 is a desktop OS and not supported for production Tableau Server deployments, though it may be used for testing in non-production scenarios.
Option C (Windows Server 2019): Correct. This is a supported server OS for Tableau Server.
Option D (Windows Server 2016): Correct. This is also a supported server OS for Tableau Server.
Reference: Tableau Server Documentation – “System Requirements for Tableau Server” (https://help.tableau.
com/current/server/en-us/requirements.htm).

Tableau Server can record performance metrics for workbooks to troubleshoot slow-loading views. This feature must be enabled at the site level (via Settings > General > Allow Performance Recording). Once enabled, you can trigger recording for a specific view by modifying its URL.
The correct syntax is to append :record_performance=yes& to the view URL, immediately after the session ID. For example:
* Original
URL: http://server/#/site/my-site/views/workbook/view?:iid=1
* Modified
URL: http://server/#/site/my-site/views/workbook/view?:iid=1:record_performance=yes
&
After loading the view with this parameter, a performance recording is generated and accessible via the Performance option in the toolbar.
* Option B (Type :record_performance=yes& at the end of the view URL, immediately after the session ID): Correct. This follows Tableau’s documented method for enabling performance recording.
* Option A (Click the Performance link in the toolbar): Incorrect. The Performance link appears only after recording is triggered via the URL; it’s not the method to enable it.
* Option C (Type :record_performance=yes& immediately before the session ID): Incorrect. The parameter must follow the session ID (e.g., :iid=1) to function correctly.
* Option D (Delete the session ID in the URL and reload the view): Incorrect. The session ID is required for the view to load properly; removing it breaks the URL.
Reference: Tableau Server Documentation – “Record Performance of a View” (https://help.tableau.com/current
/server/en-us/perf_record.htm).

Trusted Tickets is an authentication method in Tableau Server for embedding views in external applications (e.g., portals) without requiring users to log in manually. Here’s how it works:
* A trusted application (e.g., a web server) authenticates with Tableau Server using a trusted IP or username/password.
* Tableau Server issues a temporary ticket (a unique string).
* The ticket is embedded in a view URL (e.g., /trusted/<ticket>/views/…), granting access to the view for a short period (configurable, default 5 minutes).
* Option A (Access embedded views without being prompted for credentials): Correct. Trusted tickets enable SSO-like behavior for embedded content, bypassing the login prompt if the ticket is valid. This is ideal for seamless integration into external systems.
* Option B (Encrypt database connections): Incorrect. Encryption is handled by data source configurations (e.g., SSL), not trusted tickets, which focus on user authentication.
* Option C (Save and edit workbooks): Incorrect. Trusted tickets grant view access, not edit permissions-those depend on the user’s site role and permissions.
* Option D (Embed database credentials): Incorrect. Trusted tickets authenticate users to Tableau Server, not databases-database credentials are managed separately in the data source.
Why This Matters: Trusted tickets simplify embedding Tableau content securely in custom applications, enhancing user experience.
Reference: Tableau Server Documentation – “Trusted Authentication” (https://help.tableau.com/current/server
/en-us/trusted_auth.htm).

Tableau Server uses a role-based licensing model with three primary license levels: Creator, Explorer, and Viewer. Each license level corresponds to specific site roles that define what users can do on the server.
Viewer License: This is the most restrictive license, allowing users to view and interact with published content (e.g., dashboards and visualizations) but not to create or publish new content.
Site Role: The Viewer license can only be associated with the Viewer site role. This role restricts users to viewing capabilities, aligning with the license’s purpose.
Option A (Creator): Incorrect. The Creator license is for users who can create, edit, and publish content using Tableau Desktop and the web interface. It corresponds to the Creator site role, not Viewer.
Option B (Explorer (can publish)): Incorrect. This is a variation of the Explorer license, which allows users to edit and publish content within limits. It’s more permissive than Viewer.
Option C (Viewer): Correct. The Viewer site role matches the Viewer license level perfectly.
Option D (Explorer): Incorrect. The Explorer license allows users to explore data and create content in the web interface, exceeding the Viewer license’s capabilities.
Reference: Tableau Server Documentation – “User Site Roles and Licenses” (https://help.tableau.com/current
/server/en-us/license_usage.htm).

Tableau Server uses internal secrets (tokens) for secure communication between its processes (e.g., Repository, File Store). These are automatically generated during installation and can be regenerated if compromised or for security maintenance. The command to update these is:
* tsm security regenerate-internal-tokens: This regenerates the internal security tokens, ensuring all processes use the new tokens after a restart.
* Option C (tsm security regenerate-internal-tokens): Correct. This is the documented command for updating internal secrets.
* Option A (tsm data-access caching set -r 1): Incorrect. This command configures caching behavior, not security tokens.
* Option B (tsm licenses refresh): Incorrect. This refreshes license data, unrelated to internal secrets.
* Option D (tsm security validate-asset-keys): Incorrect. This validates encryption keys for assets, not internal tokens.
Reference: Tableau Server Documentation – “Regenerate Internal Tokens” (https://help.tableau.com/current/server/en-us/cli_security.htm#regenerate-internal-tokens).

In Tableau Server, roles and permissions dictate who can perform specific administrative tasks. A “server administrator” has full control over the entire Tableau Server deployment, while site administrators manage specific sites. Some tasks are restricted to server administrators due to their server-wide impact.
Option B (Adding a site): Creating a new site in a multi-site Tableau Server environment is a server-level task that only a server administrator can perform. Sites are logical partitions within the server, and adding a site affects the overall server structure. Site administrators cannot create new sites; they can only manage existing ones.
Option D (Adding users): Adding users to Tableau Server (e.g., via the TSM interface or tabcmd) is a server administrator task when it involves adding users at the server level or assigning them to the default site. While site administrators can add users to their specific site in a multi-site environment, the initial addition of users to the server requires server administrator privileges. The question’s phrasing (“always require”) suggests a server-wide context, making this a correct choice.
Option A (Creating a schedule): This is incorrect because both server administrators and site administrators can create schedules for tasks like extract refreshes or subscriptions within their scope. It’s not exclusive to server administrators.
Option C (Locking project permissions): This is incorrect because locking project permissions can be done by a site administrator or project leader with appropriate permissions. It’s a project-level action, not a server- level task requiring a server administrator.
Reference: Tableau Server Documentation – “Administrative Tasks” (https://help.tableau.com/current/server
/en-us/admin_tasks.htm) and “User Management” (https://help.tableau.com/current/server/en-us/users.htm).

Tableau Server’s minimum hardware recommendations for a production single-node deployment ensure reliable performance for small to medium workloads. As of the latest documentation:
* CPU: 8 cores (2.0 GHz or higher) to handle concurrent users, rendering, and background tasks.
* RAM: 32 GB to support in-memory processing (e.g., VizQL, Data Engine) and caching.
* Disk Space: 50 GB free for installation, logs, extracts, and temporary files.
Let’s break it down:
* Option C (8-Core CPU, 32 GB RAM, 50 GB free disk space): Correct. This matches Tableau’s official minimum for production:
* 8 cores ensure sufficient parallelism for processes like Backgrounder and VizQL.
* 32 GB RAM supports multiple users and extract refreshes.
* 50 GB disk space accommodates growth (initial install is ~1-2 GB, but logs and extracts expand).
* Option A (4-Core, 16 GB RAM, 50 GB): Incorrect. Too low for production-4 cores and 16 GB RAM are below the threshold for reliable performance under load.
* Option B (2-Core, 8 GB RAM, 15 GB): Incorrect. This is for non-production (e.g., trial) setups, insufficient for production stability.
* Option D (4-Core, 64 GB RAM, 50 GB): Incorrect. 4 cores are inadequate, though 64 GB RAM exceeds the minimum (32 GB).
Why This Matters: Under-spec hardware can lead to slow performance, failed refreshes, or crashes in production-adhering to the minimum ensures stability.
Reference: Tableau Server Documentation – “Minimum Hardware Recommendations” (https://help.tableau.
com/current/server/en-us/requirements.htm).

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.
Reference: Tableau Server Documentation – “Projects” (https://help.tableau.com/current/server/en-us/projects.
htm).

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.
Reference: Tableau Server Documentation – “Best Practices for Installation” (https://help.tableau.com/current
/server/en-us/install_best_practices.htm).

Tableau Server uses a PostgreSQL database as its repository to store metadata, user information, and permissions. In a high-availability (HA) setup with multiple nodes, there are typically two repository instances: one active and one passive. The “preferred active repository” refers to designating which repository instance should take priority as the active one. This is managed through Tableau Services Manager (TSM).
The correct method to set the preferred active repository is by using the tsm configuration set command.
Specifically, you would use a command like:
tsm configuration set -k pgsql.preferred_host -v <hostname>
This command allows an administrator to specify the preferred host for the active repository, ensuring control over which node takes precedence in an HA environment.
Option B (tabcmd set command) is incorrect because tabcmd is a command-line utility primarily used for administrative tasks like managing users, groups, and content (e.g., publishing workbooks), not for configuring server topology or repository settings.
Option C (TSM browser client’s Maintenance page) is incorrect because the Maintenance page in the TSM web interface is used for tasks like backups, restores, and cleanup, but it does not provide an option to set the preferred active repository.
Option D (TSM browser client’s Configuration Topology page) is partially relevant since the Topology page displays the current configuration of services across nodes, including the repository. However, it does not allow direct modification of the preferred active repository; this must be done via the tsm command line.
Reference: Tableau Server Documentation – “Configure Tableau Server Repository” (https://help.tableau.com
/current/server/en-us/repository.htm) and “TSM Command Line Reference” (https://help.tableau.com/current
/server/en-us/cli_configuration_set.htm).

Backing up Tableau Server ensures recovery from failures or migrations. A full backup includes multiple data types-let’s dissect this comprehensively:
* Backup Components:
* Repository Data: PostgreSQL database with metadata (users, permissions, workbooks). Backed up via tsm maintenance backup -f <filename>.tsbak.
* Configuration Data: Server settings (e.g., ports, authentication) also in the .tsbak file.
* Server Secrets: Encryption keys, internal tokens, Repository passwords-critical for restoring functionality.
* Extracts: .hyper files in File Store (optional, separate backup).
* Option A (Server secrets and Repository passwords): Correct.
* Details: Includes encryption keys (for extracts), internal tokens (process communication), and Repository credentials. Backed up separately or stored securely (e.g., tsm security export-keys).
* Why Critical: Without these, restored data may be inaccessible or services may fail.
* Option C (Configuration data): Correct.
* Details: Ports, authentication settings, process topology-part of the .tsbak file.
* Why Critical: Restores server behavior and connectivity post-recovery.
* Option D (Repository data): Correct.
* Details: Core metadata database-also in .tsbak.
* Why Critical: Without it, all content and user data is lost.
* Option B (Topology data): Incorrect.
* Details: Topology (process distribution) is part of configuration data in the .tsbak, not a separate entity. It’s not distinctly backed up as “topology data.” Why This Matters: A complete backup (secrets, config, repository) ensures full restoration-missing any piece risks an unusable server.
Reference: Tableau Server Documentation – “Back Up Tableau Server Data” (https://help.tableau.com/current
/server/en-us/backup_restore.htm).

Comments on Tableau Server visualizations facilitate collaboration. Let’s explore what’s supported:
* Comments Feature: Enabled per site (Settings > General > Allow Comments). Users with “Add Comment” permission can post on views.
* Option B (Text): Correct.
* Details: The primary content type-users type free-form text in the comment box.
* Use: Notes, questions, or feedback (e.g., “Sales spiked here-why?”).
* Option C (@mentions): Correct.
* Details: Typing @username notifies the mentioned user via email or the UI (if notifications are enabled).
* Use: Directs comments to specific people (e.g., “@John, check this trend”).
* Option A (Interactive snapshots of a view): Incorrect.
* Details: Snapshots (static images) aren’t supported in comments-users must take screenshots externally and can’t embed them interactively.
* Option D (Images – jpg, png): Incorrect.
* Details: No attachment or image embedding in comments-text and mentions only. Workaround:
Link to an image hosted elsewhere.
Why This Matters: Comments enhance teamwork, but their simplicity (text + mentions) keeps the interface lightweight and focused.
Reference: Tableau Server Documentation – “Comment on a View” (https://help.tableau.com/current/server
/en-us/comment.htm).

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.
Reference: Tableau Server Documentation – “Lock Project Permissions” (https://help.tableau.com/current
/server/en-us/permissions_lock.htm).

TSM is Tableau Server’s management layer, accessible via CLI or web UI (port 8850). HTTPS secures this access-let’s identify the responsible process:
* TSM Architecture:
* Administration Controller: Core TSM process, running on the initial node, handling configuration, UI, and CLI commands.
* HTTPS: Enabled by default on port 8850 with a self-signed certificate (configurable to custom certs).
* Option B (Administration Controller): Correct.
* Details: Hosts the TSM web UI (https://<server>:8850) and processes CLI requests. It manages the HTTPS listener, serving the interface securely.
* Why: It’s the central hub for TSM operations, including secure access.
* Option A (License Manager): Incorrect.
* Why: Validates licenses, not responsible for HTTPS or UI access.
* Option C (Administration Agent): Incorrect.
* Why: Runs on additional nodes in multi-node setups to relay commands to the Controller-no direct HTTPS role.
* Option D (Coordination Service): Incorrect.
* Why: ZooKeeper manages cluster state, not TSM’s web interface or HTTPS.
Why This Matters: Secure TSM access protects server administration-Administration Controller is the linchpin.
Reference: Tableau Server Documentation – “TSM Overview” (https://help.tableau.com/current/server/en-us
/tsm_overview.htm).