feat: add configurable deploy timeout via --timeout flag and azure.yaml

.gitignore

@@ -77,4 +77,4 @@ cli/azd/extensions/microsoft.azd.concurx/concurx
 cli/azd/extensions/microsoft.azd.concurx/concurx.exe
 cli/azd/extensions/azure.appservice/azureappservice
 cli/azd/extensions/azure.appservice/azureappservice.exe
-
+.squad/

cli/azd/cmd/testdata/TestFigSpec.ts

@@ -1844,6 +1844,15 @@ const completionSpec: Fig.Spec = {
 						},
 					],
 				},
+				{
+					name: ['--timeout'],
+					description: 'Maximum time in seconds for azd to wait for each service deployment. This stops azd from waiting but does not cancel the Azure-side deployment. (default: 1200)',
+					args: [
+						{
+							name: 'timeout',
+						},
+					],
+				},
 			],
 			args: {
 				name: 'service',

cli/azd/cmd/testdata/TestUsage-azd-deploy.snap

@@ -12,6 +12,7 @@ Flags
         --all                 	: Deploys all services that are listed in azure.yaml
     -e, --environment string  	: The name of the environment to use.
         --from-package string 	: Deploys the packaged service located at the provided path. Supports zipped file packages (file path) or container images (image tag).
+        --timeout int         	: Maximum time in seconds for azd to wait for each service deployment. This stops azd from waiting but does not cancel the Azure-side deployment. (default: 1200)
 
 Global Flags
     -C, --cwd string 	: Sets the current working directory.

cli/azd/internal/cmd/deploy.go

@@ -5,10 +5,12 @@ package cmd
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"log"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
@@ -34,11 +36,15 @@ import (
 type DeployFlags struct {
 	ServiceName string
 	All         bool
+	Timeout     int
 	fromPackage string
+	flagSet     *pflag.FlagSet
 	global      *internal.GlobalCommandOptions
 	*internal.EnvFlag
 }
 
+const defaultDeployTimeoutSeconds = 1200
+
 func (d *DeployFlags) Bind(local *pflag.FlagSet, global *internal.GlobalCommandOptions) {
 	d.BindNonCommon(local, global)
 	d.bindCommon(local, global)
@@ -62,6 +68,7 @@ func (d *DeployFlags) BindNonCommon(
 func (d *DeployFlags) bindCommon(local *pflag.FlagSet, global *internal.GlobalCommandOptions) {
 	d.EnvFlag = &internal.EnvFlag{}
 	d.EnvFlag.Bind(local, global)
+	d.flagSet = local
 
 	local.BoolVar(
 		&d.All,
@@ -76,6 +83,16 @@ func (d *DeployFlags) bindCommon(local *pflag.FlagSet, global *internal.GlobalCo
 		//nolint:lll
 		"Deploys the packaged service located at the provided path. Supports zipped file packages (file path) or container images (image tag).",
 	)
+	local.IntVar(
+		&d.Timeout,
+		"timeout",
+		defaultDeployTimeoutSeconds,
+		fmt.Sprintf(
+			"Maximum time in seconds for azd to wait for each service deployment. This stops azd from waiting "+
+				"but does not cancel the Azure-side deployment. (default: %d)",
+			defaultDeployTimeoutSeconds,
+		),
+	)
 }
 
 func (d *DeployFlags) SetCommon(envFlag *internal.EnvFlag) {
@@ -91,11 +108,21 @@ func NewDeployFlags(cmd *cobra.Command, global *internal.GlobalCommandOptions) *
 
 func NewDeployFlagsFromEnvAndOptions(envFlag *internal.EnvFlag, global *internal.GlobalCommandOptions) *DeployFlags {
 	return &DeployFlags{
+		Timeout: defaultDeployTimeoutSeconds,
 		EnvFlag: envFlag,
 		global:  global,
 	}
 }
 
+func (d *DeployFlags) timeoutChanged() bool {
+	if d.flagSet == nil {
+		return false
+	}
+
+	timeoutFlag := d.flagSet.Lookup("timeout")
+	return timeoutFlag != nil && timeoutFlag.Changed
+}
+
 func NewDeployCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "deploy <service>",
@@ -241,6 +268,10 @@ func (da *DeployAction) Run(ctx context.Context) (*actions.ActionResult, error)
 	}
 
 	deployResults := map[string]*project.ServiceDeployResult{}
+	deployTimeout, err := da.resolveDeployTimeout()
+	if err != nil {
+		return nil, err
+	}
 
 	err = da.projectConfig.Invoke(ctx, project.ProjectEventDeploy, projectEventArgs, func() error {
 		for _, svc := range stableServices {
@@ -303,18 +334,45 @@ func (da *DeployAction) Run(ctx context.Context) (*actions.ActionResult, error)
 				return err
 			}
 
+			deployCtx, deployCancel := context.WithTimeout(ctx, deployTimeout)
+			defer deployCancel()
+
 			deployResult, err := async.RunWithProgress(
 				func(deployProgress project.ServiceProgress) {
 					progressMessage := fmt.Sprintf("Deploying service %s (%s)", svc.Name, deployProgress.Message)
 					da.console.ShowSpinner(ctx, progressMessage, input.Step)
 				},
 				func(progress *async.Progress[project.ServiceProgress]) (*project.ServiceDeployResult, error) {
-					return da.serviceManager.Deploy(ctx, svc, serviceContext, progress)
+					return da.serviceManager.Deploy(deployCtx, svc, serviceContext, progress)
 				},
 			)
 
 			if err != nil {
 				da.console.StopSpinner(ctx, stepMessage, input.StepFailed)
+				if deployCtx.Err() == context.DeadlineExceeded {
+					warnMsg := fmt.Sprintf(
+						"Deployment of service '%s' exceeded the azd wait timeout."+
+							" azd has stopped waiting, but the deployment may"+
+							" still be running in Azure.",
+						svc.Name,
+					)
+					da.console.MessageUxItem(ctx, &ux.WarningMessage{
+						Description: warnMsg,
+						Hints: []string{
+							"Check the Azure Portal for current deployment status.",
+							"Increase timeout with --timeout flag or AZD_DEPLOY_TIMEOUT env var.",
+						},
+					})
+
+					return fmt.Errorf(
+						"deployment of service '%s' timed out after %d seconds. To increase, use --timeout flag "+
+							"or AZD_DEPLOY_TIMEOUT env var. Note: azd has stopped "+
+							"waiting, but the deployment may still be running in Azure. Check the Azure Portal for "+
+							"current deployment status.",
+						svc.Name,
+						int(deployTimeout.Seconds()),
+					)
+				}
 				return err
 			}
 
@@ -379,6 +437,29 @@ func (da *DeployAction) Run(ctx context.Context) (*actions.ActionResult, error)
 	}, nil
 }
 
+func (da *DeployAction) resolveDeployTimeout() (time.Duration, error) {
+	if da.flags.timeoutChanged() {
+		if da.flags.Timeout <= 0 {
+			return 0, errors.New("invalid value for --timeout: must be greater than 0 seconds")
+		}
+
+		return time.Duration(da.flags.Timeout) * time.Second, nil
+	}
+
+	if envVal, ok := os.LookupEnv("AZD_DEPLOY_TIMEOUT"); ok {
+		seconds, err := strconv.Atoi(envVal)
+		if err != nil {
+			return 0, fmt.Errorf("invalid AZD_DEPLOY_TIMEOUT value '%s': must be an integer number of seconds", envVal)
+		}
+		if seconds <= 0 {
+			return 0, fmt.Errorf("invalid AZD_DEPLOY_TIMEOUT value '%d': must be greater than 0 seconds", seconds)
+		}
+		return time.Duration(seconds) * time.Second, nil
+	}
+
+	return time.Duration(defaultDeployTimeoutSeconds) * time.Second, nil
+}
+
 func GetCmdDeployHelpDescription(*cobra.Command) string {
 	return generateCmdHelpDescription("Deploy application to Azure.", []string{
 		formatHelpNote(