LOGGER in GOlang | LOGGER in GOlang with Docker | Using LOG in GOlang with Docker | Uso de LOG en GOlang con Docker | LOGGER en GOlang

LOGGER in GOlang | LOGGER in GOlang with Docker | Using LOG in GOlang with Docker | Uso de LOG en GOlang con Docker | LOGGER en GOlang 


El registro (LOG) de peticiones, errores, o eventos es muy importante en cualquier sistema. Con un registro (LOG) de errores, eventos , es muy importante a la hora de validar un fallo computacional del sistema.


Objetivo


Mejorar el sistema de LOGs de GOlang.


Requisitos:


  • go (versión go1.14.4 o superior)

  • Docker (versión 19.03.12)

  • Docker-compose (versión 1.25.0)



En Acción:

Estructura del proyecto:

Código del ejemplo con su respectivo Dockerfile.

logger.go
package main

import (
"flag"
"log"
"os"
)
//Se declara la variable Log. Esta será usada para registrar los eventos.
var (
Log *log.Logger = Loggerx()
)

func Loggerx() *log.Logger {
LOG_FILE_LOCATION := os.Getenv("LOG_FILE_LOCATION")
//En el caso que la variable de entorno exista, el sistema usa la configuración del docker.
if LOG_FILE_LOCATION == "" {
LOG_FILE_LOCATION = "../logs/" + APP_NAME + ".log"
} else {
LOG_FILE_LOCATION = LOG_FILE_LOCATION + APP_NAME + ".log"
}
flag.Parse()
//Si el archivo existe se rehusa, es decir, no elimina el archivo log y crea uno nuevo.
if _, err := os.Stat(LOG_FILE_LOCATION); os.IsNotExist(err) {
file, err1 := os.Create(LOG_FILE_LOCATION)
if err1 != nil {
panic(err1)
}
//si no existe,se crea uno nuevo.
return log.New(file, "", log.Ldate|log.Ltime|log.Lshortfile)
} else {
//si existe se rehusa.
file, err := os.OpenFile(LOG_FILE_LOCATION, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
if err != nil {
panic(err)
}
return log.New(file, "", log.Ldate|log.Ltime|log.Lshortfile)
}
}

Dockerfile:
FROM golang:alpine
# Add Maintainer Info
LABEL maintainer="Jose Mejia"
# Instalar GIT en el contenedor/Install git.
RUN apk add git
# /Crea el folder app/Create folder app
RUN mkdir /app
# Se crean los argumentos/Build Args
ARG LOG_DIR=/logs
# Se crea el folder para almacenar los logs/Create Log Directory
RUN mkdir -p ${LOG_DIR}
# Definicion de variables de entorno/Environment Variables
ENV LOG_FILE_LOCATION=${LOG_DIR}/
ENV ENVIRONMENT=dev
# Copiar todo de nuestro repositorio al contenedor/Copy sources
COPY . /app
# Se establece /app como directorio actual/Set the Current Working Directory inside the container
WORKDIR /app
# Se descargan todas las dependencias/get dependencies
RUN go get -d -v
# Construir la aplicación GO/Build the Go app
RUN go build -o main .
# Se declaran los volumnes del contenedor/Declare volumes to mount
VOLUME [${LOG_DIR}]
# Puerto en el cual se expone la aplicacion/This container exposes port
EXPOSE 4443
# Lanza la aplicacion/Run
CMD ["./main"]

El archivo Dockerfile debe estar al mismo nivel del código fuente , 

docker-compose.yml
version: '3.4'
# Se definen los servicios que va a administrar el docker-compose
services:
  proxy:
    container_name: proxy #nombre del contenedor/container name
    build:
      context: proxy #nombre del folder donde existe el dockerfile
      dockerfile: Dockerfile #Nombre del docker file
    environment: #Declaración de variables de entorno    
      - ENVIRONMENT=dev
    ports: #Puertos que se van a abrir del contenedor
      - "4443:4443"
    networks: #Declaración de la red
      - fullstack
    volumes: #Definicón y declaración de los volumenes
      - ./logs/:/logs:rw
    restart: always # Modalidad de reinicio
networks:
  fullstack:
    driver: bridge


Resultados


* El iniciar el Docker y realizar peticiones:

2020/07/20 13:13:28 main.go:40: INICIA HTTPS SERVER :8181 :8182
2020/07/20 13:13:36 handlers.go:16: Redirect to: https://localhost:8182/
2020/07/20 13:13:44 handlers.go:45: localhost:8181 / Target not exist /
2020/07/20 13:17:38 main.go:40: INICIA HTTPS SERVER :8181 :8182
2020/07/20 13:17:48 handlers.go:19: Redirect to: https://localhost:8181/
2020/07/20 13:17:48 handlers.go:48: localhost:8181 / Target not exist /

Si se Reinicia el Docker por algún motivo, el sistema rehusa el archivo log, manteniendo los registros anteriores.

Código fuentes:


Notas finales:

Con Docker y Docker-Compose es mucho más fácil la administración y despliegues de aplicaciones en cualquier ambiente. Adicionalmente Docker se encarga de administrar el contenedor.


No olvides compartir y dar +1

-

Próximos eventos:

* Habilitar https en GOlang
* Ejecutar código HTML estático en DOCKER
* Microservicios en Python
* Python+MongoDB: CRUD
* Python+MongoDB+GridFS: Almacenamiento de archivos
* Colas - Queue Python: Envío de mensajes
* Python+AWS+SNS: Envío de mensajes de textos.
* Python3: Creación de un Chatbot básico
* NodeJS+MongoDB: CRUD

El orden de los eventos puede cambiar

Comentarios

Publicar un comentario

Entradas más populares de este blog

Ejemplo Log4j 2 en JAVA | Log4j 2 en Springboot | Configuración Log4j 2 | Log4j 2 in SpringBoot| Example Log4j 2 in SpringBoot | Configuring Log4j 2

Imagen
Log4j versión 2.x en JAVA |  Log4j versión 2.x en  SpringBoot Apache Log4j 2 o 2.x es una actualización muy importante de Log4j, la cual proporciona innumerables mejoras con respecto a las versiones anteriores, entre estas mejoras: Logback, manejo asíncrono, etc. Objetivo Configurar Log4j versión 2 o 2.x en proyectos Spring. Requisitos: Java 11 (Open) Eclipse SpringBoot 2.2.4.RELEASE Maven En Acción: Para este ejemplo se debe contar con un proyecto en SpringBoot, el cual se pueda implementar o mejorar el uso de Log4j 2 o 2.x. log4j2-spring.xml El archivo de configuración para Log4j versión 2 se define de dos formas: logj2.xml para proyectos sin Spring log4j-spring.xml para proyectos que usen Spring Para ambos archivos se mantiene la misma declaración de propiedades. <? xml version = "1.0" encoding = "UTF-8" ?> <!--https://logging.apache.org/log4j/2.x/manual/configuration.html--> < Configuration status = "TRACE" monitorInterval = "
Leer más

Python: Inyección de dependencias

Imagen
Resumen La inyección de dependencias (DI) es una técnica de ingeniería de software para definir las dependencias entre objetos. Básicamente la inyección de dependencias en Python funciona de forma similar a la inyección de EJB en JAVA. Este proceso permite suministrar un recurso que requiere en una implementación X. Prerequisitos: Python 3.x Flask Flask-Injector Inject En Acción: provider/ injectx.py #!/usr/bin/python3 from injector import inject class DependencyProvider ( object ): def __init__ ( self ): pass def get ( self ) -> object : try : return { "message" : "DependencyProvider" }, 200 except Exception as e: print (e) return { "error" : "Internal error" }, 500 class InjectProvider ( object ): @inject def __init__ ( self , dependencyProvider : DependencyProvider): self .dependencyProvider = dependencyProvider def get_dependency ( self
Leer más

GOlang con Docker | GOlang with Docker | GO con Docker | GO with Docker

Imagen
GOlang con Docker | GOlang with Docker | GO con Docker | GO with Docker Un contenedor básicamente es una unidad de software estándar que empaqueta el código y dependencias para una aplicación, permitiendo que esta se ejecute de manera rápida en un entorno. Objetivo Ejecutar una aplicación desarrollada con GOlang en Docker. Requisitos: go (versión go1.14.4 o superior) Docker (versión 19.03.12) Docker-compose (versión 1.25.0) En Acción: Estructura del proyecto: Código del ejemplo con su respectivo Dockerfile. Dockerfile: FROM golang :alpine # Add Maintainer Info LABEL maintainer= "Jose Mejia" # Install git. # Git is required for fetching the dependencies. RUN apk add git # RUN apk update && apk add --no-cache git # Create folder app RUN mkdir /app # Build Args ARG LOG_DIR = /logs # Create Log Directory RUN mkdir -p ${LOG_DIR} # Environment Variables ENV LOG_FILE_LOCATION = ${LOG_DIR} / ENV ENVIRONMENT = dev # Copy sources COPY . /app # Set the Current W
Leer más