Arquitecto PDF

Trainer: Ivan Cuadros Altamirano pág.
1
ARQUITECTO DESARROLLADOR WEB
NET CORE 2.2
Trainer: Ivan Cuadros Altamirano pág. 2

NET CORE
.NET Core tiene las siguientes características:
 Multiplataforma: se ejecuta en sistemas operativos Windows, macOS y Linux.

 Consistente en todas las arquitecturas: ejecuta su código con el mismo comportamiento en múltiples
arquitecturas, incluidas x64, x86 y ARM.
 Herramientas de línea de comandos: incluye herramientas de línea de comandos fáciles de usar que se
pueden usar para el desarrollo local y en escenarios de integración continua.
 Implementación flexible: se puede incluir en su aplicación o se puede instalar de lado a lado en toda la
máquina. Se puede utilizar con contenedores Docker.
 Compatible: .NET Core es compatible con .NET Framework, Xamarin y Mono, a través de .NET Standard.
 Código abierto: la plataforma .NET Core es de código abierto, con licencias MIT y Apache 2. .NET Core
es un proyecto de la Fundación .NET.
 Compatible con Microsoft: .NET Core es compatible con Microsoft, por .NET Core Support.

ARQUITECTURA DE SOFTWARE

ESTRUCTURA DEL PROYECTO

SESIÓN I

TEMAS A TOCAR:
1. Preparando el ambiente de desarrollo:

o Instalación de Visual Studio 2019
o Instalación de POSTMAN
2. Creación de la estructura de la solución
3. Implementación del proyecto API LOG
4. Pruebas del proyecto API LOG
5. Creación de cuenta SENTRY
6. Implementación de SENTRY
7. Pruebas de SENTRY
8. Trabajando con archivos estáticos
9. Personalización de log4net

PREPARANDO EL AMBIENTE DE DESARROLLO
o Instalación de Visual Studio 2019
o Descargar el instalador de la versión comunitaria de la página oficial
https://visualstudio.microsoft.com/es/downloads/

o Al terminar la descarga ejecutaremos el instalador como usuario administrador y seguimos los pasos
tal como se muestran en las imágenes

o Luego elegimos componentes para la carga de trabajo, como se muestran a continuación y le damos
click en instalar

o Uno de las opciones importantes que marcar es la que se muestra en la imagen, seguir las
instrucciones del trainer para este paso.

o Al finalizar la instalación abrimos el visual studio 2019 para certificar que la instalación se realizó
correctamente.

o En algunos casos será necesario instalar el SDK de NET CORE 2.2, para ello lo debemos descargar del
enlace https://dotnet.microsoft.com/download/visual-studio-sdks y luego ejecutar el instalador

o Instalación de POSTMAN
o Descargar el instalador de la página oficial https://www.getpostman.com/

o Al terminar la descarga ejecutaremos el instalador como usuario administrador y seguimos los pasos
tal como se muestran en las imágenes

o Creamos una cuenta

o Al finalizar la instalación abrimos POSTMAN para certificar que la instalación se realizó correctamente.

CREACION DE LA ESTRUCTURA DE LA SOLUCIÓN
o Creamos la solución

o Creamos las carpetas de soluciones

o Creamos las sub carpetas de soluciones

IMPLEMENTACIÓN DEL PROYECTO API LOG
¿Qué es un Log?
Las empresas se apoyan en sistemas que generan una gran cantidad de datos en forma de trazas textuales,
llamadas técnicamente “Logs”. Esta información no es visible para el usuario pero suele estar relacionada
con su actividad informática (por ejemplo, historial de navegación, programas abiertos, etc.) o con lo s
propios sistemas de información (es decir, estado actual de programas, seguridad, accesos, conectividad de
redes, etc.).
Los Logs, que nos explican el comportamiento de nuestros sistemas o programas, suelen escribirse en
ficheros. Aunque más adelante pueden ser examinados, estos archivos por sí solos no nos permitirán
detectar si se ha producido un error.
Aquí puede verse un ejemplo de fichero Log de una aplicación web:

