Select Two (Multi-Select) Questions

Azure SQL Database

Why wrong: Not designed for streaming.

Apache Kafka on HDInsight

Why wrong: Less integrated with Azure ecosystem.

Azure Data Lake Storage Gen2

Why wrong: Storage layer, not processing.

Process all data synchronously to ensure consistency

Why wrong: Synchronous processing increases latency.

Use a single large cluster for all workloads to simplify management

Why wrong: May cause resource contention and doesn't meet SLAs.

Use a single node for orchestration to reduce complexity

Why wrong: Single node can become a bottleneck.

Integration with Power BI for real-time dashboards

Why wrong: Both integrate with Power BI.

Maximum allowed latency for late-arriving data

Why wrong: Both handle late data with windowing.

Assign RBAC roles for data access

Why wrong: RBAC controls authorization, not encryption.

Configure storage firewall rules

Why wrong: Firewall restricts access, but does not encrypt data at rest.

Enable TLS 1.2 for all connections

Why wrong: TLS secures data in transit, not at rest.

A VIEW that selects only the allowed columns

Why wrong: A VIEW is an alternative method but not required for column-level security.

A DENY statement on specific columns to users or roles

Why wrong: DENY is not required; absence of GRANT is enough to block access.

A row-level security policy must be in place

Why wrong: RLS is for rows, not columns.

The table contains many NULL values in indexed columns.

Why wrong: Both index types handle NULL values.

The table will be partitioned frequently.

Why wrong: Partitioning is independent of index type.

Azure Policy to enforce tagging

Why wrong: Azure Policy is for governance and compliance, not a security layer.

Dynamic data masking for all databases

Why wrong: Dynamic data masking is a feature, not a defense-in-depth layer; it's part of access control.

Enable result-set caching.

Why wrong: Result-set caching does not address memory usage of running queries.

Scale up the DWU setting.

Why wrong: Scaling up increases overall resources but does not target specific query memory issues.

Rebuild clustered columnstore indexes.

Why wrong: Index rebuild does not directly affect query memory grants.

Configure Azure Active Directory authentication

Why wrong: Azure AD authentication controls who can connect, not what they can access.

Enable dynamic data masking on all columns

Why wrong: Dynamic data masking does not prevent access; it only masks data for non-privileged users.

Enable transparent data encryption

Why wrong: TDE encrypts data at rest but does not control user access.

Move data to the cool tier to reduce storage costs.

Why wrong: Cool tier increases read costs and may not be cost-effective for analytics workloads.

Enable soft delete to protect against accidental deletion.

Why wrong: Soft delete does not improve performance or reduce costs.

Move frequently accessed data to Azure SQL Database.

Why wrong: Azure SQL Database is for transactional workloads, not for large-scale analytical queries.

Enable soft delete on the storage account to optimize read performance.

Why wrong: Soft delete is a data protection feature, not a performance optimization.

Migrate the data to Azure NetApp Files for lower latency.

Why wrong: NetApp Files is a file share service, not optimized for analytical queries on data lakes.

Parquet is easier to implement for schema evolution than Delta Lake.

Why wrong: Delta Lake supports schema evolution more easily than Parquet.

Delta Lake reduces storage costs by automatically compressing data.

Why wrong: Delta Lake does not automatically compress data; storage costs depend on the underlying file format.

Parquet files are not natively supported by Azure Databricks.

Why wrong: Azure Databricks natively supports reading and writing Parquet files.

Configure the reference input with a static blob path

Why wrong: Static path does not trigger auto-refresh; you need a pattern to detect new blobs.

Use Azure Event Grid to trigger job restart on blob update

Why wrong: Restarting the job is not required; auto-refresh avoids restart.

Store the reference data in Azure SQL Database instead of Blob Storage

Why wrong: While SQL Database is an option, the question specifies Blob Storage; auto-refresh works with Blob Storage.

Ensure data is evenly distributed across distributions.

Why wrong: Data distribution is a design aspect, not a monitoring strategy.

Configure automatic index rebuild for columnstore indexes.

Why wrong: Index maintenance is an optimization action, not a monitoring strategy factor.

Enable advanced data compression on all tables.

Why wrong: Compression saves storage, not compute.

Scale down the pool during business hours.

Why wrong: Scaling down during usage harms performance.

Change the distribution of large tables to ROUND_ROBIN.

Why wrong: Distribution affects query performance, not cost.

Increase the batch interval to reduce load.

Why wrong: May reduce throughput, not reliability.

Increase the cluster size to handle spikes.

Why wrong: Does not address checkpoint corruption.

Create a stored procedure that checks the user's role and returns the appropriate columns.

Why wrong: Stored procedures cannot be used as predicate functions; they must be inline table-valued functions.

Grant the 'Manager' role SELECT permission on the security policy.

Why wrong: Permissions on the security policy are not needed; the policy automatically applies based on the predicate function.

Use GRANT SELECT ON OBJECT::[dbo].[Employee](Salary) TO [Manager] to grant access to the salary column.

Why wrong: Column-level permissions are not supported in dedicated SQL pools; use column-level security via a security policy.

Use storage account access keys (Shared Key) for authentication.

Why wrong: Shared Key does not provide per-user auditing and is less secure.

Generate shared access signatures (SAS) with a long expiry time.

Why wrong: Long-lived SAS tokens increase security risk.

Configure a firewall to allow access from all Azure services.

Why wrong: Allowing all Azure services may grant unintended access.

Use a single-node cluster to reduce cost

Why wrong: Single-node cluster cannot handle large data volumes efficiently.

Disable autoscaling to avoid cost variability

Why wrong: Autoscaling helps minimize cost by scaling down during idle periods.

Use default Spark shuffle partitions (200)

Why wrong: Default may not be optimal; tuning shuffle partitions is recommended.

Enable soft delete for blobs.

Why wrong: Soft delete increases cost by retaining deleted data.

Enable geo-redundant storage (GRS) for the storage account.

Why wrong: Geo-redundancy increases cost due to replication.

Enable encryption at rest using customer-managed keys.

Why wrong: Encryption does not reduce storage cost.