4 Methods to Integrate GCP MySQL to Snowflake

Businesses today rely on GCP MySQL for its fully managed relational database capabilities, offering high availability, automated backups, and seamless scaling. However, as analytics requirements grow, including concurrent workloads, petabyte-scale storage, and independent compute scaling, teams often migrate to Snowflake.

Snowflake’s architecture allows independent scaling of storage and compute, enabling high-performance queries without the performance bottlenecks of traditional MySQL.

According to Snowflake, organizations use the platform to separate storage and compute workloads independently, allowing analytics workloads to scale without impacting operational databases.

The challenge is not whether to move the data. The challenge is choosing the right migration method.

Some teams want a fully managed no-code pipeline. Others prefer native replication tooling or cloud storage-based ingestion workflows. Smaller teams may only need occasional exports using CSV files.

This post covers 4 methods to integrate GCP MySQL to Snowflake, from Snowflake’s native connector to automated no-code pipelines, CSV exports, and a GCS-based staging approach, so you can choose the method that fits your team’s technical depth and data volume.

Why Migrate from GCP MySQL to Snowflake?

There are multiple perks of integration between GCP MySQL and Snowflakes, so let’s look at some of them: 

• Unlike standard MySQL deployments, Snowflake’s architecture allows for simple scaling, handling variable workloads effortlessly without the need for manual intervention. 

• Snowflake’s division of computing and storage resources guarantees superior performance, facilitating quicker data processing and query execution while retaining high-performance analytical capabilities.
• Snowflake offers a fully managed pay-as-you-go SaaS cloud data warehouse.

4 Methods to Integrate GCP MySQL to Snowflake

Choosing the right migration method is a balance between speed, cost, maintenance, and real-time requirements. Below is an expanded comparison of all four methods, followed by detailed walkthroughs.

Feature / Method	Method 1: Snowflake Connector for MySQL	Method 2: Hevo Data (No-Code ELT)	Method 3: CSV Files (Manual)	Method 4: GCS + COPY INTO (Manual Pipeline)
Real-Time Data	✅ Yes	✅ Yes	❌ No	❌ No
Coding Required	Yes (Docker/configuration)	No (UI-based)	Yes (SQL + CLI)	Yes (gcloud + SQL)
Maintenance	Medium to High	Very Low	High (Manual scripting)	High (Pipeline scripting)
Schema Management	Auto-mapping & Evolution	Manual	Manual	Manual (COPY INTO)
Best For	Teams already using Snowflake’s ecosystem and comfortable with coding.	Teams needing real-time analytics with minimal engineering overhead.	One-time, very small data dumps.	Teams wanting to leverage existing GCS infrastructure.
Estimated Setup Time	2-5 hours	10-15 minutes	3-8 hours	4-6 hours
Community Sentiment	“Works, but we had to build our own retry logic.” – StackOverflow	“A lifesaver for real-time CDC.” – r/dataengineering	“Error-prone and slow for anything over 1GB.” – Reddit	“Standard pattern, but COPY INTO can be finicky with semi-structured data.”

Method 1: Snowflake Connector for MySQL (Native, No Extra Cost)

Snowflake released its native connector for MySQL in 2024, available directly from the Snowflake Marketplace. It uses a Docker-based agent that runs alongside your MySQL instance and syncs data into Snowflake using CDC (change data capture). There are no licensing costs for the connector itself. You only pay for Snowflake compute and storage usage.

Note: Snowflake has since released the Openflow Connector for MySQL as a next-generation replacement. If you’re starting fresh, check the Snowflake docs for the latest recommended approach. The steps below cover the current connector.

Prerequisites

•        ACCOUNTADMIN role in Snowflake

•        Docker installed on the host running the agent

•        MySQL binary logging enabled (binlog_format = ROW)

•        Network access: port 3306 open between the agent host and your GCP MySQL instance

Step 1. Set Up an Event Table

Snowflake requires an event table to store connector logs. Run this in Snowsight or SnowSQL:

CREATE EVENT TABLE IF NOT EXISTS mydb.public.connector_events   CHANGE_TRACKING = TRUE;   ALTER ACCOUNT SET EVENT_TABLE = mydb.public.connector_events;

Step 2: Install the Connector from Snowflake Marketplace

1.     Sign in to Snowsight as ACCOUNTADMIN.