¿Por qué es importante implementar un Log?
Existen muchos beneficios de la razón por la que se implementa un log, estas son algunas:
1. Visibilidad nula de errores para los equipos de desarrollo y/o sistemas . En otras palabras, será difícil
detectar problemas y solucionarlos con rapidez.
2. Metodología de trabajo no estandarizada , es decir, cada usuario aplicará su propia forma basada en
su experiencia.
3. Accesos e información descentralizada que causará dificultades para trabajar con estos datos.
4. Incremento del tiempo de respuesta ante una incidencia que afectará a niveles de servicio o SLAs (en
relación con el nivel de calidad).
5. Prevenir fugas de información, así como comportamientos inadecuados que causen errores.
6. Entre otros.

o Creamos el proyecto COMMON en la carpeta LOG/COMMON con NET ESTÁNDAR

o Instalamos, desde el administrador de paquetes, las dependencias:
1. Log4net
2. Microsoft.Extensions.Logging

o Creamos, dentro del proyecto BSOFT.Log.Logging, las clases:
1. Log4NetLogger.cs
2. Log4NetLoggerProvider.cs
3. Log4NetLoggerFactoryExtensions.cs

o Implementamos la clase Log4NetLogger
using Microsoft.Extensions.Logging;
using System;
namespace BSOFT.Log.Logging
{
public class Log4NetLogger : ILogger
{
log4net.ILog _log = null;
public Log4NetLogger(log4net.ILog log)

{
_log = log;
}
public IDisposable BeginScope<TState>(TState state)

{
return null;
}
public bool IsEnabled(LogLevel logLevel)

{
switch (logLevel)
{
case LogLevel.Trace:
case LogLevel.Debug:
return _log.IsDebugEnabled;
case LogLevel.Information:
return _log.IsInfoEnabled;
case LogLevel.Warning:
return _log.IsWarnEnabled;
case LogLevel.Error:
return _log.IsErrorEnabled;
case LogLevel.Critical:
return _log.IsFatalEnabled;
default:

throw new ArgumentOutOfRangeException(nameof(logLevel));
}
}
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception,
string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
if (formatter == null)
{
throw new ArgumentException(nameof(formatter));
}
var message = formatter(state, exception);

if (!string.IsNullOrEmpty(message) || exception != null)
{
WriteMessage(logLevel, eventId.Id, message, exception);
}
}
private void WriteMessage(LogLevel logLevel, int eventId, string message, Exception exception)
{
var evtId = eventId == 0 ? string.Empty : $" [{eventId}]";
switch (logLevel)
{
case LogLevel.Trace:
case LogLevel.Debug:
_log.Debug($"{message}{evtId}", exception);
break;
case LogLevel.Information:
_log.Info($"{message}{evtId}", exception);
break;
case LogLevel.Warning:

_log.Warn($"{message}{evtId}", exception);
break;
case LogLevel.Error:
_log.Error($"{message}{evtId}", exception);
break;
case LogLevel.Critical:
_log.Fatal($"{message}{evtId}", exception);
break;
default:
_log.Debug($"{message}{evtId}", exception);
break;
}
}
}
}

o Implementamos la clase Log4NetLoggerProvider
using System.Collections.Concurrent;
using System.IO;
using System.Linq;
using System.Reflection;
{
public class Log4NetLoggerProvider : ILoggerProvider
{
private string _configFileName = string.Empty;
private readonly ConcurrentDictionary<string, Log4NetLogger> _loggers = new ConcurrentDictionary<string,
Log4NetLogger>();
public Log4NetLoggerProvider(string configFileName)

{
_configFileName = configFileName;
}
public ILogger CreateLogger(string categoryName)

{
return _loggers.GetOrAdd(categoryName, CreateLoggerImplementation);
}
private Log4NetLogger CreateLoggerImplementation(string categoryName)

{
var repository = log4net.LogManager.GetRepository(Assembly.GetEntryAssembly());
if (log4net.LogManager.GetCurrentLoggers(repository.Name).Count() == 0)
{
log4net.Config.XmlConfigurator.Configure(repository, new FileInfo(_configFileName));
}
var logger = log4net.LogManager.GetLogger(repository.Name, categoryName);

return new Log4NetLogger(logger);
}

public void Dispose()
{
_loggers.Clear();
}
}
}

