# Containerizar una aplicación .NET


## Requisitos previos

- Has instalado la última versión de [Docker Desktop](/get-started/get-docker/).
- Tienes un [cliente de git](https://git-scm.com/downloads). Los ejemplos de esta sección utilizan un cliente de git basado en línea de comandos, pero puedes utilizar cualquier cliente.

## Resumen

Esta sección te guía a través de la containerización y ejecución de una aplicación .NET.

## Obtener las aplicaciones de ejemplo

En esta guía, utilizarás una aplicación .NET preconstruida. La aplicación es similar a la que se construye en el artículo del Blog de Docker, [Building a Multi-Container .NET App Using Docker Desktop](https://www.docker.com/blog/building-multi-container-net-app-using-docker-desktop/).

Abre una terminal, cambia al directorio en el que deseas trabajar y ejecuta el siguiente comando para clonar el repositorio.

```console
$ git clone https://github.com/docker/docker-dotnet-sample
```

## Inicializar los recursos de Docker

Ahora que tienes una aplicación, puedes crear los recursos de Docker necesarios para containerizarla. Puedes elegir entre utilizar las imágenes oficiales de .NET o las Docker Hardened Images (DHI).

> Las [Docker Hardened Images (DHIs)](https://docs-docker.esdocu.com/dhi/) son imágenes de aplicación y base de contenedor mínimas, seguras y listas para producción mantenidas por Docker. Se recomiendan las imágenes DHI para obtener una mejor seguridad: están diseñadas para reducir las vulnerabilidades y simplificar el cumplimiento normativo.

**Usar Docker Hardened Images**



Las Docker Hardened Images (DHIs) para .NET están disponibles en el [catálogo de Docker Hardened Images](https://hub.docker.com/hardened-images/catalog/dhi/aspnetcore). Las Docker Hardened Images están disponibles gratuitamente para todos, sin necesidad de suscripción. Puedes descargarlas y utilizarlas como cualquier otra imagen de Docker después de iniciar sesión en el registro DHI. Para obtener más información, consulta la guía de [inicio rápido de DHI](/dhi/get-started/).

1. Inicia sesión en el registro DHI:

   ```console
   $ docker login dhi.io
   ```

2. Descarga la DHI del SDK de .NET (consulta el catálogo para ver las versiones disponibles):

   ```console
   $ docker pull dhi.io/dotnet:10-sdk
   ```

3. Descarga la DHI del tiempo de ejecución (runtime) de ASP.NET Core (consulta el catálogo para ver las versiones disponibles):
   ```console
   $ docker pull dhi.io/aspnetcore:10
   ```

Puedes usar `docker init` para generar los recursos de Docker y luego modificar el Dockerfile para usar imágenes DHI:

```console
$ docker init
Welcome to the Docker Init CLI!

This utility will walk you through creating the following files with sensible defaults for your project:
  - .dockerignore
  - Dockerfile
  - compose.yaml
  - README.Docker.md

Let's get started!

? What application platform does your project use? ASP.NET Core
? What's the name of your solution's main project? myWebApp
? What version of .NET do you want to use? 10.0
? What local port do you want to use to access your server? 8080
```

En el siguiente Dockerfile, las instrucciones `FROM` utilizan `dhi.io/dotnet:10-sdk` y `dhi.io/aspnetcore:10` como imágenes base.

```dockerfile {title=Dockerfile}
# syntax=docker/dockerfile:1

FROM --platform=$BUILDPLATFORM dhi.io/dotnet:10-sdk AS build
ARG TARGETARCH
COPY . /source
WORKDIR /source/src
RUN --mount=type=cache,id=nuget,target=/root/.nuget/packages \
    dotnet publish -a ${TARGETARCH/amd64/x64} --use-current-runtime --self-contained false -o /app

FROM dhi.io/aspnetcore:10 AS final
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "myWebApp.dll"]
```

> [!NOTE]
>
> Las imágenes de tiempo de ejecución de DHI ya se ejecutan como un usuario no raíz (`nonroot`, UID 65532), por lo que no es necesario crear un usuario o especificar `USER` en tu Dockerfile. Esto reduce la superficie de ataque y simplifica tu configuración.

**Usar la imagen oficial de .NET 10**



Puedes usar `docker init` para crear los recursos de Docker necesarios. Dentro del directorio `docker-dotnet-sample`, ejecuta el comando `docker init` en una terminal. `docker init` proporciona cierta configuración predeterminada, pero tendrás que responder a algunas preguntas sobre tu aplicación. Consulta el siguiente ejemplo para responder a las preguntas de `docker init` y utiliza las mismas respuestas para tus indicaciones.

```console
$ docker init
Welcome to the Docker Init CLI!

This utility will walk you through creating the following files with sensible defaults for your project:
  - .dockerignore
  - Dockerfile
  - compose.yaml
  - README.Docker.md

Let's get started!

? What application platform does your project use? ASP.NET Core
? What's the name of your solution's main project? myWebApp
? What version of .NET do you want to use? 10.0
? What local port do you want to use to access your server? 8080
```

Esto genera un Dockerfile utilizando las imágenes oficiales de .NET 10 de Microsoft Container Registry:

```dockerfile {title=Dockerfile}
# syntax=docker/dockerfile:1

FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:10.0-alpine AS build
ARG TARGETARCH
COPY . /source
WORKDIR /source/src
RUN --mount=type=cache,id=nuget,target=/root/.nuget/packages \
    dotnet publish -a ${TARGETARCH/amd64/x64} --use-current-runtime --self-contained false -o /app

FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final
WORKDIR /app
COPY --from=build /app .
ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser
USER appuser
ENTRYPOINT ["dotnet", "myWebApp.dll"]
```



Ahora deberías tener los siguientes contenidos en tu directorio `docker-dotnet-sample`.

```text
├── docker-dotnet-sample/
│   ├── .git/
│   ├── src/
│   ├── .dockerignore
│   ├── compose.yaml
│   ├── Dockerfile
│   ├── README.Docker.md
│   └── README.md
```

Para obtener más información sobre los archivos, consulta lo siguiente:

- [Dockerfile](/reference/dockerfile/)
- [.dockerignore](/reference/dockerfile/#dockerignore-file)
- [compose.yaml](/reference/compose-file/)

## Ejecutar la aplicación

Dentro del directorio `docker-dotnet-sample`, ejecuta el siguiente comando en una terminal.

```console
$ docker compose up --build
```

Abre un navegador y visualiza la aplicación en [http://localhost:8080](http://localhost:8080). Deberías ver una aplicación web sencilla.

En la terminal, presiona `ctrl`+`c` para detener la aplicación.

### Ejecutar la aplicación en segundo plano

Puedes ejecutar la aplicación desacoplada (detached) de la terminal agregando la opción `-d`. Dentro del directorio `docker-dotnet-sample`, ejecuta el siguiente comando en una terminal.

```console
$ docker compose up --build -d
```

Abre un navegador y visualiza la aplicación en [http://localhost:8080](http://localhost:8080). Deberías ver una aplicación web sencilla.

En la terminal, ejecuta el siguiente comando para detener la aplicación.

```console
$ docker compose down
```

Para obtener más información sobre los comandos de Compose, consulta la [referencia de la CLI de Compose](/reference/cli/docker/compose/).

## Resumen

En esta sección, aprendiste cómo puedes containerizar y ejecutar tu aplicación .NET usando Docker.

Información relacionada:

- [Referencia de Dockerfile](/reference/dockerfile/)
- [Referencia del archivo .dockerignore](/reference/dockerfile/#dockerignore-file)
- [Resumen de Docker Compose](/compose/)
- [Docker Hardened Images](/dhi/)

## Próximos pasos

En la siguiente sección, aprenderás cómo puedes desarrollar tu aplicación usando contenedores de Docker.

