Forem: Fernando Chata

Buenas prácticas APIs

Fernando Chata — Tue, 11 Apr 2023 22:44:44 +0000

Usar nombres de recursos (sustantivos)

❌ GET /querycarts/123
✅ GET /carts/123

Uso de plurales

❌ GET /cart/123
✅ GET /carts/123

Idempotencia

❌ POST /carts
✅ POST /carts {requestId: 123}

Uso de versionado

❌ GET /carts/v1/123
✅ GET /v1/carts/123

Uso de paginado

❌ GET /carts
✅ GET /carts?pageSize=xx&pageToken=xx

Ordenado

❌ GET /carts
✅ GET /carts?sort_by=id

Filtrado

❌ GET /carts
✅ GET /carts?filter=color:blue

Acceso Seguro

❌ X-API-KEY = xxxxx
✅ X-API-KEY = xxxxx
X-EXPIRE = xxxxx
X-REQUEST-SIGNATURE = (URL + QueryString + Expire + Body)

Referencia cruzada de recursos

❌ GET /carts/123?item=321
✅ GET /carts/123/items/321

Agregar un elemento nuevo

❌ POST /carts/123?addItem=321
✅ POST /carts/123/items:add{itemID: "items/321"}

Optimización del rendimiento de una aplicación Node.js

Fernando Chata — Sun, 26 Mar 2023 03:15:08 +0000

Minimize blocking I/O operation

Node.js está diseñado para manejar operaciones de E/S sin bloqueo, lo que significa que puede manejar varias solicitudes simultáneamente sin bloquear el bucle de eventos. Para optimizar el rendimiento, minimice cualquier operación de E/S que bloquee mediante operaciones asincrónicas o dividiendo las tareas grandes en tareas más pequeñas.

//Blocking I/O example
const fs = require('fs')

const data = fs.readFileSync('file.txt')

// Non-blocking I/O example
const fs = require('fs')

fs.readFile('file.txt', (err, data) => {
    if(err) throw err
    console.log(data)
})

Use caching

El almacenamiento en caché es una técnica utilizada para almacenar datos a los que se accede con frecuencia en la memoria, de modo que se pueda acceder a ellos rápidamente y sin tener que recuperarlos de un disco o de la red. Utilice el almacenamiento en caché en su aplicación Node.js para reducir la cantidad de consultas a la base de datos y solicitudes de red.

const NodeCache = require('node-cache')
const myCache = new NodeCache({ stdTTL: 100, checkperiod: 120 })

function getDataFromDatabase(id) {
  // Database query goes here
}

function getData(id) {
  let data = myCache.get(id)
  if (data == undefined) {
    data = getDataFromDatabase(id)
    myCache.set(id, data)
  }
  return data
}

Use a load balancer

Si su aplicación maneja una gran cantidad de solicitudes, use un balanceador de carga para distribuir la carga de trabajo entre varias instancias de su aplicación. Esto mejorará el rendimiento y reducirá el riesgo de accidentes o tiempo de inactividad.

const cluster = require('cluster')
const http = require('http')
const numCPUs = require('os').cpus().length

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`)

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork()
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`)
  })
} else {
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  http.createServer((req, res) => {
    res.writeHead(200)
    res.end('hello world\n')
  }).listen(8000)

  console.log(`Worker ${process.pid} started`)
}

Optimize your database queries

Las consultas a la base de datos pueden ser un cuello de botella importante en el rendimiento. Optimice las consultas de su base de datos minimizando la cantidad de consultas, indexando su base de datos y utilizando características específicas de la base de datos, como vistas y procedimientos almacenados.

// Indexing example
db.collection('users').createIndex({ email: 1 })

// Stored procedure example
db.runCommand({
  eval: `function(email) {
    return db.users.findOne({ email: email })
  }`,
  args: ['john@example.com']
})

Use a reverse proxy

Un proxy inverso puede mejorar el rendimiento al almacenar en caché y comprimir activos estáticos como CSS, JavaScript e imágenes. Esto reduce la carga en su servidor y acelera la entrega de estos activos a los clientes.