o Implementamos la clase Log4NetLoggerFactoryExtensions
{
public static class Log4NetLoggerFactoryExtensions
{
public static ILoggingBuilder AddLog4Net(this ILoggingBuilder builder)
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddProvider(CreateLog4NetProvider(null));
return builder;
}
public static ILoggingBuilder AddLog4Net(this ILoggingBuilder builder, string configFileName)

{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddProvider(CreateLog4NetProvider(configFileName));
return builder;
}
public static ILoggerFactory AddLog4Net(this ILoggerFactory factory)

{
factory.AddProvider(CreateLog4NetProvider(null));
return factory;
}
public static ILoggerFactory AddLog4Net(this ILoggerFactory factory, string configFileName)

{
factory.AddProvider(CreateLog4NetProvider(configFileName));
return factory;

}
private static ILoggerProvider CreateLog4NetProvider(string configFileName)

{
var fileName = string.IsNullOrEmpty(configFileName) ? "log4net.config" : configFileName;
return new Log4NetLoggerProvider(fileName);

}
}
}

CREACIÓN DEL PROYECTO API LOG
o Creamos el proyecto API en la carpeta LOG/API

o Creamos el archivo de configuración para Log4net log4net.config

o Implementamos el archivo log4net.config
<?xml version="1.0" encoding="utf-8" ?>

<log4net>
<appender name="coloredConsoleAppender"
type="log4net.Appender.ManagedColoredConsoleAppender">
<mapping>
<level value="FATAL"/>
<foreColor value="Red"/>
<backColor value="White"/>
</mapping>
<mapping>
<level value="ERROR"/>
<foreColor value="Red"/>
</mapping>
<mapping>
<level value="WARN"/>
<foreColor value="Yellow"/>
</mapping>
<mapping>
<level value="INFO"/>
<foreColor value="Cyan"/>
</mapping>
<mapping>
<level value="DEBUG"/>
<foreColor value="Green"/>
</mapping>
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%date %5level - %message%newline%exception" />
</layout>
</appender>
<appender name="rollingFileDateAppender"
type="log4net.Appender.RollingFileAppender">
<file value="log4net.log"/>
<appendToFile value="true" />

<lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
<rollingStyle value="Date"/>
<datePattern value="yyyyMMdd"/>
<countDirection value="-1"/>
<staticLogFileName value="false"/>
<preserveLogFileNameExtension value="true"/>
<conversionPattern value="%date [%thread] %5level %logger [%property{diagnosticsData}] - %message%newline%exception" />
</layout>
</appender>
<root>
<level value="ALL" />
<appender-ref ref="coloredConsoleAppender"/>
<appender-ref ref="rollingFileDateAppender"/>
</root>
</log4net>

o Registramos el servicio Log4net

o Creamos la carpeta ViewObject

o Creamos las clases de LogRequest y LogResponse dentro de la carpeta ViewObject

o Implementamos la clase LogRequest y LogResponse

o Creamos el controlador LogController

o Implementamos el controlador LogController

PRUEBAS DEL PROYECTO API LOG
o Ejecutamos el proyecto, antes establecer como proyecto de inicio

o Abrimos el POSTMAN y probamos el API LOG

o Revisamos el archivo generado

CREACION DE CUENTA SENTRY
o Ingresar al enlace https://sentry.io/welcome/

o Creamos un proyecto

o Obtenemos el DSN del proyecto creado

IMPLEMENTACIÓN DE SENTRY
o Agregar la referencia nuget SharpRaven

o Creamos la carpeta Helpers en la raíz del proyecto y dentro de ella la clase Sentry

o Implementamos la clase Sentry

o Modificamos el método Post del controlador Log

PRUEBAS DE SENTRY
o Enviamos un error y verificamos nuestro correo electrónico.

TRABAJANDO CON ARCHIVOS ESTATICOS
o Creamos la carpera wwwroot y debajo de ella la carpeta log.

o Modificamos el método Configure en la clase Startup.

o Modificamos el archivo de configuración log4net.config para rutear la carpeta de escritura y hacemos
pruebas.

PERSONALIZACIÓN DEL LOG4NET
o Modificamos el archivo de configuración log4net.config para filtrar los errores en otro archivo y
realizamos pruebas.

