const gitVersion = "foo"
	fakeclientDiscovery.FakedServerVersion = &pkgversion.Info{GitVersion: gitVersion}
	ver, err := c.Discovery().ServerVersion()
	if err != nil {
		t.Fatalf("Get ServerVersion failed.: %v", err)
	}
	if ver.GitVersion != gitVersion {
		t.Fatalf("GitVersion did not match, expected %s, got %s", gitVersion, ver.GitVersion)
	}

			continue
		}
		// if uv has tiered content we add a
		// free-version to track it for asynchronous
		// deletion via scanner.
		ver, err := x.getIdx(i)
		if err != nil {
			return err
		}

		if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
			return x.addVersion(freeVersion)
		}
		return nil
	}
	return nil

func extractKubernetesVersion(versionInfo *version.Info) (int, error) {
	ver, err := goversion.NewVersion(versionInfo.String())
	if err != nil {
		return 0, fmt.Errorf("could not parse %v", err)
	}
	// Segments provide slice of int eg: v1.19.1 => [1, 19, 1]
	num := ver.Segments()[1]
	return num, nil
}

// IsK8VersionSupported checks minimum supported Kubernetes version for Istio.

				t.Errorf("unexpected prefix: got %v wanted %v", filter.ProxyPrefixMatch, tt.expectedVersionPrefix)
			}
			for ver, match := range tt.matches {
				got := proxyMatch(&Proxy{Metadata: &NodeMetadata{IstioVersion: ver}}, filter)
				if got != match {
					t.Errorf("expected %v to match %v, got %v", ver, match, got)
				}
			}
		})
	}
}

func TestConvertEnvoyFilter(t *testing.T) {

	for v := range versions {
		sortedVersions = append(sortedVersions, v)
	}
	sort.Strings(sortedVersions)
	counts := []string{}
	for _, ver := range sortedVersions {
		counts = append(counts, fmt.Sprintf("%s (%d proxies)", ver, len(versions[ver])))
	}
	return strings.Join(counts, ", ")

Nos próximos capítulos você irá ver como adicionar segurança à sua API usando essas ferramentas disponibilizadas pelo **FastAPI**.

    }

    def "can create an alias to a referenced version"() {
        builder.version("ver", "1.7!!")
        builder.library("foo", "org", "foo").versionRef("ver")

        when:
        def model = builder.build()

        then:
        model.getDependencyData("foo").version.strictVersion == "1.7"
    }

		return nil
	}
	ca, ok := global["pilotCertProvider"].(string)
	if !ok {
		// This means the default pilotCertProvider is being used
		return nil
	}
	if ca == "kubernetes" {
		ver, err := client.GetKubernetesVersion()
		if err != nil {
			return fmt.Errorf("failed to determine support for K8s legacy signer. Use the --force flag to ignore this: %v", err)
		}

		if kube.IsAtLeastVersion(client, 22) {

			return false
		}
	}
	if cp.ProxyVersionRegex != nil {
		ver := proxy.Metadata.IstioVersion
		if ver == "" {
			// we do not have a proxy version but the user has a regex. so this is a mismatch
			return false
		}
		if !cp.ProxyVersionRegex.MatchString(ver) {
			return false
		}
	}

	for k, v := range cp.Match.Proxy.Metadata {
		if proxy.Metadata.Raw[k] != v {

# Desenvolvimento - Contribuindo

Primeiramente, você deveria ver os meios básicos para [ajudar FastAPI e pedir ajuda](help-fastapi.md){.internal-link target=_blank}.

## Desenvolvendo

Se você já clonou o repositório e precisa mergulhar no código, aqui estão algumas orientações para configurar seu ambiente.

### Ambiente virtual com `venv`

Você pode criar um ambiente virtual em um diretório utilizando o módulo `venv` do Python:

<div class="termy">