try {
            envMap.put("COMPUTERNAME", "xxx");
            assertEquals("xxx", systemHelper.getHostname());
        } finally {
            envMap.remove("COMPUTERNAME");
        }
        try {
            envMap.put("HOSTNAME", "yyy");
            assertEquals("yyy", systemHelper.getHostname());
        } finally {
            envMap.remove("HOSTNAME");
        }
    }

		outEnv := make([]map[string]any, len(envMap))
		keys := make([]string, 0, len(envMap))
		for k := range envMap {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		for i, k := range keys {
			outEnv[i] = make(map[string]any)
			outEnv[i]["name"] = k
			outEnv[i]["value"] = fmt.Sprintf("%v", envMap[k])
		}

// The returned Request's Body is populated, if applicable.
func Request() (*http.Request, error) {
	r, err := RequestFromMap(envMap(os.Environ()))
	if err != nil {
		return nil, err
	}
	if r.ContentLength > 0 {
		r.Body = io.NopCloser(io.LimitReader(os.Stdin, r.ContentLength))
	}
	return r, nil
}

func envMap(env []string) map[string]string {
	m := make(map[string]string)
	for _, kv := range env {

	keys := make([]string, 0, len(params))
	for k := range params {
		keys = append(keys, k)
	}
	slices.Sort(keys)
	for _, key := range keys {
		fmt.Printf("param-%s=%s\r\n", key, params.Get(key))
	}

	envs := envMap(os.Environ())
	keys = make([]string, 0, len(envs))
	for k := range envs {
		keys = append(keys, k)
	}
	slices.Sort(keys)
	for _, key := range keys {
		fmt.Printf("env-%s=%s\r\n", key, envs[key])
	}

		envVars := candidates.ToSlice()
		for _, envVar := range envVars {
			for _, param := range validKeys {
				pEnvName := getEnvVarName(subSys, Default, param) + Default
				if len(envVar) > len(pEnvName) && strings.HasPrefix(envVar, pEnvName) {
					// This envVar is valid - it has a
					// non-empty target.
					candidates.Remove(envVar)
				}
			}
		}

func ExpandContainerVolumeMounts(mount v1.VolumeMount, envs []EnvVar) (string, error) {

	envmap := envVarsToMap(envs)
	missingKeys := sets.New[string]()
	expanded := expansion.Expand(mount.SubPathExpr, func(key string) string {
		value, ok := envmap[key]
		if !ok || len(value) == 0 {
			missingKeys.Insert(key)
		}
		return value

				}
			} else {
				for _, env := range args {
					i := strings.Index(env, "=")
					if i < 0 {
						// Display value instead of setting it.
						fmt.Fprintf(out, "%s=%s\n", env, s.envMap[env])
						continue
					}
					if err := s.Setenv(env[:i], env[i+1:]); err != nil {
						return nil, err
					}
				}
			}
			var wait WaitFunc
			if out.Len() > 0 || len(args) == 0 {

# Corpo da Requisição

Quando você precisa enviar dados de um cliente (como de um navegador web) para sua API, você o envia como um **corpo da requisição**.

O corpo da **requisição** é a informação enviada pelo cliente para sua API. O corpo da **resposta** é a informação que sua API envia para o cliente.

Sua API quase sempre irá enviar um corpo na **resposta**. Mas os clientes não necessariamente precisam enviar um corpo em toda **requisição**.

```Python hl_lines="7"
{!../../../docs_src/request_forms/tutorial001.py!}
```

Por exemplo, em uma das maneiras que a especificação OAuth2 pode ser usada (chamada "fluxo de senha"), é necessário enviar um `username` e uma `password` como campos do formulário.

A <abbr title="especificação">spec</abbr> exige que os campos sejam exatamente nomeados como `username` e `password` e sejam enviados como campos de formulário, não JSON.

		}
	}
	return envs
}

// MergeKubeadmEnvVars merges values of environment variable slices.
// The values defined in later slices overwrite values in previous ones.
func MergeKubeadmEnvVars(envList ...[]kubeadmapi.EnvVar) []v1.EnvVar {
	m := make(map[string]v1.EnvVar)
	merged := []v1.EnvVar{}
	for _, envs := range envList {
		for _, env := range envs {
			m[env.Name] = env.EnvVar
		}
	}