<appender name="errorRollingLogFileAppender"
type="log4net.Appender.RollingFileAppender">
<file value="wwwroot\log\error.log"/>
<appendToFile value="true" />
<lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
<rollingStyle value="Date"/>
<datePattern value="yyyyMMdd"/>
<countDirection value="-1"/>
<staticLogFileName value="false"/>
<preserveLogFileNameExtension value="true"/>
<conversionPattern value="%date [%thread] %5level %logger [%property{diagnosticsData}] - %message%newline%exception" />
</layout>
<filter type="log4net.Filter.LevelRangeFilter">
<levelMin value="WARN" />
<levelMax value="ERROR" />
</filter>
</appender>

HEMOS TERMINADO ESTA SESSIÓN

Arquitecto PDF

Cargado por

Copyright:

Formatos disponibles

Arquitecto PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arquitecto PDF

Cargado por

Copyright:

Formatos disponibles

Trainer: Ivan Cuadros Altamirano pág.

Trainer: Ivan Cuadros Altamirano pág. 2

.NET Core tiene las siguientes características:

 Multiplataforma: se ejecuta en sistemas operativos Windows, macOS y Linux.

Trainer: Ivan Cuadros Altamirano pág. 3

Trainer: Ivan Cuadros Altamirano pág. 4

Trainer: Ivan Cuadros Altamirano pág. 5

Trainer: Ivan Cuadros Altamirano pág. 6

1. Preparando el ambiente de desarrollo:

Trainer: Ivan Cuadros Altamirano pág. 7

Trainer: Ivan Cuadros Altamirano pág. 8

Trainer: Ivan Cuadros Altamirano pág. 9

Trainer: Ivan Cuadros Altamirano pág. 12

Trainer: Ivan Cuadros Altamirano pág. 13

Trainer: Ivan Cuadros Altamirano pág. 14

Trainer: Ivan Cuadros Altamirano pág. 16

Trainer: Ivan Cuadros Altamirano pág. 17

Trainer: Ivan Cuadros Altamirano pág. 19

Trainer: Ivan Cuadros Altamirano pág. 21

Trainer: Ivan Cuadros Altamirano pág. 22

Trainer: Ivan Cuadros Altamirano pág. 23

Trainer: Ivan Cuadros Altamirano pág. 26

Trainer: Ivan Cuadros Altamirano pág. 27

Trainer: Ivan Cuadros Altamirano pág. 28

Trainer: Ivan Cuadros Altamirano pág. 29

Trainer: Ivan Cuadros Altamirano pág. 30

Trainer: Ivan Cuadros Altamirano pág. 34

Trainer: Ivan Cuadros Altamirano pág. 38

public Log4NetLogger(log4net.ILog log)

public IDisposable BeginScope<TState>(TState state)

public bool IsEnabled(LogLevel logLevel)

Trainer: Ivan Cuadros Altamirano pág. 39

var message = formatter(state, exception);

Trainer: Ivan Cuadros Altamirano pág. 40

Trainer: Ivan Cuadros Altamirano pág. 41

public Log4NetLoggerProvider(string configFileName)

public ILogger CreateLogger(string categoryName)

private Log4NetLogger CreateLoggerImplementation(string categoryName)

var logger = log4net.LogManager.GetLogger(repository.Name, categoryName);

Trainer: Ivan Cuadros Altamirano pág. 42

Trainer: Ivan Cuadros Altamirano pág. 43

public static ILoggingBuilder AddLog4Net(this ILoggingBuilder builder, string configFileName)

public static ILoggerFactory AddLog4Net(this ILoggerFactory factory)

public static ILoggerFactory AddLog4Net(this ILoggerFactory factory, string configFileName)

Trainer: Ivan Cuadros Altamirano pág. 44

private static ILoggerProvider CreateLog4NetProvider(string configFileName)

return new Log4NetLoggerProvider(fileName);

Trainer: Ivan Cuadros Altamirano pág. 45

Trainer: Ivan Cuadros Altamirano pág. 46

Trainer: Ivan Cuadros Altamirano pág. 50

<?xml version="1.0" encoding="utf-8" ?>

Trainer: Ivan Cuadros Altamirano pág. 52

Trainer: Ivan Cuadros Altamirano pág. 53

Trainer: Ivan Cuadros Altamirano pág. 54

Trainer: Ivan Cuadros Altamirano pág. 57

Trainer: Ivan Cuadros Altamirano pág. 58

Trainer: Ivan Cuadros Altamirano pág. 59

Trainer: Ivan Cuadros Altamirano pág. 60

Trainer: Ivan Cuadros Altamirano pág. 63