Contenerizar una aplicación de .NET Core

Se aplica a: Windows Server 2025, Windows Server 2022, Windows Server 2019, Windows Server 2016

En este tema se describe cómo empaquetar una aplicación de .NET de ejemplo existente para la implementación como un contenedor de Windows, después de configurar el entorno, tal como se describe en Introducción a Windows: Preparación de Windows para contenedoresy ejecución del primer contenedor como se describe en Ejecutar el primer contenedor de Windows.

También necesitará el sistema de control de código fuente de Git instalado en el equipo. Para instalarlo, visite Git.

Clonación del código de ejemplo desde GitHub

Todo el código fuente de ejemplo de contenedor se mantiene en el repositorio git de Virtualization-Documentation en una carpeta denominada windows-container-samples.

1. Abra una sesión de PowerShell y cambie los directorios a la carpeta en la que desea almacenar este repositorio. (Otros tipos de ventanas de la línea de comandos también funcionan, pero nuestros comandos de ejemplo utilizan PowerShell).

2. Clona el repositorio en el directorio de trabajo actual.

   git clone https://github.com/MicrosoftDocs/Virtualization-Documentation.git
   

3. Vaya al directorio de ejemplo que se encuentra en Virtualization-Documentation\windows-container-samples\asp-net-getting-started y cree un Dockerfile con los siguientes comandos.

   Un dockerfile es como un archivo Make, es una lista de instrucciones que indican al motor de contenedor cómo compilar la imagen de contenedor.

   # Navigate into the sample directory
   Set-Location -Path Virtualization-Documentation\windows-container-samples\asp-net-getting-started
   
   # Create the Dockerfile for our project
   New-Item -Name Dockerfile -ItemType file
   

Escritura de Dockerfile

Abra el Archivo Dockerfile que acaba de crear con el editor de texto que desee y agregue el siguiente contenido:

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

COPY *.csproj ./
RUN dotnet restore

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

FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Vamos a desglosarlo de línea a línea y explicar lo que hace cada una de las instrucciones.

FROM mcr.microsoft.com/dotnet/core/sdk:2.1 AS build-env
WORKDIR /app

El primer grupo de líneas declara la imagen base que se usará para crear el contenedor. Si el sistema local aún no tiene esta imagen, Docker intentará capturarla automáticamente. El mcr.microsoft.com/dotnet/core/sdk:2.1 viene empaquetado con el SDK de .NET Core 2.1 instalado, por lo que está preparado para compilar proyectos de ASP.NET Core dirigidos a la versión 2.1. La siguiente instrucción cambia el directorio de trabajo de nuestro contenedor para que sea /app, por lo que todos los comandos siguientes a este se ejecutan en este contexto.

COPY *.csproj ./
RUN dotnet restore

A continuación, estas instrucciones copian los archivos .csproj hacia el directorio /app del contenedor build-env. Después de copiar este archivo, .NET leerá de él y, a continuación, extraerá y capturará todas las dependencias y herramientas necesarias para nuestro proyecto.

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

Una vez que .NET ha extraído todas las dependencias en el contenedor de build-env, la siguiente instrucción copia todos los archivos de origen del proyecto en el contenedor. A continuación, le decimos a .NET que publique nuestra aplicación con una configuración de versión y especifique la ruta de salida.

La compilación debería tener éxito. Ahora debemos crear la imagen final.

Sugerencia

En este inicio rápido se compila un proyecto de .NET Core a partir del origen. Al crear imágenes de contenedor, se recomienda incluir solo la carga de producción y sus dependencias en la imagen de contenedor. No queremos que el SDK de .NET Core se incluya en nuestra imagen final porque solo necesitamos el entorno de ejecución de .NET Core, por lo que el dockerfile se escribe para usar un contenedor temporal que se empaqueta con el SDK llamado build-env para compilar la aplicación.

FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "asp-net-getting-started.dll"]

Dado que la aplicación es ASP.NET, especificamos una imagen con este tiempo de ejecución incluido. A continuación, copiamos todos los archivos del directorio de salida de nuestro contenedor temporal en nuestro contenedor final. Configuramos el contenedor para que se ejecute con nuestra nueva aplicación como punto de entrada cuando se inicia el contenedor.

Se ha escrito el Dockerfile para realizar una compilación de varias fases. Cuando se ejecuta el dockerfile, usa el contenedor temporal, build-env, con el SDK de .NET Core 2.1 para compilar la aplicación de ejemplo y, a continuación, copia los archivos binarios generados en otro contenedor que contiene solo el entorno de ejecución de .NET Core 2.1 para que se minimice el tamaño del contenedor final.

Compilación y ejecución de la aplicación

Con el Dockerfile escrito, podemos apuntar a Docker en nuestro Dockerfile y indicarle que compile y, a continuación, ejecute nuestra imagen:

1. En una ventana de la terminal, vaya al directorio donde reside el Dockerfile y, a continuación, ejecute el comando docker build para construir el contenedor desde el Dockerfile.

   docker build -t my-asp-app .
   

2. Para ejecutar el contenedor recién compilado, ejecute el comando docker run.

   docker run -d -p 5000:80 --name myapp my-asp-app
   

   Vamos a diseccionar este comando:

   • -d indica a Docker que ejecute el contenedor "desasociado", lo que significa que no se enlaza ninguna consola a la consola dentro del contenedor. El contenedor se ejecuta en segundo plano.
   • -p 5000:80 indica a Docker que asigne el puerto 5000 en el host al puerto 80 del contenedor. Cada contenedor obtiene su propia dirección IP. ASP .NET escucha de forma predeterminada en el puerto 80. La asignación de puertos nos permite ir a la dirección IP del host en el puerto asignado y Docker reenvía todo el tráfico al puerto de destino dentro del contenedor.
   • --name myapp indica a Docker que asigne a este contenedor un nombre conveniente para realizar consultas (en lugar de tener que buscar el identificador de contenedor asignado en tiempo de ejecución por Docker).
   • my-asp-app es la imagen que queremos que Docker ejecute. Esta es la imagen de contenedor generada como la culminación del proceso de docker build.

3. Abra un explorador web y vaya a http://localhost:5000 para ver la aplicación en contenedor.

   

Pasos siguientes

1. El siguiente paso consiste en publicar la aplicación web ASP.NET contenedorizada en un registro privado mediante Azure Container Registry. Esto le permite implementarlo en la organización.

   Crear un registro de contenedor privado

   Cuando llegue a la sección donde la imagen de contenedor se inserta en el registro, especifique el nombre de la aplicación ASP.NET que acaba de empaquetar (my-asp-app) junto con el registro de contenedor (por ejemplo: contoso-container-registry):

   docker tag my-asp-app contoso-container-registry.azurecr.io/my-asp-app:v1
   

   Para ver más ejemplos de aplicaciones y sus dockerfiles asociados, consulte ejemplos adicionales de contenedores.

2. Una vez publicada la aplicación en el registro de contenedor, el siguiente paso es implementar la aplicación en un clúster de Kubernetes que cree con Azure Kubernetes Service.

   Creación de un clúster de Kubernetes