From 8f2725e6e962f295e8f75cf141fda5ebaca2235b Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Wed, 16 Aug 2023 13:01:00 +0200
Subject: [PATCH 1/8] Renamed Environments to Targets in bundle.yml

---
 bundle/bundle.go                              | 10 +--
 bundle/bundle_test.go                         | 16 ++--
 bundle/config/bundle.go                       |  9 +-
 bundle/config/environment.go                  | 12 +--
 bundle/config/mutator/default_environment.go  | 37 --------
 bundle/config/mutator/default_target.go       | 37 ++++++++
 ...ronment_test.go => default_target_test.go} | 16 ++--
 .../config/mutator/default_workspace_root.go  |  6 +-
 .../mutator/default_workspace_root_test.go    |  4 +-
 bundle/config/mutator/mutator.go              |  6 +-
 bundle/config/mutator/override_compute.go     |  2 +-
 ...ronment_mode.go => process_target_mode.go} | 20 ++---
 ...de_test.go => process_target_mode_test.go} | 22 ++---
 .../mutator/select_default_environment.go     | 54 -----------
 .../select_default_environment_test.go        | 90 -------------------
 .../config/mutator/select_default_target.go   | 54 +++++++++++
 .../mutator/select_default_target_test.go     | 90 +++++++++++++++++++
 bundle/config/mutator/select_environment.go   | 48 ----------
 bundle/config/mutator/select_target.go        | 54 +++++++++++
 ...ironment_test.go => select_target_test.go} | 14 +--
 bundle/config/resources.go                    |  2 +-
 bundle/config/resources/job.go                |  2 +-
 bundle/config/root.go                         | 75 ++++++++++------
 bundle/config/root_test.go                    | 12 +--
 bundle/config/variable/variable.go            |  2 +-
 bundle/config/workspace.go                    |  2 +-
 bundle/deploy/terraform/init_test.go          | 16 ++--
 bundle/deploy/terraform/load_test.go          |  2 +-
 bundle/phases/initialize.go                   |  2 +-
 bundle/schema/docs.go                         | 16 ++--
 bundle/tests/autoload_git/databricks.yml      |  2 +-
 bundle/tests/environment_empty/databricks.yml |  5 --
 bundle/tests/environment_empty_test.go        | 12 ---
 bundle/tests/environment_git_test.go          | 20 +++++
 bundle/tests/environment_overrides_test.go    |  8 +-
 .../environments_autoload_git/databricks.yml  | 11 +++
 .../databricks.yml                            | 44 +++++++++
 .../environments_job_and_pipeline_test.go     | 56 ++++++++++++
 .../databricks.yml                            | 35 ++++++++
 .../environments_override_job_cluster_test.go | 29 ++++++
 bundle/tests/git_test.go                      |  2 +-
 bundle/tests/job_and_pipeline/databricks.yml  |  2 +-
 bundle/tests/job_and_pipeline_test.go         |  6 +-
 bundle/tests/loader.go                        |  4 +-
 .../tests/override_job_cluster/databricks.yml |  2 +-
 bundle/tests/override_job_cluster_test.go     |  4 +-
 bundle/tests/string_interpolation/.gitignore  |  1 +
 .../tests/string_interpolation/databricks.yml | 16 ++++
 bundle/tests/string_interpolation_test.go     | 23 +++++
 bundle/tests/target_empty/databricks.yml      |  5 ++
 bundle/tests/target_empty_test.go             | 12 +++
 .../target_overrides/resources/databricks.yml | 20 +++++
 .../target_overrides/workspace/databricks.yml | 14 +++
 bundle/tests/target_overrides_test.go         | 27 ++++++
 .../variables/env_overrides/databricks.yml    |  2 +-
 bundle/tests/variables_test.go                | 20 ++---
 cmd/bundle/variables.go                       |  2 +-
 cmd/root/bundle.go                            | 38 +++++---
 cmd/root/root.go                              |  1 +
 cmd/sync/sync_test.go                         |  2 +-
 60 files changed, 748 insertions(+), 409 deletions(-)
 delete mode 100644 bundle/config/mutator/default_environment.go
 create mode 100644 bundle/config/mutator/default_target.go
 rename bundle/config/mutator/{default_environment_test.go => default_target_test.go} (51%)
 rename bundle/config/mutator/{process_environment_mode.go => process_target_mode.go} (89%)
 rename bundle/config/mutator/{process_environment_mode_test.go => process_target_mode_test.go} (90%)
 delete mode 100644 bundle/config/mutator/select_default_environment.go
 delete mode 100644 bundle/config/mutator/select_default_environment_test.go
 create mode 100644 bundle/config/mutator/select_default_target.go
 create mode 100644 bundle/config/mutator/select_default_target_test.go
 delete mode 100644 bundle/config/mutator/select_environment.go
 create mode 100644 bundle/config/mutator/select_target.go
 rename bundle/config/mutator/{select_environment_test.go => select_target_test.go} (62%)
 delete mode 100644 bundle/tests/environment_empty/databricks.yml
 delete mode 100644 bundle/tests/environment_empty_test.go
 create mode 100644 bundle/tests/environment_git_test.go
 create mode 100644 bundle/tests/environments_autoload_git/databricks.yml
 create mode 100644 bundle/tests/environments_job_and_pipeline/databricks.yml
 create mode 100644 bundle/tests/environments_job_and_pipeline_test.go
 create mode 100644 bundle/tests/environments_override_job_cluster/databricks.yml
 create mode 100644 bundle/tests/environments_override_job_cluster_test.go
 create mode 100644 bundle/tests/string_interpolation/.gitignore
 create mode 100644 bundle/tests/string_interpolation/databricks.yml
 create mode 100644 bundle/tests/string_interpolation_test.go
 create mode 100644 bundle/tests/target_empty/databricks.yml
 create mode 100644 bundle/tests/target_empty_test.go
 create mode 100644 bundle/tests/target_overrides/resources/databricks.yml
 create mode 100644 bundle/tests/target_overrides/workspace/databricks.yml
 create mode 100644 bundle/tests/target_overrides_test.go

diff --git a/bundle/bundle.go b/bundle/bundle.go
index 06c68fe8ad..a5eaa28970 100644
--- a/bundle/bundle.go
+++ b/bundle/bundle.go
@@ -117,10 +117,10 @@ func (b *Bundle) WorkspaceClient() *databricks.WorkspaceClient {
 }
 
 // CacheDir returns directory to use for temporary files for this bundle.
