# Universidad de San Carlos de Guatemala - Sistemas Operativos 1

## Práctica 1: KVM, Docker y Containers
## 201800722 - José Daniel Velásquez Orozco

### Index
- [Overview](#overview)
- [Frontend](#frontend)
- [Api](#api)
- [Database](#database)
- [Backend](#backend)
- [Módulos y Kernel](#module)
- [Librerías de C](#library)
- [Máquinas Virtuales](#vm)
- [Containers e Images](#containers)
- [Docker-Compose](#compose)
- [DockerHub](#dockerhub)

### <a name="overview">Overview</a>
A continuación vamos a describir los componentes y herramientas utilizadas para la práctica que trata acerca de un sitio web construído en react que consume servicios de una api construída en golang la cual se comunica con una base de datos en mongoDB separados en contenedores diferentes.

La arquitectura utilizada en la práctica se muestra a continuación:


### <a name="frontend">Frontend</a>
[Link a repositorio](https://github.com/JDVelasquezO/SO1_Practice2_Frontend)

Para el cliente se creó un proyecto utilizando ```create react app``` utilizando Typescript y TSX para una mejor escritura de código, se usaron técncias como hooks para manejar el estado de la aplicación de forma reactiva, useEffect para un escuchador de eventos que se producen del lado del servidor a modo de socket. Para el diseño gráfico se utilizó la librería Material UI y para el entorno de desarrollo se utilizó el IDE WebStorm.

Para las gráficas y tablas se usaron librerías como ChartJS y Datagrid.


Se tiene la siguiente estructura de carpetas:

La vista final se muestra a continuación:

### <a name="api">Api</a>
[Link a repositorio](https://github.com/JDVelasquezO/SO1_Practice2_Api)

Se creó una api escrita en el lenguaje de programación Javascript y entorno Node con el framework Express para realizar peticiones http. Se creó una arquitectura basada en tres capas para crear modelos, controladores y retornar resultados en formato JSON gracias a las rutas y para prueba de endpoints se utilizó el software postman. También se utilizó como entorno de desarollo el editor Visual Studio Code. Las información fue transmitida en formato JSON.

La estructura de carpetas es la siguiente:


### <a name="database">Database</a>
La base de datos fue escrita en el gestor MySQL de Google Cloud, creando tablas tanto de Process como de Child para relacionar uno con el otro por medio del PID_parent, así como las tablas de Ram y CPU.
Para visualizar gráficamente los datos se utilizó el IDE Datagrip.


Relación entre Child y Process:

<strong>Tabla Parent</strong>


<strong>Tabla Child</strong>

### <a name="backend">Backend</a>
[Link a repositorio](https://github.com/JDVelasquezO/SO1_Practice2_Backend)

Se realizó un servidor en el lenguaje de programación Golang y se usó la librería Fiber para conectarlo a un puerto y enviar los datos a MySQL con el orm Gorm. Este lenguaje obtenía por medio de comandos nativos de Linux a los módulos instalados previamente.

Para enviar los datos a base de datos se usaron técnicas como Go Rutines para manejar funciones en paralelo.


La estructura de carpetas es la siguiente:

### <a name="modulos">Módulos y Kernel Linux</a>
[Link a repositorio](https://github.com/JDVelasquezO/SO1_Practice2_Modules)

Se instalaron 2 módulos dentro del directorio ```/proc``` para poder acceder a ellos mediante Golang. Estos módulos se instalaron obteniendo información de la RAM y procesos del CPU gracias al lenguaje C y las librerías de Linux. Como entorno de desarrollo se usaron los editores Sublime Text, CLion y Nano.


### <a name="library">Librerías de C</a>
Para obtener información de la memoria RAM y CPU se usaron las librerías:
- linux/module.h
- linux/kernel.h
- linux/mm.h
- linux/sched.h

Las estructuras de datos usadas fueron ```sysinfo``` y ```task_struct``` . Para generar los módulos en formato .ko se usaron archivos Makefile.


### <a name="vm">Máquinas Virtuales</a>
Se tienen dos máquinas virtuales de Google Cloud con Sistema Operativo Ubuntu Server 20.04 LTS en arquitectura x86 (Intel) de 64 bits, 4 GB de Memoria RAM, 10 GB de almacenamiento interno y permisos de HTTP y HTTPS. Una máquina virtual contiene los módulos y el backend para la base de datos, mientras la otra contiene la api y el frontend.


### <a name="containers">Containers e Images</a>
Las imágenes se crearon usando un archivo ```Dockerfile``` tanto para el frontend como para la api.


### <a name="compose">Docker-Compose</a>
Este archivo fue creado específicamente para ejecutar las imágenes subidas a dockerhub y crear contenedores correspondientes localmente.


### <a name="dockerhub">Dockerhub</a>
Las imágenes respectivas del frontend y backend están disponibles en los siguientes links:

- [Frontend](https://hub.docker.com/repository/docker/jdveloper/so1practica2frontend)
- [Backend](https://hub.docker.com/repository/docker/jdveloper/so1practica2api)