0Pricing
C# Academy · Aula

Documentando APIs versionadas

Disponibilize a documentação para várias versões da API.

Documentando APIs versionadas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Um documento por versão

Quando uma API tem várias versões, normalmente você quer um documento OpenAPI separado para cada versão, para que os consumidores vejam somente os pontos de extremidade relevantes para eles.

// /openapi/v1.json -> only v1 endpoints
// /openapi/v2.json -> only v2 endpoints

O provedor de descrições de versões da API

O Asp.Versioning expõe IApiVersionDescriptionProvider, que lista todas as versões de API descobertas. Você percorre essa lista para registrar um documento por versão.

var provider = app.Services
    .GetRequiredService<IApiVersionDescriptionProvider>();

foreach (var desc in provider.ApiVersionDescriptions)
{
    // desc.GroupName is e.g. "v1", "v2"
}

Registrando um documento por versão

Chame AddOpenApi uma vez para cada grupo de versões, nomeando cada documento com o nome do grupo.

builder.Services
    .AddApiVersioning()
    .AddApiExplorer(o =>
    {
        o.GroupNameFormat = "'v'VVV";
        o.SubstituteApiVersionInUrl = true;
    });

builder.Services.AddOpenApi("v1");
builder.Services.AddOpenApi("v2");

Filtrando pontos de extremidade para o documento correto

Use um transformador de documento ou o predicado ShouldInclude para que cada documento contenha somente os pontos de extremidade da sua versão, identificados pelo nome do grupo.

builder.Services.AddOpenApi("v1", options =>
{
    options.ShouldInclude = description =>
        description.GroupName == "v1";
});

Mapeando os documentos

MapOpenApi, com o padrão padrão, disponibiliza cada documento nomeado em /openapi/{documentName}.json.

app.MapOpenApi();
// /openapi/v1.json and /openapi/v2.json both available

Definindo informações por documento

Forneça a cada documento de versão seu próprio título e sua própria versão em um transformador, para que a documentação seja autoexplicativa.

builder.Services.AddOpenApi("v2", options =>
{
    options.AddDocumentTransformer((doc, ctx, ct) =>
    {
        doc.Info.Title = "Catalog API v2";
        doc.Info.Version = "2.0";
        return Task.CompletedTask;
    });
});

Marcando versões descontinuadas na documentação

Se uma versão estiver descontinuada, informe isso na descrição do documento para que os consumidores vejam o aviso na interface.

options.AddDocumentTransformer((doc, ctx, ct) =>
{
    if (ctx.DocumentName == "v1")
        doc.Info.Description = "DEPRECATED - migrate to v2.";
    return Task.CompletedTask;
});

Substituindo a versão nas URLs

SubstituteApiVersionInUrl = true reescreve o token de rota {version:apiVersion} como a versão concreta (por exemplo, v1) no documento, para que os caminhos sejam exibidos de forma clara.

// Without: /api/v{version}/products
// With:    /api/v1/products

Uma guia da interface por versão

A maioria dos visualizadores pode mostrar uma lista suspensa com todos os documentos. Configure a interface para apontar para o JSON de cada versão.

app.MapScalarApiReference(options =>
{
    options.AddDocument("v1", "API v1", "/openapi/v1.json");
    options.AddDocument("v2", "API v2", "/openapi/v2.json");
});

Documentando formatos de solicitação e resposta

Como a v2 pode alterar os DTOs, forneça a cada versão seus próprios tipos de DTO. Assim, o OpenAPI renderiza automaticamente esquemas distintos em cada documento.

// V1 DTO
public record ProductV1(int Id, string Name);
// V2 DTO (breaking change)
public record ProductV2(int Id, string Title, decimal Price);

Combinando tudo

O fluxo completo é: configurar o versionamento e o API Explorer, registrar um documento OpenApi por versão com um filtro, mapeá-los e direcionar a interface para cada um deles.

builder.Services.AddApiVersioning().AddApiExplorer(o =>
{
    o.GroupNameFormat = "'v'VVV";
    o.SubstituteApiVersionInUrl = true;
});
builder.Services.AddOpenApi("v1");
builder.Services.AddOpenApi("v2");
// ...
app.MapOpenApi();
app.MapScalarApiReference();

Verificação rápida

Confirme como a documentação versionada é produzida.

Recapitulação

Você documentou APIs versionadas:

  • Registre um documento OpenAPI nomeado por versão com AddOpenApi("vN").
  • IApiVersionDescriptionProvider enumera as versões; ShouldInclude filtra os pontos de extremidade.
  • SubstituteApiVersionInUrl renderiza caminhos versionados com a versão concreta.
  • Aponte a interface para cada documento para obter uma visualização por versão.

Com isso, o curso de versionamento e OpenAPI está concluído.

Perguntas Frequentes

A aula “Documentando APIs versionadas” é grátis?

Sim — o texto completo de “Documentando APIs versionadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Documentando APIs versionadas”?

Disponibilize a documentação para várias versões da API. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Documentando APIs versionadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Estratégias de versionamento de API
  2. Configurando Asp.Versioning
  3. Gerando documentos OpenAPI
  4. Documentando APIs versionadas
← Voltar para C# Academy