const express = require('express');
const compression = require('compression');
const app = express();

app.use(compression());
app.use(express.static('public'));

Use a task queue

Si su aplicación realiza tareas de ejecución prolongada o que consumen muchos recursos, use una cola de tareas para administrarlas. Esto le permite distribuir la carga de trabajo y reducir el riesgo de bloqueos o tiempo de inactividad.

const kue = require('kue')
const queue = kue.createQueue()

function performTask(taskData, done) {
  // Long-running task goes here
  done()
}

queue.process('email', (job, done) => {
  performTask(job.data, done)
})

Use a profiler

Un generador de perfiles es una herramienta que puede ayudarlo a identificar cuellos de botella en el rendimiento de su aplicación. Utilice un generador de perfiles para analizar el rendimiento de su código e identificar las áreas en las que puede realizar mejoras.

const profiler = require('v8-profiler')

function runHeavyTask() {
  // Heavy task goes here
}

profiler.startProfiling('Heavy Task')
runHeavyTask()
const profile = profiler.stopProfiling()
console.log(profile)

Docker error "failed to solve with frontend dockerfile.v0"

Fernando Chata — Wed, 24 Aug 2022 17:54:00 +0000

Si aparece un error failed to solve with frontend dockerfile.v0
cambiar "buildkit": false' dentro de Settings / Docker Engine,
corresponde a una característica que construye las imágenes por defecto

{
  "builder": {
    "gc": {
      "defaultKeepStorage": "20GB",
      "enabled": true
    }
  },
  "experimental": false,
  "features": {
    "buildkit": false
  }
}

[error] [mysql] 1251

Fernando Chata — Fri, 03 Jun 2022 20:59:13 +0000

Por si le sirve a alguien...

Al usar la imagen de mysql en Docker y tratarlo de enlazar desde una app con node + mysql me aparecía el siguiente error:

[error] [mysql] 1251 - Client does not support authentication protocol requested by server; consider upgrading MySQL client

Al parecer es un plugin de cifrado de contraseñas (caching_sha2_password) incompatible con la versión de mysql que se encuentra alojada en Docker hub.

Hay dos opciones o hacer un pull de una versión anterior de mysql (en este caso la 5.7)

docker pull mysql:5.7

o modificar dicho plugin...

Para saber si el error corresponde a lo de los plugins, y verificar si el usuario con el que se conectan a la BBDD lo usa, ocupar el siguiente comando, desde una terminal conectada a la BBDD mysql

select user, plugin from mysql.user;

si efectivamente usa caching_sha2_password modificar la contraseña usando el plugin correspondiente con lo siguiente (modificar el root y el new_password)

alter user 'root'@'%' identified with mysql_native_password by "new_password";
flush privileges;

MongoDB for Dummies (like me)

Fernando Chata — Sun, 29 May 2022 16:34:11 +0000

Ejecutables

Comandos básicos

Conecta a tu instancia local de MongoDB

mongosh

Muestra todas las bases de datos
Muestra todas las colecciones de la actual base de datos

show dbs
show collections

Cambia a la base de datos ingresada

use <nombre_bd>

Muestra tu actual BD

db

Elimina tu actual BD

db.dropDatabase()

Crear colección

db.createCollection(<Name>, Options)

db.createCollection(<Name>, {
   capped : true,
   size : sizeLimit,
   max : documentLimit,
   validator: { $and:
      [   { phone: { $type: "string" } },
          { email: { $regex: /@flares\.com$/ } },
          { status: { $in: [ "Registered", "Unknown" ] } }
       ]
    }
})

db.createCollection( 'login', {
    validator: { $jsonSchema: {
        bsonType: "object",
        "additionalProperties": false,
       required: [ "email" ],
       properties: {
          email: {
             bsonType : "string",
             pattern : "@flares\.com$",
             description: "string meets the given expression"
          },
          status: {
             enum: [ "registered", "Invalid" ],
             description: "status must be within enum values"
          }
       }
    } },
} )

Cambiar nombre de colección

