Salesforce Analytics-Admn-201 Exam Dumps

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.

When Tableau Server uses Active Directory (AD) for authentication, group synchronization imports AD groups and assigns a minimum site role (e.g., Viewer, Explorer) to users in that group. This ensures users meet a baseline access level. The behavior for existing users during sync is:

If the user's current site role provides more access than the minimum (e.g., Explorer vs. Viewer), their role remains unchanged.

If the user's current role provides less access than the minimum (e.g., Unlicensed vs. Viewer), their role is upgraded to the minimum.

This preserves higher privileges while enforcing a floor. ''Reduces access'' means the minimum role is lower than the current role (e.g., Viewer vs. Explorer), in which case the existing role stays.

Option A (It will change to the minimum site role only if the minimum site role reduces access): Correct. The user's role changes only if the minimum increases access (e.g., Unlicensed to Viewer); otherwise, it stays higher.

Option B (It will change only if the minimum provides more access): Incorrect wording. This is the inverse of the actual behavior---change occurs when needed to meet the minimum, not to exceed it.

Option C (It will always change): Incorrect. Existing higher roles are preserved.

Option D (It will never change): Incorrect. It changes if the current role is below the minimum.

Kerberos delegation allows Tableau Server to pass a user's Kerberos credentials to a data source for seamless authentication (SSO)---let's explore which sources support it:

Kerberos Overview:

Used with Active Directory (AD) for SSO in Windows environments.

Tableau Server delegates the user's ticket to the data source, avoiding embedded credentials.

Requires:

Data source support for Kerberos.

Proper configuration (e.g., SPN, constrained delegation).

Supported Data Sources: Per Tableau's documentation:

Option A (Teradata): Correct.

Details: Supports Kerberos delegation---common in enterprise data warehouses.

Config: Enable in TSM (tsm authentication kerberos configure) and set SPN for Teradata.

Option C (SQL Server): Correct.

Details: Fully supports Kerberos---widely used with AD-integrated SQL Server instances.

Config: Requires AD setup and 'Trustworthy' delegation in SQL Server.

Option D (SAP HANA): Correct.

Details: Supports Kerberos SSO via delegation---popular in SAP ecosystems.

Config: Needs HANA Kerberos setup (e.g., keytab) and Tableau Server integration.

Option B (PostgreSQL): Incorrect.

Why: Supports Kerberos authentication natively, but Tableau Server doesn't enable delegation to PostgreSQL---users must embed credentials or use other methods (e.g., OAuth).

Why This Matters: Kerberos delegation enhances security by avoiding stored passwords---knowing supported sources ensures SSO feasibility.

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.

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.