- apiVersion: gateway.networking.k8s.io/v1beta1
        kind: Gateway
        name: "{{.Name}}"
        uid: "{{.UID}}"
      {{- end }}
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: {{.DeploymentName | quote}}
      namespace: {{.Namespace | quote}}
      annotations:

      - apiVersion: gateway.networking.k8s.io/v1beta1
        kind: Gateway
        name: "{{.Name}}"
        uid: "{{.UID}}"
      {{- end }}
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: {{.DeploymentName | quote}}
      namespace: {{.Namespace | quote}}
      annotations:

				bucketsToBeUpdated.Add(bucket.Name)
				continue
			}

			// No IPs seem to intersect, this means that bucket exists but has
			// different IP addresses perhaps from a different deployment.
			// bucket names are globally unique in federation at a given
			// path prefix, name collision is not allowed. We simply log
			// an error and continue.
			bucketsInConflict.Add(bucket.Name)
		}
	}

=== Using the `Copy` task

When working with application servers, you can use a `Copy` task to deploy the application archive (e.g. a WAR file).
Since you are deploying a single file, the destination directory of the `Copy` is the whole deployment directory.

	WorkloadType_JOB        WorkloadType = 3
)

// Enum value maps for WorkloadType.
var (
	WorkloadType_name = map[int32]string{
		0: "DEPLOYMENT",
		1: "CRONJOB",
		2: "POD",
		3: "JOB",
	}
	WorkloadType_value = map[string]int32{
		"DEPLOYMENT": 0,
		"CRONJOB":    1,
		"POD":        2,
		"JOB":        3,
	}
)

func (x WorkloadType) Enum() *WorkloadType {
	p := new(WorkloadType)

			for _, p := range pods {
				grace := p.Spec.TerminationGracePeriodSeconds
				if grace != nil && *grace == want {
					return true
				}
			}
			return false
		}
		// check that waypoint deployment is unmodified
		retry.UntilOrFail(t, func() bool {
			return getGracePeriod(2)
		})
		// change the waypoint template
		istio.GetOrFail(t, t).UpdateInjectionConfig(t, func(cfg *inject.Config) error {

		} else {
			reason = string(k8s.GatewayReasonAddressNotUsable)
		}
		gatewayConditions[string(k8s.GatewayConditionProgrammed)].error = &ConfigError{
			// TODO: this only checks Service ready, we should also check Deployment ready?
			Reason:  reason,
			Message: msg,
		}
	}
	obj.Status.(*kstatus.WrappedStatus).Mutate(func(s config.Status) config.Status {
		gs := s.(*k8s.GatewayStatus)
		addressesToReport := external

		if err != nil {
			return nil, err
		}

		if deploymentID == "" {
			// all pools should have same deployment ID
			deploymentID = formats[i].ID
		}

		// Validate if users brought different DeploymentID pools.
		if deploymentID != formats[i].ID {
			return nil, fmt.Errorf("all pools must have same deployment ID - expected %s, got %s for pool(%s)", deploymentID, formats[i].ID, humanize.Ordinal(i+1))
		}

build:android_x86_64 --config=android
build:android_x86_64 --cpu=x86_64
build:android_x86_64 --fat_apk_cpu=x86_64

# Build everything statically for Android since all static libs are later
# bundled together into a single .so for deployment.
build:android --dynamic_mode=off

# Sets the default Apple platform to macOS.
build:macos --apple_platform_type=macos

# gRPC on MacOS requires this #define
build:macos --copt=-DGRPC_BAZEL_BUILD

// of endpoints associated with mesh services, and calling the EDSUpdate on changes.
// A registry may group endpoints for a service in smaller subsets - for example by
// deployment, or to deal with very large number of endpoints for a service. We want
// to avoid passing around large objects - like full list of endpoints for a registry,