La web del Programador
Configura el .NET SDK moderno en cualquier OS usando la CLI multiplataforma DevOps

Configura el .NET SDK moderno en cualquier OS usando la CLI multiplataforma

DUGLAS MORENODUGLAS MORENO 👁 1

Introducción

Cuando trabajás con desarrollo moderno, necesitás un SDK que funcione en Windows, macOS y Linux sin sacrificar rendimiento o facilidad de uso. El dotnet CLI (interfaz de línea de comandos de .NET) es la herramienta principal para desarrollar, ejecutar y publicar aplicaciones .NET en todas las plataformas. Este tutorial te guía paso a paso para instalar y configurar el .NET SDK más reciente en Windows, macOS y Linux, verifica que todo esté bien, y luego crea y ejecuta una aplicación de consola sencilla, mostrando cada comando y la salida esperada.

A quién va dirigido este artículo

  • Desarrolladores principiantes que acaban de elegir .NET y necesitan un setup limpio.
  • Programadores que trabajan en equipos multiplataforma y necesitan el mismo SDK en cada máquina.
  • Estudiantes y entusiastas que quieren un tutorial práctico con ejemplos que pueden copiar y pegar.

Qué vas a aprender

  • Cómo elegir la opción de instalación correcta según tu sistema operativo.
  • Cómo instalar el SDK usando el instalador oficial, administradores de paquetes y contenedores de Docker.
  • Cómo verificar la instalación con dotnet --version y dotnet --info.
  • Cómo crear un nuevo proyecto, compilarlo y ejecutarlo paso a paso.
  • Cómo publicar una aplicación para diferentes sistemas operativos y arquitecturas.
  • Trucos útiles y errores comunes para evitar.

Requisitos del sistema

Componente Versión mínima Por qué es importante
Sistema operativo Windows 10 (v1809+), macOS 10.13+, Linux (distribuciones recientes) El SDK funciona en estos sistemas sin limitaciones.
CPU 64-bit x86 o ARM64 La compilación .NET es completamente de 64 bits.
Memoria RAM 4 GB (mínimo) Suficiente para SDK y proyectos pequeños.
Espacio en disco ~500 MB para el SDK + espacio para tus proyectos El SDK es compacto; tenés espacio para muchas aplicaciones.

Si tus máquinas cumplen con estos requisitos, estás listo para empezar.

Instalación en diferentes sistemas operativos

Windows – Usando el instalador oficial

  1. Descargá el instalador desde https://learn.microsoft.com/en-us/dotnet/core/install/windows.
  2. Ejecutá el archivo .exe y seguí la interfaz gráfica. Elegí Visual Studio si ya lo usás, o elige Spotify (que instala solo el SDK de .NET y la CLI) si querés solo el SDK.
  3. Marcar Agregar dotnet al PATH del sistema para que la CLI esté disponible desde cualquier PowerShell o CMD.
  4. Clickea Instalar y esperá. El instalador mostrará el progreso y los tamaños de los componentes.

Una vez completada la instalación, abrí una nueva ventana de PowerShell y corrés:

dotnet --version

Salida esperada (puede variar con la versión más nueva):

7.0.12

macOS – Homebrew o instalador oficial

Homebrew (lo más rápido si ya tenés Homebrew)

brew install --formula dotnet

Tras la instalación, ejecutá:

dotnet --version

Salida esperada:

7.0.12

Instalador oficial (si preferís la última versión sin Homebrew)

curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --channel 7.0

Esto descarga el script de install, lo ejecuta y agrega el binario a /usr/local/dotnet. El script mostrará qué archivo está descargando y dónde lo instala.

Verifica con:

dotnet --info

La salida incluirá:

Registro de SDK de .NET:
  Versión de .NET SDK: 7.0.12
  Versión de .NET Runtime: 7.0.12
  Ruta del SDK: /usr/local/dotnet/sdk/7.0.12/

Linux – Distribuciones apt, yum/dnf y snapshot

Ubuntu / Debian (apt)

