---
# System prepended metadata

title: Virtual Machines.
tags: [OPS, UNIAT]

---

VirtualBox
###### tags: `UNIAT` `OPS`
# Virtual Machines.
Emula un sistema operativo completo y funcional.


## Software
[Virtual box (open Source)](https://www.virtualbox.org)
[vmware (privativo)](https://www.vmware.com)

## Ventajas
* Al ser un sistema virtual, este corre completamente un plano aislado a nuestro sistema.
    * Podemos instalar cualquier tipo de programas, y solo afectara a la maquina virtual.
* La maquina virtual es almacenada como una imagen
    * Permite el uso de versiones.
* Los recursos son limitados por el host (anfitrión)




# Instalando Ubuntu en virtual box
1. Descargar Instalar Virtual box del siguiente enlace: https://www.virtualbox.org/wiki/Downloads
    1. ![](https://i.imgur.com/V7y0XcI.jpg)
    2. Descargar la versión para tu sistema.
    3. Instala la aplicación.
### Descargando Ubuntu minimal
Comenzaremos descargando la imagen ubuntu minimal del  siguiente enlace: https://help.ubuntu.com/community/Installation/MinimalCD
En la sección 64-bit PC descargamos la primera opción.
![](https://i.imgur.com/KR37a1x.jpg)
Al finalizar la descarga tendremos un archivo llamado mini.iso
![](https://i.imgur.com/s5Jl6iw.jpg)
Este archivo lo utilizaremos mas adelante

## Crear una maquina virtual
1. En el menú de virtual box presionamos el botón "new". para crear una nueva maquina virtual, será creada una "computadora virtual", así que asignaremos recursos y configuraciones.
![](https://i.imgur.com/egtOBh2.jpg)
2. Como configuración asignamos 3 parámetros 
    1. ![](https://i.imgur.com/eV9dWut.jpg)
    1. Nombre de la maquina virtual.
    2. El directorio donde estará la maquina virtual.
    3. El tipo (Linux, Windows, BSD, other)
    4. Version (versión de windows, o distribución de Linux) 
3. Asignar la memoria ram que usara la maquina virtual.
    1. 2048-4096MB Es suficiente. ![](https://i.imgur.com/mfZyNPq.jpg)
    
4. Crear un Disco duro virtual 
    1.Seleccionar la segunda opción ( Crear ) ![](https://i.imgur.com/nEA4JIM.jpg)
    2.Asignar el tipo VDI(VirtualBox Disk image) ![](https://i.imgur.com/dl4KEBr.jpg)
    3.Tipo de almacenamiento, seleccionar Dinámico ![](https://i.imgur.com/98NpU4V.jpg)
    4.Asignamos capacidad del disco duro ~32GB ![](https://i.imgur.com/gtLKM1v.jpg)
5. Al Finalizar tendremos la nueva maquina virtual de lado izquierdo ![](https://i.imgur.com/Ys4QHMi.jpg)


### Montando una imagen de instalación.
Para instalar el sistema operativo es necesario agregar la imagen de disco (Archivo .iso, .dmg) a la maquina virtual, usualmente al iniciar por primera vez nos pregunta el directorio de la imagen: ![](https://i.imgur.com/XesILnd.jpg)
Al presionar el botón en forma de folder, podremos seleccionar el path donde se encuentra la imagen de ubuntu minimal que descargamos 
previamente.

En caso de no aparecer esta ventana e iniciar por primera vez la maquina virtual mostrara este mensaje:
![](https://i.imgur.com/Mlk2uid.jpg)

La imagen de Disco puede ser agregada desde la pestaña de Devices-> OpticalDrives->Chose disk image...
![](https://i.imgur.com/xDxoZwZ.jpg)

Seleccionando la dirección de la imagen de ubuntu minimal, finalmente apagando la maquina virtual.
![](https://i.imgur.com/FH3N7xQ.jpg)

Y volviendo a encenderla debe iniciar con el contenido de la imagen.
![](https://i.imgur.com/jUonS1O.jpg)

--- 

# Instalando Ubuntu minimal 

Al aparecer esta ventana significa que estamos listos para comenzar a instalar ubuntu.
![](https://i.imgur.com/jUonS1O.jpg)
![](https://i.imgur.com/6CwzhCV.jpg)



* imagen ubuntu:  https://help.ubuntu.com/community/Installation/MinimalCD

* interface list: https://www.linuxtrainingacademy.com/install-desktop-on-ubuntu-server/

# Compilando en C++
Con nuestra instalación completamente limpia lo primero que haremos es loggearnos, nos pedirá el usuario y la contraseña:
```
user: ops
pswrd: 1234 //Al escribirlo no será mostrado en la terminal
```

Antes de instalar cualquier cualquier programa, vamos a actualizar la lista de paquetes utilizando 
```
sudo apt update 
```
* **sudo**: *Super user do* Otorga privilegios de administrador
* **apt**: es el nombre del gestor de paquetes en ubuntu.
* **update**: es la acción que llevara acabo apt.

Una vez actualizado el repositorio vamos a descargar el compilador de c/c++.
```
sudo apt install gcc g++
```
* **install**: es la acción realizada por apt.
* **gcc**: es el compilador para C.
* **g++**: es la version del compilador para C++.
En este paso nos pedirá instalar algunos paquetes extras, solo respondemos con un *Y* y presionamos enter

## Escribiendo código
Vamos a crear un directorio para hacer algunos ejemplos para compilar.
1. Crear un directorio llamado test utilizando mkdir. 
    ```
    mkdir test
    ```
2. Accesar al directorio.
    ```
    cd test
    ```
### usando VI
vi es un editor de texto en consola, muy ligero y viene por default en la instalación de ubuntu. Para este ejemplo vamos a crear un Hello world en lenguaje C.
1. Creamos un archivo de texto tipo .c 
    ```
    vi texto.txt
    ```
2. Al presionar enter la pantalla de la terminal ha cambiado al editor.
Es de vital importancia poner atención en la barra de la parte inferior, esta es nuestro menú. La forma de interactuar con el editor es utilizando shortcuts. ![](https://i.imgur.com/9h9OiJz.jpg)

    :::info
    `I -> insert` Al presionar I podemos comenzar a insertar texto dentro del editor.
    `esc-> escape` salir del modo editor y escribir cualquier otro shortcut.
    `: -> command` al estar en el menú (esc) podemos escribir comandos como:
    1. `q -> quit` Sirve para salir del editor vi.
    2. `w -> write` Escribe los cambios dentro del documento.
    
    Finalmente presionamos enter para ejecutar el comando.
    :::
Una combinación común de comandos es:
`esc -> : -> wq -> enter` 
:::danger
NO utilizar los shortcuts: 
ctlr+z 
ctlr+c
Estos interactuan con la terminal y no con el editor.
:::

### Compilar un programa en C utilizando gcc
creamos un documento de texto utilizando vi
`vi hello.c`
y escribimos lo siguiente:
```cpp=
#include<stdio.h>

int main()
{
 printf("Hello From gcc!");
 return 0;
}
```
al finalizar presionamos:
`esc -> : -> wq -> enter`
Para compilar el archivo hello.c utilizaremos gcc:
`gcc hello.c -o helloWorld`
* **gcc**: Es el compilador de C.
* **hello.c** es el nombre del archivo .c a ser compilado
* **-o**: Es un flag para notificar al compilador el nombre del programa compilado.
* **helloWorld**: Es el nombre del programa.

Si todo ha salido bien y el compilador no mostró ningún error vamos a ejecutar el programa con:
`./helloWorld`
* **./** Ejecuta el programa ~~duh!~~
* **helloWorld** nombre del programa.

Nos imprimirá el texto que escribimos en la función printf del código. 

### Compilar un programa usando c++ con g++
El proceso es muy similar al ejemplo anterior solo que vamos a agregar que el programa pueda recibir argumentos al momento de ejecutarse.

Vamos a crear un archivo llamado helloArg.cpp (Nota que ahora termina con .cpp)
`vi helloArg.cpp`
y escribimos el siguiente código:
```cpp
#include <fstream>
#include <iostream>
 
using namespace std;
 
int main ( int argc, char *argv[] )
{
    cout << "The arguments number is:" << argc << endl;
    return 0;
}
```
Imprimiendo cada argumento
```cpp
#include <fstream>
#include <iostream>
 
using namespace std;
 
int main ( int argc, char *argv[] )
{
    cout << "The arguments number is:" << argc << endl;
    return 0;
}
```
Al finalizar presionamos:
`esc -> : -> wq -> enter`
Para compilar el archivo helloArg.cpp utilizaremos g++:
`g++ helloArg.cpp -o argsCount`
* **g++**: Es el compilador de C++.
* **helloArg.cpp** es el nombre del archivo .cpp a ser compilado
* **-o**: Es un flag para notificar el al compilador el nombre del programa compilado.
* **argsCount**: Es el nombre del programa.
Probamos ejecutando el programa con:
```./argsCount```
Ademas podemos probar utilizando mas argumentos:
```./argsCount argumento```
```./argsCount Dos argumentos```

Posible tarea: 
1. Crear un binario llamado sum que sume todos los argumentos.
2. Crear un binario llamado mul que multiplique todos los argumentos.
2. Crear un binario llamado div que divida dos argumentos.
    


## Source:
* gcc:
https://linuxize.com/post/how-to-install-gcc-compiler-on-ubuntu-18-04
+ g++ argc and argv: https://www.cprogramming.com/tutorial/lesson14.html


