Venkatesh Shanbhag

Partner Solution Architect

Partner

Zi Wang

Partner Engineer at Google Cloud

Maruti C

Global Partner Engineering Lead, Google

To empower enterprises that strive to transform their data into insights, BigQuery has emerged as a powerful, scalable, cloud-based data warehouse solution offered by Google Cloud Platform (GCP). Its cloud-based approach allows efficient data management and manipulation, making BigQuery a game-changer for businesses seeking advanced data insights. Notably, one of BigQuery’s standout features is its seamless integration with Spark-based data processing that enables users to further enhance their queries. Now, leveraging BigQuery APIs, users can create and execute Spark stored procedures, which are reusable code modules that can encapsulate complex business logic and data transformations. This feature helps data engineers, data scientists, and data analysts take advantage of BigQuery’s advanced capabilities and Spark’s robust data processing capabilities.

MongoDB, a developer data platform, is a popular choice for storing and managing operational data for its scalability, performance, flexible schema, and real-time capabilities (change streams and aggregation). By combining the capabilities of BigQuery with the versatility of Apache Spark and the flexibility of MongoDB, you can unlock a powerful data processing pipeline.

Apache Spark is a powerful open-source distributed computing framework that excels at processing large amounts of data quickly and efficiently. It supports a wide range of data formats, including structured, semi-structured, and unstructured data, making it an ideal choice for integrating data from various sources, such as MongoDB.