sudo apt-get update
sudo apt-get install -y dotnet

El paquete apt instala la versión 7.0.12 en este momento. Verifica:

dotnet --version

Salida esperada:

7.0.12

Fedora / CentOS / RHEL (yum/dnf)

sudo dnf install -y dotnet

De nuevo, dotnet --version debería mostrar 7.0.12.

Instalación manual (cualquier distro)

Si tu distro no provee aún un paquete, podés usar el script oficial:

curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --channel 7.0 --prefix /usr/share/dotnet

Esto copia el SDK a /usr/share/dotnet y agrega ese directorio al PATH (si no lo hizo ya el script).

Verificación – Asegurándote que todo funcione

Comprobando la versión del SDK

dotnet --version

Obteniendo detalles del SDK y runtime

dotnet --info

Las líneas más importantes que buscas son:

Registro de SDK de .NET:
  Versión de .NET SDK: 7.0.12
  Versión de .NET Runtime: 7.0.12
  Ruta del SDK: /ruta/al/sdk/7.0.12/

Si ves una versión 7.x.x, estás usando el SDK moderno y compatible con los lenguajes C#, F# y VB más nuevos.

Comprobando la instalación de la CLI

dotnet --list-sdks

Salida esperada (puede haber múltiples versiones si tenés instaladas ambas):

7.0.12 [/usr/local/dotnet/sdk/7.0.12/]

Instalando el SDK de .NET para una versión específica del lenguaje

Si más adelante necesitás la versión 8.0, instalásla así:

curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --channel 8.0

Luego dotnet --list-sdks mostrará ambas versiones:

7.0.12 [/usr/local/dotnet/sdk/7.0.12/]
8.0.0 [/usr/local/dotnet/sdk/8.0.0/]

Creando una primera aplicación de consola

Paso 1 – Crear un nuevo proyecto

dotnet new console -o hello-world

dotnet new crea una aplicación de consola minimal. El switch -o especifica la carpeta de salida hello-world. Esperá un momento; deberías ver mensajes como:

El proyecto C# ha sido creado exitosamente en ...

Se generaron los siguientes archivos:
  /home/usuario/hello-world/Program.cs
  /home/usuario/hello-world/HelloWorld.csproj

Paso 2 – Examinando el archivo generado

El archivo Program.cs contiene típicamente:

using System;

namespace hello_world
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

Paso 3 – Compilando el proyecto

Navegá a la carpeta del proyecto:

cd hello-world
dotnet build

La compilación mostrará algo así:

Proyecto HelloWorld (/home/usuario/hello-world/HelloWorld.csproj) -> /home/usuario/hello-world/bin/Debug/net7.0/HelloWorld.dll

Si no hay errores, el binario .dll está listo.

Paso 4 – Ejecutando el programa

dotnet run

La salida esperada es:

Hello, World!

Eso es todo – acabás de ejecutar tu primera aplicación .NET.

Publicando para diferentes sistemas operativos

Una de las mayores fortalezas de .NET es la publicación multiplataforma. dotnet publish compila la aplicación para el sistema operativo y la arquitectura que especifiques, sin necesidad de un contenedor.

Publicando en Windows (x64)

cd hello-world
dotnet publish -c Release -r win-x64

Después de la compilación, encontrarás una carpeta bin/Release/net7.0/win-x64/publish. Dentro de esa carpeta estarán los archivos .dll, program.exe, y cualquier recurso necesario.

Publicando en Linux (x64)

dotnet publish -c Release -r linux-x64

Resultado: bin/Release/net7.0/linux-x64/publish con un binario estático (si usaste --self-contained). La salida esperada es:

Información compilada:
   JIT: x64

Publicando en macOS (ARM64)

dotnet publish -c Release -r osx-arm64

Genera un binario optimizado para Apple Silicon.

Publicando una aplicación con dependencia del runtime (RDS)

Si preferís un DLL más pequeño pero necesitás el runtime de .NET instalado en la máquina destino, omití el -r:

dotnet publish -c Release