db.<db_name>.renameCollection(<new_name_collection>)
db.login.renameCollection(<newCollectionName>)

Create

db.<collectionName>.<command>

insertOne collectionName.insertOne({document})
insertMany collectionName.insertMany([{document1},{document2},{ document3}….{ documentn}])

Crea uno o varios documentos dentro de una colección

db.users.insert({
   name: 'Fernando',
   age: 35,
   interesting: ['tecnology, 'music', 'movies'],
   address: {
      city: 'Santiago',
      street: 'Columbus av.'
   }.
   birdDate: Date()
})
db.users.insertOne({ name: "Fernando"})
db.users.insertMany({ name: "Fernando"}, {name: "Elias"})

Read

db.<collectionName>.<command>

find()
find(<filterObject>)
find(<filterObject>, <selectObject>)

db.users.find().pretty()
db.users.find({ name: "Fernando"})
db.users.find({ email: "fernando@mail.com"}, {name: 1})
db.users.find({}, {email: 0})

El primer comando muestra todos los documentos de la colección.
El segundo muestra todos los documentos cuyo name sea Fernando.
El tercero muestra unicamente el name de los documentos cuyo email sea fernando@mail.com
El cuarto muestra todos los documentos excepto el campo email

findOne(<filterObject>)

db.users.findOne({ name: "Fernando"})

Muestra sólo el primer documento que cumple el filtro

countDocuments(<filterObject>)

db.users.countDocuments({ name: "Fernando"})

Regresa el número de documentos que cumple el filtro

Update

db.<collectionName>.<command>

updateOne
updateMany

db.users.updateOne({ age: 20 }, { $set: { age: 21 } })
db.users.updateMany({ age: 12 }, { $set: { age: 15 } })

El primero actualiza la edad del primer documento que encuentra, en cambio el segundo actualiza todos los documentos que cumplan el filtro.

replaceOne

db.users.replaceOne({ age: 12 }, { name:"mi nombre", age: 13 })

Reemplaza el primer objeto completo que cumpla el filtro

Delete

db.<collectionName>.<command>

deleteOne
deleteMany

db.users.deleteOne({age: 10})
db.users.deleteMany({age: 10})

El primer comando elimina el primer documento que cumpla el filtro y el segundo borra todos los documentos que cumplan el filtro

Filters

$eq (equal)
$ne (not equal)

db.users.find({ name: { $eq: "Fernando" } })
db.users.find({ name: { $ne: "Fernando" } })

El primero muestra todos los documentos cuyo name sea igual a Fernando y el segundo todos los que sean diferentes.

$gt (greater than)
$gte (greater than or equal)
$lt (low than)
$lte (low than or equal)

b.users.find({ age: { $gt: 12 } })
db.users.find({ age: { $gte: 15 } })

b.users.find({ age: { $lt: 12 } })
db.users.find({ age: { $lte: 15 } })

El primer comando muestra los documentos con un age mayor a 12, sin incluirlo.
El segundo muestra los documentos con un àge mayor a 15 incluyendo los que tengan 15.
Los dos siguientes de igual forma incluyendo o excluyéndolos del filtro.

$in (include)
$nin (non include)

db.users.find({ name: { $in: ["Fernando", "Jose"] } })
db.users.find({ name: { $nin: ["Fernando", "Jose"] } })

El primer comando muestra los documentos cuyo name se encuentra en el arreglo y el segundo todos los que no se encuentren

$and
$or
$not

db.users.find({ $and: [{ age: 12 }, { name: "Fernando" }] })
db.users.find({ $or: [{ age: 12 }, { name: "Fernando" }] })
db.users.find({ name: { $not: { $eq: "Fernando" } } })

El primer comando muestra los documentos que cumplen ambos filtros, el segundo sólo necesita cumplir uno de los filtros, el tercero invierte la selección dentro del filtro.

$exist

db.users.find({ name: { $exists: true } })

Muestra los documentos que poseen un campo llamado name

$expr

db.users.find({ $expr: { $gt: ["$nota1", "$nota2"] } })

Realiza la comparación entre diferentes campos, en el ejemplo se muestran los documentos cuya nota1 es mayor a su nota2

Read Modifiers

Formatear salida

pretty()

db.users.find({ age: 10}).pretty();

Obtener registros únicos

distinct() collectionName.distinct(field,query)

db.users.distinct("name")

Se pueden agregar al final de diferentes operaciones

sort
limit
skip

db.users.find().sort({ name: 1 })
db.users.find().limit(2)
db.users.find().skip(4)

El primer comando ordena de forma alfabéticamente los documentos según el nombre.
El segundo sólo muestra los 2 primeros documentos.
El tercero omite los 4 primeros resultados

Complex Update Object

$set
$inc
$rename
$unset

b.users.updateOne({ age: 12 }, { $set: { name: "jose" } })
b.users.updateOne({ age: 12 }, { $inc: { age: 2 } })
b.users.updateMany({}, { $rename: { age: "years" } })
db.users.updateOne({ age: 12 }, { $unset: { age: "" } })

El primer comando actualiza el name del primer documento que posea un age de 12
El segundo incrementa en 2 el age del primer documento que posea un age de 12
El tercero cambia el nombre del campo age a years de todos los documentos
El cuarto elimina el campo age del primer documentos con un age de 12

$push
$pull

b.users.updateMany({}, { $push: { friends: "John" } })
b.users.updateMany({}, { $pull: { friends: "Miguel" } })

El primero agrega un valor a al arreglo friends, el segundo elimina el valor , ambos de todos los documentos.

Docker

Fernando Chata — Sat, 28 May 2022 04:06:00 +0000

DockerHub MongoDB

docker pull mongo:latest

docker run -d
     -p <puerto de escucha>:27017
     -v <ruta de volumen>:/data/db
     --name <nombre de instancia>
     mongo

ej:
docker run -d -p 27017:27017 -v ~/dataDB/mongoDB:/data/db --name mymongodb mongo:latest

docker exec -it mymongodb bash
mongosh
db.createUser({user:"fernando", pwd:"password", roles:[]})
db.auth("fernando", "password")
show databases
use <db_name>
show collections
db.<collec_name>.find()

PostgreSQL

docker pull postgres

docker run -d
     -p 5432:5432
     -v C:\dataDB\postgres:/var/lib/postgresql/data
*    -e POSTGRES_PASSWORD=<password>
     -e POSTGRES_USER=<user_name>
     -e POSTGRES_DB=<database_name>
     --name pgdb
     postgres

psql -U <user> --password  --db <database_name>

SQL Server

docker pull mcr.microsoft.com/mssql/server:2022-latest

docker run -d -p 1433:1433 \
     -e "ACCEPT_EULA=Y" \
     -e "MSSQL_SA_PASSWORD=<password>" \
     --name sql1 \
     mcr.microsoft.com/mssql/server:2022-latest

MySQL

docker pull mysql

docker run -d
     -p 3306:3306
*    -e MYSQL_ROOT_PASSWORD=pswd
     -e MYSQL_DATABASE=
     -e MYSQL_USER=
     -e MYSQL_PASSWORD=
     -v C:\dataDB\mySQL:/var/lib/mysql 
     --name mysqldb
     mysql

docker exec -it mysqldb mysql -p

otros comandos útiles

Detiene la ejecución de un contenedor

docker stop id_contenedor

Lista las imagenes descargadas

docker images

Elimina containers

docker rm id_contenedor

Elimina imagenes

docker rmi nombre_imagen

Lista de containers

docker ps -a -q -s

(-a, muestra todos los containers incluso los que no se encuentran corriendo)
(-q, muestra sólo los id de los containers)
(-s, muestra el tamaño de los containers)

Formatos de fechas y horas en Javascript

Fernando Chata — Sun, 02 Aug 2020 20:49:03 +0000

Ojalá las cosas fuesen simples al hablar de fechas, lo común es:

const date = new Date();
console.log(date);
// Sun Aug 02 2020 14:54:33 GMT-0400 (hora estándar de Chile)

Usando toLocaleDateString()

Claro tanto texto no se vería bien, si queremos "embellecer" nuestros formatos de salida debemos usar toLocaleDateString() y obtendremos algo como:

const formatFullDate = date.toLocaleDateString()
// 2/8/2020

mejor, pero quería la versión larga, entonces le agregamos algunas opciones:

const formatFullDate = date.toLocaleDateString("es-CL", {
     weekday: "long", // narrow, short
     year: "numeric", // 2-digit
     month: "short", // numeric, 2-digit, narrow, long
     day: "numeric" // 2-digit
});
console.log(formatFullDate);
// domingo, 2 de ago. de 2020

ahí si, como se ven existen varias opciones, veamos

es-CL: corresponde al idioma y al país
narrow: devuelve la primera letra, por ejemplo, si fuese un domingo el resultado es sería una letra "D"
long: devuelve la palabra completa
short: devuelve la versión corta de la palabra, en el ejemplo devolvería la abreviación "dom"
2-digit: obliga a devolver dos dígitos, si el día es menor de 10 devuelve el dia con un cero adelante, en caso de los años, devuelve los dos últimos dígitos

Si nos encontrasemos en EEUU el resultado sería:

const formatFullDate = date.toLocaleDateString("en-ES", {
     weekday: "long", // narrow, short
     year: "numeric", // 2-digit
     month: "short", // numeric, 2-digit, narrow, long
     day: "numeric" // 2-digit
});
// Sunday, Aug 2, 2020

como se ve el formato inglés es diferente al formato español.

Usando toLocaleTimeString()

Ahora veamos las horas, para esto se usa toLocaleTimeString()

const form = date.toLocaleTimeString();
// 16:05:04

bien, bien, pero quizá queramos ver el AM o PM, o quizá nuestro país tiene diferentes zonas de horarias, por ejemplo en Chile, donde vivo, tenemos la Isla de Pascua, allá tienen dos hora de diferencia dependiendo del horario de invierno o verano, entonces tendré que agregar algunas opciones:

// hora continental - Santiago de Chile
const formatFullTime = date.toLocaleTimeString("es-CL", {
     timeZone: "America/Santiago",
     hour12: true, // false
     hour: "numeric", // 2-digit
     minute: "2-digit", // numeric
     second: "2-digit" // numeric
});
console.log(formatFullTime);
// 4:28:45 p. m.

// hora insular - Isla de Pascua
const formatFullTime = date.toLocaleTimeString("es-CL", {
     timeZone: "Pacific/Easter",
     hour12: true, // false
     hour: "numeric", // 2-digit
     minute: "2-digit", // numeric
     second: "2-digit" // numeric
});
console.log(formatFullTime);
// 2:28:45 p. m.

encontramos nuevas opciones, como:

timeZone: corresponde a la hora horaria que queremos visualizar, por ejemplo en Estados Unidos sería algo como "America/Los_angeles" o "America/New_york"
hour12: si queremos visualizar la hora en formato de 12 horas (agregando el AM o PM) la opción será "true" o en caso contrario de 24 horas

NodeJS, la vida de los procesos.

Fernando Chata — Sun, 02 Aug 2020 16:11:20 +0000

Desde hace poco he comenzado a estudiar node, y a veces mientras hacia pruebas con el fetch api, el código no seguía el orden que en mi cabeza debía seguir. Además de dejarme con algo de insomnio comencé a leer a qué se debía.

Veamos, si ves el siguiente código:

console.log('program start');
setTimeout(function() { console.log('first function') }, 3000);
setTimeout(function() { console.log('second function'); }, 2000);
setTimeout(function() { console.log('third function'); }, 1000);
console.log('program end');

Y, si no sabes como funciona el setTimeout() podrías suponer un recorrido línea por línea, y esperar una salida por consola como esta:

// program start
// first function
// second function
// third function
// program end

claro, si te digo que el setTimeout() le pone un temporizador a una función (setTimeout(<función>,<tiempo en milisegundos>), es decir ejecuta la función después de determinados milisegundos), entonces quizá pienses que obtendrás algo como esto:

// program start
// third function
// second function
// first function
// program end

Pues te vas a quedar sentado, pues la salida por consola es:

// program start
// program end   <--- Ojo, ojito, ojete
// third function
// second function
// first function

Pero cómo? resulta que javascript hace lo siguiente:

console.log('program start');

esto lo toma y lo ejecuta, es decir te muestra por consola el mensaje, y pasa a la siguiente línea de código.

setTimeout(function() { console.log('first function') }, 3000);

acá se detiene y ve una función, la que podría o no demorarse, entonces la deja en una cola, para que se vaya ejecutando en segundo plano, y pasa a la siguiente línea de código.

setTimeout(function() { console.log('second function'); }, 2000);

acá vuelve a encontrarse con otra función y hace lo mismo, a la cola que tengo prisa, y sigue con la siguiente línea

setTimeout(function() { console.log('third function'); }, 1000);

se repite el proceso y pasa de la función y continua

console.log('program end');

acá encuentra algo que puede hacer e imprime por consola el mensaje, y encuentra el final del archivo.

Mientras hacía todo esto, las funciones en cola siguieron ejecutándose y si llegaban a su final, pasaban a su vez a otra cola, de salida digamos.

Javascript revisa la cola de salida y nos muestra los resultados de las funciones que se ejecutaron, todo en orden, revisa luego si queda algo en la cola donde se encontraban las funciones y si no queda nada, pasa a revisar nuevamente la cola de salida, si no encuentra nada pues termina su trabajo.

Todo esto es por optimizar el tiempo de ejecución, pues si esperara hasta que cada función se ejecute para seguir a la siguiente, como el ejemplo, se demoraría en total 6 segundos, versus los 3 segundos que realmente se demora.

Esto toma relevancia al usar funciones promesa, que no se tiene certeza de cuanto demorará en llegar la respuesta.

Eso, bueno no soy experto así que si algo está mal o quieres acotar algo, pues tienes los comentarios y gustoso modifico.

Más información acá la encuentras

setTimeout()

Git for Dummies (like me)

Fernando Chata — Sat, 01 Aug 2020 23:19:15 +0000

Configuración inicial

git config --global user.name "your name"

git config --global user.email "your_mail@mail.com"

Inicializando Git

git init

Esto comando crea una carpeta .git en nuestro directorio de trabajo, donde se almacenará información de todos los cambios que realicemos a nuestro proyecto.

Clonando repositorio remoto

git clone <link>

con este comando "copiamos" a nuestra carpeta local todos los archivos y carpetas de un repositorio remoto.

Agregando los cambios de los archivos

git add <archivo.ext>
or
git add -A
or
git add .

Para guardar los cambios realizados primero debemos prepararlos, esto puede ser archivo por archivo, o todo el conjunto total de modificaciones.

Preparando la subida

git commit -m “<message>”

Este comando guarda los cambios realizados al código, le agrega un id o head a dicho "guardado", todo esto dentro de nuestro servidor local. El parametro "message" es un comentario para poder diferenciar diferentes subidas.

Subiendo cambios a servidor local

git pull origin <branch>

Este comando sube una copia de los cambios realizados en el codigo a nuestro servidor local. El parametro "branch" se refiere a la rama de nuestro servidor donde subiremos nuestros archivos, la rama principal es "master".

Subiendo cambios a servidor remoto

git push origin <branch>

Esto sube nuestos cambios al branch (o rama) de nuestro repositorio remoto, la rama principal es "master".

Otros comandos

git status

Muestra el estado actual de los cambios realizados desde el ultimo commit, los archivos nuevos creados, y los cambios en los diferentes archivos.

git branch

Nos muestra la rama actual donde nos encontramos

git reset --hard origin/master

Regresa el repositorio local al estado del repositorio remoto, se pierden los datos que has realizado desde el ultimo push.

git checkout -b <new branch>

Crea una nueva rama, y nos redirige allí.

git checkout <branch>

Nos cambia de rama.