Hola de nuevo a todos, en este tutorial aprenderemos a usar herramientas del dia a dia, 

Recuerda compartir el sitio con tus amigos, y compartir el canal de Youtube para completar la meta 2025 de llegar a los 10K suscriptores, asi que Dale Like! y suscribite!

ahora si, el objetivo principal de este tutorial es demostrar que crear, documentar, dockerizar y desplegar una API en la nube puede ser simple, rápido y eficiente, incluso si eres principiante en el ecosistema .NET.

Que herramientas usaremos:

  • ASP.NET Core para construir una API mínima en C#

  • Swagger (OpenAPI) para documentarla automáticamente

  • Docker para empacarla en un contenedor portable

  • Docker Hub para compartirla públicamente

  • Azure Web App for Containers para desplegarla en la nube sin complicaciones

  • CORS para que pueda ser consumida desde navegadores y clientes externos

    Paso 1: Crear el proyecto


    Debemos abrir una nueva terminal:
    dotnet new webapi -n HelloWorldApi
    cd HelloWorldApi

    Paso 2: Verifica y ajusta tu archivo .csproj ->
    esto es importante porque Docker puede fallar si las versiones no son compatibles, lo digo por experiencia propia

    <Project Sdk="Microsoft.NET.Sdk.Web">

      <PropertyGroup>
        <TargetFramework>net8.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
      </PropertyGroup>

      <ItemGroup>
        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.0" />
        <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
      </ItemGroup>

    </Project>

    Paso 3: Reemplaza el contenido de Program.cs
    te explico mas a detalle mas adelante como funciona el codigo

    var builder = WebApplication.CreateBuilder(args);

    // Swagger y CORS
    builder.Services.AddEndpointsApiExplorer();
    builder.Services.AddSwaggerGen();
    builder.Services.AddCors(options =>
    {
        options.AddDefaultPolicy(policy =>
        {
            policy.AllowAnyOrigin()
                  .AllowAnyMethod()
                  .AllowAnyHeader();
        });
    });

    // Escuchar en todas las IPs dentro del contenedor
    builder.WebHost.UseUrls("http://0.0.0.0:80");

    var app = builder.Build();

    app.UseCors();
    app.UseSwagger();
    app.UseSwaggerUI();

    app.MapGet("/", () => "Hello World desde ASP.NET Core! y Azure Guides!");

    app.Run();


    Paso 4: Ejecutar localmente

    dotnet run

    Y luego abre:

    http://localhost:5000/

    http://localhost:5000/swagger

     Paso 5: Crear un Dockerfile

    Dentro del proyecto agrega un nuevo archivo:

    FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
    WORKDIR /src
    COPY . .
    RUN dotnet publish -c Release -o /app

    FROM mcr.microsoft.com/dotnet/aspnet:8.0
    WORKDIR /app
    COPY --from=build /app .
    EXPOSE 80
    ENTRYPOINT ["dotnet", "HelloWorldApi.dll"]


    Paso 6: Build y ejecución en Docker

    docker build -t tu_usuario_docker/helloworldapi .

    docker run -d -p 8080:80 tu_usuario_docker/helloworldapi


    Accede desde tu navegador a:

    http://localhost:8080/

    http://localhost:8080/swagger


    Paso 7: Subir a Docker Hub
    Aca debes ya crear un usuario en Docker hub, lo puedes hacer directo con el login de Google
    Abre una terminal :


    docker login

    docker push tu_usuario_docker/helloworldapi


    Paso 8: Desplegar en Azure Web App

     

    Opción 1: Azure Portal

    Crear App Web Linux

    Tipo de publicación: Docker Container

    Imagen pública: tu_usuario_docker/helloworldapi:latest

    Opción 2: Azure CLI
    az webapp create \
      --resource-group tu-grupo \
      --plan tu-plan-linux \
      --name helloworld-csharp-api \
      --deployment-container-image-name tu_usuario_docker/helloworldapi


    Con solo un archivo .csproj, un Program.cs, un Dockerfile y comandos básicos, puedes tener una API .NET en producción, con documentación Swagger, CORS activado, Dockerizada y desplegada en Azure.

    Esta es una base profesional para proyectos reales, y puede extenderse fácilmente a microservicios, APIs REST complejas, bases de datos, autenticación y mucho más.

     Explicación línea por línea de Program.cs

    var builder = WebApplication.CreateBuilder(args);
    Crea el objeto principal que configura la aplicación ASP.NET Core.

    builder.Services.AddEndpointsApiExplorer();
     
    Habilita la exploración automática de endpoints para Swagger.

    builder.Services.AddSwaggerGen();
     
    Agrega el generador Swagger para documentar la API.

    builder.Services.AddCors(options =>
    {
        options.AddDefaultPolicy(policy =>
        {
            policy.AllowAnyOrigin()
                  .AllowAnyMethod()
                  .AllowAnyHeader();
        });
    });
     
    Configura CORS para aceptar peticiones desde cualquier origen, método o encabezado.

    builder.WebHost.UseUrls("http://0.0.0.0:80");
     
    Hace que la aplicación escuche en todas las direcciones IP disponibles (necesario para Docker).

    var app = builder.Build();
     
    Construye la aplicación con las configuraciones definidas.

    app.UseCors();
     
    Activa el middleware de CORS para permitir solicitudes externas.

    app.UseSwagger();
     
    Habilita el middleware para generar la documentación Swagger en tiempo de ejecución.

    app.UseSwaggerUI();
     
    Muestra la interfaz web interactiva de Swagger.

    app.MapGet("/", () => "Hello World desde ASP.NET Core! y Azure Guides!");
     
    Define un endpoint GET que devuelve un mensaje de texto como respuesta.

    app.Run();
     
    Inicia el servidor web y deja la aplicación corriendo.