DEV Community: Francisco Javier Guerrero Martinez

Desplegando un Backend Graphql NodeJS Azure Container Apps

Francisco Javier Guerrero Martinez — Sun, 09 Oct 2022 21:42:07 +0000

En esta entrada realizaremos el despliegue de un backend utilizando Azure DevOPS (pipelines), Azure Registries y Azure Containers Apps

Requisitos

Cuenta en Azure
Servicio Azure Registries Activo
Servicio Azure Containers Apps Activo
Cuenta en Azure DevOps

Creando servicio Registries

Partiré de la premisa que ya cuentas con una cuenta en Azure, navegamos en el buscador de servicios y buscamos el Servicio Azure Container Registries

Una vez dentro, deberás de llenar los campos marcados como obligatorios

Para esta entrada te recomendaré que utilices en SKU: Basic, esto para reducir el gasto en la factura y si tu APP no tiene bastante demanda.

Al ser un registro básico, este estará público aplicará el mismo caso para el tipo de Encryptation. Si deseas agregar los tags puedes hacerlo para este ejemplo dejaré todo en blanco y saltaré hasta la última pantalla

Damos clic en el botón create para crear el recurso.

Conectado Azure DevOPS Pipelines con Azure Registries

En esta parte conectaremos nuestro repositorio a Registries a fin de obtener la imagen Docker que posteriormente desplegaremos.

Ingresamos al apartado pipelines de nuestro Azure DevOPS y crearemos una nueva

Seleccionamos Azure Repos Git y posteriormente el proyecto con el que vamos a trabajar. En mi caso es testProject

A continuación nos aparecerán las opciones disponibles, para esta entrada seleccionaremos la segunda opción de Docker (Build and Push and Image to Azure Container Registry)

Ahora seleccionamos la subscripción en la que desplegaremos el contenedor.

En la siguiente pantalla vamos a validar a que registro enviaremos la imagen, así como también el nombre que llevará la imagen. Para este caso dejaré todo como aparece en el asistente y hacemos clic en el Validate and Configure

En la siguiente pantalla nos aparecerá la pantalla del archivo de configuración del pipeline ya finalizado. Hacemos clic en Save and Run, damos commit y esperamos a que se ejecute el pipeline

Una vez que finalizó nuestro Pipeline, procedos a regresar al Registries. En el apartado Repositories podemos observar nuestra imagen desplegada.

Desplegando el contenedor a Azure Container App

Para este apartado crearemos un nuevo recurso de tipo Azure Container App.

Una vez creado el recurso, ingresamos y buscamos el apartado Containers. Probablemente tengamos el contenedor "hello-world", esto porque me he bricando un paso cuando estaba creando el recurso

Hacemos clic en Edit

Nos aperecerá la siguiente ventana donde eliminaremos el contenedor de ejemplo

Hacemos clic en el botón Add (+) y nos aparecerá un cuadro de diálogo donde se deberá ingresar la información para conectar el contenedor que acabamos de desplegar en Registries

Si nos aparece ese error es porque no tenemos permisos para leer las imagenes del Registro, para ello regresamos al Registro

En el apartado Access Keys habilitamos la opción Admin user

Te recomiendo guardar para uso futuro el password que aparece.

Una vez realizado esta modificación regresamos al Container Apps y volvemos a agregar el contenedor.

Ahora podemos tener acceso al registro y las imagenes de contenedor que este tiene.

Al final tienes un apartado Environment Variables, aquí configuras las variables de entorno de tu App, ejemplo conexión a base de datos, puertos, etc.

Como este es un simple hola mundo, solo agregaré la variable de entorno PORT, que es la necesaria para que la app pueda funcionar.

Finalizando las configuraciones hacemos clic en Add

Con esto tendremos nuestra aplicación contenerizada desplegada en Azure Containers App.

Probando el endpoint en Altair Graphql