-// Scoped to the bundle's environment.
+// Scoped to the bundle's target.
 func (b *Bundle) CacheDir(paths ...string) (string, error) {
-	if b.Config.Bundle.Environment == "" {
-		panic("environment not set")
+	if b.Config.Bundle.Target == "" {
+		panic("target not set")
 	}
 
 	cacheDirName, exists := os.LookupEnv("DATABRICKS_BUNDLE_TMP")
@@ -138,8 +138,8 @@ func (b *Bundle) CacheDir(paths ...string) (string, error) {
 	// Fixed components of the result path.
 	parts := []string{
 		cacheDirName,
-		// Scope with environment name.
-		b.Config.Bundle.Environment,
+		// Scope with target name.
+		b.Config.Bundle.Target,
 	}
 
 	// Append dynamic components of the result path.
diff --git a/bundle/bundle_test.go b/bundle/bundle_test.go
index ac94750006..4a3e7f2c90 100644
--- a/bundle/bundle_test.go
+++ b/bundle/bundle_test.go
@@ -31,16 +31,16 @@ func TestBundleCacheDir(t *testing.T) {
 	bundle, err := Load(context.Background(), projectDir)
 	require.NoError(t, err)
 
-	// Artificially set environment.
-	// This is otherwise done by [mutators.SelectEnvironment].
-	bundle.Config.Bundle.Environment = "default"
+	// Artificially set target.
+	// This is otherwise done by [mutators.SelectTarget].
+	bundle.Config.Bundle.Target = "default"
 
 	// unset env variable in case it's set
 	t.Setenv("DATABRICKS_BUNDLE_TMP", "")
 
 	cacheDir, err := bundle.CacheDir()
 
-	// format is <CWD>/.databricks/bundle/<environment>
+	// format is <CWD>/.databricks/bundle/<target>
 	assert.NoError(t, err)
 	assert.Equal(t, filepath.Join(projectDir, ".databricks", "bundle", "default"), cacheDir)
 }
@@ -55,16 +55,16 @@ func TestBundleCacheDirOverride(t *testing.T) {
 	bundle, err := Load(context.Background(), projectDir)
 	require.NoError(t, err)
 
-	// Artificially set environment.
-	// This is otherwise done by [mutators.SelectEnvironment].
-	bundle.Config.Bundle.Environment = "default"
+	// Artificially set target.
+	// This is otherwise done by [mutators.SelectTarget].
+	bundle.Config.Bundle.Target = "default"
 
 	// now we expect to use 'bundleTmpDir' instead of CWD/.databricks/bundle
 	t.Setenv("DATABRICKS_BUNDLE_TMP", bundleTmpDir)
 
 	cacheDir, err := bundle.CacheDir()
 
-	// format is <DATABRICKS_BUNDLE_TMP>/<environment>
+	// format is <DATABRICKS_BUNDLE_TMP>/<target>
 	assert.NoError(t, err)
 	assert.Equal(t, filepath.Join(bundleTmpDir, "default"), cacheDir)
 }
diff --git a/bundle/config/bundle.go b/bundle/config/bundle.go
index f3401477f0..d444f50778 100644
--- a/bundle/config/bundle.go
+++ b/bundle/config/bundle.go
@@ -15,7 +15,10 @@ type Bundle struct {
 	// Default warehouse to run SQL on.
 	// DefaultWarehouse string `json:"default_warehouse,omitempty"`
 
-	// Environment is set by the mutator that selects the environment.
+	// Target is set by the mutator that selects the target.
+	Target string `json:"target,omitempty" bundle:"readonly"`
+
+	// DEPRECATED. Left for backward compatibility with Target
 	Environment string `json:"environment,omitempty" bundle:"readonly"`
 
 	// Terraform holds configuration related to Terraform.
@@ -32,10 +35,10 @@ type Bundle struct {
 	// origin url. Automatically loaded by reading .git directory if not specified
 	Git Git `json:"git,omitempty"`
 
-	// Determines the mode of the environment.
+	// Determines the mode of the target.
 	// For example, 'mode: development' can be used for deployments for
 	// development purposes.
-	// Annotated readonly as this should be set at the environment level.
+	// Annotated readonly as this should be set at the target level.
 	Mode Mode `json:"mode,omitempty" bundle:"readonly"`
 
 	// Overrides the compute used for jobs and other supported assets.
diff --git a/bundle/config/environment.go b/bundle/config/environment.go
index 7152f791f6..7c4b10adb4 100644
--- a/bundle/config/environment.go
+++ b/bundle/config/environment.go
@@ -2,14 +2,14 @@ package config
 
 type Mode string
 
-// Environment defines overrides for a single environment.
+// Target defines overrides for a single taregt.
 // This structure is recursively merged into the root configuration.
-type Environment struct {
-	// Default marks that this environment must be used if one isn't specified
-	// by the user (through environment variable or command line argument).
+type Target struct {
+	// Default marks that this target must be used if one isn't specified
+	// by the user (through target variable or command line argument).
 	Default bool `json:"default,omitempty"`
 
-	// Determines the mode of the environment.
+	// Determines the mode of the target.
 	// For example, 'mode: development' can be used for deployments for
 	// development purposes.
 	Mode Mode `json:"mode,omitempty"`
@@ -27,7 +27,7 @@ type Environment struct {
 
 	// Override default values for defined variables
 	// Does not permit defining new variables or redefining existing ones
-	// in the scope of an environment
+	// in the scope of an target
 	Variables map[string]string `json:"variables,omitempty"`
 
 	Git Git `json:"git,omitempty"`
diff --git a/bundle/config/mutator/default_environment.go b/bundle/config/mutator/default_environment.go
deleted file mode 100644
index 1598a647d5..0000000000
--- a/bundle/config/mutator/default_environment.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package mutator
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/databricks/cli/bundle"
-	"github.com/databricks/cli/bundle/config"
-)
-
-type defineDefaultEnvironment struct {
-	name string
-}
-
-// DefineDefaultEnvironment adds an environment named "default"
-// to the configuration if none have been defined.
-func DefineDefaultEnvironment() bundle.Mutator {
-	return &defineDefaultEnvironment{
-		name: "default",
-	}
-}
-
-func (m *defineDefaultEnvironment) Name() string {
-	return fmt.Sprintf("DefineDefaultEnvironment(%s)", m.name)
-}
-
-func (m *defineDefaultEnvironment) Apply(_ context.Context, b *bundle.Bundle) error {
-	// Nothing to do if the configuration has at least 1 environment.
-	if len(b.Config.Environments) > 0 {
-		return nil
-	}
-
-	// Define default environment.
-	b.Config.Environments = make(map[string]*config.Environment)
-	b.Config.Environments[m.name] = &config.Environment{}
-	return nil
-}
diff --git a/bundle/config/mutator/default_target.go b/bundle/config/mutator/default_target.go
new file mode 100644
index 0000000000..d5318a3e26
--- /dev/null
+++ b/bundle/config/mutator/default_target.go
@@ -0,0 +1,37 @@
+package mutator
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/databricks/cli/bundle"
+	"github.com/databricks/cli/bundle/config"
+)
+
+type defineDefaultTarget struct {
+	name string
+}
+
+// DefineDefaultTarget adds a target named "default"
+// to the configuration if none have been defined.
+func DefineDefaultTarget() bundle.Mutator {
+	return &defineDefaultTarget{
+		name: "default",
+	}
+}
+
+func (m *defineDefaultTarget) Name() string {
+	return fmt.Sprintf("DefineDefaultTarget(%s)", m.name)
+}
+
+func (m *defineDefaultTarget) Apply(_ context.Context, b *bundle.Bundle) error {
+	// Nothing to do if the configuration has at least 1 target.
+	if len(b.Config.Targets) > 0 {
+		return nil
+	}
+
+	// Define default target.
+	b.Config.Targets = make(map[string]*config.Target)
+	b.Config.Targets[m.name] = &config.Target{}
+	return nil
+}
diff --git a/bundle/config/mutator/default_environment_test.go b/bundle/config/mutator/default_target_test.go
similarity index 51%
rename from bundle/config/mutator/default_environment_test.go
rename to bundle/config/mutator/default_target_test.go
index f196e5baee..49fbe6de2c 100644
--- a/bundle/config/mutator/default_environment_test.go
+++ b/bundle/config/mutator/default_target_test.go
@@ -11,25 +11,25 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestDefaultEnvironment(t *testing.T) {
+func TestDefaultTarget(t *testing.T) {
 	bundle := &bundle.Bundle{}
-	err := mutator.DefineDefaultEnvironment().Apply(context.Background(), bundle)
+	err := mutator.DefineDefaultTarget().Apply(context.Background(), bundle)
 	require.NoError(t, err)
-	env, ok := bundle.Config.Environments["default"]
+	env, ok := bundle.Config.Targets["default"]
 	assert.True(t, ok)
-	assert.Equal(t, &config.Environment{}, env)
+	assert.Equal(t, &config.Target{}, env)
 }
 
-func TestDefaultEnvironmentAlreadySpecified(t *testing.T) {
+func TestDefaultTargetAlreadySpecified(t *testing.T) {
 	bundle := &bundle.Bundle{
 		Config: config.Root{
-			Environments: map[string]*config.Environment{
+			Targets: map[string]*config.Target{
 				"development": {},
 			},
 		},
 	}
-	err := mutator.DefineDefaultEnvironment().Apply(context.Background(), bundle)
+	err := mutator.DefineDefaultTarget().Apply(context.Background(), bundle)
 	require.NoError(t, err)
-	_, ok := bundle.Config.Environments["default"]
+	_, ok := bundle.Config.Targets["default"]
 	assert.False(t, ok)
 }
diff --git a/bundle/config/mutator/default_workspace_root.go b/bundle/config/mutator/default_workspace_root.go
index bf51eda9e0..260a59584b 100644
--- a/bundle/config/mutator/default_workspace_root.go
+++ b/bundle/config/mutator/default_workspace_root.go
@@ -27,14 +27,14 @@ func (m *defineDefaultWorkspaceRoot) Apply(ctx context.Context, b *bundle.Bundle
 		return fmt.Errorf("unable to define default workspace root: bundle name not defined")
 	}
 
-	if b.Config.Bundle.Environment == "" {
-		return fmt.Errorf("unable to define default workspace root: bundle environment not selected")
+	if b.Config.Bundle.Target == "" {
+		return fmt.Errorf("unable to define default workspace root: bundle target not selected")
 	}
 
 	b.Config.Workspace.RootPath = fmt.Sprintf(
 		"~/.bundle/%s/%s",
 		b.Config.Bundle.Name,
-		b.Config.Bundle.Environment,
+		b.Config.Bundle.Target,
 	)
 	return nil
 }
diff --git a/bundle/config/mutator/default_workspace_root_test.go b/bundle/config/mutator/default_workspace_root_test.go
index 4a78e6e5c4..1822dca0f1 100644
--- a/bundle/config/mutator/default_workspace_root_test.go
+++ b/bundle/config/mutator/default_workspace_root_test.go
@@ -15,8 +15,8 @@ func TestDefaultWorkspaceRoot(t *testing.T) {
 	bundle := &bundle.Bundle{
 		Config: config.Root{
 			Bundle: config.Bundle{
-				Name:        "name",
-				Environment: "environment",
+				Name:   "name",
+				Target: "environment",
 			},
 		},
 	}
diff --git a/bundle/config/mutator/mutator.go b/bundle/config/mutator/mutator.go
index 058258c871..ff1f96f50e 100644
--- a/bundle/config/mutator/mutator.go
+++ b/bundle/config/mutator/mutator.go
@@ -7,11 +7,11 @@ import (
 func DefaultMutators() []bundle.Mutator {
 	return []bundle.Mutator{
 		ProcessRootIncludes(),
-		DefineDefaultEnvironment(),
+		DefineDefaultTarget(),
 		LoadGitDetails(),
 	}
 }
 
-func DefaultMutatorsForEnvironment(env string) []bundle.Mutator {
-	return append(DefaultMutators(), SelectEnvironment(env))
+func DefaultMutatorsForTarget(env string) []bundle.Mutator {
+	return append(DefaultMutators(), SelectTarget(env))
 }
diff --git a/bundle/config/mutator/override_compute.go b/bundle/config/mutator/override_compute.go
index ba3fd9940e..124392491d 100644
--- a/bundle/config/mutator/override_compute.go
+++ b/bundle/config/mutator/override_compute.go
@@ -35,7 +35,7 @@ func overrideJobCompute(j *resources.Job, compute string) {
 func (m *overrideCompute) Apply(ctx context.Context, b *bundle.Bundle) error {
 	if b.Config.Bundle.Mode != config.Development {
 		if b.Config.Bundle.ComputeID != "" {
-			return fmt.Errorf("cannot override compute for an environment that does not use 'mode: development'")
+			return fmt.Errorf("cannot override compute for an target that does not use 'mode: development'")
 		}
 		return nil
 	}
diff --git a/bundle/config/mutator/process_environment_mode.go b/bundle/config/mutator/process_target_mode.go
similarity index 89%
rename from bundle/config/mutator/process_environment_mode.go
rename to bundle/config/mutator/process_target_mode.go
index d20302347c..b5dc255981 100644
--- a/bundle/config/mutator/process_environment_mode.go
+++ b/bundle/config/mutator/process_target_mode.go
@@ -13,16 +13,16 @@ import (
 	"github.com/databricks/databricks-sdk-go/service/ml"
 )
 
-type processEnvironmentMode struct{}
+type processTargetMode struct{}
 
 const developmentConcurrentRuns = 4
 
-func ProcessEnvironmentMode() bundle.Mutator {
-	return &processEnvironmentMode{}
+func ProcessTargetMode() bundle.Mutator {
+	return &processTargetMode{}
 }
 
-func (m *processEnvironmentMode) Name() string {
-	return "ProcessEnvironmentMode"
+func (m *processTargetMode) Name() string {
+	return "ProcessTargetMode"
 }
 
 // Mark all resources as being for 'development' purposes, i.e.
@@ -110,14 +110,14 @@ func findIncorrectPath(b *bundle.Bundle, mode config.Mode) string {
 
 func validateProductionMode(ctx context.Context, b *bundle.Bundle, isPrincipalUsed bool) error {
 	if b.Config.Bundle.Git.Inferred {
-		env := b.Config.Bundle.Environment
-		return fmt.Errorf("environment with 'mode: production' must specify an explicit 'environments.%s.git' configuration", env)
+		env := b.Config.Bundle.Target
+		return fmt.Errorf("target with 'mode: production' must specify an explicit 'targets.%s.git' configuration", env)
 	}
 
 	r := b.Config.Resources
 	for i := range r.Pipelines {
 		if r.Pipelines[i].Development {
-			return fmt.Errorf("environment with 'mode: production' cannot specify a pipeline with 'development: true'")
+			return fmt.Errorf("target with 'mode: production' cannot specify a pipeline with 'development: true'")
 		}
 	}
 
@@ -125,7 +125,7 @@ func validateProductionMode(ctx context.Context, b *bundle.Bundle, isPrincipalUs
 		if path := findIncorrectPath(b, config.Production); path != "" {
 			message := "%s must not contain the current username when using 'mode: production'"
 			if path == "root_path" {
-				return fmt.Errorf(message+"\n  tip: set workspace.root_path to a shared path such as /Shared/.bundle/${bundle.name}/${bundle.environment}", path)
+				return fmt.Errorf(message+"\n  tip: set workspace.root_path to a shared path such as /Shared/.bundle/${bundle.name}/${bundle.target}", path)
 			} else {
 				return fmt.Errorf(message, path)
 			}
@@ -165,7 +165,7 @@ func isRunAsSet(r config.Resources) bool {
 	return true
 }
 
-func (m *processEnvironmentMode) Apply(ctx context.Context, b *bundle.Bundle) error {
+func (m *processTargetMode) Apply(ctx context.Context, b *bundle.Bundle) error {
 	switch b.Config.Bundle.Mode {
 	case config.Development:
 		err := validateDevelopmentMode(b)
diff --git a/bundle/config/mutator/process_environment_mode_test.go b/bundle/config/mutator/process_target_mode_test.go
similarity index 90%
rename from bundle/config/mutator/process_environment_mode_test.go
rename to bundle/config/mutator/process_target_mode_test.go
index 36e0396e2d..76db64dee6 100644
--- a/bundle/config/mutator/process_environment_mode_test.go
+++ b/bundle/config/mutator/process_target_mode_test.go
@@ -58,10 +58,10 @@ func mockBundle(mode config.Mode) *bundle.Bundle {
 	}
 }
 
-func TestProcessEnvironmentModeDevelopment(t *testing.T) {
+func TestProcessTargetModeDevelopment(t *testing.T) {
 	bundle := mockBundle(config.Development)
 
-	m := ProcessEnvironmentMode()
+	m := ProcessTargetMode()
 	err := m.Apply(context.Background(), bundle)
 	require.NoError(t, err)
 	assert.Equal(t, "[dev lennart] job1", bundle.Config.Resources.Jobs["job1"].Name)
@@ -73,10 +73,10 @@ func TestProcessEnvironmentModeDevelopment(t *testing.T) {
 	assert.True(t, bundle.Config.Resources.Pipelines["pipeline1"].PipelineSpec.Development)
 }
 
-func TestProcessEnvironmentModeDefault(t *testing.T) {
+func TestProcessTargetModeDefault(t *testing.T) {
 	bundle := mockBundle("")
 
-	m := ProcessEnvironmentMode()
+	m := ProcessTargetMode()
 	err := m.Apply(context.Background(), bundle)
 	require.NoError(t, err)
 	assert.Equal(t, "job1", bundle.Config.Resources.Jobs["job1"].Name)
@@ -84,7 +84,7 @@ func TestProcessEnvironmentModeDefault(t *testing.T) {
 	assert.False(t, bundle.Config.Resources.Pipelines["pipeline1"].PipelineSpec.Development)
 }
 
-func TestProcessEnvironmentModeProduction(t *testing.T) {
+func TestProcessTargetModeProduction(t *testing.T) {
 	bundle := mockBundle(config.Production)
 
 	err := validateProductionMode(context.Background(), bundle, false)
@@ -118,7 +118,7 @@ func TestProcessEnvironmentModeProduction(t *testing.T) {
 	assert.False(t, bundle.Config.Resources.Pipelines["pipeline1"].PipelineSpec.Development)
 }
 
-func TestProcessEnvironmentModeProductionGit(t *testing.T) {
+func TestProcessTargetModeProductionGit(t *testing.T) {
 	bundle := mockBundle(config.Production)
 
 	// Pretend the user didn't set Git configuration explicitly
@@ -129,10 +129,10 @@ func TestProcessEnvironmentModeProductionGit(t *testing.T) {
 	bundle.Config.Bundle.Git.Inferred = false
 }
 
-func TestProcessEnvironmentModeProductionOkForPrincipal(t *testing.T) {
+func TestProcessTargetModeProductionOkForPrincipal(t *testing.T) {
 	bundle := mockBundle(config.Production)
 
-	// Our environment has all kinds of problems when not using service principals ...
+	// Our target has all kinds of problems when not using service principals ...
 	err := validateProductionMode(context.Background(), bundle, false)
 	require.Error(t, err)
 
@@ -152,7 +152,7 @@ func TestAllResourcesMocked(t *testing.T) {
 			assert.True(
 				t,
 				!field.IsNil() && field.Len() > 0,
-				"process_environment_mode should support '%s' (please add it to process_environment_mode.go and extend the test suite)",
+				"process_target_mode should support '%s' (please add it to process_target_mode.go and extend the test suite)",
 				resources.Type().Field(i).Name,
 			)
 		}
@@ -164,7 +164,7 @@ func TestAllResourcesRenamed(t *testing.T) {
 	bundle := mockBundle(config.Development)
 	resources := reflect.ValueOf(bundle.Config.Resources)
 
-	m := ProcessEnvironmentMode()
+	m := ProcessTargetMode()
 	err := m.Apply(context.Background(), bundle)
 	require.NoError(t, err)
 
@@ -179,7 +179,7 @@ func TestAllResourcesRenamed(t *testing.T) {
 					assert.True(
 						t,
 						strings.Contains(nameField.String(), "dev"),
-						"process_environment_mode should rename '%s' in '%s'",
+						"process_target_mode should rename '%s' in '%s'",
 						key,
 						resources.Type().Field(i).Name,
 					)
diff --git a/bundle/config/mutator/select_default_environment.go b/bundle/config/mutator/select_default_environment.go
deleted file mode 100644
index 0ed1d2db93..0000000000
--- a/bundle/config/mutator/select_default_environment.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package mutator
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/databricks/cli/bundle"
-	"golang.org/x/exp/maps"
-)
-
-type selectDefaultEnvironment struct{}
-
-// SelectDefaultEnvironment merges the default environment into the root configuration.
-func SelectDefaultEnvironment() bundle.Mutator {
-	return &selectDefaultEnvironment{}
-}
-
-func (m *selectDefaultEnvironment) Name() string {
-	return "SelectDefaultEnvironment"
-}
-
-func (m *selectDefaultEnvironment) Apply(ctx context.Context, b *bundle.Bundle) error {
-	if len(b.Config.Environments) == 0 {
-		return fmt.Errorf("no environments defined")
-	}
-
-	// One environment means there's only one default.
-	names := maps.Keys(b.Config.Environments)
-	if len(names) == 1 {
-		return SelectEnvironment(names[0]).Apply(ctx, b)
-	}
-
-	// Multiple environments means we look for the `default` flag.
-	var defaults []string
-	for name, env := range b.Config.Environments {
-		if env != nil && env.Default {
-			defaults = append(defaults, name)
-		}
-	}
-
-	// It is invalid to have multiple environments with the `default` flag set.
-	if len(defaults) > 1 {
-		return fmt.Errorf("multiple environments are marked as default (%s)", strings.Join(defaults, ", "))
-	}
-
-	// If no environment has the `default` flag set, ask the user to specify one.
-	if len(defaults) == 0 {
-		return fmt.Errorf("please specify environment")
-	}
-
-	// One default remaining.
-	return SelectEnvironment(defaults[0]).Apply(ctx, b)
-}
diff --git a/bundle/config/mutator/select_default_environment_test.go b/bundle/config/mutator/select_default_environment_test.go
deleted file mode 100644
index cc8f9c01dc..0000000000
--- a/bundle/config/mutator/select_default_environment_test.go
+++ /dev/null
@@ -1,90 +0,0 @@
-package mutator_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/databricks/cli/bundle"
-	"github.com/databricks/cli/bundle/config"
-	"github.com/databricks/cli/bundle/config/mutator"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSelectDefaultEnvironmentNoEnvironments(t *testing.T) {
-	bundle := &bundle.Bundle{
-		Config: config.Root{
-			Environments: map[string]*config.Environment{},
-		},
-	}
-	err := mutator.SelectDefaultEnvironment().Apply(context.Background(), bundle)
-	assert.ErrorContains(t, err, "no environments defined")
-}
-
-func TestSelectDefaultEnvironmentSingleEnvironments(t *testing.T) {
-	bundle := &bundle.Bundle{
-		Config: config.Root{
-			Environments: map[string]*config.Environment{
-				"foo": {},
-			},
-		},
-	}
-	err := mutator.SelectDefaultEnvironment().Apply(context.Background(), bundle)
-	assert.NoError(t, err)
-	assert.Equal(t, "foo", bundle.Config.Bundle.Environment)
-}
-
-func TestSelectDefaultEnvironmentNoDefaults(t *testing.T) {
-	bundle := &bundle.Bundle{
-		Config: config.Root{
-			Environments: map[string]*config.Environment{
-				"foo": {},
-				"bar": {},
-				"qux": {},
-			},
-		},
-	}
-	err := mutator.SelectDefaultEnvironment().Apply(context.Background(), bundle)
-	assert.ErrorContains(t, err, "please specify environment")
-}
-
-func TestSelectDefaultEnvironmentNoDefaultsWithNil(t *testing.T) {
-	bundle := &bundle.Bundle{
-		Config: config.Root{
-			Environments: map[string]*config.Environment{
-				"foo": nil,
-				"bar": nil,
-			},
-		},
-	}
-	err := mutator.SelectDefaultEnvironment().Apply(context.Background(), bundle)
-	assert.ErrorContains(t, err, "please specify environment")
-}
-
-func TestSelectDefaultEnvironmentMultipleDefaults(t *testing.T) {
-	bundle := &bundle.Bundle{
-		Config: config.Root{
-			Environments: map[string]*config.Environment{
-				"foo": {Default: true},
-				"bar": {Default: true},
-				"qux": {Default: true},
-			},
-		},
-	}
-	err := mutator.SelectDefaultEnvironment().Apply(context.Background(), bundle)
-	assert.ErrorContains(t, err, "multiple environments are marked as default")
-}
-
-func TestSelectDefaultEnvironmentSingleDefault(t *testing.T) {
-	bundle := &bundle.Bundle{
-		Config: config.Root{
-			Environments: map[string]*config.Environment{
-				"foo": {},
-				"bar": {Default: true},
-				"qux": {},
-			},
-		},
-	}
-	err := mutator.SelectDefaultEnvironment().Apply(context.Background(), bundle)
-	assert.NoError(t, err)
-	assert.Equal(t, "bar", bundle.Config.Bundle.Environment)
-}
diff --git a/bundle/config/mutator/select_default_target.go b/bundle/config/mutator/select_default_target.go
new file mode 100644
index 0000000000..8abcfe4ff2
--- /dev/null
+++ b/bundle/config/mutator/select_default_target.go
@@ -0,0 +1,54 @@
+package mutator
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/databricks/cli/bundle"
+	"golang.org/x/exp/maps"
+)
+
+type selectDefaultTarget struct{}
+
+// SelectDefaultTarget merges the default target into the root configuration.
+func SelectDefaultTarget() bundle.Mutator {
+	return &selectDefaultTarget{}
+}
+
+func (m *selectDefaultTarget) Name() string {
+	return "SelectDefaultTarget"
+}
+
+func (m *selectDefaultTarget) Apply(ctx context.Context, b *bundle.Bundle) error {
+	if len(b.Config.Targets) == 0 {
+		return fmt.Errorf("no targets defined")
+	}
+
+	// One target means there's only one default.
+	names := maps.Keys(b.Config.Targets)
+	if len(names) == 1 {
+		return SelectTarget(names[0]).Apply(ctx, b)
+	}
+
+	// Multiple targets means we look for the `default` flag.
+	var defaults []string
+	for name, env := range b.Config.Targets {
+		if env != nil && env.Default {
+			defaults = append(defaults, name)
+		}
+	}
+
+	// It is invalid to have multiple targets with the `default` flag set.
+	if len(defaults) > 1 {
+		return fmt.Errorf("multiple targets are marked as default (%s)", strings.Join(defaults, ", "))
+	}
+
+	// If no target has the `default` flag set, ask the user to specify one.
+	if len(defaults) == 0 {
+		return fmt.Errorf("please specify target")
+	}
+
+	// One default remaining.
+	return SelectTarget(defaults[0]).Apply(ctx, b)
+}
diff --git a/bundle/config/mutator/select_default_target_test.go b/bundle/config/mutator/select_default_target_test.go
new file mode 100644
index 0000000000..5d7b93b283
--- /dev/null
+++ b/bundle/config/mutator/select_default_target_test.go
@@ -0,0 +1,90 @@
+package mutator_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/databricks/cli/bundle"
+	"github.com/databricks/cli/bundle/config"
+	"github.com/databricks/cli/bundle/config/mutator"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSelectDefaultTargetNoTargets(t *testing.T) {
+	bundle := &bundle.Bundle{
+		Config: config.Root{
+			Targets: map[string]*config.Target{},
+		},
+	}
+	err := mutator.SelectDefaultTarget().Apply(context.Background(), bundle)
+	assert.ErrorContains(t, err, "no targets defined")
+}
+
+func TestSelectDefaultTargetSingleTargets(t *testing.T) {
+	bundle := &bundle.Bundle{
+		Config: config.Root{
+			Targets: map[string]*config.Target{
+				"foo": {},
+			},
+		},
+	}
+	err := mutator.SelectDefaultTarget().Apply(context.Background(), bundle)
+	assert.NoError(t, err)
+	assert.Equal(t, "foo", bundle.Config.Bundle.Target)
+}
+
+func TestSelectDefaultTargetNoDefaults(t *testing.T) {
+	bundle := &bundle.Bundle{
+		Config: config.Root{
+			Targets: map[string]*config.Target{
+				"foo": {},
+				"bar": {},
+				"qux": {},
+			},
+		},
+	}
+	err := mutator.SelectDefaultTarget().Apply(context.Background(), bundle)
+	assert.ErrorContains(t, err, "please specify target")
+}
+
+func TestSelectDefaultTargetNoDefaultsWithNil(t *testing.T) {
+	bundle := &bundle.Bundle{
+		Config: config.Root{
+			Targets: map[string]*config.Target{
+				"foo": nil,
+				"bar": nil,
+			},
+		},
+	}
+	err := mutator.SelectDefaultTarget().Apply(context.Background(), bundle)
+	assert.ErrorContains(t, err, "please specify target")
+}
+
+func TestSelectDefaultTargetMultipleDefaults(t *testing.T) {
+	bundle := &bundle.Bundle{
+		Config: config.Root{
+			Targets: map[string]*config.Target{
+				"foo": {Default: true},
+				"bar": {Default: true},
+				"qux": {Default: true},
+			},
+		},
+	}
+	err := mutator.SelectDefaultTarget().Apply(context.Background(), bundle)
+	assert.ErrorContains(t, err, "multiple targets are marked as default")
+}
+
+func TestSelectDefaultTargetSingleDefault(t *testing.T) {
+	bundle := &bundle.Bundle{
+		Config: config.Root{
+			Targets: map[string]*config.Target{
+				"foo": {},
+				"bar": {Default: true},
+				"qux": {},
+			},
+		},
+	}
+	err := mutator.SelectDefaultTarget().Apply(context.Background(), bundle)
+	assert.NoError(t, err)
+	assert.Equal(t, "bar", bundle.Config.Bundle.Target)
+}
diff --git a/bundle/config/mutator/select_environment.go b/bundle/config/mutator/select_environment.go
deleted file mode 100644
index 6ced66e869..0000000000
--- a/bundle/config/mutator/select_environment.go
+++ /dev/null
@@ -1,48 +0,0 @@
-package mutator
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/databricks/cli/bundle"
-)
-
-type selectEnvironment struct {
-	name string
-}
-
-// SelectEnvironment merges the specified environment into the root configuration.
-func SelectEnvironment(name string) bundle.Mutator {
-	return &selectEnvironment{
-		name: name,
-	}
-}
-
-func (m *selectEnvironment) Name() string {
-	return fmt.Sprintf("SelectEnvironment(%s)", m.name)
-}
-
-func (m *selectEnvironment) Apply(_ context.Context, b *bundle.Bundle) error {
-	if b.Config.Environments == nil {
-		return fmt.Errorf("no environments defined")
-	}
-
-	// Get specified environment
-	env, ok := b.Config.Environments[m.name]
-	if !ok {
-		return fmt.Errorf("%s: no such environment", m.name)
-	}
-
-	// Merge specified environment into root configuration structure.
-	err := b.Config.MergeEnvironment(env)
-	if err != nil {
-		return err
-	}
-
-	// Store specified environment in configuration for reference.
-	b.Config.Bundle.Environment = m.name
-
-	// Clear environments after loading.
-	b.Config.Environments = nil
-	return nil
-}
diff --git a/bundle/config/mutator/select_target.go b/bundle/config/mutator/select_target.go
new file mode 100644
index 0000000000..59e780fb3d
--- /dev/null
+++ b/bundle/config/mutator/select_target.go
@@ -0,0 +1,54 @@
+package mutator
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/databricks/cli/bundle"
+)
+
+type selectTarget struct {
+	name string
+}
+
+// SelectTarget merges the specified target into the root configuration.
+func SelectTarget(name string) bundle.Mutator {
+	return &selectTarget{
+		name: name,
+	}
+}
+
+func (m *selectTarget) Name() string {
+	return fmt.Sprintf("SelectTarget(%s)", m.name)
+}
+
+func (m *selectTarget) Apply(_ context.Context, b *bundle.Bundle) error {
+	if b.Config.Targets == nil {
+		return fmt.Errorf("no targets defined")
+	}
+
+	// Get specified target
+	env, ok := b.Config.Targets[m.name]
+	if !ok {
+		return fmt.Errorf("%s: no such target", m.name)
+	}
+
+	// Merge specified target into root configuration structure.
+	err := b.Config.MergeTarget(env)
+	if err != nil {
+		return err
+	}
+
+	// Store specified target in configuration for reference.
+	b.Config.Bundle.Target = m.name
+
+	// We do this for backward compatibility.
+	// TODO: remove when Environments section is not supported anymore.
+	b.Config.Bundle.Environment = b.Config.Bundle.Target
+
+	// Clear targets after loading.
+	b.Config.Targets = nil
+	b.Config.Environments = nil
+
+	return nil
+}
diff --git a/bundle/config/mutator/select_environment_test.go b/bundle/config/mutator/select_target_test.go
similarity index 62%
rename from bundle/config/mutator/select_environment_test.go
rename to bundle/config/mutator/select_target_test.go
index 73b3a78933..dfcd8cb089 100644
--- a/bundle/config/mutator/select_environment_test.go
+++ b/bundle/config/mutator/select_target_test.go
@@ -11,13 +11,13 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestSelectEnvironment(t *testing.T) {
+func TestSelectTarget(t *testing.T) {
 	bundle := &bundle.Bundle{
 		Config: config.Root{
 			Workspace: config.Workspace{
 				Host: "foo",
 			},
-			Environments: map[string]*config.Environment{
+			Targets: map[string]*config.Target{
 				"default": {
 					Workspace: &config.Workspace{
 						Host: "bar",
@@ -26,19 +26,19 @@ func TestSelectEnvironment(t *testing.T) {
 			},
 		},
 	}
-	err := mutator.SelectEnvironment("default").Apply(context.Background(), bundle)
+	err := mutator.SelectTarget("default").Apply(context.Background(), bundle)
 	require.NoError(t, err)
 	assert.Equal(t, "bar", bundle.Config.Workspace.Host)
 }
 
-func TestSelectEnvironmentNotFound(t *testing.T) {
+func TestSelectTargetNotFound(t *testing.T) {
 	bundle := &bundle.Bundle{
 		Config: config.Root{
-			Environments: map[string]*config.Environment{
+			Targets: map[string]*config.Target{
 				"default": {},
 			},
 		},
 	}
-	err := mutator.SelectEnvironment("doesnt-exist").Apply(context.Background(), bundle)
-	require.Error(t, err, "no environments defined")
+	err := mutator.SelectTarget("doesnt-exist").Apply(context.Background(), bundle)
+	require.Error(t, err, "no targets defined")
 }
diff --git a/bundle/config/resources.go b/bundle/config/resources.go
index b15158b45a..5d47b918cd 100644
--- a/bundle/config/resources.go
+++ b/bundle/config/resources.go
@@ -115,7 +115,7 @@ func (r *Resources) SetConfigFilePath(path string) {
 }
 
 // MergeJobClusters iterates over all jobs and merges their job clusters.
-// This is called after applying the environment overrides.
+// This is called after applying the target overrides.
 func (r *Resources) MergeJobClusters() error {
 	for _, job := range r.Jobs {
 		if err := job.MergeJobClusters(); err != nil {
diff --git a/bundle/config/resources/job.go b/bundle/config/resources/job.go
index 327d7e13e6..6200062a80 100644
--- a/bundle/config/resources/job.go
+++ b/bundle/config/resources/job.go
@@ -22,7 +22,7 @@ func (j *Job) MergeJobClusters() error {
 	keys := make(map[string]*jobs.JobCluster)
 	output := make([]jobs.JobCluster, 0, len(j.JobClusters))
 
-	// Environment overrides are always appended, so we can iterate in natural order to
+	// Target overrides are always appended, so we can iterate in natural order to
 	// first find the base definition, and merge instances we encounter later.
 	for i := range j.JobClusters {
 		key := j.JobClusters[i].JobClusterKey
diff --git a/bundle/config/root.go b/bundle/config/root.go
index b6d1efc96b..cddf25d85b 100644
--- a/bundle/config/root.go
+++ b/bundle/config/root.go
@@ -69,11 +69,14 @@ type Root struct {
 	// to deploy in this bundle (e.g. jobs, pipelines, etc.).
 	Resources Resources `json:"resources,omitempty"`
 
-	// Environments can be used to differentiate settings and resources between
-	// bundle deployment environments (e.g. development, staging, production).
+	// Targets can be used to differentiate settings and resources between
+	// bundle deployment targets (e.g. development, staging, production).
 	// If not specified, the code below initializes this field with a
-	// single default-initialized environment called "default".
-	Environments map[string]*Environment `json:"environments,omitempty"`
+	// single default-initialized target called "default".
+	Targets map[string]*Target `json:"targets,omitempty"`
+
+	// DEPRECATED. Left for backward compatibility with Targets
+	Environments map[string]*Target `json:"environments,omitempty"`
 }
 
 func Load(path string) (*Root, error) {
@@ -103,8 +106,8 @@ func Load(path string) (*Root, error) {
 // was loaded from in configuration leafs that require it.
 func (r *Root) SetConfigFilePath(path string) {
 	r.Resources.SetConfigFilePath(path)
-	if r.Environments != nil {
-		for _, env := range r.Environments {
+	if r.Targets != nil {
+		for _, env := range r.Targets {
 			if env == nil {
 				continue
 			}
@@ -148,6 +151,20 @@ func (r *Root) Load(path string) error {
 		return fmt.Errorf("failed to load %s: %w", path, err)
 	}
 
+	if r.Environments != nil {
+		//TODO: add a command line notice that this is a deprecated option.
+		r.Targets = r.Environments
+	}
+
+	if r.Bundle.Environment != "" {
+		//TODO: add a command line notice that this is a deprecated option.
+		r.Bundle.Target = r.Bundle.Environment
+	}
+
+	// We do this for backward compatibility so ${bundle.environment} works correctly.
+	// TODO: remove when Environments section is not supported anymore.
+	r.Bundle.Environment = r.Bundle.Target
+
 	r.Path = filepath.Dir(path)
 	r.SetConfigFilePath(path)
 
@@ -169,37 +186,37 @@ func (r *Root) Merge(other *Root) error {
 	return mergo.Merge(r, other, mergo.WithOverride)
 }
 
-func (r *Root) MergeEnvironment(env *Environment) error {
+func (r *Root) MergeTarget(target *Target) error {
 	var err error
 
-	// Environment may be nil if it's empty.
-	if env == nil {
+	// Target may be nil if it's empty.
+	if target == nil {
 		return nil
 	}
 
-	if env.Bundle != nil {
-		err = mergo.Merge(&r.Bundle, env.Bundle, mergo.WithOverride)
+	if target.Bundle != nil {
+		err = mergo.Merge(&r.Bundle, target.Bundle, mergo.WithOverride)
 		if err != nil {
 			return err
 		}
 	}
 
-	if env.Workspace != nil {
-		err = mergo.Merge(&r.Workspace, env.Workspace, mergo.WithOverride)
+	if target.Workspace != nil {
+		err = mergo.Merge(&r.Workspace, target.Workspace, mergo.WithOverride)
 		if err != nil {
 			return err
 		}
 	}
 
-	if env.Artifacts != nil {
-		err = mergo.Merge(&r.Artifacts, env.Artifacts, mergo.WithOverride, mergo.WithAppendSlice)
+	if target.Artifacts != nil {
+		err = mergo.Merge(&r.Artifacts, target.Artifacts, mergo.WithOverride, mergo.WithAppendSlice)
 		if err != nil {
 			return err
 		}
 	}
 
-	if env.Resources != nil {
-		err = mergo.Merge(&r.Resources, env.Resources, mergo.WithOverride, mergo.WithAppendSlice)
+	if target.Resources != nil {
+		err = mergo.Merge(&r.Resources, target.Resources, mergo.WithOverride, mergo.WithAppendSlice)
 		if err != nil {
 			return err
 		}
@@ -210,8 +227,8 @@ func (r *Root) MergeEnvironment(env *Environment) error {
 		}
 	}
 
-	if env.Variables != nil {
-		for k, v := range env.Variables {
+	if target.Variables != nil {
+		for k, v := range target.Variables {
 			variable, ok := r.Variables[k]
 			if !ok {
 				return fmt.Errorf("variable %s is not defined but is assigned a value", k)
@@ -222,24 +239,24 @@ func (r *Root) MergeEnvironment(env *Environment) error {
 		}
 	}
 
-	if env.Mode != "" {
-		r.Bundle.Mode = env.Mode
+	if target.Mode != "" {
+		r.Bundle.Mode = target.Mode
 	}
 
-	if env.ComputeID != "" {
-		r.Bundle.ComputeID = env.ComputeID
+	if target.ComputeID != "" {
+		r.Bundle.ComputeID = target.ComputeID
 	}
 
 	git := &r.Bundle.Git
-	if env.Git.Branch != "" {
-		git.Branch = env.Git.Branch
+	if target.Git.Branch != "" {
+		git.Branch = target.Git.Branch
 		git.Inferred = false
 	}
-	if env.Git.Commit != "" {
-		git.Commit = env.Git.Commit
+	if target.Git.Commit != "" {
+		git.Commit = target.Git.Commit
 	}
-	if env.Git.OriginURL != "" {
-		git.OriginURL = env.Git.OriginURL
+	if target.Git.OriginURL != "" {
+		git.OriginURL = target.Git.OriginURL
 	}
 
 	return nil
diff --git a/bundle/config/root_test.go b/bundle/config/root_test.go
index 531ffcec1d..f8ba8d47a7 100644
--- a/bundle/config/root_test.go
+++ b/bundle/config/root_test.go
@@ -57,7 +57,7 @@ func TestRootMergeStruct(t *testing.T) {
 func TestRootMergeMap(t *testing.T) {
 	root := &Root{
 		Path: "path",
-		Environments: map[string]*Environment{
+		Targets: map[string]*Target{
 			"development": {
 				Workspace: &Workspace{
 					Host:    "foo",
@@ -68,7 +68,7 @@ func TestRootMergeMap(t *testing.T) {
 	}
 	other := &Root{
 		Path: "path",
-		Environments: map[string]*Environment{
+		Targets: map[string]*Target{
 			"development": {
 				Workspace: &Workspace{
 					Host: "bar",
@@ -77,7 +77,7 @@ func TestRootMergeMap(t *testing.T) {
 		},
 	}
 	assert.NoError(t, root.Merge(other))
-	assert.Equal(t, &Workspace{Host: "bar", Profile: "profile"}, root.Environments["development"].Workspace)
+	assert.Equal(t, &Workspace{Host: "bar", Profile: "profile"}, root.Targets["development"].Workspace)
 }
 
 func TestDuplicateIdOnLoadReturnsError(t *testing.T) {
@@ -159,12 +159,12 @@ func TestInitializeVariablesUndefinedVariables(t *testing.T) {
 	assert.ErrorContains(t, err, "variable bar has not been defined")
 }
 
-func TestRootMergeEnvironmentWithMode(t *testing.T) {
+func TestRootMergeTargetWithMode(t *testing.T) {
 	root := &Root{
 		Bundle: Bundle{},
 	}
-	env := &Environment{Mode: Development}
-	require.NoError(t, root.MergeEnvironment(env))
+	env := &Target{Mode: Development}
+	require.NoError(t, root.MergeTarget(env))
 	assert.Equal(t, Development, root.Bundle.Mode)
 }
 
diff --git a/bundle/config/variable/variable.go b/bundle/config/variable/variable.go
index 132920bb97..73925d432e 100644
--- a/bundle/config/variable/variable.go
+++ b/bundle/config/variable/variable.go
@@ -18,7 +18,7 @@ type Variable struct {
 	// resolved in the following priority order (from highest to lowest)
 	//
 	// 1. Command line flag. For example: `--var="foo=bar"`
-	// 2. Environment variable. eg: BUNDLE_VAR_foo=bar
+	// 2. Target variable. eg: BUNDLE_VAR_foo=bar
 	// 3. Default value as defined in the applicable environments block
 	// 4. Default value defined in variable definition
 	// 5. Throw error, since if no default value is defined, then the variable
diff --git a/bundle/config/workspace.go b/bundle/config/workspace.go
index bd116a9cb0..90cd59c6f3 100644
--- a/bundle/config/workspace.go
+++ b/bundle/config/workspace.go
@@ -45,7 +45,7 @@ type Workspace struct {
 	CurrentUser *User `json:"current_user,omitempty" bundle:"readonly"`
 
 	// Remote workspace base path for deployment state, for artifacts, as synchronization target.
-	// This defaults to "~/.bundle/${bundle.name}/${bundle.environment}" where "~" expands to
+	// This defaults to "~/.bundle/${bundle.name}/${bundle.target}" where "~" expands to
 	// the current user's home directory in the workspace (e.g. `/Users/jane@doe.com`).
 	RootPath string `json:"root_path,omitempty"`
 
diff --git a/bundle/deploy/terraform/init_test.go b/bundle/deploy/terraform/init_test.go
index 79e18170ef..5bb5929e63 100644
--- a/bundle/deploy/terraform/init_test.go
+++ b/bundle/deploy/terraform/init_test.go
@@ -31,7 +31,7 @@ func TestInitEnvironmentVariables(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 				Terraform: &config.Terraform{
 					ExecPath: "terraform",
 				},
@@ -58,7 +58,7 @@ func TestSetTempDirEnvVarsForUnixWithTmpDirSet(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
@@ -86,7 +86,7 @@ func TestSetTempDirEnvVarsForUnixWithTmpDirNotSet(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
@@ -112,7 +112,7 @@ func TestSetTempDirEnvVarsForWindowWithAllTmpDirEnvVarsSet(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
@@ -142,7 +142,7 @@ func TestSetTempDirEnvVarsForWindowWithUserProfileAndTempSet(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
@@ -172,7 +172,7 @@ func TestSetTempDirEnvVarsForWindowWithUserProfileSet(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
@@ -202,7 +202,7 @@ func TestSetTempDirEnvVarsForWindowsWithoutAnyTempDirEnvVarsSet(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
@@ -230,7 +230,7 @@ func TestSetProxyEnvVars(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 			},
 		},
 	}
diff --git a/bundle/deploy/terraform/load_test.go b/bundle/deploy/terraform/load_test.go
index c235c08e8f..1937ca8a26 100644
--- a/bundle/deploy/terraform/load_test.go
+++ b/bundle/deploy/terraform/load_test.go
@@ -20,7 +20,7 @@ func TestLoadWithNoState(t *testing.T) {
 		Config: config.Root{
 			Path: t.TempDir(),
 			Bundle: config.Bundle{
-				Environment: "whatever",
+				Target: "whatever",
 				Terraform: &config.Terraform{
 					ExecPath: "terraform",
 				},
diff --git a/bundle/phases/initialize.go b/bundle/phases/initialize.go
index fc5056f633..219ec26cf9 100644
--- a/bundle/phases/initialize.go
+++ b/bundle/phases/initialize.go
@@ -26,7 +26,7 @@ func Initialize() bundle.Mutator {
 				interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
 			),
 			mutator.OverrideCompute(),
-			mutator.ProcessEnvironmentMode(),
+			mutator.ProcessTargetMode(),
 			mutator.TranslatePaths(),
 			terraform.Initialize(),
 		},
diff --git a/bundle/schema/docs.go b/bundle/schema/docs.go
index 5fcef4eddf..4b2fd36aef 100644
--- a/bundle/schema/docs.go
+++ b/bundle/schema/docs.go
@@ -52,20 +52,20 @@ func BundleDocs(openapiSpecPath string) (*Docs, error) {
 		}
 		docs.Properties["resources"] = schemaToDocs(resourceSchema)
 	}
-	docs.refreshEnvironmentsDocs()
+	docs.refreshTargetsDocs()
 	return docs, nil
 }
 
-func (docs *Docs) refreshEnvironmentsDocs() error {
-	environmentsDocs, ok := docs.Properties["environments"]
-	if !ok || environmentsDocs.AdditionalProperties == nil ||
-		environmentsDocs.AdditionalProperties.Properties == nil {
-		return fmt.Errorf("invalid environments descriptions")
+func (docs *Docs) refreshTargetsDocs() error {
+	targetsDocs, ok := docs.Properties["targets"]
+	if !ok || targetsDocs.AdditionalProperties == nil ||
+		targetsDocs.AdditionalProperties.Properties == nil {
+		return fmt.Errorf("invalid targets descriptions")
 	}
-	environmentProperties := environmentsDocs.AdditionalProperties.Properties
+	targetProperties := targetsDocs.AdditionalProperties.Properties
 	propertiesToCopy := []string{"artifacts", "bundle", "resources", "workspace"}
 	for _, p := range propertiesToCopy {
-		environmentProperties[p] = docs.Properties[p]
+		targetProperties[p] = docs.Properties[p]
 	}
 	return nil
 }
diff --git a/bundle/tests/autoload_git/databricks.yml b/bundle/tests/autoload_git/databricks.yml
index ba4785aed0..92ab8d66a2 100644
--- a/bundle/tests/autoload_git/databricks.yml
+++ b/bundle/tests/autoload_git/databricks.yml
@@ -1,7 +1,7 @@
 bundle:
   name: autoload git config test
 
-environments:
+targets:
   development:
     default: true
 
diff --git a/bundle/tests/environment_empty/databricks.yml b/bundle/tests/environment_empty/databricks.yml
deleted file mode 100644
index 17c03c8dcb..0000000000
--- a/bundle/tests/environment_empty/databricks.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-bundle:
-  name: environment_empty
-
-environments:
-  development:
diff --git a/bundle/tests/environment_empty_test.go b/bundle/tests/environment_empty_test.go
deleted file mode 100644
index fb2e334166..0000000000
--- a/bundle/tests/environment_empty_test.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package config_tests
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestEnvironmentEmpty(t *testing.T) {
-	b := loadEnvironment(t, "./environment_empty", "development")
-	assert.Equal(t, "development", b.Config.Bundle.Environment)
-}
diff --git a/bundle/tests/environment_git_test.go b/bundle/tests/environment_git_test.go
new file mode 100644
index 0000000000..bb10825e4c
--- /dev/null
+++ b/bundle/tests/environment_git_test.go
@@ -0,0 +1,20 @@
+package config_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGitAutoLoadWithEnvironment(t *testing.T) {
+	b := load(t, "./environments_autoload_git")
+	assert.True(t, b.Config.Bundle.Git.Inferred)
+	assert.Contains(t, b.Config.Bundle.Git.OriginURL, "/cli")
+}
+
+func TestGitManuallySetBranchWithEnvironment(t *testing.T) {
+	b := loadTarget(t, "./environments_autoload_git", "production")
+	assert.False(t, b.Config.Bundle.Git.Inferred)
+	assert.Equal(t, "main", b.Config.Bundle.Git.Branch)
+	assert.Contains(t, b.Config.Bundle.Git.OriginURL, "/cli")
+}
diff --git a/bundle/tests/environment_overrides_test.go b/bundle/tests/environment_overrides_test.go
index 0a3f9fcd8e..91dc2c8114 100644
--- a/bundle/tests/environment_overrides_test.go
+++ b/bundle/tests/environment_overrides_test.go
@@ -7,17 +7,17 @@ import (
 )
 
 func TestEnvironmentOverridesWorkspaceDev(t *testing.T) {
-	b := loadEnvironment(t, "./environment_overrides/workspace", "development")
+	b := loadTarget(t, "./environment_overrides/workspace", "development")
 	assert.Equal(t, "https://development.acme.cloud.databricks.com/", b.Config.Workspace.Host)
 }
 
 func TestEnvironmentOverridesWorkspaceStaging(t *testing.T) {
-	b := loadEnvironment(t, "./environment_overrides/workspace", "staging")
+	b := loadTarget(t, "./environment_overrides/workspace", "staging")
 	assert.Equal(t, "https://staging.acme.cloud.databricks.com/", b.Config.Workspace.Host)
 }
 
 func TestEnvironmentOverridesResourcesDev(t *testing.T) {
-	b := loadEnvironment(t, "./environment_overrides/resources", "development")
+	b := loadTarget(t, "./environment_overrides/resources", "development")
 	assert.Equal(t, "base job", b.Config.Resources.Jobs["job1"].Name)
 
 	// Base values are preserved in the development environment.
@@ -26,7 +26,7 @@ func TestEnvironmentOverridesResourcesDev(t *testing.T) {
 }
 
 func TestEnvironmentOverridesResourcesStaging(t *testing.T) {
-	b := loadEnvironment(t, "./environment_overrides/resources", "staging")
+	b := loadTarget(t, "./environment_overrides/resources", "staging")
 	assert.Equal(t, "staging job", b.Config.Resources.Jobs["job1"].Name)
 
 	// Overrides are only applied if they are not zero-valued.
diff --git a/bundle/tests/environments_autoload_git/databricks.yml b/bundle/tests/environments_autoload_git/databricks.yml
new file mode 100644
index 0000000000..ba4785aed0
--- /dev/null
+++ b/bundle/tests/environments_autoload_git/databricks.yml
@@ -0,0 +1,11 @@
+bundle:
+  name: autoload git config test
+
+environments:
+  development:
+    default: true
+
+  production:
+    # production can only be deployed from the 'main' branch
+    git:
+      branch: main
diff --git a/bundle/tests/environments_job_and_pipeline/databricks.yml b/bundle/tests/environments_job_and_pipeline/databricks.yml
new file mode 100644
index 0000000000..e29fa03499
--- /dev/null
+++ b/bundle/tests/environments_job_and_pipeline/databricks.yml
@@ -0,0 +1,44 @@
+resources:
+  pipelines:
+    nyc_taxi_pipeline:
+      name: "nyc taxi loader"
+      libraries:
+        - notebook:
+            path: ./dlt/nyc_taxi_loader
+
+environments:
+  development:
+    mode: development
+    resources:
+      pipelines:
+        nyc_taxi_pipeline:
+          target: nyc_taxi_development
+          development: true
+
+  staging:
+    resources:
+      pipelines:
+        nyc_taxi_pipeline:
+          target: nyc_taxi_staging
+          development: false
+
+  production:
+    mode: production
+    resources:
+      pipelines:
+        nyc_taxi_pipeline:
+          target: nyc_taxi_production
+          development: false
+          photon: true
+
+      jobs:
+        pipeline_schedule:
+          name: Daily refresh of production pipeline
+
+          schedule:
+            quartz_cron_expression: 6 6 11 * * ?
+            timezone_id: UTC
+
+          tasks:
+            - pipeline_task:
+                pipeline_id: "to be interpolated"
diff --git a/bundle/tests/environments_job_and_pipeline_test.go b/bundle/tests/environments_job_and_pipeline_test.go
new file mode 100644
index 0000000000..a18daf90c8
--- /dev/null
+++ b/bundle/tests/environments_job_and_pipeline_test.go
@@ -0,0 +1,56 @@
+package config_tests
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/databricks/cli/bundle/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestJobAndPipelineDevelopmentWithEnvironment(t *testing.T) {
+	b := loadTarget(t, "./environments_job_and_pipeline", "development")
+	assert.Len(t, b.Config.Resources.Jobs, 0)
+	assert.Len(t, b.Config.Resources.Pipelines, 1)
+
+	p := b.Config.Resources.Pipelines["nyc_taxi_pipeline"]
+	assert.Equal(t, "environments_job_and_pipeline/databricks.yml", filepath.ToSlash(p.ConfigFilePath))
+	assert.Equal(t, b.Config.Bundle.Mode, config.Development)
+	assert.True(t, p.Development)
+	require.Len(t, p.Libraries, 1)
+	assert.Equal(t, "./dlt/nyc_taxi_loader", p.Libraries[0].Notebook.Path)
+	assert.Equal(t, "nyc_taxi_development", p.Target)
+}
+
+func TestJobAndPipelineStagingWithEnvironment(t *testing.T) {
+	b := loadTarget(t, "./environments_job_and_pipeline", "staging")
+	assert.Len(t, b.Config.Resources.Jobs, 0)
+	assert.Len(t, b.Config.Resources.Pipelines, 1)
+
+	p := b.Config.Resources.Pipelines["nyc_taxi_pipeline"]
+	assert.Equal(t, "environments_job_and_pipeline/databricks.yml", filepath.ToSlash(p.ConfigFilePath))
+	assert.False(t, p.Development)
+	require.Len(t, p.Libraries, 1)
+	assert.Equal(t, "./dlt/nyc_taxi_loader", p.Libraries[0].Notebook.Path)
+	assert.Equal(t, "nyc_taxi_staging", p.Target)
+}
+
+func TestJobAndPipelineProductionWithEnvironment(t *testing.T) {
+	b := loadTarget(t, "./environments_job_and_pipeline", "production")
+	assert.Len(t, b.Config.Resources.Jobs, 1)
+	assert.Len(t, b.Config.Resources.Pipelines, 1)
+
+	p := b.Config.Resources.Pipelines["nyc_taxi_pipeline"]
+	assert.Equal(t, "environments_job_and_pipeline/databricks.yml", filepath.ToSlash(p.ConfigFilePath))
+	assert.False(t, p.Development)
+	require.Len(t, p.Libraries, 1)
+	assert.Equal(t, "./dlt/nyc_taxi_loader", p.Libraries[0].Notebook.Path)
+	assert.Equal(t, "nyc_taxi_production", p.Target)
+
+	j := b.Config.Resources.Jobs["pipeline_schedule"]
+	assert.Equal(t, "environments_job_and_pipeline/databricks.yml", filepath.ToSlash(j.ConfigFilePath))
+	assert.Equal(t, "Daily refresh of production pipeline", j.Name)
+	require.Len(t, j.Tasks, 1)
+	assert.NotEmpty(t, j.Tasks[0].PipelineTask.PipelineId)
+}
diff --git a/bundle/tests/environments_override_job_cluster/databricks.yml b/bundle/tests/environments_override_job_cluster/databricks.yml
new file mode 100644
index 0000000000..33061b2e3d
--- /dev/null
+++ b/bundle/tests/environments_override_job_cluster/databricks.yml
@@ -0,0 +1,35 @@
+bundle:
+  name: override_job_cluster
+
+workspace:
+  host: https://acme.cloud.databricks.com/
+
+resources:
+  jobs:
+    foo:
+      name: job
+      job_clusters:
+        - job_cluster_key: key
+          new_cluster:
+            spark_version: 13.3.x-scala2.12
+
+environments:
+  development:
+    resources:
+      jobs:
+        foo:
+          job_clusters:
+            - job_cluster_key: key
+              new_cluster:
+                node_type_id: i3.xlarge
+                num_workers: 1
+
+  staging:
+    resources:
+      jobs:
+        foo:
+          job_clusters:
+            - job_cluster_key: key
+              new_cluster:
+                node_type_id: i3.2xlarge
+                num_workers: 4
diff --git a/bundle/tests/environments_override_job_cluster_test.go b/bundle/tests/environments_override_job_cluster_test.go
new file mode 100644
index 0000000000..b3ec74453e
--- /dev/null
+++ b/bundle/tests/environments_override_job_cluster_test.go
@@ -0,0 +1,29 @@
+package config_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOverrideJobClusterDevWithEnvironment(t *testing.T) {
+	b := loadTarget(t, "./environments_override_job_cluster", "development")
+	assert.Equal(t, "job", b.Config.Resources.Jobs["foo"].Name)
+	assert.Len(t, b.Config.Resources.Jobs["foo"].JobClusters, 1)
+
+	c := b.Config.Resources.Jobs["foo"].JobClusters[0]
+	assert.Equal(t, "13.3.x-scala2.12", c.NewCluster.SparkVersion)
+	assert.Equal(t, "i3.xlarge", c.NewCluster.NodeTypeId)
+	assert.Equal(t, 1, c.NewCluster.NumWorkers)
+}
+
+func TestOverrideJobClusterStagingWithEnvironment(t *testing.T) {
+	b := loadTarget(t, "./environments_override_job_cluster", "staging")
+	assert.Equal(t, "job", b.Config.Resources.Jobs["foo"].Name)
+	assert.Len(t, b.Config.Resources.Jobs["foo"].JobClusters, 1)
+
+	c := b.Config.Resources.Jobs["foo"].JobClusters[0]
+	assert.Equal(t, "13.3.x-scala2.12", c.NewCluster.SparkVersion)
+	assert.Equal(t, "i3.2xlarge", c.NewCluster.NodeTypeId)
+	assert.Equal(t, 4, c.NewCluster.NumWorkers)
+}
diff --git a/bundle/tests/git_test.go b/bundle/tests/git_test.go
index daab4d30a2..c5ae83a20c 100644
--- a/bundle/tests/git_test.go
+++ b/bundle/tests/git_test.go
@@ -17,7 +17,7 @@ func TestGitAutoLoad(t *testing.T) {
 }
 
 func TestGitManuallySetBranch(t *testing.T) {
-	b := loadEnvironment(t, "./autoload_git", "production")
+	b := loadTarget(t, "./autoload_git", "production")
 	assert.False(t, b.Config.Bundle.Git.Inferred)
 	assert.Equal(t, "main", b.Config.Bundle.Git.Branch)
 	assert.Contains(t, b.Config.Bundle.Git.OriginURL, "/cli")
diff --git a/bundle/tests/job_and_pipeline/databricks.yml b/bundle/tests/job_and_pipeline/databricks.yml
index e29fa03499..67d306ffe9 100644
--- a/bundle/tests/job_and_pipeline/databricks.yml
+++ b/bundle/tests/job_and_pipeline/databricks.yml
@@ -6,7 +6,7 @@ resources:
         - notebook:
             path: ./dlt/nyc_taxi_loader
 
-environments:
+targets:
   development:
     mode: development
     resources:
diff --git a/bundle/tests/job_and_pipeline_test.go b/bundle/tests/job_and_pipeline_test.go
index d92eabd3bd..5e8febc333 100644
--- a/bundle/tests/job_and_pipeline_test.go
+++ b/bundle/tests/job_and_pipeline_test.go
@@ -10,7 +10,7 @@ import (
 )
 
 func TestJobAndPipelineDevelopment(t *testing.T) {
-	b := loadEnvironment(t, "./job_and_pipeline", "development")
+	b := loadTarget(t, "./job_and_pipeline", "development")
 	assert.Len(t, b.Config.Resources.Jobs, 0)
 	assert.Len(t, b.Config.Resources.Pipelines, 1)
 
@@ -24,7 +24,7 @@ func TestJobAndPipelineDevelopment(t *testing.T) {
 }
 
 func TestJobAndPipelineStaging(t *testing.T) {
-	b := loadEnvironment(t, "./job_and_pipeline", "staging")
+	b := loadTarget(t, "./job_and_pipeline", "staging")
 	assert.Len(t, b.Config.Resources.Jobs, 0)
 	assert.Len(t, b.Config.Resources.Pipelines, 1)
 
@@ -37,7 +37,7 @@ func TestJobAndPipelineStaging(t *testing.T) {
 }
 
 func TestJobAndPipelineProduction(t *testing.T) {
-	b := loadEnvironment(t, "./job_and_pipeline", "production")
+	b := loadTarget(t, "./job_and_pipeline", "production")
 	assert.Len(t, b.Config.Resources.Jobs, 1)
 	assert.Len(t, b.Config.Resources.Pipelines, 1)
 
diff --git a/bundle/tests/loader.go b/bundle/tests/loader.go
index 056a82d918..f23b107649 100644
--- a/bundle/tests/loader.go
+++ b/bundle/tests/loader.go
@@ -18,9 +18,9 @@ func load(t *testing.T, path string) *bundle.Bundle {
 	return b
 }
 
-func loadEnvironment(t *testing.T, path, env string) *bundle.Bundle {
+func loadTarget(t *testing.T, path, env string) *bundle.Bundle {
 	b := load(t, path)
-	err := bundle.Apply(context.Background(), b, mutator.SelectEnvironment(env))
+	err := bundle.Apply(context.Background(), b, mutator.SelectTarget(env))
 	require.NoError(t, err)
 	return b
 }
diff --git a/bundle/tests/override_job_cluster/databricks.yml b/bundle/tests/override_job_cluster/databricks.yml
index 33061b2e3d..a85b3b7116 100644
--- a/bundle/tests/override_job_cluster/databricks.yml
+++ b/bundle/tests/override_job_cluster/databricks.yml
@@ -13,7 +13,7 @@ resources:
           new_cluster:
             spark_version: 13.3.x-scala2.12
 
-environments:
+targets:
   development:
     resources:
       jobs:
diff --git a/bundle/tests/override_job_cluster_test.go b/bundle/tests/override_job_cluster_test.go
index 97f7c04ee5..1393e03e5a 100644
--- a/bundle/tests/override_job_cluster_test.go
+++ b/bundle/tests/override_job_cluster_test.go
@@ -7,7 +7,7 @@ import (
 )
 
 func TestOverrideJobClusterDev(t *testing.T) {
-	b := loadEnvironment(t, "./override_job_cluster", "development")
+	b := loadTarget(t, "./override_job_cluster", "development")
 	assert.Equal(t, "job", b.Config.Resources.Jobs["foo"].Name)
 	assert.Len(t, b.Config.Resources.Jobs["foo"].JobClusters, 1)
 
@@ -18,7 +18,7 @@ func TestOverrideJobClusterDev(t *testing.T) {
 }
 
 func TestOverrideJobClusterStaging(t *testing.T) {
-	b := loadEnvironment(t, "./override_job_cluster", "staging")
+	b := loadTarget(t, "./override_job_cluster", "staging")
 	assert.Equal(t, "job", b.Config.Resources.Jobs["foo"].Name)
 	assert.Len(t, b.Config.Resources.Jobs["foo"].JobClusters, 1)
 
diff --git a/bundle/tests/string_interpolation/.gitignore b/bundle/tests/string_interpolation/.gitignore
new file mode 100644
index 0000000000..15bcc6dd09
--- /dev/null
+++ b/bundle/tests/string_interpolation/.gitignore
@@ -0,0 +1 @@
+.databricks
diff --git a/bundle/tests/string_interpolation/databricks.yml b/bundle/tests/string_interpolation/databricks.yml
new file mode 100644
index 0000000000..a1022328a7
--- /dev/null
+++ b/bundle/tests/string_interpolation/databricks.yml
@@ -0,0 +1,16 @@
+bundle:
+  name: basic
+  target: development
+
+resources:
+  jobs:
+    test_job_a:
+      name: "[${bundle.environment}] Test A"
+      tasks:
+        - task_key: TestTask
+          existing_cluster_id: "0717-132531-5opeqon1"
+    test_job_b:
+      name: "[${bundle.target}] Test B"
+      tasks:
+        - task_key: TestTask
+          existing_cluster_id: "0717-132531-5opeqon1"
diff --git a/bundle/tests/string_interpolation_test.go b/bundle/tests/string_interpolation_test.go
new file mode 100644
index 0000000000..d57b4dbc94
--- /dev/null
+++ b/bundle/tests/string_interpolation_test.go
@@ -0,0 +1,23 @@
+package config_tests
+
+import (
+	"context"
+	"testing"
+
+	"github.com/databricks/cli/bundle"
+	"github.com/databricks/cli/bundle/phases"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBundleEnvironmentStringInterpolation(t *testing.T) {
+	ctx := context.Background()
+	b, err := bundle.Load(ctx, "./string_interpolation")
+	require.NoError(t, err)
+
+	init := phases.Initialize()
+	err = init.Apply(ctx, b)
+	require.NoError(t, err)
+
+	require.Equal(t, b.Config.Resources.Jobs["test_job_a"].Name, "[development] Test A")
+	require.Equal(t, b.Config.Resources.Jobs["test_job_b"].Name, "[development] Test B")
+}
diff --git a/bundle/tests/target_empty/databricks.yml b/bundle/tests/target_empty/databricks.yml
new file mode 100644
index 0000000000..cd415377c5
--- /dev/null
+++ b/bundle/tests/target_empty/databricks.yml
@@ -0,0 +1,5 @@
+bundle:
+  name: target_empty
+
+targets:
+  development:
diff --git a/bundle/tests/target_empty_test.go b/bundle/tests/target_empty_test.go
new file mode 100644
index 0000000000..88705d8bb2
--- /dev/null
+++ b/bundle/tests/target_empty_test.go
@@ -0,0 +1,12 @@
+package config_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTargetEmpty(t *testing.T) {
+	b := loadTarget(t, "./target_empty", "development")
+	assert.Equal(t, "development", b.Config.Bundle.Target)
+}
diff --git a/bundle/tests/target_overrides/resources/databricks.yml b/bundle/tests/target_overrides/resources/databricks.yml
new file mode 100644
index 0000000000..f6e2a7edb2
--- /dev/null
+++ b/bundle/tests/target_overrides/resources/databricks.yml
@@ -0,0 +1,20 @@
+bundle:
+  name: environment_overrides
+
+workspace:
+  host: https://acme.cloud.databricks.com/
+
+resources:
+  jobs:
+    job1:
+      name: "base job"
+
+targets:
+  development:
+    default: true
+
+  staging:
+    resources:
+      jobs:
+        job1:
+          name: "staging job"
diff --git a/bundle/tests/target_overrides/workspace/databricks.yml b/bundle/tests/target_overrides/workspace/databricks.yml
new file mode 100644
index 0000000000..8c4f9487ed
--- /dev/null
+++ b/bundle/tests/target_overrides/workspace/databricks.yml
@@ -0,0 +1,14 @@
+bundle:
+  name: environment_overrides
+
+workspace:
+  host: https://acme.cloud.databricks.com/
+
+targets:
+  development:
+    workspace:
+      host: https://development.acme.cloud.databricks.com/
+
+  staging:
+    workspace:
+      host: https://staging.acme.cloud.databricks.com/
diff --git a/bundle/tests/target_overrides_test.go b/bundle/tests/target_overrides_test.go
new file mode 100644
index 0000000000..2516ce2a31
--- /dev/null
+++ b/bundle/tests/target_overrides_test.go
@@ -0,0 +1,27 @@
+package config_tests
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTargetOverridesWorkspaceDev(t *testing.T) {
+	b := loadTarget(t, "./target_overrides/workspace", "development")
+	assert.Equal(t, "https://development.acme.cloud.databricks.com/", b.Config.Workspace.Host)
+}
+
+func TestTargetOverridesWorkspaceStaging(t *testing.T) {
+	b := loadTarget(t, "./target_overrides/workspace", "staging")
+	assert.Equal(t, "https://staging.acme.cloud.databricks.com/", b.Config.Workspace.Host)
+}
+
+func TestTargetOverridesResourcesDev(t *testing.T) {
+	b := loadTarget(t, "./target_overrides/resources", "development")
+	assert.Equal(t, "base job", b.Config.Resources.Jobs["job1"].Name)
+}
+
+func TestTargetOverridesResourcesStaging(t *testing.T) {
+	b := loadTarget(t, "./target_overrides/resources", "staging")
+	assert.Equal(t, "staging job", b.Config.Resources.Jobs["job1"].Name)
+}
diff --git a/bundle/tests/variables/env_overrides/databricks.yml b/bundle/tests/variables/env_overrides/databricks.yml
index 1fec107339..2157596c38 100644
--- a/bundle/tests/variables/env_overrides/databricks.yml
+++ b/bundle/tests/variables/env_overrides/databricks.yml
@@ -12,7 +12,7 @@ bundle:
 workspace:
   profile: ${var.a} ${var.b}
 
-environments:
+targets:
   env-with-single-variable-override:
     variables:
       b: dev-b
diff --git a/bundle/tests/variables_test.go b/bundle/tests/variables_test.go
index 365ffbd4b6..93c8225059 100644
--- a/bundle/tests/variables_test.go
+++ b/bundle/tests/variables_test.go
@@ -34,10 +34,10 @@ func TestVariablesLoadingFailsWhenRequiredVariableIsNotSpecified(t *testing.T) {
 	assert.ErrorContains(t, err, "no value assigned to required variable b. Assignment can be done through the \"--var\" flag or by setting the BUNDLE_VAR_b environment variable")
 }
 
-func TestVariablesEnvironmentsBlockOverride(t *testing.T) {
+func TestVariablesTargetsBlockOverride(t *testing.T) {
 	b := load(t, "./variables/env_overrides")
 	err := bundle.Apply(context.Background(), b, bundle.Seq(
-		mutator.SelectEnvironment("env-with-single-variable-override"),
+		mutator.SelectTarget("env-with-single-variable-override"),
 		mutator.SetVariables(),
 		interpolation.Interpolate(
 			interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
@@ -46,10 +46,10 @@ func TestVariablesEnvironmentsBlockOverride(t *testing.T) {
 	assert.Equal(t, "default-a dev-b", b.Config.Workspace.Profile)
 }
 
-func TestVariablesEnvironmentsBlockOverrideForMultipleVariables(t *testing.T) {
+func TestVariablesTargetsBlockOverrideForMultipleVariables(t *testing.T) {
 	b := load(t, "./variables/env_overrides")
 	err := bundle.Apply(context.Background(), b, bundle.Seq(
-		mutator.SelectEnvironment("env-with-two-variable-overrides"),
+		mutator.SelectTarget("env-with-two-variable-overrides"),
 		mutator.SetVariables(),
 		interpolation.Interpolate(
 			interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
@@ -58,11 +58,11 @@ func TestVariablesEnvironmentsBlockOverrideForMultipleVariables(t *testing.T) {
 	assert.Equal(t, "prod-a prod-b", b.Config.Workspace.Profile)
 }
 
-func TestVariablesEnvironmentsBlockOverrideWithProcessEnvVars(t *testing.T) {
+func TestVariablesTargetsBlockOverrideWithProcessEnvVars(t *testing.T) {
 	t.Setenv("BUNDLE_VAR_b", "env-var-b")
 	b := load(t, "./variables/env_overrides")
 	err := bundle.Apply(context.Background(), b, bundle.Seq(
-		mutator.SelectEnvironment("env-with-two-variable-overrides"),
+		mutator.SelectTarget("env-with-two-variable-overrides"),
 		mutator.SetVariables(),
 		interpolation.Interpolate(
 			interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
@@ -71,10 +71,10 @@ func TestVariablesEnvironmentsBlockOverrideWithProcessEnvVars(t *testing.T) {
 	assert.Equal(t, "prod-a env-var-b", b.Config.Workspace.Profile)
 }
 
-func TestVariablesEnvironmentsBlockOverrideWithMissingVariables(t *testing.T) {
+func TestVariablesTargetsBlockOverrideWithMissingVariables(t *testing.T) {
 	b := load(t, "./variables/env_overrides")
 	err := bundle.Apply(context.Background(), b, bundle.Seq(
-		mutator.SelectEnvironment("env-missing-a-required-variable-assignment"),
+		mutator.SelectTarget("env-missing-a-required-variable-assignment"),
 		mutator.SetVariables(),
 		interpolation.Interpolate(
 			interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
@@ -82,10 +82,10 @@ func TestVariablesEnvironmentsBlockOverrideWithMissingVariables(t *testing.T) {
 	assert.ErrorContains(t, err, "no value assigned to required variable b. Assignment can be done through the \"--var\" flag or by setting the BUNDLE_VAR_b environment variable")
 }
 
-func TestVariablesEnvironmentsBlockOverrideWithUndefinedVariables(t *testing.T) {
+func TestVariablesTargetsBlockOverrideWithUndefinedVariables(t *testing.T) {
 	b := load(t, "./variables/env_overrides")
 	err := bundle.Apply(context.Background(), b, bundle.Seq(
-		mutator.SelectEnvironment("env-using-an-undefined-variable"),
+		mutator.SelectTarget("env-using-an-undefined-variable"),
 		mutator.SetVariables(),
 		interpolation.Interpolate(
 			interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
diff --git a/cmd/bundle/variables.go b/cmd/bundle/variables.go
index 33f557cc12..c3e4af6453 100644
--- a/cmd/bundle/variables.go
+++ b/cmd/bundle/variables.go
@@ -7,7 +7,7 @@ import (
 )
 
 func ConfigureBundleWithVariables(cmd *cobra.Command, args []string) error {
-	// Load bundle config and apply environment
+	// Load bundle config and apply target
 	err := root.MustConfigureBundle(cmd, args)
 	if err != nil {
 		return err
diff --git a/cmd/root/bundle.go b/cmd/root/bundle.go
index f691bbfc27..1b940999e0 100644
--- a/cmd/root/bundle.go
+++ b/cmd/root/bundle.go
@@ -12,10 +12,10 @@ import (
 
 const envName = "DATABRICKS_BUNDLE_ENV"
 
-// getEnvironment returns the name of the environment to operate in.
-func getEnvironment(cmd *cobra.Command) (value string) {
+// getTarget returns the name of the target to operate in.
+func getTarget(cmd *cobra.Command) (value string) {
 	// The command line flag takes precedence.
-	flag := cmd.Flag("environment")
+	flag := cmd.Flag("target")
 	if flag != nil {
 		value = flag.Value.String()
 		if value != "" {
@@ -23,6 +23,14 @@ func getEnvironment(cmd *cobra.Command) (value string) {
 		}
 	}
 
+	oldFlag := cmd.Flag("environment")
+	if oldFlag != nil {
+		value = flag.Value.String()
+		if value != "" {
+			return
+		}
+	}
+
 	// If it's not set, use the environment variable.
 	return os.Getenv(envName)
 }
@@ -80,11 +88,11 @@ func configureBundle(cmd *cobra.Command, args []string, load func(ctx context.Co
 	}
 
 	var m bundle.Mutator
-	env := getEnvironment(cmd)
+	env := getTarget(cmd)
 	if env == "" {
-		m = mutator.SelectDefaultEnvironment()
+		m = mutator.SelectDefaultTarget()
 	} else {
-		m = mutator.SelectEnvironment(env)
+		m = mutator.SelectTarget(env)
 	}
 
 	ctx := cmd.Context()
@@ -108,19 +116,27 @@ func TryConfigureBundle(cmd *cobra.Command, args []string) error {
 	return configureBundle(cmd, args, bundle.TryLoad)
 }
 
-// environmentCompletion executes to autocomplete the argument to the environment flag.
-func environmentCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+// targetCompletion executes to autocomplete the argument to the target flag.
+func targetCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 	b, err := loadBundle(cmd, args, bundle.MustLoad)
 	if err != nil {
 		cobra.CompErrorln(err.Error())
 		return nil, cobra.ShellCompDirectiveError
 	}
 
-	return maps.Keys(b.Config.Environments), cobra.ShellCompDirectiveDefault
+	return maps.Keys(b.Config.Targets), cobra.ShellCompDirectiveDefault
+}
+
+func initTargetFlag(cmd *cobra.Command) {
+	// To operate in the context of a bundle, all commands must take an "target" parameter.
+	cmd.PersistentFlags().String("target", "", "bundle target to use (if applicable)")
+	cmd.RegisterFlagCompletionFunc("target", targetCompletion)
 }
 
+// DEPRECATED flag
 func initEnvironmentFlag(cmd *cobra.Command) {
 	// To operate in the context of a bundle, all commands must take an "environment" parameter.
-	cmd.PersistentFlags().StringP("environment", "e", "", "bundle environment to use (if applicable)")
-	cmd.RegisterFlagCompletionFunc("environment", environmentCompletion)
+	cmd.PersistentFlags().StringP("environment", "e", "", "bundle target to use (if applicable)")
+	cmd.PersistentFlags().MarkDeprecated("environment", "use --target flag instead")
+	cmd.RegisterFlagCompletionFunc("environment", targetCompletion)
 }
diff --git a/cmd/root/root.go b/cmd/root/root.go
index 48868b41f4..c71cf9eacc 100644
--- a/cmd/root/root.go
+++ b/cmd/root/root.go
@@ -36,6 +36,7 @@ func New() *cobra.Command {
 	outputFlag := initOutputFlag(cmd)
 	initProfileFlag(cmd)
 	initEnvironmentFlag(cmd)
+	initTargetFlag(cmd)
 
 	cmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
 		ctx := cmd.Context()
diff --git a/cmd/sync/sync_test.go b/cmd/sync/sync_test.go
index a6eedbe6ed..06e97540fb 100644
--- a/cmd/sync/sync_test.go
+++ b/cmd/sync/sync_test.go
@@ -18,7 +18,7 @@ func TestSyncOptionsFromBundle(t *testing.T) {
 			Path: tempDir,
 
 			Bundle: config.Bundle{
-				Environment: "default",
+				Target: "default",
 			},
 
 			Workspace: config.Workspace{

From f64c1b8ee8f8f26c2887a76e719ab0690baccec0 Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Wed, 16 Aug 2023 13:27:31 +0200
Subject: [PATCH 2/8] improved test

---
 bundle/tests/string_interpolation_test.go | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/bundle/tests/string_interpolation_test.go b/bundle/tests/string_interpolation_test.go
index d57b4dbc94..02189b04bb 100644
--- a/bundle/tests/string_interpolation_test.go
+++ b/bundle/tests/string_interpolation_test.go
@@ -5,7 +5,8 @@ import (
 	"testing"
 
 	"github.com/databricks/cli/bundle"
-	"github.com/databricks/cli/bundle/phases"
+	"github.com/databricks/cli/bundle/config/interpolation"
+	"github.com/databricks/cli/bundle/config/variable"
 	"github.com/stretchr/testify/require"
 )
 
@@ -14,7 +15,11 @@ func TestBundleEnvironmentStringInterpolation(t *testing.T) {
 	b, err := bundle.Load(ctx, "./string_interpolation")
 	require.NoError(t, err)
 
-	init := phases.Initialize()
+	init := interpolation.Interpolate(
+		interpolation.IncludeLookupsInPath("bundle"),
+		interpolation.IncludeLookupsInPath("workspace"),
+		interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
+	)
 	err = init.Apply(ctx, b)
 	require.NoError(t, err)
 

From 1f73d182eca45af108f30610be195625ecbd90ba Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Wed, 16 Aug 2023 16:43:17 +0200
Subject: [PATCH 3/8] fix

---
 bundle/config/mutator/select_target.go      |  2 +-
 bundle/config/root.go                       | 15 +++++----------
 bundle/config/root_test.go                  |  4 ++--
 bundle/config/{environment.go => target.go} |  2 +-
 4 files changed, 9 insertions(+), 14 deletions(-)
 rename bundle/config/{environment.go => target.go} (96%)

diff --git a/bundle/config/mutator/select_target.go b/bundle/config/mutator/select_target.go
index 59e780fb3d..11f23fc41a 100644
--- a/bundle/config/mutator/select_target.go
+++ b/bundle/config/mutator/select_target.go
@@ -34,7 +34,7 @@ func (m *selectTarget) Apply(_ context.Context, b *bundle.Bundle) error {
 	}
 
 	// Merge specified target into root configuration structure.
-	err := b.Config.MergeTarget(env)
+	err := b.Config.MergeTargetOverrides(env)
 	if err != nil {
 		return err
 	}
diff --git a/bundle/config/root.go b/bundle/config/root.go
index cddf25d85b..206d8a91c0 100644
--- a/bundle/config/root.go
+++ b/bundle/config/root.go
@@ -151,20 +151,15 @@ func (r *Root) Load(path string) error {
 		return fmt.Errorf("failed to load %s: %w", path, err)
 	}
 
-	if r.Environments != nil {
-		//TODO: add a command line notice that this is a deprecated option.
-		r.Targets = r.Environments
+	if r.Environments != nil && r.Targets != nil {
+		return fmt.Errorf("both 'environments' and 'targets' are specified, only 'targets' should be used %s", path)
 	}
 
-	if r.Bundle.Environment != "" {
+	if r.Environments != nil {
 		//TODO: add a command line notice that this is a deprecated option.
-		r.Bundle.Target = r.Bundle.Environment
+		r.Targets = r.Environments
 	}
 
-	// We do this for backward compatibility so ${bundle.environment} works correctly.
-	// TODO: remove when Environments section is not supported anymore.
-	r.Bundle.Environment = r.Bundle.Target
-
 	r.Path = filepath.Dir(path)
 	r.SetConfigFilePath(path)
 
@@ -186,7 +181,7 @@ func (r *Root) Merge(other *Root) error {
 	return mergo.Merge(r, other, mergo.WithOverride)
 }
 
-func (r *Root) MergeTarget(target *Target) error {
+func (r *Root) MergeTargetOverrides(target *Target) error {
 	var err error
 
 	// Target may be nil if it's empty.
diff --git a/bundle/config/root_test.go b/bundle/config/root_test.go
index f8ba8d47a7..6e2636678b 100644
--- a/bundle/config/root_test.go
+++ b/bundle/config/root_test.go
@@ -159,12 +159,12 @@ func TestInitializeVariablesUndefinedVariables(t *testing.T) {
 	assert.ErrorContains(t, err, "variable bar has not been defined")
 }
 
-func TestRootMergeTargetWithMode(t *testing.T) {
+func TestRootMergeTargetOverridesWithMode(t *testing.T) {
 	root := &Root{
 		Bundle: Bundle{},
 	}
 	env := &Target{Mode: Development}
-	require.NoError(t, root.MergeTarget(env))
+	require.NoError(t, root.MergeTargetOverrides(env))
 	assert.Equal(t, Development, root.Bundle.Mode)
 }
 
diff --git a/bundle/config/environment.go b/bundle/config/target.go
similarity index 96%
rename from bundle/config/environment.go
rename to bundle/config/target.go
index 7c4b10adb4..10775049dc 100644
--- a/bundle/config/environment.go
+++ b/bundle/config/target.go
@@ -2,7 +2,7 @@ package config
 
 type Mode string
 
-// Target defines overrides for a single taregt.
+// Target defines overrides for a single target.
 // This structure is recursively merged into the root configuration.
 type Target struct {
 	// Default marks that this target must be used if one isn't specified

From a4c04d989c7572aa0f908d8669f66fc2ed15b152 Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Wed, 16 Aug 2023 17:00:25 +0200
Subject: [PATCH 4/8] fixed tests

---
 .../tests/interpolation_target/databricks.yml | 14 ++++++++++
 bundle/tests/interpolation_test.go            | 12 ++++++++
 bundle/tests/string_interpolation/.gitignore  |  1 -
 .../tests/string_interpolation/databricks.yml | 16 -----------
 bundle/tests/string_interpolation_test.go     | 28 -------------------
 5 files changed, 26 insertions(+), 45 deletions(-)
 create mode 100644 bundle/tests/interpolation_target/databricks.yml
 delete mode 100644 bundle/tests/string_interpolation/.gitignore
 delete mode 100644 bundle/tests/string_interpolation/databricks.yml
 delete mode 100644 bundle/tests/string_interpolation_test.go

diff --git a/bundle/tests/interpolation_target/databricks.yml b/bundle/tests/interpolation_target/databricks.yml
new file mode 100644
index 0000000000..ad4ebe199d
--- /dev/null
+++ b/bundle/tests/interpolation_target/databricks.yml
@@ -0,0 +1,14 @@
+bundle:
+  name: foo ${workspace.profile}
+
+workspace:
+  profile: bar
+
+targets:
+  development:
+    default: true
+
+resources:
+  jobs:
+    my_job:
+      name: "${bundle.name} | ${workspace.profile} | ${bundle.environment} | ${bundle.target}"
diff --git a/bundle/tests/interpolation_test.go b/bundle/tests/interpolation_test.go
index 47b0c775fb..837891a072 100644
--- a/bundle/tests/interpolation_test.go
+++ b/bundle/tests/interpolation_test.go
@@ -20,3 +20,15 @@ func TestInterpolation(t *testing.T) {
 	assert.Equal(t, "foo bar", b.Config.Bundle.Name)
 	assert.Equal(t, "foo bar | bar", b.Config.Resources.Jobs["my_job"].Name)
 }
+
+func TestInterpolationWithTarget(t *testing.T) {
+	b := loadTarget(t, "./interpolation_target", "development")
+	err := bundle.Apply(context.Background(), b, interpolation.Interpolate(
+		interpolation.IncludeLookupsInPath("bundle"),
+		interpolation.IncludeLookupsInPath("workspace"),
+	))
+	require.NoError(t, err)
+	assert.Equal(t, "foo bar", b.Config.Bundle.Name)
+	assert.Equal(t, "foo bar | bar | development | development", b.Config.Resources.Jobs["my_job"].Name)
+
+}
diff --git a/bundle/tests/string_interpolation/.gitignore b/bundle/tests/string_interpolation/.gitignore
deleted file mode 100644
index 15bcc6dd09..0000000000
--- a/bundle/tests/string_interpolation/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-.databricks
diff --git a/bundle/tests/string_interpolation/databricks.yml b/bundle/tests/string_interpolation/databricks.yml
deleted file mode 100644
index a1022328a7..0000000000
--- a/bundle/tests/string_interpolation/databricks.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-bundle:
-  name: basic
-  target: development
-
-resources:
-  jobs:
-    test_job_a:
-      name: "[${bundle.environment}] Test A"
-      tasks:
-        - task_key: TestTask
-          existing_cluster_id: "0717-132531-5opeqon1"
-    test_job_b:
-      name: "[${bundle.target}] Test B"
-      tasks:
-        - task_key: TestTask
-          existing_cluster_id: "0717-132531-5opeqon1"
diff --git a/bundle/tests/string_interpolation_test.go b/bundle/tests/string_interpolation_test.go
deleted file mode 100644
index 02189b04bb..0000000000
--- a/bundle/tests/string_interpolation_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package config_tests
-
-import (
-	"context"
-	"testing"
-
-	"github.com/databricks/cli/bundle"
-	"github.com/databricks/cli/bundle/config/interpolation"
-	"github.com/databricks/cli/bundle/config/variable"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBundleEnvironmentStringInterpolation(t *testing.T) {
-	ctx := context.Background()
-	b, err := bundle.Load(ctx, "./string_interpolation")
-	require.NoError(t, err)
-
-	init := interpolation.Interpolate(
-		interpolation.IncludeLookupsInPath("bundle"),
-		interpolation.IncludeLookupsInPath("workspace"),
-		interpolation.IncludeLookupsInPath(variable.VariableReferencePrefix),
-	)
-	err = init.Apply(ctx, b)
-	require.NoError(t, err)
-
-	require.Equal(t, b.Config.Resources.Jobs["test_job_a"].Name, "[development] Test A")
-	require.Equal(t, b.Config.Resources.Jobs["test_job_b"].Name, "[development] Test B")
-}

From 07734acb7825527cbbce11021f0cf8404dea3ad0 Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Thu, 17 Aug 2023 11:53:11 +0200
Subject: [PATCH 5/8] Added new env variable

---
 bundle/config/mutator/select_target.go |  4 ++--
 bundle/config/root.go                  |  2 +-
 cmd/root/bundle.go                     | 10 +++++++++-
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/bundle/config/mutator/select_target.go b/bundle/config/mutator/select_target.go
index 11f23fc41a..3be1f2e1a5 100644
--- a/bundle/config/mutator/select_target.go
+++ b/bundle/config/mutator/select_target.go
@@ -28,13 +28,13 @@ func (m *selectTarget) Apply(_ context.Context, b *bundle.Bundle) error {
 	}
 
 	// Get specified target
-	env, ok := b.Config.Targets[m.name]
+	target, ok := b.Config.Targets[m.name]
 	if !ok {
 		return fmt.Errorf("%s: no such target", m.name)
 	}
 
 	// Merge specified target into root configuration structure.
-	err := b.Config.MergeTargetOverrides(env)
+	err := b.Config.MergeTargetOverrides(target)
 	if err != nil {
 		return err
 	}
diff --git a/bundle/config/root.go b/bundle/config/root.go
index 206d8a91c0..24426dd89c 100644
--- a/bundle/config/root.go
+++ b/bundle/config/root.go
@@ -152,7 +152,7 @@ func (r *Root) Load(path string) error {
 	}
 
 	if r.Environments != nil && r.Targets != nil {
-		return fmt.Errorf("both 'environments' and 'targets' are specified, only 'targets' should be used %s", path)
+		return fmt.Errorf("both 'environments' and 'targets' are specified, only 'targets' should be used: %s", path)
 	}
 
 	if r.Environments != nil {
diff --git a/cmd/root/bundle.go b/cmd/root/bundle.go
index 1b940999e0..a375201a18 100644
--- a/cmd/root/bundle.go
+++ b/cmd/root/bundle.go
@@ -11,6 +11,7 @@ import (
 )
 
 const envName = "DATABRICKS_BUNDLE_ENV"
+const targetName = "DATABRICKS_BUNDLE_TARGET"
 
 // getTarget returns the name of the target to operate in.
 func getTarget(cmd *cobra.Command) (value string) {
@@ -32,7 +33,14 @@ func getTarget(cmd *cobra.Command) (value string) {
 	}
 
 	// If it's not set, use the environment variable.
-	return os.Getenv(envName)
+	target := os.Getenv(targetName)
+	// If target env is not set with a new variable, try to check for old variable name
+	// TODO: remove when environments section is not supported anymore
+	if target == "" {
+		target = os.Getenv(envName)
+	}
+
+	return target
 }
 
 func getProfile(cmd *cobra.Command) (value string) {

From e9805e5e99e1f51f98793c650e76da6acc458ce3 Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Thu, 17 Aug 2023 12:56:50 +0200
Subject: [PATCH 6/8] added short flag

---
 cmd/root/bundle.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/root/bundle.go b/cmd/root/bundle.go
index a375201a18..55d7c8ebd0 100644
--- a/cmd/root/bundle.go
+++ b/cmd/root/bundle.go
@@ -137,7 +137,7 @@ func targetCompletion(cmd *cobra.Command, args []string, toComplete string) ([]s
 
 func initTargetFlag(cmd *cobra.Command) {
 	// To operate in the context of a bundle, all commands must take an "target" parameter.
-	cmd.PersistentFlags().String("target", "", "bundle target to use (if applicable)")
+	cmd.PersistentFlags().String("target", "t", "bundle target to use (if applicable)")
 	cmd.RegisterFlagCompletionFunc("target", targetCompletion)
 }
 

From 124145b1684e9ae6040067a0ecc853e75b882f5a Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Thu, 17 Aug 2023 14:49:25 +0200
Subject: [PATCH 7/8] shorthand + schema renames

---
 bundle/schema/README.md                     |  4 +--
 bundle/schema/docs/bundle_descriptions.json | 30 ++++++++++-----------
 cmd/configure/configure.go                  |  2 +-
 cmd/root/bundle.go                          |  2 +-
 cmd/root/bundle_test.go                     | 24 +++++++++++++++++
 5 files changed, 43 insertions(+), 19 deletions(-)

diff --git a/bundle/schema/README.md b/bundle/schema/README.md
index 4df43cf23d..fe6b149c14 100644
--- a/bundle/schema/README.md
+++ b/bundle/schema/README.md
@@ -3,7 +3,7 @@
 `docs/bundle_descriptions.json` contains both autogenerated as well as manually written
 descriptions for the json schema. Specifically
 1. `resources` : almost all descriptions are autogenerated from the OpenAPI spec
-2. `environments` : almost all descriptions are copied over from root level entities (eg: `bundle`, `artifacts`)
+2. `targets` : almost all descriptions are copied over from root level entities (eg: `bundle`, `artifacts`)
 3. `bundle` : manually editted
 4. `include` : manually editted
 5. `workspace` : manually editted
@@ -17,7 +17,7 @@ These descriptions are rendered in the inline documentation in an IDE
 `databricks bundle schema --only-docs > ~/databricks/bundle/schema/docs/bundle_descriptions.json`
 2. Manually edit bundle_descriptions.json to add your descriptions
 3. Build again to embed the new `bundle_descriptions.json` into the binary (`go build`)
-4. Again run `databricks bundle schema --only-docs > ~/databricks/bundle/schema/docs/bundle_descriptions.json` to copy over any applicable descriptions to `environments`
+4. Again run `databricks bundle schema --only-docs > ~/databricks/bundle/schema/docs/bundle_descriptions.json` to copy over any applicable descriptions to `targets`
 5. push to repo
 
 
diff --git a/bundle/schema/docs/bundle_descriptions.json b/bundle/schema/docs/bundle_descriptions.json
index 2adb11f219..8713558f52 100644
--- a/bundle/schema/docs/bundle_descriptions.json
+++ b/bundle/schema/docs/bundle_descriptions.json
@@ -36,7 +36,7 @@
         }
       }
     },
-    "environments": {
+    "targets": {
       "description": "",
       "additionalproperties": {
         "description": "",
@@ -281,7 +281,7 @@
                                     "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                                   },
                                   "instance_profile_arn": {
-                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                                   },
                                   "spot_bid_price_percent": {
                                     "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -411,7 +411,7 @@
                                     "description": "boot disk size in GB"
                                   },
                                   "google_service_account": {
-                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
+                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
                                   },
                                   "local_ssd_count": {
                                     "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -808,7 +808,7 @@
                                     "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                                   },
                                   "instance_profile_arn": {
-                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                                   },
                                   "spot_bid_price_percent": {
                                     "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -938,7 +938,7 @@
                                     "description": "boot disk size in GB"
                                   },
                                   "google_service_account": {
-                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
+                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
                                   },
                                   "local_ssd_count": {
                                     "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -1496,7 +1496,7 @@
                                 "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                               },
                               "instance_profile_arn": {
-                                "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                                "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                               },
                               "spot_bid_price_percent": {
                                 "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -1592,7 +1592,7 @@
                                 "description": "boot disk size in GB"
                               },
                               "google_service_account": {
-                                "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
+                                "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
                               },
                               "local_ssd_count": {
                                 "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -1827,7 +1827,7 @@
                 "description": "Connection profile to use. By default profiles are specified in ~/.databrickscfg."
               },
               "root_path": {
-                "description": "The base location for synchronizing files, artifacts and state. Defaults to `/Users/jane@doe.com/.bundle/${bundle.name}/${bundle.environment}`"
+                "description": "The base location for synchronizing files, artifacts and state. Defaults to `/Users/jane@doe.com/.bundle/${bundle.name}/${bundle.target}`"
               },
               "state_path": {
                 "description": "The remote path to synchronize bundle state to. This defaults to `${workspace.root}/state`"
@@ -2045,7 +2045,7 @@
                               "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                             },
                             "instance_profile_arn": {
-                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                             },
                             "spot_bid_price_percent": {
                               "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -2175,7 +2175,7 @@
                               "description": "boot disk size in GB"
                             },
                             "google_service_account": {
-                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
+                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
                             },
                             "local_ssd_count": {
                               "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -2572,7 +2572,7 @@
                               "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                             },
                             "instance_profile_arn": {
-                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                             },
                             "spot_bid_price_percent": {
                               "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -2702,7 +2702,7 @@
                               "description": "boot disk size in GB"
                             },
                             "google_service_account": {
-                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
+                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
                             },
                             "local_ssd_count": {
                               "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -3260,7 +3260,7 @@
                           "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                         },
                         "instance_profile_arn": {
-                          "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                          "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                         },
                         "spot_bid_price_percent": {
                           "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -3356,7 +3356,7 @@
                           "description": "boot disk size in GB"
                         },
                         "google_service_account": {
-                          "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
+                          "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
                         },
                         "local_ssd_count": {
                           "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -3591,7 +3591,7 @@
           "description": "Connection profile to use. By default profiles are specified in ~/.databrickscfg."
         },
         "root_path": {
-          "description": "The base location for synchronizing files, artifacts and state. Defaults to `/Users/jane@doe.com/.bundle/${bundle.name}/${bundle.environment}`"
+          "description": "The base location for synchronizing files, artifacts and state. Defaults to `/Users/jane@doe.com/.bundle/${bundle.name}/${bundle.target}`"
         },
         "state_path": {
           "description": "The remote path to synchronize bundle state to. This defaults to `${workspace.root}/state`"
diff --git a/cmd/configure/configure.go b/cmd/configure/configure.go
index c51fd8300b..0c1e405216 100644
--- a/cmd/configure/configure.go
+++ b/cmd/configure/configure.go
@@ -131,7 +131,7 @@ func newConfigureCommand() *cobra.Command {
 
 	// Include token flag for compatibility with the legacy CLI.
 	// It doesn't actually do anything because we always use PATs.
-	cmd.Flags().BoolP("token", "t", true, "Configure using Databricks Personal Access Token")
+	cmd.Flags().Bool("token", true, "Configure using Databricks Personal Access Token")
 	cmd.Flags().MarkHidden("token")
 
 	cmd.RunE = func(cmd *cobra.Command, args []string) error {
diff --git a/cmd/root/bundle.go b/cmd/root/bundle.go
index 55d7c8ebd0..e1c1233653 100644
--- a/cmd/root/bundle.go
+++ b/cmd/root/bundle.go
@@ -137,7 +137,7 @@ func targetCompletion(cmd *cobra.Command, args []string, toComplete string) ([]s
 
 func initTargetFlag(cmd *cobra.Command) {
 	// To operate in the context of a bundle, all commands must take an "target" parameter.
-	cmd.PersistentFlags().String("target", "t", "bundle target to use (if applicable)")
+	cmd.PersistentFlags().StringP("target", "t", "", "bundle target to use (if applicable)")
 	cmd.RegisterFlagCompletionFunc("target", targetCompletion)
 }
 
diff --git a/cmd/root/bundle_test.go b/cmd/root/bundle_test.go
index 4382cf22ff..8aff9018f6 100644
--- a/cmd/root/bundle_test.go
+++ b/cmd/root/bundle_test.go
@@ -128,3 +128,27 @@ func TestBundleConfigureWithProfileFlagAndEnvVariable(t *testing.T) {
 		b.WorkspaceClient()
 	})
 }
+
+func TestTargetFlagFull(t *testing.T) {
+	cmd := emptyCommand(t)
+	initTargetFlag(cmd)
+	cmd.SetArgs([]string{"version", "--target", "development"})
+
+	ctx := context.Background()
+	err := cmd.ExecuteContext(ctx)
+	assert.NoError(t, err)
+
+	assert.Equal(t, cmd.Flag("target").Value.String(), "development")
+}
+
+func TestTargetFlagShort(t *testing.T) {
+	cmd := emptyCommand(t)
+	initTargetFlag(cmd)
+	cmd.SetArgs([]string{"version", "-t", "production"})
+
+	ctx := context.Background()
+	err := cmd.ExecuteContext(ctx)
+	assert.NoError(t, err)
+
+	assert.Equal(t, cmd.Flag("target").Value.String(), "production")
+}

From 26d08271dfcc5156ca5a14e612b46b4a0259b180 Mon Sep 17 00:00:00 2001
From: Andrew Nester <andrew.nester@databricks.com>
Date: Thu, 17 Aug 2023 17:14:43 +0200
Subject: [PATCH 8/8] do not replace in generated docs

---
 bundle/schema/docs/bundle_descriptions.json | 24 ++++++++++-----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/bundle/schema/docs/bundle_descriptions.json b/bundle/schema/docs/bundle_descriptions.json
index 8713558f52..84f0492fb5 100644
--- a/bundle/schema/docs/bundle_descriptions.json
+++ b/bundle/schema/docs/bundle_descriptions.json
@@ -281,7 +281,7 @@
                                     "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                                   },
                                   "instance_profile_arn": {
-                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                                   },
                                   "spot_bid_price_percent": {
                                     "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -411,7 +411,7 @@
                                     "description": "boot disk size in GB"
                                   },
                                   "google_service_account": {
-                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
+                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
                                   },
                                   "local_ssd_count": {
                                     "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -808,7 +808,7 @@
                                     "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                                   },
                                   "instance_profile_arn": {
-                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                                    "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                                   },
                                   "spot_bid_price_percent": {
                                     "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -938,7 +938,7 @@
                                     "description": "boot disk size in GB"
                                   },
                                   "google_service_account": {
-                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
+                                    "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
                                   },
                                   "local_ssd_count": {
                                     "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -1496,7 +1496,7 @@
                                 "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                               },
                               "instance_profile_arn": {
-                                "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                                "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                               },
                               "spot_bid_price_percent": {
                                 "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -1592,7 +1592,7 @@
                                 "description": "boot disk size in GB"
                               },
                               "google_service_account": {
-                                "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
+                                "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
                               },
                               "local_ssd_count": {
                                 "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -2045,7 +2045,7 @@
                               "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                             },
                             "instance_profile_arn": {
-                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                             },
                             "spot_bid_price_percent": {
                               "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -2175,7 +2175,7 @@
                               "description": "boot disk size in GB"
                             },
                             "google_service_account": {
-                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
+                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
                             },
                             "local_ssd_count": {
                               "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -2572,7 +2572,7 @@
                               "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                             },
                             "instance_profile_arn": {
-                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                              "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                             },
                             "spot_bid_price_percent": {
                               "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -2702,7 +2702,7 @@
                               "description": "boot disk size in GB"
                             },
                             "google_service_account": {
-                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
+                              "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
                             },
                             "local_ssd_count": {
                               "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."
@@ -3260,7 +3260,7 @@
                           "description": "The first `first_on_demand` nodes of the cluster will be placed on on-demand instances.\nIf this value is greater than 0, the cluster driver node in particular will be placed on an\non-demand instance. If this value is greater than or equal to the current cluster size, all\nnodes will be placed on on-demand instances. If this value is less than the current cluster\nsize, `first_on_demand` nodes will be placed on on-demand instances and the remainder will\nbe placed on `availability` instances. Note that this value does not affect\ncluster size and cannot currently be mutated over the lifetime of a cluster."
                         },
                         "instance_profile_arn": {
-                          "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks target by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
+                          "description": "Nodes for this cluster will only be placed on AWS instances with this instance profile. If\nommitted, nodes will be placed on instances without an IAM instance profile. The instance\nprofile must have previously been added to the Databricks environment by an account\nadministrator.\n\nThis feature may only be available to certain customer plans.\n\nIf this field is ommitted, we will pull in the default from the conf if it exists."
                         },
                         "spot_bid_price_percent": {
                           "description": "The bid price for AWS spot instances, as a percentage of the corresponding instance type's\non-demand price.\nFor example, if this field is set to 50, and the cluster needs a new `r3.xlarge` spot\ninstance, then the bid price is half of the price of\non-demand `r3.xlarge` instances. Similarly, if this field is set to 200, the bid price is twice\nthe price of on-demand `r3.xlarge` instances. If not specified, the default value is 100.\nWhen spot instances are requested for this cluster, only spot instances whose bid price\npercentage matches this field will be considered.\nNote that, for safety, we enforce this field to be no more than 10000.\n\nThe default value and documentation here should be kept consistent with\nCommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."
@@ -3356,7 +3356,7 @@
                           "description": "boot disk size in GB"
                         },
                         "google_service_account": {
-                          "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks target by an account\nadministrator."
+                          "description": "If provided, the cluster will impersonate the google service account when accessing\ngcloud services (like GCS). The google service account\nmust have previously been added to the Databricks environment by an account\nadministrator."
                         },
                         "local_ssd_count": {
                           "description": "If provided, each node (workers and driver) in the cluster will have this number of local SSDs attached. Each local SSD is 375GB in size. Refer to [GCP documentation](https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds) for the supported number of local SSDs for each instance type."