What you will be able to do
- Create the secret, API integration and Git repository object that connect Snowflake to a remote ML code repository
- Address branches, tags and commits in a repository clone and deploy from them with EXECUTE IMMEDIATE FROM
- Authenticate a CI runner as a Snowflake service user and predict which connection setting wins
- Promote ML assets through environments with Snowflake-native DCM projects and pinned Git references
- Script validate, deploy and verify stages with snow, using project-definition variables and DCM targets
- Order the objects and privileges a pipeline deployment depends on
Key concept
Git repository clone — A Snowflake object that holds a copy of a remote Git repository's branches, tags and commits. Snowflake reads files from it the way it reads a stage, and its content changes only when someone fetches from the remote.
1.What a Git repository object is in Snowflake
ML code usually already lives in Git: feature-pipeline SQL, training scripts, stored procedure handlers. A Git repository object lets Snowflake deploy that code from the repository itself, so you don't copy files onto a stage by hand. Snowflake connects to GitHub, GitLab, BitBucket, Azure DevOps and AWS CodeCommit, and also to repositories based on those platforms that are hosted at custom URLs. It keeps a clone that includes every branch, tag and commit of the remote.
The clone is another client of the remote. It is not a live mirror of it. Your laptop's clone and Snowflake's clone each talk to the remote on their own, and you keep using your usual tools as before. The clone changes when a fetch runs: ALTER GIT REPOSITORY ... FETCH, or the Fetch button in Snowsight. A fetch brings in the latest branches, tags and commits and prunes the ones that no longer exist on the remote.
ALTER GIT REPOSITORY snowflake_extensions FETCH;In that case yesterday's version runs, because the clone only knows what the last fetch brought in. That is why a CI deploy job fetches first. Changes flow back to the remote only from the authoring surfaces: Workspaces, Streamlit apps and Snowflake notebooks can commit and push. A deployment pipeline only reads from the clone. Also keep in mind that the clone holds files, not database objects. No table, procedure or model exists because its SQL is in the repository. Each one exists only after that file has been executed.
Checkpoint 1 of 11· Fill the gap
A CI deploy job has to make sure the Snowflake clone has the latest commits from the remote before it runs EXECUTE IMMEDIATE FROM. Which keyword completes this statement?
ALTER GIT REPOSITORY snowflake_extensions ? ;The Snowflake clone is a separate client of the remote, not a live mirror. It changes only when ALTER GIT REPOSITORY ... FETCH runs, which brings in the latest branches, tags and commits and prunes the ones gone from the remote. PULL and SYNC are familiar Git and tool terms, but they aren't the Snowflake keyword.
Source: docs.snowflake.comCheckpoint 2 of 11· Exam question
What does Snowflake create when you run CREATE GIT REPOSITORY against a remote origin, and how does its content stay current?
Correct answer: A — A read-only snapshot of the remote's branches, tags, and commits inside Snowflake that changes only when a fetch is run
- A. Correct. The Git repository object holds a read-only clone of the remote; its content is refreshed only by an explicit
ALTER GIT REPOSITORY ... FETCH(orsnow git fetch), never automatically. - B. Incorrect. Snowflake does not poll the remote, and the repository clone is read-only; commits are pushed only from tools such as Workspaces with write credentials.
- C. Incorrect. The object is not a webhook-fed stage; Snowflake pulls content only on an explicit fetch and exposes it under branch, tag, and commit paths.
- D. Incorrect. The object stores repository files, not database objects; SQL files must be executed (for example with
EXECUTE IMMEDIATE FROM) to create anything.
2.Connecting a private repository: secret, API integration, repository
Setting up the connection involves two decisions: which authentication method to use and which network path to take. Choose authentication by who will use the clone. Interactive Workspaces users are best served by OAuth. Automated pipelines and ML projects should use token-based authentication, because a scheduled job can't complete a sign-in prompt. Public repositories need no authentication at all.
| Method | Best for | Objects to create |
|---|---|---|
| No authentication | Public repositories, quick starts | API integration (no credentials) |
| Token (for example a personal access token) | Automated pipelines and ML projects | Secret holding username and token, then an API integration allowed to use it |
| OAuth flow | Interactive development in Workspaces | API integration configured for OAuth2; no secret |
With token authentication, the objects form a chain. The secret stores the Git username, with the personal access token as its PASSWORD value. The API integration must have API_PROVIDER = git_https_api. Its API_ALLOWED_PREFIXES lists the repository URLs it may reach, and its ALLOWED_AUTHENTICATION_SECRETS lists the secrets it may use. The Git repository object names that integration in API_INTEGRATION and the secret in GIT_CREDENTIALS. If the secret isn't on the integration's allowed list, the repository can't use it. You can leave out GIT_CREDENTIALS when the integration supplies a default secret or the remote needs no authentication.
Other objects are not part of this setup. A network rule with an external access integration, a storage integration with an external stage, or a notification integration relaying webhooks all solve different problems. A Git clone needs only an integration whose provider is git_https_api. If the organisation requires full network isolation, Git traffic can go over a private link instead of the public internet. You set up that private link before you configure access to the repository.
Checkpoint 3 of 11· Check yourself
A platform team creates a Git repository object with token authentication: a secret, an API integration with API_PROVIDER = git_https_api, and the repository. All three objects are created without errors. The nightly ML deploy job runs as role DEPLOY_ROLE, and its ALTER GIT REPOSITORY ... FETCH fails with an insufficient-privileges error. Neither DEPLOY_ROLE nor the repository's owning role has any grant on the API integration. What fixes the job?
Git operations need USAGE on the API integration from either the current role or the repository's owning role. Without that grant, fetches and executes fail even when the repository object looks correct. Network rules and external access integrations solve a different problem, OAuth is meant for interactive Workspaces users rather than scheduled jobs, and the secret is not what causes a privilege error.
“insufficient-privileges error if neither the current role nor the role that owns the Git repository has USAGE on the API integration”Source: docs.snowflake.com
Checkpoint 4 of 11· Exam question
A team keeps ML pipeline code in a private GitHub repository and authenticates with a personal access token. Which set of Snowflake objects lets them create a Git repository object for it?
Correct answer: B — A password-type secret holding the username and token, plus a git_https_api API integration allowing that prefix and secret
- A. Incorrect. External access integrations are for outbound calls from UDFs and procedures; a Git repository object is bound to an API integration instead.
- B. Correct. The repository object needs an API integration with
API_PROVIDER = git_https_api,API_ALLOWED_PREFIXES, andALLOWED_AUTHENTICATION_SECRETS, andGIT_CREDENTIALSpointing at the secret. - C. Incorrect. Storage integrations and external stages target cloud object storage, not Git hosting, and cannot back a Git repository object.
- D. Incorrect. OAuth security integrations authenticate clients to Snowflake, and notification integrations deliver messages; neither supplies Git credentials to the repository object.
3.Addressing branches, tags and commits, and deploying with EXECUTE IMMEDIATE FROM
You address a clone with stage syntax, followed by a reference type and a name. SHOW GIT BRANCHES and SHOW GIT TAGS list what the last fetch brought in. The branch output includes a path such as /branches/main and the commit_hash that the branch currently points to. LS (short for LIST) shows the files under any reference.
| Reference | Path form | Moves when the remote changes? |
|---|---|---|
| Branch | @repository_name/branches/branch_name/... | Yes, on the next fetch after a new commit |
| Tag | @repository_name/tags/tag_name/... | Names one release; a release tag belongs here |
| Commit | @repository_name/commits/commit_hash/... | No; a hash identifies exactly one commit |
Each kind of reference goes under its own prefix. A tag name under /commits/ or /branches/ doesn't resolve, and there is no /releases/ prefix. A release tag v2.1.0 lives at @ml_repo/tags/v2.1.0/.
EXECUTE IMMEDIATE FROM @snowflake_extensions/branches/main/sql/create-database.sql;The reference you choose for production decides what production runs. A deploy that points at /branches/main runs whatever main contained at the last fetch, so a merge you haven't reviewed can reach production on the next run. If you point dev, test and prod at the same /tags/ or /commits/ path, all three run identical, reviewed code, and a later merge doesn't change production. Snowsight's Execute immediate option runs the same file, but you won't see the output the code produces. A pipeline that needs to read results should run the file through SQL.
Checkpoint 5 of 11· Check yourself
Your team wants production to run exactly the reviewed release tagged v2.1.0 of train_model.sql, so that later merges to main can't change what production executes. The Git repository clone is named ml_repo. Which EXECUTE IMMEDIATE FROM path does that?
Every reference type has its own path prefix, and tags are found under /tags/. A tag name placed under /commits/ won't resolve, and Snowflake has no /releases/ prefix. A /branches/main path runs whatever main contained at the last fetch, so a later merge could reach production.
“LS @repository_name/tags/tag_name;”Source: docs.snowflake.com
Checkpoint 6 of 11· Exam question
Which path correctly runs a training-setup script from a release tag named v2.1.0 in the Git repository object ml_repo?
Correct answer: A — EXECUTE IMMEDIATE FROM @ml_repo/tags/v2.1.0/deploy/setup.sql
- A. Correct. Repository content is addressed as
@repo/tags/<tag>/,@repo/branches/<branch>/, or@repo/commits/<sha>/. - B. Incorrect. The commits segment expects a commit SHA, not a tag name.
- C. Incorrect. There is no releases segment in Git repository paths; only branches, tags, and commits exist.
- D. Incorrect. The branches path resolves branch names; a tag name placed there is not found unless a branch has that name.
Sources2
4.Authenticating a CI runner with Snowflake CLI
Snowflake CLI (snow) is the client to script deployments with. SnowSQL is the legacy client, and it gets no new features. Snowflake maintains CI integrations that install the CLI on the runner and configure authentication. For any other system that can run a shell command, such as Jenkins, Bitbucket Pipelines or CircleCI, one install line is enough.
uv tool install snowflake-cli
snow --version| Integration | Status | Recommended authentication |
|---|---|---|
| GitHub Action | Generally available | Workload identity federation (OIDC) |
| GitLab CI/CD Component | Public preview | Workload identity federation (OIDC) |
| Azure DevOps Extension | Public preview | OIDC through Azure service connection |
Each integration follows the same pattern on the Snowflake side. You create a service user for the pipeline, configure how it authenticates, and grant it only the roles it needs to deploy. With workload identity federation, the runner gets a short-lived OIDC token that Snowflake validates directly, so the CI system stores no long-lived secret. Each CI platform issues tokens from its own issuer with its own subject format, so the ISSUER and SUBJECT values come from that platform's reference page.
CREATE USER <username>
TYPE = SERVICE
WORKLOAD_IDENTITY = (
TYPE = OIDC
ISSUER = '<ci-platform-issuer>'
SUBJECT = '<ci-platform-subject>'
);Use key pair authentication when OIDC isn't available, for example with older CLI versions or on-premises runners. Store the private key as a CI secret and inject it through SNOWFLAKE_PRIVATE_KEY_RAW for a temporary connection, or through SNOWFLAKE_CONNECTIONS_<NAME>_PRIVATE_KEY_RAW for a named connection. Rotate it on a schedule. Passwords still work, but only for legacy workflows. Create one service user per repository or per environment, and restrict its source IPs with a network policy where you can. Then a leaked dev credential can't deploy to prod.
The service user's job is Snowflake-native promotion: applying one reviewed definition to each environment in turn, using objects inside Snowflake rather than files copied between accounts. DCM Projects (Database Change Management Projects) are the Snowflake-native option for the objects inside your databases. A DCM project is a set of SQL and YAML files, usually kept in Git, in which DEFINE statements describe the desired state of tables, schemas, roles and other objects; Snowflake works out the changes needed to reach that state. The files take effect only through a DCM project object, a schema-level object that runs the DCM commands and stores the artifacts and definition files of every deployment. Each target environment needs its own project object, so the dev service user and the prod service user each deploy into their own. Code that Snowflake runs from a Git clone is promoted by changing the reference rather than the file: dev can follow a /branches/ path while prod stays pinned to a /tags/ path. Account-level objects and infrastructure outside Snowflake fall to the Terraform provider instead.
Checkpoint 7 of 11· Fill the gap
Your GitHub Actions pipeline has to deploy to Snowflake without keeping any long-lived secret in the CI system. Which value completes this service user definition so that the runner's short-lived identity token is validated directly by Snowflake?
CREATE USER <username>
TYPE = SERVICE
WORKLOAD_IDENTITY = (
TYPE = ?
ISSUER = '<ci-platform-issuer>'
SUBJECT = '<ci-platform-subject>'
);With workload identity federation, the runner gets a short-lived OIDC token, and Snowflake checks it against the platform's ISSUER and SUBJECT. The CI system stores no secret. Key pair and password authentication both depend on a long-lived credential kept as a CI secret, and OAuth is the interactive method used for Workspaces Git access.
Source: docs.snowflake.com5.Connection precedence and project-definition variables
A typical pipeline commits a config.toml that holds only the connection skeleton and injects the secrets as environment variables. Several sources can then set the same parameter, so you need to know which one wins.
From highest to lowest, the order is:
- Command-line parameters.
- Environment variables that target one parameter of one named connection, for example
SNOWFLAKE_CONNECTIONS_MYCONNECTION_PASSWORD. - Values in
config.toml. - Generic environment variables such as
SNOWFLAKE_USER, which fill a parameter only when nothing above set it.
The usual mistake is to export SNOWFLAKE_USER and expect it to replace the user in a committed connection. It doesn't. To replace one key of a saved connection, set SNOWFLAKE_CONNECTIONS_<NAME>_<KEY>.
Variables also make one set of SQL serve every environment. The env section of snowflake.yml defines values that commands reference as <% ctx.env.name %>. Values passed on the command line with -D are referenced without the prefix, as <% name %>. A shell environment variable with the same, case-sensitive name overrides an env value. A CI job can therefore set database per stage without editing the file.
definition_version: 2
env:
database: "dev"
role: "eng_rl"Checkpoint 8 of 11· Put it in order
A CI job uses a committed config.toml connection named MYCONNECTION, and the user parameter could come from several places. Rank these sources from the one that wins to the one used only when nothing else sets the parameter.
- 1.A generic environment variable, such as SNOWFLAKE_USER
- 2.A connection-specific environment variable, such as SNOWFLAKE_CONNECTIONS_MYCONNECTION_USER
- 3.A command-line parameter passed to snow, such as --user
- 4.The value stored for MYCONNECTION in config.toml
Command-line parameters override everything. Next come environment variables aimed at one parameter of one named connection, and then config.toml. Generic SNOWFLAKE_* variables are applied last, so exporting SNOWFLAKE_USER does not replace a user already set in config.toml.
“Generic environment variables such as SNOWFLAKE_USER apply last.”Source: docs.snowflake.com
6.Scripting validate, deploy and verify with snow
A Snowflake pipeline runs in three stages on any CI platform: validate on the pull request, deploy on merge, and verify afterwards. Only the CI syntax differs between platforms. The command you use in each stage depends on what you are deploying.
| Stage | When it runs | Commands |
|---|---|---|
| Validate | On the pull request; post output as a PR comment | snow dcm plan (changes nothing) |
| Deploy | After merge to main | snow dcm deploy; snow sql -f <file>; snow snowpark deploy; snow git execute |
| Verify | After deploy | snow dcm test (exit code 0 if all pass, 1 if any fail) |
snow git execute connects the CLI to the Git clone. It runs EXECUTE IMMEDIATE on every file under a repository path. You can filter with a glob such as @my_repo/branches/main/*.sql, and only .sql and .py files run. The command accepts --variable for substitution and --workload-identity-provider for OIDC, so a single step can authenticate and deploy.
The DCM commands require Snowflake CLI 3.24.0 or later. snow dcm plan --target dev --save-output writes the plan and its artifacts to a local out/ directory that a job can attach to the pull request. snow dcm test runs the data metric expectations defined in the project. Because it exits with 1 on any failure, a CI step fails without extra scripting. Commands that would normally ask for confirmation, such as snow dcm purge, take --force in pipelines. Only point snow at sources you trust: some commands execute code from the project directory or fetch and run content from remote URLs.
A target is a named profile that --target selects, so one set of project files can be aimed at dev or prod. Targets are defined in the project's manifest.yml, and the main thing a target supplies is the identifier of the DCM project object the command runs against: snow dcm create --target dev creates the project named by the dev target, and snow dcm deploy --target prod deploys into the one named by the prod target. Without --target, the default target in the manifest is used. Because each environment has its own project object, choosing a target is what keeps a dev run from touching prod. How a target interacts with the active connection and role is covered in the CLI's project identifier resolution reference.
Checkpoint 9 of 11· Match them up
Match each snow command to the pipeline stage it belongs to and what it does there.
Tap a term, then the definition that fits it.
The pipeline validates on the pull request, deploys on merge and then verifies. snow dcm plan is the validate step because it changes nothing. snow dcm deploy and snow git execute both apply changes after the merge. snow dcm test checks the result, and its non-zero exit code fails the job with no extra scripting.
“A Snowflake CI/CD pipeline typically progresses through three stages: validate proposed changes on a pull request, deploy them on merge, and verify the result.”Source: docs.snowflake.com
7.Object dependencies a pipeline deployment must respect
With imperative scripts, a deployment fails if it creates an object before the objects it references. For Git-driven ML code, the order follows from the references between objects:
- Secret holding the Git token.
- API integration with
API_PROVIDER = git_https_api, the repository prefix and the secret in its allowed list. - USAGE on that integration for the role that owns or operates the repository.
- Git repository object referencing the integration and the secret.
- A fetch, so the clone holds the files.
- The procedures, UDFs and tasks whose handler code, or whose deploy script, comes from paths in the clone.
- The service user and the roles it needs to run the deploy.
Scripts that run in this order should also be safe to rerun. If a release fails halfway, a rerun after the fix should converge rather than collide with objects the first run already created. CREATE OR REPLACE, which swaps an existing object for the new definition in a single atomic transaction, and snow dcm create --if-not-exists are the script-level tools for that.
DCM projects remove the ordering problem for objects inside databases. You write DEFINE statements describing the target state, and Snowflake collects and sorts all of them before applying changes. Where a statement sits in the project has no effect on the result. A rerun therefore converges on the declared state. DCM still has a few prerequisites. Each target environment needs its own DCM project object, which is a schema-level object, so a database and schema must exist first. Running local definitions through the CLI also needs privileges to create a temporary stage in that schema. PLAN and DEPLOY are mostly metadata operations, and an X-Small warehouse is sufficient for them.
DCM projects cover the objects inside your databases. The Snowflake Terraform provider covers account-level objects and infrastructure outside Snowflake. Many organisations use both.
Checkpoint 10 of 11· Check yourself
In a DCM project for an ML feature pipeline, the file views.sql holds a DEFINE statement for a view over FEATURES.TRAINING_SET. That table's DEFINE statement sits further down, in tables.sql. During code review, someone asks for a change before snow dcm deploy runs. What actually needs to change?
DCM projects are declarative. Snowflake collects and sorts every DEFINE statement before it applies changes, so where a statement sits in the project doesn't change the result. Hand-ordering by dependency, splitting deploys and renaming files are habits from imperative scripts, where creating an object before the objects it references makes the deployment fail.
“The order and location of DEFINE statements within a project don’t affect the results. Snowflake collects and sorts all statements before applying changes”Source: docs.snowflake.com
8.Running ML promotion as a CI stage
Promotion means applying one reviewed definition to each environment in turn, and DCM targets express that directly. The Promoting feature pipelines across Dev/Test/Prod flow becomes a sequence of commands. Run snow dcm plan --target dev on the pull request. After merge, run snow dcm deploy --target dev and snow dcm test --target dev. Then repeat deploy and test with --from the same project and --target prod. Feature pipelines then deploy the same way as the rest of the ML code.
Each deployment becomes a record you can audit. The DCM project object stores the immutable artifacts and definition files of every executed deployment. --alias v1.0 labels a deployment, and snow dcm list-deployments shows the names and aliases for each target.
Model promotion across environments and accounts fits the same pipeline as a later stage. That stage runs only after verify passes. It runs the promotion SQL with snow git execute from a /tags/ path, so the promotion script itself is pinned to the reviewed release.
Checkpoint 11 of 11· Fill the gap
After snow dcm deploy and snow dcm test both succeed in dev, the pipeline promotes the same reviewed DCM project to production. Which option completes the command so it uses the production environment's settings?
snow dcm deploy --from /path/to/project ? prodDCM targets are how promotion works: the same project definition goes to each environment in turn, chosen with --target (dev, then prod). --env sounds right because snowflake.yml has an env section, but that section holds template variables, not a deploy flag. --connection and --database don't pick a DCM target.
Source: docs.snowflake.comSources8
Sources
(12)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.
“Through the Git repository clone, Snowflake becomes another client of your repository separate from your local repository.”
↩︎ What a Git repository object is in Snowflake“Commit and push changes to the remote repository from Workspaces, Streamlit apps, and Snowflake notebooks.”
↩︎ What a Git repository object is in Snowflake“Copy file paths for referencing in Snowflake code (such as handler code for functions, tasks, or procedures).”
↩︎ Object dependencies a pipeline deployment must respect“files from the remote repository are synchronized to a Git repository clone in Snowflake”
↩︎ Key concept - 2.
“When you do so, you also prune branches and commits that were fetched earlier but no longer exist in the remote repository.”
↩︎ What a Git repository object is in Snowflake“specifying the Git repository clone as you would a stage (you can abbreviate LIST to LS)”
↩︎ Addressing branches, tags and commits, and deploying with EXECUTE IMMEDIATE FROM“You can use EXECUTE IMMEDIATE FROM to execute code in a Git repository clone.”
↩︎ Addressing branches, tags and commits, and deploying with EXECUTE IMMEDIATE FROM“Note that when you execute code this way, you won’t see output generated by the code’s execution.”
↩︎ Addressing branches, tags and commits, and deploying with EXECUTE IMMEDIATE FROM“List by tag name: Copy codeLS @repository_name/tags/tag_name;”
↩︎ Exam trap 1“neither the current role nor the role that owns the Git repository has USAGE on the API integration used by the repository”
↩︎ Exam trap 4“insufficient-privileges error if neither the current role nor the role that owns the Git repository has USAGE on the API integration”
↩︎ Checkpoint“LS @repository_name/tags/tag_name;”
↩︎ Checkpoint - 3.
“Automated pipelines or ML projects: configure token-based authentication so that scripted processes can access the repository without manual sign-in.”
↩︎ Connecting a private repository: secret, API integration, repository“routes Git traffic through a dedicated outbound private link connection instead of the public internet”
↩︎ Connecting a private repository: secret, API integration, repository - 4.
“The API integration you specify here must have an API_PROVIDER parameter whose value is set to git_https_api.”
↩︎ Connecting a private repository: secret, API integration, repository“As a best practice, use a personal access token for the secret’s PASSWORD value.”
↩︎ Connecting a private repository: secret, API integration, repository“The secret you specify here must be a secret specified by the ALLOWED_AUTHENTICATION_SECRETS parameter of the API integration”
↩︎ Connecting a private repository: secret, API integration, repository“when an object is replaced, the old object is deleted and the new object is created in a single transaction.”
↩︎ Object dependencies a pipeline deployment must respect - 5.
“Snowflake will only add new features and enhancements to Snowflake CLI.”
↩︎ Authenticating a CI runner with Snowflake CLI - 6.
“Snowflake recommends workload identity federation (WIF) with OpenID Connect (OIDC) so that no long-lived secrets are stored in the CI system.”
↩︎ Authenticating a CI runner with Snowflake CLI“Store the private key as a CI secret and pass it through the environment using SNOWFLAKE_PRIVATE_KEY_RAW (for a temporary connection)”
↩︎ Authenticating a CI runner with Snowflake CLI“Create a dedicated service user for each pipeline environment (for example, one user per repository or per environment).”
↩︎ Authenticating a CI runner with Snowflake CLI“Do not commit config.toml files that contain credentials. Commit only the connection skeleton and supply secrets through environment variables.”
↩︎ Connection precedence and project-definition variables“Generic environment variables such as SNOWFLAKE_USER apply last.”
↩︎ Connection precedence and project-definition variables“Environment variables that target a specific connection parameter (for example, SNOWFLAKE_CONNECTIONS_MYCONNECTION_PASSWORD) override config.toml.”
↩︎ Exam trap 2“A Snowflake CI/CD pipeline typically progresses through three stages: validate proposed changes on a pull request, deploy them on merge, and verify the result.”
↩︎ Checkpoint - 7.
“DCM Projects (Database Change Management Projects) are the Snowflake-native option for the objects inside your databases.”
↩︎ Authenticating a CI runner with Snowflake CLI“The Snowflake Terraform provider covers account-level objects and any infrastructure you manage outside Snowflake”
↩︎ Object dependencies a pipeline deployment must respect - 8.
“You need a DCM project object for each target environment.”
↩︎ Authenticating a CI runner with Snowflake CLI“Specifically, DCM Projects leverage DEFINE statements with templating features.”
↩︎ Authenticating a CI runner with Snowflake CLI“A DCM project is a schema-level object in Snowflake that you use to deploy and manage the objects defined in DCM project files.”
↩︎ Authenticating a CI runner with Snowflake CLI“The order and location of DEFINE statements within a project don’t affect the results.”
↩︎ Object dependencies a pipeline deployment must respect“you also need privileges to create a temporary stage in the schema of your target DCM project object”
↩︎ Object dependencies a pipeline deployment must respect“stores the immutable artifacts and definition files of all executed deployments”
↩︎ Running ML promotion as a CI stage“You need a DCM project object for each target environment.”
↩︎ Running ML promotion as a CI stage“Snowflake collects and sorts all statements before applying changes, so you don’t need to manually handle sequencing or dependencies.”
↩︎ Exam trap 3“The order and location of DEFINE statements within a project don’t affect the results. Snowflake collects and sorts all statements before applying changes”
↩︎ Checkpoint - 9.
“The ctx.env prefix applies only to project definition env values, not to -D variables.”
↩︎ Connection precedence and project-definition variables - 10.https://docs.snowflake.com/en/developer-guide/snowflake-cli/project-definitions/use-sql-variablesOfficial docs
“You can override any variable defined the in snowflake.yml project definition file by setting a shell environment variable by the same name (case-sensitive).”
↩︎ Connection precedence and project-definition variables - 11.https://docs.snowflake.com/en/developer-guide/snowflake-cli/command-reference/git-commands/executeOfficial docs
“Execute immediate all files from the repository path.”
↩︎ Scripting validate, deploy and verify with snow“Only files with .sql or .py extension will be executed.”
↩︎ Scripting validate, deploy and verify with snow - 12.https://docs.snowflake.com/en/developer-guide/snowflake-cli/data-pipelines/dcm-projectsOfficial docs
“The command returns exit code 0 if all tests pass, or exit code 1 if any test fails.”
↩︎ Scripting validate, deploy and verify with snow“To use the snow dcm commands, you must install Snowflake CLI version 3.24.0 or later.”
↩︎ Scripting validate, deploy and verify with snow“Create a project using the identifier from the dev target specified in the manifest”
↩︎ Scripting validate, deploy and verify with snow