Un análisis de cómo vulneraron mi servidor de pruebas de PostgresSQL y cómo proteger tu

Francisco Javier Guerrero Martinez — Mon, 20 Sep 2021 07:49:40 +0000

Un análisis de cómo vulneraron mi servidor de pruebas de PostgresSQL y cómo proteger tu instalación si eres nuevo con este motor de base de datos.

Recientemente inicié a trabajar con una base de datos PostgreSQL fuera del ambiente seguro de los contenedores, esto On Promise en un servidor virtual, ya se la saben primero hago explotar mis experimentos en casa y ya luego al mundo laboral.
No han pasado menos de tres días que empecé y me había percatado de que la CPU estaba al máximo y se me creaban una serie procesos que consumían todos los núcleos.

Sin comprender porque sucedía el día de hoy empecé a indagar por cuenta propia y descubrí una “vulnerabilidad” del propio gestor, “PgMiner Botnet Attacks PostgreSQL” hasta este punto debo reconocer lo noob que vengo siendo y el pecado de la inocencia, mi experiencia se desarrolla más en Percona con base MySQL.

Después de estar leyendo diversos artículos de cómo deshacerme de este “Malware” llegué a las entradas de Sanchistsharman Investigation into Postgres malware (hack?) - DEV Community, pero antes de describir todo esto te explico.
Siempre que instalo un nuevo servidor Linux por defecto va Glances and Htop para tener una vista más clara se los procesos que se están ejecutando.

UFW to Rescue

El proveedor actual no nos da un firewall administrable así que lo primero que realicé fue habilitar ufw, actualmente trabajo con Ubuntu Server 20.04.

En este punto dejo abierto solo los puertos que requiero para administrar el servidor.
Una vez aplicadas las reglas al firewall procedí a deshabilitar el logueo de usuario postgresql y revocar los accesos a las bases de datos.

Como siguiente punto cambiar el puerto 5432 por uno diferente, esto lo recomiendo para todos los servicios a excepción de los puertos 80 y 443, el resto de los servicios puede ser cambiado.
En este punto tanto el uso de la CPU como de la Memoria había disminuido.

Lo mismo de agradecido hasta ahora con las conexiones al servidor

Te recomiendo seguir esta guía Cómo configurar un firewall con UFW en Ubuntu 20.04 | DigitalOcean

Posteriormente regresando al post de Sanchistsharman me he puesto a leerlo todo y trate de entender el cómo lo había hecho.

En mi caso particular estoy trabajando con la versión 12 del motor y el manual no funcionó como tal sin embargo al navegar en /var/lib/postgresql/12 había encontrado un “binario llamado k” pero lo que el indicaba en el manual no.

Retrocedí un directorio y ejecuté el comando ls -f para mostrar los archivos ocultos y me encontré con el siguiente archivo .systemd-private-2OossFop8vSbHI1fjSzMJoolZfE29S.sh cuyo contenido no es más que una cade hasheada a base 64

A continuación la imagen

Acorde a lo que indica el post de sanchistsharma hay que navegar en los directorios del archivo ya desencriptado para removerlo.

Después de una batalla de tres horas así luce nuevamente mi servidor de pruebas

Conclusiones.

Después de esta vulnerabilidad recomendaría que, aunque tengas una instalación en Windows revisaras el estado de tus procesos (así sea para pruebas), si vas a trabajar con un servidor fuera de contenedores:

Cambiar los puertos, deshabilitar el logueo para el usuario postgresql y crear otro rol que pueda administrar el motor
Utilizar una contraseña de más de 16 caracteres algo como wt2Ut/rF)asd3412-*--x~FZ.!*V((k4ry podría ayudar
No dar por sentado que la instalación por defecto mitigará errores o vulnerabilidades, así sea la última versión.
Linux es un sistema seguro, los errores los comete el administrador sorry
Aventurarse a trabajar y aprender cosas nuevas es divertido dentro de un entorno seguro, cuando vayas a producción asegúrate de haber aprendido todo y conocer realmente la tecnología que vas a implementar y sus vulnerabilidades, hoy lo aprendí a la mala.
Siempre pregúntate ¿qué pasó aquí? Y cómo poderlo resolver, recuerda que en producción se vuelve más complicado, ten ese espíritu de batalla e investigación.
Duerme a tus horas.

Referencias

Creando un API Microservicios con GraphQL + Apollo Gateway y MySQL

Francisco Javier Guerrero Martinez — Sat, 11 Sep 2021 22:00:50 +0000

Hace unos días que rondaba en mi cabeza el cómo poder diseñar una arquitectura basada en servicios utilizando el Stack que actualmente estoy aprendiendo "GraphQL + Apollo + NodeJS + TypeScript y MySQL"

Evidentemente hasta ahora no había tenido necesidad de hacer algo parecido al menos no en mis anteriores proyectos, sin embargo todo nace por una necesidad "cómo podría optimizar los procesos de entrega en la página de RockandRo".

Anteriormente había diseñado un API basada en REST, un monolito, sin embargo las necesidades del juego van cambiando así como las mías como cliente.

En esta entrada realizaremos un pequeño ejercicio de un API basada en Microservicios utilizando GraphQL.

Tabla de contenido

¿Qué es un microservicio?
Problemática
Codificando servicio proveedor
Codificando servicio Gateway

¿Qué es un microservicio?

Según la documentación proveída por Microsoft Azure define a los microservicios cómo "un método arquitectónico para crear aplicaciones donde cada función (o servicio) principal se compila e implementa de manera independiente". (Ref)

Esto que significa en palabras "mortales", tu puedes definir tus propias funciones en diferentes lenguajes de programación en diferentes lenguajes de programación e ir agregando funcionalidad, así mismo si uno de los servicios llegase a fallar el resto podría seguir funcionando, gracias a que la arquitectura es distribuida y ligeramente acoplada, cosa que con un sistema basado en una arquitectura en Monolito causaría la detención del mismo.

Problemática

Nota: Utilizaré la palabra cliente para hacer referencia a la entidad o persona que contrató nuestros servicios.

El cliente desea crear, obtener, modificar y eliminar la información de sus proveedores

¿Qué información desea almacenar el cliente de sus proveedores?

Nombre del proveedor
Representante de ventas
Teléfono de contacto
Correo Electrónico

Codificando servicio proveedor

Creando la base de datos

Creamos una nueva base de datos, en mi caso la llamaré proveedores:

CREATE DATABASE proveedores;

Posteriormente creamos la tabla con la información descrita en el apartado Problemática.

CREATE TABLE proveedor (nombreProveedor VARCHAR(150),
representante VARCHAR(120),
telefono VARCHAR(10),
email VARCHAR(150),
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY)

Ya tenemos lo básico para iniciar.

Arquitectura de la aplicación

En primera instancia vamos a crear el servicio "proveedor" (service-proveedor) las dependencias que utilizaré serán las siguientes:

"@apollo/gateway": "^0.40.0",
"@graphql-tools/load-files": "^6.4.0",
"@wiicamp/graphql-merge-resolvers": "^2.1.2",
"apollo-server": "^3.0.2",
"apollo-server-core": "^3.0.2",
"apollo-server-express": "^3.1.2",
"dotenv": "^10.0.0",
"graphql": "^15.5.2",
"graphql-tools": "^8.2.0",
"mysql": "^2.18.1",
"mysql2": "^2.2.5",
"ts-node": "^10.0.0",
"ts-node-dev": "^1.1.1",
"typescript": "^4.3.5"

Dependencias de desarrollo

"@types/express": "^4.17.12",
"@types/express-graphql": "^0.9.0",
"@types/graphql": "^14.5.0",
"@types/node": "^16.4.0"

Requerimientos funciones

Crear un nuevo proveedor
Editar la información de un proveedor
Eliminar un proveedor de la base de datos
Obtener la información de un proveedor
Obtener la lista de proveedores

Definición del archivo SQL_PROVEEDORES.ts

En este archivo definiremos las consultas a la base de datos que prácticamente son las reglas del negocio definidas en el apartado Requerimientos funcionales, este archivo tendrá el siguiente contenido.

//Crear un proveedor
export const CREARP_ROVEEDOR =
  "INSERT INTO proveedor (nombreProveedor,representante,telefono,email) VALUES (?,?,?,?)";
//editar proveedor
export const EDITAR_PROVEEDOR =
  "UPDATE SET nombreProveedor=?, representante=?, telefono=?, email=? SET WHERE id=?";
//Eliminar proveedor
export const DELETE_PROVEEDOR = "DELETE FROM proveedor WHERE id= ? ";
//Listar proveedor
export const SELECT_PROVEEDOR = "SELECT  FROM proveedor WHERE id=? LIMIT 1";
//Listar todos los proveedores
export const SELECT_ALL_PROVEEDORES = "SELECT  FROM proveedor ";

Creado esto, nos dirigimos a la carpeta config donde crearé los siguientes dos archivos:

.env
mysql.persistences.ts

En el archivo .env crearemos las variables de entorno

NODE_ENV="DEVELOPMENT"
PORT="PUERTO_DONDE_ESCUCHARÁ_EL_SERVICIO"
MYSQL_HOST="IP/URL DEL SERVIDOR MYSQL"MYSQL_USER="USUARIO_DB"
MYSQL_PASSWORD="CONTRASEÑA_DB"
MYSQL_DB="nombre_de_la_base_de_datos"

Ahora, en el archivo mysql.presistences.ts agregaremos el siguiente código, este código nos permitirá conectarnos con la base de datos

import { createPool } from "mysql2/promise";
export default createPool({
  host: process.env.MYSQL_HOST,
  user: process.env.MYSQL_USER,
  password: process.env.MYSQL_PASSWORD,
  database: process.env.MYSQL_DB,
  decimalNumbers: true,
});

Ya que tenemos estos archivos creados, nos vamos a la carpeta Schema, donde crearemos el schema proveedor, el cual quedará definido de la siguiente manera:

type Query {
  obtenerProveedores: [Proveedor]
  obtenerProveedor(id: ID): Proveedor
}

type Mutation {
  addProveedor(proveedor: ProveedorInput): String
  updateProveedor(proveedor: ProveedorInput): String
  deleteProveedor(id: ID): String
}
type Proveedor {
  id: ID
  nombreProveedor: String
  representante: String
  telefono: String
  email: String
}

input ProveedorInput {
  nombreProveedor: String
  representante: String
  telefono: String
  email: String
  id: ID
}

Básicamente ya tenemos la estructura del servicio a continuación trabajaremos en la definición de los resolvers, dentro de esta carpeta tenemos mutation y query que básicamente son las operaciones que realizará el servicio, mismas que fueron definidas anteriormente en las reglas del negocio.

Inicialmente empezaré a trabajar en la carpeta mutation en esta carpeta crearemos dos archivos nuevos:

index.ts El cual "unirá" los archivos de mutaciones
proveedores.ts El cual contiene la definición de las reglas de negocio de Agregar, Eliminar, Editar

Dentro del archivo poveedores.ts definimos las siguientes funciones.

import {
  CREAR_PROVEEDOR,
  DELETE_PROVEEDOR,
  EDITAR_PROVEEDOR,
} from "../../sql/SQL_PROVEEDORES";

const resolverMutationProveedor = {
  Mutation: {
    //Agregar un nuevo proveedor a la base de datos
    async addProveedor(_: any, { proveedor }: any, { sql }: any) {
      try {
        let { nombreProveedor, representante, telefono, email } = proveedor;
        await sql.query("START TRANSACTION");
        await sql.query(CREAR_PROVEEDOR, [
          nombreProveedor,
          representante,
          telefono,
          email,
        ]);
        await sql.query("COMMIT");
        return "Operación finalizada con éxito";
      } catch (error: any) {
        await sql.query("ROLLBACK");
        throw new Error(error);
      }
    },
    //Actualizar la información del proveedor
    async updateProveedor(_: any, { proveedor }: any, { sql }: any) {
      try {
        let { nombreProveedor, representante, telefono, email, id } = proveedor;
        await sql.query("START TRANSACTION");
        await sql.query(EDITAR_PROVEEDOR, [
          nombreProveedor,
          representante,
          telefono,
          email,
          id,
        ]);
        await sql.query("COMMIT");
        return "Información actualizada correctamente";
      } catch (error: any) {
        throw new Error(error);
      }
    },
    //Eliminar registro
    async deleteProveedor(_: any, { id }: any, { sql }: any) {
      try {
        await sql.query("START TRANSACTION");
        await sql.query(DELETE_PROVEEDOR, [id]);
        await sql.query("COMMIT");
        return "Registro eliminado";
      } catch (error: any) {
        await sql.query("ROLLBACK");
        throw new Error(error);
      }
    },
  },
};

export default resolverMutationProveedor;

Dentro del archivos index.ts definiremos las siguientes funciones.

const GMR = require("@wiicamp/graphql-merge-resolvers");

//Query
import resolverMutationProveedor from "./proveedores";

const resolverMutation = GMR.merge([resolverMutationProveedor]);

export default resolverMutation;

A continuación definiremos el contenido de la carpeta query al igual que mutations esta tendrá dos archivos, uno llamado index.ts donde uniremos los archivos de query a medida que nuestro servicio vaya creciendo y otro llamado proveedores.ts

Definiendo el archivo proveedores.ts

import {
  SELECT_ALL_PROVEEDORES,
  SELECT_PROVEEDOR,
} from "./../../sql/SQL_PROVEEDORES";
const resolverQueryProveedor = {
  Query: {
    async obtenerProveedores(_: any, __: any, { sql }: any) {
      try {
        const [rows]: [any] = await sql.execute(SELECT_ALL_PROVEEDORES);
        return rows;
      } catch (error: any) {
        throw new Error(error);
      }
    },
    async obtenerProveedor(_: any, { id }: any, { sql }: any) {
      try {
        const [rows]: [any] = await sql.execute(SELECT_PROVEEDOR, [id]);
        return rows[0];
      } catch (error: any) {
        throw new Error(error);
      }
    },
  },
};

export default resolverQueryProveedor;

Definiendo nuestro archivo index.ts

const GMR = require("@wiicamp/graphql-merge-resolvers");

//Query
import resolverQueryProveedor from "./proveedor";

const mainResolver = GMR.merge([resolverQueryProveedor]);

export default mainResolver;

Básicamente hemos terminado con nuestro servicio de proveedores, lo único que falta es definir el archivos server.ts, el cual lucirá de la siguiente forma

server.ts

Al final, la estructura de nuestro servicio lucirá de la siguiente manera.

Codificando servicio Gateway

Este es mas sencillo de codificar.

Dependencias

"@apollo/gateway": "^0.41.0",
"apollo-server": "^3.3.0",
"dotenv": "^10.0.0",
"ts-node": "^10.0.0",
"graphql": "^15.5.2",
"typescript": "^4.3.5"

Dependencias de desarollo

"@types/graphql": "^14.5.0"
"@types/node": "^16.4.0",
"ts-node-dev": "^1.1.1"

Creamos el archivo server.ts dentro de la carpeta src, el cual tendrá el siguiente contenido.

Con esto tendremos funcionando un API basada en Microservicios utilizando GraphQL, MySQL y Apollo Gateway.

Puedes acceder al repositorio del código fuente desde aquí https://github.com/DiWolf/api-servicios-graphql