Esto crea bin/Release/net7.0/publish, donde podés copiar y pegar el .dll y el archivo .runtimeconfig.json en cualquier máquina con el SDK de .NET (o runtime) instalado.

Configurando el SDK dentro de un contenedor Docker

Los desarrolladores a menudo usan contenedores para mantener entornos aislados. La imagen oficial mcr.microsoft.com/dotnet/sdk incluye el SDK y el runtime.

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

COPY . ./
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS final
WORKDIR /app
COPY --from=build /app/publish ./

ENTRYPOINT ["dotnet", "HelloWorld.dll"]

Este Dockerfile compila la aplicación, la publica y correla usando la imagen más liviana de ASP.NET. Puedes construir e ejecutar:

docker build -t dotnet-hello-world .
docker run --rm dotnet-hello-world

La salida mostrará Hello, World! dentro del contenedor.

Mantenimiento del SDK y buenas prácticas

  • Elegí un canal de soporte a largo plazo (LTS) a menos que necesites las últimas características. La versión LTS más reciente es .NET 6 (soportada hasta noviembre de 2024). Si estás en un entorno de producción, usa LTS.
  • Mantené versiones exactas con global.json. Creá un archivo global.json en tu repositorio raíz con la versión del SDK que querés forzar:
{
  "sdk": {
    "version": "7.0.12"
  }
}

El CLI lo leerá automáticamente, asegurando builds consistentes.

  • Evitá instalar múltiples SDK al mismo tiempo si no necesitas versiones paralelas. Borrá el directorio del SDK antiguo (/usr/local/dotnet/sdk/6.0.*) o desinstálalo usando el gestor de paquetes del sistema.

  • Usá las variables de entorno DOTNET_ROOT y PATH correctamente. Si instalaste manualmente el SDK, agregá su carpeta binaria al PATH del sistema, o exportá DOTNET_ROOT en tu shell:

export DOTNET_ROOT=$HOME/.dotnet
export PATH=$PATH:$DOTNET_ROOT/dotnet
  • Habilitá la suma de verificación de la instalación. El script de instalación soporta --checksum, pero la mayoría de los usuarios confían en la clave pública de Microsoft para verificar la integridad.

Errores comunes y cómo evitarlos

Síntoma Causa típica Solución rápida
dotnet: comando no encontrado SDK no está en PATH Reinstalá y marcá Agregar a PATH, o exportá manualmente DOTNET_ROOT.
La versión del SDK X no se encuentra Intentás usar una versión más nueva de SDK que la instalada. Instalá la versión faltante o actualizá global.json.
No se puede resolver el SDK de .NET al correr dotnet --info Ruta del SDK incorrecta en DOTNET_ROOT. Borra el SDK antiguo y reinstalá en una ubicación limpia.
dotnet publish falla con --self-contained en Linux Intentás crear un binario estático para una arquitectura que el SDK no soporta. Usá -r linux-x64 o -r linux-arm64 según tu CPU.
dotnet run lanza System.TypeLoadException Corriendo una DLL compilada con un runtime diferente (por ejemplo, .NET 5 vs .NET 7). Asegurate de ejecutar con el SDK correcto (dotnet --list-sdks).

Conclusión

Configurar el .NET SDK moderno con la CLI multiplataforma es un proceso rápido y bien documentado. Siguiendo los pasos en este tutorial, podés tener el SDK funcionando en Windows, macOS y Linux, crear y ejecutar una aplicación de consola, y publicar para cualquier sistema operativo que necesites. Recaldamos la importancia de:

  • Elegir el método de instalación adecuado para tu OS.
  • Verificar la versión del SDK con dotnet --version y dotnet --info.
  • Usar global.json para un control preciso de versiones.
  • Seguir buenas prácticas como elegir la versión LTS y mantener un solo SDK activo.

Ahora podés centrarte en escribir código en lugar de lidiar con problemas de instalación. ¡Feliz programación!.

dotnetsetupclimultiplatformtutorial

Comentarios (0)

Sé el primero en comentar.

Dejá tu comentario