BigQuery Spark stored procedures are routines that are executed within the BigQuery environment. These procedures can perform various tasks, such as data manipulation, complex calculations, and even external data integration. They provide a way to modularize and reuse code, making it easier to maintain and optimize data processing workflows. Spark stored procedures use the [serverless Spark](https://cloud.google.com/solutions/spark) engine that enables serverless, autoscaling Spark. However, you don’t need to enable Dataproc APIs or be charged for Dataproc when you leverage this new capability. 

Let's explore how to extend BigQuery’s data processing to Apache Spark, and integrate MongoDB with BigQuery to effectively facilitate data movement between the two platforms.

## Connecting them together

![Data movement between MongoDB and BigQuery using Spark stored procedure running on serverless Spark][1]

This tutorial guides you through creating a PySpark procedure using the BigQuery editor.

Before we start with the Spark stored procedure setup, you need to [upload](https://cloud.google.com/storage/docs/uploading-objects#uploading-an-object) the [MongoDB Spark connector JAR](https://repo1.maven.org/maven2/org/mongodb/spark/) file to Google Cloud Storage to connect and read from MongoDB Atlas. Copy and save the gsutil URI for the JAR file that will be used in upcoming steps.

![Copy the path for gsutil URI][2]

1. As a prerequisite for completing the tutorial, you need to [set up](https://mongodb.prakticum-team.ru/docs/atlas/getting-started/) a MongoDB Atlas cluster with [sample data](https://mongodb.prakticum-team.ru/docs/guides/atlas/sample-data/) loaded to it. 
2. Navigate to the [BigQuery page](https://console.cloud.google.com/bigquery) on the Google Cloud console.
3. [Create](https://cloud.google.com/bigquery/docs/datasets#create-dataset) a **BigQuery dataset** with the name **spark_run**.
4. You will type the PySpark code directly into the query editor. To create a PySpark stored procedure, click on **Create Pyspark Procedure**, and then select **Create PySpark Procedure**.

![Creating PySPark procedure from BigQuery explorer][3]

5. To set options, click **More** > **PySpark Options**, and then do the following:

    1. Specify the location where you want to run the PySpark code.

    2. In the **Connection** field, click on **CREATE NEW CONNECTION** and enter the below values for each field.

        1. Connection Type > Apache Spark

        2. Connection id > Name it as **mongodb-to-bigquery** for the sake of this tutorial.
        3. Leave the other option empty and click on **Create**.

    3. In the Stored procedure invocation section select **Set a dataset for stored procedure invocation** to **spark_run.**
    4. Click on the advanced options. Copy the gsutil URI name copied at the beginning of the setup and paste in the **JAR files in the pre-requisite**. Leave the other options empty. Press enter and click on **Save**.

6. Open a new tab and go to BigQuery. Navigate to the **External connections** > Find the **mongodb-to-bigquery Connection** > Copy the **Service account id**. [Grant](https://cloud.google.com/iam/docs/grant-role-console#grant_an_iam_role) BigQuery Storage Admin, Secret Manager Secret Accessor, and Storage Object Admin access to this service account from IAM. 

![External connections created using Spark stored procedures][4]

7. (Optional) [Add your username and password](https://cloud.google.com/secret-manager/docs/creating-and-accessing-secrets#create) into Google Cloud Secret Manager, or you can hardcode it in the MongoDB URI string itself. 
8. Copy the below Python script in the PySpark procedure editor and click on **RUN**. The snippet takes around two to three minutes to complete. The below script will create a new table under dataset **spark_run** with the name **sample_mflix_comments**.

```python
from pyspark.sql import SparkSession
from google.cloud import secretmanager

def access_secret_version(secret_id, project_id):
    client = secretmanager.SecretManagerServiceClient()
    name = f"projects/{project_id}/secrets/{secret_id}/versions/1"
    response = client.access_secret_version(request={"name": name})
    payload = response.payload.data.decode("UTF-8")
    return payload
# Update project_number, username_secret_id and password_secret_id, comment them out if you did not create the secrets earlier 

project_id = "<Your project number, 12 digit number>"
username_secret_id = "<Your username secret id>"
password_secret_id = "<Your password secret id>"

username = access_secret_version(username_secret_id, project_id)
password = access_secret_version(password_secret_id, project_id)

  # Update the mongodb_uri directly if with your username and password if you did not create a secret from Step 7, update the hostname with your hostname
mongodb_uri = "mongodb+srv://"+username+":"+password+"@<hostname>/sample_mflix.comments"

my_spark = SparkSession \
  .builder \
  .appName("myApp") \
  .config("spark.mongodb.read.connection.uri", mongodb_uri) \
  .config("spark.mongodb.write.connection.uri", mongodb_uri) \
  .getOrCreate()


dataFrame = my_spark.read.format("mongodb").option("database", "sample_mflix").option("collection", "comments").load()

dataFrame.show()

# Saving the data to BigQuery
dataFrame.write.format("bigquery") \
  .option("writeMethod", "direct") \
    .save("spark_run.sample_mflix_comments")
```

![Stored procedure on Google BigQuery Explorer][5]

9. Navigate to the spark_run dataset to validate the data is loaded from MongoDB Atlas to BigQuery under the table with the name **sample_mflix_comments**.
10. Now that the data is in BigQuery, leverage BQML to run some Generative AI on the new MongoDB data in BigQuery. 
    1. Create a connection with the name **gentext-conn,** using either the [console](https://cloud.google.com/bigquery/docs/create-cloud-resource-connection#create-cloud-resource-connection) or bq command line with connection type as CLOUD_RESOURCE.

```
!bq mk \
  --connection \
  --location=US \
  --project_id=<GCP Project id> \
  --connection_type=CLOUD_RESOURCE gentext-conn 
```

11. To grant IAM permissions to access Vertex AI from BigQuery, navigate to **External connections** > Find the **gettext-conn** connection > Copy the **Service account id**. Grant the **Vertex AI User** access to this service account from **IAM**.
12. Create a model using the CREATE MODEL command.

```
CREATE OR REPLACE MODEL `gcp-pov.spark_run.llm_model`
REMOTE WITH CONNECTION `us.gentext-conn`
OPTIONS (ENDPOINT = 'gemini-pro');
```

13. Run the SQL command against the BigQuery table. This query allows the user to extract the host name from the email leveraging the Gemini Pro model. The resulting [output](https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-generate-text#output) includes the response and safety attributes.

```
SELECT prompt,ml_generate_text_result
FROM
ML.GENERATE_TEXT( MODEL `gcp-pov.spark_run.llm_model`,
  (
    SELECT CONCAT('Extract the host name from the email: ', email) AS prompt,
      *  FROM  `gcp-pov.spark_run.sample_mflix_comments`
    LIMIT 5),
  STRUCT(
    0.9 AS temperature,
    100 AS max_output_tokens
    )
  );
```

14. Here is the [sample output](https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-generate-text#output) showing the prompt as well as the response. The prompt parameter provides the text for the model to analyze. Prompt design can strongly affect the responses returned by the LLM.

![Output after running the Spark stored procedure][6]

## Benefits of the integration

1. This integration enables you to use MongoDB for OLTP and BigQuery for OLAP, providing a complete data management solution.
2. Once the data is transformed and copied to BigQuery, BigQuery ML lets you [create and run machine learning (ML) models](https://cloud.google.com/bigquery/docs/e2e-journey) by using GoogleSQL queries. 
3. BigQuery ML also lets you [access LLMs and Cloud AI APIs](https://cloud.google.com/bigquery/docs/ai-application-overview) to perform artificial intelligence (AI) tasks like text generation and machine translation. 

## Conclusion

By combining the power of BigQuery, Spark stored procedures, and MongoDB, you can create a robust and scalable data processing pipeline that leverages the strengths of each technology. BigQuery provides a reliable and scalable data warehouse for storing and analyzing structured data, while Spark allows you to process and transform data from various sources, including semi-structured and unstructured data from MongoDB. Spark stored procedures enable you to encapsulate and reuse this logic, making it easier to maintain and optimize your data processing workflows.

### Further reading

1. [Get started](https://mongodb.prakticum-team.ru/docs/atlas/getting-started/) with MongoDB Atlas on Google Cloud.
2. Work with [stored procedures](https://cloud.google.com/bigquery/docs/spark-procedures) for Apache Spark.
3. [Create](https://cloud.google.com/bigquery/docs/create-machine-learning-model) machine learning models in BigQuery ML.


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3cc99ff9b6ad9cec/66155da90c478454e8a349f1/1.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltdd635dea2d750e73/66155dc254d7c1521e8eea3a/2.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta48182269e87f9e7/66155dd2cbc2fbae6d8175ea/3.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltb399b53e83efffb9/66155de5be36f52825d96ea5/4.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6efef490b3d34cf0/66155dfd2b98e91579101401/5.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt56b91d83e11dea5f/66155e0f7cacdc153bd4a78b/6.png

Explore how to extend BigQuery’s data processing to Apache Spark, and integrate MongoDB with BigQuery to facilitate data movement between the two.

Zi Wang

Content by Zi Wang

Spark Up Your MongoDB and BigQuery Using BigQuery Spark Stored Procedures