finish cherrypicking

Author: HarshCasper

public/images/snowflake/native-app.png

@@ -11,7 +11,6 @@ State Management in LocalStack allows you to save and load the state of your Loc
 
 State Management in LocalStack encompasses the following features:
 
-- **Cloud Pods**: Cloud Pods are persistent state snapshots of your LocalStack instance that can easily be shared, stored, versioned, and restored.
 - **Export & Import State**: Export and import the state of your LocalStack instance on your local machine as a local file.
 - **Persistence**: Persist the state of your LocalStack instance on your local machine using a configuration variable.
 
@@ -75,30 +74,3 @@ $ localstack state import '<file-name>'
 {{< /command >}}
 
 The `<file-name>` argument is required and specifies the file path to import the state from. The file should be generated from a previous export.
-
-## Cloud Pods
-
-Cloud pods are persistent state snapshots of your LocalStack instance that can easily be stored, versioned, shared, and restored. Cloud Pods can be used for various purposes, such as:
-
--  Save and manage snapshots of active LocalStack instances.
--  Share state snapshots with your team to debug collectively.
--  Automate your testing pipelines by pre-seeding CI environments.
--  Create reproducible development and testing environments locally.
-
-You can save and load the persistent state of Cloud Pods, using the Cloud Pods CLI. LocalStack provides a remote storage backend that can be used to store the state of your running application and share it with your team members. Cloud Pods CLI is included in the [LocalStack CLI installation](https://docs.localstack.cloud/getting-started/installation/#localstack-cli), so there's no need for additional installations to begin using it.
-
-### Create a new Cloud Pod
-
-To create the Cloud Pod, you can run the following command:
-
-{{< command >}}
-$ localstack pod save '<pod-name>'
-{{< /command >}}
-
-### Load an existing Cloud Pod
-
-To load the Cloud Pod, you can run the following command:
-
-{{< command >}}
-$ localstack pod load '<pod-name>'
-{{< /command >}}

src/content/docs/snowflake/capabilities/ephemeral-instances.md

@@ -142,35 +142,6 @@ models:
     materialized: table
 ```
 
-### Connect to dbt Cloud
-
-To use dbt Cloud with the Snowflake emulator, you'll first need to configure an ephemeral instance. Ephemeral instances provide isolated environments for testing and development. For more information, see the [Ephemeral Instances documentation]({{< ref "user-guide/ephemeral-instances" >}}).
-
-1. First, create an ephemeral instance for Snowflake in the LocalStack Web application.
-
-2. Once your ephemeral instance is running, note the host URL (e.g., `sf-v09rkl9fcjs21.sandbox.localstack.cloud`).
-
-3. In the dbt Cloud interface:
-   - Navigate to **Deploy** > **Environments**
-   - Create a new environment or edit an existing one
-   - Under **Connection Settings**, select **Snowflake**
-   - Fill in the basic credentials:
-     * Username: `test`
-     * Password: `test`
-     * Schema: `public`
-
-4. In the **Extended attributes** section, specify the host from your ephemeral instance:
-
-```yaml
-host: sf-v09rkl9fcjs21.sandbox.localstack.cloud
-```
-
-<!-- ![dbt Cloud Configuration](dbt-cloud-config.png) -->
-
-{{< alert type="info" >}}
-The host value must match your ephemeral instance URL. This overrides the default Snowflake host and directs connections to your LocalStack environment.
-{{< /alert >}}
-
 ## Best Practices
 
 1. **Version Control**: Keep your dbt models and configurations in version control
@@ -180,4 +151,4 @@ The host value must match your ephemeral instance URL. This overrides the defaul
 
 {{< alert type="info" >}}
 It's a good practice to always test your dbt models locally with the Snowflake emulator before deploying to production, to save time and resources.
-{{< /alert >}} 
+{{< /alert >}} 

src/content/docs/snowflake/capabilities/state-management.md

@@ -0,0 +1,71 @@
+---
+title: Authentication
+description: Get started with authentication in Snowflake.
+---
+
+## Introduction
+
+Snowflake supports [multiple authentication methods](https://docs.snowflake.com/en/user-guide/authentication-policies). The Snowflake emulator supports the following authentication methods:
+
+* Username and password
+* RSA key pair authentication
+
+This guide demonstrates how to use the Snowflake emulator to authenticate using both methods.
+
+## Username and password
+
+To authenticate using a username and password, you can set the `user` and `password` parameters in the connection string. The values for these parameters can be set to `test` in the Snowflake emulator. Since the Snowflake emulator is a local instance, the username and password can be the same, and the authentication mechanism is mocked.
+
+Here's an example of how to connect to the Snowflake emulator using a username and password in a Python script:
+
+```python
+import snowflake.connector as sf
+
+sf_conn_obj = sf.connect(
+    user="test",
+    password="test",
+    account="test",
+    database="test",
+    host="snowflake.localhost.localstack.cloud",
+)
+```
+
+The default username and password are set to `test` and can be changed using `SF_DEFAULT_USER` and `SF_DEFAULT_PASSWORD` when starting the Snowflake emulator.
+
+{{< alert title="Note" >}}
+It is not recommended to use your production credentials in the Snowflake emulator.
+{{< /alert >}}
+
+## RSA key pair authentication
+
+The Snowflake emulator supports RSA key-based authentication, allowing users to log in without a password by using a private key and a configured public key.
+
+To enable this, create a private key and a public key pair.
+
+```bash
+openssl genrsa -out private_key.pem 2048
+openssl rsa -in private_key.pem -pubout -out public_key.pem
+```
+
+Then set a public key for the user:
+
+```sql
+ALTER USER your_user_name SET RSA_PUBLIC_KEY='<public_key>';
+```
+
+Then authenticate with the private key using the Snowflake client:
+
+```python
+import snowflake.connector
+
+conn = snowflake.connector.connect(
+    user='your_user_name',
+    account='your_account_identifier',
+    private_key_file='/path/to/private_key.pem',
+    # Add other parameters as needed
+)
+```
+
+{{< alert title="Note" >}}
+The Snowflake emulator does not validate key contents—RSA authentication is mocked for local testing only.
+{{< /alert >}}

src/content/docs/snowflake/integrations/dbt.md

@@ -0,0 +1,91 @@
+---
+title: "Materialized Views"
+description: Get started with Materialized Views in LocalStack for Snowflake
+---
+
+## Introduction
+
+Materialized views are a feature of Snowflake that allows you to create a persistent view of a table. This view is pre-computed and stored in the database, allowing for faster queries and improved performance.
+
+The Snowflake emulator supports Materialized Views, allowing you to accurately test materialized view logic and behavior in local development environments. The following operations are supported:
+
+- [`CREATE MATERIALIZED VIEW`](https://docs.snowflake.com/en/sql-reference/sql/create-materialized-view)
+- [`ALTER MATERIALIZED VIEW`](https://docs.snowflake.com/en/sql-reference/sql/alter-materialized-view)
+- [`DESCRIBE MATERIALIZED VIEW`](https://docs.snowflake.com/en/sql-reference/sql/desc-materialized-view)
+- [`DROP MATERIALIZED VIEW`](https://docs.snowflake.com/en/sql-reference/sql/drop-materialized-view)
+- [`SHOW MATERIALIZED VIEWS`](https://docs.snowflake.com/en/sql-reference/sql/show-materialized-views)
+- [`TRUNCATE MATERIALIZED VIEW`](https://docs.snowflake.com/en/sql-reference/sql/truncate-materialized-view)
+
+## Getting started
+
+This guide is designed for users new to Materialized Views and assumes basic knowledge of SQL and Snowflake. Start your Snowflake emulator and connect to it using an SQL client to execute the queries below.
+
+The following sections guide you through creating materialized views, inserting data into source tables, querying from views, and performing operations like rename, describe, and drop.
+
+### Create a materialized view
+
+To create a materialized view, use the `CREATE MATERIALIZED VIEW` statement. The following example creates a view `order_view` that selects specific columns from the `orders` table.
+
+```sql 
+CREATE TABLE IF NOT EXISTS orders (
+  id INT,
+  product TEXT,
+  shipped BOOLEAN
+);
+
+CREATE MATERIALIZED VIEW IF NOT EXISTS order_view AS
+SELECT id, product FROM orders;
+```
+
+### Insert data into source table
+
+Inserting new data into the base table automatically refreshes the materialized view in the background.
+
+```sql 
+INSERT INTO orders(id, product, shipped)
+VALUES (1, 'Book', FALSE), (2, 'Pen', TRUE);
+```
+
+### Query from materialized view
+
+You can query a materialized view just like a regular table. The view reflects the data from the source table as of its most recent refresh.
+
+```sql
+SELECT * FROM order_view;
+```
+
+The output should be:
+
+```sql 
+ID|PRODUCT|
+--+-------+
+ 1|Book   |
+ 2|Pen    |
+```
+
+### Describe the view
+
+Use `DESCRIBE MATERIALIZED VIEW` to inspect the schema of the view, including column names and types.
+
+```sql
+DESCRIBE MATERIALIZED VIEW order_view;
+```
+
+The output should be:
+
+```sql 
+name   |type|kind  |null?|default|primary key|unique key|check|expression|comment|policy name|privacy domain|
+-------+----+------+-----+-------+-----------+----------+-----+----------+-------+-----------+--------------+
+ID     |INT4|COLUMN|Y    |       |N          |N         |     |          |       |           |              |
+PRODUCT|TEXT|COLUMN|Y    |       |N          |N         |     |          |       |           |              |
+```
+
+### Rename and drop view
+
+You can rename and drop materialized views using standard SQL statements.
+
+```sql
+ALTER MATERIALIZED VIEW order_view RENAME TO order_view_new;
+
+DROP MATERIALIZED VIEW IF EXISTS order_view_new;
+```

src/content/docs/snowflake/services/authentication.md

@@ -0,0 +1,80 @@
+---
+title: "Native Apps"
+description: Get started with Native Apps in LocalStack for Snowflake
+---
+
+## Introduction
+
+Snowflake Native Apps are applications built and executed directly within the Snowflake Data Cloud platform. These apps can be used to extend the capabilities of Snowflake by integrating with external services, automating workflows, and building custom data applications. These apps are developed using Snowflake-native tools (e.g., Snowflake SQL, Snowflake API, and JavaScript) and can be distributed on the Snowflake Marketplace.
+
+The Snowflake emulator supports creating & deploying Native Apps locally with the same statements as the Snowflake service. The following operations are supported:
+
+- [`CREATE APPLICATIONS`](https://docs.snowflake.com/en/sql-reference/sql/create-application.html)
+- [`SHOW APPLICATION PACKAGES`](https://docs.snowflake.com/en/sql-reference/sql/show-application-packages.html)
+- [`ALTER APPLICATION PACKAGE`](https://docs.snowflake.com/en/sql-reference/sql/alter-application-package.html)
+- [`DESCRIBE APPLICATION`]( https://docs.snowflake.com/en/sql-reference/sql/desc-application)
+- [`DROP APPLICATION PACKAGE`](https://docs.snowflake.com/en/sql-reference/sql/drop-application-package.html)
+
+## Getting started
+
+This guide is designed for users new to Native Apps and assumes basic knowledge of Snow CLI and Snowflake. Start your Snowflake emulator and connect to it using the Snow CLI in order to execute the commands further below.
+
+In this guide, you will locally deploy a Native App using an existing Application Package.
+
+### Clone the repository
+
+Clone the [Native Apps repository](https://github.com/snowflakedb/native-apps-examples) and navigate to the `tasks-streams` directory:
+
+```bash
+git clone https://github.com/snowflakedb/native-apps-examples.git
+cd native-apps-examples/tasks-streams
+```
+
+### Deploy Native App
+
+Deploy the Native App using the Snow CLI:
+
+```bash
+snow app run --connection localstack
+```
+
+The following output should be displayed:
+
+```bash
+Creating new application package tasks_streams_app_pkg_username in account.
+Checking if stage tasks_streams_app_pkg_username.app_src.stage exists, or creating a new one if none exists.
+Performing a diff between the Snowflake stage: stage and your local deploy_root: /Users/username/code/localstack/native-apps-examples/tasks-streams/output/deploy.
+Local changes to be deployed:
+  added:    app/manifest.yml -> manifest.yml
+  added:    app/setup_script.sql -> setup_script.sql
+  added:    src/module-ui/src/environment.yml -> streamlit/environment.yml
+  added:    src/module-ui/src/ui.py -> streamlit/ui.py
+Updating the Snowflake stage from your local /Users/username/code/localstack/native-apps-examples/tasks-streams/output/deploy directory.
+Validating Snowflake Native App setup script.
+Creating new application object tasks_streams_app_username in account.
+Application 'TASKS_STREAMS_APP_username' created successfully.
+
+Your application object (tasks_streams_app_username) is now available:
+https://app.snowflake.com/test/test/#/apps/application/TASKS_STREAMS_APP_username
+```
+
+### Access Native App
+
+You can access the Native App by visiting your preferred browser and navigating to the following URL:
+
+```bash
+https://snowflake.localhost.localstack.cloud:4566/apps/test/test/TASKS_STREAMS_APP_username/
+```
+
+{{< alert title="Note" >}}
+The URL above is an example. Change the outputted URL by:
+
+1.  Replacing `https://app.snowflake.com` with `https://snowflake.localhost.localstack.cloud:4566`.
+2.  Changing the path structure from `/#/apps/application/` to `/apps/test/test/`.
+
+You can make additional changes depending on your local setup.
+{{< /alert >}}
+
+The following app should be displayed:
+
+![Native App](/images/snowflake/native-app.png)