---
# System prepended metadata

title: Instalación de aplicación.

---

![logo](https://i.imgur.com/ViLj5it.jpg)

 
# Instalación de aplicación.

Instalación del 'Sistema de GRP' by dBlocks.io


## Dependencias del sistema
Se recomienda tener un conocimiento básico de las siguientes tecnologías.
 - [Git (Sistema manejador de versiones)](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
 - [MariaDB (Base de datos)](https://mariadb.org/documentation/)
 - [NVM (Administrador de versiones de Node)](https://github.com/nvm-sh/nvm)
 - [Nodejs (Entorno de ejecución de JavaScript)](https://bulldogjob.com/news/449-how-to-write-a-good-readme-for-your-github-project)
 - [Angular (Framework de desarrollo)](https://angular.io/docs)
 - [Nestjs (Framework server-side)](https://docs.nestjs.com)
 - [HttpServer (Servidor HTTP)](https://www.npmjs.com/package/http-server)
 - [PM2 (Librería de administración de procesos)](https://pm2.keymetrics.io/docs/usage/quick-start/)


## Prerrequisitos
Dentro del servidor o sistema que se esté usando se recomienda tener una carpeta principal llamada `grp` donde clonaremos las aplicaciones.
Es necesario tener acceso al repositorio de la aplicación en gitlab con las credenciales proporcionadas.

### Clonando los proyectos

Para descargarlos antes necesitaremos tener instalado git en el sistema por lo que primero lo instalaremos con el siguiente comando 
```bash=
sudo apt install git
```

Si ya cuenta con los repositorios ejecute un 'git pull' dentro de la carpeta de cada repositorio para asegurar la última versión si no, nos situamos en la carpeta /grp y clonamos el repositorio con los siguientes comandos: 
Para clonar el front via HTTPS: 
```bash=
git clone https://gitlab.com/R1k4rd01/source-code-grp-back_fondeso.git
```
o bien via SSH:
```bash=
git clone git@gitlab.com:R1k4rd01/source-code-grp-front_fondeso.git
```
nos pedirá las credenciales dependiendo el método escogido para poder descargarlo y después clonamos el front con el siguiente comando:
```bash=
git clone https://gitlab.com/R1k4rd01/source-code-grp-front_fondeso.git
```
o bien via SSH:
```bash=
git clone git@gitlab.com:R1k4rd01/source-code-grp-front_fondeso.git
```
Posteriormente ya tendremos la carpeta del proyecto en el directorio.


## Instalación

### Instalando las dependencias del sistema en el servidor. 


- #### Instalando MariaDB
Para instalar la base de datos usaremos uso de los comandos de la [documentación oficial](https://mariadb.org/download/?t=repo-config&d=Debian+11+"Bullseye"&v=10.5&r_m=gigenet).
```bash=
    sudo apt install mariadb-server
    sudo mysql_secure_installation
```
El último comando se utiliza para asegurar su implementación estableciendo una 
contraseña de root (Es importante saber, que la contraseña debe ser la misma que la que se encuentra en el archivo dataSource.ts en la carpeta de 'src' del back)
``../grp/source-code-grp-back/src/dataSource.ts`` 



también deshabilitamos el inicio de sesión de root remoto, eliminando la base de datos de prueba, así como los usuarios anónimos y finalmente recargando los privilegios. Quedando de la siguiente manera:

     - `Enter current password for root (enter for none): `
     - `Switch to unix_socket authentication [Y/n]: n`
     - `Change the root password? [Y/n]: y `
     - `Remove anonymous users? [Y/n]: y`
     - `Disallow root login remotely? [Y/n]: n`
     - `Remove test database and access to it? [Y/n]: y`
     - `Reload privilege tables now? [Y/n] y`


- #### Instalación de NVM
Para instalar  nvm, se puede usar el siguiente comando cURL o Wget. En caso de no tener instalado curl por defecto tendremos que ejecutar el comando `sudo apt install curl`
```bash=
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash
```
o bien.
```bash=
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash
```
Una vez instalado, es necesario reiniciar la terminal o ejecutar los siguientes comandos para configurar y usar sin reiniciar.
```bash=
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
```


- #### Instalación de Nodejs
Para descargar, compilar e instalar la última versión de node, usaremos nvm anteriormente ya instalado, mediante el siguiente comando:
```bash=
nvm install node --lts
```
"`node`" con la bandera `--lts`es una manera de decir que se instale la última versión de node estable con largo tiempo de soporte la cual en el caso del servidor fue la `lts`.
###### Descargando librerías de la aplicación
Después de instalar node tendremos que descargar la carpeta node modules que contiene las librerías del proyecto para esto ejecutaremos el siguiente comando en cada una de las carpetas que clonamos.
```bash=
npm install
```
El comando anterior debe ser ejecutado dos veces una en la carpeta del front (./source-code-grp-front_fondeso) y una segunda vez en la carpeta de back (./source-code-grp-back_fondeso)

- #### Instalación de Angular
Para la instalación de Angular/Cli usamos el comando de su documentación oficial el cual es:
```bash=
npm install -g @angular/cli
```


- #### Instalación de NestJS
Para descargar e instalar NestJS se ejecuta el siguiente comando:
```bash=
    npm i -g @nestjs/cli
```


- #### Instalación de HttpServer
Para descargar e instalar el servidor `http` se ejecuta el siguiente comando:
```bash=
    npm install -g http-server
```
- #### Instalación de PM2
Para la instalación de PM2 bastará con ejecutar el siguiente comando:
```bash=
npm install pm2 -g
```
---

### Despliegue 
#### Despliegue base de datos
Para la instalación de la base de datos primero creamos una base de datos con el nombre que nos aparece dentro del archivo en la linea 11 que dice database:'' `./source-code-grp-back_fondeso/src/dataSource.ts` el cual es `GRP_BD` o en su defecto con el nombre de la base que se requiera pero **es importante que  el nombre de la base sea el mismo que se encuentra en el dataSource.js ya sea modificar el dataSource o crear la base de acuerdo al dataSource por defecto.** 

Accedemos a mariadb  con **`sudo mariadb -u root -p`** nos pedirá la clave de acceso de mariadb antes establecida, al entrar a la consola de mariadb escribimos el comando de creación de la base de datos:
```bash= 
CREATE DATABASE GRP_BD;
```
donde 'GRP_BD' es el nombre de la base de datos que se creará.

Una vez creada la base de datos podemos verificar que se ha creado correctamente con el comando:
```bash= 
SHOW DATABASES;
```
donde deberíamos ver la lista de las bases de datos y entre ella la que fue creada, confirmando la creación de la base de datos, salimos de entorno de Mariadb tecleando el comando '`exit;`' o con la combinación de teclas `ctrl+c` volviendo al entorno de Debian para después ejecutar el comando para correr el script de creación de la BD. Teniendo en cuenta que necesitamos estar en el directorio donde esté el script de creación.

```bash=
sudo mariadb -u root -p GRP_BD < dumpCreacion.sql
```
el comando anterior toma en cuenta que la base creada tiene por nombre 'GRP_BD' y el script de creación se llama 'dumpCreacion.sql' por lo que si se tiene otros nombres el comando genérico sería:

```bash=
sudo mariadb -u root -p (database) < (scriptDeEjecucion)
```

Nos pedirá escribir la contraseña configurada para mariadb para confirmar la ejecución del script.

### Generación de carpetas de distribución
#### Back
Para generar las carpetas de distribución, se necesita estar dentro de la carpeta del back (./source-code-grp-back_fondeso) y ejecutar el comando:
```bash=
nest build
```
lo que generará una carpeta en el directorio llamada '/dist' la cual será nuestra carpeta de distribución.
#### Front
**Nota.
Para compilar y generar la carpeta de distribución del front se requiere que el sistema cuente con ocho núcleos de procesamiento.**

Para el caso de front (./source-code-grp-front_fondeso)  generamos la carpeta con el comando:
```bash=
ng build
```
lo que nos generará una carpeta ./dist/grp-extreme
NOTA: Debido a lo grande del proyecto es necesario un equipo con al menos 8 gb ram y un procesador con al menos 4 nucleos para realizar la compilación.
 
### Desplegando aplicación (Sin pm2)
#### Back
Para iniciar el back es necesario estar dentro del directorio (./source-code-grp-back_fondeso) y ejecutar el comando:
```=bash
node dist/main.js
```
#### Front
Para iniciar el front es necesario estar dentro del directorio (./source-code-grp-front_fondeso/dist) y ejecutar el comando:
```=bash
http-server grp-extreme
```
Nos devolverá la url en la que se montó la aplicación.
### Desplegando aplicación con pm2
Podemos desplegar el sistema en segundo plano con PM2 ejecutando los siguientes comandos: (teniendo en cuenta que nos encontramos en la carpeta del back)

```bash=
pm2 start dist/main.js
```
En el caso del front es necesario crear un script de ejecución para inicializar el servicio con pm2 por lo que dentro de la carpeta '/dist'  crearemos un archivo llamado 'execScript.js' que contendrá el siguiente código:
```bash=
const { exec } = require('child_process');

exec('http-server ./dist/grp-extreme', (error, stdout, stderr) => {
  if (error) {
    console.error(`error: ${error.message}`);
    return;
  }

  if (stderr) {
    console.error(`stderr: ${stderr}`);
    return;
  }

  console.log(`stdout:\n${stdout}`);
});

```
con el script anterior ya podemos inicializar el servicio con pm2 por lo que se ejecuta el comando de pm2 desde el directorio `./grp-source-code-front`:
```bas=
pm2 start execScript.js
```
### Creación de script de bash para el arranque automático.
Creamos un archivo llamado 'initservice.sh' en el directorio `./grp` con el comando
```bash=
nano initservice.sh
```
Posteriormente  escribimos las siguientes líneas para configurar los comandos a ejecutar al iniciar.
**Nota***
Las rutas son absolutas por lo que en la parte de '/< user>/' de las rutas debe ser cambiada a la ruta correcta del sistema donde se esté instalando.
```bash=
#!/bin/sh
pm2 start /home/<user>/grp/source-code-grp-back/dist/main.js
pm2 start /home/<user>/grp/source-code-grp-front/dist/execScript.js
```
Una vez escrito lo anterior podemos guardar el archivo y salir del editor.

#### Configurar scripts de inicio usando CRON
CRON es un programador de trabajos  que puede ejecutar ciertas tareas al reiniciar el sistema. Podemos crear fácilmente un trabajo de inicio usando CRON. 
Simplemente edite su crontab con el comando:
```bash=
crontab -e
```
nos pedirá seleccionar un editor de texto puede elegir el de su preferencia en este caso nano y posteriormente nos abrirá el archivo siguiente:

![](https://i.imgur.com/z5A4QUb.png)

En ese archivo deberemos agregar al final la siguiente línea:
```bash=
@reboot /home/<user>/grp/initservice.sh
```
**Nota***
*Las rutas son absolutas por lo que en la parte de '/< user>/' de las rutas debe ser cambiada a la ruta correcta del sistema donde se esté instalando.*

![](https://i.imgur.com/QrEgQUe.png)

La directiva @reboot le dice a CRON que ejecute el script personalizado después de una operación de arranque / reinicio. Una vez modificado el archivo lo guardamos y nos dirá que se instaló por lo que ya iniciará el script cada que arranque o reinicie el sistema.




