```bash
kubectl apply -f helloworld.yaml
```

Alternatively, you can run just one version at a time by first defining the service:

```bash
kubectl apply -f helloworld.yaml -l service=helloworld
```

and then deploying version v1, v2, or both:

```bash
kubectl apply -f helloworld.yaml -l version=v1
kubectl apply -f helloworld.yaml -l version=v2
```

For even more flexibility, there is also a script, `gen-helloworld.sh`, that will

	})
	c.namespaces = kclient.NewFiltered[*v1.Namespace](kubeClient, kclient.Filter{
		ObjectFilter: kube.FilterIfEnhancedFilteringEnabled(kubeClient),
	})
	// kube-system is not skipped to enable deploying ztunnel in that namespace
	c.ignoredNamespaces = inject.IgnoredNamespaces.Copy().Delete(constants.KubeSystemNamespace)

                                    + now
                                    + ", lastUpdated = " + lastUpdated + "). Please verify that the clocks of all"
                                    + " deploying machines are reasonably synchronized.");
                    versioning.setLastUpdated(now);
                    changed = true;
                }
            }
        }

        if (changed) {

//     to ensure that the various parts of the program be made available
//     in the correct location in the file system (or container image).
//     By contrast, deploying an application consisting of a single static
//     executable is straightforward.
//
//   - Reasoning about program initialization is more difficult when
//     some packages may not be initialized until long after the

	VARIANT Variable = "VARIANT"

	// PULL_POLICY is the image pull policy to use when rendering templates.
	// nolint: revive, stylecheck
	PULL_POLICY Variable = "PULL_POLICY"

	// ECHO_IMAGE is the image to use when deploying echo services.
	// nolint: golint, revive, stylecheck
	ECHO_IMAGE Variable = "ECHO_IMAGE"

	// GRPC_ECHO_IMAGE is the image to use for a separate gRPC-only container in echo Pods.
	// nolint: golint, revive, stylecheck

## Adopters

The [User Case Studies](https://kubernetes.io/case-studies/) website has real-world use cases of organizations across industries that are deploying/migrating to Kubernetes.

## Governance 

Kubernetes project is governed by a framework of principles, values, policies and processes to help our community and constituents towards our shared goals.

					scopes.Framework.Errorf("failed updating namespace %s on cluster %s. This can happen when deploying "+
						"multiple control planes. Error: %v", i.cfg.SystemNamespace, c.Name(), err)
				}
			} else {
				scopes.Framework.Errorf("failed creating namespace %s on cluster %s. This can happen when deploying "+
					"multiple control planes. Error: %v", i.cfg.SystemNamespace, c.Name(), err)
			}
		}

func TestMain(m *testing.M) {
	// nolint: staticcheck
	framework.
		NewSuite(m).
		RequireMultiPrimary().
		// Requires two CPs with specific names to be configured.
		Label(label.CustomSetup).
		// We are deploying two isolated environments, which CNI doesn't support.
		// We could deploy one of the usergroups as the CNI owner, but for now we skip
		SkipIf("CNI is not suppored", func(ctx resource.Context) bool {

# FastAPI in Containers - Docker

When deploying FastAPI applications a common approach is to build a **Linux container image**. It's normally done using <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. You can then deploy that container image in one of a few possible ways.

Using Linux containers has several advantages including **security**, **replicability**, **simplicity**, and others.

!!! tip

	// packages. For example: `go test $(go list ./... | grep -v bad-package)`.
	SkipString  ArrayFlags
	SkipMatcher *Matcher

	// SkipWorkloadClasses can be used to skip deploying special workload types like TPROXY, VMs, etc.
	SkipWorkloadClasses ArrayFlags

	// OnlyWorkloadClasses can be used to only deploy specific workload types like TPROXY, VMs, etc.
	OnlyWorkloadClasses ArrayFlags