UNIVERSIDAD PERUANA DE CIENCIAS APLICADAS 

SISTEMA PARA LA UNIFICACIÓN

DE HISTORIAS CLÍNICAS
MEDIANTE LA UTILIZACIÓN DE
BLOCKCHAIN
Despliegue Datacenter 
v. 1.2 
Preparado por:
Project Manager Mauricio Ichiro Yano Troncoso
Scrum Master Alonso Daniel Saravia Ochoa
Especialidad Ingeniería de Sistemas de Información
Empresa IT Innova

Historial de Versiones
Fecha Versión Autor Descripción de los cambios
Mauricio Yano
20/05/2022 1.0 Troncoso / Alonso Creación del documento.
Saravia Ochoa
Mauricio Yano
29/05/2022 1.1 Troncoso / Alonso Actualización del documento.
Saravia Ochoa
Mauricio Yano
06/06/2022 1.2 Troncoso / Alonso Corrección del documento.
Saravia Ochoa
 Índice

1. Diagrama de arquitecturas.........................................................................................................4
1.1. Arquitectura Física.............................................................................................................4
1.2. Arquitectura Lógica...........................................................................................................4
1.3. Arquitectura Integrada.......................................................................................................5
2. Código Fuente...........................................................................................................................5
3. Manual de despliegue................................................................................................................6
3.1. Levantamiento de máquina virtual en la nube...................................................................6
3.2. Instalación de componentes en máquina virtual..............................................................11
3.2.1. Acceso a máquina virtual.........................................................................................11
3.2.2. Instalación de Docker...............................................................................................11
3.2.3. Instalación de MySQL..............................................................................................14
3.2.4. Conexión y creación de base de datos con instancia MySQL..................................17
3.2.5. Instalación de Nginx.................................................................................................19
3.2.6. Instalación de npm....................................................................................................21
3.2.7. Instalación de PM2...................................................................................................21
3.2.8. Instalación de git.......................................................................................................22
3.2.9. Instalación de CURL................................................................................................22
3.2.10. Instalación de Go......................................................................................................22
3.2.11. Instalación de Fabric y Fabric Samples....................................................................23
3.3. Clonación de repositorios................................................................................................25
3.3.1. Clonación del subproyecto Chaincode.....................................................................25
3.3.2. Levantamiento de la red blockchain y creación de componentes de transferencia. .27
3.3.3. Carga del subproyecto Web......................................................................................28
3.3.4. Clonación del subproyecto Api................................................................................29
3.4. Aplicación desplegada.....................................................................................................31
1. Diagrama de arquitecturas
1.1. Arquitectura Física

1.2. Arquitectura Lógica

 1.3. Arquitectura Integrada

2. Código Fuente

El proyecto está dividido en tres partes, las cuales se muestra a continuación:

 Chaincode de la red blockchain:

 GitLab:
o Clonar con SSH: git@gitlab.com:j2735/chaincode.git
o Clonar con HTTPS: https://gitlab.com/j2735/chaincode.git
 GitHub:
o Clonar con HTTPS: https://github.com/ichirokun444/PRY2021242-Chaincode.git
 API REST:
 GitLab:
o Clonar con SSH: git@gitlab.com:j2735/api.git
o Clonar con HTTPS: https://gitlab.com/j2735/api.git
 GitHub:
o Clonar con HTTPS: https://github.com/ichirokun444/PRY2021242-Api.git
 Aplicación Web:
 GitLab:
o Clonar con SSH: git@gitlab.com:j2735/web.git
o Clonar con HTTPS: https://gitlab.com/j2735/web.git
 GitHub:
 o Clonar con HTTPS: https://github.com/ichirokun444/PRY2021242-Web.git
3. Manual de despliegue

Prerrequisito para el despliegue del proyecto:

o MySQL Workbench 8.0 CE

3.1. Levantamiento de máquina virtual en

la nube

Luego de ya contar con el prerrequisito se siguieron los siguientes pasos:

1. Adquirir una máquina virtual en la nube, que en este caso elegimos como proveedor a
DigitalOcean: https://www.digitalocean.com/?
refcode=311599aeceeb&utm_campaign=Referral_Invite&utm_medium=Referral_Progra
m&utm_source=CopyPaste y luego se procede a registrar e iniciar sesión con alguno de
los métodos disponibles.