2.     Go to Data Products → Marketplace.

3.     Search for “Snowflake Connector for MySQL” and select the tile.

4.     Click Get. When the success dialog appears, click Configure.

Snowflake’s native apps, including this connector, are distributed through the GCP Marketplace and Snowflake Marketplace ecosystems. 

Step 3: Configure the Agent

Download the agent container from Docker Hub and create a config file pointing to your GCP MySQL instance:

{   “gcp_mysql_source”: { “url”: “jdbc:mysql://<YOUR_CLOUD_SQL_IP>:3306/<database>”, “username”: “<db_user>”, “password”: “<db_password>”   } }

Run the agent container:

docker run –rm \   -v /path/to/config.json:/config/config.json \   snowflakedb/snowflake-mysql-connector-agent:latest

Step 4: Configure Replication

Back in Snowsight, select your destination database and add tables for replication. Exact stored procedure names may vary slightly depending on whether your account uses the legacy Snowflake Connector for MySQL or the newer Openflow Connector framework.

— Grant connector permission on destination DB GRANT CREATE SCHEMA ON DATABASE my_destination_db   TO APPLICATION snowflake_connector_for_mysql;   — Add source tables CALL snowflake_connector_for_mysql.PUBLIC.ADD_DATA_SOURCE(   ‘gcp_mysql_source’, ‘my_destination_db’ );   CALL snowflake_connector_for_mysql.PUBLIC.ADD_TABLE(   ‘gcp_mysql_source’, ‘my_schema’, ‘my_table’ );

When to choose this: You’re already all-in on Snowflake and want a native solution without paying for a third-party tool. Good for teams comfortable with Docker and a one-time setup effort.

Method 2: Hevo Data (No-Code, Real-Time ELT)

Hevo is a no-code ELT platform that automates the entire pipeline and handles everything from Change Data Capture (CDC) to schema evolution. For GCP MySQL to Snowflake, it’s the fastest path from zero to production-grade pipeline.

A verified user noted, “I use Hevo Data for ingesting data from various tools to Snowflake, it makes my work so easier by being an easy way to connect to a data source without too much engineering effort.”  – G2 review.

What Hevo manages automatically:

•        Schema detection and mapping, no manual DDL

•        Incremental loads via binlog-based CDC

•        Auto-healing on source failures with intelligent retries

•        Pipeline visibility via unified dashboards and event logs

•        Automatic schema drift handling when source columns change

Teams evaluating broader replication tooling often compare best mysql ETL tools before standardizing on a production pipeline architecture. 

Prerequisites: 

A Hevo account (14-day free trial available), GCP MySQL credentials, Snowflake account.

Step 1: Configure GCP MySQL as Your Source

In Hevo, go to Pipelines → Create Pipeline → Source.

1.     Select GCP MySQL from the source catalog.

2.     Enter connection details: host (your Cloud SQL IP), port (3306), database name, username, password.

3.     Enable binary logging on your Cloud SQL instance if not already set (required for CDC).

4.     Allowlist Hevo’s IPs in your Cloud SQL network settings.

5.     Test the connection and select the tables to replicate.

Full config reference: Hevo GCP MySQL Source Documentation

Step 2: Configure Snowflake as Your Destination

6.     Select Snowflake as the destination.

7.     Provide: account name, database, schema, warehouse, username, and password.

8.     Hevo creates the destination tables automatically – no need to pre-define schemas.

9.     Set sync frequency (real-time CDC or scheduled batch, depending on your plan).

Full config reference: Hevo Snowflake Destination Documentation

Key Hevo Features Relevant to This Pipeline

• Auto Schema Mapping: Hevo detects schema changes at the source and propagates them to Snowflake automatically. No broken pipelines when a column is added.
• Incremental Data Load: Only new and changed records are synced after the initial historical load.
• Data Transformations: Apply Python-based or drag-and-drop transformations mid-pipeline to clean or reshape data before it lands in Snowflake.
• Fault-Tolerant Architecture: Auto-healing pipelines and intelligent retries ensure data arrives even when sources have intermittent failures.

When to choose this

You need a production-grade, low-maintenance pipeline. No infrastructure to manage, no pipeline scripts to maintain, Ideal for data teams that want to move fast and trust their data.

Method 3: Migrating GCP MySQL to Snowflake using CSV files

The manual CSV method works for one-time or low-volume migrations. It requires no tools beyond Cloud SQL’s export feature and Snowflake’s staging commands. Don’t use this for recurring pipelines, it doesn’t scale.

Step 3.1: Export Data from GCP MySQL to CSV

Prerequisites:

To initiate the export from Cloud SQL into Cloud Storage, you must have one of the following roles: 

• The Cloud SQL Editor role.
• A custom role, which includes the following permissions.

cloudsql.instances.get
cloudsql.instances.export

Furthermore, one of the following roles has to be present in the service account for the Cloud SQL instance:

• The storage.objectionAdmin Identify and Access Management (IAM) role
• A custom role, which includes the following permissions:

storage.objects.create
storage.objects.list
storage.objects.delete

For assistance with IAM roles, visit Identity and Access Management.

Once the prerequisites are met, follow the steps below:

• Navigate to the Cloud SQL instances page in the Google Cloud console.
• Click the instance name to bring up the instance’s Overview page.
• Click on Export.
• To allow other tasks to take place while the export is in progress, select Offload export.
• Click on Show Advanced Options.
• Select the database from the drop-down menu located in the Database section.
• To specify the table from which to export data, execute an SQL query.
• To start the export, click on Export.
• When the Export database? box opens, a message stating that the “export procedure for a big database may take up to an hour” will appear. You can only examine the instance’s contents while the export is in progress. You also have the option to stop the export after it has begun. Click Export if you think it is an appropriate moment to begin an export. If not, select Cancel.  

Step 3.2: Export Data from CSV file to Snowflake 

The process of loading CSV files into your Snowflake database is explained in the section below.

Step 3.2.1: Generate an Object in the File Format for CSV Data

To create the mycsvformat file format, use the CREATE FILE FORMAT command.

CREATE OR REPLACE FILE FORMAT mycsvformat
  TYPE = 'CSV'
  FIELD_DELIMITER = '|'
  SKIP_HEADER = 1;

Step 3.2.2: Set up a Stage for CSV Files

The my_CSV_stage can be created by executing CREATE STAGE function:

CREATE OR REPLACE STAGE my_csv_stage
  FILE_FORMAT = mycsvformat;

Step 3.2.3: Set up the CSV Sample Data Files

To upload the CSV files from your local file system, run the PUT command.

Linux or macOS

PUT file:///tmp/load/contacts*.csv @my_csv_stage AUTO_COMPRESS=TRUE;

Windows

PUT file://C:\temp\load\contacts*.csv @my_csv_stage AUTO_COMPRESS=TRUE;

Step 3.2.4: Copy Data to the Intended Tables

To load your staged data into the target tables, execute COPY INTO <table>.

COPY INTO mycsvtable
  FROM @my_csv_stage/contacts1.csv.gz
  FILE_FORMAT = (FORMAT_NAME = mycsvformat)
  ON_ERROR = 'skip_file';

Once data has been moved to the target tables, you need to use the Remove command to delete the copied data files from the intimidating staging table.

Limitations of Migrating GCP MySQL to Snowflake Using CSV files

• No Real-time Data Access: Neither automated data refreshes nor real-time data access is supported by the manual CSV export/import method.
• Technical Knowledge: To ensure correct transfer, a thorough grasp of cloud platforms and SQL scripts is required.
• Manual errors: The quantity of code and actions needed to debug and rectify data might result in errors and additional time spent.

Method 4: Manual Data Pipeline via Google Cloud Storage (GCS)

This method uses GCS as an intermediary staging layer, a pattern common in GCP-native data stacks. It’s more automated than raw CSV export but still requires you to script the orchestration. It pairs well with Cloud Scheduler or GCP data pipeline tooling like Dataflow or Composer.

Prerequisites

• GCP project with Cloud SQL, GCS, and IAM access
• A GCS bucket to use as the staging destination
• Snowflake account with SYSADMIN or ACCOUNTADMIN role
• Snowflake GCS storage integration configured

Step 1: Export GCP MySQL Data to GCS

Use the Cloud SQL export API or gcloud CLI to export directly to GCS on a schedule:

gcloud sql export csv INSTANCE_NAME \   gs://your-bucket/exports/table_$(date +%Y%m%d).csv \   –database=your_database \   –query=”SELECT * FROM your_table WHERE updated_at > DATE_SUB(NOW(), INTERVAL 1 DAY)”

Set this up as a Cloud Scheduler job with a Cloud Functions or Cloud Run trigger for daily incremental exports.

Step 2: Create an External Stage in Snowflake Pointing to GCS

First, create a GCS integration in Snowflake:

CREATE STORAGE INTEGRATION gcs_int   TYPE = EXTERNAL_STAGE   STORAGE_PROVIDER = ‘GCS’   ENABLED = TRUE   STORAGE_ALLOWED_LOCATIONS = (‘gcs://your-bucket/exports/’);

Grant Snowflake’s service account access to the GCS bucket (retrieve the service account with DESC INTEGRATION gcs_int).

Step 3: Create the Stage and Load Data

CREATE OR REPLACE STAGE gcs_mysql_stage   URL = ‘gcs://your-bucket/exports/’   STORAGE_INTEGRATION = gcs_int   FILE_FORMAT = (TYPE = ‘CSV’ SKIP_HEADER = 1);   — Load into Snowflake COPY INTO your_schema.your_table   FROM @gcs_mysql_stage   PATTERN = ‘.*table_[0-9]{8}.csv’   ON_ERROR = ‘CONTINUE’;

Step 4: Automate with a Task (Optional)

CREATE OR REPLACE TASK load_from_gcs   WAREHOUSE = compute_wh   SCHEDULE = ‘USING CRON 0 6 * * * UTC’ AS   COPY INTO your_schema.your_table FROM @gcs_mysql_stage PATTERN = ‘.*table_[0-9]{8}.csv’ ON_ERROR = ‘CONTINUE’;   ALTER TASK load_from_gcs RESUME;

Limitations of the GCS Pipeline Method

• Engineering overhead: You own the orchestration, error handling, and monitoring. Every failure requires manual intervention unless you build alerting on top.
• Near-real-time at best: Depending on your Cloud Scheduler frequency, there’s always a lag. True CDC requires additional tooling.
• Schema changes break things: If a column is added to the MySQL table, your COPY INTO will fail silently or error until you update the stage definition.

When to choose this: Your team is already GCP-native, comfortable with gcloud and SQL, and wants to avoid third-party tools for a moderate-volume pipeline with batch latency acceptable.Teams needing lower latency should evaluate event-driven architectures. See GCP Kafka installation as an alternative for streaming use cases.

Use Cases of Integrating GCP MySQL to Snowflake

• Unified Analytics Dashboard: Move transactional data from GCP MySQL into Snowflake alongside data from other sources (ad platforms, CRMs, event tracking). Build a single source of truth for BI tools like Looker or Tableau.
• Historical Trend Analysis: MySQL is typically pruned or archived after a retention window. Snowflake’s columnar storage makes it cost-effective to retain and query years of historical data without affecting the operational DB.
• ML Feature Engineering: Data science teams use Snowflake as their feature store — syncing MySQL data via Hevo or GCS pipelines ensures they always have fresh, query-ready data without touching production.
• Compliance and Audit Logging: Replicate MySQL transactional records to Snowflake for immutable audit trails. Snowflake’s time-travel and data sharing features make compliance reporting straightforward.
• Multi-source Consolidation: Combine GCP MySQL with Segment MySQL data, event streams, and third-party SaaS data in Snowflake for cross-functional analytics.

Also, check out how to migrate data from MySQL to Snowflake to get a better understanding of how you can load data and work with Snowflake.

You can also Learn more about:

• MySQL to Snowflake
• Azure MySQL to Snowflake
• Simplifying GCP Setup
• PostgreSQL on Google Cloud SQL to Snowflake

Conclusion

Choosing between these four methods comes down to your team’s tolerance for setup complexity and your data freshness requirements.

The Snowflake Connector for MySQL is a strong native option if you’re committed to the Snowflake ecosystem and comfortable with Docker. The CSV method handles one-off migrations cleanly. The GCS pipeline gives GCP-native teams maximum control. But for teams that need reliable, real-time pipelines with minimal maintenance, Hevo is the pragmatic choice.

You can start a free trial of Hevo and have your GCP MySQL to Snowflake pipeline running in under 10 minutes — no code, no infrastructure, no surprises.

FAQs