Containers en .Net Core y Docker
Tags: dotnet, docker, spanish, csharp
Published: 2022-08-17 22:26:00

Actualmente existe mas de una forma para desplegar nuestras aplicaciones. Una de ellas es trabajar con contenedores, lo que nos permite construir, compartir y correr tus aplicaciones.
A continuación contenerizaremos una aplicación .Net Core 6 con docker, explicando paso a paso su configuración.

- [¿ Qué es un contenedor ?](#¿-Qu--es-un-contenedor-?)
- [¿ Qué es docker ?](#¿-qu--es-docker-?)
- [Pre requisitos](#pre-requisitos)
- [Creando nuestra API Net Core 6](#creando-nuestra-api-net-core-6)
- [Creando el Dockerfile](#creando-el-dockerfile)
- [Construir imagen y contenedor](#construir-imagen-y-contenedor)

# ¿ Qué es un contenedor ?

Es un paquete de software que agrupa el código de una aplicación junto con las bibliotecas y los archivos de configuración pertinentes, así como las dependencias necesarias para que la aplicación funcione.

# ¿ Qué es docker ?

Docker es una tecnología que le permite implementar aplicaciones como contenedores portátiles autónomos que pueden ejecutarse en la nube o en ambiente local, Linux o Windows.

Al igual que Docker, existen otros tipos de creadores de contenedores. En los últimos años, Docker se ha convertido en el formato de contenedor predeterminado.

# Pre requisitos

Previo a irnos a la practica debemos considerar lo siguiente:

- El ejemplo se realizara en un entorno windows 10
- Debes tener instalado Docker desktop [Link oficial](https://www.docker.com/products/docker-desktop/)
- Tener instalado Visual Studio 2022 para crear la api en .Net 6

# Creando nuestra API Net Core 6

En visual studio 2022 crearemos un proyecto con una plantilla tipo **ASP.NET Core Web API**:
![Seleccionar plantilla](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3fqip9e8yiymrbzw0slg.png)

Configuramos el proyecto con el nombre **NetCoreDocker**:

![Configurar proyecto](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2t10ie2mbhm3vz7nl52x.png)

Seleccionamos el framework .NET 6.0,con las opciónes deshabilitadas *Configurar HTTPS*, *Habilitar Docker*, *Do not use top-level statements*. Las opciones que debemos tener habilitadas son *Desactivar para usar api minimas*, *Habilitar compatibilidad con OPEN API (Swagger)*. El motivo de no habilitar docker es por que en el siguiente paso de forma manual crearemos nuestro Dockerfile:

![Seleccionar framework .NET 6](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/35dqmkw2cw8km2ue3d4j.png)
 
Una vez creado nuestro proyecto debemos correr nuestra api y verificar que se visualice swagger con el endpoint por defecto *WeatherForecast*.
 
# Creando el Dockerfile

Dockerfile es un archivo de texto que contine los pasos sobre cómo compilar una imagen docker.

El siguiente archivo que crearemos estara compuesto por tres partes:
- Declaración de la imagen base a utilizar
- La contrucción de nuestra app
- Compilacion y creación del contenedor

Se crearan dos archivos, Dockerfile y .dockerignore   los cuales deben quedar como el siguiente arbol de archivos.

* NetcoreDocker
   * NetcoreDocker
      * Dockerfile
      * .dockerignore
* NetCoreDocker.sln

En el archivo Dockerfile debemos escribir lo siguiente

*Dockerfile* :
```Dockerfile
# Imagen base en la cual basaremos nuestra imagen
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /app

# Exponemos el puerto 80 
EXPOSE 80
    
# Copiar csproj y restauramos nuestra app
COPY ./*.csproj ./
RUN dotnet restore
    
# Copiamos todos los archivos y compilamos o contruimos nuestra app
COPY . .
RUN dotnet publish -c Release -o publish
    
# Construimos o instanciamos nuestro contenedor
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build /app/publish .
    #Indicamos el archivo dll compilado (nombre del proyecto)
ENTRYPOINT ["dotnet", "NetCoreDocker.dll"]
```

Archivo .dockerignore es donde le indicamos las carpetas para omitir en la construcción de nuestra app para hacer que nuestro contexto de compilación sea lo más pequeño posible. En net core son las carpetas bin y obj

*.dockerignore* :

```
bin/
obj/
```

# Construir imagen y contenedor

Ya estamos en condiciones de crear nuestra imagen, para ello debemos abrir una consola que para este ejemplo sera powershell. Puedes utilizar la cmd de windows o la que mas te acomode.

Comprobamos que tengamos docker instalado con:

```powershell
docker --version
```

Nos posicionamos en la carpeta del proyecto:

```powershell
cd C:\DevTest\NetCoreDocker\NetCoreDocker\
```

Construiremos nuestra imagen con el siguiente comando

```powershell
docker build -t netcoreimage .
```

*netcoreimage es el nombre de la imagen que le asignaremos*

Luego debemos comprobar que este creada con el siguiente comando

```powershell
docker images
```

*Deberia devolvernos un resultados similar a:*

REPOSITORY            |     TAG  |     IMAGE ID   |    CREATED       SIZE
netcoreimage          |   latest |   e332bfb3d5c7 |  4 hours ago   213MB

Una vez creada la imagen ya podemos correr el contenedor con el siguiente comando:

```powershell
docker run -d -p 5000:80 -e ASPNETCORE_ENVIRONMENT=Development --name apinetcore  netcoreimage
```

Explicación del script

- *-p 5000:80* indicamos el puerto del sistema operativo anfitrion que es el que permitira conectarnos a la api y el puerto del contenedor

- *-e ASPNETCORE_ENVIRONMENT=Development* variable de entorno

- *--name apinetcore* el nombre que le daremos al contenedor

- *netcoreimage* es el nombre de la imagen en la cual se basara nuestro contenedor

Comprobamos que el contenedor esta corriendo:

```powershell
docker ps
```

**¡Listo!** nuestra api ya esta contenerizada. 

### ¿Como lo comprobamos?

Copiemos la siguiente url en nuestro navegador y lograremos visualizar swagger

http://localhost:5000/swagger/index.html

y si necesitamos probar el endpoint copiamos y pegamos en nuestro navegador la siguiente url

http://localhost:5000/WeatherForecast

:briefcase: <a href="http://airarrazabal.netlify.app/" target="_blank">Mi Portafolio</a>