2. Luego tendremos que elegir uno de los 2 métodos para verificar nuestra identidad.
3. Ingresamos los datos asociados a la tarjeta de crédito que se usará.

4. En caso el método de verificación sea aceptado, se mostrará la siguiente pantalla donde se

seleccionará la opción “Deploy a virtual machine”.
5. Posterior a ello, para el caso de la imagen del SO seleccionamos la opción de “Ubuntu
20.04 (LTS) x64” y para el plan seleccionamos la opción “Basic”.

6. El plan escogido para la máquina virtual para la realización de este manual fue el de 15
dólares/mes con 2 GB / 2 CPUs. Sin embargo, en el proyecto implementado el plan
escogido fue el de 20 dólares/mes con 4 GB / 4 CPUs, para contar con un mayor espacio
de almacenamiento y concurrencia de usuarios al sistema.
7. Luego procedemos a elegir la región en la cual estará alojada nuestra máquina virtual, de
los cuales el que nos brinda una mayor velocidad de conexión debido la cercanía con el
servidor es la opción de “New York 1”.

8. Respecto al método de autenticación para el acceso a la máquina virtual seleccionamos la

opción “Password” y colocamos una contraseña para el usuario root que cumpla con los
requisitos establecidos por la plataforma.
9. Como opciones adicionales únicamente marcamos la opción “Monitoring” con la cual
podremos obtener indicadores tales como el porcentaje de uso de CPU, memoria, banda
ancha, etc.

10. Como paso final, validamos que el proyecto sobre el cual se asignarán los Droplets sea el
que estamos creando y presionamos el botón “Create Droplet”.

11. Como resultado se nos debería mostrar la siguiente pantalla, en la cual podemos observar
el número IP de nuestra máquina virtual el cual debemos copiar en algún lugar para
posteriormente utilizarlo.
3.2. Instalación de componentes en máquina virtual
3.2.1. Acceso a máquina virtual
1. Ahora procederemos a acceder a la máquina virtual a través del CMD modo
administrador de nuestro equipo local, ingresando el comando “ssh
root@167.99.148.242” y presionamos el botón Enter.

2. Se nos pregunta si deseamos continuar con la conexión, a lo cual escribimos “yes” y

presionamos el botón Enter.

3. Luego de eso se nos pide ingresar la contraseña creada para el acceso a la máquina virtual.
En el caso de ingresar los datos de manera correcta podremos conectarnos a la máquina
virtual.

3.2.2. Instalación de Docker

1. Para lograr la instalación de Docker, primero tendremos que configurar el repositorio
actualizando el índice de paquetes apt, para lo cual ingresamos el comando “sudo apt-get
update” y presionamos el botón Enter.
2. Continuando con el proceso ingresamos el siguiente comando y presionamos el botón
Enter:
sudo apt-get install \
ca-certificates \
curl \
gnupg \
lsb-release

3. Luego tendremos que agregar la clave GPG oficial del Docker ingresando el comando
“sudo mkdir -p /etc/apt/keyrings” y presionamos el botón Enter.

4. Continuando con la agregación de la clave GPG ingresamos el comando “curl -fsSL

https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o
/etc/apt/keyrings/docker.gpg” y presionamos el botón Enter.
5. Posterior a ello ya para configurar el repositorio ingresamos el siguiente comando y
presionamos el botón Enter:

echo \

"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg]

https://download.docker.com/linux/ubuntu \

$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

6. Para instalar el Docker Engine, primero actualizamos el índice del paquete apt,
ingresando el siguiente comando “sudo apt-get update”.

7. Y luego instalamos las últimas versiones de Docker Engine, containerd y Docker

Compose ingresando el siguiente comando “sudo apt-get install docker-ce docker-ce-cli
containerd.io docker-compose-plugin”. Posterior a ello se nos mostrará un mensaje de
confirmación para continuar, al cual escribiremos la opción “Y”.
 8. Una vez instalados los componentes, procederemos a validar si el Docker Engine se
encuentra funcionando correctamente, para lo cual ingresamos el siguiente comando
“docker ps”.

3.2.3. Instalación de MySQL

1. El gestor de base de datos escogido para el proyecto fue MySQL por lo cual ahora
procederemos con su instalación, iniciando con la actualización del índice de paquetes,
ingresando el siguiente comando “sudo apt update”.

