Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Contenedores

2020-01-10T16:04:32Z

Artrodase: /* Paso 14: Ejercicios */

En esta práctica aprenderemos a utilizar [https://es.wikipedia.org/wiki/Docker_(software) docker] para desplegar contenedores.

= Paso 1: Instalar docker =

Vamos a añadir un nuevo repositorio, ya que docker no está en los repositorios
oficiales:

<syntaxhighlight lang="bash">
sudo apt update
sudo apt install docker.io
</syntaxhighlight>

Para ver si está todo bien y se ha instalado correctamente, comprobaremos que el
servicio está activo:

<syntaxhighlight lang="bash">
sudo service docker status
</syntaxhighlight>

Debería mostrar algo similar a lo siguiente:

<syntaxhighlight lang="bash">
● docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2019-08-26 09:41:40 UTC; 37s ago
Docs: https://docs.docker.com
Main PID: 3630 (dockerd)
Tasks: 8
CGroup: /system.slice/docker.service
└─3630 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
</syntaxhighlight>

Pulsamos la tecla 'q' para salir.

Si el servicio aparece inactivo, puedes lanzarlo con:

<syntaxhighlight lang="bash">
sudo service docker start
</syntaxhighlight>

= Paso 2: Ejecutar docker con nuestro usuario =

Para no necesitar sudo al utilizar docker, añadiremos a nuestro usuario al grupo
docker:

<syntaxhighlight lang="bash">
sudo usermod -aG docker ubuntu
</syntaxhighlight>

Para que el cambio tenga efecto, tendremos que cerrar la sesión de nuestro
usuario y abrirla de nuevo. Podemos hacerlo fácilmente pulsando CTRL + D y
volviendo a insertar nuestras credenciales.

= Paso 3: Repositorio de imágenes de contenedores DockerHub =

Docker ofrece un servicio de nube denominado ''DockerHub'' que puede ser empleado como red social para compartir tus imágenes de Docker. En ''DockerHub'' existen además imágenes de contenedores preconfiguradas de software, muchas de ellas oficiales (ofrecidas por el propio fabricante del software) que se podrán emplear como base para construir nuevas imágenes adaptadas a nuestras necesidades.

Podremos realizar búsquedas en este repositorio ''DockerHub'' puedes emplear el siguiente comando:

<syntaxhighlight lang="bash">
docker search hello-world
</syntaxhighlight>

Para descargarnos la imagen de ''hello-world'' podemos usar la orden ''pull'':

<syntaxhighlight lang="bash">
docker pull hello-world
</syntaxhighlight>

También podemos publicar imágenes propias, esto require '''registro de usuario''' en la nube de ''DockerHub'', lo que '''no''' es obligatorio para la realización de esta práctica. Para subir una imagen, hay que validarse como usuario en la nube de ''DockerHub'':

<syntaxhighlight lang="bash">
docker login
</syntaxhighlight>

Tras introducir tu usuario y contraseña, puedes comenzar a publicar tus propias imágenes.

<syntaxhighlight lang="bash">
docker push MI_IMAGEN
</syntaxhighlight>

= Paso 4: Comprobar imágenes en nuestra máquina =

Para ver las imágenes que tenemos en nuestra máquina, utilizaremos el comando:

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Inicialmente, no tenemos imágenes en almacenamiento, podemos descargarnos la imagen oficial de Ubuntu:

<syntaxhighlight lang="bash">
docker pull ubuntu:latest
</syntaxhighlight>

Ahora si, ya debería de aparecernos la imagen ''ubuntu''.

Comentar también que cada imagen puede tener varias etiquetas, por ejemplo, la imagen ubuntu, cuando la hemos visto en el listado de imágenes, venía con el tag latest, que es el tag que se descarga por defecto, pero nosotros podemos especificar otro, por ejemplo:

<syntaxhighlight lang="bash">
docker pull ubuntu:bionic
</syntaxhighlight>

Para traernos la versión de la imagen de Ubuntu ''bionic'' (18.04).

Ahora tendremos dos imágenes con diferente etiqueta, que serían como las diferentes versiones de cada imagen.

= Paso 5: Lanzar un contenedor =

Un contenedor no es más que una imagen de docker ejecutándose, sería similar a
una máquina virtual, aunque mucho más liviano.

Para crear un contenedor, utilizaremos una imagen, en este caso, la imagen
hello-world. Hacemos lo siguiente:

<syntaxhighlight lang="bash">
docker run hello-world
</syntaxhighlight>

Esto nos mostrará el siguiente mensaje si todo está correcto:

<syntaxhighlight lang="bash">
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/

For more examples and ideas, visit:
https://docs.docker.com/get-started/
</syntaxhighlight>

Al crear los contenedores utilizando el comando 'run', tenemos varias opciones:

== Paso 5.1: Ejecutar una terminal en el contenedor en modo interactivo (-ti) ==

Para este ejemplo vamos a utilizar otra imagen diferente, en este caso vamos a utilizar una imagen de ubuntu.

Vamos a lanzar un contenedor y ejecutar una terminal en el que se va a ejecutar el programa '''bash''' que me ofrece un interprete de órdenes:

<syntaxhighlight lang="bash">
docker run -ti ubuntu bash
</syntaxhighlight>

La opción ''-t'' indica que se crea un terminal en el contenedor. Y la opción ''-i'' indica que el contenedor se ejecuta en modo interactivo.

Al acceder al contenedor de ''ubuntu'' nos aparece un ''hash'' en el prompt de la shell, que identifica a la instancia del contenedor (es valor es similar al que muestra la orden ''docker container ls'').

Para salir del contenedor, escribimos 'exit' o pulsamos 'CTRL + D'

== Paso 5.2 Ejecutar en segundo plano (-d) ==

<syntaxhighlight lang="bash">
docker run -d hello-world
</syntaxhighlight>

Nos mostrará el id del contenedor y se ejecutará en segundo plano, por lo que la salida que antes obtuvimos, ahora no se muestra. Para poder ver esta salida,
podemos utilizar el comando logs y el id mostrador anteriormente:

<syntaxhighlight lang="bash">
docker logs 2ec1daae4676a4e84dc04fd91399c1dfe92119544ff12ee307991fe573d3db64
</syntaxhighlight>

== Paso 5.3: Añadir variables de entorno a un contenedor ==

Utilizaremos la imagen anterior, y vamos a añadir una variable de entorno
llamada TEST que contenga el valor 'test'. A parte, también ejecutaremos la
terminal como antes, para comprobar con el comando echo, que la variable de
entorno está creada correctamente:

<syntaxhighlight lang="bash">
docker run -ti -e TEST=test ubuntu bash
</syntaxhighlight>

Ahora, desde el contenedor podemos comprobar el valor de la variable de entorno ''$TEST''.

<syntaxhighlight lang="bash">
echo $TEST
test
</syntaxhighlight>

= Paso 6: Listar contenedores en ejecución =

Hemos estado haciendo pruebas y ejecutando contenedores en el paso anterior, vamos a ver donde se encuentran estos contenedores que hemos ejecutado, y después veremos algunas opciones más del comando run.

Tenemos dos opciones para ver los contenedores:

<syntaxhighlight lang="bash">
docker container ls -a
</syntaxhighlight>

o la versión corta:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Ambas hacen lo mismo, y debería de mostrarnos una salida similar a la siguiente:

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e2bde5f5500c ubuntu "bash" 6 minutes ago Exited (0) 2 seconds ago pensive_sammet
544ad27dbc3c ubuntu "bash" 7 minutes ago Exited (0) 7 minutes ago serene_elgamal
</syntaxhighlight>

En la información veremos que el contenedor tiene el estado exited, eso quiere decir que no se está ejecutando y ya ha finalizado. Vamos a hacer una prueba para ver un contendor ejecutándose:

<syntaxhighlight lang="bash">
docker run -d ubuntu sleep 30
</syntaxhighlight>

Con el comando sleep 30 esperamos 30 segundos hasta que termine el comando, asíque durante esos 30 segundos, el contenedor estará ejecutándose, veámoslo:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
eacceb27d52d ubuntu "sleep 30" 12 seconds ago Up 11 seconds sharp_pasteur
</syntaxhighlight>

Vamos a ver alguna opciones más de la orden ''run''.

== Paso 6.1: Dar un nombre al contenedor (--name) ==

Por defecto, docker creará automáticamente un nombre como hemos visto en las salidas del comando ''docker ps -a''. Podemos establecer el nombre del contenedor que queramos con la opción ''--name'':

<syntaxhighlight lang="bash">
docker run -d --name mi_ubuntu ubuntu
</syntaxhighlight>

== Paso 6.2: Eliminar contenedor cuando termine (--rm) ==

Vamos a mezclar todo lo visto anteriormente:

* Lanzar en segundo plano (-d)
* Ejecutar contenedor durante 30 segundos (sleep 30)
* Dar un nombre a la imagen (--name)
* Eliminar contenedor cuando termine (--rm)

<syntaxhighlight lang="bash">
docker run -d --rm --name bye-bye ubuntu sleep 30
</syntaxhighlight>

Antes y una vez pasados los 30 segundos, podemos comprobar que el contenedor ha desaparecido.

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

= Paso 7: Parar y eliminar contenedores =

Los contenedores podemos pararlos o eliminarlos, veamos como hacerlo. Antes que
nada, borraremos todos los contenedores que estén terminados, para ello:

<syntaxhighlight lang="bash">
docker container prune
docker ps -a
</syntaxhighlight>

Ya lo hemos dejado todo limpio para seguir, ahora vamos a crear un contenedor,
utilizando un comando de linux que no termina, para que así se quede
ejecutándose el contenedor infinitamente:

<syntaxhighlight lang="bash">
docker run -d -ti --name my_container ubuntu bash
docker ps -a
</syntaxhighlight>

Vamos a pararlo (podemos utilizar el nombre dado o el id):

<syntaxhighlight lang="bash">
docker stop my_container
docker stop e4901956f108
docker ps -a
</syntaxhighlight>

Veremos que ya ha terminado, y ahora vamos a eliminarlo, pero solo este
contenedor, no como previamente que eliminamos todos. Lo mismo que para pararlo,
podemos utilizar el nombre o el id.

<syntaxhighlight lang="bash">
docker container rm my_container
docker container rm my_container
docker ps -a
</syntaxhighlight>

Veremos que ya no tenemos el contenedor y está correctamente eliminado.

= Paso 8: Conectarnos a un contenedor que se está ejecutando en segundo plano =

Vamos a ejecutar de nuevo un contenedor que no termine:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_attach ubuntu bash
</syntaxhighlight>

Ahora, vamos a conectarnos a este contenedor que está ejecutándose en segundo
plano:

<syntaxhighlight lang="bash">
docker attach to_attach
</syntaxhighlight>

Veremos la orden bash ejecutándose, para terminar, hacemos un 'CTRL + C', y ahora, veremos que ha pasado con el contenedor:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Lo veremos parado, por que lo que hemos hecho ha sido conectarnos al contenedor
y parar el comando que se estaba ejecutando, así que ahora tenemos el contenedor
finalizado.

= Paso 9: Ejecutar en un contenedor otro comando =

Vamos a ver otresta vez como ejecutar un comando en un contenedor que ya está
ejecutándose:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_exec ubuntu bash
</syntaxhighlight>

Ahora, vamos a ejecutar un comando en ese contenedor. El comando exec es similar
al comando run, pero para ejecutar un comando dentro de un contenedor:

<syntaxhighlight lang="bash">
docker exec -ti to_exec ls
</syntaxhighlight>

Ahora estamos dentro del contenedor creado anteriormente:

<syntaxhighlight lang="bash">
ps -a
</syntaxhighlight>

Aquí veremos en el listado de procesos que hay en ejecución.

Ahora vamos a salirnos del contenedor, escribiendo 'exit' o 'CTRL + D', y
comprobemos el estado del contenedor:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Ahora veremos que el contenedor se sigue ejecutando, no como en el paso anterior.

= Paso 10: Persistencia en contenedores =

Vamos a ver que los contenedores no mantienen los datos por defecto, solo nos
dan un servicio pero los datos NO son persistentes. Creemos un contenedor que
vamos a dejar ejecutándose:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_expire ubuntu bash
</syntaxhighlight>

Ahora, vamos a crear una carpeta en el contenedor y comprobar que esa carpeta
existe:

<syntaxhighlight lang="bash">
docker exec to_expire mkdir test
docker exec to_expire ls
</syntaxhighlight>

Veremos que la carpeta existe, pero, ¿qué ocurre si eliminamos el contedor y
volvemos a crear uno?

<syntaxhighlight lang="bash">
docker container stop to_expire
docker container rm to_expire
docker run -d -ti --name to_expire ubuntu bash
docker exec to_expire ls
</syntaxhighlight>

Podemos comprobar que la carpeta creada anteriormente, no existe si el
contenedor termina. Si quisíeramos mantener una persistencia de datos, tenemos
varias opciones:

== Paso 10.1: Mantener la persistencia cambiando la imagen base ==

Repetimos los pasos anteriores, pero antes de parar el contenedor, vamos a
guardar el estado del contener en la imagen:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_save ubuntu bash
docker exec to_save mkdir test
docker commit to_save ubuntu
docker stop to_save
</syntaxhighlight>

Ahora, vamos a para el contenedor y ejecutar uno nuevo para probar que los datos
han persistido:

<syntaxhighlight lang="bash">
docker run -d -ti --name to_save_v2 ubuntu:con_directorio_test bash
docker exec to_save_v2 ls
</syntaxhighlight>

Esto crea una imagen ubuntu con la etiqueta "con_directorio_test".

== Paso 10.2: Mantener la persistencia creando volúmenes ==

La otra opción para mantener los datos es montar un volumen al ejecutar el
contenedor. Primero crearemos una carpeta que hará de volumen en nuestra
máquina, que será la que luego montemos para docker:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/volumen
</syntaxhighlight>

Ahora vamos a montar la carpeta al ejecutar el contenedor, lo hacemos con la
opción -v, la cual tiene 3 campos separados por ':':

# El volumen en nuestra máquina
# Donde se montará el volumen dentro del contenedor
# Opciones de mmontaje, por ejemplo rw (read and write) o ro (read only)

<syntaxhighlight lang="bash">
docker run --rm -ti -v /home/ubuntu/volumen:/volumen:rw ubuntu bash
mkdir /volumen/test
touch /volumen/test/file
exit
</syntaxhighlight>

Una vez nos salgamos del contenedor, podemos ver que en nuestra máquina están
los datos:

<syntaxhighlight lang="bash">
ls /home/ubuntu/volumen/
ls /home/ubuntu/volumen/test
</syntaxhighlight>

La próxima vez que ejecutemos un contenedor, si montamos ese volumen, los datos
estarán ahí, además esta forma tiene el beneficio de compartir datos entre
nuestra máquina y el contenedor de forma sencilla.

= Paso 11: Crear nuestra propia imagen docker =

Para crear una imagen de un contenedor con una aplicación de Python hug, creamos en primer lugar la carpeta que contendrá los ficheros que nos permiten crear la imagen.

<syntaxhighlight lang="bash">
mkdir miapp
cd miapp
</syntaxhighlight>

Definimos un fichero ''Dockerfile'' para definir la imagen:

<syntaxhighlight lang="bash">
FROM python:alpine

ENV USERNAME="username"
RUN mkdir /app
RUN pip install hug
COPY endpoint.py /app
WORKDIR /app
CMD hug -f endpoint.py
</syntaxhighlight>

Alternativamente, puedes crear un [[Creando imagen propia usando Ubuntu de base|Dockerfile empleando la imagen de Ubuntu]] como base en lugar de Alpine.

Y añadimos el fichero ''endpoint.py'' que emplea el framework Python hug con el contenido siguiente:

<syntaxhighlight lang="bash">
import hug

@hug.get('/welcome')
def welcome(username="unknown"):
""" Say welcome to username """
return "Welcome " + username
</syntaxhighlight>

Este fichero es un ejemplo de uso de Python hug. Si hacemos una petición a /welcome?username="LSO", esto nos devolverá el mensaje "Welcome LSO".

Una vez tengamos los dos ficheros creados en nuestra máquina virtual, podemos construir nuestra imagen:

<syntaxhighlight lang="bash">
docker build -t app:v1 -f Dockerfile .
</syntaxhighlight>

Vamos a explicar para que sirve cada línea:

* FROM: servirá para basarnos en una imagen existente, en este caso, una imagen de python alpine, que contiene python y no ocupa mucho espacio
* ENV: para crear variables de entorno
* RUN: para ejecutar comandos, ya sea para crear una carpeta, instalar dependencias o cualquier otra opción que necesitemos
* COPY: para copiar datos desde nuestra máquina a la imagen
* WORKDIR: para cambiar el directorio de trabajo
* CMD: este comando será ejecutado por defecto al iniciar un contenedor a partir de esta imagen

Esto construirá una imagen docker basada en python:alpine, en la cual hemos
guardado nuestra pequeña aplicación y se va a ejecutar cuando ejecutemos un
contenedor basado en esa imagen. Para comprobar que la imagen se ha creado
correctamente, listamos las imagenes, y debería de aparecernos una imagen con
nombre 'app' y tag 'v1':

<syntaxhighlight lang="bash">
docker images
</syntaxhighlight>

Ahora vamos a crear un contenedor de nuestra imagen, y vamos a añadir una nueva
opción, -p 8001:8000. Esta opción hará que el puerto interno 8000 del contenedor
sea expuesto en el puerto 8001 de nuestra máquina:

<syntaxhighlight lang="bash">
docker run --name my-app --rm -d -p 8001:8000 app:v1
</syntaxhighlight>

Ahora vamos a probar que funciona nuestra imagen y nuestro código. En nuestra
máquina haremos:

<syntaxhighlight lang="bash">
curl -X GET http://localhost:8001/welcome?username=LSO
</syntaxhighlight>

Comprobaremos que la salida del comando curl, es "Welcome LSO".

Antes de terminar, vamos a comprobar otro pequeño detalle que añadimos en
nuestra imagen, la variable de entorno USERNAME, vamos a comprobar que funciona:

<syntaxhighlight lang="bash">
docker exec -ti my-app ash
echo $USERNAME
</syntaxhighlight>

Funciona correctamente, pero al ejecutar el contenedor, podemos cambiar esta
variable de entorno como vimos en uno de los pasos anteriores:

<syntaxhighlight lang="bash">
docker run --rm -ti -e USERNAME=me app:v1 ash
echo $USERNAME
</syntaxhighlight>

Esto nos servirá para tener opciones por defecto y que el usuario pueda
cambiarlo a su antojo, como por ejemplo contraseñas u otros detalles.

= Paso 12: Eliminar imágenes =

Veremos que después de todas las pruebas que hemos estado haciendo, tenemos
muchas imágenes, y algunas de las cuales no nos servirán o no las utilizaremos,
así que podemos borrarlas para ahorrar espacio.

Al igual que con los contenedores, tenemos una opción para borrar imágenes que
no se utilicen:

<syntaxhighlight lang="bash">
docker image prune
</syntaxhighlight>

Esto borrará imágenes intermedias que se utilizan a veces para construir
nuestras imágenes o imágenes que hemos intentado construir y nos han fallado.

La otra opción para borrar imágenes una a una, sería utilizando el comando
docker rmi y utilizar el nombre de la imagen o el id. Si esta es la salida de
'docker images':

<syntaxhighlight lang="bash">
REPOSITORY TAG IMAGE ID CREATED SIZE
app v1 18609c517d32 14 minutes ago 109MB
python alpine 39fb80313465 23 hours ago 98.7MB
debian latest 85c4fd36a543 13 days ago 114MB
hello-world latest fce289e99eb9 7 months ago 1.84kB
hello-world linux fce289e99eb9 7 months ago 1.84kB
</syntaxhighlight>

Podemos eliminar las imágenes de hello-world:

<syntaxhighlight lang="bash">
docker rmi hello-world
</syntaxhighlight>

ó

<syntaxhighlight lang="bash">
docker rmi fce289e99eb9
</syntaxhighlight>

= Paso 13: Varios docker a la vez (docker-compose) =

Antes de comenzar, vamos a parar todos los contenedores que tengamos abiertos,
para dejar el entorno de docker limpio, que nos vendrá bien para esta parte.

Cuando queremos ejecutar varios contenedores a la vez y que estén conectados
entre ellos fácilmente, utilizaremos docker-compose, donde con un fichero de
configuración simple en yaml, tendremos toda la configuración de lo que vamos a
ejecutar.

Primero vamos a instalar docker-compose:

<syntaxhighlight lang="bash">
sudo apt install docker-compose
</syntaxhighlight>

Ahora veamos un pequeño ejemplo donde explicaremos todos los detalles para crear
un docker-compose, en este caso, el nombre por defecto de los ficheros suele ser
docker-compose.yml, y el contenido será similar a:

<syntaxhighlight lang="bash">
version: '3'

services:
web:
container_name: web
restart: always
build:
context: .
ports:
- "8000:8000"
volumes:
- /home/ubuntu/volume:/volumen:rw
environment:
USERNAME: test
web2:
container_name: web2
build:
dockerfile: Dockerfile
context: .
depends_on:
- web
command: touch web2
web3:
container_name: web3
restart: on-failure
image: pstauffer/curl
depends_on:
- web
command: curl -X GET web:8000/welcome?username=web3
</syntaxhighlight>

En el docker-compose definimos diferentes servicios a ejecutar, en nuestro caso
hemos iniciado tres servicios diferentes, web, web2 y web3:

El primer servicio, web:

* container_name: para darle un nombre por defecto al contenedor cuando se cree
* restart: pueden ser:
** "no": si la máquina termina, no se vuelve a iniciar (opción por defecto)
** always: siempre que el contenedor termine, intenta iniciarse de nuevo
** on-failure: solo intenta reiniciarse si el contenedor termina con fallo
** unless-stopped: solo reinicia el contenedor si el usuario es el que lo termina
* Utilizará el fichero Dockerfile creado en el paso 11 para generar la imagen a usar.
* Expondrá el puerto 8000 del contenedor en el 8000 de nuestra máquina
* Montará un volumen, se hace de forma similar a la línea de comandos
* Creará una variable de entorno

El segundo servicio, web2:

* Utilizará el fichero Dockerfile también, la diferencia entre este y el primer servicio, es que si el nombre del Dockerfile cambia, tendremos que hacerlo de esta segunda forma, la primera por defecto solo buscará el fichero Dockerfile
* depends_on hará que para ejecutar este servicio, su dependencia tenga ya que estar iniciada
* Ejecutaremos un comando el cual sustituirá al comando de la imagen

El tercer servicio, web3:

* Utilizará la imagen ostauffer/curl que es un imagen mínima que contiene el comando curl
* restart: en este caso, hasta que el comando no se ejecute correctamente, se seguirá reiniciando el contenedor
* depends_on igual que el servicio 2, dependerá del servicio 1
* Ejecutaremos un comando para llamar desde el servicio 3 al servicio 1

== Paso 13.1: Construir docker-compose ==

En el caso de existir servicios que tengan Dockerfiles, esto hará que se construyan previamente, como hacer un docker build de cada uno de los servicios que contenga un Dockerfile:

<syntaxhighlight lang="bash">
docker-compose build
</syntaxhighlight>

Con esto se generarán las imágenes necesarias para ejecutar todos los servicios.

== Paso 13.2: Iniciar docker-compose ==

Para iniciar todos los servicios, ejecutaremos:

<syntaxhighlight lang="bash">
docker-compose up -d
</syntaxhighlight>

Después de esto podremos ver el logs de todos los servicios:

<syntaxhighlight lang="bash">
docker-compose logs -f
</syntaxhighlight>

Aquí veremos que el servicio 3 ha conseguido llamar correctamente al servicio 1.

Ahora veremos como docker-compose ha creado los contenedores:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

La salida será similar a la siguiente:

<syntaxhighlight lang="bash">
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
219a4118244c pstauffer/curl "curl -X GET web:800…" 6 seconds ago Exited (0) 3 seconds ago web3
c97e894cb3ae ubuntu_web2 "touch web2" 6 seconds ago Exited (0) 4 seconds ago web2
f35d034204fc ubuntu_web "/bin/sh -c 'hug -f …" 6 seconds ago Up 5 seconds 0.0.0.0:8000->8000/tcp web
</syntaxhighlight>

Aquí vemos varios detalles:

* El nombre que le hemos dado en el docker-compose ha funcionado correctamente
* Vemos que los comandos son los correctos también
* web2 está parado por que la política de reinicio es apagar cuando se termine de ejecutar un comando
* web 3 está parado por que el comando ha terminado con un salida correcta

Vamos a comprobar ahora que en el servicio web está todo correcto:

<syntaxhighlight lang="bash">
docker exec -ti web ash
echo $USERNAME
ls /volumen
exit
</syntaxhighlight>

Podemos comprobar que tanto cambiar la variable de entorno como crear un
volumen ha funcionado correctamente.

== Paso 13.3: Parar docker-compose ==

Para parar todos los servicios:

<syntaxhighlight lang="bash">
docker-compose down
</syntaxhighlight>

Comprobamos:

<syntaxhighlight lang="bash">
docker ps -a
</syntaxhighlight>

Vemos que han desaparecido todos los contenedores.

= Paso 14: Ejercicios =

* Construya una imagen ''httpd-hola-mundo'' a partir de la imagen ''httpd''.

<syntaxhighlight lang="bash">
docker pull httpd
</syntaxhighlight>

Edita el fichero Dockerfile:

<syntaxhighlight lang="bash">
nano Dockerfile
</syntaxhighlight>

Añada este contenido:

<syntaxhighlight lang="bash">
FROM httpd

COPY index.html htdocs/index.html
</syntaxhighlight>

Edita el fichero index.html:

<syntaxhighlight lang="bash">
nano index.html
</syntaxhighlight>

Añada este contenido:

<syntaxhighlight lang="bash">
<html>hola mundo</html>
</syntaxhighlight>

Construye la imagen:

<syntaxhighlight lang="bash">
docker build -t mihttpd -f Dockerfile .
</syntaxhighlight>

Ahora vamos a crear un contenedor de nuestra imagen:

<syntaxhighlight lang="bash">
sudo docker run --name mihttpd -d -p 8080:80 mihttpd
</syntaxhighlight>

Ahora vamos a probar que funciona nuestra imagen y nuestro código:
<syntaxhighlight lang="bash">
curl -X GET http://localhost:8080
</syntaxhighlight>

Tiene que salir por pantalla esto:
<syntaxhighlight lang="bash">
<html>hola mundo</html>
</syntaxhighlight>

Sistemas de archivos

2019-12-13T18:28:42Z

Artrodase: /* Paso 5: Montar y desmontar particiones en Linux */

= Paso 1: Añadir un disco a la máquina virtual =

Vamos a usar cualquier máquina virtual de ubuntu cloud que hayamos usado
previamente y vamos a añadir dos discos virtuales para hacer pruebas.

# Abrimos la ventana de la máquina virtual a usar
# Nos movemos a Vista -> Detalles, y le damos al botón de 'Agregar hardware'
# Seleccionamos Almacenamiento, le damos un tamaño de 5GB y en el tipo de dispositivo seleccionamos 'dispositivo de disco'. Con estas opciones, pulsamos Finalizar., y ya tendremos nuestro disco creado.
# Repetir el paso anterior y crear otro disco de 4GB

= Paso 2: Ver discos en Linux =

Volvamos a la vista consola (Vista -> Consola) y arranquemos la máquina (Máquina virtual -> Ejecutar).

Para comprobar los discos añadidos en el paso 1 vamos a utilizar el comando lsblk, el cual nos mostrará una salida similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Aqui vemos que tenemos 3 discos:

* vda: el actual de ubuntu que añadimos al crear la máquina
* vdb: el disco que añadimos en el paso 1 de 5GB
* vdc: el disco que añadimos en el paso 1 de 4GB

También vemos que el disco vda tiene 3 particiones: vda1, vda14 y vda15

= Paso 3: Creación de particiones en Linux =

Vamos a utilizar ahora nuestro disco añadido de 5GB, en el paso anterior
deberiamos de haber identificado cual es, en mi caso /dev/vdb, aseguraros cual
es el vuestro y comenzaremos a particionar el disco:

<syntaxhighlight lang="bash">
sudo fdisk /dev/vdb
</syntaxhighlight>

Si el disco es nuevo y no ha hecho nada previamente, normalmente viene sin tabla
de particiones, así que fdisk se encarga de crear una, seguramente veamos ese
mensaje cuando hayamos ejecutado el comando anterior.
La tabla de particiones es una pequeña parte del disco que se utiliza para
alamacenar la información de las particiones, el formato y si una partición es
ejecutable o no.

Una vez hecho esto, veremos que estamos dentro de fdisk (software para
particionar un disco), y veremos que este tiene su propia linea de comando.

Ahora veremos la ayuda de fdisk y crearemos una partición de prueba de 3GB

# Introducir la letra 'm' y pulsar Intro, así obtendremos el listado de comandos posibles de fdisk.
# Introducir 'n' y pulsar Intro para crear una nueva partición. Nos preguntará varios detalles:
## Tipo de partición: pulsamos Intro y se asignará primaria por defecto.
## Número de partición: pulsamos Intro y se asignará 1 por defecto.
## Primer sector: pulsamos Intro para que se asigne por defecto.
## Último sector: vamos a crear una partición de 3GB, así que escribimos ''+3G'' y pulsamos Intro
# Ya está creada nuestra primera partición, aunque los cambios todavía no se han escrito en disco, para ello, necesitaremos aplicar estos cambios, y lo hacemos con el comando 'w' y pulsando Intro.
# Ahora si, ya tenemos nuestra partición creada. Vamos a comprobar que el cambio está hecho, usando lsblk por ejemplo, deberíamos de obtener algo similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
└─vdb1 252:17 0 3G 0 part
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Vamos ahora a crear en el disco de 4GB (vdc en mi caso) dos particiones de 2GB cada una, y la partición de 3GB creada anteriormente, vamos a borrarla:

# sudo fdisk /dev/vdc
# comando 'n' e Intro
# Todos los datos por defecto, excepto el último sector, donde pondremos '+2G'
# Una vez creada la primera partición, antes de escribir a disco, vamos a crear la segunda partición, repetimos los pasos anteriores. Vamos a tener un problema y cuando lleguemos al último paso, nos dirá que 2GB no es posible. Si tenemos un disco de 4GB, ¿Por qué no nos permite crear dos particiones de 2GB? Exacto, por la tabla de particiones. Lo que haremos en el último paso será dejar el valor por defecto, que será todo el disco sobrante.
# Vamos a comprobar antes de escribir los cambios, que todo está bien, comando 'p' e Intro debería de mostrarnos una salida similar a:

<syntaxhighlight lang="bash">
Device Boot Start End Sectors Size Id Type
/dev/vdc1 2048 4196351 4194304 2G 83 Linux
/dev/vdc2 4196352 4196351 4194304 2G 83 Linux
</syntaxhighlight>

# Si todo está correcto, pulsamos 'w' e Intro y aplicamos los cambios
# Ahora entraremos con el disco /dev/vdb para eliminar la partición: sudo fdisk /dev/vdb
# Ahora vamos a eliminar la particion, pulsamos 'd' e Intro. Como solo tenemos una partición, nos la borra directamente, en caso de tener más de una, nos preguntaría cual queremos borrar.
# Aplicamos los cambios: 'w' e Intro
# Comprobamos que todo ha quedado a nuestro gusto con el comando lsblk

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
├─vdc1 252:33 0 2G 0 part
└─vdc2 252:34 0 2G 0 part
</syntaxhighlight>

= Paso 4: Formatear partición: crear un sistema de archivos =

Hasta ahora solo hemos definido en la tabla de particiones donde comienza y
acaba cada partición, pero no podremos utilizarla hasta que no creemos un
sistema de archivos en la partición. Para crear un sistema de archivos
utilizaremos el comando 'mkfs', y tendremos varias opciones a la hora de crear
uno: ext2, ext3, ext4, btrfs, fat, ntfs, etc...

Nosotros creamos un sistema ext4 para /dev/vdc1 y uno fat para /dev/vdc2:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/vdc1
sudo mkfs -t fat /dev/vdc2
</syntaxhighlight>

Una vez hecho esto, vamos a comprobar que se han aplicado bien los cambios:

<syntaxhighlight lang="bash">
sudo file -s /dev/vdc1
sudo file -s /dev/vdc2
</syntaxhighlight>

En la salida deberíamos de obtener que tenemos un sistema de ficheros ext4 y
otro FAT.

= Paso 5: Montar y desmontar particiones en Linux =

Tras haber creado en los pasos anteriores unas particiones y formatearlas, vamos
a pasar ahora a montarlas para poderles dar uso. En linux montar una partición
significará que asignaremos una carpeta del sistema a una partición, y en ella
estará todo el contenido del disco.

== Mount y umount ==

Empezaremos utilizando los comandos mount y umount para montar y desmontar
particiones. Vamos a montar las particiones /dev/vdc1 y /dev/vdc2, la primera la
montaremos en /home/ubuntu/part1 y la segunda en /home/ubuntu/part2:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part1 # Creamos la carpeta donde vamos a montar la partición
sudo mount /dev/vdc1 /home/ubuntu/part1 # montamos la partición
</syntaxhighlight>

Lo mismo con /dev/vdc2

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part2
sudo mount /dev/vdc2 /home/ubuntu/part2
</syntaxhighlight>

Vamos a ver el contenido de las particiones montadas:

<syntaxhighlight lang="bash">
ls /home/ubuntu/part1
ls /home/ubuntu/part2
</syntaxhighlight>

Veremos que tenemos una carpeta lost+found en el sistema ext4, la cual se
utiliza para los errores en el sistema de archivos, cuando hay un error y
encontramos un fichero sin referencia, este se añadiría dentro de esta carpeta,
y existiría la posibilidad de recuperarlo.

Ahora vamos a crear un nuevo fichero dentro de nuestra partición /dev/vdc1, la
vamos a desmontar, y vamos a montarla en otro directorio diferente:

<syntaxhighlight lang="bash">
sudo touch /home/ubuntu/part1/nuevoFichero # tenemos que crearlo con sudo porque no tenemos permisos, luego veremos esto
sudo umount /dev/vdc1
ls /home/ubuntu/part1 # el fichero ya no está, la partición fue desmontada
mkdir /home/ubuntu/part3
sudo mount /dev/vdc1 /home/ubuntu/part3
ls /home/ubuntu/part3
</syntaxhighlight>

Comprobaremos que el fichero creado en /home/ubuntu/part1 lo tenemos ahora en
/home/ubuntu/part3, ya que realmente, cuando lo guardamos, estaba en la
partición que montamos.

También podemos ver que utilizando el comando lsblk, podremos observar donde
está montada la partición.

== Montaje automático al iniciar el sistema ==

Ahora veremos como automatizar el proceso de montaje cada vez que se inicia el
sistema, ya que sería tedioso tener que montar todos las particiones cada vez
que apagamos y encendemos nuestra máquina.

El proceso de automatizado suele hacerse dentro del fichero /etc/fstab, veamos
su contenido:

<syntaxhighlight lang="bash">
cat /etc/fstab
</syntaxhighlight>

Cada fila contiene un montaje de una partición, la cual contiene:

* Identificación de la partición: en este caso se está utilizando una etiqueta de
la partición, pero podemos utilizar cualquier cosa que identifique al
dispositivo, como el uuid o la localización (/dev/vdc1)
* Punto de montaje: donde se montará el dispositivo
* Sistema de archivos: ext4, fat32, reiserfs
* Opciones: aquí pondremos las diferentes opciones de montaje, como por ejemplo
montar para solo lectura, dar permisos a un usuario para utilizar la
partición, etc. Hay que tener en cuenta que cada sistema tiene sus opciones.
* backup: si está a cero, no haremos backup
* chequeo: si está a cero no se hace chequeo al iniciar

Vamos a añadir unas líneas para montar automáticamente las particiones al
iniciar:

Utilizando el editor que prefieras, añadir lo siguiente en el fichero
/etc/fstab. Importante hacerlo con sudo para que nos permita escribir en el
fichero:

<syntaxhighlight lang="bash">
/dev/vdc1 /home/ubuntu/part1 ext4 rw,user,exec 0 0
/dev/vdc2 /home/ubuntu/part2 vfat umask=000 0 0
</syntaxhighlight>

Una vez guardado los cambios, vamos a aplicarlos sin reiniciar, para comprobar
que funciona correctamente:

<syntaxhighlight lang="bash">
mount -a # aplica los cambios de fstab sin necesidad de reiniciar
lsblk # comprobar que está bien montado
</syntaxhighlight>

Ahora vamos a comprobar si nuestro usuario tiene permisos para escribir:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
touch /home/ubuntu/part2
</syntaxhighlight>

En el primero no nos dejará y en el segundo no tendremos problemas. Esto
funciona así porque los sistemas ext4, para poder tener permisos de escritura,
tenemos que darlo sobre el sistema de ficheros, mientras que el sistema fat,
tiene la opción umask que ya hace el trabajo. Para tener permisos de escritura
con nuestro usuario en la partición, tendremos que darle permiso a la partición
para poder escribir en ella, por ejemplo, utilizando el comando chown:

<syntaxhighlight lang="bash">
sudo chown ubuntu /home/ubuntu/part1
</syntaxhighlight>

Si probamos ahora, podremos escribir en la partición de ext4, y al haber dado
permisos, ya nos funcionará siempre:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
</syntaxhighlight>

Ahora, vamos a desmontar todo y a reiniciar la máquina para comprobar que está todo funciona.

<syntaxhighlight lang="bash">
sudo umount /dev/vdc1
sudo umount /home/ubuntu/part2 # Es otra forma de desmontar, dando el punto de montaje
lsblk # comprobamos que no estén montadas
</syntaxhighlight>

Reiniciamos la máquina (Máquina virtual -> Apagar -> Reiniciar) y comprobamos:

<syntaxhighlight lang="bash">
lsblk
</syntaxhighlight>

= Paso 6: Creación de sistemas de ficheros de red NFS =

En este paso, vamos a crear un sistema de ficheros de red compartido a través de NFS.
Para ello vamos a necesitar crear un servidor donde iniciemos este sistema al que se conectarán los clientes.

== Paso 6.1: Instalación y configuración del servidor de NFS ==

Para configurar el servidor, necesitaremos abrir una de las máquinas virtuales
creadas anteriormente e instalar la herramienta necesaria:

<syntaxhighlight lang="bash">
sudo apt install nfs-kernel-server
</syntaxhighlight>

Una vez hecho esto, vamos a crear un directorio el cual será el que
compartiremos, por ejemplo:

<syntaxhighlight lang="bash">
sudo mkdir /home/shared
</syntaxhighlight>

Ahora vamos a editar el servidor nfs, para ello, tendremos que editar el fichero
/etc/exports, pero antes, veremos cual es nuestra IP, que nos hará falta:

<syntaxhighlight lang="bash">
ip address
</syntaxhighlight>

La salida de este comando será similar a la siguiente:

<syntaxhighlight lang="bash">
enp1s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 192.168.0.167 netmask 255.255.255.0 broadcast 192.168.0.255
inet6 fe80::ea6a:64ff:fe66:66a0 prefixlen 64 scopeid 0x20<link>
ether e8:6a:64:66:66:a0 txqueuelen 1000 (Ethernet)
RX packets 3821 bytes 2152349 (2.0 MiB)
RX errors 0 dropped 268 overruns 0 frame 0
TX packets 3386 bytes 266855 (260.6 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 16 memory 0xa4300000-a4320000

lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1000 (Local Loopback)
RX packets 220506 bytes 16017419 (15.2 MiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 220506 bytes 16017419 (15.2 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
</syntaxhighlight>

Nos fijamos donde pone inet, y miramos la red que NO sea 'lo', en este caso,
la IP buscada sería 192.168.0.167. Ahora si, vamos a editar el /etc/exports:

<syntaxhighlight lang="bash">
/home/shared 192.168.0.*(rw,sync,subtree_check)
</syntaxhighlight>

Explicamos los parámetros:

# Carpeta a compartir
# Le damos la IP con un * al final para poder permitir a todas las redes poder
acceder, desde la 192.168.0.0 a la 192.168.0.255
# Aquí tenemos muchas opciones disponibles:
## ro: solo lectura
## rw: lectura y escritura
## subtree_check: comprueba subdirectorios para compartirlos también
## sync: forzar a hacer las operaciones de forma síncrona (los datos se escriben inmediatamente en el disco del servidor NFS).

Una vez modificado el fichero, vamos a reiniciar el servicio NFS:

<syntaxhighlight lang="bash">
sudo service nfs-kernel-server restart
</syntaxhighlight>

Una vez hecho esto, nuestro servidor NFS ya está configurado.

== Paso 6.2: Instalación y configuración del cliente de NFS ==

Para acceder al sistema de ficheros NFS creado en el paso anterior, tendremos
que configurar el cliente para montar el sistema de ficheros compartido. El
cliente lo montaremos en otra máquina virtual diferente.

Creamos y abrimos esta nueva máquina e instalamos una herramienta para poder
montar el NFS en nuestra máquina:

<syntaxhighlight lang="bash">
sudo apt install nfs-common
</syntaxhighlight>

Con esto ya podremos montar en nuestro cliente el NFS. Recordemos la IP que
obtuvimos en el paso anterior cuando montamos el servidor, y hacemos lo
siguiente:

<syntaxhighlight lang="bash">
sudo mount 192.168.0.167:/home/shared /mnt
</syntaxhighlight>

Ya tenemos nuestro sistema de ficheros compartidos por red montado, vamos a
probar que todo funciona.

1. En la máquina donde instalamos el servidor de NFS, vamos a crear una carpeta
y un fichero dentro de la carpeta compartida, para ellos necesitaremos darle
permisos a nuestro usuario previamente:

<syntaxhighlight lang="bash">
sudo chown -R ubuntu /home/shared
mkdir /home/shared/carpeta
touch /home/shared/carpeta/fichero
</syntaxhighlight>

2. Vamos a comprobar en el cliente, que estos ficheros se están mostrando:

<syntaxhighlight lang="bash">
ls /mnt
ls /mnt/carpeta
</syntaxhighlight>

3. Ahora lo hacemos al contrario, escribiremos desde el cliente, y vamos a verlo en el servidor:

<syntaxhighlight lang="bash">
mkdir /mnt/carpeta2
touch /mnt/carpeta2/fichero
</syntaxhighlight>

4. Entramos en el servidor y comprobamos:

<syntaxhighlight lang="bash">
ls /home/shared
ls /home/shared/carpeta2
</syntaxhighlight>

= Paso 7: Creación de un RAID =

En este apartado vamos a configurar un RAID 1 (espejo) que nos permite aumentar la fiabilidad. La idea es que si uno de los discos del RAID deja de funcionar, los datos en el sistema de fichero siguen estando disponibles con lo que disponemos de algo de tiempo para reemplazar el disco defectuoso.

== Paso 7.1: Añadir discos a la máquina virtual ==

Como explicamos en el Paso 1, vamos a añadir a una máquina virtual 2 discos duros de 5GB cada uno.

== Paso 7.2: Instalación de la herramienta de mdadm ==

Por defecto, esta herramienta viene instalada en el ubuntu cloud server, pero en
el caso de utilizar otra distribución diferente, necesitaremos instalarla:

<syntaxhighlight lang="bash">
sudo apt install mdadm
</syntaxhighlight>

== Paso 7.3: Utilización de la herramienta de mdadm ==

Empezamos escribiendo el comando, y luego pasamos a explicar los detalles:

<syntaxhighlight lang="bash">
sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/vdb1 /dev/vdc1
</syntaxhighlight>

Explicamos los parámetros:

# --create: para crear el raid
# --verbose: nos muestra más información del proceso
# /dev/md0: El nombre del nuevo raid, normalmente se utiliza md0
# --level=1: crea un raid 1 que es el que queremos
# --raid-devices=2: cantidad de dispositivos que vamos a utilizar, 2 en nuestro caso
# /dev/vdb1: Nombre de la partición 1
# /dev/vdc1: Nombre de la partición 2

Una vez ejecutado el comando, creará el RAID 1, pasemos ahora a ver los
detalles:

<syntaxhighlight lang="bash">
sudo mdadm --detail /dev/md0
</syntaxhighlight>

Esto nos mostrará la información del RAID, lo que a nosotros nos interesa son
las últimas líneas:

<syntaxhighlight lang="bash">
Name : ubuntu:0 (local to host ubuntu)
UUID : e40ba520:5ed1bd37:5c818550:03a18368
Events : 17

Number Major Minor RaidDevice State
0 252 17 0 active sync /dev/vdb1
1 252 33 1 active sync /dev/vdc1
</syntaxhighlight>

Aqui vemos el UUID de nuestro RAID, y también veremos en las dos última líneas,
las dos particiones, las cuales están marcadas con active sync, esto quiere
decir que están activos y sincronizados. Puede que si hacemos muy rápido este
comando, muestre algo diferente porque tarda un poco en sincronizar la primera
vez, pero pronto estará.

Otra forma de ver el UUID es usando:

<syntaxhighlight lang="bash">
blkid
</syntaxhighlight>

== Paso 7.5: Guardar la configuración del RAID ==

Vamos a modificar la configuración, tendremos que editar el
fichero /etc/mdadm/mdadm.conf y debajo de la línea que pone '# definitions of
existing MD arrays', añadir lo siguiente:

<syntaxhighlight lang="bash">
ARRAY /dev/md0 UUID=e40ba520:5ed1bd37:5c818550:03a18368
</syntaxhighlight>

Recuerda que el UUID lo puedes consultar con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Busca el campo UUID.

Tras actualizar /etc/mdadm/mdadm.conf, tienes que invocar la siguiente orden:

<syntaxhighlight lang="bash">
update-initramfs -u
</syntaxhighlight>

Esto asegura que en el próximo arranque el RAID usa la unidad /dev/md0.

== Paso 7.6: Particionar y formatear el RAID ==

Como explicamos en los Pasos 2, 3 y 4, vamos a particionar el disco RAID:

<syntaxhighlight lang="bash">
lsblk # comprobamos los dicos, en mi caso sería md0
sudo fdisk /dev/md0
</syntaxhighlight>

Ahora vamos a formatear la partición:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/md0p1
</syntaxhighlight>

== Paso 7.7: Montar el RAID ==

Como previamente hemos hecho, crearemos una carpeta donde montar el RAID y lo
montaremos usando el comando mount:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/datos
sudo mount /dev/md0p1 /home/ubuntu/datos
sudo chown -R ubuntu /home/ubuntu/datos
</syntaxhighlight>

Así ya tenemos nuestro RAID montado y podemos utilizarlo, vamos a probar a
escribir en él.

<syntaxhighlight lang="bash">
touch /home/ubuntu/datos/fichero
</syntaxhighlight>

Esto está funcionando, pero como comentamos en uno de los pasos previos, el
comando mount solo montará el raid temporalmente, para automatizar este montado
al arrancar, tendremos que añadir la siguiente línea a /etc/fstab:

<syntaxhighlight lang="bash">
/dev/md0p1 /home/ubuntu/datos ext4 defaults
</syntaxhighlight>

== Paso 7.8: Comprobar tolerancia a fallos ==

Vamos a probar que sin un disco duro, todo sigue funcionando bien, ya que al
tener un RAID 1 y tener los datos en espejo, no debería de haber problemas.

La siguiente orden marca el disco /dev/sdb1 como dañado:

<syntaxhighlight lang="bash">
mdadm --fail /dev/md0 /dev/sdb1
</syntaxhighlight>

Podemos ver con la siguiente orden que el disco aparece como ''faulty'':

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Sin embargo, podemos ver que el sistema de ficheros sigue montado y el contenido sigue estando disponible.

<syntaxhighlight lang="bash">
ls /home/ubuntu/datos/
</syntaxhighlight>

Podéis retirar definitivamente el disco defectuoso con la orden:

<syntaxhighlight lang="bash">
mdadm --remove /dev/md0 /dev/sdb1
</syntaxhighlight>

Para volver a incluirlo en el RAID:

<syntaxhighlight lang="bash">
mdadm --add /dev/md0 /dev/sdb1
</syntaxhighlight>

Podéis consultar que está sincronizando con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Que mostrará el disco /dev/sdb1 en estado ''spare rebuilding'' y mostrará el porcentaje de sincronización.

= Paso 8: Gestión volúmenes (Logic Volume Manager, LVM) =

Logic Volume Manager (LVM) es una capa de software que permite crear volúmenes lógicos y mapearlos de manera sencilla sobre dispositivos físicos.

La instalación de LVM es sencilla mediante la orden:

sudo apt-get install lvm2

La gestión de LVM se basa en tres conceptos básicos:

* Volúmenes físicos (PV): Representa una unidad de almacenamiento que aprovisiona espacio de almacenamiento para el volumen lógico que vamos a crear.
* Grupo volumen (VG): Representa un almacén de espacio para LVM. Un VG estará compuesto por varios PV, pudiendo tener tantos VG como sean necesarios.
* Volumen lógico (LV): Representan unidades lógicas creadas a partir de VG creado previamente. Se podrán crear tantos LV como sean necesarios para un VG. La creación de un LVM genera un archivo especial en /dev, con la forma /dev/nombre_del_grupo/nombre_volumne_logico. El mapeo de espacio desde un LV hasta un PV es configurable pudiendo ser: Lineal, RAID, Cache, ...

== Paso 8.1: Creación de volumen físico LVM (PV) ==

Para listar las unidades de almacenamiento disponibles en el sistema, empleamos la siguiente orden:

lsblk

En virtualbox podemos crear nuevas unidades almacenamiento y añadirlas a la máquina virtual.

Para crear un volumen físico en la unidad /dev/sdb, empleamos la orden:

pvcreate /dev/sdb

Recuerde que la unidad /dev/sdb tiene que estar en desuso.

Para ver los volúmenes físicos existentes, empleamos la orden:

pvscan

Para obtener más información:

pvdisplay

Para eliminar un PV, por ejemplo /dev/sdb:

pvremove /dev/sdb

== Paso 8.2: Creación de grupo de volumenes LVM (VG) ==

Para crear un grupo, empleamos el comando vgcreate:

vgcreate vg_prueba /dev/sdb /dev/sdc

Esto añade al grupo 'vg_prueba' los volúmenes sdb y sdc, haciendo que la capacidad del grupo sea la capacidad agregada de los PV añadidos.

Para eliminar un grupo vgremove:

vgremove vg_prueba

Para extender un grupo creado (por ejemplo, vg_prueba) con más PV (por ejemplo /dev/sde) usamos el comando vgextend:

vgextend vg_prueba /dev/sde

Para reducir la capacidad de un grupo creado (por ejemplo, vg_prueba) basta con usar el comando vgreduce indicando la unidad (PV) a quitar, por ejemplo /dev/sde:

vgreduce vg_prueba /dev/sde

Para mostrar todos los grupos de volumenes existentes

vgscan

== Paso 8.3: Creación de volumen lógico (LV) ==

Para crear un volúmen lógico, empleamos la orden:

lvcreate --name volumen1 --size 100MB vg_prueba

A partir de este momento hay una unidad que se presenta como ''/dev/mapper/vg_prueba-volumen1''.

Podemos ahora formatear el volumen lógico:

mkfs.ext4 /dev/vg_prueba/volumen1

y montarlo para almacenar información:

mount /dev/vg_prueba/volumen1 /mnt

Puedes extender un volumen lógico en 1 Gbyte de más:

lvextend --size +1GB /dev/vg_prueba/volumen1

Justo después tienes que redimensionar el sistema de ficheros:

resize2fs /dev/vg_prueba/volumen1

Puedes comprobar con:

df -h

que el sistema de ficheros en ''volumen1'' ocupa ahora todo el volumen lógico.

Reducir el tamaño de un volumen lógico es un poco más complicado, ¡podrían perder datos si no se realiza correctamente!

Primero, desmontamos el volumen:

umount /mnt/volumen1

reducir el tamaño del sistema de ficheros, comprobamos la integridad del sistema de ficheros:

e2fsck -f /dev/vg_prueba/volumen1

Y lo redimensionamos (reducimos de tamaño):

resize2fs /dev/vg_prueba/volumen1 500M

Ahora ya, por último lugar, puedes reducir el tamaño del volumen:

lvreduce --size 500M /dev/vg_prueba/volumen1

Para comprobar que hay ido todo bien, vuelve a redimensionar el sistema de ficheros para que ocupe todo el espacio disponible.

resize2fs /dev/vg_prueba/volumen1

Y puedes volver a montar el sistema de ficheros:

mount /dev/vg_prueba/volumen1 /mnt/volumen1

con

df -h

para comprar el nuevo tamaño disponible de sólo 500 MBytes.

Sistemas de archivos

2019-12-11T00:12:54Z

Artrodase: /* Paso 6.1: Instalación y configuración del servidor de NFS */

= Paso 1: Añadir un disco a la máquina virtual =

Vamos a usar cualquier máquina virtual de ubuntu cloud que hayamos usado
previamente y vamos a añadir dos discos virtuales para hacer pruebas.

# Abrimos la ventana de la máquina virtual a usar
# Nos movemos a Vista -> Detalles, y le damos al botón de 'Agregar hardware'
# Seleccionamos Almacenamiento, le damos un tamaño de 5GB y en el tipo de dispositivo seleccionamos 'dispositivo de disco'. Con estas opciones, pulsamos Finalizar., y ya tendremos nuestro disco creado.
# Repetir el paso anterior y crear otro disco de 4GB

= Paso 2: Ver discos en Linux =

Volvamos a la vista consola (Vista -> Consola) y arranquemos la máquina (Máquina virtual -> Ejecutar).

Para comprobar los discos añadidos en el paso 1 vamos a utilizar el comando lsblk, el cual nos mostrará una salida similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Aqui vemos que tenemos 3 discos:

* vda: el actual de ubuntu que añadimos al crear la máquina
* vdb: el disco que añadimos en el paso 1 de 5GB
* vdc: el disco que añadimos en el paso 1 de 4GB

También vemos que el disco vda tiene 3 particiones: vda1, vda14 y vda15

= Paso 3: Creación de particiones en Linux =

Vamos a utilizar ahora nuestro disco añadido de 5GB, en el paso anterior
deberiamos de haber identificado cual es, en mi caso /dev/vdb, aseguraros cual
es el vuestro y comenzaremos a particionar el disco:

<syntaxhighlight lang="bash">
sudo fdisk /dev/vdb
</syntaxhighlight>

Si el disco es nuevo y no ha hecho nada previamente, normalmente viene sin tabla
de particiones, así que fdisk se encarga de crear una, seguramente veamos ese
mensaje cuando hayamos ejecutado el comando anterior.
La tabla de particiones es una pequeña parte del disco que se utiliza para
alamacenar la información de las particiones, el formato y si una partición es
ejecutable o no.

Una vez hecho esto, veremos que estamos dentro de fdisk (software para
particionar un disco), y veremos que este tiene su propia linea de comando.

Ahora veremos la ayuda de fdisk y crearemos una partición de prueba de 3GB

# Introducir la letra 'm' y pulsar Intro, así obtendremos el listado de comandos posibles de fdisk.
# Introducir 'n' y pulsar Intro para crear una nueva partición. Nos preguntará varios detalles:
## Tipo de partición: pulsamos Intro y se asignará primaria por defecto.
## Número de partición: pulsamos Intro y se asignará 1 por defecto.
## Primer sector: pulsamos Intro para que se asigne por defecto.
## Último sector: vamos a crear una partición de 3GB, así que escribimos ''+3G'' y pulsamos Intro
# Ya está creada nuestra primera partición, aunque los cambios todavía no se han escrito en disco, para ello, necesitaremos aplicar estos cambios, y lo hacemos con el comando 'w' y pulsando Intro.
# Ahora si, ya tenemos nuestra partición creada. Vamos a comprobar que el cambio está hecho, usando lsblk por ejemplo, deberíamos de obtener algo similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
└─vdb1 252:17 0 3G 0 part
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Vamos ahora a crear en el disco de 4GB (vdc en mi caso) dos particiones de 2GB cada una, y la partición de 3GB creada anteriormente, vamos a borrarla:

# sudo fdisk /dev/vdc
# comando 'n' e Intro
# Todos los datos por defecto, excepto el último sector, donde pondremos '+2G'
# Una vez creada la primera partición, antes de escribir a disco, vamos a crear la segunda partición, repetimos los pasos anteriores. Vamos a tener un problema y cuando lleguemos al último paso, nos dirá que 2GB no es posible. Si tenemos un disco de 4GB, ¿Por qué no nos permite crear dos particiones de 2GB? Exacto, por la tabla de particiones. Lo que haremos en el último paso será dejar el valor por defecto, que será todo el disco sobrante.
# Vamos a comprobar antes de escribir los cambios, que todo está bien, comando 'p' e Intro debería de mostrarnos una salida similar a:

<syntaxhighlight lang="bash">
Device Boot Start End Sectors Size Id Type
/dev/vdc1 2048 4196351 4194304 2G 83 Linux
/dev/vdc2 4196352 4196351 4194304 2G 83 Linux
</syntaxhighlight>

# Si todo está correcto, pulsamos 'w' e Intro y aplicamos los cambios
# Ahora entraremos con el disco /dev/vdb para eliminar la partición: sudo fdisk /dev/vdb
# Ahora vamos a eliminar la particion, pulsamos 'd' e Intro. Como solo tenemos una partición, nos la borra directamente, en caso de tener más de una, nos preguntaría cual queremos borrar.
# Aplicamos los cambios: 'w' e Intro
# Comprobamos que todo ha quedado a nuestro gusto con el comando lsblk

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
├─vdc1 252:33 0 2G 0 part
└─vdc2 252:34 0 2G 0 part
</syntaxhighlight>

= Paso 4: Formatear partición: crear un sistema de archivos =

Hasta ahora solo hemos definido en la tabla de particiones donde comienza y
acaba cada partición, pero no podremos utilizarla hasta que no creemos un
sistema de archivos en la partición. Para crear un sistema de archivos
utilizaremos el comando 'mkfs', y tendremos varias opciones a la hora de crear
uno: ext2, ext3, ext4, btrfs, fat, ntfs, etc...

Nosotros creamos un sistema ext4 para /dev/vdc1 y uno fat para /dev/vdc2:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/vdc1
sudo mkfs -t fat /dev/vdc2
</syntaxhighlight>

Una vez hecho esto, vamos a comprobar que se han aplicado bien los cambios:

<syntaxhighlight lang="bash">
sudo file -s /dev/vdc1
sudo file -s /dev/vdc2
</syntaxhighlight>

En la salida deberíamos de obtener que tenemos un sistema de ficheros ext4 y
otro FAT.

= Paso 5: Montar y desmontar particiones en Linux =

Tras haber creado en los pasos anteriores unas particiones y formatearlas, vamos
a pasar ahora a montarlas para poderles dar uso. En linux montar una partición
significará que asignaremos una carpeta del sistema a una partición, y en ella
estará todo el contenido del disco.

== Mount y umount ==

Empezaremos utilizando los comandos mount y umount para montar y desmontar
particiones. Vamos a montar las particiones /dev/vdc1 y /dev/vdc2, la primera la
montaremos en /home/ubuntu/part1 y la segunda en /home/ubuntu/part2:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part1 # Creamos la carpeta donde vamos a montar la partición
sudo mount /dev/vdc1 /home/ubuntu/part1 # montamos la partición
</syntaxhighlight>

Lo mismo con /dev/vdc2

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part2
sudo mount /dev/vdc2 /home/ubuntu/part2
</syntaxhighlight>

Vamos a ver el contenido de las particiones montadas:

<syntaxhighlight lang="bash">
ls /home/ubuntu/part1
ls /home/ubuntu/part2
</syntaxhighlight>

Veremos que tenemos una carpeta lost+found en el sistema ext4, la cual se
utiliza para los errores en el sistema de archivos, cuando hay un error y
encontramos un fichero sin referencia, este se añadiría dentro de esta carpeta,
y existiría la posibilidad de recuperarlo.

Ahora vamos a crear un nuevo fichero dentro de nuestra partición /dev/vdc1, la
vamos a desmontar, y vamos a montarla en otro directorio diferente:

<syntaxhighlight lang="bash">
sudo touch /home/ubuntu/part1/nuevoFichero # tenemos que crearlo con sudo porque no tenemos permisos, luego veremos esto
sudo umount /dev/vdc1
ls /home/ubuntu/part3 # el fichero ya no está, la partición fue desmontada
mkdir /home/ubuntu/part3
sudo mount /dev/vdc1 /home/ubuntu/part3
ls /home/ubuntu/part3
</syntaxhighlight>

Comprobaremos que el fichero creado en /home/ubuntu/part1 lo tenemos ahora en
/home/ubuntu/part3, ya que realmente, cuando lo guardamos, estaba en la
partición que montamos.

También podemos ver que utilizando el comando lsblk, podremos observar donde
está montada la partición.

== Montaje automático al iniciar el sistema ==

Ahora veremos como automatizar el proceso de montaje cada vez que se inicia el
sistema, ya que sería tedioso tener que montar todos las particiones cada vez
que apagamos y encendemos nuestra máquina.

El proceso de automatizado suele hacerse dentro del fichero /etc/fstab, veamos
su contenido:

<syntaxhighlight lang="bash">
cat /etc/fstab
</syntaxhighlight>

Cada fila contiene un montaje de una partición, la cual contiene:

* Identificación de la partición: en este caso se está utilizando una etiqueta de
la partición, pero podemos utilizar cualquier cosa que identifique al
dispositivo, como el uuid o la localización (/dev/vdc1)
* Punto de montaje: donde se montará el dispositivo
* Sistema de archivos: ext4, fat32, reiserfs
* Opciones: aquí pondremos las diferentes opciones de montaje, como por ejemplo
montar para solo lectura, dar permisos a un usuario para utilizar la
partición, etc. Hay que tener en cuenta que cada sistema tiene sus opciones.
* backup: si está a cero, no haremos backup
* chequeo: si está a cero no se hace chequeo al iniciar

Vamos a añadir unas líneas para montar automáticamente las particiones al
iniciar:

Utilizando el editor que prefieras, añadir lo siguiente en el fichero
/etc/fstab. Importante hacerlo con sudo para que nos permita escribir en el
fichero:

<syntaxhighlight lang="bash">
/dev/vdc1 /home/ubuntu/part1 ext4 rw,user,exec 0 0
/dev/vdc2 /home/ubuntu/part2 vfat umask=000 0 0
</syntaxhighlight>

Una vez guardado los cambios, vamos a aplicarlos sin reiniciar, para comprobar
que funciona correctamente:

<syntaxhighlight lang="bash">
mount -a # aplica los cambios de fstab sin necesidad de reiniciar
lsblk # comprobar que está bien montado
</syntaxhighlight>

Ahora vamos a comprobar si nuestro usuario tiene permisos para escribir:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
touch /home/ubuntu/part2
</syntaxhighlight>

En el primero no nos dejará y en el segundo no tendremos problemas. Esto
funciona así porque los sistemas ext4, para poder tener permisos de escritura,
tenemos que darlo sobre el sistema de ficheros, mientras que el sistema fat,
tiene la opción umask que ya hace el trabajo. Para tener permisos de escritura
con nuestro usuario en la partición, tendremos que darle permiso a la partición
para poder escribir en ella, por ejemplo, utilizando el comando chown:

<syntaxhighlight lang="bash">
sudo chown ubuntu /home/ubuntu/part1
</syntaxhighlight>

Si probamos ahora, podremos escribir en la partición de ext4, y al haber dado
permisos, ya nos funcionará siempre:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
</syntaxhighlight>

Ahora, vamos a desmontar todo y a reiniciar la máquina para comprobar que está todo funciona.

<syntaxhighlight lang="bash">
sudo umount /dev/vdc1
sudo umount /home/ubuntu/part2 # Es otra forma de desmontar, dando el punto de montaje
lsblk # comprobamos que no estén montadas
</syntaxhighlight>

Reiniciamos la máquina (Máquina virtual -> Apagar -> Reiniciar) y comprobamos:

<syntaxhighlight lang="bash">
lsblk
</syntaxhighlight>

= Paso 6: Creación de sistemas de ficheros de red NFS =

En este paso, vamos a crear un sistema de ficheros de red compartido a través de NFS.
Para ello vamos a necesitar crear un servidor donde iniciemos este sistema al que se conectarán los clientes.

== Paso 6.1: Instalación y configuración del servidor de NFS ==

Para configurar el servidor, necesitaremos abrir una de las máquinas virtuales
creadas anteriormente e instalar la herramienta necesaria:

<syntaxhighlight lang="bash">
sudo apt install nfs-kernel-server
</syntaxhighlight>

Una vez hecho esto, vamos a crear un directorio el cual será el que
compartiremos, por ejemplo:

<syntaxhighlight lang="bash">
sudo mkdir /home/shared
</syntaxhighlight>

Ahora vamos a editar el servidor nfs, para ello, tendremos que editar el fichero
/etc/exports, pero antes, veremos cual es nuestra IP, que nos hará falta:

<syntaxhighlight lang="bash">
ip address
</syntaxhighlight>

La salida de este comando será similar a la siguiente:

<syntaxhighlight lang="bash">
enp1s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 192.168.0.167 netmask 255.255.255.0 broadcast 192.168.0.255
inet6 fe80::ea6a:64ff:fe66:66a0 prefixlen 64 scopeid 0x20<link>
ether e8:6a:64:66:66:a0 txqueuelen 1000 (Ethernet)
RX packets 3821 bytes 2152349 (2.0 MiB)
RX errors 0 dropped 268 overruns 0 frame 0
TX packets 3386 bytes 266855 (260.6 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 16 memory 0xa4300000-a4320000

lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1000 (Local Loopback)
RX packets 220506 bytes 16017419 (15.2 MiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 220506 bytes 16017419 (15.2 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
</syntaxhighlight>

Nos fijamos donde pone inet, y miramos la red que NO sea 'lo', en este caso,
la IP buscada sería 192.168.0.167. Ahora si, vamos a editar el /etc/exports:

<syntaxhighlight lang="bash">
/home/shared 192.168.0.*(rw,sync,subtree_check)
</syntaxhighlight>

Explicamos los parámetros:

# Carpeta a compartir
# Le damos la IP con un * al final para poder permitir a todas las redes poder
acceder, desde la 192.168.0.0 a la 192.168.0.255
# Aquí tenemos muchas opciones disponibles:
## ro: solo lectura
## rw: lectura y escritura
## subtree_check: comprueba subdirectorios para compartirlos también
## sync: forzar a hacer las operaciones de forma síncrona (los datos se escriben inmediatamente en el disco del servidor NFS).

Una vez modificado el fichero, vamos a reiniciar el servicio NFS:

<syntaxhighlight lang="bash">
sudo service nfs-kernel-server restart
</syntaxhighlight>

Una vez hecho esto, nuestro servidor NFS ya está configurado.

== Paso 6.2: Instalación y configuración del cliente de NFS ==

Para acceder al sistema de ficheros NFS creado en el paso anterior, tendremos
que configurar el cliente para montar el sistema de ficheros compartido. El
cliente lo montaremos en otra máquina virtual diferente.

Creamos y abrimos esta nueva máquina e instalamos una herramienta para poder
montar el NFS en nuestra máquina:

<syntaxhighlight lang="bash">
sudo apt install nfs-common
</syntaxhighlight>

Con esto ya podremos montar en nuestro cliente el NFS. Recordemos la IP que
obtuvimos en el paso anterior cuando montamos el servidor, y hacemos lo
siguiente:

<syntaxhighlight lang="bash">
sudo mount 192.168.0.167:/home/shared /mnt
</syntaxhighlight>

Ya tenemos nuestro sistema de ficheros compartidos por red montado, vamos a
probar que todo funciona.

1. En la máquina donde instalamos el servidor de NFS, vamos a crear una carpeta
y un fichero dentro de la carpeta compartida, para ellos necesitaremos darle
permisos a nuestro usuario previamente:

<syntaxhighlight lang="bash">
sudo chown -R ubuntu /home/shared
mkdir /home/shared/carpeta
touch /home/shared/carpeta/fichero
</syntaxhighlight>

2. Vamos a comprobar en el cliente, que estos ficheros se están mostrando:

<syntaxhighlight lang="bash">
ls /mnt
ls /mnt/carpeta
</syntaxhighlight>

3. Ahora lo hacemos al contrario, escribiremos desde el cliente, y vamos a verlo en el servidor:

<syntaxhighlight lang="bash">
mkdir /mnt/carpeta2
touch /mnt/carpeta2/fichero
</syntaxhighlight>

4. Entramos en el servidor y comprobamos:

<syntaxhighlight lang="bash">
ls /home/shared
ls /home/shared/carpeta2
</syntaxhighlight>

= Paso 7: Creación de un RAID =

En este apartado vamos a configurar un RAID 1 (espejo) que nos permite aumentar la fiabilidad. La idea es que si uno de los discos del RAID deja de funcionar, los datos en el sistema de fichero siguen estando disponibles con lo que disponemos de algo de tiempo para reemplazar el disco defectuoso.

== Paso 7.1: Añadir discos a la máquina virtual ==

Como explicamos en el Paso 1, vamos a añadir a una máquina virtual 2 discos duros de 5GB cada uno.

== Paso 7.2: Instalación de la herramienta de mdadm ==

Por defecto, esta herramienta viene instalada en el ubuntu cloud server, pero en
el caso de utilizar otra distribución diferente, necesitaremos instalarla:

<syntaxhighlight lang="bash">
sudo apt install mdadm
</syntaxhighlight>

== Paso 7.3: Utilización de la herramienta de mdadm ==

Empezamos escribiendo el comando, y luego pasamos a explicar los detalles:

<syntaxhighlight lang="bash">
sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/vdb1 /dev/vdc1
</syntaxhighlight>

Explicamos los parámetros:

# --create: para crear el raid
# --verbose: nos muestra más información del proceso
# /dev/md0: El nombre del nuevo raid, normalmente se utiliza md0
# --level=1: crea un raid 1 que es el que queremos
# --raid-devices=2: cantidad de dispositivos que vamos a utilizar, 2 en nuestro caso
# /dev/vdb1: Nombre de la partición 1
# /dev/vdc1: Nombre de la partición 2

Una vez ejecutado el comando, creará el RAID 1, pasemos ahora a ver los
detalles:

<syntaxhighlight lang="bash">
sudo mdadm --detail /dev/md0
</syntaxhighlight>

Esto nos mostrará la información del RAID, lo que a nosotros nos interesa son
las últimas líneas:

<syntaxhighlight lang="bash">
Name : ubuntu:0 (local to host ubuntu)
UUID : e40ba520:5ed1bd37:5c818550:03a18368
Events : 17

Number Major Minor RaidDevice State
0 252 17 0 active sync /dev/vdb1
1 252 33 1 active sync /dev/vdc1
</syntaxhighlight>

Aqui vemos el UUID de nuestro RAID, y también veremos en las dos última líneas,
las dos particiones, las cuales están marcadas con active sync, esto quiere
decir que están activos y sincronizados. Puede que si hacemos muy rápido este
comando, muestre algo diferente porque tarda un poco en sincronizar la primera
vez, pero pronto estará.

== Paso 7.5: Guardar la configuración del RAID ==

Vamos a modificar la configuración, tendremos que editar el
fichero /etc/mdadm/mdadm.conf y debajo de la línea que pone '# definitions of
existing MD arrays', añadir lo siguiente:

<syntaxhighlight lang="bash">
ARRAY /dev/md0 UUID=e40ba520:5ed1bd37:5c818550:03a18368
</syntaxhighlight>

Recuerda que el UUID lo puedes consultar con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Busca el campo UUID.

Tras actualizar /etc/mdadm/mdadm.conf, tienes que invocar la siguiente orden:

<syntaxhighlight lang="bash">
update-initramfs -u
</syntaxhighlight>

Esto asegura que en el próximo arranque el RAID usa la unidad /dev/md0.

== Paso 7.6: Particionar y formatear el RAID ==

Como explicamos en los Pasos 2, 3 y 4, vamos a particionar el disco RAID:

<syntaxhighlight lang="bash">
lsblk # comprobamos los dicos, en mi caso sería md0
sudo fdisk /dev/md0
</syntaxhighlight>

Ahora vamos a formatear la partición:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/md0p1
</syntaxhighlight>

== Paso 7.7: Montar el RAID ==

Como previamente hemos hecho, crearemos una carpeta donde montar el RAID y lo
montaremos usando el comando mount:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/datos
sudo mount /dev/md0p1 /home/ubuntu/datos
sudo chown -R ubuntu /home/ubuntu/datos
</syntaxhighlight>

Así ya tenemos nuestro RAID montado y podemos utilizarlo, vamos a probar a
escribir en él.

<syntaxhighlight lang="bash">
touch /home/ubuntu/datos/fichero
</syntaxhighlight>

Esto está funcionando, pero como comentamos en uno de los pasos previos, el
comando mount solo montará el raid temporalmente, para automatizar este montado
al arrancar, tendremos que añadir la siguiente línea a /etc/fstab:

<syntaxhighlight lang="bash">
/dev/md0p1 /home/ubuntu/datos ext4 defaults
</syntaxhighlight>

== Paso 7.8: Comprobar tolerancia a fallos ==

Vamos a probar que sin un disco duro, todo sigue funcionando bien, ya que al
tener un RAID 1 y tener los datos en espejo, no debería de haber problemas.

La siguiente orden marca el disco /dev/sdb1 como dañado:

<syntaxhighlight lang="bash">
mdadm --fail /dev/md0 /dev/sdb1
</syntaxhighlight>

Podemos ver con la siguiente orden que el disco aparece como ''faulty'':

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Sin embargo, podemos ver que el sistema de ficheros sigue montado y el contenido sigue estando disponible.

<syntaxhighlight lang="bash">
ls /home/ubuntu/datos/
</syntaxhighlight>

Podéis retirar definitivamente el disco defectuoso con la orden:

<syntaxhighlight lang="bash">
mdadm --remove /dev/md0 /dev/sdb1
</syntaxhighlight>

Para volver a incluirlo en el RAID:

<syntaxhighlight lang="bash">
mdadm --add /dev/md0 /dev/sdb1
</syntaxhighlight>

Podéis consultar que está sincronizando con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Que mostrará el disco /dev/sdb1 en estado ''spare rebuilding'' y mostrará el porcentaje de sincronización.

= Paso 8: Gestión volúmenes (Logic Volume Manager, LVM) =

Logic Volume Manager (LVM) es una capa de software que permite crear volúmenes lógicos y mapearlos de manera sencilla sobre dispositivos físicos.

La instalación de LVM es sencilla mediante la orden:

sudo apt-get install lvm2

La gestión de LVM se basa en tres conceptos básicos:

* Volúmenes físicos (PV): Representa una unidad de almacenamiento que aprovisiona espacio de almacenamiento para el volumen lógico que vamos a crear.
* Grupo volumen (VG): Representa un almacén de espacio para LVM. Un VG estará compuesto por varios PV, pudiendo tener tantos VG como sean necesarios.
* Volumen lógico (LV): Representan unidades lógicas creadas a partir de VG creado previamente. Se podrán crear tantos LV como sean necesarios para un VG. La creación de un LVM genera un archivo especial en /dev, con la forma /dev/nombre_del_grupo/nombre_volumne_logico. El mapeo de espacio desde un LV hasta un PV es configurable pudiendo ser: Lineal, RAID, Cache, ...

== Paso 8.1: Creación de volumen físico LVM (PV) ==

Para listar las unidades de almacenamiento disponibles en el sistema, empleamos la siguiente orden:

lsblk

En virtualbox podemos crear nuevas unidades almacenamiento y añadirlas a la máquina virtual.

Para crear un volumen físico en la unidad /dev/sdb, empleamos la orden:

pvcreate /dev/sdb

Recuerde que la unidad /dev/sdb tiene que estar en desuso.

Para ver los volúmenes físicos existentes, empleamos la orden:

pvscan

Para obtener más información:

pvdisplay

Para eliminar un PV, por ejemplo /dev/sdb:

pvremove /dev/sdb

== Paso 8.2: Creación de grupo de volumenes LVM (VG) ==

Para crear un grupo, empleamos el comando vgcreate:

vgcreate vg_prueba /dev/sdb /dev/sdc

Esto añade al grupo 'vg_prueba' los volúmenes sdb y sdc, haciendo que la capacidad del grupo sea la capacidad agregada de los PV añadidos.

Para eliminar un grupo vgremove:

vgremove vg_prueba

Para extender un grupo creado (por ejemplo, vg_prueba) con más PV (por ejemplo /dev/sde) usamos el comando vgextend:

vgextend vg_prueba /dev/sde

Para reducir la capacidad de un grupo creado (por ejemplo, vg_prueba) basta con usar el comando vgreduce indicando la unidad (PV) a quitar, por ejemplo /dev/sde:

vgreduce vg_prueba /dev/sde

Para mostrar todos los grupos de volumenes existentes

vgscan

== Paso 8.3: Creación de volumen lógico (LV) ==

Para crear un volúmen lógico, empleamos la orden:

lvcreate --name volumen1 --size 100MB vg_prueba

A partir de este momento hay una unidad que se presenta como ''/dev/mapper/vg_prueba-volumen1''.

Podemos ahora formatear el volumen lógico:

mkfs.ext4 /dev/vg_prueba/volumen1

y montarlo para almacenar información:

mount /dev/vg_prueba/volumen1 /mnt

Puedes extender un volumen lógico en 1 Gbyte de más:

lvextend --size +1GB /dev/vg_prueba/volumen1

Justo después tienes que redimensionar el sistema de ficheros:

resize2fs /dev/vg_prueba/volumen1

Puedes comprobar con:

df -h

que el sistema de ficheros en ''volumen1'' ocupa ahora todo el volumen lógico.

Reducir el tamaño de un volumen lógico es un poco más complicado, ¡podrían perder datos si no se realiza correctamente!

Primero, desmontamos el volumen:

umount /mnt/volumen1

reducir el tamaño del sistema de ficheros, comprobamos la integridad del sistema de ficheros:

e2fsck -f /dev/vg_prueba/volumen1

Y lo redimensionamos (reducimos de tamaño):

resize2fs /dev/vg_prueba/volumen1 500M

Ahora ya, por último lugar, puedes reducir el tamaño del volumen:

lvreduce --size 500M /dev/vg_prueba/volumen1

Para comprobar que hay ido todo bien, vuelve a redimensionar el sistema de ficheros para que ocupe todo el espacio disponible.

resize2fs /dev/vg_prueba/volumen1

Y puedes volver a montar el sistema de ficheros:

mount /dev/vg_prueba/volumen1 /mnt/volumen1

con

df -h

para comprar el nuevo tamaño disponible de sólo 500 MBytes.

Sistemas de archivos

2019-12-10T17:47:11Z

Artrodase: /* Paso 6.1: Instalación y configuración del servidor de NFS */

= Paso 1: Añadir un disco a la máquina virtual =

Vamos a usar cualquier máquina virtual de ubuntu cloud que hayamos usado
previamente y vamos a añadir dos discos virtuales para hacer pruebas.

# Abrimos la ventana de la máquina virtual a usar
# Nos movemos a Vista -> Detalles, y le damos al botón de 'Agregar hardware'
# Seleccionamos Almacenamiento, le damos un tamaño de 5GB y en el tipo de dispositivo seleccionamos 'dispositivo de disco'. Con estas opciones, pulsamos Finalizar., y ya tendremos nuestro disco creado.
# Repetir el paso anterior y crear otro disco de 4GB

= Paso 2: Ver discos en Linux =

Volvamos a la vista consola (Vista -> Consola) y arranquemos la máquina (Máquina virtual -> Ejecutar).

Para comprobar los discos añadidos en el paso 1 vamos a utilizar el comando lsblk, el cual nos mostrará una salida similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Aqui vemos que tenemos 3 discos:

* vda: el actual de ubuntu que añadimos al crear la máquina
* vdb: el disco que añadimos en el paso 1 de 5GB
* vdc: el disco que añadimos en el paso 1 de 4GB

También vemos que el disco vda tiene 3 particiones: vda1, vda14 y vda15

= Paso 3: Creación de particiones en Linux =

Vamos a utilizar ahora nuestro disco añadido de 5GB, en el paso anterior
deberiamos de haber identificado cual es, en mi caso /dev/vdb, aseguraros cual
es el vuestro y comenzaremos a particionar el disco:

<syntaxhighlight lang="bash">
sudo fdisk /dev/vdb
</syntaxhighlight>

Si el disco es nuevo y no ha hecho nada previamente, normalmente viene sin tabla
de particiones, así que fdisk se encarga de crear una, seguramente veamos ese
mensaje cuando hayamos ejecutado el comando anterior.
La tabla de particiones es una pequeña parte del disco que se utiliza para
alamacenar la información de las particiones, el formato y si una partición es
ejecutable o no.

Una vez hecho esto, veremos que estamos dentro de fdisk (software para
particionar un disco), y veremos que este tiene su propia linea de comando.

Ahora veremos la ayuda de fdisk y crearemos una partición de prueba de 3GB

# Introducir la letra 'm' y pulsar Intro, así obtendremos el listado de comandos posibles de fdisk.
# Introducir 'n' y pulsar Intro para crear una nueva partición. Nos preguntará varios detalles:
## Tipo de partición: pulsamos Intro y se asignará primaria por defecto.
## Número de partición: pulsamos Intro y se asignará 1 por defecto.
## Primer sector: pulsamos Intro para que se asigne por defecto.
## Último sector: vamos a crear una partición de 3GB, así que escribimos ''+3G'' y pulsamos Intro
# Ya está creada nuestra primera partición, aunque los cambios todavía no se han escrito en disco, para ello, necesitaremos aplicar estos cambios, y lo hacemos con el comando 'w' y pulsando Intro.
# Ahora si, ya tenemos nuestra partición creada. Vamos a comprobar que el cambio está hecho, usando lsblk por ejemplo, deberíamos de obtener algo similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
└─vdb1 252:17 0 3G 0 part
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Vamos ahora a crear en el disco de 4GB (vdc en mi caso) dos particiones de 2GB cada una, y la partición de 3GB creada anteriormente, vamos a borrarla:

# sudo fdisk /dev/vdc
# comando 'n' e Intro
# Todos los datos por defecto, excepto el último sector, donde pondremos '+2G'
# Una vez creada la primera partición, antes de escribir a disco, vamos a crear la segunda partición, repetimos los pasos anteriores. Vamos a tener un problema y cuando lleguemos al último paso, nos dirá que 2GB no es posible. Si tenemos un disco de 4GB, ¿Por qué no nos permite crear dos particiones de 2GB? Exacto, por la tabla de particiones. Lo que haremos en el último paso será dejar el valor por defecto, que será todo el disco sobrante.
# Vamos a comprobar antes de escribir los cambios, que todo está bien, comando 'p' e Intro debería de mostrarnos una salida similar a:

<syntaxhighlight lang="bash">
Device Boot Start End Sectors Size Id Type
/dev/vdc1 2048 4196351 4194304 2G 83 Linux
/dev/vdc2 4196352 4196351 4194304 2G 83 Linux
</syntaxhighlight>

# Si todo está correcto, pulsamos 'w' e Intro y aplicamos los cambios
# Ahora entraremos con el disco /dev/vdb para eliminar la partición: sudo fdisk /dev/vdb
# Ahora vamos a eliminar la particion, pulsamos 'd' e Intro. Como solo tenemos una partición, nos la borra directamente, en caso de tener más de una, nos preguntaría cual queremos borrar.
# Aplicamos los cambios: 'w' e Intro
# Comprobamos que todo ha quedado a nuestro gusto con el comando lsblk

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
├─vdc1 252:33 0 2G 0 part
└─vdc2 252:34 0 2G 0 part
</syntaxhighlight>

= Paso 4: Formatear partición: crear un sistema de archivos =

Hasta ahora solo hemos definido en la tabla de particiones donde comienza y
acaba cada partición, pero no podremos utilizarla hasta que no creemos un
sistema de archivos en la partición. Para crear un sistema de archivos
utilizaremos el comando 'mkfs', y tendremos varias opciones a la hora de crear
uno: ext2, ext3, ext4, btrfs, fat, ntfs, etc...

Nosotros creamos un sistema ext4 para /dev/vdc1 y uno fat para /dev/vdc2:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/vdc1
sudo mkfs -t fat /dev/vdc2
</syntaxhighlight>

Una vez hecho esto, vamos a comprobar que se han aplicado bien los cambios:

<syntaxhighlight lang="bash">
sudo file -s /dev/vdc1
sudo file -s /dev/vdc2
</syntaxhighlight>

En la salida deberíamos de obtener que tenemos un sistema de ficheros ext4 y
otro FAT.

= Paso 5: Montar y desmontar particiones en Linux =

Tras haber creado en los pasos anteriores unas particiones y formatearlas, vamos
a pasar ahora a montarlas para poderles dar uso. En linux montar una partición
significará que asignaremos una carpeta del sistema a una partición, y en ella
estará todo el contenido del disco.

== Mount y umount ==

Empezaremos utilizando los comandos mount y umount para montar y desmontar
particiones. Vamos a montar las particiones /dev/vdc1 y /dev/vdc2, la primera la
montaremos en /home/ubuntu/part1 y la segunda en /home/ubuntu/part2:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part1 # Creamos la carpeta donde vamos a montar la partición
sudo mount /dev/vdc1 /home/ubuntu/part1 # montamos la partición
</syntaxhighlight>

Lo mismo con /dev/vdc2

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part2
sudo mount /dev/vdc2 /home/ubuntu/part2
</syntaxhighlight>

Vamos a ver el contenido de las particiones montadas:

<syntaxhighlight lang="bash">
ls /home/ubuntu/part1
ls /home/ubuntu/part2
</syntaxhighlight>

Veremos que tenemos una carpeta lost+found en el sistema ext4, la cual se
utiliza para los errores en el sistema de archivos, cuando hay un error y
encontramos un fichero sin referencia, este se añadiría dentro de esta carpeta,
y existiría la posibilidad de recuperarlo.

Ahora vamos a crear un nuevo fichero dentro de nuestra partición /dev/vdc1, la
vamos a desmontar, y vamos a montarla en otro directorio diferente:

<syntaxhighlight lang="bash">
sudo touch /home/ubuntu/part1/nuevoFichero # tenemos que crearlo con sudo porque no tenemos permisos, luego veremos esto
sudo umount /dev/vdc1
ls /home/ubuntu/part3 # el fichero ya no está, la partición fue desmontada
mkdir /home/ubuntu/part3
sudo mount /dev/vdc1 /home/ubuntu/part3
ls /home/ubuntu/part3
</syntaxhighlight>

Comprobaremos que el fichero creado en /home/ubuntu/part1 lo tenemos ahora en
/home/ubuntu/part3, ya que realmente, cuando lo guardamos, estaba en la
partición que montamos.

También podemos ver que utilizando el comando lsblk, podremos observar donde
está montada la partición.

== Montaje automático al iniciar el sistema ==

Ahora veremos como automatizar el proceso de montaje cada vez que se inicia el
sistema, ya que sería tedioso tener que montar todos las particiones cada vez
que apagamos y encendemos nuestra máquina.

El proceso de automatizado suele hacerse dentro del fichero /etc/fstab, veamos
su contenido:

<syntaxhighlight lang="bash">
cat /etc/fstab
</syntaxhighlight>

Cada fila contiene un montaje de una partición, la cual contiene:

* Identificación de la partición: en este caso se está utilizando una etiqueta de
la partición, pero podemos utilizar cualquier cosa que identifique al
dispositivo, como el uuid o la localización (/dev/vdc1)
* Punto de montaje: donde se montará el dispositivo
* Sistema de archivos: ext4, fat32, reiserfs
* Opciones: aquí pondremos las diferentes opciones de montaje, como por ejemplo
montar para solo lectura, dar permisos a un usuario para utilizar la
partición, etc. Hay que tener en cuenta que cada sistema tiene sus opciones.
* backup: si está a cero, no haremos backup
* chequeo: si está a cero no se hace chequeo al iniciar

Vamos a añadir unas líneas para montar automáticamente las particiones al
iniciar:

Utilizando el editor que prefieras, añadir lo siguiente en el fichero
/etc/fstab. Importante hacerlo con sudo para que nos permita escribir en el
fichero:

<syntaxhighlight lang="bash">
/dev/vdc1 /home/ubuntu/part1 ext4 rw,user,exec 0 0
/dev/vdc2 /home/ubuntu/part2 vfat umask=000 0 0
</syntaxhighlight>

Una vez guardado los cambios, vamos a aplicarlos sin reiniciar, para comprobar
que funciona correctamente:

<syntaxhighlight lang="bash">
mount -a # aplica los cambios de fstab sin necesidad de reiniciar
lsblk # comprobar que está bien montado
</syntaxhighlight>

Ahora vamos a comprobar si nuestro usuario tiene permisos para escribir:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
touch /home/ubuntu/part2
</syntaxhighlight>

En el primero no nos dejará y en el segundo no tendremos problemas. Esto
funciona así porque los sistemas ext4, para poder tener permisos de escritura,
tenemos que darlo sobre el sistema de ficheros, mientras que el sistema fat,
tiene la opción umask que ya hace el trabajo. Para tener permisos de escritura
con nuestro usuario en la partición, tendremos que darle permiso a la partición
para poder escribir en ella, por ejemplo, utilizando el comando chown:

<syntaxhighlight lang="bash">
sudo chown ubuntu /home/ubuntu/part1
</syntaxhighlight>

Si probamos ahora, podremos escribir en la partición de ext4, y al haber dado
permisos, ya nos funcionará siempre:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
</syntaxhighlight>

Ahora, vamos a desmontar todo y a reiniciar la máquina para comprobar que está todo funciona.

<syntaxhighlight lang="bash">
sudo umount /dev/vdc1
sudo umount /home/ubuntu/part2 # Es otra forma de desmontar, dando el punto de montaje
lsblk # comprobamos que no estén montadas
</syntaxhighlight>

Reiniciamos la máquina (Máquina virtual -> Apagar -> Reiniciar) y comprobamos:

<syntaxhighlight lang="bash">
lsblk
</syntaxhighlight>

= Paso 6: Creación de sistemas de ficheros de red NFS =

En este paso, vamos a crear un sistema de ficheros de red compartido a través de NFS.
Para ello vamos a necesitar crear un servidor donde iniciemos este sistema al que se conectarán los clientes.

== Paso 6.1: Instalación y configuración del servidor de NFS ==

Para configurar el servidor, necesitaremos abrir una de las máquinas virtuales
creadas anteriormente e instalar la herramienta necesaria:

<syntaxhighlight lang="bash">
sudo apt nfs-kernel-server
</syntaxhighlight>

Una vez hecho esto, vamos a crear un directorio el cual será el que
compartiremos, por ejemplo:

<syntaxhighlight lang="bash">
sudo mkdir /home/shared
</syntaxhighlight>

Ahora vamos a editar el servidor nfs, para ello, tendremos que editar el fichero
/etc/exports, pero antes, veremos cual es nuestra IP, que nos hará falta:

<syntaxhighlight lang="bash">
ip address
</syntaxhighlight>

La salida de este comando será similar a la siguiente:

<syntaxhighlight lang="bash">
enp1s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 192.168.0.167 netmask 255.255.255.0 broadcast 192.168.0.255
inet6 fe80::ea6a:64ff:fe66:66a0 prefixlen 64 scopeid 0x20<link>
ether e8:6a:64:66:66:a0 txqueuelen 1000 (Ethernet)
RX packets 3821 bytes 2152349 (2.0 MiB)
RX errors 0 dropped 268 overruns 0 frame 0
TX packets 3386 bytes 266855 (260.6 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 16 memory 0xa4300000-a4320000

lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1000 (Local Loopback)
RX packets 220506 bytes 16017419 (15.2 MiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 220506 bytes 16017419 (15.2 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
</syntaxhighlight>

Nos fijamos donde pone inet, y miramos la red que NO sea 'lo', en este caso,
la IP buscada sería 192.168.0.167. Ahora si, vamos a editar el /etc/exports:

<syntaxhighlight lang="bash">
/home/shared 192.168.0.*(rw,sync,subtree_check)
</syntaxhighlight>

Explicamos los parámetros:

# Carpeta a compartir
# Le damos la IP con un * al final para poder permitir a todas las redes poder
acceder, desde la 192.168.0.0 a la 192.168.0.255
# Aquí tenemos muchas opciones disponibles:
## ro: solo lectura
## rw: lectura y escritura
## subtree_check: comprueba subdirectorios para compartirlos también
## sync: forzar a hacer las operaciones de forma síncrona (los datos se escriben inmediatamente en el disco del servidor NFS).

Una vez modificado el fichero, vamos a reiniciar el servicio NFS:

<syntaxhighlight lang="bash">
sudo service nfs-kernel-server restart
</syntaxhighlight>

Una vez hecho esto, nuestro servidor NFS ya está configurado.

== Paso 6.2: Instalación y configuración del cliente de NFS ==

Para acceder al sistema de ficheros NFS creado en el paso anterior, tendremos
que configurar el cliente para montar el sistema de ficheros compartido. El
cliente lo montaremos en otra máquina virtual diferente.

Creamos y abrimos esta nueva máquina e instalamos una herramienta para poder
montar el NFS en nuestra máquina:

<syntaxhighlight lang="bash">
sudo apt install nfs-common
</syntaxhighlight>

Con esto ya podremos montar en nuestro cliente el NFS. Recordemos la IP que
obtuvimos en el paso anterior cuando montamos el servidor, y hacemos lo
siguiente:

<syntaxhighlight lang="bash">
sudo mount 192.168.0.167:/home/shared /mnt
</syntaxhighlight>

Ya tenemos nuestro sistema de ficheros compartidos por red montado, vamos a
probar que todo funciona.

1. En la máquina donde instalamos el servidor de NFS, vamos a crear una carpeta
y un fichero dentro de la carpeta compartida, para ellos necesitaremos darle
permisos a nuestro usuario previamente:

<syntaxhighlight lang="bash">
sudo chown -R ubuntu /home/shared
mkdir /home/shared/carpeta
touch /home/shared/carpeta/fichero
</syntaxhighlight>

2. Vamos a comprobar en el cliente, que estos ficheros se están mostrando:

<syntaxhighlight lang="bash">
ls /mnt
ls /mnt/carpeta
</syntaxhighlight>

3. Ahora lo hacemos al contrario, escribiremos desde el cliente, y vamos a verlo en el servidor:

<syntaxhighlight lang="bash">
mkdir /mnt/carpeta2
touch /mnt/carpeta2/fichero
</syntaxhighlight>

4. Entramos en el servidor y comprobamos:

<syntaxhighlight lang="bash">
ls /home/shared
ls /home/shared/carpeta2
</syntaxhighlight>

= Paso 7: Creación de un RAID =

En este apartado vamos a configurar un RAID 1 (espejo) que nos permite aumentar la fiabilidad. La idea es que si uno de los discos del RAID deja de funcionar, los datos en el sistema de fichero siguen estando disponibles con lo que disponemos de algo de tiempo para reemplazar el disco defectuoso.

== Paso 7.1: Añadir discos a la máquina virtual ==

Como explicamos en el Paso 1, vamos a añadir a una máquina virtual 2 discos duros de 5GB cada uno.

== Paso 7.2: Instalación de la herramienta de mdadm ==

Por defecto, esta herramienta viene instalada en el ubuntu cloud server, pero en
el caso de utilizar otra distribución diferente, necesitaremos instalarla:

<syntaxhighlight lang="bash">
sudo apt install mdadm
</syntaxhighlight>

== Paso 7.3: Utilización de la herramienta de mdadm ==

Empezamos escribiendo el comando, y luego pasamos a explicar los detalles:

<syntaxhighlight lang="bash">
sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/vdb1 /dev/vdc1
</syntaxhighlight>

Explicamos los parámetros:

# --create: para crear el raid
# --verbose: nos muestra más información del proceso
# /dev/md0: El nombre del nuevo raid, normalmente se utiliza md0
# --level=1: crea un raid 1 que es el que queremos
# --raid-devices=2: cantidad de dispositivos que vamos a utilizar, 2 en nuestro caso
# /dev/vdb1: Nombre de la partición 1
# /dev/vdc1: Nombre de la partición 2

Una vez ejecutado el comando, creará el RAID 1, pasemos ahora a ver los
detalles:

<syntaxhighlight lang="bash">
sudo mdadm --detail /dev/md0
</syntaxhighlight>

Esto nos mostrará la información del RAID, lo que a nosotros nos interesa son
las últimas líneas:

<syntaxhighlight lang="bash">
Name : ubuntu:0 (local to host ubuntu)
UUID : e40ba520:5ed1bd37:5c818550:03a18368
Events : 17

Number Major Minor RaidDevice State
0 252 17 0 active sync /dev/vdb1
1 252 33 1 active sync /dev/vdc1
</syntaxhighlight>

Aqui vemos el UUID de nuestro RAID, y también veremos en las dos última líneas,
las dos particiones, las cuales están marcadas con active sync, esto quiere
decir que están activos y sincronizados. Puede que si hacemos muy rápido este
comando, muestre algo diferente porque tarda un poco en sincronizar la primera
vez, pero pronto estará.

== Paso 7.5: Guardar la configuración del RAID ==

Vamos a modificar la configuración, tendremos que editar el
fichero /etc/mdadm/mdadm.conf y debajo de la línea que pone '# definitions of
existing MD arrays', añadir lo siguiente:

<syntaxhighlight lang="bash">
ARRAY /dev/md0 UUID=e40ba520:5ed1bd37:5c818550:03a18368
</syntaxhighlight>

Recuerda que el UUID lo puedes consultar con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Busca el campo UUID.

Tras actualizar /etc/mdadm/mdadm.conf, tienes que invocar la siguiente orden:

<syntaxhighlight lang="bash">
update-initramfs -u
</syntaxhighlight>

Esto asegura que en el próximo arranque el RAID usa la unidad /dev/md0.

== Paso 7.6: Particionar y formatear el RAID ==

Como explicamos en los Pasos 2, 3 y 4, vamos a particionar el disco RAID:

<syntaxhighlight lang="bash">
lsblk # comprobamos los dicos, en mi caso sería md0
sudo fdisk /dev/md0
</syntaxhighlight>

Ahora vamos a formatear la partición:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/md0p1
</syntaxhighlight>

== Paso 7.7: Montar el RAID ==

Como previamente hemos hecho, crearemos una carpeta donde montar el RAID y lo
montaremos usando el comando mount:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/datos
sudo mount /dev/md0p1 /home/ubuntu/datos
sudo chown -R ubuntu /home/ubuntu/datos
</syntaxhighlight>

Así ya tenemos nuestro RAID montado y podemos utilizarlo, vamos a probar a
escribir en él.

<syntaxhighlight lang="bash">
touch /home/ubuntu/datos/fichero
</syntaxhighlight>

Esto está funcionando, pero como comentamos en uno de los pasos previos, el
comando mount solo montará el raid temporalmente, para automatizar este montado
al arrancar, tendremos que añadir la siguiente línea a /etc/fstab:

<syntaxhighlight lang="bash">
/dev/md0p1 /home/ubuntu/datos ext4 defaults
</syntaxhighlight>

== Paso 7.8: Comprobar tolerancia a fallos ==

Vamos a probar que sin un disco duro, todo sigue funcionando bien, ya que al
tener un RAID 1 y tener los datos en espejo, no debería de haber problemas.

La siguiente orden marca el disco /dev/sdb1 como dañado:

<syntaxhighlight lang="bash">
mdadm --fail /dev/md0 /dev/sdb1
</syntaxhighlight>

Podemos ver con la siguiente orden que el disco aparece como ''faulty'':

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Sin embargo, podemos ver que el sistema de ficheros sigue montado y el contenido sigue estando disponible.

<syntaxhighlight lang="bash">
ls /home/ubuntu/datos/
</syntaxhighlight>

Podéis retirar definitivamente el disco defectuoso con la orden:

<syntaxhighlight lang="bash">
mdadm --remove /dev/md0 /dev/sdb1
</syntaxhighlight>

Para volver a incluirlo en el RAID:

<syntaxhighlight lang="bash">
mdadm --add /dev/md0 /dev/sdb1
</syntaxhighlight>

Podéis consultar que está sincronizando con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Que mostrará el disco /dev/sdb1 en estado ''spare rebuilding'' y mostrará el porcentaje de sincronización.

= Paso 8: Gestión volúmenes (Logic Volume Manager, LVM) =

Logic Volume Manager (LVM) es una capa de software que permite crear volúmenes lógicos y mapearlos de manera sencilla sobre dispositivos físicos.

La instalación de LVM es sencilla mediante la orden:

sudo apt-get install lvm2

La gestión de LVM se basa en tres conceptos básicos:

* Volúmenes físicos (PV): Representa una unidad de almacenamiento que aprovisiona espacio de almacenamiento para el volumen lógico que vamos a crear.
* Grupo volumen (VG): Representa un almacén de espacio para LVM. Un VG estará compuesto por varios PV, pudiendo tener tantos VG como sean necesarios.
* Volumen lógico (LV): Representan unidades lógicas creadas a partir de VG creado previamente. Se podrán crear tantos LV como sean necesarios para un VG. La creación de un LVM genera un archivo especial en /dev, con la forma /dev/nombre_del_grupo/nombre_volumne_logico. El mapeo de espacio desde un LV hasta un PV es configurable pudiendo ser: Lineal, RAID, Cache, ...

== Paso 8.1: Creación de volumen físico LVM (PV) ==

Para listar las unidades de almacenamiento disponibles en el sistema, empleamos la siguiente orden:

lsblk

En virtualbox podemos crear nuevas unidades almacenamiento y añadirlas a la máquina virtual.

Para crear un volumen físico en la unidad /dev/sdb, empleamos la orden:

pvcreate /dev/sdb

Recuerde que la unidad /dev/sdb tiene que estar en desuso.

Para ver los volúmenes físicos existentes, empleamos la orden:

pvscan

Para obtener más información:

pvdisplay

Para eliminar un PV, por ejemplo /dev/sdb:

pvremove /dev/sdb

== Paso 8.2: Creación de grupo de volumenes LVM (VG) ==

Para crear un grupo, empleamos el comando vgcreate:

vgcreate vg_prueba /dev/sdb /dev/sdc

Esto añade al grupo 'vg_prueba' los volúmenes sdb y sdc, haciendo que la capacidad del grupo sea la capacidad agregada de los PV añadidos.

Para eliminar un grupo vgremove:

vgremove vg_prueba

Para extender un grupo creado (por ejemplo, vg_prueba) con más PV (por ejemplo /dev/sde) usamos el comando vgextend:

vgextend vg_prueba /dev/sde

Para reducir la capacidad de un grupo creado (por ejemplo, vg_prueba) basta con usar el comando vgreduce indicando la unidad (PV) a quitar, por ejemplo /dev/sde:

vgreduce vg_prueba /dev/sde

Para mostrar todos los grupos de volumenes existentes

vgscan

== Paso 8.3: Creación de volumen lógico (LV) ==

Para crear un volúmen lógico, empleamos la orden:

lvcreate --name volumen1 --size 100MB vg_prueba

A partir de este momento hay una unidad que se presenta como ''/dev/mapper/vg_prueba-volumen1''.

Podemos ahora formatear el volumen lógico:

mkfs.ext4 /dev/vg_prueba/volumen1

y montarlo para almacenar información:

mount /dev/vg_prueba/volumen1 /mnt

Puedes extender un volumen lógico en 1 Gbyte de más:

lvextend --size +1GB /dev/vg_prueba/volumen1

Justo después tienes que redimensionar el sistema de ficheros:

resize2fs /dev/vg_prueba/volumen1

Puedes comprobar con:

df -h

que el sistema de ficheros en ''volumen1'' ocupa ahora todo el volumen lógico.

Reducir el tamaño de un volumen lógico es un poco más complicado, ¡podrían perder datos si no se realiza correctamente!

Primero, desmontamos el volumen:

umount /mnt/volumen1

reducir el tamaño del sistema de ficheros, comprobamos la integridad del sistema de ficheros:

e2fsck -f /dev/vg_prueba/volumen1

Y lo redimensionamos (reducimos de tamaño):

resize2fs /dev/vg_prueba/volumen1 500M

Ahora ya, por último lugar, puedes reducir el tamaño del volumen:

lvreduce --size 500M /dev/vg_prueba/volumen1

Para comprobar que hay ido todo bien, vuelve a redimensionar el sistema de ficheros para que ocupe todo el espacio disponible.

resize2fs /dev/vg_prueba/volumen1

Y puedes volver a montar el sistema de ficheros:

mount /dev/vg_prueba/volumen1 /mnt/volumen1

con

df -h

para comprar el nuevo tamaño disponible de sólo 500 MBytes.

Sistemas de archivos

2019-12-10T15:52:48Z

Artrodase: /* Paso 6.1: Instalación y configuración del servidor de NFS */

= Paso 1: Añadir un disco a la máquina virtual =

Vamos a usar cualquier máquina virtual de ubuntu cloud que hayamos usado
previamente y vamos a añadir dos discos virtuales para hacer pruebas.

# Abrimos la ventana de la máquina virtual a usar
# Nos movemos a Vista -> Detalles, y le damos al botón de 'Agregar hardware'
# Seleccionamos Almacenamiento, le damos un tamaño de 5GB y en el tipo de dispositivo seleccionamos 'dispositivo de disco'. Con estas opciones, pulsamos Finalizar., y ya tendremos nuestro disco creado.
# Repetir el paso anterior y crear otro disco de 4GB

= Paso 2: Ver discos en Linux =

Volvamos a la vista consola (Vista -> Consola) y arranquemos la máquina (Máquina virtual -> Ejecutar).

Para comprobar los discos añadidos en el paso 1 vamos a utilizar el comando lsblk, el cual nos mostrará una salida similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Aqui vemos que tenemos 3 discos:

* vda: el actual de ubuntu que añadimos al crear la máquina
* vdb: el disco que añadimos en el paso 1 de 5GB
* vdc: el disco que añadimos en el paso 1 de 4GB

También vemos que el disco vda tiene 3 particiones: vda1, vda14 y vda15

= Paso 3: Creación de particiones en Linux =

Vamos a utilizar ahora nuestro disco añadido de 5GB, en el paso anterior
deberiamos de haber identificado cual es, en mi caso /dev/vdb, aseguraros cual
es el vuestro y comenzaremos a particionar el disco:

<syntaxhighlight lang="bash">
sudo fdisk /dev/vdb
</syntaxhighlight>

Si el disco es nuevo y no ha hecho nada previamente, normalmente viene sin tabla
de particiones, así que fdisk se encarga de crear una, seguramente veamos ese
mensaje cuando hayamos ejecutado el comando anterior.
La tabla de particiones es una pequeña parte del disco que se utiliza para
alamacenar la información de las particiones, el formato y si una partición es
ejecutable o no.

Una vez hecho esto, veremos que estamos dentro de fdisk (software para
particionar un disco), y veremos que este tiene su propia linea de comando.

Ahora veremos la ayuda de fdisk y crearemos una partición de prueba de 3GB

# Introducir la letra 'm' y pulsar Intro, así obtendremos el listado de comandos posibles de fdisk.
# Introducir 'n' y pulsar Intro para crear una nueva partición. Nos preguntará varios detalles:
## Tipo de partición: pulsamos Intro y se asignará primaria por defecto.
## Número de partición: pulsamos Intro y se asignará 1 por defecto.
## Primer sector: pulsamos Intro para que se asigne por defecto.
## Último sector: vamos a crear una partición de 3GB, así que escribimos ''+3G'' y pulsamos Intro
# Ya está creada nuestra primera partición, aunque los cambios todavía no se han escrito en disco, para ello, necesitaremos aplicar estos cambios, y lo hacemos con el comando 'w' y pulsando Intro.
# Ahora si, ya tenemos nuestra partición creada. Vamos a comprobar que el cambio está hecho, usando lsblk por ejemplo, deberíamos de obtener algo similar a la siguiente:

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
└─vdb1 252:17 0 3G 0 part
vdc 252:32 0 4G 0 disk
</syntaxhighlight>

Vamos ahora a crear en el disco de 4GB (vdc en mi caso) dos particiones de 2GB cada una, y la partición de 3GB creada anteriormente, vamos a borrarla:

# sudo fdisk /dev/vdc
# comando 'n' e Intro
# Todos los datos por defecto, excepto el último sector, donde pondremos '+2G'
# Una vez creada la primera partición, antes de escribir a disco, vamos a crear la segunda partición, repetimos los pasos anteriores. Vamos a tener un problema y cuando lleguemos al último paso, nos dirá que 2GB no es posible. Si tenemos un disco de 4GB, ¿Por qué no nos permite crear dos particiones de 2GB? Exacto, por la tabla de particiones. Lo que haremos en el último paso será dejar el valor por defecto, que será todo el disco sobrante.
# Vamos a comprobar antes de escribir los cambios, que todo está bien, comando 'p' e Intro debería de mostrarnos una salida similar a:

<syntaxhighlight lang="bash">
Device Boot Start End Sectors Size Id Type
/dev/vdc1 2048 4196351 4194304 2G 83 Linux
/dev/vdc2 4196352 4196351 4194304 2G 83 Linux
</syntaxhighlight>

# Si todo está correcto, pulsamos 'w' e Intro y aplicamos los cambios
# Ahora entraremos con el disco /dev/vdb para eliminar la partición: sudo fdisk /dev/vdb
# Ahora vamos a eliminar la particion, pulsamos 'd' e Intro. Como solo tenemos una partición, nos la borra directamente, en caso de tener más de una, nos preguntaría cual queremos borrar.
# Aplicamos los cambios: 'w' e Intro
# Comprobamos que todo ha quedado a nuestro gusto con el comando lsblk

<syntaxhighlight lang="bash">
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sr0 11:0 1 1024M 0 rom
vda 252:0 0 2.2G 0 disk
├─vda1 252:1 0 2.1G 0 part /
├─vda14 252:14 0 4M 0 part
└─vda15 252:15 0 106M 0 part /boot/efi
vdb 252:16 0 5G 0 disk
vdc 252:32 0 4G 0 disk
├─vdc1 252:33 0 2G 0 part
└─vdc2 252:34 0 2G 0 part
</syntaxhighlight>

= Paso 4: Formatear partición: crear un sistema de archivos =

Hasta ahora solo hemos definido en la tabla de particiones donde comienza y
acaba cada partición, pero no podremos utilizarla hasta que no creemos un
sistema de archivos en la partición. Para crear un sistema de archivos
utilizaremos el comando 'mkfs', y tendremos varias opciones a la hora de crear
uno: ext2, ext3, ext4, btrfs, fat, ntfs, etc...

Nosotros creamos un sistema ext4 para /dev/vdc1 y uno fat para /dev/vdc2:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/vdc1
sudo mkfs -t fat /dev/vdc2
</syntaxhighlight>

Una vez hecho esto, vamos a comprobar que se han aplicado bien los cambios:

<syntaxhighlight lang="bash">
sudo file -s /dev/vdc1
sudo file -s /dev/vdc2
</syntaxhighlight>

En la salida deberíamos de obtener que tenemos un sistema de ficheros ext4 y
otro FAT.

= Paso 5: Montar y desmontar particiones en Linux =

Tras haber creado en los pasos anteriores unas particiones y formatearlas, vamos
a pasar ahora a montarlas para poderles dar uso. En linux montar una partición
significará que asignaremos una carpeta del sistema a una partición, y en ella
estará todo el contenido del disco.

== Mount y umount ==

Empezaremos utilizando los comandos mount y umount para montar y desmontar
particiones. Vamos a montar las particiones /dev/vdc1 y /dev/vdc2, la primera la
montaremos en /home/ubuntu/part1 y la segunda en /home/ubuntu/part2:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part1 # Creamos la carpeta donde vamos a montar la partición
sudo mount /dev/vdc1 /home/ubuntu/part1 # montamos la partición
</syntaxhighlight>

Lo mismo con /dev/vdc2

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/part2
sudo mount /dev/vdc2 /home/ubuntu/part2
</syntaxhighlight>

Vamos a ver el contenido de las particiones montadas:

<syntaxhighlight lang="bash">
ls /home/ubuntu/part1
ls /home/ubuntu/part2
</syntaxhighlight>

Veremos que tenemos una carpeta lost+found en el sistema ext4, la cual se
utiliza para los errores en el sistema de archivos, cuando hay un error y
encontramos un fichero sin referencia, este se añadiría dentro de esta carpeta,
y existiría la posibilidad de recuperarlo.

Ahora vamos a crear un nuevo fichero dentro de nuestra partición /dev/vdc1, la
vamos a desmontar, y vamos a montarla en otro directorio diferente:

<syntaxhighlight lang="bash">
sudo touch /home/ubuntu/part1/nuevoFichero # tenemos que crearlo con sudo porque no tenemos permisos, luego veremos esto
sudo umount /dev/vdc1
ls /home/ubuntu/part3 # el fichero ya no está, la partición fue desmontada
mkdir /home/ubuntu/part3
sudo mount /dev/vdc1 /home/ubuntu/part3
ls /home/ubuntu/part3
</syntaxhighlight>

Comprobaremos que el fichero creado en /home/ubuntu/part1 lo tenemos ahora en
/home/ubuntu/part3, ya que realmente, cuando lo guardamos, estaba en la
partición que montamos.

También podemos ver que utilizando el comando lsblk, podremos observar donde
está montada la partición.

== Montaje automático al iniciar el sistema ==

Ahora veremos como automatizar el proceso de montaje cada vez que se inicia el
sistema, ya que sería tedioso tener que montar todos las particiones cada vez
que apagamos y encendemos nuestra máquina.

El proceso de automatizado suele hacerse dentro del fichero /etc/fstab, veamos
su contenido:

<syntaxhighlight lang="bash">
cat /etc/fstab
</syntaxhighlight>

Cada fila contiene un montaje de una partición, la cual contiene:

* Identificación de la partición: en este caso se está utilizando una etiqueta de
la partición, pero podemos utilizar cualquier cosa que identifique al
dispositivo, como el uuid o la localización (/dev/vdc1)
* Punto de montaje: donde se montará el dispositivo
* Sistema de archivos: ext4, fat32, reiserfs
* Opciones: aquí pondremos las diferentes opciones de montaje, como por ejemplo
montar para solo lectura, dar permisos a un usuario para utilizar la
partición, etc. Hay que tener en cuenta que cada sistema tiene sus opciones.
* backup: si está a cero, no haremos backup
* chequeo: si está a cero no se hace chequeo al iniciar

Vamos a añadir unas líneas para montar automáticamente las particiones al
iniciar:

Utilizando el editor que prefieras, añadir lo siguiente en el fichero
/etc/fstab. Importante hacerlo con sudo para que nos permita escribir en el
fichero:

<syntaxhighlight lang="bash">
/dev/vdc1 /home/ubuntu/part1 ext4 rw,user,exec 0 0
/dev/vdc2 /home/ubuntu/part2 vfat umask=000 0 0
</syntaxhighlight>

Una vez guardado los cambios, vamos a aplicarlos sin reiniciar, para comprobar
que funciona correctamente:

<syntaxhighlight lang="bash">
mount -a # aplica los cambios de fstab sin necesidad de reiniciar
lsblk # comprobar que está bien montado
</syntaxhighlight>

Ahora vamos a comprobar si nuestro usuario tiene permisos para escribir:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
touch /home/ubuntu/part2
</syntaxhighlight>

En el primero no nos dejará y en el segundo no tendremos problemas. Esto
funciona así porque los sistemas ext4, para poder tener permisos de escritura,
tenemos que darlo sobre el sistema de ficheros, mientras que el sistema fat,
tiene la opción umask que ya hace el trabajo. Para tener permisos de escritura
con nuestro usuario en la partición, tendremos que darle permiso a la partición
para poder escribir en ella, por ejemplo, utilizando el comando chown:

<syntaxhighlight lang="bash">
sudo chown ubuntu /home/ubuntu/part1
</syntaxhighlight>

Si probamos ahora, podremos escribir en la partición de ext4, y al haber dado
permisos, ya nos funcionará siempre:

<syntaxhighlight lang="bash">
touch /home/ubuntu/part1
</syntaxhighlight>

Ahora, vamos a desmontar todo y a reiniciar la máquina para comprobar que está todo funciona.

<syntaxhighlight lang="bash">
sudo umount /dev/vdc1
sudo umount /home/ubuntu/part2 # Es otra forma de desmontar, dando el punto de montaje
lsblk # comprobamos que no estén montadas
</syntaxhighlight>

Reiniciamos la máquina (Máquina virtual -> Apagar -> Reiniciar) y comprobamos:

<syntaxhighlight lang="bash">
lsblk
</syntaxhighlight>

= Paso 6: Creación de sistemas de ficheros de red NFS =

En este paso, vamos a crear un sistema de ficheros de red compartido a través de NFS.
Para ello vamos a necesitar crear un servidor donde iniciemos este sistema al que se conectarán los clientes.

== Paso 6.1: Instalación y configuración del servidor de NFS ==

Para configurar el servidor, necesitaremos abrir una de las máquinas virtuales
creadas anteriormente e instalar la herramienta necesaria:

<syntaxhighlight lang="bash">
sudo apt nfs-kernel-server -y
</syntaxhighlight>

Una vez hecho esto, vamos a crear un directorio el cual será el que
compartiremos, por ejemplo:

<syntaxhighlight lang="bash">
sudo mkdir /home/shared
</syntaxhighlight>

Ahora vamos a editar el servidor nfs, para ello, tendremos que editar el fichero
/etc/exports, pero antes, veremos cual es nuestra IP, que nos hará falta:

<syntaxhighlight lang="bash">
ip address
</syntaxhighlight>

La salida de este comando será similar a la siguiente:

<syntaxhighlight lang="bash">
enp1s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 192.168.0.167 netmask 255.255.255.0 broadcast 192.168.0.255
inet6 fe80::ea6a:64ff:fe66:66a0 prefixlen 64 scopeid 0x20<link>
ether e8:6a:64:66:66:a0 txqueuelen 1000 (Ethernet)
RX packets 3821 bytes 2152349 (2.0 MiB)
RX errors 0 dropped 268 overruns 0 frame 0
TX packets 3386 bytes 266855 (260.6 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 16 memory 0xa4300000-a4320000

lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1000 (Local Loopback)
RX packets 220506 bytes 16017419 (15.2 MiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 220506 bytes 16017419 (15.2 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
</syntaxhighlight>

Nos fijamos donde pone inet, y miramos la red que NO sea 'lo', en este caso,
la IP buscada sería 192.168.0.167. Ahora si, vamos a editar el /etc/exports:

<syntaxhighlight lang="bash">
/home/shared 192.168.0.*(rw,sync,subtree_check)
</syntaxhighlight>

Explicamos los parámetros:

# Carpeta a compartir
# Le damos la IP con un * al final para poder permitir a todas las redes poder
acceder, desde la 192.168.0.0 a la 192.168.0.255
# Aquí tenemos muchas opciones disponibles:
## ro: solo lectura
## rw: lectura y escritura
## subtree_check: comprueba subdirectorios para compartirlos también
## sync: forzar a hacer las operaciones de forma síncrona (los datos se escriben inmediatamente en el disco del servidor NFS).

Una vez modificado el fichero, vamos a reiniciar el servicio NFS:

<syntaxhighlight lang="bash">
sudo service nfs-kernel-server restart
</syntaxhighlight>

Una vez hecho esto, nuestro servidor NFS ya está configurado.

== Paso 6.2: Instalación y configuración del cliente de NFS ==

Para acceder al sistema de ficheros NFS creado en el paso anterior, tendremos
que configurar el cliente para montar el sistema de ficheros compartido. El
cliente lo montaremos en otra máquina virtual diferente.

Creamos y abrimos esta nueva máquina e instalamos una herramienta para poder
montar el NFS en nuestra máquina:

<syntaxhighlight lang="bash">
sudo apt install nfs-common
</syntaxhighlight>

Con esto ya podremos montar en nuestro cliente el NFS. Recordemos la IP que
obtuvimos en el paso anterior cuando montamos el servidor, y hacemos lo
siguiente:

<syntaxhighlight lang="bash">
sudo mount 192.168.0.167:/home/shared /mnt
</syntaxhighlight>

Ya tenemos nuestro sistema de ficheros compartidos por red montado, vamos a
probar que todo funciona.

1. En la máquina donde instalamos el servidor de NFS, vamos a crear una carpeta
y un fichero dentro de la carpeta compartida, para ellos necesitaremos darle
permisos a nuestro usuario previamente:

<syntaxhighlight lang="bash">
sudo chown -R ubuntu /home/shared
mkdir /home/shared/carpeta
touch /home/shared/carpeta/fichero
</syntaxhighlight>

2. Vamos a comprobar en el cliente, que estos ficheros se están mostrando:

<syntaxhighlight lang="bash">
ls /mnt
ls /mnt/carpeta
</syntaxhighlight>

3. Ahora lo hacemos al contrario, escribiremos desde el cliente, y vamos a verlo en el servidor:

<syntaxhighlight lang="bash">
mkdir /mnt/carpeta2
touch /mnt/carpeta2/fichero
</syntaxhighlight>

4. Entramos en el servidor y comprobamos:

<syntaxhighlight lang="bash">
ls /home/shared
ls /home/shared/carpeta2
</syntaxhighlight>

= Paso 7: Creación de un RAID =

En este apartado vamos a configurar un RAID 1 (espejo) que nos permite aumentar la fiabilidad. La idea es que si uno de los discos del RAID deja de funcionar, los datos en el sistema de fichero siguen estando disponibles con lo que disponemos de algo de tiempo para reemplazar el disco defectuoso.

== Paso 7.1: Añadir discos a la máquina virtual ==

Como explicamos en el Paso 1, vamos a añadir a una máquina virtual 2 discos duros de 5GB cada uno.

== Paso 7.2: Instalación de la herramienta de mdadm ==

Por defecto, esta herramienta viene instalada en el ubuntu cloud server, pero en
el caso de utilizar otra distribución diferente, necesitaremos instalarla:

<syntaxhighlight lang="bash">
sudo apt install mdadm
</syntaxhighlight>

== Paso 7.3: Utilización de la herramienta de mdadm ==

Empezamos escribiendo el comando, y luego pasamos a explicar los detalles:

<syntaxhighlight lang="bash">
sudo mdadm --create --verbose /dev/md0 --level=1 --raid-devices=2 /dev/vdb1 /dev/vdc1
</syntaxhighlight>

Explicamos los parámetros:

# --create: para crear el raid
# --verbose: nos muestra más información del proceso
# /dev/md0: El nombre del nuevo raid, normalmente se utiliza md0
# --level=1: crea un raid 1 que es el que queremos
# --raid-devices=2: cantidad de dispositivos que vamos a utilizar, 2 en nuestro caso
# /dev/vdb1: Nombre de la partición 1
# /dev/vdc1: Nombre de la partición 2

Una vez ejecutado el comando, creará el RAID 1, pasemos ahora a ver los
detalles:

<syntaxhighlight lang="bash">
sudo mdadm --detail /dev/md0
</syntaxhighlight>

Esto nos mostrará la información del RAID, lo que a nosotros nos interesa son
las últimas líneas:

<syntaxhighlight lang="bash">
Name : ubuntu:0 (local to host ubuntu)
UUID : e40ba520:5ed1bd37:5c818550:03a18368
Events : 17

Number Major Minor RaidDevice State
0 252 17 0 active sync /dev/vdb1
1 252 33 1 active sync /dev/vdc1
</syntaxhighlight>

Aqui vemos el UUID de nuestro RAID, y también veremos en las dos última líneas,
las dos particiones, las cuales están marcadas con active sync, esto quiere
decir que están activos y sincronizados. Puede que si hacemos muy rápido este
comando, muestre algo diferente porque tarda un poco en sincronizar la primera
vez, pero pronto estará.

== Paso 7.5: Guardar la configuración del RAID ==

Vamos a modificar la configuración, tendremos que editar el
fichero /etc/mdadm/mdadm.conf y debajo de la línea que pone '# definitions of
existing MD arrays', añadir lo siguiente:

<syntaxhighlight lang="bash">
ARRAY /dev/md0 UUID=e40ba520:5ed1bd37:5c818550:03a18368
</syntaxhighlight>

Recuerda que el UUID lo puedes consultar con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Busca el campo UUID.

Tras actualizar /etc/mdadm/mdadm.conf, tienes que invocar la siguiente orden:

<syntaxhighlight lang="bash">
update-initramfs -u
</syntaxhighlight>

Esto asegura que en el próximo arranque el RAID usa la unidad /dev/md0.

== Paso 7.6: Particionar y formatear el RAID ==

Como explicamos en los Pasos 2, 3 y 4, vamos a particionar el disco RAID:

<syntaxhighlight lang="bash">
lsblk # comprobamos los dicos, en mi caso sería md0
sudo fdisk /dev/md0
</syntaxhighlight>

Ahora vamos a formatear la partición:

<syntaxhighlight lang="bash">
sudo mkfs -t ext4 /dev/md0p1
</syntaxhighlight>

== Paso 7.7: Montar el RAID ==

Como previamente hemos hecho, crearemos una carpeta donde montar el RAID y lo
montaremos usando el comando mount:

<syntaxhighlight lang="bash">
mkdir /home/ubuntu/datos
sudo mount /dev/md0p1 /home/ubuntu/datos
sudo chown -R ubuntu /home/ubuntu/datos
</syntaxhighlight>

Así ya tenemos nuestro RAID montado y podemos utilizarlo, vamos a probar a
escribir en él.

<syntaxhighlight lang="bash">
touch /home/ubuntu/datos/fichero
</syntaxhighlight>

Esto está funcionando, pero como comentamos en uno de los pasos previos, el
comando mount solo montará el raid temporalmente, para automatizar este montado
al arrancar, tendremos que añadir la siguiente línea a /etc/fstab:

<syntaxhighlight lang="bash">
/dev/md0p1 /home/ubuntu/datos ext4 defaults
</syntaxhighlight>

== Paso 7.8: Comprobar tolerancia a fallos ==

Vamos a probar que sin un disco duro, todo sigue funcionando bien, ya que al
tener un RAID 1 y tener los datos en espejo, no debería de haber problemas.

La siguiente orden marca el disco /dev/sdb1 como dañado:

<syntaxhighlight lang="bash">
mdadm --fail /dev/md0 /dev/sdb1
</syntaxhighlight>

Podemos ver con la siguiente orden que el disco aparece como ''faulty'':

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Sin embargo, podemos ver que el sistema de ficheros sigue montado y el contenido sigue estando disponible.

<syntaxhighlight lang="bash">
ls /home/ubuntu/datos/
</syntaxhighlight>

Podéis retirar definitivamente el disco defectuoso con la orden:

<syntaxhighlight lang="bash">
mdadm --remove /dev/md0 /dev/sdb1
</syntaxhighlight>

Para volver a incluirlo en el RAID:

<syntaxhighlight lang="bash">
mdadm --add /dev/md0 /dev/sdb1
</syntaxhighlight>

Podéis consultar que está sincronizando con la orden:

<syntaxhighlight lang="bash">
mdadm --detail /dev/md0
</syntaxhighlight>

Que mostrará el disco /dev/sdb1 en estado ''spare rebuilding'' y mostrará el porcentaje de sincronización.

= Paso 8: Gestión volúmenes (Logic Volume Manager, LVM) =

Logic Volume Manager (LVM) es una capa de software que permite crear volúmenes lógicos y mapearlos de manera sencilla sobre dispositivos físicos.

La instalación de LVM es sencilla mediante la orden:

sudo apt-get install lvm2

La gestión de LVM se basa en tres conceptos básicos:

* Volúmenes físicos (PV): Representa una unidad de almacenamiento que aprovisiona espacio de almacenamiento para el volumen lógico que vamos a crear.
* Grupo volumen (VG): Representa un almacén de espacio para LVM. Un VG estará compuesto por varios PV, pudiendo tener tantos VG como sean necesarios.
* Volumen lógico (LV): Representan unidades lógicas creadas a partir de VG creado previamente. Se podrán crear tantos LV como sean necesarios para un VG. La creación de un LVM genera un archivo especial en /dev, con la forma /dev/nombre_del_grupo/nombre_volumne_logico. El mapeo de espacio desde un LV hasta un PV es configurable pudiendo ser: Lineal, RAID, Cache, ...

== Paso 8.1: Creación de volumen físico LVM (PV) ==

Para listar las unidades de almacenamiento disponibles en el sistema, empleamos la siguiente orden:

lsblk

En virtualbox podemos crear nuevas unidades almacenamiento y añadirlas a la máquina virtual.

Para crear un volumen físico en la unidad /dev/sdb, empleamos la orden:

pvcreate /dev/sdb

Recuerde que la unidad /dev/sdb tiene que estar en desuso.

Para ver los volúmenes físicos existentes, empleamos la orden:

pvscan

Para obtener más información:

pvdisplay

Para eliminar un PV, por ejemplo /dev/sdb:

pvremove /dev/sdb

== Paso 8.2: Creación de grupo de volumenes LVM (VG) ==

Para crear un grupo, empleamos el comando vgcreate:

vgcreate vg_prueba /dev/sdb /dev/sdc

Esto añade al grupo 'vg_prueba' los volúmenes sdb y sdc, haciendo que la capacidad del grupo sea la capacidad agregada de los PV añadidos.

Para eliminar un grupo vgremove:

vgremove vg_prueba

Para extender un grupo creado (por ejemplo, vg_prueba) con más PV (por ejemplo /dev/sde) usamos el comando vgextend:

vgextend vg_prueba /dev/sde

Para reducir la capacidad de un grupo creado (por ejemplo, vg_prueba) basta con usar el comando vgreduce indicando la unidad (PV) a quitar, por ejemplo /dev/sde:

vgreduce vg_prueba /dev/sde

Para mostrar todos los grupos de volumenes existentes

vgscan

== Paso 8.3: Creación de volumen lógico (LV) ==

Para crear un volúmen lógico, empleamos la orden:

lvcreate --name volumen1 --size 100MB vg_prueba

A partir de este momento hay una unidad que se presenta como ''/dev/mapper/vg_prueba-volumen1''.

Podemos ahora formatear el volumen lógico:

mkfs.ext4 /dev/vg_prueba/volumen1

y montarlo para almacenar información:

mount /dev/vg_prueba/volumen1 /mnt

Puedes extender un volumen lógico en 1 Gbyte de más:

lvextend --size +1GB /dev/vg_prueba/volumen1

Justo después tienes que redimensionar el sistema de ficheros:

resize2fs /dev/vg_prueba/volumen1

Puedes comprobar con:

df -h

que el sistema de ficheros en ''volumen1'' ocupa ahora todo el volumen lógico.

Reducir el tamaño de un volumen lógico es un poco más complicado, ¡podrían perder datos si no se realiza correctamente!

Primero, desmontamos el volumen:

umount /mnt/volumen1

reducir el tamaño del sistema de ficheros, comprobamos la integridad del sistema de ficheros:

e2fsck -f /dev/vg_prueba/volumen1

Y lo redimensionamos (reducimos de tamaño):

resize2fs /dev/vg_prueba/volumen1 500M

Ahora ya, por último lugar, puedes reducir el tamaño del volumen:

lvreduce --size 500M /dev/vg_prueba/volumen1

Para comprobar que hay ido todo bien, vuelve a redimensionar el sistema de ficheros para que ocupe todo el espacio disponible.

resize2fs /dev/vg_prueba/volumen1

Y puedes volver a montar el sistema de ficheros:

mount /dev/vg_prueba/volumen1 /mnt/volumen1

con

df -h

para comprar el nuevo tamaño disponible de sólo 500 MBytes.

Administración básica

2019-11-18T16:07:10Z

Artrodase: /* Paso 9: Administración remota con ssh */

Para realizar esta práctica utilizaremos una de las máquinas virtuales que generamos en la práctica anterior.

En esta práctica aprenderemos a utilizar el interprete de ordenes (también conocido como ''[https://www.traficantes.net/sites/default/files/pdfs/En%20el%20principio%20fue...-TdS.pdf línea de comandos]'') y a aprender nociones básicas de administración de sistemas Linux.

= Paso 0: Breve introducción al sistema Linux =

== Estructura básica del sistema de archivos ==

En un sistema Linux, todas las carpetas y ficheros en el sistema de fichero pende de la carpeta raíz que se representa con la /.

/
├── bin
├── usr
│   ├── local
│   ├── bin
│   └── ...
├── dev
│   ├── sda
│   ├── sda1
│   └── ...
├── home
│   ├── practica
│   │   ├── tema1.pdf
│   │   ├── boletin1.pdf
│   │   └── ...
│   ├── profesor
│   └── ...
└── etc
├── firefox
├── libvirt
├── ...
└── ...

Como puedes observar, el sistema de fichero emplea una estructura de árbol.

== Nociones básicas ==

·Aplicaciones con nombres compuestos: usar guion entre palabras

·Nombres con espacios en blanco: Escribir entre comillas dobles

·Espacios en blanco para separar ordenes (ej: instalar varios paquetes )

·Formato general de una orden: comando [-opciones] [argumentos]

·'''IMPORTANTE''': Diferencia entre mayúsculas y minúsculas

== Carpetas . y .. ==

Toda carpeta en un sistema Linux dispone de dos pseudocarpetas, la '''.''' y la '''..'':

* La pseudocarpeta '''..''' hace referencia a la carpeta padre que contiene a esta carpeta.
* La pseudocarpeta '''.''' hace referencia a la carpeta actual, es por tanto una autoreferencia.

En el caso de la carpeta raíz, la pseudocarpeta '''.''' y '''..''' hacen referencia a la propia carpeta raíz, se trata, por tanto de una excepción.

== Directorio de trabajo actual y la orden cd ==

Cada interprete de ordenes dispone de una ''carpeta de trabajo actual'' ('''c'''urrent '''w''orking '''d''irectory, en inglés). La carpeta de trabajo actual se puede modificar con la orden '''cd''' ('''c'''hange '''d'''irectory, en inglés).

Por ejemplo:

<syntaxhighlight lang="bash">
$ cd ..
</syntaxhighlight>

Nos situaría en la carpeta padre, empleando una ruta relativa.

Si volvemos a escribir desde /home " cd .. " nos lleva a '''/$'''

Para situarnos en el raíz, podemos emplear una ruta absoluta:

<syntaxhighlight lang="bash">
$ cd /
</syntaxhighlight>

En caso de que queramos volver a la carpeta de usuario, bastaría con invocar a '''cd''' sin más o ''' cd ~ '''

<syntaxhighlight lang="bash">
$ cd
</syntaxhighlight>

'''MUY IMPORTANTE''': No es lo mismo cd.. que ''' cd .. ''', es necesario el espacio después del cd.

== Rutas absolutas, rutas relativas ==

Para hacer referencia a un fichero o una carpeta se usan ruta absolutas o rutas relativas.

Las rutas absolutas siempre empieza por /, de manera que toman como punto de referencia la carpeta raíz (/). Por ejemplo, una ruta absoluta a la carpeta '''prueba''' que está almacenada en la carpeta del usuario '''ubuntu''' es '/home/ubuntu/prueba/'.

Las ruta relativa toma como referencia la carpeta de trabajo actual. Para averiguar la carpeta de trabajo actual disponemos de la orden '''pwd'''.

<syntaxhighlight lang="bash">
$ pwd
/home/ubuntu
</syntaxhighlight>

En base a la carpeta de trabajo actual, empleando la pseudocarpeta '''..''', se puede construir rutas relativas. Por ejemplo, para referenciar un fichero '''fichero.txt''' en la carpeta temporal, podemos emplear la ruta relativa '''../../tmp/fichero.txt'''.

Aunque probablemente sea más cómodo emplear una ruta absoluta en este caso, que sería '''/tmp/fichero.txt'''.

== Intérprete de órdenes ==

El intérprete de órdenes es un lanzador de aplicaciones textual que emplea el teclado como dispositivo de entrada de datos. Mediante el teclado, se escribe el nombre del programa que se quiere lanzar y al pulsa la tecla ''intro'' el intérprete de ordenes ejecutara dicho programa. Por defecto, el intérprete de ordenes que emplea Ubuntu por defecto es '''bash'''.

== man: ver la página de manual de una orden ==

La orden '''man''' te será útil para ver las páginas de manual.

Su estructura básica es:

<syntaxhighlight lang="bash">
man <comando>
</syntaxhighlight>

Aunque también se utiliza con la opción ''' -a ''' de All, que también muestra las entradas comenzadas por '''.''':

<syntaxhighlight lang="bash">
man -a <comando>
</syntaxhighlight>

Este programa toma como entrada el nombre de la orden de la que quieres consultar su página de manual, por ejemplo:

<syntaxhighlight lang="bash">
man ls
</syntaxhighlight>

Nos da información del manual de la orden '''ls'''.

Para salir de la página de manual, pulsa la tecla '''q''' (la primera letra de la palabra '''quit''', en inglés).

quit = salir

Normalmente, los programas ofrecen opciones de ayuda, como '''--help'''.

<syntaxhighlight lang="bash">
man --help
</syntaxhighlight>

También se puede emplear la versión compacta a la hora de especificar opciones.

<syntaxhighlight lang="bash">
man -h
</syntaxhighlight>

En general, todas las ordenes suelen ofrecer una opción de ayuda.

= Paso 1: Operaciones básicas con el sistema de ficheros =

== ls ==

Lista los ficheros y carpetas. Si no se especifica nada, muestra los ficheros y carpetas que contiene la carpeta de trabajo actual.

<syntaxhighlight lang="bash">
ls
</syntaxhighlight>

Si se especifica una ruta, muestra las carpetas y ficheros contenidos en dicha ruta, por ejemplo:

<syntaxhighlight lang="bash">
$ ls /
bin boot data dev etc home initrd.img initrd.img.old lib lib64 lost+found media mnt opt proc root run sbin snap srv sys tmp usr var vmlinuz vmlinuz.old
</syntaxhighlight>

Al emplear '''/''' como ruta absoluta, muestra el contenido de la carpeta raíz.

Las opciones más usadas de este programa suelen ser:

* -a: muestra los ficheros y carpetas ''ocultos''. En Linux, cualquier fichero o carpeta cuyo nombre empiece por . se considera ''oculto''. Esto incluye también en el listado las pseudocarpetas . y ..

* -l: se muestra en lista y aporta datos como la fecha de última modificación, propietario, grupo, tamaño en bytes y nombre:

<syntaxhighlight lang="bash">
$ ls -a

. .. .bash_history .bash_logout .bashrc .profile .ssh
</syntaxhighlight>

Ambas opciones se puede combinar:

<syntaxhighlight lang="bash">
$ ls -la /

total 92
drwxr-xr-x 24 root root 4096 Aug 28 09:50 .
drwxr-xr-x 24 root root 4096 Aug 28 09:50 ..
drwxr-xr-x 2 root root 4096 Aug 22 12:37 bin
drwxr-xr-x 4 root root 4096 Aug 22 12:37 boot
drwx------ 3 root root 4096 Aug 28 09:50 data
drwxr-xr-x 18 root root 3780 Aug 28 09:46 dev
[...]

</syntaxhighlight>

Otras opciones útiles son:

* -s : muestra el tamaño en bloques de cada archivo

* -t : aporta el día y la hora de modificación

* -R : lista también las subcarpetas

* --color : muestra el contenido coloreado

Los '''permisos''' se emplean en base a tres capacidades:

* Lectura, que se codifica con '''r''' (read, en inglés).
* Escritura, que se codifica con '''w''' (write, en inglés).
* Ejecutación, que se codifica con '''x''' (execute, en inglés).

La primera columna muestra los permisos que codifican:

* Tipo de entrada: '''d''' indica ''directorio'' (''carpeta'').
* Permisos del propietario, primera terna de rwx
* Permisos del grupo, segunda terna de rwx
* Permisos para el resto del mundo, tercera terna de rwx.

A continuación, aparecen el propietario y el grupo, seguidos de la fecha de última modificación y el nombre del fichero o carpeta.

La ayuda ( help ) en ls solo funciona con ''' ls --help ''' no con ls -h

== mkdir ==

Crea un nuevo directorio.

<syntaxhighlight lang="bash">
$ mkdir test
</syntaxhighlight>

Crea una carpeta test en el directorio actual.

Comprobemos que se ha creado bien:

<syntaxhighlight lang="bash">
$ ls
test
</syntaxhighlight>

Con la opción '''-p''', permite crear sucesivas carpetas anidadas de una sola vez, por ejemplo:

<syntaxhighlight lang="bash">
$ mkdir -p a/b/c
</syntaxhighlight>

Que crea la siguiente estructura de carpetas.

a
└── b
└── c

== touch ==

Crea un nuevo fichero vacío (sin contenido) con el nombre que especifiquemos.

<syntaxhighlight lang="bash">
$ touch file.txt
</syntaxhighlight>

Comprobamos que el fichero se ha creado correctamente.

<syntaxhighlight lang="bash">
$ ls
file.txt
</syntaxhighlight>

== cp ==

Copia un fichero o directorio.

<syntaxhighlight lang="bash">
$ cp file.txt file_copy.txt
</syntaxhighlight>

Para copiar una carpeta y su contenido tenemos que usar la opción -r (recursivo).

<syntaxhighlight lang="bash">
$ cp -r test test_copy
</syntaxhighlight>

* Comprobamos el resultado con la orden '''ls'''.

* Si nos encontramos en la carpeta destino, la estructura sería la siguiente:

<syntaxhighlight lang="bash">
$ cp <nombre ruta origen> <nombre archivo>
</syntaxhighlight>

== mv ==

Mueve fichero o carpeta.

<syntaxhighlight lang="bash">
mv file_copy.txt file2.txt
</syntaxhighlight>

También se emplea para renombrar.

<syntaxhighlight lang="bash">
mv test_copy test_copy2
</syntaxhighlight>

== rm ==

* Borra un fichero o carpeta vacía:
<syntaxhighlight lang="bash">
rm <nombre>
</syntaxhighlight>

* Para borrar una carpeta no vacía y su contenido:
<syntaxhighlight lang="bash">
rm -r <nombre>
</syntaxhighlight>

'''IMPORTANTE''': No hacer jamás ''' rm -r * '''

* EJERCICIOS:

# Crear la siguiente estructura dentro del directorio /tmp (usar los comandos mkdir, touch y cp):

/tmp
├── carpeta1
├── carpeta2
│   ├── fichero1.txt
│   └── fichero2.md
└── carpeta3
   ├── fichero1.txt
   └── fichero2.md

# Basándonos en el ejercicio anterior, cambiar la estructura a la siguiente (usar comandos mv y rm):

/tmp
└── carpeta
   ├── fichero1.txt
└── fichero2.md

= Paso 2: Impresión por pantalla y redirección de salida =

== echo ==

Sirve para imprimir una línea de texto por pantalla o variables de entorno. Además, nos permite escribir en ficheros.

<syntaxhighlight lang="bash">
echo <opción> <texto>
</syntaxhighlight>

* Opciones curiosas:

-e <PALABRA \bPALABRA> Se eliminan los espacios entre las palabras

-e <PALABRA \nPALABRA> Se añaden saltos de línea

Una variable de entorno es una variable editada con algún valor, por defecto existen algunas creadas, como por ejemplo la variable HOME, que contiene el directorio del usuario:

<syntaxhighlight lang="bash">
echo $HOME
</syntaxhighlight>

Aprovecharemos y crearemos una variable nosotros:

<syntaxhighlight lang="bash">
ME="my name"
</syntaxhighlight>

Comprobamos:

<syntaxhighlight lang="bash">
echo $ME
</syntaxhighlight>

== Redirección de salida ==

> y >> sirve para redirigir una salida. Por ejemplo, utilizando el comando echo,
podemos enviar un texto dentro de un fichero:

<syntaxhighlight lang="bash">
echo "Esto es una prueba" > file.txt
</syntaxhighlight>

La diferencia entre > y >> es que > sobrescribe lo que haya en el fichero y
añade el contenido, y >> no sobrescribe, solo añade el nuevo contenido.

Hagamos la prueba:

<syntaxhighlight lang="bash">
echo "Esto es una prueba" > file.txt
echo "Esto es una prueba2" > file.txt
echo "Esto es una prueba" >> file2.txt
echo "Esto es una prueba2" >> file2.txt
</syntaxhighlight>

En cualquier caso, si el fichero no existe, se crea.

= Paso 3: Manejo de ficheros y carpetas avanzado =

== cat ==

* Muestra el contenido de un fichero:

<syntaxhighlight lang="bash">
cat file.txt
cat <fichero1> <fichero2>
</syntaxhighlight>

* Crea un fichero:

<syntaxhighlight lang="bash">
cat ><nombre archivo>
</syntaxhighlight>

GUARDAR FICHERO: Pulsamos ENTER y luego CTRL + D

* Añadir más lineas al fichero:

<syntaxhighlight lang="bash">
cat >><nombre fichero>
</syntaxhighlight>

* Concatenar ficheros:

<syntaxhighlight lang="bash">
cat <fichero1> <fichero2> > <fichero3>
</syntaxhighlight>

* Editar ficheros:

<syntaxhighlight lang="bash">
cat

hola
que pasa

cat > <fichero4>
</syntaxhighlight>

== grep ==

Sirve para localizar coincidencias de un cierto patrón en ficheros y muestra la coincidencia, en caso de encontrarla, por pantalla.

<syntaxhighlight lang="bash">
grep <opción> <patrón> <archivos donde buscar>
</syntaxhighlight>
Por ejemplo, para buscar el patrón ''prueba'' en el fichero ''fichero.txt''.

<syntaxhighlight lang="bash">
$ grep -n prueba fichero.txt
1:Esto es una prueba
</syntaxhighlight>

* Principales opciones del comando:

-c : Escribe el número de líneas encontradas.

-i : No distingue entre mayúsculas y minúsculas.

-l : Muestra los nombres de los ficheros que contienen los caracteres buscados.

-n : Cada línea es precedida por su número en el fichero.

-s : No se muestran los mensajes que indican que no se puede abrir un fichero.

-v : Muestra sólo las líneas que no cumplen la condición.

== wc ==

Sirve para contar el número de palabras, caracteres, líneas o bytes que contiene un fichero.

Las opciones más utilizadas son:

* -l: muestra el número de líneas que contiene el fichero.
* -w: muestra el número de palabras.
* -m: muestra el número de caracteres
* -c: muestra el número de bytes

Probemos y contemos todo en el fichero file2.txt:

<syntaxhighlight lang="bash">
wc -l file2.txt
wc -w file2.txt
wc -m file2.txt
wc -c file2.txt
</syntaxhighlight>

Podemos contar más de un fichero a la vez:

<syntaxhighlight lang="bash">
wc -l file.txt file2.txt
</syntaxhighlight>

Nos mostrará el conteo de cada fichero y el total.

== Tubería (|) ==

La tubería nos servirá para conectar varios comandos al mismo tiempo, veamos
unos ejemplos, que siempre se entiende mejor:

<syntaxhighlight lang="bash">
cat file2.txt | grep prueba
grep -nr prueba file2.txt | wc -l
</syntaxhighlight>

En el primer ejemplo, mostramos el contenido de file2.txt, y esta salida se la
pasamos al comando grep, el cual busca las líneas que contengan prueba.

En el segundo, buscamos todas las líneas que contengan la palabra prueba, y esta
salida se la pasamos al comando wc, el cual cuenta las líneas de la salida del
comando grep.

== Redirecciones ==

Vamos a ver unos conceptos antes de seguir:

* Entrada estándar: representa los datos que necesita una aplicación para funcionar, como por ejemplo un archivo de datos o información ingresada desde la terminal y es representado en la terminal como el tipo 0.
* Salida estándar: es la vía que utilizan las aplicaciones para mostrarte información, allí podemos ver el progreso o simplemente los mensajes que la aplicación quiera darte en determinado momento y es representado en la terminal como el tipo 1.
* Error estándar: es la forma en que los programas te informan sobre los problemas que pueden encontrarse al momento de la ejecución y es representado en la terminal como el tipo 2.

Las redirecciones nos sirven para mover la información de un tipo a otro.

Ya vimos previamente el uso de > y >>, y también el |, veamos algunas más:

* comando < fichero: Toma la entrada de fichero
* comando 2> fichero: Envía la salida de error de comando a fichero
* comando 2>&1: Envía la salida de error a la salida estándar
* comando &> fichero: Envía la salida estándar y de error a fichero; equivale a comando > fichero 2>&1

= Paso 4: Usuarios y grupos =

== whoami ==

Sirve para obtener el usuario actual.

<syntaxhighlight lang="bash">
whoami
</syntaxhighlight>

Lo más seguro es que nos aparezca ubuntu.

== who ==

Es para saber quien está ahora mismo en la máquina conectado.

<syntaxhighlight lang="bash">
who
</syntaxhighlight>

Seguramente solo estemos nosotros:

<syntaxhighlight lang="bash">
ubuntu pts/0 2019-08-28 13:51 (192.168.122.1)
</syntaxhighlight>

== su y sudo ==

su (substitute user): sirve para cambiar de usuario. Por ejemplo:

<syntaxhighlight lang="bash">
su root
</syntaxhighlight>

Aquí nos pedirá la contraseña del usuario al que queramos cambiar.

sudo (super user do): no todas las distribuciones lo integran, porque es menos
seguro que su, este comando nos permite ejecutar un comando siendo otro usuario,
por defecto, si no le damos usuario, lo hará con el usuario root. Si sudo nos
pide contraseña, nos pide la contraseña del usuario, ya que el usuario es que el
tiene permisos para usar sudo o no.

<syntaxhighlight lang="bash">
sudo ls -a /root
</syntaxhighlight>

Si tuviéramos por ejemplo un usuario 'practica' y quisíeramos ejecutar un
comando en su nombre:

<syntaxhighlight lang="bash">
sudo -u practica ls
</syntaxhighlight>

== adduser y useradd ==

Ambos comandos sirven para crear un nuevo usuario, pero tienen sus diferencias.

useradd es un comando del sistema, y adduser es un script escrito en perl que
utiliza el comando useradd. La diferencia así de primeras es que adduser nos
crear el directorio /home/usuario y useradd necesita la opción -m para hacer lo
mismo. Se puede utilizar el que se quiera, aunque es más recomendable useradd,
ya que funcionará igual en todas las distribuciones.

Vamos a añadir un usuario practica con su directorio en /home (notemos que
necesitamos permisos de super usuario para realizar esta tarea):

<syntaxhighlight lang="bash">
sudo useradd -m practica
</syntaxhighlight>

Vamos a comprobar que el directorio home está creado y que el usuario practica
funciona:

<syntaxhighlight lang="bash">
ls /home # veremos el directorio practica
sudo -u practica whoami # nos dirá que somo el usuario practica
</syntaxhighlight>

== passwd ==

Sirve para modificar la contraseña de un usuario, por ejemplo, vamos a modificar
la contraseña del usuario que hemos creado previamente:

<syntaxhighlight lang="bash">
sudo passwd practica
</syntaxhighlight>

Nos preguntará dos veces la contraseña, y ya la tendremos actualizadas. Vamos
ahora a probar ahora el comando su para cambiar de usuario:

<syntaxhighlight lang="bash">
su practica
whoami
</syntaxhighlight>

Veremos que hemos cambiado de usuario, para cerrar este usuario, escribimos
'exit' o pulsamos 'CTLR + D'

== deluser y userdel ==

Ambos sirven para borrar un usuario, similar a adduser y useradd, userdel es el
comando y deluser el script.

Vamos a borrar el usuario que hemos creado, incluyendo el borrado de su /home
(opción -r):

<syntaxhighlight lang="bash">
userdel -r practica
</syntaxhighlight>

Comprobemos que ya no tenemos usuario ni /home:

<syntaxhighlight lang="bash">
ls /home
sudo -u practica whoami
</syntaxhighlight>

== addgroup y groupadd ==

Ambos sirven para crear un grupo. Los grupos sirven para agrupar a los usuarios
y que estos tengan unos mismos permisos. Por ejemplo, cuando instalamos algunas
herramientas como por ejemplo docker, este crea el grupo docker automáticamente
para que fácilmente podamos añadir a un usuario al grupo, y este tenga los
permisos para trabajar con dicha herramienta.

Vamos a crear un nuevo grupo, vamos a llamarle invitado:

<syntaxhighlight lang="bash">
sudo groupadd invitado
</syntaxhighlight>

== usermod y groups ==

usermod es utilizado para asignar un grupo a un usuario.

groups es utilizado para ver los grupos a los que pertenece un usuario.

Vamos a añadir a un usuario practica, lo vamos a añadir al grupo invitado y
veremos los grupos a los que pertenece:

<syntaxhighlight lang="bash">
sudo useradd -m practica
sudo usermod -G invitado practica
groups practica
</syntaxhighlight>

Veremos que el usuario práctica pertenece al grupo invitado.

== delgroup y groupdel ==

Ambos sirven para eliminar un grupo. Vamos a eliminar el grupo que hemos creado
anteriormente:

<syntaxhighlight lang="bash">
sudo groupdel invitado
</syntaxhighlight>

Podemos observar ahora que el usuario practica no pertenece al grupo invitado:

<syntaxhighlight lang="bash">
groups practica
</syntaxhighlight>

= Paso 5: Permisos =

== Nomenclatura rwx y numérica ==

Si hacemos un ls -l, la primera cadena que nos aparece son los permisos del
fichero (-rwxrw-r--), podemos dividirlo en 4 elementos:

- (rwx) (rw-) (r--)
| | | |
type owner group others

* type: el tipo de fichero, pudiendo ser d (directorio), l (enlace simbólico), - (fichero normal)
* owner: permisos de propietario
* group: permisos de grupo
* others: permisos para los demás usuarios

Significado de los permisos:

* r: permisos de lectura
* w: permisos de escritura
* x: permisos de ejecución

Por último, existe un modo abreviado para estos permisos que se utiliza con
números.

rwx
001 en binario es 1 en decimal. Permisos de ejecución
010 en binario es 2 en decimal. Permisos de escritura
100 en binario es 4 en decimal. Permisos de lectura

La suma de los permisos, nos da el valor numérico. Veamos un ejemplo:
rwx rw- r--
111 110 100
7 6 4

== chmod ==

Permite cambiar los permisos de acceso a un fichero o directorio. Podemos dar
permisos de dos formas diferentes.

=== modo carácter ===

Veamos primero unos detalles:

Clases de usuario:

* owner (u)
* group (g)
* others (o)
* all (a)

Modificador:

* añadir (+)
* eliminar (-)
* sobrescribir (=)

Para dar permisos tendríamos que seleccionar la clase de usuario el modificador
y los permisos, veamos un ejemplo:

<syntaxhighlight lang="bash">
chmod u+x file # añadimos permisos de ejecución al usuario
chmod go-w file # quitamos permisos de escritura al grupo y a otros usuarios
chmod u=rwx,go=r file # Al usuario le damos todos los permisos, y al grupo y otros solo le damos permisos de lectura
</syntaxhighlight>

=== Modo octal ===

Con el modo octacl, es como si siempre utilizáramos el modificar sobrescribir,
pongamos algunos ejemplos:

<syntaxhighlight lang="bash">
chmod 744 file # Al usuario le damos todos los permisos, y al grupo y otros solo le damos permisos de lectura
chmod 777 file # Todos tienen permisos para todo
chmod 600 file # solo el propietario tiene permisos de lectura y escritura
</syntaxhighlight>

=== Ejemplos ===

Vamos a ver como funciona el tema de permisos con unos ejemplos. Vamos a crear
un fichero pruebas y le vamos a quitar los permisos de escritura a nuestro
usuario, y le vamos a dar permisos de escritura a otros:

<syntaxhighlight lang="bash">
touch pruebas
ls -l pruebas # de esta forma veremos que por defecto los permisos son rw-rw-r--
chmod u-w,o+w pruebas
ls -l pruebas # ahora los permisos deberían ser -w-rw-rw-
</syntaxhighlight>

Una vez dado los permisos, veamos que con nuestro usuario podemos leer pero no
escribir:

<syntaxhighlight lang="bash">
cat pruebas
echo "probando" > pruebas
exit
</syntaxhighlight>

Y ahora vamos a ver que el usuario pruebas, puede leer y escribir:

<syntaxhighlight lang="bash">
su practica
cat pruebas
echo "probando" > pruebas
</syntaxhighlight>

== chown ==

Permite cambiar el propietario de un fichero o directorio.

Vamos por ejemplo a pasarle ahora el fichero pruebas al usuario practica:

<syntaxhighlight lang="bash">
sudo chown practica pruebas
ls -l pruebas
</syntaxhighlight>

Veremos que el usuario actual ahora es pruebas, aunque vemos que el ls muestra
lo siguiente:

<syntaxhighlight lang="bash">
-r--rw-rw- 1 practica ubuntu 9 Aug 29 09:34 pruebas
</syntaxhighlight>

Hay que comentar un detalle, y es que los ficheros y directorios tienen asignado
un usuario y un grupo, por defecto se utiliza el mismo usuario como grupo
cuando creamos un nuevo fichero o directorio. Si queremos que cuando cambiemos
el propietario, cambiar tambien el grupo del fichero, podemos hacerlo de la
siguiente forma:

<syntaxhighlight lang="bash">
sudo chown practica:practica pruebas
</syntaxhighlight>

Una vez hecho esto, vamos ahora a probar que los permisos siguen funcionando
como antes, ahora con el usuario ubuntu, deberíamos de poder leer y escribir en
el fichero pruebas, y con el usuario practica, solo leer, esto es así por que
ahora el propitario es practica:

<syntaxhighlight lang="bash">
# Pruebas usuario ubuntu
cat pruebas
echo test >> pruebas
# Pruebas usuario practica
su practica
cat pruebas
echo "probando" > pruebas
exit
</syntaxhighlight>

= Paso 6: Procesos =

== ps ==

Sirve para ver que procesos están ejecutándose en el sistema, veamos un ejemplo:

<syntaxhighlight lang="bash">
ps aux # con la opción aux mostraremos todos los procesos del sistema
</syntaxhighlight>

Cada línea es un proceso, y cada proceso muestra su PID, usuario, cantidad de
memoria y cpu utilizada, comando y otros detalles.

<syntaxhighlight lang="bash">
man kill & # añadir el & al final de un comando hace que este se ejecute en segundo plano, por lo que se quedará abierto
</syntaxhighlight>

La salida de este comando nos mostrará el PID que tiene ese proceso que acabamos
de ejecutar, vamos a comprobarlo:

<syntaxhighlight lang="bash">
ps aux | grep "man kill"
</syntaxhighlight>

Veremos que el PID coincide.

== kill ==

Este comando nos servirá para matar un proceso. kill se utiliza seguido de una
señal para enviar al proceso seguido de uno o varios PID. para ver las señales
disponibles, podemos listarlas:

<syntaxhighlight lang="bash">
kill -l
</syntaxhighlight>

Las más utilizadas suele ser SIGTERM y SIGKILL, la primera intenta terminar el
proceso de forma poco abrupta, y la segunda suele utilizarse cuando el proceso
no atiende a esta primera señal. Vamos ahora a terminar el proceso que creamos
antes, si no recordamos el PID, busquémoslo de nuevo:

<syntaxhighlight lang="bash">
ps aux | grep "man kill"
</syntaxhighlight>

Enviamos señal para terminar el proceso y comprobamos que ha terminado:

<syntaxhighlight lang="bash">
kill -SIGTERM 8470
ps aux | grep "man kill"
</syntaxhighlight>

También podemos notar que en el listado de señales, hay unos números, podemos
utilizar esos números en vez de las palabras, por ejemplo:

<syntaxhighlight lang="bash">
man kill &
kill -15 PID_COMANDO_PREVIO
</syntaxhighlight>

Comprobamos que el proceso ha terminado correctamente:

<syntaxhighlight lang="bash">
ps aux | grep "man kill"
</syntaxhighlight>

= Paso 7: Estado CPU, RAM y Disco =

== top ==

Este comando nos servirá para ver el listado de procesos y el estado de la CPU y
memoria.

Probemos el comando y observemos detalladamente la salida:

<syntaxhighlight lang="bash">
top
</syntaxhighlight>

Para salir, pulsamos q.

== df y du ==

df (disk free) y du (disk usage). Ambas son utilidades para mostrar el uso de
los discos.

Con df mostraremos la información del espacio en cada dispositivo montado:

<syntaxhighlight lang="bash">
df
</syntaxhighlight>

Estos comandos que nos muestran el tamaño de los ficheros, casi siempre tienen
una opción para mostrarlo en un formato más legible (-h)

<syntaxhighlight lang="bash">
df -h
</syntaxhighlight>

Mucho mejor.

Ahora veamos el comando du, el cual nos mostrará el tamaño de un fichero o
directorio y sus subdirectorios, no olvidemos el -h:

<syntaxhighlight lang="bash">
du -h /home/ubuntu
du -h /home/ubuntu/pruebas
</syntaxhighlight>

Si solo quisíeramos saber el total de una carpeta y nos nos interesan sus
subcarpetas, podemos utilizar la opción -s:

<syntaxhighlight lang="bash">
du -sh /home/ubuntu
</syntaxhighlight>

== free ==

Sirve para ver el estado de la memoria, como siempre, opción -h:

<syntaxhighlight lang="bash">
free -h
</syntaxhighlight>

== lsblk ==

Nos muestra la información de todos los dispositivos de bloques (discos duros,
pendrivers, CD_ROM, SSD, ...).

<syntaxhighlight lang="bash">
lsblk
</syntaxhighlight>

En la siguiente práctica se utilizará más a fondo este comando, ya que
trabajaremos con dispositivos.

= Paso 8: Gestión de paquetes de software y repositorios =

Los sistemas Linux incluyen, además de las herramientas básicas del sistema operativo, repositorios de software que puede ser opcionalmente instalados por el administrador del sistema. Los fabricantes de las distribuciones de Linux incluyen paquetes de software listos para ser instalados que se integran con el sistema.

Un paquete incluye el software necesario para que una cierta aplicación funcione correctamente, así como sus paquetes de dependencia.

En Ubuntu, la herramienta de gestión de paquetes de software y repositorios se llama '''apt'''.

=== Listado de repositorios de paquetes de software ===

En Ubuntu el listado de repositorios se encuentra en el fichero /etc/apt/sources.list. Podemos comprobar que repositorios tenemos añadido:

<syntaxhighlight lang="bash">
cat /etc/apt/sources.list
</syntaxhighlight>

=== Actualización del listado de paquetes de software ===

Para actualizar el listado de paquetes utilizaremos el comando:

<syntaxhighlight lang="bash">
sudo apt update
</syntaxhighlight>

=== Instalación un nuevo paquete ===

Para instalar un nuevo paquete, utilizaremos la orden install, por ejemplo, vamos a instalar tree, similar al ls pero muestra el arbol de directorios:

<syntaxhighlight lang="bash">
sudo apt install tree
</syntaxhighlight>

=== Desinstalación de un paquete ===

Usaremos la orden purge o la orden remove, purge nos lo eliminad todo, y remove mantiene la configuración en el caso de que el paquete la tuviese. Vamos a eliminar el paquete instalado previamente:

<syntaxhighlight lang="bash">
sudo apt purge tree
</syntaxhighlight>

= Paso 9: Administración remota con ssh =

''ssh'' (Secure SHell) permite administrar de manera remota un sistema desde el intérprete de órdenes. Para poder acceder a la máquina virtual por medio de ''[[ssh]]'', hay que instalar el paquete ''openssh-server''.

sudo apt-get install openssh-server

Una vez instalado, tenemos que consultar la dirección IP de la máquina virtual

ip address

Desde el hipervisor podemos acceder por ''ssh'' a la máquina virtual con la orden:

ssh usuario@ip

Siendo ''usuario'' el nombre de usuario con el que accedes a la máquina virtual y la dirección ''ip'' que nos muestra la orden ''ip address''.

Por ejemplo, si el usuario seleccionado es ''ubuntu'' y la IP es 192.168.122.123, entonces la invocación a ''ssh'' es la siguiente:

ssh ubuntu@192.168.122.123

En caso de que en la maquina virtual no esté instalado openssh-server, puede que la conexión sea rechazada:
ssh: connect to host 192.168.122.123 port 22: Connection refused

Para resolver el problema es necesario instalar OpenSSH client en la maquina virtual

sudo apt install openssh-client

Y a continuación se instala OpenSSH server

sudo apt install openssh-server

= Paso 10: Módulos =

Los módulos del kernel de Linux son partes que podemos añadir o quitar de forma
sencilla con el fin de añadir o quitar funcionalidad. Por ejemplo, algunas de
estas funcionalidades son:

* Registrar temperaturas de nuestros componentes
* Hacer funcionr la tarjeta de red wifi
* Cargar los drivers de una tarjeta gráfica

== lsmod ==

Comando para ver los módulos que estamos usando:

<syntaxhighlight lang="bash">
lsmod
</syntaxhighlight>

== lspci y usb-devices ==

Estos comandos nos servirán para ver el hardware que está conectado a nuestro
ordenador. Con lspci veremos el listado del hardware integrado y con usb-devices
el que está conectado por hardware.

Normalmente, como los módulos se utilizan para dar funcionalidad un hardware,
aquí en los listado de hardware podremos ver que módulo está utilizando cada
hardware:

<syntaxhighlight lang="bash">
lspci -v
</syntaxhighlight>

Veremos una línea en algunos dispositivos que nos diga que módulo estamos
usando, pongo un pequeño trozo de la salida del comando:

<syntaxhighlight lang="bash">
00:1f.2 SATA controller: Intel Corporation 82801IR/IO/IH (ICH9R/DO/DH) 6 port SATA Controller [AHCI mode] (rev 02) (prog-if 01 [AHCI 1.0])
Subsystem: Red Hat, Inc. QEMU Virtual Machine
Flags: bus master, fast devsel, latency 0, IRQ 35
I/O ports at c0c0 [size=32]
Memory at fcc1d000 (32-bit, non-prefetchable) [size=4K]
Capabilities: <access denied>
Kernel driver in use: ahci
Kernel modules: ahci
</syntaxhighlight>

Vemos que el hardware INTEl Corporation está utilizando el módulo ahci.

Probemos ahora con usb-devices:

<syntaxhighlight lang="bash">
usb-devices
</syntaxhighlight>

Veamos un trozo de código:

<syntaxhighlight lang="bash">
T: Bus=01 Lev=01 Prnt=01 Port=00 Cnt=01 Dev#= 2 Spd=480 MxCh= 0
D: Ver= 2.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs= 1
P: Vendor=0627 ProdID=0001 Rev=00.00
S: Manufacturer=QEMU
S: Product=QEMU USB Tablet
S: SerialNumber=42
C: #Ifs= 1 Cfg#= 1 Atr=a0 MxPwr=100mA
I: If#= 0 Alt= 0 #EPs= 1 Cls=03(HID ) Sub=00 Prot=00 Driver=usbhid
</syntaxhighlight>

Vemos que el teclado está utilizando el módulo usbhid

== insmod ==

Sirve para cargar un módulo en el kernel, imaginemos que tenemos un módulo que
se llama modulo1:

<syntaxhighlight lang="bash">
sudo insmod modulo1
</syntaxhighlight>

== rmmod ==

Sirve para eliminar un módulo de kernel. Imaginemos que queremos borrar un
módulo cargado anteriormente con el nombre modulo1:

<syntaxhighlight lang="bash">
sudo rmmod modulo1
</syntaxhighlight>

= Ejercicios =

# Cree un fichero vacio llamado 123.txt
# Añada al fichero las siguientes tres lineas:

Hola mundo
Probando 1 2 3
Adios

# Añada una linea más al fichero con el siguiente contenido:

Prueba

# Renombre el fichero 123.txt a 456.txt
# Haga una copia del fichero 456.txt al fichero 789.txt
# Cree la carpeta xyz
# Mueva el fichero 789.txt a la carpeta xyz
# Mueva el fichero 456.txt al temporal
# Borre el fichero 456.txt
# Compruebe si el fichero 789.txt contiene la palabra “mundo”
# Borre la carpeta xyz y su contenido
# Liste el contenido de la carpeta temporal mostrando los permisos asociados a los ficheros y carpetas, almacene el resultado en el fichero temporal.txt
# Cree la carpeta ‘x’ y dentro de ella, la carpeta ‘y’
# Mueva el fichero temporal.txt dentro de la carpeta ‘y’
# Cuente el número de ficheros y directorios en la carpeta tmp