Initial commit

parents
Pipeline #472 failed with stages
node_modules/
.vscode/
yarn-error.log
npm-debug.log
package-lock.json
alias.sh
src/common/config/db.js
src/common/config/mail.js
src/common/config/openid.js
src/common/lib/event-bus
deploy/roles/backend/files/base-backend
deploy/roles/frontend/files/base-backend
## temporales creados por emacs
*~
\#*\#
.\#*
# Registro de actualizaciones y cambios
## Versión 1.1
Fecha: 12 Diciembre 2019
- Correcciones test unitarios
- Soporte hasta node.js 12.
- Agregación de validaciones
- Nueva estrucutra api
- Nueva estrucutra graphql
- Archivo openid.js.sample para integración a ciudadanía digital
## Versión 1.0
Fecha: 11 Diciembre 2018
1ra Versión: Proyecto base.
Este base contiene los siguientes módulos:
- Entidades
- Usuarios
- Personas
- Roles
- Módulos
- Permisos
- Tokens
- Ciudadanía Digital
También ya se integra los siguientes módulos con sus respectivos seeders
- Logs del sistema
- Parámetros del sistema
- Servicios de Interoperabilidad
Funcionalidades incluidas
- Integración con ciudadanía Digital
# Lista de Autora(e)s
* Omar Gutierrez <ogutierrez@agetic.gob.bo>
* Elio Canqui <ecanqui@agetic.gob.bo>
* Rodrigo Garcia <rgarcia@agetic.gob.bo>
* ...
# Instalación
## Requerimientos del servidor
Ver [SERVER.md](SERVER.md)
## Instalación del proyecto
1. Clonar el código fuente desde el repositorio.
```sh
$ git clone https://gitlab.agetic.gob.bo/agetic/base-backend.git
```
> Es posible que al descargar el proyecto con HTTPs, muestre siguiente error:
> ```sh
> Cloning into 'nombre-del-proyecto'...
> fatal: unable to access 'https://url-del-proyecto.git/': server certificate verification >failed. CAfile: /etc/ssl/certs/ca-certificates.crt CRLfile: none
> ```
> Configurar lo siguiente e intentar nuevamente la clonación:
> ```sh
> git config --global http.sslverify false
> ```
2. Ingresar a la carpeta.
```sh
$ cd base-backend
```
3. Verificar que se encuentra en la rama master o develop.
```sh
$ git branch
```
4. Instalar las dependencias de paquetes npm
```sh
$ npm run instalar
```
## Configuraciones
1. Copiar archivos de configuración
```sh
$ cp src/common/config/db.js.sample src/common/config/db.js
$ cp src/common/config/mail.js.sample src/common/config/mail.js
$ cp src/common/config/openid.js.sample src/common/config/openid.js
```
2. Configurar URL, client, client_params `nano src/common/config/openid.js`
```js
const openid = {
// issuer server openid connect
issuer: 'https://OPENID_URL',
// response registry client
client: {
...
},
// parameters registry client
client_params: {
scope: ['openid profile email']
}
};
```
3. Configurar correo electrónico `nano src/common/config/mail.js` (opcional)
```js
const correoConfig = {
origen: process.env.EMAIL_SENDER || 'info@dominio.gob.bo',
host: process.env.EMAIL_HOST || 'smtp.dominio.gob.bo',
port: process.env.EMAIL_PORT || 587,
secure: false,
ignoreTLS: false,
auth: {
user: '<unusuario@dominio.gob.bo>',
pass: '<password>'
},
tls: {
rejectUnauthorized: false
},
logging: s => debug(s)
};
```
4. Configurar correo electrónico `nano src/common/config/db.js`
```js
const db = {
database: process.env.DB_NAME || 'proyecto',
username: process.env.DB_USER || 'usuario',
password: process.env.DB_PASS || 'usuario',
host: process.env.DB_HOST || 'localhost',
dialect: 'postgres',
timezone: 'America/La_Paz',
logging: s => debug(s)
};
```
## Inicializar la base de datos
1. Ejecutar lo siguiente para crear las tablas, esto eliminará las tablas y los datos de estas para reescribirlos.
```sh
$ env NODE_ENV=production npm run setup
```
2. Ejecutar lo siguiente para poblar las tablas con datos iniciales.
```sh
$ env NODE_ENV=production npm run seeders
```
## Iniciar el servicio con pm2
```sh
$ env NODE_ENV=production pm2 start src/application/server.js --name "proyecto-api"
```
## Configurar Nginx
Editar el archivo de configuración `nano /etc/nginx/sites-enabled/default`
Agregar las siguientes lineas
```sh
...
location /myapp/ {
proxy_pass http://localhost:3000/;
}
...
```
Reiniciar el servicio
```sh
$ sudo service nginx restart
```
---
This diff is collapsed.
# Base Backend
Proyecto base para desarrollo de backends usando node.js, es un mini-framework que utiliza la arquitecutra [ddd](doc/Arquitectura.md).
Este base contiene los siguientes módulos:
- Entidades
- Usuarios
- Personas
- Roles
- Módulos
- Permisos
- Tokens
- Ciudadanía Digital
También ya se integra los siguientes módulos con sus respectivos seeders
- Logs del sistema
- Parámetros del sistema
- Servicios de Interoperabilidad
Funcionalidades incluidas
- Integración con ciudadanía Digital (require parametrizar)
- Módulo para deploy del sistema a producción
- Módulos API rest y graphql
- Ejemplo de uso para cronjobs
- app-Iop para gestionar servicios de interoperabilidad endpoints, tokens, etc en BD.
- Tests unitarios.
- Guardado de logs en BD.
## Sobre el proyecto
Licencia y lista de colaboradores
- Licencia: [LPG-Bolivia v1.0](LICENCIA.md)
- Lista de personas autoras: [COLABORACIÓN.md](COLABORACIÓN.md)
Requisitos
- Nodejs 10.13.0 en adelante
- Postgresql 9 en adelante
Instalación
- Especificación a detalle en archivo [INSTALL.md](INSTALL.md)
Documentación estrucutra del proyecto y código fuente `doc/`
- Arquitectura del proyecto: [Arquitectura.md](doc/Arquitectura.md)
- Estructura del código fuente: [Codigo.md](doc/Codigo.md)
- Modelos, roles y permisos: [Modelos.md](doc/Modelos.md)
Ejecutar lo siguiente para ejecutar tests unitarios de las 3 capas del DDD, esto eliminará las tablas y los datos de estas para reescribirlos.
```bash
npm run test
```
Puede usar los siguientes comandos por separado para hacer lo mismo que el comando `npm test`.
```bash
npm run test-db # Test de la capa de infrastructura
npm run test-domain # Test de la capa de dominio
```
# Registro de actualizaciones y cambios
## Versión 1.0
Fecha: 11 Diciembre 2018
1ra Versión: Proyecto base.
Este base contiene los siguientes módulos:
- Entidades
- Usuarios
- Personas
- Roles
- Módulos
- Permisos
- Tokens
- Ciudadanía Digital
También ya se integra los siguientes módulos con sus respectivos seeders
- Logs del sistema
- Parámetros del sistema
- Servicios de Interoperabilidad
Funcionalidades incluidas
- Integración con ciudadanía Digital
'use strict';
// Para ejecutar el CronJob se puede usar crontab, video explicativo: https://youtu.be/ppFqkXJmwS0
const { errors, config } = require('../src/common');
const domain = require('../src/domain');
const moment = require('moment');
(async () => {
let services = await domain(config.db).catch(errors.handleFatalError);
const { Modulo } = services;
console.time('=========> TIEMPO TOTAL');
try {
console.log('========== INICIO CRON ==========', moment().format('DD/MM/YYYY HH:mm:ss'));
await Modulo.getMenu();
console.log('========== FIN CRON ==========', moment().format('DD/MM/YYYY HH:mm:ss'));
} catch (e) {
console.error('ERROR EN EL CRON JOB:', e);
}
console.timeEnd('=========> TIEMPO TOTAL');
process.exit();
})();
# Manual de deploy para producción
Este documento contiene todas las instrucciones para instalar el sistema en producción.
**IMPORTANTE.-** Este deploy está en etapas de pruebas para que funcione al 100%
## 1. Instalando Ansible
Instalar de acuerdo al sistema operativo http://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html con la última versión de Ansible.
**Nota.-** Este documento se lo realizó con la versión 2.5.2 de Ansible.
## 2. Instalando Dependencias de Ansible
Se deben instalar los siguientes paquetes de ansible-galaxy para realizar el deploy del sistema.
``` bash
# Instalando Postgres
ansible-galaxy install ANXS.postgresql
# Instalando Nginx
ansible-galaxy install jdauphant.nginx
```
## 3. Configuración de la base de datos
Configurar los datos de la base de datos en el archivo `deploy/roles/database/vars/main.yml`, si se coloca la variable `pass` con un valor encriptado colocar la variable **encrypted** así `encrypted: yes`
## 4. Creando llave ssh de conexión
Creamos una llave ssh para poder conectarnos directamente con el servidor de producción
``` bash
# Generamos la llave ssh dentro la carpeta deploy/ssh con el nombre deploy
ssh-keygen -t rsa -C "ogutierrez@agetic.gob.bo - deploy"
```
## 5. Configurando servidor
Ingresamos al servidor de producción y agregamos la llave ssh dentro del mismo
``` bash
# Ingresamos como root
sudo su -
# Editamos el archivo ~/.ssh/authorized_keys
vi ~/.ssh/authorized_keys
```
Agregamos el contenido de nuestra llave pública `deploy/ssh/deploy.pub` que generamos previamente, lo copiamos en el archivo `authorized_keys` abierto en el servidor de producción y nos salimos del servidor.
**Nota.-** en caso de salir un error relacionado con known_hosts (esto no es en el servidor) eliminar este archivo con `rm ~/.ssh/known_hosts`
Probamos la conexión con el servidor de producción usando la llave privada generada en `deploy/ssh/deploy` (esto lo hacemos dentro la carpeta deploy del proyecto)
``` bash
ssh root@127.0.0.1 -p 2222 -i ssh/deploy
```
## 6. Copiando archivos para el deploy
Se copiará todo el código fuente para su subida a producción
``` bash
# Ejecutar este archivo shell dentro la carpeta deploy
sh copy.sh
```
Se debe verificar que todas estas carpetas existan con su contenido correspondiente:
``` bash
deploy/roles/common/files/common/
deploy/roles/infrastructure/files/infrastructure/
deploy/roles/domain/files/domain/
deploy/roles/application/files/application/
deploy/roles/web/files/web/
```
**Nota.-** Si el archivo `copy.sh` no copia todos los archivos requeridos ejecutar todos los comandos del archivo uno por uno.
## 7. Configurando base de datos y correo electrónico
- Se debe configurar la conexión de la base de datos en el archivo copiado `deploy/roles/common/files/common/src/config/db.js`
- Se debe configurar el correo electrónico en el archivo copiado `deploy/roles/common/files/common/src/config/correo.js`
## 8. Ejecutando Ansible y haciendo deploy del sistema
``` bash
# Ejecutamos el playbook de ansible
ansible-playbook -i inventory.ini backend.yml --private-key ssh/deploy
```
## 9. Probando servicios en el servidor de producción
``` bash
# Probando conexión a la bd en el servidor de producción
psql -U agetic apostilla
# Comprobamos el estado del servicio backend-admin
systemctl status backend-admin
# Comprobamos el estado del servicio backend-proxy
systemctl status backend-proxy
```
# Para entorno de desarrollo
## 1. Probando las configuraciones en vagrant
Si se desea probar el deploy de manera local seguir los siguientes pasos:
1. Requisitos.-
- Instalar Virtualbox https://www.virtualbox.org/wiki/Downloads
- Instalar Vagrant https://www.vagrantup.com/downloads.html
2. Instalando e iniciando un servidor Debian con Vagrant
``` bash
# Instalando Debian con Vagrant
vagrant init debian/jessie64
# Inicializando Debian Vagrant
vagrant up
# Ingresando a Debian mediante SSH
vagrant ssh
```
\ No newline at end of file
# -*- mode: ruby -*-
# vi: set ft=ruby :
# All Vagrant configuration is done below. The "2" in Vagrant.configure
# configures the configuration version (we support older styles for
# backwards compatibility). Please don't change it unless you know what
# you're doing.
Vagrant.configure("2") do |config|
# The most common configuration options are documented and commented below.
# For a complete reference, please see the online documentation at
# https://docs.vagrantup.com.
# Every Vagrant development environment requires a box. You can search for
# boxes at https://vagrantcloud.com/search.
config.vm.box = "debian/jessie64"
# Disable automatic box update checking. If you disable this, then
# boxes will only be checked for updates when the user runs
# `vagrant box outdated`. This is not recommended.
# config.vm.box_check_update = false
# Create a forwarded port mapping which allows access to a specific port
# within the machine from a port on the host machine. In the example below,
# accessing "localhost:8080" will access port 80 on the guest machine.
# NOTE: This will enable public access to the opened port
# config.vm.network "forwarded_port", guest: 80, host: 8080
# Create a forwarded port mapping which allows access to a specific port
# within the machine from a port on the host machine and only allow access
# via 127.0.0.1 to disable public access
# config.vm.network "forwarded_port", guest: 80, host: 8080, host_ip: "127.0.0.1"
# Create a private network, which allows host-only access to the machine
# using a specific IP.
# config.vm.network "private_network", ip: "192.168.33.10"
# Create a public network, which generally matched to bridged network.
# Bridged networks make the machine appear as another physical device on
# your network.
# config.vm.network "public_network"
# Share an additional folder to the guest VM. The first argument is
# the path on the host to the actual folder. The second argument is
# the path on the guest to mount the folder. And the optional third
# argument is a set of non-required options.
# config.vm.synced_folder "../data", "/vagrant_data"
# Provider-specific configuration so you can fine-tune various
# backing providers for Vagrant. These expose provider-specific options.
# Example for VirtualBox:
#
# config.vm.provider "virtualbox" do |vb|
# # Display the VirtualBox GUI when booting the machine
# vb.gui = true
#
# # Customize the amount of memory on the VM:
# vb.memory = "1024"
# end
#
# View the documentation for the provider you are using for more
# information on available options.
# Enable provisioning with a shell script. Additional provisioners such as
# Puppet, Chef, Ansible, Salt, and Docker are also available. Please see the
# documentation for more information about their specific syntax and use.
# config.vm.provision "shell", inline: <<-SHELL
# apt-get update
# apt-get install -y apache2
# SHELL
end
---
- hosts: backend-*
gather_facts: False
pre_tasks:
- name: Install Python 2
raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal)
- setup:
roles:
- database
- backend
\ No newline at end of file
#!/usr/bin/env bash
# Archivo para copiar el base-backend a la carpeta deploy/roles para subir a producción
echo - Copiando archivos para el deploy -
pwd
echo 1. Copiando Backend
rm -rf roles/backend/files/base-backend
cp -rf ../../base-backend roles/backend/files
rm -rf roles/backend/files/base-backend/node_modules
rm -rf roles/backend/files/base-backend/deploy
rm -f roles/backend/files/base-backend/src/common/config/db.js
cp roles/backend/files/base-backend/src/common/config/db.js.sample roles/backend/files/base-backend/src/common/config/db.js
rm -f roles/backend/files/base-backend/src/common/config/correo.js
cp roles/backend/files/base-backend/src/common/config/correo.js.sample roles/backend/files/base-backend/src/common/config/correo.js
echo 2. ¡Finalizado!
---
- hosts: frontend-*
gather_facts: False
pre_tasks:
- name: Install Python 2
raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal)
- setup:
roles:
- frontend
# Definir en localhost el IP de donde se subirá el proyecto
backend-local ansible_ssh_user=root ansible_ssh_host=localhost ansible_ssh_port=22
server {
listen 80 default_server;
listen [::]:80 default_server;
index index.html index.htm index.nginx-debian.html;
server_name _;
location /base-backend {
rewrite ^/base-backend(.*) $1 break;
proxy_pass http://127.0.0.1:3000;
}
location / {
try_files $uri $uri/ =404;
}
}
[Unit]
Description=Backend Admin
After=network.target
[Service]
Environment=NODE_ENV=production
Type=simple
User=root
WorkingDirectory=/usr/local/src/base-backend
ExecStart=/usr/bin/npm start
Restart=on-failure
[Install]
WantedBy=multi-user.target
---
dependencies:
- { role: node }
- { role: jdauphant.nginx }
---
- apt: name=git state=present
- apt: name=build-essential state=present
\ No newline at end of file
---
- include: deps.yml
- name: Copy Backend
copy:
src=base-backend
dest=/usr/local/src
mode=u=rwx,g=rwx,o=rx
- name: Run npm install
command: npm install
chdir=/usr/local/src/base-backend