2. Luego instalaremos el paquete mysql-server ingresando el comando “sudo apt install

mysql-server”. Posterior a ello se nos mostrará un mensaje de confirmación para
continuar a lo cual escribiremos la opción “Y”.

3. Para asegurarnos que el servicio de MySQL ya se encuentre ejecutando en la máquina

virtual, ingresaremos el siguiente comando “sudo systemctl start mysql.service”.
4. Con la finalidad de mantener una mayor seguridad sobre los inicios de sesión remotos,
configuramos MySQL ejecutando un script de seguridad, para lo cual ingresamos el
comando “sudo mysql_secure_installation”.

5. Se nos pide confirmar si realmente deseamos establecer este tipo de seguridad sobre las
contraseñas a lo cual escribimos la opción “Y”.

6. Luego tendremos que escoger entre uno de los 3 niveles de políticas de validación de
contraseña, que para este caso elegimos la opción “0”.

7. Continuando con la configuración se nos pide ingresar la nueva contraseña por dos veces.
Cabe mencionar que para que el proyecto se ejecute correctamente ingresamos como
contraseña lo siguiente “202201Tesis”.

8. En algunos de los casos no podremos acceder a MySQL debido a estrictos privilegios de

acceso propios de este, es por ello que tendremos que salir y volver a conectarnos a la
máquina virtual colocando el comando “exit” para salir, cerramos la ventana del CMD en
 el que estábamos trabajando, abrimos un nuevo CMD en modo administrador, después
tendremos que ingresar el comando “ssh root@ 167.99.148.242” y colocar el password de
la máquina virtual.

9. Luego intentaremos acceder a la instancia de MySQL, ingresando el comando “mysql -u

root -p”, al dejar el password vacío y presionar Enter, se nos mostrará el siguiente
mensaje de error para el acceso del usuario root.

10. Luego tendremos que detener el servicio de MySQL en ejecución, ingresando el comando
“service mysql stop”.
11. Ahora iniciaremos MySQL sin utilizar su sistema de privilegios, ejecutando el comando
“mysqld_safe --skip-grant-tables &”.
12. Posterior a ello, abriremos un nuevo terminal y nos conectaremos a la máquina virtual.
Luego, iniciamos sesión en MySQL ingresando el comando “mysql -u root”.
13. Después de ello, tendremos que fijar la configuración de permisos del usuario root,
ejecutando los siguientes comandos uno por uno:
o use mysql;
o select * from user;
o truncate table user;
o flush privileges;
o grant all privileges on *.* to root@localhost identified by '202201Tesis' with grant
option;
14. Ahora cerraremos la sesión de MySQL con el comando “quit” y lo reiniciaremos en modo
normal con los siguientes comandos a ejecutarse de manera individual.
o kill -KILL [PID of mysqld_safe]
o kill -KILL [PID of mysqld]
o service mysql start
 15. Ahora ya no se debería tener problemas al ingresar a la instancia de MySQL con el
usuario root, por lo cual continuaremos con el proceso iniciando nuevamente sesión en
MySQL con el comando “mysql -u root -p202201Tesis”.
16. Continuando con la configuración, ahora crearemos un nuevo usuario root para
conexiones remotas, ingresando el comando “CREATE USER 'root'@ '167.99.148.242'
IDENTIFIED BY '202201Tesis';”
17. Luego, se le otorgará los privilegios correspondientes con el comando “GRANT ALL
PRIVILEGES ON *.* TO 'root'@'167.99.148.242' WITH GRANT OPTION;”
18. Una vez concedidos los permisos tendremos que editar el archivo mysqld.cnf en el cual
por default viene configurado para trabajar de manera local, para hacer está edición
tendremos que ingresar el comando “quit” para salir de MySQL y ejecutaremos el
comando “sudo vi /etc/mysql/mysql.conf.d/mysqld.cnf” con el cual se nos abrirá un editor
de texto en donde buscaremos la línea que menciona “bind-address = 127.0.0.1” y la
modificaremos por “bind-address = 0.0.0.0”.
19. Como punto final de está configuración tendremos que establecer que el Firewall permita
las conexiones al servidor MySQL utilizando la ip de la máquina virtual y el puerto de
MySQL, para ello ingresaremos el comando “sudo ufw allow from 167.99.148.242 to any
port 3306”.
20. Adicional a ello ya que nos encontramos configurando el Firewall, habilitaremos la
conexión con los puertos para conectarse a los subproyectos Api y Web a través de los
siguientes comandos que se ejecutan de manera individual:
o cd fabric-samples/medical transfer/
o sudo ufw allow 22
o sudo ufw allow 40000
o sudo ufw allow 40001
3.2.4. Conexión y creación de base de datos con instancia MySQL
1. Ahora procederemos a restaurar nuestra base de datos que ya cuenta con registros, para lo
cual utilizaremos el programa MySQL Workbench 8.0 CE, dentro del cual presionaremos
el botón para establecer una nueva conexión. Luego tendremos que ingresar los
mismos datos que se muestran en la imagen a continuación, el único dato que variará es el
 Hostname dependiendo de la IP de la máquina virtual en la nube que se posea. Una vez
completado los datos presionaremos el botón OK.

2. Luego tendremos que descargar el backup de la base de datos .sql a través del siguiente
enlace de OneDrive: PRY2021242.sql y alojarlo en una ubicación que recordemos.

3. Una vez dentro procederemos a importar los datos del backup, para lo cual nos
dirigiremos al menú de la parte superior y presionaremos la opción “Data Import”.

4. Luego marcamos la opción “Import form Self-Contained File” ya que todo el backup se
encuentra en un mismo archivo. Posterior a ello colocamos como ruta aquella en la que se
encuentra alojado el archivo .sql.
 5. Finalmente, importaremos la data del .sql presionando el botón ubicado
en la parte inferior derecha y esperaremos hasta que la barra de progreso del proceso de
importación haya terminado.

3.2.5. Instalación de Nginx

1. Debido a que nuestra solución cuenta con una aplicación web se requiere de un servidor
web en el cual poder alojar nuestra página, es por ello que utilizaremos uno de los
servidores web más populares llamado Nginx, para lo cual primero tendremos que
ejecutar el siguiente comando “sudo apt install nginx”. Y se nos informa que para realizar
esta instalación se utilizará una cierta cantidad extra del disco a lo cual escribimos como
opción “Y”.

2. Luego pasaremos a realizar ciertos ajustes al firewall para que este permita el acceso del
servidor web Nginx, es por ello que ingresando el comando “sudo ufw app list”,
obtendremos el listado de las configuraciones de la aplicación con las que UFW puede
trabajar.
3. Para el proyecto escogimos el perfil Nginx HTTP con el cual tendremos un tráfico de web
normal a través del puerto 80, para ello ingresamos el comando “sudo ufw allow 'Nginx
HTTP'”.

4. Para verificar el cambio realizado escribiremos el comando “sudo ufw status”.

5. Una vez ya hayamos culminado la instalación verificaremos que el servicio propio de

Nginx se esté ejecutando con el comando “systemctl status nginx”.

6. Ahora finalmente procederemos a detener e iniciar nuevamente el servicio ingresando el

comando “sudo systemctl restart nginx”.

7. Como resultado final en caso la instalación haya sido exitosa podremos validarla
ingresando la URL asociada a nuestro servidor que en nuestro caso es
http://167.99.148.242/ y observar la pantalla de bienvenida de Nginx.
3.2.6. Instalación de npm
1. El siguiente paso consistirá en instalar npm debido a que este es el administrador de
paquetes de la plataforma sobre el cual se desarrolló la parte Backend de nuestro proyecto
que es Node.js, para poder instalar este componente ingresamos el comando “npm install -
g n”. Y escribimos la opción “Y” cuando se nos pregunte si deseamos continuar con el
proceso de instalación.

3.2.7. Instalación de PM2

1. Luego instalaremos el administrador de procesos PM2, con el cual podremos gestionar el
registro de la aplicación, para ello ingresamos el comando “npm install pm2 -g”.
3.2.8. Instalación de git
1. Asimismo, necesitaremos instalar git para realizar la clonación de los archivos de nuestro
proyecto es por ello ingresamos el comando “sudo apt-get install git”.

3.2.9. Instalación de CURL

1. Para poder realizar la transferencia de archivos a través del protocolo HTTP requeriremos
instalar el software cURL ingresando el comando “sudo apt-get install curl”.

3.2.10. Instalación de Go
1. Nuestro proyecto utiliza la tecnología de blokchain la cual tiene como eje central al
chaincode propio de la cadena de bloques, en este caso el chaincode fue desarrollado bajo
el lenguaje de programación Go. El cual procederemos a buscar si se encuentra disponible
ingresando el comando “sudo apt search golang-go”.

2. Adicional al lenguaje de programación instalaremos su compilador ingresando el

comando “sudo apt search gccgo-go”.
 3. Finalmente, instalaremos el lenguaje Go ingresando el comando “sudo apt install golang-
go”.

4. Luego de la instalación visualizaremos la versión que ha sido instalada con el objetivo de

que haya compatibilidad con el proyecto, para lo cual ingresamos el comando “go
version”.

3.2.11. Instalación de Fabric y Fabric Samples

1. Tal como se menciono previamente nuestro proyecto utiliza la tecnología de blockchain,
específicamente la plataforma Hyperledger Fabric. Para la instalación de esta primero
tendremos que establecer el directorio de trabajo ingresando el siguiente comando:
mkdir -p $HOME/go/src/github.com/user
cd $HOME/go/src/github.com/user

2. Luego obtendremos el script de instalación de la plataforma ingresando el comando “curl

-sSLO https://raw.githubusercontent.com/hyperledger/fabric/main/scripts/install-fabric.sh
&& chmod +x install-fabric.sh”.

3. Siguiendo con el proceso de instalación, ejecutaremos el script de instalación con el

comando “./install-fabric.sh -h”.
 4. Para este caso estamos trabajando el Fabric con Docker con lo cual tendremos que instalar
las imágenes Docker asociadas y clonar el repositorio de muestras, ingresando el
comando “./install-fabric.sh docker samples”.

5. También ingresamos este otro comando “./install-fabric.sh d s”.

6. Ahora instalaremos exactamente la versión 2.4.2 de Fabric ingresando el comando

“./install-fabric.sh --fabric-version 2.4.2”.

3.3. Clonación de repositorios

3.3.1. Clonación del subproyecto Chaincode
1. Para realizar la clonación primero listaremos el contenido del directorio actual en el que
nos encontrados, ingresando el comando “ls”.

2. Ahora que ya contamos con la plataforma Hyperledger Fabric instalada accederemos a la

carpeta de samples, ingresando el comando “cd fabric-samples/”.

3. Luego creamos una nueva carpeta llamada medical-transfer ingresando el comando

“mkdir medical-transfer”.

4. En la carpeta creada clonaremos el repositorio del chaincode ingresando el siguiente

comando “git clone https://gitlab.com/j2735/chaincode.git”.

5. Luego de ello se nos solicitará ingresar el usuario y contraseña de nuestro usuario de

Gitlab, el cual tendremos que registrar, luego de ello cuando se nos solicite ingresar el
username en la consola de comandos se ingresa el correo de nuestra cuenta Gitlab, Luego
cuando se nos pida la contraseña, se tiene que crear una contraseña por aplicativo, con lo
cual nos dirigimos a la parte superior derecha, presionamos el botón al lado de nuestra
foto de perfil y luego seleccionamos la opción “Preferences”.

Luego en el menú de la parte izquierda seleccionaremos la opción “Access Tokens”.

 Continuamos ingresando un nombre al Token, en nuestro caso es hyperledger.

Luego le otorgamos todos los niveles de permiso al token, marcando todas las casillas y
finalmente creamos nuestro token personal.

Ahora en la parte superior se nos mostrará nuestro Token, el cual copiaremos e ingresaremos
en la parte de contraseña del CMD que dejamos pendiente.
 6. En caso las credenciales ingresadas estén correctas, la clonación del repositorio chaincode
mostrará el siguiente resultado.

7. Luego configuraremos la variable de entorno GOPATH ingresando el siguiente comando

“export PATH=$PATH:/usr/local/go/bin”.

8. También modificaremos la homedir del usuario root ingresando el comando “usermod --

move-home --home ~/go/src/github.com/user/fabric-samples root”.

3.3.2. Levantamiento de la red blockchain y creación de componentes de transferencia

1. De nuevo tendremos que salir y volver a conectarnos a la máquina virtual colocando el
comando “exit” para salir, cerramos la ventana del CMD en el que estábamos trabajando,
abrimos un nuevo CMD en modo administrador, después tendremos que ingresar el
comando “ssh root@ 167.99.148.242” y colocar el password de la máquina virtual.

2. Luego tendremos que dirigirnos a la ruta del directorio de la prueba de red ingresando el
comando “cd fabric-samples/test-network”.

3. El siguiente paso consta de parar la red de blockchain ejecutando el comando

“./network.sh down”.
 4. Una vez que la red se encuentre parada, crearemos el canal y los peers con los cual se
establecerá la conexión con el chaincode, ingresando el comando “./network.sh up
createChannel -c mychannel -ca”.

5. Luego, volveremos a realizar el despliegue de la red de blockchain ejecutando el comando

“./network.sh deployCC -ccn basic -ccp ../medical-transfer/chaincode -ccl typescript”.

6. Finalmente, para poder observar el resultado del despliegue de la parte del Chaincode del
proyecto, ingresamos el comando “docker ps” y obtenemos las imágenes Docker
asociadas a los peers creados.

3.3.3. Carga del subproyecto Web

1. El segundo apartado de nuestra solución consiste en una aplicación web, la cual
tendremos que clonar, para esto tendremos que retroceder hasta el directorio fabric-
samples, ingresando el comando “cd ..” continuando desde el punto anterior en el que se
dejó la configuración. Luego accederemos al directorio medical-transfer ingresando el
comando “cd medical-transfer/” y tocaría acceder al directorio web donde estará alojado
el subproyecto, al cual accedemos ingresando “cd web”.
 2. Para observar que nos encontramos en el directorio correcto ingresamos el comando “ls”
y debería mostrar lo siguiente:

3. Ahora procederemos a cargar el subproyecto web ingresando el comando “docker load -i

web.tar”.

4. Luego tendremos que ejecutar la última imagen Docker del apartado web a través del
puerto 40001:80 ingresando el comando “docker run -d -it -p 40001:80 medical-
web:latest”.

3.3.4. Clonación del subproyecto Api

1. El tercer y último apartado de nuestra solución consiste en una API REST, la cual
tendremos que clonar de nuestro repositorio, para ello primero tenemos que reiniciar la
red de blockchain, por lo cual retrocedemos dos directorios con respecto al paso anterior
ingresando el comando “cd ..” dos veces, después tendremos que ingresar al directorio
test-network con el comando “cd test-network” quedando de esta manera.

2. Luego ejecutaremos los siguientes comandos de reinicio de la red blockchain de manera

individual, tal como se realizó en el proceso de levantamiento de la red blockchain y
creación de componentes de transferencia:
o ./network.sh down
o ./network.sh up createChannel -c mychannel -ca
o ./network.sh deployCC -ccn basic -ccp ../medical-transfer/chaincode -ccl typescript
3. Posterior al reinicio de la red, retrocedemos del directorio web con el comando “cd ..”,
luego accedemos al directorio medical-transfer con el comando “cd medical-transfer”,
después al directorio del api con el comando “cd api” y para observar el punto en el que
nos encontramos ejecutamos el comando “ls”.

4. Posterior a ello tendremos que iniciar el servicio pm2 en el que está nuestra API,
ingresando el comando “pm2 start app.js”.

5. Como resultado podemos observar el servicio pm2 ejecutándose y con el estado en línea.

6. Continuando con el proceso, clonaremos el repositorio del api, ingresando el comando

“git clone https://gitlab.com/j2735/api.git api2”.
3.4. Aplicación desplegada

Luego de haber realizado todos los pasos detallados en el presente manual de despliegue, todo el
sistema estará funcionando de manera correcta tal como se puede observar ingresando al
siguiente enlace: http://167.99.148.242:40001/#/login en el cual actualmente tenemos desplegada
nuestra solución.

Para poder validar la funcionalidad del sistema se brinda las credenciales de acceso de 3 usuarios
cada uno perteneciente a un rol:

 Rol: Administrador
o DNI: 00000001
o Contraseña: contrasena

 Rol: Doctor
o DNI: 00000112
o Contraseña: contrasena
 Rol: Paciente
o DNI: 07865568
o Contraseña: contrasena