Snowflake SnowPro Specialty - Native Apps Sample Questions:

1. You are developing a Snowflake Native Application that leverages Snowflake Event Tables to log application events. You notice that while the application is successfully writing events to the event table, consumers are reporting that they cannot query the event table. Assume that you have successfully implemented the logging mechanism in your code and data is being logged. Consider the following manifest section:

Which of the following steps is MOST critical to resolve this issue and ensure consumers can query the event table?

A) The correct approach is not listed, as consumers cannot directly query event tables associated with Snowflake Native Applications for security reasons.
B) Verify that the application role defined in the application manifest has been granted the 'SELECT privilege on the event table within the provider account.
C) Ensure that the consumer account has the 'MONITOR privilege on the application, as this is required to query event tables associated with native applications.
D) Confirm that the event table is explicitly listed in the 'shared_objects' section of the application manifest with the correct 'object_name', 'source_type' set to event_table', and 'privileges' including 'SELECT'.
E) Grant the 'APPLY MASKING POLICY privilege to the application role on the event table to enable consumers to see masked data, and the REFERENCE_USAGE privilege on the database and schema that contains the event table.

2. An application developer is creating a Snowflake Native App that uses a user-defined function (UDF) 'MY UDF' in 'APP SCHEMA' The UDF reads data from a table 'APP TABLE' which is also in "APP SCHEMA'. The application role is 'APP ROLE'. Which of the following 'GRANT' statements are necessary for the application to function correctly within the provider account , assuming the UDF is defined with 'VOLATILE' behavior and is using the caller's rights (i.e., 'EXECUTE AS CALLER)?

A)

B)

C)

D)

E)

3. A consumer installs a Snowflake Native App that performs data transformations. The consumer wants to monitor the resource consumption (e.g., credits used) of the application. Which of the following SQL queries can the consumer use to retrieve the warehouse- level credit usage information associated with the installed application 'my_app'?

A) SELECT start_time, end_time, warehouse_name, credits_used FROM snowflake.account_usage.warehouse_metering_history WHERE application_name = 'my_app';
B) SELECT start_time, end_time, warehouse_name, credits_used FROM snowflake.account_usage.database_storage_usage_history WHERE application_name = 'my_app';
C) SELECT start_time, end_time, warehouse_name, credits_used FROM snowflake.account_usage.resource_monitors WHERE application_name = 'my_app';
D) SELECT start_time, end_time, warehouse_name, credits_used FROM snowflake.account_usage.query_history WHERE application_name = 'my_app';
E) SELECT start_time, end_time, warehouse_name, credits_used FROM snowflake.account_usage.metering_history WHERE application_name = 'my_app';

4. A Snowflake Native Application, 'Geolnsights', uses an external API to enrich location data provided by consumers. This API requires an API key for authentication. How can you securely manage and access this API key within the Native Application's code, ensuring that it is not directly exposed in the application package or code repository?

A) Store the API key in an external key management system (e.g., AWS KMS, Azure Key Vault) and retrieve it within the UDF using a custom external function, ensuring the function has appropriate access permissions.
B) Use a Snowflake Secret to store the API key and retrieve it within the application's UDF using the 'SYSTEM$GET SECRET function.
C) Store the API key directly in a configuration file within the application package and encrypt the application package during deployment.
D) Pass the API key as a parameter to the UDF from the consumer's environment.
E) Hardcode the API key within the UDF itself after obfuscating it using a basic encoding algorithm (e.g., Base64).

5. You are designing a Snowflake Native Application that allows consumers to upload data files to a stage within their account, which your application then processes. To enhance security and data governance, you need to implement a callback function that validates the uploaded data before it is processed by your application. The callback function must verify the file format and size. Which of the following options correctly outlines the necessary steps and considerations for implementing this callback function?

A) Implement a stored procedure within the application package that receives the file path as input. Register this stored procedure as a callback using 'ALTER APPLICATION ... SET callback_procedure = ..:. The stored procedure performs the validation and raises an error if the file is invalid.
B) Set up an AWS Lambda function triggered by S3 events when files are uploaded to the consumer's stage. The Lambda function validates the file format and size and sends a message to a Snowflake queue, which your application then reads.
C) Create a UDF that resides within the consumer's account and is called using the 'CALL' command from the provider's application logic. The UDF validates the file properties and returns a boolean indicating success or failure.
D) Define an event table in the provider account and configure a Snowflake Notification to trigger when a new file is uploaded to the consumer's stage. The notification invokes a remote service that validates the file and updates the event table.
E) Create an external function pointing to an API Gateway endpoint that performs the validation. The application logic calls this external function, passing the file path. The external function then returns a boolean indicating success or failure.

Solutions: