Data-Engineer-Associate domain - 10% of the exam

Implementing CI/CD

Implementing CI/CD is 10% of the Data-Engineer-Associate exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

30
Practice questions
4
Objectives
23
Medium
7
Hard

Where people go wrong

  • Expecting the workspace to host review and merge

    The wrong answers treat a Databricks Git folder as the place where a pull request is approved or merged, or copy files onto main to skip review. A Git folder handles the branch, commit and push. The pull request, the approvals and the merge belong to the linked Git provider, which the dialog links out to, and branch protection rules also live there. Bypassing the pull request leaves no approval record.

    See it in a sample question
  • Assuming a Git folder updates itself

    The wrong answers expect the folder to catch up with the remote after a merge: by waiting for a scheduled process, by reopening the notebook, or by merging uncommitted work automatically. A Git folder is a working copy fixed at the commit last checked out or pulled. It advances only when someone checks out the right branch and pulls, and a pull needs a clean working tree, so outstanding edits are committed or discarded first.

    See it in a sample question
  • Fixing a deployed resource by hand in the workspace

    The wrong answers change a deployed job in the workspace interface: raising a worker count, or setting the identity the job executes under. The edit appears to work. A bundle deployment reconciles the resources it manages with the configuration, so the next deploy overwrites it. The durable change is made in the bundle, in the target's variables mapping or its run_as block, and promoted through the same pipeline.

    See it in a sample question
  • Expecting validate or deploy to start a job run

    The wrong answers credit databricks bundle validate or databricks bundle deploy with executing the job, as a smoke test. Validate parses the configuration, applies the target overrides, resolves variables and reports errors, creating nothing in the workspace. Deploy creates and updates the declared resources and stops there. Starting a run is the job of databricks bundle run, which takes the resource key and the target.

    See it in a sample question
  • Mixing up deployment authentication and run_as

    The wrong answers authenticate an unattended runner with an interactive login, which needs a browser and a person, or with one engineer's personal access token, which ties the deployment to that account. Others offer run_as as the credential. Deployment authentication comes from a service principal's DATABRICKS_HOST, DATABRICKS_CLIENT_ID and DATABRICKS_CLIENT_SECRET variables. run_as only sets the identity the deployed jobs execute under, and it supplies no credentials for the deployment itself.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleImplementing CI/CDmedium

A team has finished a feature on a branch in a Databricks Git Folder and has committed and pushed it. Governance requires that the code reaching main is approved by two reviewers and that the approval record lives with the repository, alongside the branch protection rules the team already maintains. An engineer asks how the merge itself should be carried out. Which statement is correct?

  • AThe Git dialog merges the feature branch into main inside the workspace once the required reviewers have added their approval in the dialog, and it then pushes the merge commit to the provider.
  • BThe engineer checks out main in the Git Folder, copies the notebooks across from the feature branch checkout, and commits the result to main so that the reviewers can read the diff afterwards.
  • CThe Git dialog links out to the Git provider to open a pull request, and the review and merge take place there, after which the folder is brought up to date by checking out main and pulling. Correct
  • DThe team should schedule a Lakeflow Job that runs a notebook calling the provider's merge endpoint, because the workspace UI offers no route from a pushed branch to a pull request.
Pull requests for Databricks Git Folders are raised, reviewed and merged in the Git provider, and the workspace copy is refreshed by pulling main. Databricks Git Folders provide the working copy and the branch, commit, push and pull operations, while review and merge remain the responsibility of the Git provider that holds the repository. That is why the Git dialog offers a link to create the pull request instead of a merge button, and why branch protection and approval rules keep applying unchanged.

Why A is wrong: It sounds reasonable because the dialog does handle branches, commits and pushes, but Databricks does not host code review, and approvals are recorded by the provider.

Why B is wrong: Copying files does produce the same content on main, which makes it look equivalent, but it bypasses the pull request and so leaves no approval record and defeats branch protection.

Why C is correct: Databricks Git Folders integrate with the provider rather than replacing it, so approvals and the merge happen in the provider and the workspace copy is refreshed with a pull.

Why D is wrong: Automating a provider call is technically possible, so it reads as thorough, but it is unnecessary bespoke work and its premise about the UI having no route is wrong.

Free sampleImplementing CI/CDmedium

A colleague merged a pull request into the main branch of a repository an hour ago. A data engineer whose Databricks Git folder has main checked out opens a notebook in that folder and finds the previous version of the code, with no sign of the merged change. The Git provider shows the merge on main. What accounts for this, and what should the engineer do?

  • AA Git folder tracks its remote branch continuously, so stale content means the merge landed on a branch of a different repository than the one the folder is linked to.
  • BA Git folder refreshes its contents whenever a notebook in it is opened, so closing the notebook and opening it once more brings the merged commit into the folder.
  • CA Git folder changes only when someone performs a Git operation in it, so the engineer should pull the branch from the Git dialog to bring the merged commit into the folder. Correct
  • DA Git folder is synchronised by a background workspace job that runs roughly hourly, so the engineer should wait for the next cycle before reading the notebook again.
A Databricks Git folder advances to the remote branch tip only when a user pulls, since nothing synchronises it automatically. The files in a Git folder are a checkout of one commit, not a live mirror of the branch. Commits made elsewhere, including a merge performed in the provider, leave that checkout untouched until someone runs a pull in the folder, which fetches the branch and updates the working copy to its current tip.

Why A is wrong: Tempting because a wrong repository would indeed explain it, but the provider shows the merge on the same linked repository, and Git folders do not track continuously.

Why B is wrong: Plausible because opening a notebook does reload it, but the reload reads the workspace copy of the file and fetches nothing from the remote repository.

Why C is correct: Correct, because the folder holds a working copy fixed at the commit last checked out or pulled, and a pull is what advances it to the remote branch tip.

Why D is wrong: Attractive because other workspace features do run on schedules, but no scheduled process pulls commits into Git folders, so waiting changes nothing.

Free sampleImplementing CI/CDhard

A team promotes one job definition across dev, test and prod with Declarative Automation Bundles. Each environment needs a different Unity Catalog catalogue name and a different worker count on the job cluster, while the notebook code and the job structure stay identical. The team wants a single job declaration in the bundle and no hand editing between deployments. Which approach fits the requirement?

variables:
  catalog_name:
    description: Unity Catalog catalogue the job writes to
    default: dev_catalog
  worker_count:
    default: 2
  • ADeclare the catalogue and the worker count as bundle variables, reference them in the single job declaration, set each target's values in that target's variables mapping, and deploy with the target selected by the -t flag. Correct
  • BKeep one databricks.yml per environment in separate directories of the repository, each holding its own copy of the job declaration, and deploy whichever file matches the environment being promoted.
  • CDeploy the bundle once with its defaults and then adjust the catalogue and the worker count on the deployed job in the workspace user interface for each environment after the deployment finishes.
  • DCreate a git branch per environment, commit the environment values into the job declaration on each branch, and deploy the branch that matches the environment being promoted.
Promote one bundle definition across environments by parameterising it with bundle variables and setting each value in the target's variables mapping. A bundle variable declared once and referenced inside a resource lets a single job declaration carry environment specific values. Each target supplies its own value in that target's variables mapping, so selecting the target at deploy time resolves the reference. The structure of the job stays in one place, which is what makes promotion across dev, test and prod repeatable.

Why A is correct: Correct: one job declaration references the variables, and each target supplies its own values, so the same codebase is promoted and only the environment specific values change.

Why B is wrong: Tempting because it does give each environment its own values, but it duplicates the job declaration three times, so a structural change has to be applied in three places and the copies drift.

Why C is wrong: Tempting because the change is quick, but a later deploy reconciles the deployed job with the bundle configuration and overwrites those manual edits, so the environments drift silently between deployments.

Why D is wrong: Plausible because branches do isolate values, but promoting code then means merging between long-lived branches that differ by configuration, which is the drift the bundle target mechanism exists to remove.

Free sampleImplementing CI/CDmedium

A continuous integration pipeline deploys a bundle to the prod target on every merge to the main branch. After one such merge, a data engineer needs the job declared below to execute once straight away, rather than waiting for its next scheduled trigger, and without editing the job in the workspace. Which command carries that out, and what does it do?

resources:
  jobs:
    reporting_job:
      name: nightly_reporting
  • Adatabricks bundle deploy -t prod reporting_job, which redeploys that one job to the prod target and starts a run of it as the final step of the deployment.
  • Bdatabricks bundle run -t prod reporting_job, which starts a run of the job already deployed to prod from this bundle and reports the outcome of that run. Correct
  • Cdatabricks bundle validate -t prod reporting_job, which resolves that job's definition for the prod target and executes it once so the resolved configuration is proved end to end.
  • Ddatabricks bundle summary -t prod reporting_job, which prints the deployed job's identifier and triggers a run of it so that the printed output can be checked afterwards.
Distinguish deploying a bundle from running one of its resources, and identify the command that starts a deployed job on demand. Deployment and execution are deliberately separate in a bundle workflow. Deploy reconciles the workspace with the configuration for a target, which is what a continuous integration pipeline should do on merge. Running a resource is a distinct action addressed by its key in the configuration, so the same key that identifies the job in YAML is what the run command resolves against the deployment for that target.

Why A is wrong: Tempting because deploy is the command the pipeline already uses, but deploy reconciles the whole bundle for the target and does not accept a resource key or start a run.

Why B is correct: Correct, because run takes the resource key from the bundle configuration, resolves it to the job the prod deployment created, triggers a run of it, and follows that run to completion.

Why C is wrong: Plausible if validation is read as a live test of the definition, but validate is a local check over the configuration and starts nothing in the workspace.

Why D is wrong: The summary command is real and does report deployed resources for a target, which makes it a believable choice, but it is a read only view and triggers nothing.

Free sampleImplementing CI/CDmedium

A hosted continuous integration runner deploys a Declarative Automation Bundle to a production workspace on every merge. The runner has no browser and no interactive terminal, and governance requires the deployment to act as a service principal rather than as any engineer's account. Which arrangement authenticates the Databricks CLI for that unattended deployment?

  • ARun the CLI login command as the first step of the pipeline so the CLI opens an OAuth session for the service principal before the deployment step runs.
  • BSet DATABRICKS_HOST together with DATABRICKS_CLIENT_ID and DATABRICKS_CLIENT_SECRET as protected pipeline secrets so the CLI authenticates as the service principal. Correct
  • CSet the workspace host as a pipeline variable and let the CLI adopt the identity named in the bundle's run_as setting when it deploys the resources.
  • DPass the service principal's application identifier to the deploy command with the profile flag so the CLI selects that identity from the runner's configuration file.
Unattended CLI deployments authenticate as a service principal through host and OAuth client credentials supplied as environment variables, not through interactive login. The CLI resolves credentials from environment variables before falling back to a configuration file. Supplying the host with an OAuth client id and secret for a service principal gives it a complete non interactive credential, which is why headless runners use that path instead of a browser based login flow.

Why A is wrong: Tempting because that login command is the usual way an engineer authenticates a laptop, but it expects a browser and a person to complete the consent, so it cannot finish on a headless runner.

Why B is correct: Correct: those environment variables give the CLI a workspace target and OAuth machine to machine credentials for the service principal, which needs no browser and no human interaction during the run.

Why C is wrong: Tempting because run_as does control which identity the deployed job executes under, but it does not authenticate the deployment itself, which still needs its own credentials before any API call succeeds.

Why D is wrong: Tempting because the profile flag is a genuine CLI flag, but it names a configuration profile rather than an identity, and no credential exists on a fresh runner for it to select.

Other domains in this exam

See also the Data-Engineer-Associate cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Databricks. Original, blueprint-aligned practice material only.